code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
/*
* Galois/Counter Mode (GCM) and GMAC with AES
*
* Copyright (c) 2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "aes.h"
#include "aes_wrap.h"
static void inc32(u8 *block)
{
u32 val;
val = WPA_GET_BE32(block + AES_BLOCK_SIZE - 4);
val++;
WPA_PUT_BE32(block + AES_BLOCK_SIZE - 4, val);
}
static void xor_block(u8 *dst, const u8 *src)
{
u32 *d = (u32 *) dst;
u32 *s = (u32 *) src;
*d++ ^= *s++;
*d++ ^= *s++;
*d++ ^= *s++;
*d++ ^= *s++;
}
static void shift_right_block(u8 *v)
{
u32 val;
val = WPA_GET_BE32(v + 12);
val >>= 1;
if (v[11] & 0x01)
val |= 0x80000000;
WPA_PUT_BE32(v + 12, val);
val = WPA_GET_BE32(v + 8);
val >>= 1;
if (v[7] & 0x01)
val |= 0x80000000;
WPA_PUT_BE32(v + 8, val);
val = WPA_GET_BE32(v + 4);
val >>= 1;
if (v[3] & 0x01)
val |= 0x80000000;
WPA_PUT_BE32(v + 4, val);
val = WPA_GET_BE32(v);
val >>= 1;
WPA_PUT_BE32(v, val);
}
/* Multiplication in GF(2^128) */
static void gf_mult(const u8 *x, const u8 *y, u8 *z)
{
u8 v[16];
int i, j;
os_memset(z, 0, 16); /* Z_0 = 0^128 */
os_memcpy(v, y, 16); /* V_0 = Y */
for (i = 0; i < 16; i++) {
for (j = 0; j < 8; j++) {
if (x[i] & BIT(7 - j)) {
/* Z_(i + 1) = Z_i XOR V_i */
xor_block(z, v);
} else {
/* Z_(i + 1) = Z_i */
}
if (v[15] & 0x01) {
/* V_(i + 1) = (V_i >> 1) XOR R */
shift_right_block(v);
/* R = 11100001 || 0^120 */
v[0] ^= 0xe1;
} else {
/* V_(i + 1) = V_i >> 1 */
shift_right_block(v);
}
}
}
}
static void ghash_start(u8 *y)
{
/* Y_0 = 0^128 */
os_memset(y, 0, 16);
}
static void ghash(const u8 *h, const u8 *x, size_t xlen, u8 *y)
{
size_t m, i;
const u8 *xpos = x;
u8 tmp[16];
m = xlen / 16;
for (i = 0; i < m; i++) {
/* Y_i = (Y^(i-1) XOR X_i) dot H */
xor_block(y, xpos);
xpos += 16;
/* dot operation:
* multiplication operation for binary Galois (finite) field of
* 2^128 elements */
gf_mult(y, h, tmp);
os_memcpy(y, tmp, 16);
}
if (x + xlen > xpos) {
/* Add zero padded last block */
size_t last = x + xlen - xpos;
os_memcpy(tmp, xpos, last);
os_memset(tmp + last, 0, sizeof(tmp) - last);
/* Y_i = (Y^(i-1) XOR X_i) dot H */
xor_block(y, tmp);
/* dot operation:
* multiplication operation for binary Galois (finite) field of
* 2^128 elements */
gf_mult(y, h, tmp);
os_memcpy(y, tmp, 16);
}
/* Return Y_m */
}
static void aes_gctr(void *aes, const u8 *icb, const u8 *x, size_t xlen, u8 *y)
{
size_t i, n, last;
u8 cb[AES_BLOCK_SIZE], tmp[AES_BLOCK_SIZE];
const u8 *xpos = x;
u8 *ypos = y;
if (xlen == 0)
return;
n = xlen / 16;
os_memcpy(cb, icb, AES_BLOCK_SIZE);
/* Full blocks */
for (i = 0; i < n; i++) {
aes_encrypt(aes, cb, ypos);
xor_block(ypos, xpos);
xpos += AES_BLOCK_SIZE;
ypos += AES_BLOCK_SIZE;
inc32(cb);
}
last = x + xlen - xpos;
if (last) {
/* Last, partial block */
aes_encrypt(aes, cb, tmp);
for (i = 0; i < last; i++)
*ypos++ = *xpos++ ^ tmp[i];
}
}
static void * aes_gcm_init_hash_subkey(const u8 *key, size_t key_len, u8 *H)
{
void *aes;
aes = aes_encrypt_init(key, key_len);
if (aes == NULL)
return NULL;
/* Generate hash subkey H = AES_K(0^128) */
os_memset(H, 0, AES_BLOCK_SIZE);
aes_encrypt(aes, H, H);
wpa_hexdump_key(_MSG_EXCESSIVE_, "Hash subkey H for GHASH",
H, AES_BLOCK_SIZE);
return aes;
}
static void aes_gcm_prepare_j0(const u8 *iv, size_t iv_len, const u8 *H, u8 *J0)
{
u8 len_buf[16];
if (iv_len == 12) {
/* Prepare block J_0 = IV || 0^31 || 1 [len(IV) = 96] */
os_memcpy(J0, iv, iv_len);
os_memset(J0 + iv_len, 0, AES_BLOCK_SIZE - iv_len);
J0[AES_BLOCK_SIZE - 1] = 0x01;
} else {
/*
* s = 128 * ceil(len(IV)/128) - len(IV)
* J_0 = GHASH_H(IV || 0^(s+64) || [len(IV)]_64)
*/
ghash_start(J0);
ghash(H, iv, iv_len, J0);
WPA_PUT_BE64(len_buf, 0);
WPA_PUT_BE64(len_buf + 8, iv_len * 8);
ghash(H, len_buf, sizeof(len_buf), J0);
}
}
static void aes_gcm_gctr(void *aes, const u8 *J0, const u8 *in, size_t len,
u8 *out)
{
u8 J0inc[AES_BLOCK_SIZE];
if (len == 0)
return;
os_memcpy(J0inc, J0, AES_BLOCK_SIZE);
inc32(J0inc);
aes_gctr(aes, J0inc, in, len, out);
}
static void aes_gcm_ghash(const u8 *H, const u8 *aad, size_t aad_len,
const u8 *crypt, size_t crypt_len, u8 *S)
{
u8 len_buf[16];
/*
* u = 128 * ceil[len(C)/128] - len(C)
* v = 128 * ceil[len(A)/128] - len(A)
* S = GHASH_H(A || 0^v || C || 0^u || [len(A)]64 || [len(C)]64)
* (i.e., zero padded to block size A || C and lengths of each in bits)
*/
ghash_start(S);
ghash(H, aad, aad_len, S);
ghash(H, crypt, crypt_len, S);
WPA_PUT_BE64(len_buf, aad_len * 8);
WPA_PUT_BE64(len_buf + 8, crypt_len * 8);
ghash(H, len_buf, sizeof(len_buf), S);
wpa_hexdump_key(_MSG_EXCESSIVE_, "S = GHASH_H(...)", S, 16);
}
/**
* aes_gcm_ae - GCM-AE_K(IV, P, A)
*/
int aes_gcm_ae(const u8 *key, size_t key_len, const u8 *iv, size_t iv_len,
const u8 *plain, size_t plain_len,
const u8 *aad, size_t aad_len, u8 *crypt, u8 *tag)
{
u8 H[AES_BLOCK_SIZE];
u8 J0[AES_BLOCK_SIZE];
u8 S[16];
void *aes;
aes = aes_gcm_init_hash_subkey(key, key_len, H);
if (aes == NULL)
return -1;
aes_gcm_prepare_j0(iv, iv_len, H, J0);
/* C = GCTR_K(inc_32(J_0), P) */
aes_gcm_gctr(aes, J0, plain, plain_len, crypt);
aes_gcm_ghash(H, aad, aad_len, crypt, plain_len, S);
/* T = MSB_t(GCTR_K(J_0, S)) */
aes_gctr(aes, J0, S, sizeof(S), tag);
/* Return (C, T) */
aes_encrypt_deinit(aes);
return 0;
}
/**
* aes_gcm_ad - GCM-AD_K(IV, C, A, T)
*/
int aes_gcm_ad(const u8 *key, size_t key_len, const u8 *iv, size_t iv_len,
const u8 *crypt, size_t crypt_len,
const u8 *aad, size_t aad_len, const u8 *tag, u8 *plain)
{
u8 H[AES_BLOCK_SIZE];
u8 J0[AES_BLOCK_SIZE];
u8 S[16], T[16];
void *aes;
aes = aes_gcm_init_hash_subkey(key, key_len, H);
if (aes == NULL)
return -1;
aes_gcm_prepare_j0(iv, iv_len, H, J0);
/* P = GCTR_K(inc_32(J_0), C) */
aes_gcm_gctr(aes, J0, crypt, crypt_len, plain);
aes_gcm_ghash(H, aad, aad_len, crypt, crypt_len, S);
/* T' = MSB_t(GCTR_K(J_0, S)) */
aes_gctr(aes, J0, S, sizeof(S), T);
aes_encrypt_deinit(aes);
if (os_memcmp_const(tag, T, 16) != 0) {
wpa_printf(_MSG_EXCESSIVE_, "GCM: Tag mismatch");
return -1;
}
return 0;
}
int aes_gmac(const u8 *key, size_t key_len, const u8 *iv, size_t iv_len,
const u8 *aad, size_t aad_len, u8 *tag)
{
return aes_gcm_ae(key, key_len, iv, iv_len, NULL, 0, aad, aad_len, NULL,
tag);
}
|
2301_81045437/rtl8852be
|
core/crypto/aes-gcm.c
|
C
|
agpl-3.0
| 6,615
|
/*
* AES (Rijndael) cipher - encrypt
*
* Modifications to public domain implementation:
* - cleanup
* - use C pre-processor to make it easier to change S table access
* - added option (AES_SMALL_TABLES) for reducing code size by about 8 kB at
* cost of reduced throughput (quite small difference on Pentium 4,
* 10-25% when using -O1 or -O2 optimization)
*
* Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "aes_i.h"
static void rijndaelEncrypt(const u32 rk[], int Nr, const u8 pt[16], u8 ct[16])
{
u32 s0, s1, s2, s3, t0, t1, t2, t3;
#ifndef FULL_UNROLL
int r;
#endif /* ?FULL_UNROLL */
/*
* map byte array block to cipher state
* and add initial round key:
*/
s0 = GETU32(pt ) ^ rk[0];
s1 = GETU32(pt + 4) ^ rk[1];
s2 = GETU32(pt + 8) ^ rk[2];
s3 = GETU32(pt + 12) ^ rk[3];
#define ROUND(i,d,s) \
d##0 = TE0(s##0) ^ TE1(s##1) ^ TE2(s##2) ^ TE3(s##3) ^ rk[4 * i]; \
d##1 = TE0(s##1) ^ TE1(s##2) ^ TE2(s##3) ^ TE3(s##0) ^ rk[4 * i + 1]; \
d##2 = TE0(s##2) ^ TE1(s##3) ^ TE2(s##0) ^ TE3(s##1) ^ rk[4 * i + 2]; \
d##3 = TE0(s##3) ^ TE1(s##0) ^ TE2(s##1) ^ TE3(s##2) ^ rk[4 * i + 3]
#ifdef FULL_UNROLL
ROUND(1,t,s);
ROUND(2,s,t);
ROUND(3,t,s);
ROUND(4,s,t);
ROUND(5,t,s);
ROUND(6,s,t);
ROUND(7,t,s);
ROUND(8,s,t);
ROUND(9,t,s);
if (Nr > 10) {
ROUND(10,s,t);
ROUND(11,t,s);
if (Nr > 12) {
ROUND(12,s,t);
ROUND(13,t,s);
}
}
rk += Nr << 2;
#else /* !FULL_UNROLL */
/* Nr - 1 full rounds: */
r = Nr >> 1;
for (;;) {
ROUND(1,t,s);
rk += 8;
if (--r == 0)
break;
ROUND(0,s,t);
}
#endif /* ?FULL_UNROLL */
#undef ROUND
/*
* apply last round and
* map cipher state to byte array block:
*/
s0 = TE41(t0) ^ TE42(t1) ^ TE43(t2) ^ TE44(t3) ^ rk[0];
PUTU32(ct , s0);
s1 = TE41(t1) ^ TE42(t2) ^ TE43(t3) ^ TE44(t0) ^ rk[1];
PUTU32(ct + 4, s1);
s2 = TE41(t2) ^ TE42(t3) ^ TE43(t0) ^ TE44(t1) ^ rk[2];
PUTU32(ct + 8, s2);
s3 = TE41(t3) ^ TE42(t0) ^ TE43(t1) ^ TE44(t2) ^ rk[3];
PUTU32(ct + 12, s3);
}
void * aes_encrypt_init(const u8 *key, size_t len)
{
u32 *rk;
int res;
if (TEST_FAIL())
return NULL;
rk = os_malloc(AES_PRIV_SIZE);
if (rk == NULL)
return NULL;
res = rijndaelKeySetupEnc(rk, key, len * 8);
if (res < 0) {
rtw_mfree(rk, AES_PRIV_SIZE);
return NULL;
}
rk[AES_PRIV_NR_POS] = res;
return rk;
}
int aes_encrypt(void *ctx, const u8 *plain, u8 *crypt)
{
u32 *rk = ctx;
rijndaelEncrypt(ctx, rk[AES_PRIV_NR_POS], plain, crypt);
return 0;
}
void aes_encrypt_deinit(void *ctx)
{
os_memset(ctx, 0, AES_PRIV_SIZE);
rtw_mfree(ctx, AES_PRIV_SIZE);
}
|
2301_81045437/rtl8852be
|
core/crypto/aes-internal-enc.c
|
C
|
agpl-3.0
| 2,722
|
/*
* AES (Rijndael) cipher
*
* Modifications to public domain implementation:
* - cleanup
* - use C pre-processor to make it easier to change S table access
* - added option (AES_SMALL_TABLES) for reducing code size by about 8 kB at
* cost of reduced throughput (quite small difference on Pentium 4,
* 10-25% when using -O1 or -O2 optimization)
*
* Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "aes_i.h"
/*
* rijndael-alg-fst.c
*
* @version 3.0 (December 2000)
*
* Optimised ANSI C code for the Rijndael cipher (now AES)
*
* @author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>
* @author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>
* @author Paulo Barreto <paulo.barreto@terra.com.br>
*
* This code is hereby placed in the public domain.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
Te0[x] = S [x].[02, 01, 01, 03];
Te1[x] = S [x].[03, 02, 01, 01];
Te2[x] = S [x].[01, 03, 02, 01];
Te3[x] = S [x].[01, 01, 03, 02];
Te4[x] = S [x].[01, 01, 01, 01];
Td0[x] = Si[x].[0e, 09, 0d, 0b];
Td1[x] = Si[x].[0b, 0e, 09, 0d];
Td2[x] = Si[x].[0d, 0b, 0e, 09];
Td3[x] = Si[x].[09, 0d, 0b, 0e];
Td4[x] = Si[x].[01, 01, 01, 01];
*/
const u32 Te0[256] = {
0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,
0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,
0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,
0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,
0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,
0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,
0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,
0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,
0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,
0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,
0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,
0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,
0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,
0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,
0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,
0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,
0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,
0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,
0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,
0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,
0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,
0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,
0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,
0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,
0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,
0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,
0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,
0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,
0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,
0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,
0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,
0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,
0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,
0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,
0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,
0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,
0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,
0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,
0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,
0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,
0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,
0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,
0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,
0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,
0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,
0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,
0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,
0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,
0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,
0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,
0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,
0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,
0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,
0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,
0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,
0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,
0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,
0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,
0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,
0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,
0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,
0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,
0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,
0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,
};
#ifndef AES_SMALL_TABLES
const u32 Te1[256] = {
0xa5c66363U, 0x84f87c7cU, 0x99ee7777U, 0x8df67b7bU,
0x0dfff2f2U, 0xbdd66b6bU, 0xb1de6f6fU, 0x5491c5c5U,
0x50603030U, 0x03020101U, 0xa9ce6767U, 0x7d562b2bU,
0x19e7fefeU, 0x62b5d7d7U, 0xe64dababU, 0x9aec7676U,
0x458fcacaU, 0x9d1f8282U, 0x4089c9c9U, 0x87fa7d7dU,
0x15effafaU, 0xebb25959U, 0xc98e4747U, 0x0bfbf0f0U,
0xec41adadU, 0x67b3d4d4U, 0xfd5fa2a2U, 0xea45afafU,
0xbf239c9cU, 0xf753a4a4U, 0x96e47272U, 0x5b9bc0c0U,
0xc275b7b7U, 0x1ce1fdfdU, 0xae3d9393U, 0x6a4c2626U,
0x5a6c3636U, 0x417e3f3fU, 0x02f5f7f7U, 0x4f83ccccU,
0x5c683434U, 0xf451a5a5U, 0x34d1e5e5U, 0x08f9f1f1U,
0x93e27171U, 0x73abd8d8U, 0x53623131U, 0x3f2a1515U,
0x0c080404U, 0x5295c7c7U, 0x65462323U, 0x5e9dc3c3U,
0x28301818U, 0xa1379696U, 0x0f0a0505U, 0xb52f9a9aU,
0x090e0707U, 0x36241212U, 0x9b1b8080U, 0x3ddfe2e2U,
0x26cdebebU, 0x694e2727U, 0xcd7fb2b2U, 0x9fea7575U,
0x1b120909U, 0x9e1d8383U, 0x74582c2cU, 0x2e341a1aU,
0x2d361b1bU, 0xb2dc6e6eU, 0xeeb45a5aU, 0xfb5ba0a0U,
0xf6a45252U, 0x4d763b3bU, 0x61b7d6d6U, 0xce7db3b3U,
0x7b522929U, 0x3edde3e3U, 0x715e2f2fU, 0x97138484U,
0xf5a65353U, 0x68b9d1d1U, 0x00000000U, 0x2cc1ededU,
0x60402020U, 0x1fe3fcfcU, 0xc879b1b1U, 0xedb65b5bU,
0xbed46a6aU, 0x468dcbcbU, 0xd967bebeU, 0x4b723939U,
0xde944a4aU, 0xd4984c4cU, 0xe8b05858U, 0x4a85cfcfU,
0x6bbbd0d0U, 0x2ac5efefU, 0xe54faaaaU, 0x16edfbfbU,
0xc5864343U, 0xd79a4d4dU, 0x55663333U, 0x94118585U,
0xcf8a4545U, 0x10e9f9f9U, 0x06040202U, 0x81fe7f7fU,
0xf0a05050U, 0x44783c3cU, 0xba259f9fU, 0xe34ba8a8U,
0xf3a25151U, 0xfe5da3a3U, 0xc0804040U, 0x8a058f8fU,
0xad3f9292U, 0xbc219d9dU, 0x48703838U, 0x04f1f5f5U,
0xdf63bcbcU, 0xc177b6b6U, 0x75afdadaU, 0x63422121U,
0x30201010U, 0x1ae5ffffU, 0x0efdf3f3U, 0x6dbfd2d2U,
0x4c81cdcdU, 0x14180c0cU, 0x35261313U, 0x2fc3ececU,
0xe1be5f5fU, 0xa2359797U, 0xcc884444U, 0x392e1717U,
0x5793c4c4U, 0xf255a7a7U, 0x82fc7e7eU, 0x477a3d3dU,
0xacc86464U, 0xe7ba5d5dU, 0x2b321919U, 0x95e67373U,
0xa0c06060U, 0x98198181U, 0xd19e4f4fU, 0x7fa3dcdcU,
0x66442222U, 0x7e542a2aU, 0xab3b9090U, 0x830b8888U,
0xca8c4646U, 0x29c7eeeeU, 0xd36bb8b8U, 0x3c281414U,
0x79a7dedeU, 0xe2bc5e5eU, 0x1d160b0bU, 0x76addbdbU,
0x3bdbe0e0U, 0x56643232U, 0x4e743a3aU, 0x1e140a0aU,
0xdb924949U, 0x0a0c0606U, 0x6c482424U, 0xe4b85c5cU,
0x5d9fc2c2U, 0x6ebdd3d3U, 0xef43acacU, 0xa6c46262U,
0xa8399191U, 0xa4319595U, 0x37d3e4e4U, 0x8bf27979U,
0x32d5e7e7U, 0x438bc8c8U, 0x596e3737U, 0xb7da6d6dU,
0x8c018d8dU, 0x64b1d5d5U, 0xd29c4e4eU, 0xe049a9a9U,
0xb4d86c6cU, 0xfaac5656U, 0x07f3f4f4U, 0x25cfeaeaU,
0xafca6565U, 0x8ef47a7aU, 0xe947aeaeU, 0x18100808U,
0xd56fbabaU, 0x88f07878U, 0x6f4a2525U, 0x725c2e2eU,
0x24381c1cU, 0xf157a6a6U, 0xc773b4b4U, 0x5197c6c6U,
0x23cbe8e8U, 0x7ca1ddddU, 0x9ce87474U, 0x213e1f1fU,
0xdd964b4bU, 0xdc61bdbdU, 0x860d8b8bU, 0x850f8a8aU,
0x90e07070U, 0x427c3e3eU, 0xc471b5b5U, 0xaacc6666U,
0xd8904848U, 0x05060303U, 0x01f7f6f6U, 0x121c0e0eU,
0xa3c26161U, 0x5f6a3535U, 0xf9ae5757U, 0xd069b9b9U,
0x91178686U, 0x5899c1c1U, 0x273a1d1dU, 0xb9279e9eU,
0x38d9e1e1U, 0x13ebf8f8U, 0xb32b9898U, 0x33221111U,
0xbbd26969U, 0x70a9d9d9U, 0x89078e8eU, 0xa7339494U,
0xb62d9b9bU, 0x223c1e1eU, 0x92158787U, 0x20c9e9e9U,
0x4987ceceU, 0xffaa5555U, 0x78502828U, 0x7aa5dfdfU,
0x8f038c8cU, 0xf859a1a1U, 0x80098989U, 0x171a0d0dU,
0xda65bfbfU, 0x31d7e6e6U, 0xc6844242U, 0xb8d06868U,
0xc3824141U, 0xb0299999U, 0x775a2d2dU, 0x111e0f0fU,
0xcb7bb0b0U, 0xfca85454U, 0xd66dbbbbU, 0x3a2c1616U,
};
const u32 Te2[256] = {
0x63a5c663U, 0x7c84f87cU, 0x7799ee77U, 0x7b8df67bU,
0xf20dfff2U, 0x6bbdd66bU, 0x6fb1de6fU, 0xc55491c5U,
0x30506030U, 0x01030201U, 0x67a9ce67U, 0x2b7d562bU,
0xfe19e7feU, 0xd762b5d7U, 0xabe64dabU, 0x769aec76U,
0xca458fcaU, 0x829d1f82U, 0xc94089c9U, 0x7d87fa7dU,
0xfa15effaU, 0x59ebb259U, 0x47c98e47U, 0xf00bfbf0U,
0xadec41adU, 0xd467b3d4U, 0xa2fd5fa2U, 0xafea45afU,
0x9cbf239cU, 0xa4f753a4U, 0x7296e472U, 0xc05b9bc0U,
0xb7c275b7U, 0xfd1ce1fdU, 0x93ae3d93U, 0x266a4c26U,
0x365a6c36U, 0x3f417e3fU, 0xf702f5f7U, 0xcc4f83ccU,
0x345c6834U, 0xa5f451a5U, 0xe534d1e5U, 0xf108f9f1U,
0x7193e271U, 0xd873abd8U, 0x31536231U, 0x153f2a15U,
0x040c0804U, 0xc75295c7U, 0x23654623U, 0xc35e9dc3U,
0x18283018U, 0x96a13796U, 0x050f0a05U, 0x9ab52f9aU,
0x07090e07U, 0x12362412U, 0x809b1b80U, 0xe23ddfe2U,
0xeb26cdebU, 0x27694e27U, 0xb2cd7fb2U, 0x759fea75U,
0x091b1209U, 0x839e1d83U, 0x2c74582cU, 0x1a2e341aU,
0x1b2d361bU, 0x6eb2dc6eU, 0x5aeeb45aU, 0xa0fb5ba0U,
0x52f6a452U, 0x3b4d763bU, 0xd661b7d6U, 0xb3ce7db3U,
0x297b5229U, 0xe33edde3U, 0x2f715e2fU, 0x84971384U,
0x53f5a653U, 0xd168b9d1U, 0x00000000U, 0xed2cc1edU,
0x20604020U, 0xfc1fe3fcU, 0xb1c879b1U, 0x5bedb65bU,
0x6abed46aU, 0xcb468dcbU, 0xbed967beU, 0x394b7239U,
0x4ade944aU, 0x4cd4984cU, 0x58e8b058U, 0xcf4a85cfU,
0xd06bbbd0U, 0xef2ac5efU, 0xaae54faaU, 0xfb16edfbU,
0x43c58643U, 0x4dd79a4dU, 0x33556633U, 0x85941185U,
0x45cf8a45U, 0xf910e9f9U, 0x02060402U, 0x7f81fe7fU,
0x50f0a050U, 0x3c44783cU, 0x9fba259fU, 0xa8e34ba8U,
0x51f3a251U, 0xa3fe5da3U, 0x40c08040U, 0x8f8a058fU,
0x92ad3f92U, 0x9dbc219dU, 0x38487038U, 0xf504f1f5U,
0xbcdf63bcU, 0xb6c177b6U, 0xda75afdaU, 0x21634221U,
0x10302010U, 0xff1ae5ffU, 0xf30efdf3U, 0xd26dbfd2U,
0xcd4c81cdU, 0x0c14180cU, 0x13352613U, 0xec2fc3ecU,
0x5fe1be5fU, 0x97a23597U, 0x44cc8844U, 0x17392e17U,
0xc45793c4U, 0xa7f255a7U, 0x7e82fc7eU, 0x3d477a3dU,
0x64acc864U, 0x5de7ba5dU, 0x192b3219U, 0x7395e673U,
0x60a0c060U, 0x81981981U, 0x4fd19e4fU, 0xdc7fa3dcU,
0x22664422U, 0x2a7e542aU, 0x90ab3b90U, 0x88830b88U,
0x46ca8c46U, 0xee29c7eeU, 0xb8d36bb8U, 0x143c2814U,
0xde79a7deU, 0x5ee2bc5eU, 0x0b1d160bU, 0xdb76addbU,
0xe03bdbe0U, 0x32566432U, 0x3a4e743aU, 0x0a1e140aU,
0x49db9249U, 0x060a0c06U, 0x246c4824U, 0x5ce4b85cU,
0xc25d9fc2U, 0xd36ebdd3U, 0xacef43acU, 0x62a6c462U,
0x91a83991U, 0x95a43195U, 0xe437d3e4U, 0x798bf279U,
0xe732d5e7U, 0xc8438bc8U, 0x37596e37U, 0x6db7da6dU,
0x8d8c018dU, 0xd564b1d5U, 0x4ed29c4eU, 0xa9e049a9U,
0x6cb4d86cU, 0x56faac56U, 0xf407f3f4U, 0xea25cfeaU,
0x65afca65U, 0x7a8ef47aU, 0xaee947aeU, 0x08181008U,
0xbad56fbaU, 0x7888f078U, 0x256f4a25U, 0x2e725c2eU,
0x1c24381cU, 0xa6f157a6U, 0xb4c773b4U, 0xc65197c6U,
0xe823cbe8U, 0xdd7ca1ddU, 0x749ce874U, 0x1f213e1fU,
0x4bdd964bU, 0xbddc61bdU, 0x8b860d8bU, 0x8a850f8aU,
0x7090e070U, 0x3e427c3eU, 0xb5c471b5U, 0x66aacc66U,
0x48d89048U, 0x03050603U, 0xf601f7f6U, 0x0e121c0eU,
0x61a3c261U, 0x355f6a35U, 0x57f9ae57U, 0xb9d069b9U,
0x86911786U, 0xc15899c1U, 0x1d273a1dU, 0x9eb9279eU,
0xe138d9e1U, 0xf813ebf8U, 0x98b32b98U, 0x11332211U,
0x69bbd269U, 0xd970a9d9U, 0x8e89078eU, 0x94a73394U,
0x9bb62d9bU, 0x1e223c1eU, 0x87921587U, 0xe920c9e9U,
0xce4987ceU, 0x55ffaa55U, 0x28785028U, 0xdf7aa5dfU,
0x8c8f038cU, 0xa1f859a1U, 0x89800989U, 0x0d171a0dU,
0xbfda65bfU, 0xe631d7e6U, 0x42c68442U, 0x68b8d068U,
0x41c38241U, 0x99b02999U, 0x2d775a2dU, 0x0f111e0fU,
0xb0cb7bb0U, 0x54fca854U, 0xbbd66dbbU, 0x163a2c16U,
};
const u32 Te3[256] = {
0x6363a5c6U, 0x7c7c84f8U, 0x777799eeU, 0x7b7b8df6U,
0xf2f20dffU, 0x6b6bbdd6U, 0x6f6fb1deU, 0xc5c55491U,
0x30305060U, 0x01010302U, 0x6767a9ceU, 0x2b2b7d56U,
0xfefe19e7U, 0xd7d762b5U, 0xababe64dU, 0x76769aecU,
0xcaca458fU, 0x82829d1fU, 0xc9c94089U, 0x7d7d87faU,
0xfafa15efU, 0x5959ebb2U, 0x4747c98eU, 0xf0f00bfbU,
0xadadec41U, 0xd4d467b3U, 0xa2a2fd5fU, 0xafafea45U,
0x9c9cbf23U, 0xa4a4f753U, 0x727296e4U, 0xc0c05b9bU,
0xb7b7c275U, 0xfdfd1ce1U, 0x9393ae3dU, 0x26266a4cU,
0x36365a6cU, 0x3f3f417eU, 0xf7f702f5U, 0xcccc4f83U,
0x34345c68U, 0xa5a5f451U, 0xe5e534d1U, 0xf1f108f9U,
0x717193e2U, 0xd8d873abU, 0x31315362U, 0x15153f2aU,
0x04040c08U, 0xc7c75295U, 0x23236546U, 0xc3c35e9dU,
0x18182830U, 0x9696a137U, 0x05050f0aU, 0x9a9ab52fU,
0x0707090eU, 0x12123624U, 0x80809b1bU, 0xe2e23ddfU,
0xebeb26cdU, 0x2727694eU, 0xb2b2cd7fU, 0x75759feaU,
0x09091b12U, 0x83839e1dU, 0x2c2c7458U, 0x1a1a2e34U,
0x1b1b2d36U, 0x6e6eb2dcU, 0x5a5aeeb4U, 0xa0a0fb5bU,
0x5252f6a4U, 0x3b3b4d76U, 0xd6d661b7U, 0xb3b3ce7dU,
0x29297b52U, 0xe3e33eddU, 0x2f2f715eU, 0x84849713U,
0x5353f5a6U, 0xd1d168b9U, 0x00000000U, 0xeded2cc1U,
0x20206040U, 0xfcfc1fe3U, 0xb1b1c879U, 0x5b5bedb6U,
0x6a6abed4U, 0xcbcb468dU, 0xbebed967U, 0x39394b72U,
0x4a4ade94U, 0x4c4cd498U, 0x5858e8b0U, 0xcfcf4a85U,
0xd0d06bbbU, 0xefef2ac5U, 0xaaaae54fU, 0xfbfb16edU,
0x4343c586U, 0x4d4dd79aU, 0x33335566U, 0x85859411U,
0x4545cf8aU, 0xf9f910e9U, 0x02020604U, 0x7f7f81feU,
0x5050f0a0U, 0x3c3c4478U, 0x9f9fba25U, 0xa8a8e34bU,
0x5151f3a2U, 0xa3a3fe5dU, 0x4040c080U, 0x8f8f8a05U,
0x9292ad3fU, 0x9d9dbc21U, 0x38384870U, 0xf5f504f1U,
0xbcbcdf63U, 0xb6b6c177U, 0xdada75afU, 0x21216342U,
0x10103020U, 0xffff1ae5U, 0xf3f30efdU, 0xd2d26dbfU,
0xcdcd4c81U, 0x0c0c1418U, 0x13133526U, 0xecec2fc3U,
0x5f5fe1beU, 0x9797a235U, 0x4444cc88U, 0x1717392eU,
0xc4c45793U, 0xa7a7f255U, 0x7e7e82fcU, 0x3d3d477aU,
0x6464acc8U, 0x5d5de7baU, 0x19192b32U, 0x737395e6U,
0x6060a0c0U, 0x81819819U, 0x4f4fd19eU, 0xdcdc7fa3U,
0x22226644U, 0x2a2a7e54U, 0x9090ab3bU, 0x8888830bU,
0x4646ca8cU, 0xeeee29c7U, 0xb8b8d36bU, 0x14143c28U,
0xdede79a7U, 0x5e5ee2bcU, 0x0b0b1d16U, 0xdbdb76adU,
0xe0e03bdbU, 0x32325664U, 0x3a3a4e74U, 0x0a0a1e14U,
0x4949db92U, 0x06060a0cU, 0x24246c48U, 0x5c5ce4b8U,
0xc2c25d9fU, 0xd3d36ebdU, 0xacacef43U, 0x6262a6c4U,
0x9191a839U, 0x9595a431U, 0xe4e437d3U, 0x79798bf2U,
0xe7e732d5U, 0xc8c8438bU, 0x3737596eU, 0x6d6db7daU,
0x8d8d8c01U, 0xd5d564b1U, 0x4e4ed29cU, 0xa9a9e049U,
0x6c6cb4d8U, 0x5656faacU, 0xf4f407f3U, 0xeaea25cfU,
0x6565afcaU, 0x7a7a8ef4U, 0xaeaee947U, 0x08081810U,
0xbabad56fU, 0x787888f0U, 0x25256f4aU, 0x2e2e725cU,
0x1c1c2438U, 0xa6a6f157U, 0xb4b4c773U, 0xc6c65197U,
0xe8e823cbU, 0xdddd7ca1U, 0x74749ce8U, 0x1f1f213eU,
0x4b4bdd96U, 0xbdbddc61U, 0x8b8b860dU, 0x8a8a850fU,
0x707090e0U, 0x3e3e427cU, 0xb5b5c471U, 0x6666aaccU,
0x4848d890U, 0x03030506U, 0xf6f601f7U, 0x0e0e121cU,
0x6161a3c2U, 0x35355f6aU, 0x5757f9aeU, 0xb9b9d069U,
0x86869117U, 0xc1c15899U, 0x1d1d273aU, 0x9e9eb927U,
0xe1e138d9U, 0xf8f813ebU, 0x9898b32bU, 0x11113322U,
0x6969bbd2U, 0xd9d970a9U, 0x8e8e8907U, 0x9494a733U,
0x9b9bb62dU, 0x1e1e223cU, 0x87879215U, 0xe9e920c9U,
0xcece4987U, 0x5555ffaaU, 0x28287850U, 0xdfdf7aa5U,
0x8c8c8f03U, 0xa1a1f859U, 0x89898009U, 0x0d0d171aU,
0xbfbfda65U, 0xe6e631d7U, 0x4242c684U, 0x6868b8d0U,
0x4141c382U, 0x9999b029U, 0x2d2d775aU, 0x0f0f111eU,
0xb0b0cb7bU, 0x5454fca8U, 0xbbbbd66dU, 0x16163a2cU,
};
const u32 Te4[256] = {
0x63636363U, 0x7c7c7c7cU, 0x77777777U, 0x7b7b7b7bU,
0xf2f2f2f2U, 0x6b6b6b6bU, 0x6f6f6f6fU, 0xc5c5c5c5U,
0x30303030U, 0x01010101U, 0x67676767U, 0x2b2b2b2bU,
0xfefefefeU, 0xd7d7d7d7U, 0xababababU, 0x76767676U,
0xcacacacaU, 0x82828282U, 0xc9c9c9c9U, 0x7d7d7d7dU,
0xfafafafaU, 0x59595959U, 0x47474747U, 0xf0f0f0f0U,
0xadadadadU, 0xd4d4d4d4U, 0xa2a2a2a2U, 0xafafafafU,
0x9c9c9c9cU, 0xa4a4a4a4U, 0x72727272U, 0xc0c0c0c0U,
0xb7b7b7b7U, 0xfdfdfdfdU, 0x93939393U, 0x26262626U,
0x36363636U, 0x3f3f3f3fU, 0xf7f7f7f7U, 0xccccccccU,
0x34343434U, 0xa5a5a5a5U, 0xe5e5e5e5U, 0xf1f1f1f1U,
0x71717171U, 0xd8d8d8d8U, 0x31313131U, 0x15151515U,
0x04040404U, 0xc7c7c7c7U, 0x23232323U, 0xc3c3c3c3U,
0x18181818U, 0x96969696U, 0x05050505U, 0x9a9a9a9aU,
0x07070707U, 0x12121212U, 0x80808080U, 0xe2e2e2e2U,
0xebebebebU, 0x27272727U, 0xb2b2b2b2U, 0x75757575U,
0x09090909U, 0x83838383U, 0x2c2c2c2cU, 0x1a1a1a1aU,
0x1b1b1b1bU, 0x6e6e6e6eU, 0x5a5a5a5aU, 0xa0a0a0a0U,
0x52525252U, 0x3b3b3b3bU, 0xd6d6d6d6U, 0xb3b3b3b3U,
0x29292929U, 0xe3e3e3e3U, 0x2f2f2f2fU, 0x84848484U,
0x53535353U, 0xd1d1d1d1U, 0x00000000U, 0xededededU,
0x20202020U, 0xfcfcfcfcU, 0xb1b1b1b1U, 0x5b5b5b5bU,
0x6a6a6a6aU, 0xcbcbcbcbU, 0xbebebebeU, 0x39393939U,
0x4a4a4a4aU, 0x4c4c4c4cU, 0x58585858U, 0xcfcfcfcfU,
0xd0d0d0d0U, 0xefefefefU, 0xaaaaaaaaU, 0xfbfbfbfbU,
0x43434343U, 0x4d4d4d4dU, 0x33333333U, 0x85858585U,
0x45454545U, 0xf9f9f9f9U, 0x02020202U, 0x7f7f7f7fU,
0x50505050U, 0x3c3c3c3cU, 0x9f9f9f9fU, 0xa8a8a8a8U,
0x51515151U, 0xa3a3a3a3U, 0x40404040U, 0x8f8f8f8fU,
0x92929292U, 0x9d9d9d9dU, 0x38383838U, 0xf5f5f5f5U,
0xbcbcbcbcU, 0xb6b6b6b6U, 0xdadadadaU, 0x21212121U,
0x10101010U, 0xffffffffU, 0xf3f3f3f3U, 0xd2d2d2d2U,
0xcdcdcdcdU, 0x0c0c0c0cU, 0x13131313U, 0xececececU,
0x5f5f5f5fU, 0x97979797U, 0x44444444U, 0x17171717U,
0xc4c4c4c4U, 0xa7a7a7a7U, 0x7e7e7e7eU, 0x3d3d3d3dU,
0x64646464U, 0x5d5d5d5dU, 0x19191919U, 0x73737373U,
0x60606060U, 0x81818181U, 0x4f4f4f4fU, 0xdcdcdcdcU,
0x22222222U, 0x2a2a2a2aU, 0x90909090U, 0x88888888U,
0x46464646U, 0xeeeeeeeeU, 0xb8b8b8b8U, 0x14141414U,
0xdedededeU, 0x5e5e5e5eU, 0x0b0b0b0bU, 0xdbdbdbdbU,
0xe0e0e0e0U, 0x32323232U, 0x3a3a3a3aU, 0x0a0a0a0aU,
0x49494949U, 0x06060606U, 0x24242424U, 0x5c5c5c5cU,
0xc2c2c2c2U, 0xd3d3d3d3U, 0xacacacacU, 0x62626262U,
0x91919191U, 0x95959595U, 0xe4e4e4e4U, 0x79797979U,
0xe7e7e7e7U, 0xc8c8c8c8U, 0x37373737U, 0x6d6d6d6dU,
0x8d8d8d8dU, 0xd5d5d5d5U, 0x4e4e4e4eU, 0xa9a9a9a9U,
0x6c6c6c6cU, 0x56565656U, 0xf4f4f4f4U, 0xeaeaeaeaU,
0x65656565U, 0x7a7a7a7aU, 0xaeaeaeaeU, 0x08080808U,
0xbabababaU, 0x78787878U, 0x25252525U, 0x2e2e2e2eU,
0x1c1c1c1cU, 0xa6a6a6a6U, 0xb4b4b4b4U, 0xc6c6c6c6U,
0xe8e8e8e8U, 0xddddddddU, 0x74747474U, 0x1f1f1f1fU,
0x4b4b4b4bU, 0xbdbdbdbdU, 0x8b8b8b8bU, 0x8a8a8a8aU,
0x70707070U, 0x3e3e3e3eU, 0xb5b5b5b5U, 0x66666666U,
0x48484848U, 0x03030303U, 0xf6f6f6f6U, 0x0e0e0e0eU,
0x61616161U, 0x35353535U, 0x57575757U, 0xb9b9b9b9U,
0x86868686U, 0xc1c1c1c1U, 0x1d1d1d1dU, 0x9e9e9e9eU,
0xe1e1e1e1U, 0xf8f8f8f8U, 0x98989898U, 0x11111111U,
0x69696969U, 0xd9d9d9d9U, 0x8e8e8e8eU, 0x94949494U,
0x9b9b9b9bU, 0x1e1e1e1eU, 0x87878787U, 0xe9e9e9e9U,
0xcecececeU, 0x55555555U, 0x28282828U, 0xdfdfdfdfU,
0x8c8c8c8cU, 0xa1a1a1a1U, 0x89898989U, 0x0d0d0d0dU,
0xbfbfbfbfU, 0xe6e6e6e6U, 0x42424242U, 0x68686868U,
0x41414141U, 0x99999999U, 0x2d2d2d2dU, 0x0f0f0f0fU,
0xb0b0b0b0U, 0x54545454U, 0xbbbbbbbbU, 0x16161616U,
};
#endif /* AES_SMALL_TABLES */
const u32 Td0[256] = {
0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,
0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,
0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,
0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,
0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,
0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,
0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,
0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,
0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,
0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,
0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,
0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,
0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,
0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,
0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,
0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,
0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,
0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,
0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,
0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,
0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,
0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,
0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,
0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,
0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,
0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,
0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,
0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,
0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,
0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,
0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,
0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,
0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,
0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,
0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,
0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,
0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,
0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,
0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,
0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,
0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,
0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,
0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,
0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,
0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,
0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,
0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,
0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,
0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,
0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,
0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,
0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,
0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,
0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,
0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,
0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,
0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,
0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,
0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,
0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,
0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,
0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,
0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,
0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,
};
#ifndef AES_SMALL_TABLES
const u32 Td1[256] = {
0x5051f4a7U, 0x537e4165U, 0xc31a17a4U, 0x963a275eU,
0xcb3bab6bU, 0xf11f9d45U, 0xabacfa58U, 0x934be303U,
0x552030faU, 0xf6ad766dU, 0x9188cc76U, 0x25f5024cU,
0xfc4fe5d7U, 0xd7c52acbU, 0x80263544U, 0x8fb562a3U,
0x49deb15aU, 0x6725ba1bU, 0x9845ea0eU, 0xe15dfec0U,
0x02c32f75U, 0x12814cf0U, 0xa38d4697U, 0xc66bd3f9U,
0xe7038f5fU, 0x9515929cU, 0xebbf6d7aU, 0xda955259U,
0x2dd4be83U, 0xd3587421U, 0x2949e069U, 0x448ec9c8U,
0x6a75c289U, 0x78f48e79U, 0x6b99583eU, 0xdd27b971U,
0xb6bee14fU, 0x17f088adU, 0x66c920acU, 0xb47dce3aU,
0x1863df4aU, 0x82e51a31U, 0x60975133U, 0x4562537fU,
0xe0b16477U, 0x84bb6baeU, 0x1cfe81a0U, 0x94f9082bU,
0x58704868U, 0x198f45fdU, 0x8794de6cU, 0xb7527bf8U,
0x23ab73d3U, 0xe2724b02U, 0x57e31f8fU, 0x2a6655abU,
0x07b2eb28U, 0x032fb5c2U, 0x9a86c57bU, 0xa5d33708U,
0xf2302887U, 0xb223bfa5U, 0xba02036aU, 0x5ced1682U,
0x2b8acf1cU, 0x92a779b4U, 0xf0f307f2U, 0xa14e69e2U,
0xcd65daf4U, 0xd50605beU, 0x1fd13462U, 0x8ac4a6feU,
0x9d342e53U, 0xa0a2f355U, 0x32058ae1U, 0x75a4f6ebU,
0x390b83ecU, 0xaa4060efU, 0x065e719fU, 0x51bd6e10U,
0xf93e218aU, 0x3d96dd06U, 0xaedd3e05U, 0x464de6bdU,
0xb591548dU, 0x0571c45dU, 0x6f0406d4U, 0xff605015U,
0x241998fbU, 0x97d6bde9U, 0xcc894043U, 0x7767d99eU,
0xbdb0e842U, 0x8807898bU, 0x38e7195bU, 0xdb79c8eeU,
0x47a17c0aU, 0xe97c420fU, 0xc9f8841eU, 0x00000000U,
0x83098086U, 0x48322bedU, 0xac1e1170U, 0x4e6c5a72U,
0xfbfd0effU, 0x560f8538U, 0x1e3daed5U, 0x27362d39U,
0x640a0fd9U, 0x21685ca6U, 0xd19b5b54U, 0x3a24362eU,
0xb10c0a67U, 0x0f9357e7U, 0xd2b4ee96U, 0x9e1b9b91U,
0x4f80c0c5U, 0xa261dc20U, 0x695a774bU, 0x161c121aU,
0x0ae293baU, 0xe5c0a02aU, 0x433c22e0U, 0x1d121b17U,
0x0b0e090dU, 0xadf28bc7U, 0xb92db6a8U, 0xc8141ea9U,
0x8557f119U, 0x4caf7507U, 0xbbee99ddU, 0xfda37f60U,
0x9ff70126U, 0xbc5c72f5U, 0xc544663bU, 0x345bfb7eU,
0x768b4329U, 0xdccb23c6U, 0x68b6edfcU, 0x63b8e4f1U,
0xcad731dcU, 0x10426385U, 0x40139722U, 0x2084c611U,
0x7d854a24U, 0xf8d2bb3dU, 0x11aef932U, 0x6dc729a1U,
0x4b1d9e2fU, 0xf3dcb230U, 0xec0d8652U, 0xd077c1e3U,
0x6c2bb316U, 0x99a970b9U, 0xfa119448U, 0x2247e964U,
0xc4a8fc8cU, 0x1aa0f03fU, 0xd8567d2cU, 0xef223390U,
0xc787494eU, 0xc1d938d1U, 0xfe8ccaa2U, 0x3698d40bU,
0xcfa6f581U, 0x28a57adeU, 0x26dab78eU, 0xa43fadbfU,
0xe42c3a9dU, 0x0d507892U, 0x9b6a5fccU, 0x62547e46U,
0xc2f68d13U, 0xe890d8b8U, 0x5e2e39f7U, 0xf582c3afU,
0xbe9f5d80U, 0x7c69d093U, 0xa96fd52dU, 0xb3cf2512U,
0x3bc8ac99U, 0xa710187dU, 0x6ee89c63U, 0x7bdb3bbbU,
0x09cd2678U, 0xf46e5918U, 0x01ec9ab7U, 0xa8834f9aU,
0x65e6956eU, 0x7eaaffe6U, 0x0821bccfU, 0xe6ef15e8U,
0xd9bae79bU, 0xce4a6f36U, 0xd4ea9f09U, 0xd629b07cU,
0xaf31a4b2U, 0x312a3f23U, 0x30c6a594U, 0xc035a266U,
0x37744ebcU, 0xa6fc82caU, 0xb0e090d0U, 0x1533a7d8U,
0x4af10498U, 0xf741ecdaU, 0x0e7fcd50U, 0x2f1791f6U,
0x8d764dd6U, 0x4d43efb0U, 0x54ccaa4dU, 0xdfe49604U,
0xe39ed1b5U, 0x1b4c6a88U, 0xb8c12c1fU, 0x7f466551U,
0x049d5eeaU, 0x5d018c35U, 0x73fa8774U, 0x2efb0b41U,
0x5ab3671dU, 0x5292dbd2U, 0x33e91056U, 0x136dd647U,
0x8c9ad761U, 0x7a37a10cU, 0x8e59f814U, 0x89eb133cU,
0xeecea927U, 0x35b761c9U, 0xede11ce5U, 0x3c7a47b1U,
0x599cd2dfU, 0x3f55f273U, 0x791814ceU, 0xbf73c737U,
0xea53f7cdU, 0x5b5ffdaaU, 0x14df3d6fU, 0x867844dbU,
0x81caaff3U, 0x3eb968c4U, 0x2c382434U, 0x5fc2a340U,
0x72161dc3U, 0x0cbce225U, 0x8b283c49U, 0x41ff0d95U,
0x7139a801U, 0xde080cb3U, 0x9cd8b4e4U, 0x906456c1U,
0x617bcb84U, 0x70d532b6U, 0x74486c5cU, 0x42d0b857U,
};
const u32 Td2[256] = {
0xa75051f4U, 0x65537e41U, 0xa4c31a17U, 0x5e963a27U,
0x6bcb3babU, 0x45f11f9dU, 0x58abacfaU, 0x03934be3U,
0xfa552030U, 0x6df6ad76U, 0x769188ccU, 0x4c25f502U,
0xd7fc4fe5U, 0xcbd7c52aU, 0x44802635U, 0xa38fb562U,
0x5a49deb1U, 0x1b6725baU, 0x0e9845eaU, 0xc0e15dfeU,
0x7502c32fU, 0xf012814cU, 0x97a38d46U, 0xf9c66bd3U,
0x5fe7038fU, 0x9c951592U, 0x7aebbf6dU, 0x59da9552U,
0x832dd4beU, 0x21d35874U, 0x692949e0U, 0xc8448ec9U,
0x896a75c2U, 0x7978f48eU, 0x3e6b9958U, 0x71dd27b9U,
0x4fb6bee1U, 0xad17f088U, 0xac66c920U, 0x3ab47dceU,
0x4a1863dfU, 0x3182e51aU, 0x33609751U, 0x7f456253U,
0x77e0b164U, 0xae84bb6bU, 0xa01cfe81U, 0x2b94f908U,
0x68587048U, 0xfd198f45U, 0x6c8794deU, 0xf8b7527bU,
0xd323ab73U, 0x02e2724bU, 0x8f57e31fU, 0xab2a6655U,
0x2807b2ebU, 0xc2032fb5U, 0x7b9a86c5U, 0x08a5d337U,
0x87f23028U, 0xa5b223bfU, 0x6aba0203U, 0x825ced16U,
0x1c2b8acfU, 0xb492a779U, 0xf2f0f307U, 0xe2a14e69U,
0xf4cd65daU, 0xbed50605U, 0x621fd134U, 0xfe8ac4a6U,
0x539d342eU, 0x55a0a2f3U, 0xe132058aU, 0xeb75a4f6U,
0xec390b83U, 0xefaa4060U, 0x9f065e71U, 0x1051bd6eU,
0x8af93e21U, 0x063d96ddU, 0x05aedd3eU, 0xbd464de6U,
0x8db59154U, 0x5d0571c4U, 0xd46f0406U, 0x15ff6050U,
0xfb241998U, 0xe997d6bdU, 0x43cc8940U, 0x9e7767d9U,
0x42bdb0e8U, 0x8b880789U, 0x5b38e719U, 0xeedb79c8U,
0x0a47a17cU, 0x0fe97c42U, 0x1ec9f884U, 0x00000000U,
0x86830980U, 0xed48322bU, 0x70ac1e11U, 0x724e6c5aU,
0xfffbfd0eU, 0x38560f85U, 0xd51e3daeU, 0x3927362dU,
0xd9640a0fU, 0xa621685cU, 0x54d19b5bU, 0x2e3a2436U,
0x67b10c0aU, 0xe70f9357U, 0x96d2b4eeU, 0x919e1b9bU,
0xc54f80c0U, 0x20a261dcU, 0x4b695a77U, 0x1a161c12U,
0xba0ae293U, 0x2ae5c0a0U, 0xe0433c22U, 0x171d121bU,
0x0d0b0e09U, 0xc7adf28bU, 0xa8b92db6U, 0xa9c8141eU,
0x198557f1U, 0x074caf75U, 0xddbbee99U, 0x60fda37fU,
0x269ff701U, 0xf5bc5c72U, 0x3bc54466U, 0x7e345bfbU,
0x29768b43U, 0xc6dccb23U, 0xfc68b6edU, 0xf163b8e4U,
0xdccad731U, 0x85104263U, 0x22401397U, 0x112084c6U,
0x247d854aU, 0x3df8d2bbU, 0x3211aef9U, 0xa16dc729U,
0x2f4b1d9eU, 0x30f3dcb2U, 0x52ec0d86U, 0xe3d077c1U,
0x166c2bb3U, 0xb999a970U, 0x48fa1194U, 0x642247e9U,
0x8cc4a8fcU, 0x3f1aa0f0U, 0x2cd8567dU, 0x90ef2233U,
0x4ec78749U, 0xd1c1d938U, 0xa2fe8ccaU, 0x0b3698d4U,
0x81cfa6f5U, 0xde28a57aU, 0x8e26dab7U, 0xbfa43fadU,
0x9de42c3aU, 0x920d5078U, 0xcc9b6a5fU, 0x4662547eU,
0x13c2f68dU, 0xb8e890d8U, 0xf75e2e39U, 0xaff582c3U,
0x80be9f5dU, 0x937c69d0U, 0x2da96fd5U, 0x12b3cf25U,
0x993bc8acU, 0x7da71018U, 0x636ee89cU, 0xbb7bdb3bU,
0x7809cd26U, 0x18f46e59U, 0xb701ec9aU, 0x9aa8834fU,
0x6e65e695U, 0xe67eaaffU, 0xcf0821bcU, 0xe8e6ef15U,
0x9bd9bae7U, 0x36ce4a6fU, 0x09d4ea9fU, 0x7cd629b0U,
0xb2af31a4U, 0x23312a3fU, 0x9430c6a5U, 0x66c035a2U,
0xbc37744eU, 0xcaa6fc82U, 0xd0b0e090U, 0xd81533a7U,
0x984af104U, 0xdaf741ecU, 0x500e7fcdU, 0xf62f1791U,
0xd68d764dU, 0xb04d43efU, 0x4d54ccaaU, 0x04dfe496U,
0xb5e39ed1U, 0x881b4c6aU, 0x1fb8c12cU, 0x517f4665U,
0xea049d5eU, 0x355d018cU, 0x7473fa87U, 0x412efb0bU,
0x1d5ab367U, 0xd25292dbU, 0x5633e910U, 0x47136dd6U,
0x618c9ad7U, 0x0c7a37a1U, 0x148e59f8U, 0x3c89eb13U,
0x27eecea9U, 0xc935b761U, 0xe5ede11cU, 0xb13c7a47U,
0xdf599cd2U, 0x733f55f2U, 0xce791814U, 0x37bf73c7U,
0xcdea53f7U, 0xaa5b5ffdU, 0x6f14df3dU, 0xdb867844U,
0xf381caafU, 0xc43eb968U, 0x342c3824U, 0x405fc2a3U,
0xc372161dU, 0x250cbce2U, 0x498b283cU, 0x9541ff0dU,
0x017139a8U, 0xb3de080cU, 0xe49cd8b4U, 0xc1906456U,
0x84617bcbU, 0xb670d532U, 0x5c74486cU, 0x5742d0b8U,
};
const u32 Td3[256] = {
0xf4a75051U, 0x4165537eU, 0x17a4c31aU, 0x275e963aU,
0xab6bcb3bU, 0x9d45f11fU, 0xfa58abacU, 0xe303934bU,
0x30fa5520U, 0x766df6adU, 0xcc769188U, 0x024c25f5U,
0xe5d7fc4fU, 0x2acbd7c5U, 0x35448026U, 0x62a38fb5U,
0xb15a49deU, 0xba1b6725U, 0xea0e9845U, 0xfec0e15dU,
0x2f7502c3U, 0x4cf01281U, 0x4697a38dU, 0xd3f9c66bU,
0x8f5fe703U, 0x929c9515U, 0x6d7aebbfU, 0x5259da95U,
0xbe832dd4U, 0x7421d358U, 0xe0692949U, 0xc9c8448eU,
0xc2896a75U, 0x8e7978f4U, 0x583e6b99U, 0xb971dd27U,
0xe14fb6beU, 0x88ad17f0U, 0x20ac66c9U, 0xce3ab47dU,
0xdf4a1863U, 0x1a3182e5U, 0x51336097U, 0x537f4562U,
0x6477e0b1U, 0x6bae84bbU, 0x81a01cfeU, 0x082b94f9U,
0x48685870U, 0x45fd198fU, 0xde6c8794U, 0x7bf8b752U,
0x73d323abU, 0x4b02e272U, 0x1f8f57e3U, 0x55ab2a66U,
0xeb2807b2U, 0xb5c2032fU, 0xc57b9a86U, 0x3708a5d3U,
0x2887f230U, 0xbfa5b223U, 0x036aba02U, 0x16825cedU,
0xcf1c2b8aU, 0x79b492a7U, 0x07f2f0f3U, 0x69e2a14eU,
0xdaf4cd65U, 0x05bed506U, 0x34621fd1U, 0xa6fe8ac4U,
0x2e539d34U, 0xf355a0a2U, 0x8ae13205U, 0xf6eb75a4U,
0x83ec390bU, 0x60efaa40U, 0x719f065eU, 0x6e1051bdU,
0x218af93eU, 0xdd063d96U, 0x3e05aeddU, 0xe6bd464dU,
0x548db591U, 0xc45d0571U, 0x06d46f04U, 0x5015ff60U,
0x98fb2419U, 0xbde997d6U, 0x4043cc89U, 0xd99e7767U,
0xe842bdb0U, 0x898b8807U, 0x195b38e7U, 0xc8eedb79U,
0x7c0a47a1U, 0x420fe97cU, 0x841ec9f8U, 0x00000000U,
0x80868309U, 0x2bed4832U, 0x1170ac1eU, 0x5a724e6cU,
0x0efffbfdU, 0x8538560fU, 0xaed51e3dU, 0x2d392736U,
0x0fd9640aU, 0x5ca62168U, 0x5b54d19bU, 0x362e3a24U,
0x0a67b10cU, 0x57e70f93U, 0xee96d2b4U, 0x9b919e1bU,
0xc0c54f80U, 0xdc20a261U, 0x774b695aU, 0x121a161cU,
0x93ba0ae2U, 0xa02ae5c0U, 0x22e0433cU, 0x1b171d12U,
0x090d0b0eU, 0x8bc7adf2U, 0xb6a8b92dU, 0x1ea9c814U,
0xf1198557U, 0x75074cafU, 0x99ddbbeeU, 0x7f60fda3U,
0x01269ff7U, 0x72f5bc5cU, 0x663bc544U, 0xfb7e345bU,
0x4329768bU, 0x23c6dccbU, 0xedfc68b6U, 0xe4f163b8U,
0x31dccad7U, 0x63851042U, 0x97224013U, 0xc6112084U,
0x4a247d85U, 0xbb3df8d2U, 0xf93211aeU, 0x29a16dc7U,
0x9e2f4b1dU, 0xb230f3dcU, 0x8652ec0dU, 0xc1e3d077U,
0xb3166c2bU, 0x70b999a9U, 0x9448fa11U, 0xe9642247U,
0xfc8cc4a8U, 0xf03f1aa0U, 0x7d2cd856U, 0x3390ef22U,
0x494ec787U, 0x38d1c1d9U, 0xcaa2fe8cU, 0xd40b3698U,
0xf581cfa6U, 0x7ade28a5U, 0xb78e26daU, 0xadbfa43fU,
0x3a9de42cU, 0x78920d50U, 0x5fcc9b6aU, 0x7e466254U,
0x8d13c2f6U, 0xd8b8e890U, 0x39f75e2eU, 0xc3aff582U,
0x5d80be9fU, 0xd0937c69U, 0xd52da96fU, 0x2512b3cfU,
0xac993bc8U, 0x187da710U, 0x9c636ee8U, 0x3bbb7bdbU,
0x267809cdU, 0x5918f46eU, 0x9ab701ecU, 0x4f9aa883U,
0x956e65e6U, 0xffe67eaaU, 0xbccf0821U, 0x15e8e6efU,
0xe79bd9baU, 0x6f36ce4aU, 0x9f09d4eaU, 0xb07cd629U,
0xa4b2af31U, 0x3f23312aU, 0xa59430c6U, 0xa266c035U,
0x4ebc3774U, 0x82caa6fcU, 0x90d0b0e0U, 0xa7d81533U,
0x04984af1U, 0xecdaf741U, 0xcd500e7fU, 0x91f62f17U,
0x4dd68d76U, 0xefb04d43U, 0xaa4d54ccU, 0x9604dfe4U,
0xd1b5e39eU, 0x6a881b4cU, 0x2c1fb8c1U, 0x65517f46U,
0x5eea049dU, 0x8c355d01U, 0x877473faU, 0x0b412efbU,
0x671d5ab3U, 0xdbd25292U, 0x105633e9U, 0xd647136dU,
0xd7618c9aU, 0xa10c7a37U, 0xf8148e59U, 0x133c89ebU,
0xa927eeceU, 0x61c935b7U, 0x1ce5ede1U, 0x47b13c7aU,
0xd2df599cU, 0xf2733f55U, 0x14ce7918U, 0xc737bf73U,
0xf7cdea53U, 0xfdaa5b5fU, 0x3d6f14dfU, 0x44db8678U,
0xaff381caU, 0x68c43eb9U, 0x24342c38U, 0xa3405fc2U,
0x1dc37216U, 0xe2250cbcU, 0x3c498b28U, 0x0d9541ffU,
0xa8017139U, 0x0cb3de08U, 0xb4e49cd8U, 0x56c19064U,
0xcb84617bU, 0x32b670d5U, 0x6c5c7448U, 0xb85742d0U,
};
const u32 Td4[256] = {
0x52525252U, 0x09090909U, 0x6a6a6a6aU, 0xd5d5d5d5U,
0x30303030U, 0x36363636U, 0xa5a5a5a5U, 0x38383838U,
0xbfbfbfbfU, 0x40404040U, 0xa3a3a3a3U, 0x9e9e9e9eU,
0x81818181U, 0xf3f3f3f3U, 0xd7d7d7d7U, 0xfbfbfbfbU,
0x7c7c7c7cU, 0xe3e3e3e3U, 0x39393939U, 0x82828282U,
0x9b9b9b9bU, 0x2f2f2f2fU, 0xffffffffU, 0x87878787U,
0x34343434U, 0x8e8e8e8eU, 0x43434343U, 0x44444444U,
0xc4c4c4c4U, 0xdedededeU, 0xe9e9e9e9U, 0xcbcbcbcbU,
0x54545454U, 0x7b7b7b7bU, 0x94949494U, 0x32323232U,
0xa6a6a6a6U, 0xc2c2c2c2U, 0x23232323U, 0x3d3d3d3dU,
0xeeeeeeeeU, 0x4c4c4c4cU, 0x95959595U, 0x0b0b0b0bU,
0x42424242U, 0xfafafafaU, 0xc3c3c3c3U, 0x4e4e4e4eU,
0x08080808U, 0x2e2e2e2eU, 0xa1a1a1a1U, 0x66666666U,
0x28282828U, 0xd9d9d9d9U, 0x24242424U, 0xb2b2b2b2U,
0x76767676U, 0x5b5b5b5bU, 0xa2a2a2a2U, 0x49494949U,
0x6d6d6d6dU, 0x8b8b8b8bU, 0xd1d1d1d1U, 0x25252525U,
0x72727272U, 0xf8f8f8f8U, 0xf6f6f6f6U, 0x64646464U,
0x86868686U, 0x68686868U, 0x98989898U, 0x16161616U,
0xd4d4d4d4U, 0xa4a4a4a4U, 0x5c5c5c5cU, 0xccccccccU,
0x5d5d5d5dU, 0x65656565U, 0xb6b6b6b6U, 0x92929292U,
0x6c6c6c6cU, 0x70707070U, 0x48484848U, 0x50505050U,
0xfdfdfdfdU, 0xededededU, 0xb9b9b9b9U, 0xdadadadaU,
0x5e5e5e5eU, 0x15151515U, 0x46464646U, 0x57575757U,
0xa7a7a7a7U, 0x8d8d8d8dU, 0x9d9d9d9dU, 0x84848484U,
0x90909090U, 0xd8d8d8d8U, 0xababababU, 0x00000000U,
0x8c8c8c8cU, 0xbcbcbcbcU, 0xd3d3d3d3U, 0x0a0a0a0aU,
0xf7f7f7f7U, 0xe4e4e4e4U, 0x58585858U, 0x05050505U,
0xb8b8b8b8U, 0xb3b3b3b3U, 0x45454545U, 0x06060606U,
0xd0d0d0d0U, 0x2c2c2c2cU, 0x1e1e1e1eU, 0x8f8f8f8fU,
0xcacacacaU, 0x3f3f3f3fU, 0x0f0f0f0fU, 0x02020202U,
0xc1c1c1c1U, 0xafafafafU, 0xbdbdbdbdU, 0x03030303U,
0x01010101U, 0x13131313U, 0x8a8a8a8aU, 0x6b6b6b6bU,
0x3a3a3a3aU, 0x91919191U, 0x11111111U, 0x41414141U,
0x4f4f4f4fU, 0x67676767U, 0xdcdcdcdcU, 0xeaeaeaeaU,
0x97979797U, 0xf2f2f2f2U, 0xcfcfcfcfU, 0xcecececeU,
0xf0f0f0f0U, 0xb4b4b4b4U, 0xe6e6e6e6U, 0x73737373U,
0x96969696U, 0xacacacacU, 0x74747474U, 0x22222222U,
0xe7e7e7e7U, 0xadadadadU, 0x35353535U, 0x85858585U,
0xe2e2e2e2U, 0xf9f9f9f9U, 0x37373737U, 0xe8e8e8e8U,
0x1c1c1c1cU, 0x75757575U, 0xdfdfdfdfU, 0x6e6e6e6eU,
0x47474747U, 0xf1f1f1f1U, 0x1a1a1a1aU, 0x71717171U,
0x1d1d1d1dU, 0x29292929U, 0xc5c5c5c5U, 0x89898989U,
0x6f6f6f6fU, 0xb7b7b7b7U, 0x62626262U, 0x0e0e0e0eU,
0xaaaaaaaaU, 0x18181818U, 0xbebebebeU, 0x1b1b1b1bU,
0xfcfcfcfcU, 0x56565656U, 0x3e3e3e3eU, 0x4b4b4b4bU,
0xc6c6c6c6U, 0xd2d2d2d2U, 0x79797979U, 0x20202020U,
0x9a9a9a9aU, 0xdbdbdbdbU, 0xc0c0c0c0U, 0xfefefefeU,
0x78787878U, 0xcdcdcdcdU, 0x5a5a5a5aU, 0xf4f4f4f4U,
0x1f1f1f1fU, 0xddddddddU, 0xa8a8a8a8U, 0x33333333U,
0x88888888U, 0x07070707U, 0xc7c7c7c7U, 0x31313131U,
0xb1b1b1b1U, 0x12121212U, 0x10101010U, 0x59595959U,
0x27272727U, 0x80808080U, 0xececececU, 0x5f5f5f5fU,
0x60606060U, 0x51515151U, 0x7f7f7f7fU, 0xa9a9a9a9U,
0x19191919U, 0xb5b5b5b5U, 0x4a4a4a4aU, 0x0d0d0d0dU,
0x2d2d2d2dU, 0xe5e5e5e5U, 0x7a7a7a7aU, 0x9f9f9f9fU,
0x93939393U, 0xc9c9c9c9U, 0x9c9c9c9cU, 0xefefefefU,
0xa0a0a0a0U, 0xe0e0e0e0U, 0x3b3b3b3bU, 0x4d4d4d4dU,
0xaeaeaeaeU, 0x2a2a2a2aU, 0xf5f5f5f5U, 0xb0b0b0b0U,
0xc8c8c8c8U, 0xebebebebU, 0xbbbbbbbbU, 0x3c3c3c3cU,
0x83838383U, 0x53535353U, 0x99999999U, 0x61616161U,
0x17171717U, 0x2b2b2b2bU, 0x04040404U, 0x7e7e7e7eU,
0xbabababaU, 0x77777777U, 0xd6d6d6d6U, 0x26262626U,
0xe1e1e1e1U, 0x69696969U, 0x14141414U, 0x63636363U,
0x55555555U, 0x21212121U, 0x0c0c0c0cU, 0x7d7d7d7dU,
};
const u32 rcon[] = {
0x01000000, 0x02000000, 0x04000000, 0x08000000,
0x10000000, 0x20000000, 0x40000000, 0x80000000,
0x1B000000, 0x36000000, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
};
#else /* AES_SMALL_TABLES */
const u8 Td4s[256] = {
0x52U, 0x09U, 0x6aU, 0xd5U, 0x30U, 0x36U, 0xa5U, 0x38U,
0xbfU, 0x40U, 0xa3U, 0x9eU, 0x81U, 0xf3U, 0xd7U, 0xfbU,
0x7cU, 0xe3U, 0x39U, 0x82U, 0x9bU, 0x2fU, 0xffU, 0x87U,
0x34U, 0x8eU, 0x43U, 0x44U, 0xc4U, 0xdeU, 0xe9U, 0xcbU,
0x54U, 0x7bU, 0x94U, 0x32U, 0xa6U, 0xc2U, 0x23U, 0x3dU,
0xeeU, 0x4cU, 0x95U, 0x0bU, 0x42U, 0xfaU, 0xc3U, 0x4eU,
0x08U, 0x2eU, 0xa1U, 0x66U, 0x28U, 0xd9U, 0x24U, 0xb2U,
0x76U, 0x5bU, 0xa2U, 0x49U, 0x6dU, 0x8bU, 0xd1U, 0x25U,
0x72U, 0xf8U, 0xf6U, 0x64U, 0x86U, 0x68U, 0x98U, 0x16U,
0xd4U, 0xa4U, 0x5cU, 0xccU, 0x5dU, 0x65U, 0xb6U, 0x92U,
0x6cU, 0x70U, 0x48U, 0x50U, 0xfdU, 0xedU, 0xb9U, 0xdaU,
0x5eU, 0x15U, 0x46U, 0x57U, 0xa7U, 0x8dU, 0x9dU, 0x84U,
0x90U, 0xd8U, 0xabU, 0x00U, 0x8cU, 0xbcU, 0xd3U, 0x0aU,
0xf7U, 0xe4U, 0x58U, 0x05U, 0xb8U, 0xb3U, 0x45U, 0x06U,
0xd0U, 0x2cU, 0x1eU, 0x8fU, 0xcaU, 0x3fU, 0x0fU, 0x02U,
0xc1U, 0xafU, 0xbdU, 0x03U, 0x01U, 0x13U, 0x8aU, 0x6bU,
0x3aU, 0x91U, 0x11U, 0x41U, 0x4fU, 0x67U, 0xdcU, 0xeaU,
0x97U, 0xf2U, 0xcfU, 0xceU, 0xf0U, 0xb4U, 0xe6U, 0x73U,
0x96U, 0xacU, 0x74U, 0x22U, 0xe7U, 0xadU, 0x35U, 0x85U,
0xe2U, 0xf9U, 0x37U, 0xe8U, 0x1cU, 0x75U, 0xdfU, 0x6eU,
0x47U, 0xf1U, 0x1aU, 0x71U, 0x1dU, 0x29U, 0xc5U, 0x89U,
0x6fU, 0xb7U, 0x62U, 0x0eU, 0xaaU, 0x18U, 0xbeU, 0x1bU,
0xfcU, 0x56U, 0x3eU, 0x4bU, 0xc6U, 0xd2U, 0x79U, 0x20U,
0x9aU, 0xdbU, 0xc0U, 0xfeU, 0x78U, 0xcdU, 0x5aU, 0xf4U,
0x1fU, 0xddU, 0xa8U, 0x33U, 0x88U, 0x07U, 0xc7U, 0x31U,
0xb1U, 0x12U, 0x10U, 0x59U, 0x27U, 0x80U, 0xecU, 0x5fU,
0x60U, 0x51U, 0x7fU, 0xa9U, 0x19U, 0xb5U, 0x4aU, 0x0dU,
0x2dU, 0xe5U, 0x7aU, 0x9fU, 0x93U, 0xc9U, 0x9cU, 0xefU,
0xa0U, 0xe0U, 0x3bU, 0x4dU, 0xaeU, 0x2aU, 0xf5U, 0xb0U,
0xc8U, 0xebU, 0xbbU, 0x3cU, 0x83U, 0x53U, 0x99U, 0x61U,
0x17U, 0x2bU, 0x04U, 0x7eU, 0xbaU, 0x77U, 0xd6U, 0x26U,
0xe1U, 0x69U, 0x14U, 0x63U, 0x55U, 0x21U, 0x0cU, 0x7dU,
};
const u8 rcons[] = {
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
/* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
};
#endif /* AES_SMALL_TABLES */
/**
* Expand the cipher key into the encryption key schedule.
*
* @return the number of rounds for the given cipher key size.
*/
int rijndaelKeySetupEnc(u32 rk[], const u8 cipherKey[], int keyBits)
{
int i;
u32 temp;
rk[0] = GETU32(cipherKey );
rk[1] = GETU32(cipherKey + 4);
rk[2] = GETU32(cipherKey + 8);
rk[3] = GETU32(cipherKey + 12);
if (keyBits == 128) {
for (i = 0; i < 10; i++) {
temp = rk[3];
rk[4] = rk[0] ^ TE421(temp) ^ TE432(temp) ^
TE443(temp) ^ TE414(temp) ^ RCON(i);
rk[5] = rk[1] ^ rk[4];
rk[6] = rk[2] ^ rk[5];
rk[7] = rk[3] ^ rk[6];
rk += 4;
}
return 10;
}
rk[4] = GETU32(cipherKey + 16);
rk[5] = GETU32(cipherKey + 20);
if (keyBits == 192) {
for (i = 0; i < 8; i++) {
temp = rk[5];
rk[6] = rk[0] ^ TE421(temp) ^ TE432(temp) ^
TE443(temp) ^ TE414(temp) ^ RCON(i);
rk[7] = rk[1] ^ rk[6];
rk[8] = rk[2] ^ rk[7];
rk[9] = rk[3] ^ rk[8];
if (i == 7)
return 12;
rk[10] = rk[4] ^ rk[9];
rk[11] = rk[5] ^ rk[10];
rk += 6;
}
}
rk[6] = GETU32(cipherKey + 24);
rk[7] = GETU32(cipherKey + 28);
if (keyBits == 256) {
for (i = 0; i < 7; i++) {
temp = rk[7];
rk[8] = rk[0] ^ TE421(temp) ^ TE432(temp) ^
TE443(temp) ^ TE414(temp) ^ RCON(i);
rk[9] = rk[1] ^ rk[8];
rk[10] = rk[2] ^ rk[9];
rk[11] = rk[3] ^ rk[10];
if (i == 6)
return 14;
temp = rk[11];
rk[12] = rk[4] ^ TE411(temp) ^ TE422(temp) ^
TE433(temp) ^ TE444(temp);
rk[13] = rk[5] ^ rk[12];
rk[14] = rk[6] ^ rk[13];
rk[15] = rk[7] ^ rk[14];
rk += 8;
}
}
return -1;
}
|
2301_81045437/rtl8852be
|
core/crypto/aes-internal.c
|
C
|
agpl-3.0
| 42,188
|
/*
* One-key CBC MAC (OMAC1) hash with AES
*
* Copyright (c) 2003-2007, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "aes.h"
#include "aes_wrap.h"
static void gf_mulx(u8 *pad)
{
int i, carry;
carry = pad[0] & 0x80;
for (i = 0; i < AES_BLOCK_SIZE - 1; i++)
pad[i] = (pad[i] << 1) | (pad[i + 1] >> 7);
pad[AES_BLOCK_SIZE - 1] <<= 1;
if (carry)
pad[AES_BLOCK_SIZE - 1] ^= 0x87;
}
/**
* omac1_aes_vector - One-Key CBC MAC (OMAC1) hash with AES
* @key: Key for the hash operation
* @key_len: Key length in octets
* @num_elem: Number of elements in the data vector
* @addr: Pointers to the data areas
* @len: Lengths of the data blocks
* @mac: Buffer for MAC (128 bits, i.e., 16 bytes)
* Returns: 0 on success, -1 on failure
*
* This is a mode for using block cipher (AES in this case) for authentication.
* OMAC1 was standardized with the name CMAC by NIST in a Special Publication
* (SP) 800-38B.
*/
int omac1_aes_vector(const u8 *key, size_t key_len, size_t num_elem,
const u8 *addr[], const size_t *len, u8 *mac)
{
void *ctx;
u8 cbc[AES_BLOCK_SIZE], pad[AES_BLOCK_SIZE];
const u8 *pos, *end;
size_t i, e, left, total_len;
if (TEST_FAIL())
return -1;
ctx = aes_encrypt_init(key, key_len);
if (ctx == NULL)
return -1;
os_memset(cbc, 0, AES_BLOCK_SIZE);
total_len = 0;
for (e = 0; e < num_elem; e++)
total_len += len[e];
left = total_len;
e = 0;
pos = addr[0];
end = pos + len[0];
while (left >= AES_BLOCK_SIZE) {
for (i = 0; i < AES_BLOCK_SIZE; i++) {
cbc[i] ^= *pos++;
if (pos >= end) {
/*
* Stop if there are no more bytes to process
* since there are no more entries in the array.
*/
if (i + 1 == AES_BLOCK_SIZE &&
left == AES_BLOCK_SIZE)
break;
e++;
pos = addr[e];
end = pos + len[e];
}
}
if (left > AES_BLOCK_SIZE)
aes_encrypt(ctx, cbc, cbc);
left -= AES_BLOCK_SIZE;
}
os_memset(pad, 0, AES_BLOCK_SIZE);
aes_encrypt(ctx, pad, pad);
gf_mulx(pad);
if (left || total_len == 0) {
for (i = 0; i < left; i++) {
cbc[i] ^= *pos++;
if (pos >= end) {
/*
* Stop if there are no more bytes to process
* since there are no more entries in the array.
*/
if (i + 1 == left)
break;
e++;
pos = addr[e];
end = pos + len[e];
}
}
cbc[left] ^= 0x80;
gf_mulx(pad);
}
for (i = 0; i < AES_BLOCK_SIZE; i++)
pad[i] ^= cbc[i];
aes_encrypt(ctx, pad, mac);
aes_encrypt_deinit(ctx);
return 0;
}
/**
* omac1_aes_128_vector - One-Key CBC MAC (OMAC1) hash with AES-128
* @key: 128-bit key for the hash operation
* @num_elem: Number of elements in the data vector
* @addr: Pointers to the data areas
* @len: Lengths of the data blocks
* @mac: Buffer for MAC (128 bits, i.e., 16 bytes)
* Returns: 0 on success, -1 on failure
*
* This is a mode for using block cipher (AES in this case) for authentication.
* OMAC1 was standardized with the name CMAC by NIST in a Special Publication
* (SP) 800-38B.
*/
int omac1_aes_128_vector(const u8 *key, size_t num_elem,
const u8 *addr[], const size_t *len, u8 *mac)
{
return omac1_aes_vector(key, 16, num_elem, addr, len, mac);
}
/**
* omac1_aes_128 - One-Key CBC MAC (OMAC1) hash with AES-128 (aka AES-CMAC)
* @key: 128-bit key for the hash operation
* @data: Data buffer for which a MAC is determined
* @data_len: Length of data buffer in bytes
* @mac: Buffer for MAC (128 bits, i.e., 16 bytes)
* Returns: 0 on success, -1 on failure
*
* This is a mode for using block cipher (AES in this case) for authentication.
* OMAC1 was standardized with the name CMAC by NIST in a Special Publication
* (SP) 800-38B.
*/
int omac1_aes_128(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
{
return omac1_aes_128_vector(key, 1, &data, &data_len, mac);
}
/**
* omac1_aes_256 - One-Key CBC MAC (OMAC1) hash with AES-256 (aka AES-CMAC)
* @key: 256-bit key for the hash operation
* @data: Data buffer for which a MAC is determined
* @data_len: Length of data buffer in bytes
* @mac: Buffer for MAC (128 bits, i.e., 16 bytes)
* Returns: 0 on success, -1 on failure
*
* This is a mode for using block cipher (AES in this case) for authentication.
* OMAC1 was standardized with the name CMAC by NIST in a Special Publication
* (SP) 800-38B.
*/
int omac1_aes_256(const u8 *key, const u8 *data, size_t data_len, u8 *mac)
{
return omac1_aes_vector(key, 32, 1, &data, &data_len, mac);
}
|
2301_81045437/rtl8852be
|
core/crypto/aes-omac1.c
|
C
|
agpl-3.0
| 4,558
|
/*
* AES SIV (RFC 5297)
* Copyright (c) 2013 Cozybit, Inc.
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "aes.h"
#include "aes_wrap.h"
#include "aes_siv.h"
static const u8 zero[AES_BLOCK_SIZE];
static void dbl(u8 *pad)
{
int i, carry;
carry = pad[0] & 0x80;
for (i = 0; i < AES_BLOCK_SIZE - 1; i++)
pad[i] = (pad[i] << 1) | (pad[i + 1] >> 7);
pad[AES_BLOCK_SIZE - 1] <<= 1;
if (carry)
pad[AES_BLOCK_SIZE - 1] ^= 0x87;
}
static void xor(u8 *a, const u8 *b)
{
int i;
for (i = 0; i < AES_BLOCK_SIZE; i++)
*a++ ^= *b++;
}
static void xorend(u8 *a, int alen, const u8 *b, int blen)
{
int i;
if (alen < blen)
return;
for (i = 0; i < blen; i++)
a[alen - blen + i] ^= b[i];
}
static void pad_block(u8 *pad, const u8 *addr, size_t len)
{
os_memset(pad, 0, AES_BLOCK_SIZE);
os_memcpy(pad, addr, len);
if (len < AES_BLOCK_SIZE)
pad[len] = 0x80;
}
static int aes_s2v(const u8 *key, size_t key_len,
size_t num_elem, const u8 *addr[], size_t *len, u8 *mac)
{
u8 tmp[AES_BLOCK_SIZE], tmp2[AES_BLOCK_SIZE];
u8 *buf = NULL;
int ret;
size_t i;
const u8 *data[1];
size_t data_len[1];
if (!num_elem) {
os_memcpy(tmp, zero, sizeof(zero));
tmp[AES_BLOCK_SIZE - 1] = 1;
data[0] = tmp;
data_len[0] = sizeof(tmp);
return omac1_aes_vector(key, key_len, 1, data, data_len, mac);
}
data[0] = zero;
data_len[0] = sizeof(zero);
ret = omac1_aes_vector(key, key_len, 1, data, data_len, tmp);
if (ret)
return ret;
for (i = 0; i < num_elem - 1; i++) {
ret = omac1_aes_vector(key, key_len, 1, &addr[i], &len[i],
tmp2);
if (ret)
return ret;
dbl(tmp);
xor(tmp, tmp2);
}
if (len[i] >= AES_BLOCK_SIZE) {
buf = os_memdup(addr[i], len[i]);
if (!buf)
return -ENOMEM;
xorend(buf, len[i], tmp, AES_BLOCK_SIZE);
data[0] = buf;
ret = omac1_aes_vector(key, key_len, 1, data, &len[i], mac);
bin_clear_free(buf, len[i]);
return ret;
}
dbl(tmp);
pad_block(tmp2, addr[i], len[i]);
xor(tmp, tmp2);
data[0] = tmp;
data_len[0] = sizeof(tmp);
return omac1_aes_vector(key, key_len, 1, data, data_len, mac);
}
int aes_siv_encrypt(const u8 *key, size_t key_len,
const u8 *pw, size_t pwlen,
size_t num_elem, const u8 *addr[], const size_t *len,
u8 *out)
{
const u8 *_addr[6];
size_t _len[6];
const u8 *k1, *k2;
u8 v[AES_BLOCK_SIZE];
size_t i;
u8 *iv, *crypt_pw;
if (num_elem > ARRAY_SIZE(_addr) - 1 ||
(key_len != 32 && key_len != 48 && key_len != 64))
return -1;
key_len /= 2;
k1 = key;
k2 = key + key_len;
for (i = 0; i < num_elem; i++) {
_addr[i] = addr[i];
_len[i] = len[i];
}
_addr[num_elem] = pw;
_len[num_elem] = pwlen;
if (aes_s2v(k1, key_len, num_elem + 1, _addr, _len, v))
return -1;
iv = out;
crypt_pw = out + AES_BLOCK_SIZE;
os_memcpy(iv, v, AES_BLOCK_SIZE);
os_memcpy(crypt_pw, pw, pwlen);
/* zero out 63rd and 31st bits of ctr (from right) */
v[8] &= 0x7f;
v[12] &= 0x7f;
return aes_ctr_encrypt(k2, key_len, v, crypt_pw, pwlen);
}
int aes_siv_decrypt(const u8 *key, size_t key_len,
const u8 *iv_crypt, size_t iv_c_len,
size_t num_elem, const u8 *addr[], const size_t *len,
u8 *out)
{
const u8 *_addr[6];
size_t _len[6];
const u8 *k1, *k2;
size_t crypt_len;
size_t i;
int ret;
u8 iv[AES_BLOCK_SIZE];
u8 check[AES_BLOCK_SIZE];
if (iv_c_len < AES_BLOCK_SIZE || num_elem > ARRAY_SIZE(_addr) - 1 ||
(key_len != 32 && key_len != 48 && key_len != 64))
return -1;
crypt_len = iv_c_len - AES_BLOCK_SIZE;
key_len /= 2;
k1 = key;
k2 = key + key_len;
for (i = 0; i < num_elem; i++) {
_addr[i] = addr[i];
_len[i] = len[i];
}
_addr[num_elem] = out;
_len[num_elem] = crypt_len;
os_memcpy(iv, iv_crypt, AES_BLOCK_SIZE);
os_memcpy(out, iv_crypt + AES_BLOCK_SIZE, crypt_len);
iv[8] &= 0x7f;
iv[12] &= 0x7f;
ret = aes_ctr_encrypt(k2, key_len, iv, out, crypt_len);
if (ret)
return ret;
ret = aes_s2v(k1, key_len, num_elem + 1, _addr, _len, check);
if (ret)
return ret;
if (os_memcmp(check, iv_crypt, AES_BLOCK_SIZE) == 0)
return 0;
return -1;
}
|
2301_81045437/rtl8852be
|
core/crypto/aes-siv.c
|
C
|
agpl-3.0
| 4,148
|
/*
* AES functions
* Copyright (c) 2003-2006, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef AES_H
#define AES_H
#define AES_BLOCK_SIZE 16
void * aes_encrypt_init(const u8 *key, size_t len);
int aes_encrypt(void *ctx, const u8 *plain, u8 *crypt);
void aes_encrypt_deinit(void *ctx);
void * aes_decrypt_init(const u8 *key, size_t len);
int aes_decrypt(void *ctx, const u8 *crypt, u8 *plain);
void aes_decrypt_deinit(void *ctx);
#endif /* AES_H */
|
2301_81045437/rtl8852be
|
core/crypto/aes.h
|
C
|
agpl-3.0
| 548
|
/*
* AES (Rijndael) cipher
* Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef AES_I_H
#define AES_I_H
#include "aes.h"
/* #define FULL_UNROLL */
#define AES_SMALL_TABLES
extern const u32 Te0[256];
extern const u32 Te1[256];
extern const u32 Te2[256];
extern const u32 Te3[256];
extern const u32 Te4[256];
extern const u32 Td0[256];
extern const u32 Td1[256];
extern const u32 Td2[256];
extern const u32 Td3[256];
extern const u32 Td4[256];
extern const u32 rcon[10];
extern const u8 Td4s[256];
extern const u8 rcons[10];
#ifndef AES_SMALL_TABLES
#define RCON(i) rcon[(i)]
#define TE0(i) Te0[((i) >> 24) & 0xff]
#define TE1(i) Te1[((i) >> 16) & 0xff]
#define TE2(i) Te2[((i) >> 8) & 0xff]
#define TE3(i) Te3[(i) & 0xff]
#define TE41(i) (Te4[((i) >> 24) & 0xff] & 0xff000000)
#define TE42(i) (Te4[((i) >> 16) & 0xff] & 0x00ff0000)
#define TE43(i) (Te4[((i) >> 8) & 0xff] & 0x0000ff00)
#define TE44(i) (Te4[(i) & 0xff] & 0x000000ff)
#define TE421(i) (Te4[((i) >> 16) & 0xff] & 0xff000000)
#define TE432(i) (Te4[((i) >> 8) & 0xff] & 0x00ff0000)
#define TE443(i) (Te4[(i) & 0xff] & 0x0000ff00)
#define TE414(i) (Te4[((i) >> 24) & 0xff] & 0x000000ff)
#define TE411(i) (Te4[((i) >> 24) & 0xff] & 0xff000000)
#define TE422(i) (Te4[((i) >> 16) & 0xff] & 0x00ff0000)
#define TE433(i) (Te4[((i) >> 8) & 0xff] & 0x0000ff00)
#define TE444(i) (Te4[(i) & 0xff] & 0x000000ff)
#define TE4(i) (Te4[(i)] & 0x000000ff)
#define TD0(i) Td0[((i) >> 24) & 0xff]
#define TD1(i) Td1[((i) >> 16) & 0xff]
#define TD2(i) Td2[((i) >> 8) & 0xff]
#define TD3(i) Td3[(i) & 0xff]
#define TD41(i) (Td4[((i) >> 24) & 0xff] & 0xff000000)
#define TD42(i) (Td4[((i) >> 16) & 0xff] & 0x00ff0000)
#define TD43(i) (Td4[((i) >> 8) & 0xff] & 0x0000ff00)
#define TD44(i) (Td4[(i) & 0xff] & 0x000000ff)
#define TD0_(i) Td0[(i) & 0xff]
#define TD1_(i) Td1[(i) & 0xff]
#define TD2_(i) Td2[(i) & 0xff]
#define TD3_(i) Td3[(i) & 0xff]
#else /* AES_SMALL_TABLES */
#define RCON(i) (rcons[(i)] << 24)
static inline u32 rotr(u32 val, int bits)
{
return (val >> bits) | (val << (32 - bits));
}
#define TE0(i) Te0[((i) >> 24) & 0xff]
#define TE1(i) rotr(Te0[((i) >> 16) & 0xff], 8)
#define TE2(i) rotr(Te0[((i) >> 8) & 0xff], 16)
#define TE3(i) rotr(Te0[(i) & 0xff], 24)
#define TE41(i) ((Te0[((i) >> 24) & 0xff] << 8) & 0xff000000)
#define TE42(i) (Te0[((i) >> 16) & 0xff] & 0x00ff0000)
#define TE43(i) (Te0[((i) >> 8) & 0xff] & 0x0000ff00)
#define TE44(i) ((Te0[(i) & 0xff] >> 8) & 0x000000ff)
#define TE421(i) ((Te0[((i) >> 16) & 0xff] << 8) & 0xff000000)
#define TE432(i) (Te0[((i) >> 8) & 0xff] & 0x00ff0000)
#define TE443(i) (Te0[(i) & 0xff] & 0x0000ff00)
#define TE414(i) ((Te0[((i) >> 24) & 0xff] >> 8) & 0x000000ff)
#define TE411(i) ((Te0[((i) >> 24) & 0xff] << 8) & 0xff000000)
#define TE422(i) (Te0[((i) >> 16) & 0xff] & 0x00ff0000)
#define TE433(i) (Te0[((i) >> 8) & 0xff] & 0x0000ff00)
#define TE444(i) ((Te0[(i) & 0xff] >> 8) & 0x000000ff)
#define TE4(i) ((Te0[(i)] >> 8) & 0x000000ff)
#define TD0(i) Td0[((i) >> 24) & 0xff]
#define TD1(i) rotr(Td0[((i) >> 16) & 0xff], 8)
#define TD2(i) rotr(Td0[((i) >> 8) & 0xff], 16)
#define TD3(i) rotr(Td0[(i) & 0xff], 24)
#define TD41(i) (Td4s[((i) >> 24) & 0xff] << 24)
#define TD42(i) (Td4s[((i) >> 16) & 0xff] << 16)
#define TD43(i) (Td4s[((i) >> 8) & 0xff] << 8)
#define TD44(i) (Td4s[(i) & 0xff])
#define TD0_(i) Td0[(i) & 0xff]
#define TD1_(i) rotr(Td0[(i) & 0xff], 8)
#define TD2_(i) rotr(Td0[(i) & 0xff], 16)
#define TD3_(i) rotr(Td0[(i) & 0xff], 24)
#endif /* AES_SMALL_TABLES */
#ifdef _MSC_VER
#define SWAP(x) (_lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00)
#define GETU32(p) SWAP(*((u32 *)(p)))
#define PUTU32(ct, st) { *((u32 *)(ct)) = SWAP((st)); }
#else
#define GETU32(pt) (((u32)(pt)[0] << 24) ^ ((u32)(pt)[1] << 16) ^ \
((u32)(pt)[2] << 8) ^ ((u32)(pt)[3]))
#define PUTU32(ct, st) { \
(ct)[0] = (u8)((st) >> 24); (ct)[1] = (u8)((st) >> 16); \
(ct)[2] = (u8)((st) >> 8); (ct)[3] = (u8)(st); }
#endif
#define AES_PRIV_SIZE (4 * 4 * 15 + 4)
#define AES_PRIV_NR_POS (4 * 15)
int rijndaelKeySetupEnc(u32 rk[], const u8 cipherKey[], int keyBits);
#endif /* AES_I_H */
|
2301_81045437/rtl8852be
|
core/crypto/aes_i.h
|
C
|
agpl-3.0
| 4,228
|
/*
* AES SIV (RFC 5297)
* Copyright (c) 2013 Cozybit, Inc.
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef AES_SIV_H
#define AES_SIV_H
int aes_siv_encrypt(const u8 *key, size_t key_len,
const u8 *pw, size_t pwlen,
size_t num_elem, const u8 *addr[], const size_t *len,
u8 *out);
int aes_siv_decrypt(const u8 *key, size_t key_len,
const u8 *iv_crypt, size_t iv_c_len,
size_t num_elem, const u8 *addr[], const size_t *len,
u8 *out);
#endif /* AES_SIV_H */
|
2301_81045437/rtl8852be
|
core/crypto/aes_siv.h
|
C
|
agpl-3.0
| 565
|
/*
* AES-based functions
*
* - AES Key Wrap Algorithm (RFC3394)
* - One-Key CBC MAC (OMAC1) hash with AES-128 and AES-256
* - AES-128/192/256 CTR mode encryption
* - AES-128 EAX mode encryption/decryption
* - AES-128 CBC
* - AES-GCM
* - AES-CCM
*
* Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef AES_WRAP_H
#define AES_WRAP_H
int __must_check aes_wrap(const u8 *kek, size_t kek_len, int n, const u8 *plain,
u8 *cipher);
int __must_check aes_unwrap(const u8 *kek, size_t kek_len, int n,
const u8 *cipher, u8 *plain);
int __must_check omac1_aes_vector(const u8 *key, size_t key_len,
size_t num_elem, const u8 *addr[],
const size_t *len, u8 *mac);
int __must_check omac1_aes_128_vector(const u8 *key, size_t num_elem,
const u8 *addr[], const size_t *len,
u8 *mac);
int __must_check omac1_aes_128(const u8 *key, const u8 *data, size_t data_len,
u8 *mac);
int __must_check omac1_aes_256(const u8 *key, const u8 *data, size_t data_len,
u8 *mac);
int __must_check aes_128_encrypt_block(const u8 *key, const u8 *in, u8 *out);
int __must_check aes_ctr_encrypt(const u8 *key, size_t key_len, const u8 *nonce,
u8 *data, size_t data_len);
int __must_check aes_128_ctr_encrypt(const u8 *key, const u8 *nonce,
u8 *data, size_t data_len);
int __must_check aes_128_eax_encrypt(const u8 *key,
const u8 *nonce, size_t nonce_len,
const u8 *hdr, size_t hdr_len,
u8 *data, size_t data_len, u8 *tag);
int __must_check aes_128_eax_decrypt(const u8 *key,
const u8 *nonce, size_t nonce_len,
const u8 *hdr, size_t hdr_len,
u8 *data, size_t data_len, const u8 *tag);
int __must_check aes_128_cbc_encrypt(const u8 *key, const u8 *iv, u8 *data,
size_t data_len);
int __must_check aes_128_cbc_decrypt(const u8 *key, const u8 *iv, u8 *data,
size_t data_len);
int __must_check aes_gcm_ae(const u8 *key, size_t key_len,
const u8 *iv, size_t iv_len,
const u8 *plain, size_t plain_len,
const u8 *aad, size_t aad_len,
u8 *crypt, u8 *tag);
int __must_check aes_gcm_ad(const u8 *key, size_t key_len,
const u8 *iv, size_t iv_len,
const u8 *crypt, size_t crypt_len,
const u8 *aad, size_t aad_len, const u8 *tag,
u8 *plain);
int __must_check aes_gmac(const u8 *key, size_t key_len,
const u8 *iv, size_t iv_len,
const u8 *aad, size_t aad_len, u8 *tag);
int __must_check aes_ccm_ae(const u8 *key, size_t key_len, const u8 *nonce,
size_t M, const u8 *plain, size_t plain_len,
const u8 *aad, size_t aad_len, u8 *crypt, u8 *auth);
int __must_check aes_ccm_ad(const u8 *key, size_t key_len, const u8 *nonce,
size_t M, const u8 *crypt, size_t crypt_len,
const u8 *aad, size_t aad_len, const u8 *auth,
u8 *plain);
#endif /* AES_WRAP_H */
|
2301_81045437/rtl8852be
|
core/crypto/aes_wrap.h
|
C
|
agpl-3.0
| 2,975
|
/*
* CTR with CBC-MAC Protocol (CCMP)
* Copyright (c) 2010-2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "aes.h"
#include "aes_wrap.h"
#include "wlancrypto_wrap.h"
static void ccmp_aad_nonce(_adapter *padapter, const struct ieee80211_hdr *hdr, const u8 *data,
u8 *aad, size_t *aad_len, u8 *nonce)
{
u16 fc, stype, seq;
int qos = 0, addr4 = 0;
u8 *pos;
nonce[0] = 0;
fc = le_to_host16(hdr->frame_control);
stype = WLAN_FC_GET_STYPE(fc);
if ((fc & (WLAN_FC_TODS | WLAN_FC_FROMDS)) ==
(WLAN_FC_TODS | WLAN_FC_FROMDS))
addr4 = 1;
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_DATA) {
fc &= ~0x0070; /* Mask subtype bits */
if (stype & WLAN_FC_STYPE_QOS_DATA) {
const u8 *qc;
qos = 1;
fc &= ~WLAN_FC_ORDER;
qc = (const u8 *)hdr + 24;
if (addr4)
qc += ETH_ALEN;
nonce[0] = qc[0] & 0x0f;
}
} else if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT)
nonce[0] |= 0x10; /* Management */
fc &= ~(WLAN_FC_RETRY | WLAN_FC_PWRMGT | WLAN_FC_MOREDATA);
fc |= WLAN_FC_ISWEP;
WPA_PUT_LE16(aad, fc);
pos = aad + 2;
os_memcpy(pos, hdr->addr1, 3 * ETH_ALEN);
pos += 3 * ETH_ALEN;
seq = le_to_host16(hdr->seq_ctrl);
seq &= ~0xfff0; /* Mask Seq#; do not modify Frag# */
WPA_PUT_LE16(pos, seq);
pos += 2;
os_memcpy(pos, (u8 *)hdr + 24, addr4 * ETH_ALEN + qos * 2);
pos += addr4 * ETH_ALEN;
if (qos) {
pos[0] &= ~0x70;
/* only spp mode need to refer QoS bit7 */
if (padapter->registrypriv.amsdu_mode != RTW_AMSDU_MODE_SPP)
pos[0] &= ~0x80;
pos++;
*pos++ = 0x00;
}
*aad_len = pos - aad;
os_memcpy(nonce + 1, hdr->addr2, ETH_ALEN);
nonce[7] = data[7]; /* PN5 */
nonce[8] = data[6]; /* PN4 */
nonce[9] = data[5]; /* PN3 */
nonce[10] = data[4]; /* PN2 */
nonce[11] = data[1]; /* PN1 */
nonce[12] = data[0]; /* PN0 */
}
static void ccmp_aad_nonce_pv1(const u8 *hdr, const u8 *a1, const u8 *a2,
const u8 *a3, const u8 *pn,
u8 *aad, size_t *aad_len, u8 *nonce)
{
u16 fc, type;
u8 *pos;
nonce[0] = BIT(5); /* PV1 */
/* TODO: Priority for QMF; 0 is used for Data frames */
fc = WPA_GET_LE16(hdr);
type = (fc & (BIT(2) | BIT(3) | BIT(4))) >> 2;
if (type == 1)
nonce[0] |= 0x10; /* Management */
fc &= ~(BIT(10) | BIT(11) | BIT(13) | BIT(14) | BIT(15));
fc |= BIT(12);
WPA_PUT_LE16(aad, fc);
pos = aad + 2;
if (type == 0 || type == 3) {
const u8 *sc;
os_memcpy(pos, a1, ETH_ALEN);
pos += ETH_ALEN;
os_memcpy(pos, a2, ETH_ALEN);
pos += ETH_ALEN;
if (type == 0) {
/* Either A1 or A2 contains SID */
sc = hdr + 2 + 2 + ETH_ALEN;
} else {
/* Both A1 and A2 contain full addresses */
sc = hdr + 2 + 2 * ETH_ALEN;
}
/* SC with Sequence Number subfield (bits 4-15 of the Sequence
* Control field) masked to 0. */
*pos++ = *sc & 0x0f;
*pos++ = 0;
if (a3) {
os_memcpy(pos, a3, ETH_ALEN);
pos += ETH_ALEN;
}
}
*aad_len = pos - aad;
os_memcpy(nonce + 1, a2, ETH_ALEN);
nonce[7] = pn[5]; /* PN5 */
nonce[8] = pn[4]; /* PN4 */
nonce[9] = pn[3]; /* PN3 */
nonce[10] = pn[2]; /* PN2 */
nonce[11] = pn[1]; /* PN1 */
nonce[12] = pn[0]; /* PN0 */
}
u8 * ccmp_decrypt(_adapter *padapter, const u8 *tk, const struct ieee80211_hdr *hdr,
const u8 *data, size_t data_len, size_t *decrypted_len)
{
u8 aad[30], nonce[13];
size_t aad_len;
size_t mlen;
u8 *plain;
if (data_len < 8 + 8)
return NULL;
plain = os_malloc(data_len + AES_BLOCK_SIZE);
if (plain == NULL)
return NULL;
mlen = data_len - 8 - 8;
os_memset(aad, 0, sizeof(aad));
ccmp_aad_nonce(padapter, hdr, data, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP nonce", nonce, 13);
if (aes_ccm_ad(tk, 16, nonce, 8, data + 8, mlen, aad, aad_len,
data + 8 + mlen, plain) < 0) {
u16 seq_ctrl = le_to_host16(hdr->seq_ctrl);
wpa_printf(_MSG_INFO_, "Invalid CCMP MIC in frame: A1=" MACSTR
" A2=" MACSTR " A3=" MACSTR " seq=%u frag=%u",
MAC2STR(hdr->addr1), MAC2STR(hdr->addr2),
MAC2STR(hdr->addr3),
WLAN_GET_SEQ_SEQ(seq_ctrl),
WLAN_GET_SEQ_FRAG(seq_ctrl));
rtw_mfree(plain, data_len + AES_BLOCK_SIZE);
return NULL;
}
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP decrypted", plain, mlen);
*decrypted_len = mlen;
return plain;
}
void ccmp_get_pn(u8 *pn, const u8 *data)
{
pn[0] = data[7]; /* PN5 */
pn[1] = data[6]; /* PN4 */
pn[2] = data[5]; /* PN3 */
pn[3] = data[4]; /* PN2 */
pn[4] = data[1]; /* PN1 */
pn[5] = data[0]; /* PN0 */
}
u8 * ccmp_encrypt(_adapter *padapter, const u8 *tk, u8 *frame, size_t len, size_t hdrlen, u8 *qos,
u8 *pn, int keyid, size_t *encrypted_len)
{
u8 aad[30], nonce[13];
size_t aad_len, plen;
u8 *crypt, *pos, *pdata;
struct ieee80211_hdr *hdr;
if (len < hdrlen || hdrlen < 24)
return NULL;
plen = len - hdrlen;
crypt = os_malloc(hdrlen + 8 + plen + 8 + AES_BLOCK_SIZE);
if (crypt == NULL)
return NULL;
if (pn == NULL) {
os_memcpy(crypt, frame, hdrlen + 8);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen + 8;
pdata = frame + hdrlen + 8;
} else {
os_memcpy(crypt, frame, hdrlen);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen;
*pos++ = pn[5]; /* PN0 */
*pos++ = pn[4]; /* PN1 */
*pos++ = 0x00; /* Rsvd */
*pos++ = 0x20 | (keyid << 6);
*pos++ = pn[3]; /* PN2 */
*pos++ = pn[2]; /* PN3 */
*pos++ = pn[1]; /* PN4 */
*pos++ = pn[0]; /* PN5 */
pdata = frame + hdrlen;
}
os_memset(aad, 0, sizeof(aad));
ccmp_aad_nonce(padapter, hdr, crypt + hdrlen, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP nonce", nonce, 13);
if (aes_ccm_ae(tk, 16, nonce, 8, pdata, plen, aad, aad_len,
pos, pos + plen) < 0) {
rtw_mfree(crypt, hdrlen + 8 + plen + 8 + AES_BLOCK_SIZE);
return NULL;
}
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP encrypted", crypt + hdrlen + 8, plen);
*encrypted_len = hdrlen + 8 + plen + 8;
return crypt;
}
u8 * ccmp_encrypt_pv1(const u8 *tk, const u8 *a1, const u8 *a2, const u8 *a3,
const u8 *frame, size_t len,
size_t hdrlen, const u8 *pn, int keyid,
size_t *encrypted_len)
{
u8 aad[24], nonce[13];
size_t aad_len, plen;
u8 *crypt, *pos;
struct ieee80211_hdr *hdr;
if (len < hdrlen || hdrlen < 12)
return NULL;
plen = len - hdrlen;
crypt = os_malloc(hdrlen + plen + 8 + AES_BLOCK_SIZE);
if (crypt == NULL)
return NULL;
os_memcpy(crypt, frame, hdrlen);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(BIT(12)); /* Protected Frame */
pos = crypt + hdrlen;
os_memset(aad, 0, sizeof(aad));
ccmp_aad_nonce_pv1(crypt, a1, a2, a3, pn, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP nonce", nonce, sizeof(nonce));
if (aes_ccm_ae(tk, 16, nonce, 8, frame + hdrlen, plen, aad, aad_len,
pos, pos + plen) < 0) {
rtw_mfree(crypt, hdrlen + plen + 8 + AES_BLOCK_SIZE);
return NULL;
}
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP encrypted", crypt + hdrlen, plen);
*encrypted_len = hdrlen + plen + 8;
return crypt;
}
u8 * ccmp_256_decrypt(_adapter *padapter, const u8 *tk, const struct ieee80211_hdr *hdr,
const u8 *data, size_t data_len, size_t *decrypted_len)
{
u8 aad[30], nonce[13];
size_t aad_len;
size_t mlen;
u8 *plain;
if (data_len < 8 + 16)
return NULL;
plain = os_malloc(data_len + AES_BLOCK_SIZE);
if (plain == NULL)
return NULL;
mlen = data_len - 8 - 16;
os_memset(aad, 0, sizeof(aad));
ccmp_aad_nonce(padapter, hdr, data, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 nonce", nonce, 13);
if (aes_ccm_ad(tk, 32, nonce, 16, data + 8, mlen, aad, aad_len,
data + 8 + mlen, plain) < 0) {
u16 seq_ctrl = le_to_host16(hdr->seq_ctrl);
wpa_printf(_MSG_INFO_, "Invalid CCMP-256 MIC in frame: A1=" MACSTR
" A2=" MACSTR " A3=" MACSTR " seq=%u frag=%u",
MAC2STR(hdr->addr1), MAC2STR(hdr->addr2),
MAC2STR(hdr->addr3),
WLAN_GET_SEQ_SEQ(seq_ctrl),
WLAN_GET_SEQ_FRAG(seq_ctrl));
rtw_mfree(plain, data_len + AES_BLOCK_SIZE);
return NULL;
}
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 decrypted", plain, mlen);
*decrypted_len = mlen;
return plain;
}
u8 * ccmp_256_encrypt(_adapter *padapter, const u8 *tk, u8 *frame, size_t len, size_t hdrlen,
u8 *qos, u8 *pn, int keyid, size_t *encrypted_len)
{
u8 aad[30], nonce[13];
size_t aad_len, plen;
u8 *crypt, *pos, *pdata;
struct ieee80211_hdr *hdr;
if (len < hdrlen || hdrlen < 24)
return NULL;
plen = len - hdrlen;
crypt = os_malloc(hdrlen + 8 + plen + 16 + AES_BLOCK_SIZE);
if (crypt == NULL)
return NULL;
if (pn == NULL) {
os_memcpy(crypt, frame, hdrlen + 8);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen + 8;
pdata = frame + hdrlen + 8;
} else {
os_memcpy(crypt, frame, hdrlen);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen;
*pos++ = pn[5]; /* PN0 */
*pos++ = pn[4]; /* PN1 */
*pos++ = 0x00; /* Rsvd */
*pos++ = 0x20 | (keyid << 6);
*pos++ = pn[3]; /* PN2 */
*pos++ = pn[2]; /* PN3 */
*pos++ = pn[1]; /* PN4 */
*pos++ = pn[0]; /* PN5 */
pdata = frame + hdrlen;
}
os_memset(aad, 0, sizeof(aad));
ccmp_aad_nonce(padapter, hdr, crypt + hdrlen, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 nonce", nonce, 13);
if (aes_ccm_ae(tk, 32, nonce, 16, pdata, plen, aad, aad_len,
pos, pos + plen) < 0) {
rtw_mfree(crypt, hdrlen + 8 + plen + 16 + AES_BLOCK_SIZE);
return NULL;
}
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 encrypted", crypt + hdrlen + 8,
plen);
*encrypted_len = hdrlen + 8 + plen + 16;
return crypt;
}
#if 0 //RTW_PHL_TX: mark un-finished codes for reading
void core_ccmp_encrypt(const u8 *tk, uint hdrlen, u8 *phdr, uint datalen, u8 *pdata,
u8 *qos, u8 *pn, int keyid, size_t *encrypted_len)
{
u8 aad[30], nonce[13];
size_t aad_len;
u8 *crypt, *pos;
struct ieee80211_hdr *hdr;
size_t enc_hdrlen, enc_datalen = 0;
if (hdrlen < 24)
return;
enc_hdrlen = hdrlen + 8;
enc_datalen = datalen + 8;
crypt = os_malloc(enc_hdrlen + enc_hdrlen + AES_BLOCK_SIZE);
if (crypt == NULL)
return;
if (pn == NULL) {
os_memcpy(crypt, phdr, hdrlen + 8);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen + 8;
} else {
os_memcpy(crypt, phdr, hdrlen);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen;
*pos++ = pn[5]; /* PN0 */
*pos++ = pn[4]; /* PN1 */
*pos++ = 0x00; /* Rsvd */
*pos++ = 0x20 | (keyid << 6);
*pos++ = pn[3]; /* PN2 */
*pos++ = pn[2]; /* PN3 */
*pos++ = pn[1]; /* PN4 */
*pos++ = pn[0]; /* PN5 */
}
os_memset(aad, 0, sizeof(aad));
ccmp_aad_nonce(hdr, crypt + hdrlen, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP nonce", nonce, 13);
if (aes_ccm_ae(tk, 16, nonce, 8, pdata, datalen, aad, aad_len,
pos, pos + datalen) < 0) {
rtw_mfree(crypt, hdrlen + 8 + datalen + 8 + AES_BLOCK_SIZE);
return;
}
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP encrypted", crypt + enc_hdrlen, datalen);
/* Copy @enc back to @frame and free @enc */
_rtw_memcpy(phdr, crypt, enc_hdrlen);
_rtw_memcpy(pdata, crypt + enc_hdrlen, enc_datalen);
rtw_mfree(crypt, enc_hdrlen+enc_datalen+AES_BLOCK_SIZE);
return;
}
void core_ccmp_256_encrypt(const u8 *tk, uint hdrlen, u8 *phdr, uint datalen, u8 *pdata,
u8 *qos, u8 *pn, int keyid, size_t *encrypted_len)
{
u8 aad[30], nonce[13];
size_t aad_len;
u8 *crypt, *pos;
struct ieee80211_hdr *hdr;
size_t enc_hdrlen, enc_datalen = 0;
if (hdrlen < 24)
return;
enc_hdrlen = hdrlen + 8;
enc_datalen = datalen + 16;
crypt = os_malloc(enc_hdrlen + enc_hdrlen + AES_BLOCK_SIZE);
if (crypt == NULL)
return;
if (pn == NULL) {
os_memcpy(crypt, phdr, hdrlen + 8);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen + 8;
} else {
os_memcpy(crypt, phdr, hdrlen);
hdr = (struct ieee80211_hdr *) crypt;
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
pos = crypt + hdrlen;
*pos++ = pn[5]; /* PN0 */
*pos++ = pn[4]; /* PN1 */
*pos++ = 0x00; /* Rsvd */
*pos++ = 0x20 | (keyid << 6);
*pos++ = pn[3]; /* PN2 */
*pos++ = pn[2]; /* PN3 */
*pos++ = pn[1]; /* PN4 */
*pos++ = pn[0]; /* PN5 */
}
os_memset(aad, 0, sizeof(aad));
ccmp_aad_nonce(hdr, crypt + hdrlen, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 nonce", nonce, 13);
if (aes_ccm_ae(tk, 32, nonce, 16, pdata, datalen, aad, aad_len,
pos, pos + datalen) < 0) {
rtw_mfree(crypt, enc_hdrlen + enc_datalen + AES_BLOCK_SIZE);
return;
}
wpa_hexdump(_MSG_EXCESSIVE_, "CCMP-256 encrypted", crypt + enc_hdrlen, datalen);
_rtw_memcpy(phdr, crypt, enc_hdrlen);
_rtw_memcpy(pdata, crypt + enc_hdrlen, enc_datalen);
rtw_mfree(crypt, enc_hdrlen+enc_datalen+AES_BLOCK_SIZE);
}
#endif
|
2301_81045437/rtl8852be
|
core/crypto/ccmp.c
|
C
|
agpl-3.0
| 13,510
|
/*
* GCM with GMAC Protocol (GCMP)
* Copyright (c) 2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "aes.h"
#include "aes_wrap.h"
#include "wlancrypto_wrap.h"
static void gcmp_aad_nonce(_adapter * padapter, const struct ieee80211_hdr *hdr, const u8 *data,
u8 *aad, size_t *aad_len, u8 *nonce)
{
u16 fc, stype, seq;
int qos = 0, addr4 = 0;
u8 *pos;
fc = le_to_host16(hdr->frame_control);
stype = WLAN_FC_GET_STYPE(fc);
if ((fc & (WLAN_FC_TODS | WLAN_FC_FROMDS)) ==
(WLAN_FC_TODS | WLAN_FC_FROMDS))
addr4 = 1;
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_DATA) {
fc &= ~0x0070; /* Mask subtype bits */
if (stype & WLAN_FC_STYPE_QOS_DATA) {
const u8 *qc;
qos = 1;
fc &= ~WLAN_FC_ORDER;
qc = (const u8 *)hdr + 24;
if (addr4)
qc += ETH_ALEN;
}
}
fc &= ~(WLAN_FC_RETRY | WLAN_FC_PWRMGT | WLAN_FC_MOREDATA);
WPA_PUT_LE16(aad, fc);
pos = aad + 2;
os_memcpy(pos, hdr->addr1, 3 * ETH_ALEN);
pos += 3 * ETH_ALEN;
seq = le_to_host16(hdr->seq_ctrl);
seq &= ~0xfff0; /* Mask Seq#; do not modify Frag# */
WPA_PUT_LE16(pos, seq);
pos += 2;
wpa_printf(_MSG_INFO_, "pos - aad = %u, qos(%d)\n", (pos - aad), qos);
os_memcpy(pos, (u8 *)hdr + 24, addr4 * ETH_ALEN + qos * 2);
pos += addr4 * ETH_ALEN;
if (qos) {
pos[0] &= ~0x70;
/* only spp mode need to refer QoS bit7 */
if (padapter->registrypriv.amsdu_mode != RTW_AMSDU_MODE_SPP)
pos[0] &= ~0x80;
pos++;
*pos++ = 0x00;
}
wpa_printf(_MSG_INFO_, "pos - aad = %u\n", (pos - aad));
*aad_len = pos - aad;
os_memcpy(nonce, hdr->addr2, ETH_ALEN);
nonce[6] = data[7]; /* PN5 */
nonce[7] = data[6]; /* PN4 */
nonce[8] = data[5]; /* PN3 */
nonce[9] = data[4]; /* PN2 */
nonce[10] = data[1]; /* PN1 */
nonce[11] = data[0]; /* PN0 */
}
/**
* gcmp_decrypt -
* @tk: the temporal key
* @tk_len: length of @tk
* @hdr: the mac header
* @data: payload after mac header (PN + enc_data + MIC)
* @data_len: length of @data (PN + enc_data + MIC)
* @decrypted_len: length of the data decrypted
*/
u8 * gcmp_decrypt(_adapter *padapter, const u8 *tk, size_t tk_len, const struct ieee80211_hdr *hdr,
const u8 *data, size_t data_len, size_t *decrypted_len)
{
u8 aad[30], nonce[12], *plain;
size_t aad_len, mlen;
const u8 *m;
if (data_len < 8 + 16)
return NULL;
plain = os_malloc(data_len + AES_BLOCK_SIZE);
if (plain == NULL)
return NULL;
m = data + 8;
mlen = data_len - 8 - 16;
os_memset(aad, 0, sizeof(aad));
gcmp_aad_nonce(padapter, hdr, data, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "GCMP AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "GCMP nonce", nonce, sizeof(nonce));
if (aes_gcm_ad(tk, tk_len, nonce, sizeof(nonce), m, mlen, aad, aad_len,
m + mlen, plain) < 0) {
u16 seq_ctrl = le_to_host16(hdr->seq_ctrl);
wpa_printf(_MSG_INFO_, "Invalid GCMP frame: A1=" MACSTR
" A2=" MACSTR " A3=" MACSTR " seq=%u frag=%u",
MAC2STR(hdr->addr1), MAC2STR(hdr->addr2),
MAC2STR(hdr->addr3),
WLAN_GET_SEQ_SEQ(seq_ctrl),
WLAN_GET_SEQ_FRAG(seq_ctrl));
rtw_mfree(plain, data_len + AES_BLOCK_SIZE);
return NULL;
}
*decrypted_len = mlen;
return plain;
}
/**
* gcmp_encrypt -
* @tk: the temporal key
* @tk_len: length of @tk
* @frame: the point to mac header, the frame including mac header and payload,
* if @pn is NULL, then the frame including pn
* @len: length of @frame
* length = mac header + payload
* @hdrlen: length of the mac header
* @qos: pointer to the QOS field of the frame
* @pn: packet number
* @keyid: key id
* @encrypted_len: length of the encrypted frame
* including mac header, pn, payload and MIC
*/
u8 * gcmp_encrypt(_adapter *padapter, const u8 *tk, size_t tk_len, const u8 *frame, size_t len,
size_t hdrlen, const u8 *qos,
const u8 *pn, int keyid, size_t *encrypted_len)
{
u8 aad[30], nonce[12], *crypt, *pos;
const u8 *pdata;
size_t aad_len, plen;
struct ieee80211_hdr *hdr;
if (len < hdrlen || hdrlen < 24)
return NULL;
plen = len - hdrlen;
crypt = os_malloc(hdrlen + 8 + plen + 16 + AES_BLOCK_SIZE);
if (crypt == NULL)
return NULL;
if (pn == NULL) {
os_memcpy(crypt, frame, hdrlen + 8);
hdr = (struct ieee80211_hdr *)crypt;
pos = crypt + hdrlen + 8;
pdata = frame + hdrlen + 8;
} else {
os_memcpy(crypt, frame, hdrlen);
hdr = (struct ieee80211_hdr *)crypt;
pos = crypt + hdrlen;
*pos++ = pn[5]; /* PN0 */
*pos++ = pn[4]; /* PN1 */
*pos++ = 0x00; /* Rsvd */
*pos++ = 0x20 | (keyid << 6);
*pos++ = pn[3]; /* PN2 */
*pos++ = pn[2]; /* PN3 */
*pos++ = pn[1]; /* PN4 */
*pos++ = pn[0]; /* PN5 */
pdata = frame + hdrlen;
}
os_memset(aad, 0, sizeof(aad));
gcmp_aad_nonce(padapter, hdr, crypt + hdrlen, aad, &aad_len, nonce);
wpa_hexdump(_MSG_EXCESSIVE_, "GCMP AAD", aad, aad_len);
wpa_hexdump(_MSG_EXCESSIVE_, "GCMP nonce", nonce, sizeof(nonce));
if (aes_gcm_ae(tk, tk_len, nonce, sizeof(nonce), pdata, plen,
aad, aad_len, pos, pos + plen) < 0) {
rtw_mfree(crypt, hdrlen + 8 + plen + 16 + AES_BLOCK_SIZE);
return NULL;
}
wpa_hexdump(_MSG_EXCESSIVE_, "GCMP MIC", pos + plen, 16);
wpa_hexdump(_MSG_EXCESSIVE_, "GCMP encrypted", pos, plen);
*encrypted_len = hdrlen + 8 + plen + 16;
return crypt;
}
|
2301_81045437/rtl8852be
|
core/crypto/gcmp.c
|
C
|
agpl-3.0
| 5,360
|
#include "rtw_crypto_wrap.h"
#ifndef DEBUG_CRYPTO
#define DEBUG_CRYPTO 0
#endif /* DEBUG_CRYTO */
int os_memcmp(const void *s1, const void *s2, size_t n)
{
return _rtw_memcmp2(s1, s2, n);
}
int os_memcmp_const(const void *a, const void *b, size_t len)
{
const u8 *aa = a;
const u8 *bb = b;
size_t i;
u8 res;
for (res = 0, i = 0; i < len; i++)
res |= aa[i] ^ bb[i];
return res;
}
void* os_memdup(const void *src, u32 sz)
{
void *r = rtw_malloc(sz);
if (r && src)
_rtw_memcpy(r, src, sz);
return r;
}
size_t os_strlen(const char *s)
{
const char *p = s;
while (*p)
p++;
return p - s;
}
void forced_memzero(void *ptr, size_t len)
{
_rtw_memset(ptr, 0, len);
}
void bin_clear_free(void *bin, size_t len)
{
if (bin) {
forced_memzero(bin, len);
rtw_mfree(bin, len);
}
}
void wpa_printf(int level, const char *fmt, ...)
{
#if DEBUG_CRYPTO
#define MSG_LEN 100
va_list args;
u8 buf[MSG_LEN] = { 0 };
int err;
va_start(args, fmt);
err = vsnprintf(buf, MSG_LEN, fmt, args);
va_end(args);
RTW_INFO("%s", buf);
#undef MSG_LEN
#endif /* DEBUG_CRYPTO */
}
void wpa_hexdump(int level, const char *title, const void *buf, size_t len)
{
#if DEBUG_CRYPTO
RTW_INFO_DUMP((u8 *)title, buf, len);
#endif /* DEBUG_CRYPTO */
}
void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len)
{
#if DEBUG_CRYPTO
RTW_INFO_DUMP((u8 *)title, buf, len);
#endif /* DEBUG_CRYPTO */
}
|
2301_81045437/rtl8852be
|
core/crypto/rtw_crypto_wrap.c
|
C
|
agpl-3.0
| 1,418
|
#ifndef RTW_CRYTO_WRAP_H
#define RTW_CRYTO_WRAP_H
#include <drv_types.h>
#define TEST_FAIL() 0
#define os_memset _rtw_memset
#define os_memcpy _rtw_memcpy
#define os_malloc rtw_malloc
#define le_to_host16 le16_to_cpu
#define host_to_le16 cpu_to_le16
#define WPA_PUT_LE16 RTW_PUT_LE16
#define WPA_GET_LE16 RTW_GET_LE16
#define WPA_PUT_LE32 RTW_PUT_LE32
#define WPA_GET_LE32 RTW_GET_LE32
#define WPA_PUT_LE64 RTW_PUT_LE64
#define WPA_GET_LE64 RTW_GET_LE64
#define WPA_PUT_BE16 RTW_PUT_BE16
#define WPA_GET_BE16 RTW_GET_BE16
#define WPA_PUT_BE32 RTW_PUT_BE32
#define WPA_GET_BE32 RTW_GET_BE32
#define WPA_PUT_BE64 RTW_PUT_BE64
#define WPA_GET_BE64 RTW_GET_BE64
#ifndef MAC2STR
#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
#endif
#define WLAN_FC_PVER 0x0003
#define WLAN_FC_TODS 0x0100
#define WLAN_FC_FROMDS 0x0200
#define WLAN_FC_MOREFRAG 0x0400
#define WLAN_FC_RETRY 0x0800
#define WLAN_FC_PWRMGT 0x1000
#define WLAN_FC_MOREDATA 0x2000
#define WLAN_FC_ISWEP 0x4000
#define WLAN_FC_ORDER 0x8000
#define WLAN_FC_TYPE_DATA RTW_IEEE80211_FTYPE_DATA
#define WLAN_FC_TYPE_MGMT RTW_IEEE80211_FTYPE_MGMT
#define WLAN_FC_STYPE_QOS_DATA RTW_IEEE80211_STYPE_QOS_DATA
enum {
_MSG_EXCESSIVE_, _MSG_MSGDUMP_, _MSG_DEBUG_, _MSG_INFO_, _MSG_WARNING_, _MSG_ERROR_
};
int os_memcmp(const void *s1, const void *s2, size_t n);
int os_memcmp_const(const void *a, const void *b, size_t len);
void* os_memdup(const void *src, u32 sz);
size_t os_strlen(const char *s);
void forced_memzero(void *ptr, size_t len);
void bin_clear_free(void *bin, size_t len);
void wpa_printf(int level, const char *fmt, ...);
void wpa_hexdump(int level, const char *title, const void *buf, size_t len);
void wpa_hexdump_key(int level, const char *title, const void *buf, size_t len);
#endif /* RTW_CRYTO_WRAP_H */
|
2301_81045437/rtl8852be
|
core/crypto/rtw_crypto_wrap.h
|
C
|
agpl-3.0
| 1,860
|
/*
* SHA-256 hash implementation and interface functions
* Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
//#include "common.h"
#include "sha256.h"
#include "sha256_i.h"
//#include "crypto.h"
#include "wlancrypto_wrap.h"
/**
* sha256_vector - SHA256 hash for data vector
* @num_elem: Number of elements in the data vector
* @addr: Pointers to the data areas
* @len: Lengths of the data blocks
* @mac: Buffer for the hash
* Returns: 0 on success, -1 of failure
*/
int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
u8 *mac)
{
struct _sha256_state ctx;
size_t i;
if (TEST_FAIL())
return -1;
_sha256_init(&ctx);
for (i = 0; i < num_elem; i++)
if (sha256_process(&ctx, addr[i], len[i]))
return -1;
if (sha256_done(&ctx, mac))
return -1;
return 0;
}
/* ===== start - public domain SHA256 implementation ===== */
/* This is based on SHA256 implementation in LibTomCrypt that was released into
* public domain by Tom St Denis. */
/* the K array */
static const unsigned long K[64] = {
0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,
0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,
0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,
0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,
0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
};
/* Various logical functions */
#define RORc(x, y) \
( ((((unsigned long) (x) & 0xFFFFFFFFUL) >> (unsigned long) ((y) & 31)) | \
((unsigned long) (x) << (unsigned long) (32 - ((y) & 31)))) & 0xFFFFFFFFUL)
#define Ch(x,y,z) (z ^ (x & (y ^ z)))
#define Maj(x,y,z) (((x | y) & z) | (x & y))
#define S(x, n) RORc((x), (n))
#define R(x, n) (((x)&0xFFFFFFFFUL)>>(n))
#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
#ifndef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
/* compress 512-bits */
static int sha256_compress(struct _sha256_state *md, unsigned char *buf)
{
u32 S[8], W[64], t0, t1;
u32 t;
int i;
/* copy state into S */
for (i = 0; i < 8; i++) {
S[i] = md->state[i];
}
/* copy the state into 512-bits into W[0..15] */
for (i = 0; i < 16; i++)
W[i] = WPA_GET_BE32(buf + (4 * i));
/* fill W[16..63] */
for (i = 16; i < 64; i++) {
W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) +
W[i - 16];
}
/* Compress */
#define RND(a,b,c,d,e,f,g,h,i) \
t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
t1 = Sigma0(a) + Maj(a, b, c); \
d += t0; \
h = t0 + t1;
for (i = 0; i < 64; ++i) {
RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4];
S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t;
}
/* feedback */
for (i = 0; i < 8; i++) {
md->state[i] = md->state[i] + S[i];
}
return 0;
}
/* Initialize the hash state */
void _sha256_init(struct _sha256_state *md)
{
md->curlen = 0;
md->length = 0;
md->state[0] = 0x6A09E667UL;
md->state[1] = 0xBB67AE85UL;
md->state[2] = 0x3C6EF372UL;
md->state[3] = 0xA54FF53AUL;
md->state[4] = 0x510E527FUL;
md->state[5] = 0x9B05688CUL;
md->state[6] = 0x1F83D9ABUL;
md->state[7] = 0x5BE0CD19UL;
}
/**
Process a block of memory though the hash
@param md The hash state
@param in The data to hash
@param inlen The length of the data (octets)
@return CRYPT_OK if successful
*/
int sha256_process(struct _sha256_state *md, const unsigned char *in,
unsigned long inlen)
{
unsigned long n;
if (md->curlen >= sizeof(md->buf))
return -1;
while (inlen > 0) {
if (md->curlen == 0 && inlen >= SHA256_BLOCK_SIZE) {
if (sha256_compress(md, (unsigned char *) in) < 0)
return -1;
md->length += SHA256_BLOCK_SIZE * 8;
in += SHA256_BLOCK_SIZE;
inlen -= SHA256_BLOCK_SIZE;
} else {
n = MIN(inlen, (SHA256_BLOCK_SIZE - md->curlen));
os_memcpy(md->buf + md->curlen, in, n);
md->curlen += n;
in += n;
inlen -= n;
if (md->curlen == SHA256_BLOCK_SIZE) {
if (sha256_compress(md, md->buf) < 0)
return -1;
md->length += 8 * SHA256_BLOCK_SIZE;
md->curlen = 0;
}
}
}
return 0;
}
/**
Terminate the hash to get the digest
@param md The hash state
@param out [out] The destination of the hash (32 bytes)
@return CRYPT_OK if successful
*/
int sha256_done(struct _sha256_state *md, unsigned char *out)
{
int i;
if (md->curlen >= sizeof(md->buf))
return -1;
/* increase the length of the message */
md->length += md->curlen * 8;
/* append the '1' bit */
md->buf[md->curlen++] = (unsigned char) 0x80;
/* if the length is currently above 56 bytes we append zeros
* then compress. Then we can fall back to padding zeros and length
* encoding like normal.
*/
if (md->curlen > 56) {
while (md->curlen < SHA256_BLOCK_SIZE) {
md->buf[md->curlen++] = (unsigned char) 0;
}
sha256_compress(md, md->buf);
md->curlen = 0;
}
/* pad up to 56 bytes of zeroes */
while (md->curlen < 56) {
md->buf[md->curlen++] = (unsigned char) 0;
}
/* store length */
WPA_PUT_BE64(md->buf + 56, md->length);
sha256_compress(md, md->buf);
/* copy output */
for (i = 0; i < 8; i++)
WPA_PUT_BE32(out + (4 * i), md->state[i]);
return 0;
}
/* ===== end - public domain SHA256 implementation ===== */
|
2301_81045437/rtl8852be
|
core/crypto/sha256-internal.c
|
C
|
agpl-3.0
| 6,187
|
/*
* SHA256-based PRF (IEEE 802.11r)
* Copyright (c) 2003-2016, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
//#include "common.h"
#include "sha256.h"
//#include "crypto.h"
#include "wlancrypto_wrap.h"
/**
* sha256_prf - SHA256-based Pseudo-Random Function (IEEE 802.11r, 8.5.1.5.2)
* @key: Key for PRF
* @key_len: Length of the key in bytes
* @label: A unique label for each purpose of the PRF
* @data: Extra data to bind into the key
* @data_len: Length of the data
* @buf: Buffer for the generated pseudo-random key
* @buf_len: Number of bytes of key to generate
* Returns: 0 on success, -1 on failure
*
* This function is used to derive new, cryptographically separate keys from a
* given key.
*/
int sha256_prf(const u8 *key, size_t key_len, const char *label,
const u8 *data, size_t data_len, u8 *buf, size_t buf_len)
{
return sha256_prf_bits(key, key_len, label, data, data_len, buf,
buf_len * 8);
}
/**
* sha256_prf_bits - IEEE Std 802.11-2012, 11.6.1.7.2 Key derivation function
* @key: Key for KDF
* @key_len: Length of the key in bytes
* @label: A unique label for each purpose of the PRF
* @data: Extra data to bind into the key
* @data_len: Length of the data
* @buf: Buffer for the generated pseudo-random key
* @buf_len: Number of bits of key to generate
* Returns: 0 on success, -1 on failure
*
* This function is used to derive new, cryptographically separate keys from a
* given key. If the requested buf_len is not divisible by eight, the least
* significant 1-7 bits of the last octet in the output are not part of the
* requested output.
*/
int sha256_prf_bits(const u8 *key, size_t key_len, const char *label,
const u8 *data, size_t data_len, u8 *buf,
size_t buf_len_bits)
{
u16 counter = 1;
size_t pos, plen;
u8 hash[SHA256_MAC_LEN];
const u8 *addr[4];
size_t len[4];
u8 counter_le[2], length_le[2];
size_t buf_len = (buf_len_bits + 7) / 8;
addr[0] = counter_le;
len[0] = 2;
addr[1] = (u8 *) label;
len[1] = os_strlen(label);
addr[2] = data;
len[2] = data_len;
addr[3] = length_le;
len[3] = sizeof(length_le);
WPA_PUT_LE16(length_le, buf_len_bits);
pos = 0;
while (pos < buf_len) {
plen = buf_len - pos;
WPA_PUT_LE16(counter_le, counter);
if (plen >= SHA256_MAC_LEN) {
if (hmac_sha256_vector(key, key_len, 4, addr, len,
&buf[pos]) < 0)
return -1;
pos += SHA256_MAC_LEN;
} else {
if (hmac_sha256_vector(key, key_len, 4, addr, len,
hash) < 0)
return -1;
os_memcpy(&buf[pos], hash, plen);
pos += plen;
break;
}
counter++;
}
/*
* Mask out unused bits in the last octet if it does not use all the
* bits.
*/
if (buf_len_bits % 8) {
u8 mask = 0xff << (8 - buf_len_bits % 8);
buf[pos - 1] &= mask;
}
forced_memzero(hash, sizeof(hash));
return 0;
}
|
2301_81045437/rtl8852be
|
core/crypto/sha256-prf.c
|
C
|
agpl-3.0
| 2,945
|
/*
* SHA-256 hash implementation and interface functions
* Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "rtw_crypto_wrap.h"
#include "sha256.h"
//#include "crypto.h"
#include "wlancrypto_wrap.h"
/**
* hmac_sha256_vector - HMAC-SHA256 over data vector (RFC 2104)
* @key: Key for HMAC operations
* @key_len: Length of the key in bytes
* @num_elem: Number of elements in the data vector
* @addr: Pointers to the data areas
* @len: Lengths of the data blocks
* @mac: Buffer for the hash (32 bytes)
* Returns: 0 on success, -1 on failure
*/
int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
const u8 *addr[], const size_t *len, u8 *mac)
{
unsigned char k_pad[64]; /* padding - key XORd with ipad/opad */
unsigned char tk[32];
const u8 *_addr[6];
size_t _len[6], i;
if (num_elem > 5) {
/*
* Fixed limit on the number of fragments to avoid having to
* allocate memory (which could fail).
*/
return -1;
}
/* if key is longer than 64 bytes reset it to key = SHA256(key) */
if (key_len > 64) {
if (sha256_vector(1, &key, &key_len, tk) < 0)
return -1;
key = tk;
key_len = 32;
}
/* the HMAC_SHA256 transform looks like:
*
* SHA256(K XOR opad, SHA256(K XOR ipad, text))
*
* where K is an n byte key
* ipad is the byte 0x36 repeated 64 times
* opad is the byte 0x5c repeated 64 times
* and text is the data being protected */
/* start out by storing key in ipad */
os_memset(k_pad, 0, sizeof(k_pad));
os_memcpy(k_pad, key, key_len);
/* XOR key with ipad values */
for (i = 0; i < 64; i++)
k_pad[i] ^= 0x36;
/* perform inner SHA256 */
_addr[0] = k_pad;
_len[0] = 64;
for (i = 0; i < num_elem; i++) {
_addr[i + 1] = addr[i];
_len[i + 1] = len[i];
}
if (sha256_vector(1 + num_elem, _addr, _len, mac) < 0)
return -1;
os_memset(k_pad, 0, sizeof(k_pad));
os_memcpy(k_pad, key, key_len);
/* XOR key with opad values */
for (i = 0; i < 64; i++)
k_pad[i] ^= 0x5c;
/* perform outer SHA256 */
_addr[0] = k_pad;
_len[0] = 64;
_addr[1] = mac;
_len[1] = SHA256_MAC_LEN;
return sha256_vector(2, _addr, _len, mac);
}
/**
* hmac_sha256 - HMAC-SHA256 over data buffer (RFC 2104)
* @key: Key for HMAC operations
* @key_len: Length of the key in bytes
* @data: Pointers to the data area
* @data_len: Length of the data area
* @mac: Buffer for the hash (32 bytes)
* Returns: 0 on success, -1 on failure
*/
int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
size_t data_len, u8 *mac)
{
return hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
}
|
2301_81045437/rtl8852be
|
core/crypto/sha256.c
|
C
|
agpl-3.0
| 2,718
|
/*
* SHA256 hash implementation and interface functions
* Copyright (c) 2003-2016, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef SHA256_H
#define SHA256_H
#define SHA256_MAC_LEN 32
int hmac_sha256_vector(const u8 *key, size_t key_len, size_t num_elem,
const u8 *addr[], const size_t *len, u8 *mac);
int hmac_sha256(const u8 *key, size_t key_len, const u8 *data,
size_t data_len, u8 *mac);
int sha256_prf(const u8 *key, size_t key_len, const char *label,
const u8 *data, size_t data_len, u8 *buf, size_t buf_len);
int sha256_prf_bits(const u8 *key, size_t key_len, const char *label,
const u8 *data, size_t data_len, u8 *buf,
size_t buf_len_bits);
void tls_prf_sha256(const u8 *secret, size_t secret_len,
const char *label, const u8 *seed, size_t seed_len,
u8 *out, size_t outlen);
int hmac_sha256_kdf(const u8 *secret, size_t secret_len,
const char *label, const u8 *seed, size_t seed_len,
u8 *out, size_t outlen);
#endif /* SHA256_H */
|
2301_81045437/rtl8852be
|
core/crypto/sha256.h
|
C
|
agpl-3.0
| 1,095
|
/*
* SHA-256 internal definitions
* Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef SHA256_I_H
#define SHA256_I_H
#define SHA256_BLOCK_SIZE 64
struct _sha256_state {
u64 length;
u32 state[8], curlen;
u8 buf[SHA256_BLOCK_SIZE];
};
void _sha256_init(struct _sha256_state *md);
int sha256_process(struct _sha256_state *md, const unsigned char *in,
unsigned long inlen);
int sha256_done(struct _sha256_state *md, unsigned char *out);
#endif /* SHA256_I_H */
|
2301_81045437/rtl8852be
|
core/crypto/sha256_i.h
|
C
|
agpl-3.0
| 589
|
/*
* wlantest - IEEE 802.11 protocol monitoring and testing tool
* Copyright (c) 2010-2013, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#ifndef WLANCRYPTO_WRAP_H
#define WLANCRYPTO_WRAP_H
int sha256_vector(size_t num_elem, const u8 *addr[], const size_t *len,
u8 *mac);
u8* ccmp_decrypt(_adapter *padapter, const u8 *tk, const struct ieee80211_hdr *hdr,
const u8 *data, size_t data_len, size_t *decrypted_len);
u8* ccmp_encrypt(_adapter *padapter, const u8 *tk, u8 *frame, size_t len, size_t hdrlen, u8 *qos,
u8 *pn, int keyid, size_t *encrypted_len);
u8* ccmp_encrypt_pv1(const u8 *tk, const u8 *a1, const u8 *a2, const u8 *a3,
const u8 *frame, size_t len,
size_t hdrlen, const u8 *pn, int keyid,
size_t *encrypted_len);
u8* ccmp_256_decrypt(_adapter *padapter, const u8 *tk, const struct ieee80211_hdr *hdr,
const u8 *data, size_t data_len, size_t *decrypted_len);
u8* ccmp_256_encrypt(_adapter *padapter, const u8 *tk, u8 *frame, size_t len, size_t hdrlen,
u8 *qos, u8 *pn, int keyid, size_t *encrypted_len);
u8* gcmp_decrypt(_adapter *padapter, const u8 *tk, size_t tk_len, const struct ieee80211_hdr *hdr,
const u8 *data, size_t data_len, size_t *decrypted_len);
u8* gcmp_encrypt(_adapter *padapter, const u8 *tk, size_t tk_len, const u8 *frame, size_t len,
size_t hdrlen, const u8 *qos,
const u8 *pn, int keyid, size_t *encrypted_len);
#if 0 //RTW_PHL_TX: mark un-finished codes for reading
void core_ccmp_encrypt(const u8 *tk, uint hdrlen, u8 *phdr, uint datalen, u8 *pdata,
u8 *qos, u8 *pn, int keyid, size_t *encrypted_len);
void core_ccmp_256_encrypt(const u8 *tk, uint hdrlen, u8 *phdr, uint datalen, u8 *pdata,
u8 *qos, u8 *pn, int keyid, size_t *encrypted_len);
#endif
#endif /* WLANCRYPTO_WRAP_H */
|
2301_81045437/rtl8852be
|
core/crypto/wlancrypto_wrap.h
|
C
|
agpl-3.0
| 1,834
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_MESH_C_
#ifdef CONFIG_RTW_MESH
#include <drv_types.h>
const char *_rtw_mesh_plink_str[] = {
"UNKNOWN",
"LISTEN",
"OPN_SNT",
"OPN_RCVD",
"CNF_RCVD",
"ESTAB",
"HOLDING",
"BLOCKED",
};
const char *_rtw_mesh_ps_str[] = {
"UNKNOWN",
"ACTIVE",
"LSLEEP",
"DSLEEP",
};
const char *_action_self_protected_str[] = {
"ACT_SELF_PROTECTED_RSVD",
"MESH_OPEN",
"MESH_CONF",
"MESH_CLOSE",
"MESH_GK_INFORM",
"MESH_GK_ACK",
};
inline u8 *rtw_set_ie_mesh_id(u8 *buf, u32 *buf_len, const char *mesh_id, u8 id_len)
{
return rtw_set_ie(buf, WLAN_EID_MESH_ID, id_len, mesh_id, buf_len);
}
inline u8 *rtw_set_ie_mesh_config(u8 *buf, u32 *buf_len
, u8 path_sel_proto, u8 path_sel_metric, u8 congest_ctl_mode, u8 sync_method, u8 auth_proto
, u8 num_of_peerings, bool cto_mgate, bool cto_as
, bool accept_peerings, bool mcca_sup, bool mcca_en, bool forwarding
, bool mbca_en, bool tbtt_adj, bool ps_level)
{
u8 conf[7] = {0};
SET_MESH_CONF_ELE_PATH_SEL_PROTO_ID(conf, path_sel_proto);
SET_MESH_CONF_ELE_PATH_SEL_METRIC_ID(conf, path_sel_metric);
SET_MESH_CONF_ELE_CONGEST_CTRL_MODE_ID(conf, congest_ctl_mode);
SET_MESH_CONF_ELE_SYNC_METHOD_ID(conf, sync_method);
SET_MESH_CONF_ELE_AUTH_PROTO_ID(conf, auth_proto);
SET_MESH_CONF_ELE_CTO_MGATE(conf, cto_mgate);
SET_MESH_CONF_ELE_NUM_OF_PEERINGS(conf, num_of_peerings);
SET_MESH_CONF_ELE_CTO_AS(conf, cto_as);
SET_MESH_CONF_ELE_ACCEPT_PEERINGS(conf, accept_peerings);
SET_MESH_CONF_ELE_MCCA_SUP(conf, mcca_sup);
SET_MESH_CONF_ELE_MCCA_EN(conf, mcca_en);
SET_MESH_CONF_ELE_FORWARDING(conf, forwarding);
SET_MESH_CONF_ELE_MBCA_EN(conf, mbca_en);
SET_MESH_CONF_ELE_TBTT_ADJ(conf, tbtt_adj);
SET_MESH_CONF_ELE_PS_LEVEL(conf, ps_level);
return rtw_set_ie(buf, WLAN_EID_MESH_CONFIG, 7, conf, buf_len);
}
inline u8 *rtw_set_ie_mpm(u8 *buf, u32 *buf_len
, u8 proto_id, u16 llid, u16 *plid, u16 *reason, u8 *chosen_pmk)
{
u8 data[24] = {0};
u8 *pos = data;
RTW_PUT_LE16(pos, proto_id);
pos += 2;
RTW_PUT_LE16(pos, llid);
pos += 2;
if (plid) {
RTW_PUT_LE16(pos, *plid);
pos += 2;
}
if (reason) {
RTW_PUT_LE16(pos, *reason);
pos += 2;
}
if (chosen_pmk) {
_rtw_memcpy(pos, chosen_pmk, 16);
pos += 16;
}
return rtw_set_ie(buf, WLAN_EID_MPM, pos - data, data, buf_len);
}
bool rtw_bss_is_forwarding(WLAN_BSSID_EX *bss)
{
u8 *ie;
int ie_len;
bool ret = 0;
ie = rtw_get_ie(BSS_EX_TLV_IES(bss), WLAN_EID_MESH_CONFIG, &ie_len,
BSS_EX_TLV_IES_LEN(bss));
if (!ie || ie_len != 7)
goto exit;
ret = GET_MESH_CONF_ELE_FORWARDING(ie + 2);
exit:
return ret;
}
bool rtw_bss_is_cto_mgate(WLAN_BSSID_EX *bss)
{
u8 *ie;
int ie_len;
bool ret = 0;
ie = rtw_get_ie(BSS_EX_TLV_IES(bss), WLAN_EID_MESH_CONFIG, &ie_len,
BSS_EX_TLV_IES_LEN(bss));
if (!ie || ie_len != 7)
goto exit;
ret = GET_MESH_CONF_ELE_CTO_MGATE(ie + 2);
exit:
return ret;
}
int _rtw_bss_is_same_mbss(WLAN_BSSID_EX *a, WLAN_BSSID_EX *b, u8 **a_mconf_ie_r, u8 **b_mconf_ie_r)
{
int ret = 0;
u8 *a_mconf_ie, *b_mconf_ie;
sint a_mconf_ie_len, b_mconf_ie_len;
if (a->InfrastructureMode != Ndis802_11_mesh)
goto exit;
a_mconf_ie = rtw_get_ie(BSS_EX_TLV_IES(a), WLAN_EID_MESH_CONFIG, &a_mconf_ie_len, BSS_EX_TLV_IES_LEN(a));
if (!a_mconf_ie || a_mconf_ie_len != 7)
goto exit;
if (a_mconf_ie_r)
*a_mconf_ie_r = a_mconf_ie;
if (b->InfrastructureMode != Ndis802_11_mesh)
goto exit;
b_mconf_ie = rtw_get_ie(BSS_EX_TLV_IES(b), WLAN_EID_MESH_CONFIG, &b_mconf_ie_len, BSS_EX_TLV_IES_LEN(b));
if (!b_mconf_ie || b_mconf_ie_len != 7)
goto exit;
if (b_mconf_ie_r)
*b_mconf_ie_r = b_mconf_ie;
if (a->mesh_id.SsidLength != b->mesh_id.SsidLength
|| _rtw_memcmp(a->mesh_id.Ssid, b->mesh_id.Ssid, a->mesh_id.SsidLength) == _FALSE)
goto exit;
if (_rtw_memcmp(a_mconf_ie + 2, b_mconf_ie + 2, 5) == _FALSE)
goto exit;
ret = 1;
exit:
return ret;
}
int rtw_bss_is_same_mbss(WLAN_BSSID_EX *a, WLAN_BSSID_EX *b)
{
return _rtw_bss_is_same_mbss(a, b, NULL, NULL);
}
int rtw_bss_is_candidate_mesh_peer(_adapter *adapter, WLAN_BSSID_EX *target, u8 ch, u8 add_peer)
{
int ret = 0;
WLAN_BSSID_EX *self = &adapter->mlmepriv.cur_network.network;
u8 *s_mconf_ie, *t_mconf_ie;
u8 auth_pid;
int i, j;
if (ch && self->Configuration.DSConfig != target->Configuration.DSConfig)
goto exit;
if (!_rtw_bss_is_same_mbss(self, target, &s_mconf_ie, &t_mconf_ie))
goto exit;
if (add_peer) {
/* Accept additional mesh peerings */
if (GET_MESH_CONF_ELE_ACCEPT_PEERINGS(t_mconf_ie + 2) == 0)
goto exit;
}
/* BSSBasicRateSet */
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
if (target->SupportedRates[i] == 0)
break;
if (target->SupportedRates[i] & 0x80) {
u8 match = 0;
if (!ch) {
/* off-channel, check target with our hardcode capability */
if (target->Configuration.DSConfig > 14)
match = rtw_is_basic_rate_ofdm(target->SupportedRates[i]);
else
match = rtw_is_basic_rate_mix(target->SupportedRates[i]);
} else {
for (j = 0; j < NDIS_802_11_LENGTH_RATES_EX; j++) {
if (self->SupportedRates[j] == 0)
break;
if (self->SupportedRates[j] == target->SupportedRates[i]) {
match = 1;
break;
}
}
}
if (!match)
goto exit;
}
}
/* BSSBasicMCSSet */
auth_pid = GET_MESH_CONF_ELE_AUTH_PROTO_ID(s_mconf_ie + 2);
if (auth_pid && auth_pid <= 2) {
struct security_priv *sec = &adapter->securitypriv;
u8 *rsn_ie;
int rsn_ie_len;
int group_cipher = 0, pairwise_cipher = 0, gmcs = 0;
u8 mfp_opt = MFP_NO;
/* 802.1X connected to AS ? */
/* RSN */
rsn_ie = rtw_get_wpa2_ie(BSS_EX_TLV_IES(target), &rsn_ie_len, BSS_EX_TLV_IES_LEN(target));
if (!rsn_ie || rsn_ie_len == 0)
goto exit;
if (rtw_parse_wpa2_ie(rsn_ie, rsn_ie_len + 2, &group_cipher, &pairwise_cipher, &gmcs, NULL, &mfp_opt, NULL) != _SUCCESS)
goto exit;
if ((sec->mfp_opt == MFP_REQUIRED && mfp_opt < MFP_OPTIONAL)
|| (mfp_opt == MFP_REQUIRED && sec->mfp_opt < MFP_OPTIONAL))
goto exit;
if (!(sec->wpa2_group_cipher & group_cipher))
goto exit;
if (!(sec->wpa2_pairwise_cipher & pairwise_cipher))
goto exit;
#ifdef CONFIG_IEEE80211W
if ((sec->mfp_opt >= MFP_OPTIONAL && mfp_opt >= MFP_OPTIONAL)
&& security_type_bip_to_gmcs(sec->dot11wCipher) != gmcs)
goto exit;
#endif
}
ret = 1;
exit:
return ret;
}
void rtw_mesh_bss_peering_status(WLAN_BSSID_EX *bss, u8 *nop, u8 *accept)
{
u8 *ie;
int ie_len;
if (nop)
*nop = 0;
if (accept)
*accept = 0;
ie = rtw_get_ie(BSS_EX_TLV_IES(bss), WLAN_EID_MESH_CONFIG, &ie_len,
BSS_EX_TLV_IES_LEN(bss));
if (!ie || ie_len != 7)
goto exit;
if (nop)
*nop = GET_MESH_CONF_ELE_NUM_OF_PEERINGS(ie + 2);
if (accept)
*accept = GET_MESH_CONF_ELE_ACCEPT_PEERINGS(ie + 2);
exit:
return;
}
#if CONFIG_RTW_MESH_ACNODE_PREVENT
void rtw_mesh_update_scanned_acnode_status(_adapter *adapter, struct wlan_network *scanned)
{
bool acnode;
u8 nop, accept;
rtw_mesh_bss_peering_status(&scanned->network, &nop, &accept);
acnode = !nop && accept;
if (acnode && scanned->acnode_stime == 0) {
scanned->acnode_stime = rtw_get_current_time();
if (scanned->acnode_stime == 0)
scanned->acnode_stime++;
} else if (!acnode) {
scanned->acnode_stime = 0;
scanned->acnode_notify_etime = 0;
}
}
bool rtw_mesh_scanned_is_acnode_confirmed(_adapter *adapter, struct wlan_network *scanned)
{
return scanned->acnode_stime
&& rtw_get_passing_time_ms(scanned->acnode_stime)
> adapter->mesh_cfg.peer_sel_policy.acnode_conf_timeout_ms;
}
static bool rtw_mesh_scanned_is_acnode_allow_notify(_adapter *adapter, struct wlan_network *scanned)
{
return scanned->acnode_notify_etime
&& rtw_time_after(scanned->acnode_notify_etime, rtw_get_current_time());
}
bool rtw_mesh_acnode_prevent_allow_sacrifice(_adapter *adapter)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct sta_priv *stapriv = &adapter->stapriv;
bool allow = 0;
if (!mcfg->peer_sel_policy.acnode_prevent
|| mcfg->max_peer_links <= 1
|| stapriv->asoc_list_cnt < mcfg->max_peer_links)
goto exit;
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
if (rtw_mesh_cto_mgate_required(adapter))
goto exit;
#endif
allow = 1;
exit:
return allow;
}
static bool rtw_mesh_acnode_candidate_exist(_adapter *adapter)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct sta_priv *stapriv = &adapter->stapriv;
struct mlme_priv *mlme = &adapter->mlmepriv;
_queue *queue = &(mlme->scanned_queue);
_list *head, *list;
struct wlan_network *scanned = NULL;
struct sta_info *sta = NULL;
bool need = 0;
_rtw_spinlock_bh(&(mlme->scanned_queue.lock));
head = get_list_head(queue);
list = get_next(head);
while (!rtw_end_of_queue_search(head, list)) {
scanned = LIST_CONTAINOR(list, struct wlan_network, list);
list = get_next(list);
if (rtw_get_passing_time_ms(scanned->last_scanned) < mcfg->peer_sel_policy.scanr_exp_ms
&& rtw_mesh_scanned_is_acnode_confirmed(adapter, scanned)
&& (!mcfg->rssi_threshold || mcfg->rssi_threshold <= scanned->network.PhyInfo.rssi)
#if CONFIG_RTW_MACADDR_ACL
&& rtw_access_ctrl(adapter, scanned->network.MacAddress) == _TRUE
#endif
&& rtw_bss_is_candidate_mesh_peer(adapter, &scanned->network, 1, 1)
#if CONFIG_RTW_MESH_PEER_BLACKLIST
&& !rtw_mesh_peer_blacklist_search(adapter, scanned->network.MacAddress)
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
&& rtw_mesh_cto_mgate_network_filter(adapter, scanned)
#endif
) {
need = 1;
break;
}
}
_rtw_spinunlock_bh(&(mlme->scanned_queue.lock));
return need;
}
static int rtw_mesh_acnode_prevent_sacrifice_chk(_adapter *adapter, struct sta_info **sac, struct sta_info *com)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
int updated = 0;
/*
* TODO: compare next_hop reference cnt of forwarding info
* don't sacrifice working next_hop or choose sta with least cnt
*/
if (*sac == NULL) {
updated = 1;
goto exit;
}
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
if (mcfg->peer_sel_policy.cto_mgate_require
&& !mcfg->dot11MeshGateAnnouncementProtocol
) {
if (IS_CTO_MGATE_CONF_TIMEOUT(com->plink)) {
if (!IS_CTO_MGATE_CONF_TIMEOUT((*sac)->plink)) {
/* blacklist > not blacklist */
updated = 1;
goto exit;
}
} else if (!IS_CTO_MGATE_CONF_DISABLED(com->plink)) {
if (IS_CTO_MGATE_CONF_DISABLED((*sac)->plink)) {
/* confirming > disabled */
updated = 1;
goto exit;
}
}
}
#endif
exit:
if (updated)
*sac = com;
return updated;
}
struct sta_info *_rtw_mesh_acnode_prevent_pick_sacrifice(_adapter *adapter)
{
struct sta_priv *stapriv = &adapter->stapriv;
_list *head, *list;
struct sta_info *sta, *sacrifice = NULL;
u8 nop;
head = &stapriv->asoc_list;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
sta = LIST_CONTAINOR(list, struct sta_info, asoc_list);
list = get_next(list);
if (!sta->plink || !sta->plink->scanned) {
rtw_warn_on(1);
continue;
}
rtw_mesh_bss_peering_status(&sta->plink->scanned->network, &nop, NULL);
if (nop < 2)
continue;
rtw_mesh_acnode_prevent_sacrifice_chk(adapter, &sacrifice, sta);
}
return sacrifice;
}
struct sta_info *rtw_mesh_acnode_prevent_pick_sacrifice(_adapter *adapter)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct sta_info *sacrifice = NULL;
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
sacrifice = _rtw_mesh_acnode_prevent_pick_sacrifice(adapter);
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
return sacrifice;
}
static void rtw_mesh_acnode_rsvd_chk(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
u8 acnode_rsvd = 0;
if (rtw_mesh_acnode_prevent_allow_sacrifice(adapter)
&& rtw_mesh_acnode_prevent_pick_sacrifice(adapter)
&& rtw_mesh_acnode_candidate_exist(adapter))
acnode_rsvd = 1;
if (plink_ctl->acnode_rsvd != acnode_rsvd) {
plink_ctl->acnode_rsvd = acnode_rsvd;
RTW_INFO(FUNC_ADPT_FMT" acnode_rsvd = %d\n", FUNC_ADPT_ARG(adapter), plink_ctl->acnode_rsvd);
rtw_update_beacon(adapter, WLAN_EID_MESH_CONFIG, NULL, 1, 0);
}
}
static void rtw_mesh_acnode_set_notify_etime(_adapter *adapter, u8 *rframe_whdr)
{
if (adapter->mesh_info.plink_ctl.acnode_rsvd) {
struct wlan_network *scanned = rtw_find_network(&adapter->mlmepriv.scanned_queue, get_addr2_ptr(rframe_whdr));
if (rtw_mesh_scanned_is_acnode_confirmed(adapter, scanned)) {
scanned->acnode_notify_etime = rtw_get_current_time()
+ rtw_ms_to_systime(adapter->mesh_cfg.peer_sel_policy.acnode_notify_timeout_ms);
if (scanned->acnode_notify_etime == 0)
scanned->acnode_notify_etime++;
}
}
}
void dump_mesh_acnode_prevent_settings(void *sel, _adapter *adapter)
{
struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
RTW_PRINT_SEL(sel, "%-6s %-12s %-14s\n"
, "enable", "conf_timeout", "nofity_timeout");
RTW_PRINT_SEL(sel, "%6u %12u %14u\n"
, peer_sel_policy->acnode_prevent
, peer_sel_policy->acnode_conf_timeout_ms
, peer_sel_policy->acnode_notify_timeout_ms);
}
#endif /* CONFIG_RTW_MESH_ACNODE_PREVENT */
#if CONFIG_RTW_MESH_PEER_BLACKLIST
int rtw_mesh_peer_blacklist_add(_adapter *adapter, const u8 *addr)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
return rtw_blacklist_add(&plink_ctl->peer_blacklist, addr
, mcfg->peer_sel_policy.peer_blacklist_timeout_ms);
}
int rtw_mesh_peer_blacklist_del(_adapter *adapter, const u8 *addr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
return rtw_blacklist_del(&plink_ctl->peer_blacklist, addr);
}
int rtw_mesh_peer_blacklist_search(_adapter *adapter, const u8 *addr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
return rtw_blacklist_search(&plink_ctl->peer_blacklist, addr);
}
void rtw_mesh_peer_blacklist_flush(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
rtw_blacklist_flush(&plink_ctl->peer_blacklist);
}
void dump_mesh_peer_blacklist(void *sel, _adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
dump_blacklist(sel, &plink_ctl->peer_blacklist, "blacklist");
}
void dump_mesh_peer_blacklist_settings(void *sel, _adapter *adapter)
{
struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
RTW_PRINT_SEL(sel, "%-12s %-17s\n"
, "conf_timeout", "blacklist_timeout");
RTW_PRINT_SEL(sel, "%12u %17u\n"
, peer_sel_policy->peer_conf_timeout_ms
, peer_sel_policy->peer_blacklist_timeout_ms);
}
#endif /* CONFIG_RTW_MESH_PEER_BLACKLIST */
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
u8 rtw_mesh_cto_mgate_required(_adapter *adapter)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
return mcfg->peer_sel_policy.cto_mgate_require
&& !rtw_bss_is_cto_mgate(&(mlmeext->mlmext_info.network));
}
u8 rtw_mesh_cto_mgate_network_filter(_adapter *adapter, struct wlan_network *scanned)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
return !rtw_mesh_cto_mgate_required(adapter)
|| (rtw_bss_is_cto_mgate(&scanned->network)
&& !rtw_mesh_cto_mgate_blacklist_search(adapter, scanned->network.MacAddress));
}
int rtw_mesh_cto_mgate_blacklist_add(_adapter *adapter, const u8 *addr)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
return rtw_blacklist_add(&plink_ctl->cto_mgate_blacklist, addr
, mcfg->peer_sel_policy.cto_mgate_blacklist_timeout_ms);
}
int rtw_mesh_cto_mgate_blacklist_del(_adapter *adapter, const u8 *addr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
return rtw_blacklist_del(&plink_ctl->cto_mgate_blacklist, addr);
}
int rtw_mesh_cto_mgate_blacklist_search(_adapter *adapter, const u8 *addr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
return rtw_blacklist_search(&plink_ctl->cto_mgate_blacklist, addr);
}
void rtw_mesh_cto_mgate_blacklist_flush(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
rtw_blacklist_flush(&plink_ctl->cto_mgate_blacklist);
}
void dump_mesh_cto_mgate_blacklist(void *sel, _adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
dump_blacklist(sel, &plink_ctl->cto_mgate_blacklist, "blacklist");
}
void dump_mesh_cto_mgate_blacklist_settings(void *sel, _adapter *adapter)
{
struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
RTW_PRINT_SEL(sel, "%-12s %-17s\n"
, "conf_timeout", "blacklist_timeout");
RTW_PRINT_SEL(sel, "%12u %17u\n"
, peer_sel_policy->cto_mgate_conf_timeout_ms
, peer_sel_policy->cto_mgate_blacklist_timeout_ms);
}
static void rtw_mesh_cto_mgate_blacklist_chk(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
_queue *blist = &plink_ctl->cto_mgate_blacklist;
_list *list, *head;
struct blacklist_ent *ent = NULL;
struct wlan_network *scanned = NULL;
_rtw_spinlock_bh(&blist->lock);
head = &blist->queue;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
ent = LIST_CONTAINOR(list, struct blacklist_ent, list);
list = get_next(list);
if (rtw_time_after(rtw_get_current_time(), ent->exp_time)) {
rtw_list_delete(&ent->list);
rtw_mfree(ent, sizeof(struct blacklist_ent));
continue;
}
scanned = rtw_find_network(&adapter->mlmepriv.scanned_queue, ent->addr);
if (!scanned)
continue;
if (rtw_bss_is_forwarding(&scanned->network)) {
rtw_list_delete(&ent->list);
rtw_mfree(ent, sizeof(struct blacklist_ent));
}
}
_rtw_spinunlock_bh(&blist->lock);
}
#endif /* CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST */
void rtw_chk_candidate_peer_notify(_adapter *adapter, struct wlan_network *scanned)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct mlme_priv *mlme = &adapter->mlmepriv;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
bool acnode = 0;
if (IS_CH_WAITING(rfctl) && !IS_UNDER_CAC(rfctl))
goto exit;
if (plink_ctl->num >= RTW_MESH_MAX_PEER_CANDIDATES)
goto exit;
#if CONFIG_RTW_MESH_ACNODE_PREVENT
if (plink_ctl->acnode_rsvd) {
acnode = rtw_mesh_scanned_is_acnode_confirmed(adapter, scanned);
if (acnode && !rtw_mesh_scanned_is_acnode_allow_notify(adapter, scanned))
goto exit;
}
#endif
/* wpa_supplicant's auto peer will initiate peering when candidate peer is reported without max_peer_links consideration */
if (plink_ctl->num >= mcfg->max_peer_links + acnode ? 1 : 0)
goto exit;
if (rtw_get_passing_time_ms(scanned->last_scanned) >= mcfg->peer_sel_policy.scanr_exp_ms
|| (mcfg->rssi_threshold && mcfg->rssi_threshold > scanned->network.PhyInfo.rssi)
|| !rtw_bss_is_candidate_mesh_peer(adapter, &scanned->network, 1, 1)
#if CONFIG_RTW_MACADDR_ACL
|| rtw_access_ctrl(adapter, scanned->network.MacAddress) == _FALSE
#endif
|| rtw_mesh_plink_get(adapter, scanned->network.MacAddress)
#if CONFIG_RTW_MESH_PEER_BLACKLIST
|| rtw_mesh_peer_blacklist_search(adapter, scanned->network.MacAddress)
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
|| !rtw_mesh_cto_mgate_network_filter(adapter, scanned)
#endif
)
goto exit;
#if CONFIG_RTW_MESH_ACNODE_PREVENT
if (acnode) {
scanned->acnode_notify_etime = 0;
RTW_INFO(FUNC_ADPT_FMT" acnode "MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(scanned->network.MacAddress));
}
#endif
#ifdef CONFIG_IOCTL_CFG80211
rtw_cfg80211_notify_new_peer_candidate(adapter->rtw_wdev
, scanned->network.MacAddress
, BSS_EX_TLV_IES(&scanned->network)
, BSS_EX_TLV_IES_LEN(&scanned->network)
, scanned->network.PhyInfo.rssi
, GFP_ATOMIC
);
#endif
exit:
return;
}
void rtw_mesh_peer_status_chk(_adapter *adapter)
{
struct mlme_priv *mlme = &adapter->mlmepriv;
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *plink;
_list *head, *list;
struct sta_info *sta = NULL;
struct sta_priv *stapriv = &adapter->stapriv;
int stainfo_offset;
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
u8 cto_mgate, forwarding, mgate;
#endif
u8 flush;
s8 flush_list[NUM_STA];
u8 flush_num = 0;
int i;
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
if (rtw_mesh_cto_mgate_required(adapter)) {
/* active scan on operating channel */
issue_probereq_ex(adapter, &adapter->mlmepriv.cur_network.network.mesh_id, NULL, 0, 0, 0, 0);
}
#endif
_rtw_spinlock_bh(&(plink_ctl->lock));
/* check established peers */
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
head = &stapriv->asoc_list;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
sta = LIST_CONTAINOR(list, struct sta_info, asoc_list);
list = get_next(list);
if (!sta->plink || !sta->plink->scanned) {
rtw_warn_on(1);
continue;
}
plink = sta->plink;
flush = 0;
/* remove unsuitable peer */
if (!rtw_bss_is_candidate_mesh_peer(adapter, &plink->scanned->network, 1, 0)
#if CONFIG_RTW_MACADDR_ACL
|| rtw_access_ctrl(adapter, plink->addr) == _FALSE
#endif
) {
flush = 1;
goto flush_add;
}
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
cto_mgate = rtw_bss_is_cto_mgate(&(plink->scanned->network));
forwarding = rtw_bss_is_forwarding(&(plink->scanned->network));
mgate = rtw_mesh_gate_search(minfo->mesh_paths, sta->phl_sta->mac_addr);
/* CTO_MGATE required, remove peer without CTO_MGATE */
if (rtw_mesh_cto_mgate_required(adapter) && !cto_mgate) {
flush = 1;
goto flush_add;
}
/* cto_mgate_conf status update */
if (IS_CTO_MGATE_CONF_DISABLED(plink)) {
if (cto_mgate && !forwarding && !mgate)
SET_CTO_MGATE_CONF_END_TIME(plink, mcfg->peer_sel_policy.cto_mgate_conf_timeout_ms);
else
rtw_mesh_cto_mgate_blacklist_del(adapter, sta->phl_sta->mac_addr);
} else {
/* cto_mgate_conf ongoing */
if (cto_mgate && !forwarding && !mgate) {
if (IS_CTO_MGATE_CONF_TIMEOUT(plink)) {
rtw_mesh_cto_mgate_blacklist_add(adapter, sta->phl_sta->mac_addr);
/* CTO_MGATE required, remove peering can't achieve CTO_MGATE */
if (rtw_mesh_cto_mgate_required(adapter)) {
flush = 1;
goto flush_add;
}
}
} else {
SET_CTO_MGATE_CONF_DISABLED(plink);
rtw_mesh_cto_mgate_blacklist_del(adapter, sta->phl_sta->mac_addr);
}
}
#endif /* CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST */
flush_add:
if (flush) {
rtw_list_delete(&sta->asoc_list);
stapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (sta->tbtx_enable)
stapriv->tbtx_asoc_list_cnt--;
#endif
STA_SET_MESH_PLINK(sta, NULL);
stainfo_offset = rtw_stainfo_offset(stapriv, sta);
if (stainfo_offset_valid(stainfo_offset))
flush_list[flush_num++] = stainfo_offset;
else
rtw_warn_on(1);
}
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
/* check non-established peers */
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++) {
plink = &plink_ctl->ent[i];
if (plink->valid != _TRUE || plink->plink_state == RTW_MESH_PLINK_ESTAB)
continue;
/* remove unsuitable peer */
if (!rtw_bss_is_candidate_mesh_peer(adapter, &plink->scanned->network, 1, 1)
#if CONFIG_RTW_MACADDR_ACL
|| rtw_access_ctrl(adapter, plink->addr) == _FALSE
#endif
) {
_rtw_mesh_expire_peer_ent(adapter, plink);
continue;
}
#if CONFIG_RTW_MESH_PEER_BLACKLIST
/* peer confirm check timeout, add to black list */
if (IS_PEER_CONF_TIMEOUT(plink)) {
rtw_mesh_peer_blacklist_add(adapter, plink->addr);
_rtw_mesh_expire_peer_ent(adapter, plink);
}
#endif
}
_rtw_spinunlock_bh(&(plink_ctl->lock));
if (flush_num) {
u8 sta_addr[ETH_ALEN];
u8 updated = _FALSE;
for (i = 0; i < flush_num; i++) {
sta = rtw_get_stainfo_by_offset(stapriv, flush_list[i]);
_rtw_memcpy(sta_addr, sta->phl_sta->mac_addr, ETH_ALEN);
updated |= ap_free_sta(adapter, sta, _TRUE, WLAN_REASON_DEAUTH_LEAVING, _FALSE, _FALSE);
rtw_mesh_expire_peer(adapter, sta_addr);
}
associated_clients_update(adapter, updated, STA_INFO_UPDATE_ALL);
}
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
/* loop cto_mgate_blacklist to remove ent according to scan_r */
rtw_mesh_cto_mgate_blacklist_chk(adapter);
#endif
#if CONFIG_RTW_MESH_ACNODE_PREVENT
rtw_mesh_acnode_rsvd_chk(adapter);
#endif
return;
}
#if CONFIG_RTW_MESH_OFFCH_CAND
static u8 rtw_mesh_offch_cto_mgate_required(_adapter *adapter)
{
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct mlme_priv *mlme = &adapter->mlmepriv;
_queue *queue = &(mlme->scanned_queue);
_list *head, *pos;
struct wlan_network *scanned = NULL;
u8 ret = 0;
if (!rtw_mesh_cto_mgate_required(adapter))
goto exit;
_rtw_spinlock_bh(&(mlme->scanned_queue.lock));
head = get_list_head(queue);
pos = get_next(head);
while (!rtw_end_of_queue_search(head, pos)) {
scanned = LIST_CONTAINOR(pos, struct wlan_network, list);
if (rtw_get_passing_time_ms(scanned->last_scanned) < mcfg->peer_sel_policy.scanr_exp_ms
&& (!mcfg->rssi_threshold || mcfg->rssi_threshold <= scanned->network.PhyInfo.rssi)
#if CONFIG_RTW_MACADDR_ACL
&& rtw_access_ctrl(adapter, scanned->network.MacAddress) == _TRUE
#endif
&& rtw_bss_is_candidate_mesh_peer(adapter, &scanned->network, 1, 1)
&& rtw_bss_is_cto_mgate(&scanned->network)
#if CONFIG_RTW_MESH_PEER_BLACKLIST
&& !rtw_mesh_peer_blacklist_search(adapter, scanned->network.MacAddress)
#endif
&& !rtw_mesh_cto_mgate_blacklist_search(adapter, scanned->network.MacAddress)
)
break;
pos = get_next(pos);
}
if (rtw_end_of_queue_search(head, pos))
ret = 1;
_rtw_spinunlock_bh(&(mlme->scanned_queue.lock));
exit:
return ret;
#else
return 0;
#endif /* CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST */
}
u8 rtw_mesh_offch_candidate_accepted(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
u8 ret = 0;
if (!adapter->mesh_cfg.peer_sel_policy.offch_cand)
goto exit;
ret = MLME_IS_MESH(adapter) && MLME_IS_ASOC(adapter)
&& (!plink_ctl->num || rtw_mesh_offch_cto_mgate_required(adapter))
;
#ifdef CONFIG_CONCURRENT_MODE
if (ret) {
struct mi_state mstate_no_self;
rtw_mi_status_no_self(adapter, &mstate_no_self);
if (MSTATE_STA_LD_NUM(&mstate_no_self))
ret = 0;
}
#endif
exit:
return ret;
}
/*
* this function is called under off channel candidate is required
* the channel with maximum candidate count is selected
*/
u8 rtw_mesh_select_operating_ch(_adapter *adapter)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct mlme_priv *mlme = &adapter->mlmepriv;
_queue *queue = &(mlme->scanned_queue);
_list *head, *pos;
struct wlan_network *scanned = NULL;
int i;
/* statistics for candidate accept peering */
u8 cand_ap_cnt[MAX_CHANNEL_NUM] = {0};
u8 max_cand_ap_ch = 0;
u8 max_cand_ap_cnt = 0;
/* statistics for candidate including not accept peering */
u8 cand_cnt[MAX_CHANNEL_NUM] = {0};
u8 max_cand_ch = 0;
u8 max_cand_cnt = 0;
_rtw_spinlock_bh(&(mlme->scanned_queue.lock));
head = get_list_head(queue);
pos = get_next(head);
while (!rtw_end_of_queue_search(head, pos)) {
scanned = LIST_CONTAINOR(pos, struct wlan_network, list);
pos = get_next(pos);
if (rtw_get_passing_time_ms(scanned->last_scanned) < mcfg->peer_sel_policy.scanr_exp_ms
&& (!mcfg->rssi_threshold || mcfg->rssi_threshold <= scanned->network.PhyInfo.rssi)
#if CONFIG_RTW_MACADDR_ACL
&& rtw_access_ctrl(adapter, scanned->network.MacAddress) == _TRUE
#endif
&& rtw_bss_is_candidate_mesh_peer(adapter, &scanned->network, 0, 0)
#if CONFIG_RTW_MESH_PEER_BLACKLIST
&& !rtw_mesh_peer_blacklist_search(adapter, scanned->network.MacAddress)
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
&& rtw_mesh_cto_mgate_network_filter(adapter, scanned)
#endif
) {
int ch_set_idx = rtw_chset_search_ch(rfctl->channel_set, scanned->network.Configuration.DSConfig);
if (ch_set_idx >= 0
&& !(rfctl->channel_set[ch_set_idx].flags & RTW_CHF_NO_IR)
&& !CH_IS_NON_OCP(&rfctl->channel_set[ch_set_idx])
) {
u8 nop, accept;
rtw_mesh_bss_peering_status(&scanned->network, &nop, &accept);
cand_cnt[ch_set_idx]++;
if (max_cand_cnt < cand_cnt[ch_set_idx]) {
max_cand_cnt = cand_cnt[ch_set_idx];
max_cand_ch = rfctl->channel_set[ch_set_idx].ChannelNum;
}
if (accept) {
cand_ap_cnt[ch_set_idx]++;
if (max_cand_ap_cnt < cand_ap_cnt[ch_set_idx]) {
max_cand_ap_cnt = cand_ap_cnt[ch_set_idx];
max_cand_ap_ch = rfctl->channel_set[ch_set_idx].ChannelNum;
}
}
}
}
}
_rtw_spinunlock_bh(&(mlme->scanned_queue.lock));
return max_cand_ap_ch ? max_cand_ap_ch : max_cand_ch;
}
void dump_mesh_offch_cand_settings(void *sel, _adapter *adapter)
{
struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
RTW_PRINT_SEL(sel, "%-6s %-11s\n"
, "enable", "find_int_ms");
RTW_PRINT_SEL(sel, "%6u %11u\n"
, peer_sel_policy->offch_cand, peer_sel_policy->offch_find_int_ms);
}
#endif /* CONFIG_RTW_MESH_OFFCH_CAND */
void dump_mesh_peer_sel_policy(void *sel, _adapter *adapter)
{
struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
RTW_PRINT_SEL(sel, "%-12s\n", "scanr_exp_ms");
RTW_PRINT_SEL(sel, "%12u\n", peer_sel_policy->scanr_exp_ms);
}
void dump_mesh_networks(void *sel, _adapter *adapter)
{
#if CONFIG_RTW_MESH_ACNODE_PREVENT
#define NSTATE_TITLE_FMT_ACN " %-5s"
#define NSTATE_VALUE_FMT_ACN " %5d"
#define NSTATE_TITLE_ARG_ACN , "acn"
#define NSTATE_VALUE_ARG_ACN , (acn_ms < 99999 ? acn_ms : 99999)
#else
#define NSTATE_TITLE_FMT_ACN ""
#define NSTATE_VALUE_FMT_ACN ""
#define NSTATE_TITLE_ARG_ACN
#define NSTATE_VALUE_ARG_ACN
#endif
struct mlme_priv *mlme = &(adapter->mlmepriv);
_queue *queue = &(mlme->scanned_queue);
struct wlan_network *network;
_list *list, *head;
u8 same_mbss;
u8 candidate;
struct mesh_plink_ent *plink;
u8 blocked;
u8 established;
s32 age_ms;
#if CONFIG_RTW_MESH_ACNODE_PREVENT
s32 acn_ms;
#endif
u8 *mesh_conf_ie;
sint mesh_conf_ie_len;
u8 auth_pid;
u8 *rsn_ie;
int rsn_ie_len;
int gcs, pcs, gmcs;
u8 mfp_opt;
struct wlan_network **mesh_networks;
u8 mesh_network_cnt = 0;
int i;
mesh_networks = rtw_zvmalloc(mlme->max_bss_cnt * sizeof(struct wlan_network *));
if (!mesh_networks)
return;
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
network = LIST_CONTAINOR(list, struct wlan_network, list);
list = get_next(list);
if (network->network.InfrastructureMode != Ndis802_11_mesh)
continue;
mesh_conf_ie = rtw_get_ie(BSS_EX_TLV_IES(&network->network), WLAN_EID_MESH_CONFIG
, &mesh_conf_ie_len, BSS_EX_TLV_IES_LEN(&network->network));
if (!mesh_conf_ie || mesh_conf_ie_len != 7)
continue;
mesh_networks[mesh_network_cnt++] = network;
}
_rtw_spinunlock_bh(&queue->lock);
RTW_PRINT_SEL(sel, " %-17s %-3s %-4s %-5s %-32s %-10s"
" %-3s %-3s %-4s"
" %-3s %-3s %-3s"
NSTATE_TITLE_FMT_ACN
"\n"
, "bssid", "ch", "rssi", "age", "mesh_id", "P M C S A "
, "pcs", "gcs", "gmcs"
, "nop", "fwd", "cto"
NSTATE_TITLE_ARG_ACN
);
if (MLME_IS_MESH(adapter) && MLME_IS_ASOC(adapter)) {
network = &mlme->cur_network;
mesh_conf_ie = rtw_get_ie(BSS_EX_TLV_IES(&network->network), WLAN_EID_MESH_CONFIG
, &mesh_conf_ie_len, BSS_EX_TLV_IES_LEN(&network->network));
if (mesh_conf_ie && mesh_conf_ie_len == 7) {
gcs = pcs = gmcs = 0;
mfp_opt = MFP_NO;
auth_pid = GET_MESH_CONF_ELE_AUTH_PROTO_ID(mesh_conf_ie + 2);
if (auth_pid && auth_pid <= 2) {
rsn_ie = rtw_get_wpa2_ie(BSS_EX_TLV_IES(&network->network)
, &rsn_ie_len, BSS_EX_TLV_IES_LEN(&network->network));
if (rsn_ie && rsn_ie_len)
rtw_parse_wpa2_ie(rsn_ie, rsn_ie_len + 2, &gcs, &pcs, &gmcs, NULL, &mfp_opt, NULL);
}
RTW_PRINT_SEL(sel, "* "MAC_FMT" %3d %-32s %2x%2x%2x%2x%2x"
" %03x %03x %c%03x"
" %c%2u %3u %c%c "
"\n"
, MAC_ARG(network->network.MacAddress)
, network->network.Configuration.DSConfig
, network->network.mesh_id.Ssid
, GET_MESH_CONF_ELE_PATH_SEL_PROTO_ID(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_PATH_SEL_METRIC_ID(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_CONGEST_CTRL_MODE_ID(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_SYNC_METHOD_ID(mesh_conf_ie + 2)
, auth_pid
, pcs, gcs, mfp_opt == MFP_REQUIRED ? 'R' : (mfp_opt == MFP_OPTIONAL ? 'C' : ' ')
, mfp_opt >= MFP_OPTIONAL ? gmcs : 0
, GET_MESH_CONF_ELE_ACCEPT_PEERINGS(mesh_conf_ie + 2) ? '+' : ' '
, GET_MESH_CONF_ELE_NUM_OF_PEERINGS(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_FORWARDING(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_CTO_MGATE(mesh_conf_ie + 2) ? 'G' : ' '
, GET_MESH_CONF_ELE_CTO_AS(mesh_conf_ie + 2) ? 'A' : ' '
);
}
}
for (i = 0; i < mesh_network_cnt; i++) {
network = mesh_networks[i];
if (network->network.InfrastructureMode != Ndis802_11_mesh)
continue;
mesh_conf_ie = rtw_get_ie(BSS_EX_TLV_IES(&network->network), WLAN_EID_MESH_CONFIG
, &mesh_conf_ie_len, BSS_EX_TLV_IES_LEN(&network->network));
if (!mesh_conf_ie || mesh_conf_ie_len != 7)
continue;
gcs = pcs = gmcs = 0;
mfp_opt = MFP_NO;
auth_pid = GET_MESH_CONF_ELE_AUTH_PROTO_ID(mesh_conf_ie + 2);
if (auth_pid && auth_pid <= 2) {
rsn_ie = rtw_get_wpa2_ie(BSS_EX_TLV_IES(&network->network), &rsn_ie_len, BSS_EX_TLV_IES_LEN(&network->network));
if (rsn_ie && rsn_ie_len)
rtw_parse_wpa2_ie(rsn_ie, rsn_ie_len + 2, &gcs, &pcs, &gmcs, NULL, &mfp_opt, NULL);
}
age_ms = rtw_get_passing_time_ms(network->last_scanned);
#if CONFIG_RTW_MESH_ACNODE_PREVENT
if (network->acnode_stime == 0)
acn_ms = 0;
else
acn_ms = rtw_get_passing_time_ms(network->acnode_stime);
#endif
same_mbss = 0;
candidate = 0;
plink = NULL;
blocked = 0;
established = 0;
if (MLME_IS_MESH(adapter) && MLME_IS_ASOC(adapter)) {
plink = rtw_mesh_plink_get(adapter, network->network.MacAddress);
if (plink && plink->plink_state == RTW_MESH_PLINK_ESTAB)
established = 1;
else if (plink && plink->plink_state == RTW_MESH_PLINK_BLOCKED)
blocked = 1;
else if (plink)
;
else if (rtw_bss_is_candidate_mesh_peer(adapter, &network->network, 0, 1))
candidate = 1;
else if (rtw_bss_is_same_mbss(&mlme->cur_network.network, &network->network))
same_mbss = 1;
}
RTW_PRINT_SEL(sel, "%c "MAC_FMT" %3d %4ld %5d %-32s %2x%2x%2x%2x%2x"
" %03x %03x %c%03x"
" %c%2u %3u %c%c "
NSTATE_VALUE_FMT_ACN
"\n"
, established ? 'E' : (blocked ? 'B' : (plink ? 'N' : (candidate ? 'C' : (same_mbss ? 'S' : ' '))))
, MAC_ARG(network->network.MacAddress)
, network->network.Configuration.DSConfig
, network->network.PhyInfo.rssi
, age_ms < 99999 ? age_ms : 99999
, network->network.mesh_id.Ssid
, GET_MESH_CONF_ELE_PATH_SEL_PROTO_ID(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_PATH_SEL_METRIC_ID(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_CONGEST_CTRL_MODE_ID(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_SYNC_METHOD_ID(mesh_conf_ie + 2)
, auth_pid
, pcs, gcs, mfp_opt == MFP_REQUIRED ? 'R' : (mfp_opt == MFP_OPTIONAL ? 'C' : ' ')
, mfp_opt >= MFP_OPTIONAL ? gmcs : 0
, GET_MESH_CONF_ELE_ACCEPT_PEERINGS(mesh_conf_ie + 2) ? '+' : ' '
, GET_MESH_CONF_ELE_NUM_OF_PEERINGS(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_FORWARDING(mesh_conf_ie + 2)
, GET_MESH_CONF_ELE_CTO_MGATE(mesh_conf_ie + 2) ? 'G' : ' '
, GET_MESH_CONF_ELE_CTO_AS(mesh_conf_ie + 2) ? 'A' : ' '
NSTATE_VALUE_ARG_ACN
);
}
rtw_vmfree(mesh_networks, mlme->max_bss_cnt * sizeof(struct wlan_network *));
}
void rtw_mesh_adjust_chbw(u8 req_ch, u8 *req_bw, u8 *req_offset)
{
if (req_ch >= 5 && req_ch <= 9) {
/* prevent secondary channel offset mismatch */
if (*req_bw > CHANNEL_WIDTH_20) {
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
}
}
}
void rtw_mesh_sae_check_frames(_adapter *adapter, const u8 *buf, u32 len, u8 tx, u16 alg, u16 seq, u16 status)
{
#if CONFIG_RTW_MESH_PEER_BLACKLIST
if (tx && seq == 1)
rtw_mesh_plink_set_peer_conf_timeout(adapter, GetAddr1Ptr(buf));
#endif
}
#if CONFIG_RTW_MPM_TX_IES_SYNC_BSS
#ifdef CONFIG_RTW_MESH_AEK
static int rtw_mpm_ampe_dec(_adapter *adapter, struct mesh_plink_ent *plink
, u8 *fhead, size_t flen, u8* fbody, u8 *mic_ie, u8 *ampe_buf)
{
int ret = _FAIL, verify_ret;
const u8 *aad[] = {adapter_mac_addr(adapter), plink->addr, fbody};
const size_t aad_len[] = {ETH_ALEN, ETH_ALEN, mic_ie - fbody};
u8 *iv_crypt;
size_t iv_crypt_len = flen - (mic_ie + 2 - fhead);
iv_crypt = rtw_malloc(iv_crypt_len);
if (!iv_crypt)
goto exit;
_rtw_memcpy(iv_crypt, mic_ie + 2, iv_crypt_len);
verify_ret = rtw_aes_siv_decrypt(plink->aek, 32, iv_crypt, iv_crypt_len
, 3, aad, aad_len, ampe_buf);
rtw_mfree(iv_crypt, iv_crypt_len);
if (verify_ret) {
RTW_WARN("verify error, aek_valid=%u\n", plink->aek_valid);
goto exit;
} else if (*ampe_buf != WLAN_EID_AMPE) {
RTW_WARN("plaintext is not AMPE IE\n");
goto exit;
} else if ( 16 /* AES_BLOCK_SIZE*/ + 2 + *(ampe_buf + 1) > iv_crypt_len) {
RTW_WARN("plaintext AMPE IE length is not valid\n");
goto exit;
}
ret = _SUCCESS;
exit:
return ret;
}
static int rtw_mpm_ampe_enc(_adapter *adapter, struct mesh_plink_ent *plink
, u8* fbody, u8 *mic_ie, u8 *ampe_buf, bool inverse)
{
int ret = _FAIL, protect_ret;
const u8 *aad[3];
const size_t aad_len[3] = {ETH_ALEN, ETH_ALEN, mic_ie - fbody};
u8 *ampe_ie;
size_t ampe_ie_len = *(ampe_buf + 1) + 2; /* including id & len */
if (inverse) {
aad[0] = plink->addr;
aad[1] = adapter_mac_addr(adapter);
} else {
aad[0] = adapter_mac_addr(adapter);
aad[1] = plink->addr;
}
aad[2] = fbody;
ampe_ie = rtw_malloc(ampe_ie_len);
if (!ampe_ie)
goto exit;
_rtw_memcpy(ampe_ie, ampe_buf, ampe_ie_len);
protect_ret = rtw_aes_siv_encrypt(plink->aek, 32, ampe_ie, ampe_ie_len
, 3, aad, aad_len, mic_ie + 2);
rtw_mfree(ampe_ie, ampe_ie_len);
if (protect_ret) {
RTW_WARN("protect error, aek_valid=%u\n", plink->aek_valid);
goto exit;
}
ret = _SUCCESS;
exit:
return ret;
}
#endif /* CONFIG_RTW_MESH_AEK */
static int rtw_mpm_tx_ies_sync_bss(_adapter *adapter, struct mesh_plink_ent *plink
, u8 *fhead, size_t flen, u8* fbody, u8 tlv_ies_offset, u8 *mpm_ie, u8 *mic_ie
, u8 **nbuf, size_t *nlen)
{
int ret = _FAIL;
struct mlme_priv *mlme = &(adapter->mlmepriv);
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *mlmeinfo = &(mlmeext->mlmext_info);
WLAN_BSSID_EX *network = &(mlmeinfo->network);
uint left;
u8 *pos;
uint mpm_ielen = *(mpm_ie + 1);
u8 *fpos;
u8 *new_buf = NULL;
size_t new_len = 0;
u8 *new_fhead;
size_t new_flen;
u8 *new_fbody;
u8 *new_mic_ie;
#ifdef CONFIG_RTW_MESH_AEK
u8 *ampe_buf = NULL;
size_t ampe_buf_len = 0;
/* decode */
if (mic_ie) {
ampe_buf_len = flen - (mic_ie + 2 + 16 /* AES_BLOCK_SIZE */ - fhead);
ampe_buf = rtw_malloc(ampe_buf_len);
if (!ampe_buf)
goto exit;
if (rtw_mpm_ampe_dec(adapter, plink, fhead, flen, fbody, mic_ie, ampe_buf) != _SUCCESS)
goto exit;
if (*(ampe_buf + 1) >= 68) {
_rtw_memcpy(plink->sel_pcs, ampe_buf + 2, 4);
_rtw_memcpy(plink->l_nonce, ampe_buf + 6, 32);
_rtw_memcpy(plink->p_nonce, ampe_buf + 38, 32);
}
}
#endif
/* count for new frame length */
new_len = sizeof(struct rtw_ieee80211_hdr_3addr) + tlv_ies_offset;
left = BSS_EX_TLV_IES_LEN(network);
pos = BSS_EX_TLV_IES(network);
while (left >= 2) {
u8 id, elen;
id = *pos++;
elen = *pos++;
left -= 2;
if (elen > left)
break;
switch (id) {
case WLAN_EID_SSID:
case WLAN_EID_DS_PARAMS:
case WLAN_EID_TIM:
break;
default:
new_len += 2 + elen;
}
left -= elen;
pos += elen;
}
new_len += mpm_ielen + 2;
if (mic_ie)
new_len += 16 /* AES_BLOCK_SIZE*/ + 2 + ampe_buf_len;
/* alloc new frame */
new_buf = rtw_malloc(new_len);
if (!new_buf) {
rtw_warn_on(1);
goto exit;
}
/* build new frame */
_rtw_memcpy(new_buf, fhead, sizeof(struct rtw_ieee80211_hdr_3addr) + tlv_ies_offset);
new_fhead = new_buf;
new_flen = new_len;
new_fbody = new_fhead + sizeof(struct rtw_ieee80211_hdr_3addr);
fpos = new_fbody + tlv_ies_offset;
left = BSS_EX_TLV_IES_LEN(network);
pos = BSS_EX_TLV_IES(network);
while (left >= 2) {
u8 id, elen;
id = *pos++;
elen = *pos++;
left -= 2;
if (elen > left)
break;
switch (id) {
case WLAN_EID_SSID:
case WLAN_EID_DS_PARAMS:
case WLAN_EID_TIM:
break;
default:
fpos = rtw_set_ie(fpos, id, elen, pos, NULL);
if (id == WLAN_EID_MESH_CONFIG)
fpos = rtw_set_ie(fpos, WLAN_EID_MPM, mpm_ielen, mpm_ie + 2, NULL);
}
left -= elen;
pos += elen;
}
if (mic_ie) {
new_mic_ie = fpos;
*fpos++ = WLAN_EID_MIC;
*fpos++ = 16 /* AES_BLOCK_SIZE */;
}
#ifdef CONFIG_RTW_MESH_AEK
/* encode */
if (mic_ie) {
int enc_ret = rtw_mpm_ampe_enc(adapter, plink, new_fbody, new_mic_ie, ampe_buf, 0);
if (enc_ret != _SUCCESS)
goto exit;
}
#endif
*nlen = new_len;
*nbuf = new_buf;
ret = _SUCCESS;
exit:
if (ret != _SUCCESS && new_buf)
rtw_mfree(new_buf, new_len);
#ifdef CONFIG_RTW_MESH_AEK
if (ampe_buf)
rtw_mfree(ampe_buf, ampe_buf_len);
#endif
return ret;
}
#endif /* CONFIG_RTW_MPM_TX_IES_SYNC_BSS */
struct mpm_frame_info {
u8 *aid;
u16 aid_v;
u8 *pid;
u16 pid_v;
u8 *llid;
u16 llid_v;
u8 *plid;
u16 plid_v;
u8 *reason;
u16 reason_v;
u8 *chosen_pmk;
};
/*
* pid:00000 llid:00000 chosen_pmk:0x00000000000000000000000000000000
* aid:00000 pid:00000 llid:00000 plid:00000 chosen_pmk:0x00000000000000000000000000000000
* pid:00000 llid:00000 plid:00000 reason:00000 chosen_pmk:0x00000000000000000000000000000000
*/
#define MPM_LOG_BUF_LEN 92 /* this length is limited for legal combination */
static void rtw_mpm_info_msg(struct mpm_frame_info *mpm_info, u8 *mpm_log_buf)
{
int cnt = 0;
if (mpm_info->aid) {
cnt += snprintf(mpm_log_buf + cnt, MPM_LOG_BUF_LEN - cnt - 1, "aid:%u ", mpm_info->aid_v);
if (cnt >= MPM_LOG_BUF_LEN - 1)
goto exit;
}
if (mpm_info->pid) {
cnt += snprintf(mpm_log_buf + cnt, MPM_LOG_BUF_LEN - cnt - 1, "pid:%u ", mpm_info->pid_v);
if (cnt >= MPM_LOG_BUF_LEN - 1)
goto exit;
}
if (mpm_info->llid) {
cnt += snprintf(mpm_log_buf + cnt, MPM_LOG_BUF_LEN - cnt - 1, "llid:%u ", mpm_info->llid_v);
if (cnt >= MPM_LOG_BUF_LEN - 1)
goto exit;
}
if (mpm_info->plid) {
cnt += snprintf(mpm_log_buf + cnt, MPM_LOG_BUF_LEN - cnt - 1, "plid:%u ", mpm_info->plid_v);
if (cnt >= MPM_LOG_BUF_LEN - 1)
goto exit;
}
if (mpm_info->reason) {
cnt += snprintf(mpm_log_buf + cnt, MPM_LOG_BUF_LEN - cnt - 1, "reason:%u ", mpm_info->reason_v);
if (cnt >= MPM_LOG_BUF_LEN - 1)
goto exit;
}
if (mpm_info->chosen_pmk) {
cnt += snprintf(mpm_log_buf + cnt, MPM_LOG_BUF_LEN - cnt - 1, "chosen_pmk:0x"KEY_FMT, KEY_ARG(mpm_info->chosen_pmk));
if (cnt >= MPM_LOG_BUF_LEN - 1)
goto exit;
}
exit:
return;
}
static int rtw_mpm_check_frames(_adapter *adapter, u8 action, const u8 **buf, size_t *len, u8 tx)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *plink = NULL;
u8 *nbuf = NULL;
size_t nlen = 0;
u8 *fhead = (u8 *)*buf;
size_t flen = *len;
u8 *peer_addr = tx ? GetAddr1Ptr(fhead) : get_addr2_ptr(fhead);
u8 *frame_body = fhead + sizeof(struct rtw_ieee80211_hdr_3addr);
struct mpm_frame_info mpm_info;
u8 tlv_ies_offset;
u8 *mpm_ie = NULL;
uint mpm_ielen = 0;
u8 *mic_ie = NULL;
uint mic_ielen = 0;
int ret = 0;
u8 mpm_log_buf[MPM_LOG_BUF_LEN] = {0};
if (action == RTW_ACT_SELF_PROTECTED_MESH_OPEN)
tlv_ies_offset = 4;
else if (action == RTW_ACT_SELF_PROTECTED_MESH_CONF)
tlv_ies_offset = 6;
else if (action == RTW_ACT_SELF_PROTECTED_MESH_CLOSE)
tlv_ies_offset = 2;
else {
rtw_warn_on(1);
goto exit;
}
plink = rtw_mesh_plink_get(adapter, peer_addr);
if (!plink && (tx == _TRUE || action == RTW_ACT_SELF_PROTECTED_MESH_CONF)) {
/* warning message if no plink when: 1.TX all MPM or 2.RX CONF */
RTW_WARN("RTW_%s:%s without plink of "MAC_FMT"\n"
, (tx == _TRUE) ? "Tx" : "Rx", action_self_protected_str(action), MAC_ARG(peer_addr));
goto exit;
}
_rtw_memset(&mpm_info, 0, sizeof(struct mpm_frame_info));
if (action == RTW_ACT_SELF_PROTECTED_MESH_CONF) {
mpm_info.aid = (u8 *)frame_body + 4;
mpm_info.aid_v = RTW_GET_LE16(mpm_info.aid);
}
mpm_ie = rtw_get_ie(fhead + sizeof(struct rtw_ieee80211_hdr_3addr) + tlv_ies_offset
, WLAN_EID_MPM, &mpm_ielen
, flen - sizeof(struct rtw_ieee80211_hdr_3addr) - tlv_ies_offset);
if (!mpm_ie || mpm_ielen < 2 + 2)
goto exit;
mpm_info.pid = mpm_ie + 2;
mpm_info.pid_v = RTW_GET_LE16(mpm_info.pid);
mpm_info.llid = mpm_info.pid + 2;
mpm_info.llid_v = RTW_GET_LE16(mpm_info.llid);
switch (action) {
case RTW_ACT_SELF_PROTECTED_MESH_OPEN:
/* pid:2, llid:2, (chosen_pmk:16) */
if (mpm_info.pid_v == 0 && mpm_ielen == 4)
;
else if (mpm_info.pid_v == 1 && mpm_ielen == 20)
mpm_info.chosen_pmk = mpm_info.llid + 2;
else
goto exit;
break;
case RTW_ACT_SELF_PROTECTED_MESH_CONF:
/* pid:2, llid:2, plid:2, (chosen_pmk:16) */
mpm_info.plid = mpm_info.llid + 2;
mpm_info.plid_v = RTW_GET_LE16(mpm_info.plid);
if (mpm_info.pid_v == 0 && mpm_ielen == 6)
;
else if (mpm_info.pid_v == 1 && mpm_ielen == 22)
mpm_info.chosen_pmk = mpm_info.plid + 2;
else
goto exit;
break;
case RTW_ACT_SELF_PROTECTED_MESH_CLOSE:
/* pid:2, llid:2, (plid:2), reason:2, (chosen_pmk:16) */
if (mpm_info.pid_v == 0 && mpm_ielen == 6) {
/* MPM, without plid */
mpm_info.reason = mpm_info.llid + 2;
mpm_info.reason_v = RTW_GET_LE16(mpm_info.reason);
} else if (mpm_info.pid_v == 0 && mpm_ielen == 8) {
/* MPM, with plid */
mpm_info.plid = mpm_info.llid + 2;
mpm_info.plid_v = RTW_GET_LE16(mpm_info.plid);
mpm_info.reason = mpm_info.plid + 2;
mpm_info.reason_v = RTW_GET_LE16(mpm_info.reason);
} else if (mpm_info.pid_v == 1 && mpm_ielen == 22) {
/* AMPE, without plid */
mpm_info.reason = mpm_info.llid + 2;
mpm_info.reason_v = RTW_GET_LE16(mpm_info.reason);
mpm_info.chosen_pmk = mpm_info.reason + 2;
} else if (mpm_info.pid_v == 1 && mpm_ielen == 24) {
/* AMPE, with plid */
mpm_info.plid = mpm_info.llid + 2;
mpm_info.plid_v = RTW_GET_LE16(mpm_info.plid);
mpm_info.reason = mpm_info.plid + 2;
mpm_info.reason_v = RTW_GET_LE16(mpm_info.reason);
mpm_info.chosen_pmk = mpm_info.reason + 2;
} else
goto exit;
break;
};
if (mpm_info.pid_v == 1) {
mic_ie = rtw_get_ie(fhead + sizeof(struct rtw_ieee80211_hdr_3addr) + tlv_ies_offset
, WLAN_EID_MIC, &mic_ielen
, flen - sizeof(struct rtw_ieee80211_hdr_3addr) - tlv_ies_offset);
if (!mic_ie || mic_ielen != 16 /* AES_BLOCK_SIZE */)
goto exit;
}
#if CONFIG_RTW_MPM_TX_IES_SYNC_BSS
if ((action == RTW_ACT_SELF_PROTECTED_MESH_OPEN || action == RTW_ACT_SELF_PROTECTED_MESH_CONF)
&& tx == _TRUE
) {
#define DBG_RTW_MPM_TX_IES_SYNC_BSS 0
if (mpm_info.pid_v == 1 && (!plink || !MESH_PLINK_AEK_VALID(plink))) {
RTW_WARN("AEK not ready, IEs can't sync with BSS\n");
goto bypass_sync_bss;
}
if (DBG_RTW_MPM_TX_IES_SYNC_BSS) {
RTW_INFO(FUNC_ADPT_FMT" before:\n", FUNC_ADPT_ARG(adapter));
dump_ies(RTW_DBGDUMP
, fhead + sizeof(struct rtw_ieee80211_hdr_3addr) + tlv_ies_offset
, flen - sizeof(struct rtw_ieee80211_hdr_3addr) - tlv_ies_offset);
}
rtw_mpm_tx_ies_sync_bss(adapter, plink
, fhead, flen, frame_body, tlv_ies_offset, mpm_ie, mic_ie
, &nbuf, &nlen);
if (!nbuf)
goto exit;
/* update pointer & len for new frame */
fhead = nbuf;
flen = nlen;
frame_body = fhead + sizeof(struct rtw_ieee80211_hdr_3addr);
if (mpm_info.pid_v == 1) {
mic_ie = rtw_get_ie(fhead + sizeof(struct rtw_ieee80211_hdr_3addr) + tlv_ies_offset
, WLAN_EID_MIC, &mic_ielen
, flen - sizeof(struct rtw_ieee80211_hdr_3addr) - tlv_ies_offset);
}
if (DBG_RTW_MPM_TX_IES_SYNC_BSS) {
RTW_INFO(FUNC_ADPT_FMT" after:\n", FUNC_ADPT_ARG(adapter));
dump_ies(RTW_DBGDUMP
, fhead + sizeof(struct rtw_ieee80211_hdr_3addr) + tlv_ies_offset
, flen - sizeof(struct rtw_ieee80211_hdr_3addr) - tlv_ies_offset);
}
}
bypass_sync_bss:
#endif /* CONFIG_RTW_MPM_TX_IES_SYNC_BSS */
if (!plink)
goto mpm_log;
#if CONFIG_RTW_MESH_PEER_BLACKLIST
if (action == RTW_ACT_SELF_PROTECTED_MESH_OPEN) {
if (tx)
rtw_mesh_plink_set_peer_conf_timeout(adapter, peer_addr);
} else
#endif
#if CONFIG_RTW_MESH_ACNODE_PREVENT
if (action == RTW_ACT_SELF_PROTECTED_MESH_CLOSE) {
if (tx && mpm_info.reason && mpm_info.reason_v == WLAN_REASON_MESH_MAX_PEERS) {
if (rtw_mesh_scanned_is_acnode_confirmed(adapter, plink->scanned)
&& rtw_mesh_acnode_prevent_allow_sacrifice(adapter)
) {
struct sta_info *sac = rtw_mesh_acnode_prevent_pick_sacrifice(adapter);
if (sac) {
struct sta_priv *stapriv = &adapter->stapriv;
u8 sta_addr[ETH_ALEN];
u8 updated = _FALSE;
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
if (!rtw_is_list_empty(&sac->asoc_list)) {
rtw_list_delete(&sac->asoc_list);
stapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (sac->tbtx_enable)
stapriv->tbtx_asoc_list_cnt--;
#endif
STA_SET_MESH_PLINK(sac, NULL);
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
RTW_INFO(FUNC_ADPT_FMT" sacrifice "MAC_FMT" for acnode\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sac->phl_sta->mac_addr));
_rtw_memcpy(sta_addr, sac->phl_sta->mac_addr, ETH_ALEN);
updated = ap_free_sta(adapter, sac, 0, 0, 1, 0);
rtw_mesh_expire_peer(stapriv->padapter, sta_addr);
associated_clients_update(adapter, updated, STA_INFO_UPDATE_ALL);
}
}
}
} else
#endif
if (action == RTW_ACT_SELF_PROTECTED_MESH_CONF) {
u8 *ies = NULL;
u16 ies_len = 0;
_rtw_spinlock_bh(&(plink_ctl->lock));
plink = _rtw_mesh_plink_get(adapter, peer_addr);
if (!plink)
goto release_plink_ctl;
if (tx == _FALSE) {
ies = plink->rx_conf_ies;
ies_len = plink->rx_conf_ies_len;
plink->rx_conf_ies = NULL;
plink->rx_conf_ies_len = 0;
plink->llid = mpm_info.plid_v;
plink->plid = mpm_info.llid_v;
plink->peer_aid = mpm_info.aid_v;
if (mpm_info.pid_v == 1)
_rtw_memcpy(plink->chosen_pmk, mpm_info.chosen_pmk, 16);
}
#ifdef CONFIG_RTW_MESH_DRIVER_AID
else {
ies = plink->tx_conf_ies;
ies_len = plink->tx_conf_ies_len;
plink->tx_conf_ies = NULL;
plink->tx_conf_ies_len = 0;
}
#endif
if (ies && ies_len)
rtw_mfree(ies, ies_len);
#ifndef CONFIG_RTW_MESH_DRIVER_AID
if (tx == _TRUE)
goto release_plink_ctl; /* no need to copy tx conf ies */
#endif
/* copy mesh confirm IEs */
if (mpm_info.pid_v == 1) /* not include MIC & encrypted AMPE */
ies_len = (mic_ie - fhead) - sizeof(struct rtw_ieee80211_hdr_3addr) - 2;
else
ies_len = flen - sizeof(struct rtw_ieee80211_hdr_3addr) - 2;
ies = rtw_zmalloc(ies_len);
if (ies) {
_rtw_memcpy(ies, fhead + sizeof(struct rtw_ieee80211_hdr_3addr) + 2, ies_len);
if (tx == _FALSE) {
plink->rx_conf_ies = ies;
plink->rx_conf_ies_len = ies_len;
}
#ifdef CONFIG_RTW_MESH_DRIVER_AID
else {
plink->tx_conf_ies = ies;
plink->tx_conf_ies_len = ies_len;
}
#endif
}
release_plink_ctl:
_rtw_spinunlock_bh(&(plink_ctl->lock));
}
mpm_log:
rtw_mpm_info_msg(&mpm_info, mpm_log_buf);
RTW_INFO("RTW_%s:%s %s\n"
, (tx == _TRUE) ? "Tx" : "Rx"
, action_self_protected_str(action)
, mpm_log_buf
);
ret = 1;
exit:
if (nbuf) {
if (ret == 1) {
*buf = nbuf;
*len = nlen;
} else
rtw_mfree(nbuf, nlen);
}
return ret;
}
static int rtw_mesh_check_frames(_adapter *adapter, const u8 **buf, size_t *len, u8 tx)
{
int is_mesh_frame = -1;
const u8 *frame_body;
u8 category, action;
frame_body = *buf + sizeof(struct rtw_ieee80211_hdr_3addr);
category = frame_body[0];
if (category == RTW_WLAN_CATEGORY_SELF_PROTECTED) {
action = frame_body[1];
switch (action) {
case RTW_ACT_SELF_PROTECTED_MESH_OPEN:
case RTW_ACT_SELF_PROTECTED_MESH_CONF:
case RTW_ACT_SELF_PROTECTED_MESH_CLOSE:
rtw_mpm_check_frames(adapter, action, buf, len, tx);
is_mesh_frame = action;
break;
case RTW_ACT_SELF_PROTECTED_MESH_GK_INFORM:
case RTW_ACT_SELF_PROTECTED_MESH_GK_ACK:
RTW_INFO("RTW_%s:%s\n", (tx == _TRUE) ? "Tx" : "Rx", action_self_protected_str(action));
is_mesh_frame = action;
break;
default:
break;
};
}
return is_mesh_frame;
}
int rtw_mesh_check_frames_tx(_adapter *adapter, const u8 **buf, size_t *len)
{
return rtw_mesh_check_frames(adapter, buf, len, _TRUE);
}
int rtw_mesh_check_frames_rx(_adapter *adapter, const u8 *buf, size_t len)
{
return rtw_mesh_check_frames(adapter, &buf, &len, _FALSE);
}
int rtw_mesh_on_auth(_adapter *adapter, union recv_frame *rframe)
{
u8 *whdr = rframe->u.hdr.rx_data;
#if CONFIG_RTW_MACADDR_ACL
if (rtw_access_ctrl(adapter, get_addr2_ptr(whdr)) == _FALSE)
return _SUCCESS;
#endif
if (!rtw_mesh_plink_get(adapter, get_addr2_ptr(whdr))) {
#if CONFIG_RTW_MESH_ACNODE_PREVENT
rtw_mesh_acnode_set_notify_etime(adapter, whdr);
#endif
if (adapter_to_rfctl(adapter)->offch_state == OFFCHS_NONE)
issue_probereq(adapter, &adapter->mlmepriv.cur_network.network.mesh_id, get_addr2_ptr(whdr));
/* only peer being added (checked by notify conditions) is allowed */
return _SUCCESS;
}
rtw_cfg80211_rx_mframe(adapter, rframe, NULL);
return _SUCCESS;
}
unsigned int on_action_self_protected(_adapter *adapter, union recv_frame *rframe)
{
unsigned int ret = _FAIL;
struct sta_info *sta = NULL;
u8 *pframe = rframe->u.hdr.rx_data;
uint frame_len = rframe->u.hdr.len;
u8 *frame_body = (u8 *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
u8 category;
u8 action;
/* check RA matches or not */
if (!_rtw_memcmp(adapter_mac_addr(adapter), GetAddr1Ptr(pframe), ETH_ALEN))
goto exit;
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_SELF_PROTECTED)
goto exit;
action = frame_body[1];
switch (action) {
case RTW_ACT_SELF_PROTECTED_MESH_OPEN:
case RTW_ACT_SELF_PROTECTED_MESH_CONF:
case RTW_ACT_SELF_PROTECTED_MESH_CLOSE:
case RTW_ACT_SELF_PROTECTED_MESH_GK_INFORM:
case RTW_ACT_SELF_PROTECTED_MESH_GK_ACK:
if (!(MLME_IS_MESH(adapter) && MLME_IS_ASOC(adapter)))
goto exit;
#ifdef CONFIG_IOCTL_CFG80211
#if CONFIG_RTW_MACADDR_ACL
if (rtw_access_ctrl(adapter, get_addr2_ptr(pframe)) == _FALSE)
goto exit;
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
if (rtw_mesh_cto_mgate_required(adapter)
/* only peer being added (checked by notify conditions) is allowed */
&& !rtw_mesh_plink_get(adapter, get_addr2_ptr(pframe)))
goto exit;
#endif
rtw_cfg80211_rx_action(adapter, rframe, NULL);
ret = _SUCCESS;
#endif /* CONFIG_IOCTL_CFG80211 */
break;
default:
break;
}
exit:
return ret;
}
const u8 ae_to_mesh_ctrl_len[] = {
6,
12, /* MESH_FLAGS_AE_A4 */
18, /* MESH_FLAGS_AE_A5_A6 */
0,
};
unsigned int on_action_mesh(_adapter *adapter, union recv_frame *rframe)
{
unsigned int ret = _FAIL;
struct sta_info *sta = NULL;
struct sta_priv *stapriv = &adapter->stapriv;
u8 *pframe = rframe->u.hdr.rx_data;
uint frame_len = rframe->u.hdr.len;
u8 *frame_body = (u8 *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
u8 category;
u8 action;
if (!MLME_IS_MESH(adapter))
goto exit;
/* check stainfo exist? */
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_MESH)
goto exit;
action = frame_body[1];
switch (action) {
case RTW_ACT_MESH_HWMP_PATH_SELECTION:
rtw_mesh_rx_path_sel_frame(adapter, rframe);
ret = _SUCCESS;
break;
default:
break;
}
exit:
return ret;
}
bool rtw_mesh_update_bss_peering_status(_adapter *adapter, WLAN_BSSID_EX *bss)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
u8 num_of_peerings = stapriv->asoc_list_cnt;
bool accept_peerings = stapriv->asoc_list_cnt < mcfg->max_peer_links;
u8 *ie;
int ie_len;
bool updated = 0;
#if CONFIG_RTW_MESH_ACNODE_PREVENT
accept_peerings |= plink_ctl->acnode_rsvd;
#endif
ie = rtw_get_ie(BSS_EX_TLV_IES(bss), WLAN_EID_MESH_CONFIG, &ie_len, BSS_EX_TLV_IES_LEN(bss));
if (!ie || ie_len != 7) {
rtw_warn_on(1);
goto exit;
}
if (GET_MESH_CONF_ELE_NUM_OF_PEERINGS(ie + 2) != num_of_peerings) {
SET_MESH_CONF_ELE_NUM_OF_PEERINGS(ie + 2, num_of_peerings);
updated = 1;
}
if (GET_MESH_CONF_ELE_ACCEPT_PEERINGS(ie + 2) != accept_peerings) {
SET_MESH_CONF_ELE_ACCEPT_PEERINGS(ie + 2, accept_peerings);
updated = 1;
}
exit:
return updated;
}
bool rtw_mesh_update_bss_formation_info(_adapter *adapter, WLAN_BSSID_EX *bss)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
u8 cto_mgate = (minfo->num_gates || mcfg->dot11MeshGateAnnouncementProtocol);
u8 cto_as = 0;
u8 *ie;
int ie_len;
bool updated = 0;
ie = rtw_get_ie(BSS_EX_TLV_IES(bss), WLAN_EID_MESH_CONFIG, &ie_len,
BSS_EX_TLV_IES_LEN(bss));
if (!ie || ie_len != 7) {
rtw_warn_on(1);
goto exit;
}
if (GET_MESH_CONF_ELE_CTO_MGATE(ie + 2) != cto_mgate) {
SET_MESH_CONF_ELE_CTO_MGATE(ie + 2, cto_mgate);
updated = 1;
}
if (GET_MESH_CONF_ELE_CTO_AS(ie + 2) != cto_as) {
SET_MESH_CONF_ELE_CTO_AS(ie + 2, cto_as);
updated = 1;
}
exit:
return updated;
}
bool rtw_mesh_update_bss_forwarding_state(_adapter *adapter, WLAN_BSSID_EX *bss)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
u8 forward = mcfg->dot11MeshForwarding;
u8 *ie;
int ie_len;
bool updated = 0;
ie = rtw_get_ie(BSS_EX_TLV_IES(bss), WLAN_EID_MESH_CONFIG, &ie_len,
BSS_EX_TLV_IES_LEN(bss));
if (!ie || ie_len != 7) {
rtw_warn_on(1);
goto exit;
}
if (GET_MESH_CONF_ELE_FORWARDING(ie + 2) != forward) {
SET_MESH_CONF_ELE_FORWARDING(ie + 2, forward);
updated = 1;
}
exit:
return updated;
}
struct mesh_plink_ent *_rtw_mesh_plink_get(_adapter *adapter, const u8 *hwaddr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
int i;
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++) {
if (plink_ctl->ent[i].valid == _TRUE
&& _rtw_memcmp(plink_ctl->ent[i].addr, hwaddr, ETH_ALEN) == _TRUE
) {
ent = &plink_ctl->ent[i];
break;
}
}
return ent;
}
struct mesh_plink_ent *rtw_mesh_plink_get(_adapter *adapter, const u8 *hwaddr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
_rtw_spinlock_bh(&(plink_ctl->lock));
ent = _rtw_mesh_plink_get(adapter, hwaddr);
_rtw_spinunlock_bh(&(plink_ctl->lock));
return ent;
}
struct mesh_plink_ent *rtw_mesh_plink_get_no_estab_by_idx(_adapter *adapter, u8 idx)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
int i, j = 0;
_rtw_spinlock_bh(&(plink_ctl->lock));
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++) {
if (plink_ctl->ent[i].valid == _TRUE
&& plink_ctl->ent[i].plink_state != RTW_MESH_PLINK_ESTAB
) {
if (j == idx) {
ent = &plink_ctl->ent[i];
break;
}
j++;
}
}
_rtw_spinunlock_bh(&(plink_ctl->lock));
return ent;
}
int _rtw_mesh_plink_add(_adapter *adapter, const u8 *hwaddr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
u8 exist = _FALSE;
int i;
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++) {
if (plink_ctl->ent[i].valid == _TRUE
&& _rtw_memcmp(plink_ctl->ent[i].addr, hwaddr, ETH_ALEN) == _TRUE
) {
ent = &plink_ctl->ent[i];
exist = _TRUE;
break;
}
if (ent == NULL && plink_ctl->ent[i].valid == _FALSE)
ent = &plink_ctl->ent[i];
}
if (exist == _FALSE && ent) {
_rtw_memcpy(ent->addr, hwaddr, ETH_ALEN);
ent->valid = _TRUE;
#ifdef CONFIG_RTW_MESH_AEK
ent->aek_valid = 0;
#endif
ent->llid = 0;
ent->plid = 0;
_rtw_memset(ent->chosen_pmk, 0, 16);
#ifdef CONFIG_RTW_MESH_AEK
_rtw_memset(ent->sel_pcs, 0, 4);
_rtw_memset(ent->l_nonce, 0, 32);
_rtw_memset(ent->p_nonce, 0, 32);
#endif
ent->plink_state = RTW_MESH_PLINK_LISTEN;
#ifndef CONFIG_RTW_MESH_DRIVER_AID
ent->aid = 0;
#endif
ent->peer_aid = 0;
SET_PEER_CONF_DISABLED(ent);
SET_CTO_MGATE_CONF_DISABLED(ent);
plink_ctl->num++;
}
return exist == _TRUE ? RTW_ALREADY : (ent ? _SUCCESS : _FAIL);
}
int rtw_mesh_plink_add(_adapter *adapter, const u8 *hwaddr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
int ret;
_rtw_spinlock_bh(&(plink_ctl->lock));
ret = _rtw_mesh_plink_add(adapter, hwaddr);
_rtw_spinunlock_bh(&(plink_ctl->lock));
return ret;
}
int rtw_mesh_plink_set_state(_adapter *adapter, const u8 *hwaddr, u8 state)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
_rtw_spinlock_bh(&(plink_ctl->lock));
ent = _rtw_mesh_plink_get(adapter, hwaddr);
if (ent)
ent->plink_state = state;
_rtw_spinunlock_bh(&(plink_ctl->lock));
return ent ? _SUCCESS : _FAIL;
}
#ifdef CONFIG_RTW_MESH_AEK
int rtw_mesh_plink_set_aek(_adapter *adapter, const u8 *hwaddr, const u8 *aek)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
_rtw_spinlock_bh(&(plink_ctl->lock));
ent = _rtw_mesh_plink_get(adapter, hwaddr);
if (ent) {
_rtw_memcpy(ent->aek, aek, 32);
ent->aek_valid = 1;
}
_rtw_spinunlock_bh(&(plink_ctl->lock));
return ent ? _SUCCESS : _FAIL;
}
#endif
#if CONFIG_RTW_MESH_PEER_BLACKLIST
int rtw_mesh_plink_set_peer_conf_timeout(_adapter *adapter, const u8 *hwaddr)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
_rtw_spinlock_bh(&(plink_ctl->lock));
ent = _rtw_mesh_plink_get(adapter, hwaddr);
if (ent) {
if (IS_PEER_CONF_DISABLED(ent))
SET_PEER_CONF_END_TIME(ent, mcfg->peer_sel_policy.peer_conf_timeout_ms);
}
_rtw_spinunlock_bh(&(plink_ctl->lock));
return ent ? _SUCCESS : _FAIL;
}
#endif
void _rtw_mesh_plink_del_ent(_adapter *adapter, struct mesh_plink_ent *ent)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
ent->valid = _FALSE;
#ifdef CONFIG_RTW_MESH_DRIVER_AID
if (ent->tx_conf_ies && ent->tx_conf_ies_len)
rtw_mfree(ent->tx_conf_ies, ent->tx_conf_ies_len);
ent->tx_conf_ies = NULL;
ent->tx_conf_ies_len = 0;
#endif
if (ent->rx_conf_ies && ent->rx_conf_ies_len)
rtw_mfree(ent->rx_conf_ies, ent->rx_conf_ies_len);
ent->rx_conf_ies = NULL;
ent->rx_conf_ies_len = 0;
if (ent->scanned)
ent->scanned = NULL;
plink_ctl->num--;
}
int rtw_mesh_plink_del(_adapter *adapter, const u8 *hwaddr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent = NULL;
u8 exist = _FALSE;
int i;
_rtw_spinlock_bh(&(plink_ctl->lock));
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++) {
if (plink_ctl->ent[i].valid == _TRUE
&& _rtw_memcmp(plink_ctl->ent[i].addr, hwaddr, ETH_ALEN) == _TRUE
) {
ent = &plink_ctl->ent[i];
exist = _TRUE;
break;
}
}
if (exist == _TRUE)
_rtw_mesh_plink_del_ent(adapter, ent);
_rtw_spinunlock_bh(&(plink_ctl->lock));
return exist == _TRUE ? _SUCCESS : RTW_ALREADY;
}
void rtw_mesh_plink_ctl_init(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
int i;
_rtw_spinlock_init(&plink_ctl->lock);
plink_ctl->num = 0;
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++)
plink_ctl->ent[i].valid = _FALSE;
#if CONFIG_RTW_MESH_PEER_BLACKLIST
_rtw_init_queue(&plink_ctl->peer_blacklist);
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
_rtw_init_queue(&plink_ctl->cto_mgate_blacklist);
#endif
}
void rtw_mesh_plink_ctl_deinit(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent;
int i;
_rtw_spinlock_bh(&(plink_ctl->lock));
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++) {
ent = &plink_ctl->ent[i];
#ifdef CONFIG_RTW_MESH_DRIVER_AID
if (ent->tx_conf_ies && ent->tx_conf_ies_len)
rtw_mfree(ent->tx_conf_ies, ent->tx_conf_ies_len);
#endif
if (ent->rx_conf_ies && ent->rx_conf_ies_len)
rtw_mfree(ent->rx_conf_ies, ent->rx_conf_ies_len);
}
_rtw_spinunlock_bh(&(plink_ctl->lock));
_rtw_spinlock_free(&plink_ctl->lock);
#if CONFIG_RTW_MESH_PEER_BLACKLIST
rtw_mesh_peer_blacklist_flush(adapter);
_rtw_deinit_queue(&plink_ctl->peer_blacklist);
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
rtw_mesh_cto_mgate_blacklist_flush(adapter);
_rtw_deinit_queue(&plink_ctl->cto_mgate_blacklist);
#endif
}
void dump_mesh_plink_ctl(void *sel, _adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *ent;
int i;
RTW_PRINT_SEL(sel, "num:%u\n", plink_ctl->num);
#if CONFIG_RTW_MESH_ACNODE_PREVENT
RTW_PRINT_SEL(sel, "acnode_rsvd:%u\n", plink_ctl->acnode_rsvd);
#endif
for (i = 0; i < RTW_MESH_MAX_PEER_CANDIDATES; i++) {
ent = &plink_ctl->ent[i];
if (!ent->valid)
continue;
RTW_PRINT_SEL(sel, "\n");
RTW_PRINT_SEL(sel, "peer:"MAC_FMT"\n", MAC_ARG(ent->addr));
RTW_PRINT_SEL(sel, "plink_state:%s\n", rtw_mesh_plink_str(ent->plink_state));
#ifdef CONFIG_RTW_MESH_AEK
if (ent->aek_valid)
RTW_PRINT_SEL(sel, "aek:"KEY_FMT KEY_FMT"\n", KEY_ARG(ent->aek), KEY_ARG(ent->aek + 16));
#endif
RTW_PRINT_SEL(sel, "llid:%u, plid:%u\n", ent->llid, ent->plid);
#ifndef CONFIG_RTW_MESH_DRIVER_AID
RTW_PRINT_SEL(sel, "aid:%u\n", ent->aid);
#endif
RTW_PRINT_SEL(sel, "peer_aid:%u\n", ent->peer_aid);
RTW_PRINT_SEL(sel, "chosen_pmk:"KEY_FMT"\n", KEY_ARG(ent->chosen_pmk));
#ifdef CONFIG_RTW_MESH_AEK
RTW_PRINT_SEL(sel, "sel_pcs:%02x%02x%02x%02x\n"
, ent->sel_pcs[0], ent->sel_pcs[1], ent->sel_pcs[2], ent->sel_pcs[3]);
RTW_PRINT_SEL(sel, "l_nonce:"KEY_FMT KEY_FMT"\n", KEY_ARG(ent->l_nonce), KEY_ARG(ent->l_nonce + 16));
RTW_PRINT_SEL(sel, "p_nonce:"KEY_FMT KEY_FMT"\n", KEY_ARG(ent->p_nonce), KEY_ARG(ent->p_nonce + 16));
#endif
#ifdef CONFIG_RTW_MESH_DRIVER_AID
RTW_PRINT_SEL(sel, "tx_conf_ies:%p, len:%u\n", ent->tx_conf_ies, ent->tx_conf_ies_len);
#endif
RTW_PRINT_SEL(sel, "rx_conf_ies:%p, len:%u\n", ent->rx_conf_ies, ent->rx_conf_ies_len);
RTW_PRINT_SEL(sel, "scanned:%p\n", ent->scanned);
#if CONFIG_RTW_MESH_PEER_BLACKLIST
if (!IS_PEER_CONF_DISABLED(ent)) {
if (!IS_PEER_CONF_TIMEOUT(ent))
RTW_PRINT_SEL(sel, "peer_conf:%d\n", rtw_systime_to_ms(ent->peer_conf_end_time - rtw_get_current_time()));
else
RTW_PRINT_SEL(sel, "peer_conf:TIMEOUT\n");
}
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
if (!IS_CTO_MGATE_CONF_DISABLED(ent)) {
if (!IS_CTO_MGATE_CONF_TIMEOUT(ent))
RTW_PRINT_SEL(sel, "cto_mgate_conf:%d\n", rtw_systime_to_ms(ent->cto_mgate_conf_end_time - rtw_get_current_time()));
else
RTW_PRINT_SEL(sel, "cto_mgate_conf:TIMEOUT\n");
}
#endif
}
}
/* this function is called with plink_ctl being locked */
static int rtw_mesh_peer_establish(_adapter *adapter, struct mesh_plink_ent *plink, struct sta_info *sta)
{
#ifndef DBG_RTW_MESH_PEER_ESTABLISH
#define DBG_RTW_MESH_PEER_ESTABLISH 0
#endif
struct sta_priv *stapriv = &adapter->stapriv;
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
u8 *tlv_ies;
u16 tlv_ieslen;
struct rtw_ieee802_11_elems elems;
int i;
u16 status = 0;
int ret = _FAIL;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
u8 sta_tbtx_enable = _FALSE;
#endif
if (!plink->rx_conf_ies || !plink->rx_conf_ies_len) {
RTW_INFO(FUNC_ADPT_FMT" no rx confirm from sta "MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
goto exit;
}
if (plink->rx_conf_ies_len < 4) {
RTW_INFO(FUNC_ADPT_FMT" confirm from sta "MAC_FMT" too short\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
goto exit;
}
#ifdef CONFIG_RTW_MESH_DRIVER_AID
if (!plink->tx_conf_ies || !plink->tx_conf_ies_len) {
RTW_INFO(FUNC_ADPT_FMT" no tx confirm to sta "MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
goto exit;
}
if (plink->tx_conf_ies_len < 4) {
RTW_INFO(FUNC_ADPT_FMT" confirm to sta "MAC_FMT" too short\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
goto exit;
}
#endif
tlv_ies = plink->rx_conf_ies + 4;
tlv_ieslen = plink->rx_conf_ies_len - 4;
if (DBG_RTW_MESH_PEER_ESTABLISH)
dump_ies(RTW_DBGDUMP, tlv_ies, tlv_ieslen);
if (rtw_ieee802_11_parse_elems(tlv_ies, tlv_ieslen, &elems, 1) == ParseFailed) {
RTW_INFO(FUNC_ADPT_FMT" sta "MAC_FMT" sent invalid confirm\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
goto exit;
}
SET_PEER_CONF_DISABLED(plink);
if (rtw_bss_is_cto_mgate(&plink->scanned->network)
&& !rtw_bss_is_forwarding(&plink->scanned->network))
SET_CTO_MGATE_CONF_END_TIME(plink, mcfg->peer_sel_policy.cto_mgate_conf_timeout_ms);
else
SET_CTO_MGATE_CONF_DISABLED(plink);
sta->state &= (~WIFI_FW_AUTH_SUCCESS);
sta->state |= WIFI_FW_ASSOC_STATE;
rtw_ap_parse_sta_capability(adapter, sta, plink->rx_conf_ies);
status = rtw_ap_parse_sta_supported_rates(adapter, sta, tlv_ies, tlv_ieslen);
if (status != _STATS_SUCCESSFUL_)
goto exit;
status = rtw_ap_parse_sta_security_ie(adapter, sta, &elems);
if (status != _STATS_SUCCESSFUL_) {
RTW_INFO(FUNC_ADPT_FMT" security check fail, status=%u\n", FUNC_ADPT_ARG(adapter), status);
goto exit;
}
rtw_ap_parse_sta_wmm_ie(adapter, sta, tlv_ies, tlv_ieslen);
#ifdef CONFIG_RTS_FULL_BW
/*check vendor IE*/
rtw_parse_sta_vendor_ie_8812(adapter, sta, tlv_ies, tlv_ieslen);
#endif/*CONFIG_RTS_FULL_BW*/
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (elems.tbtx_cap && elems.tbtx_cap_len != 0) {
if(rtw_is_tbtx_capabilty(elems.tbtx_cap, elems.tbtx_cap_len)) {
sta_tbtx_enable = _TRUE;
}
}
#endif
rtw_ap_parse_sta_ht_ie(adapter, sta, &elems);
rtw_ap_parse_sta_vht_ie(adapter, sta, &elems);
/* AID */
#ifdef CONFIG_RTW_MESH_DRIVER_AID
sta->phl_sta->aid = RTW_GET_LE16(plink->tx_conf_ies + 2);
#else
sta->phl_sta->aid = plink->aid;
#endif
stapriv->sta_aid[sta->phl_sta->aid - 1] = sta;
RTW_INFO(FUNC_ADPT_FMT" sta "MAC_FMT" aid:%u\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr), sta->phl_sta->aid);
sta->state &= (~WIFI_FW_ASSOC_STATE);
sta->state |= WIFI_FW_ASSOC_SUCCESS;
sta->local_mps = RTW_MESH_PS_ACTIVE;
rtw_ewma_err_rate_init(&sta->metrics.err_rate);
rtw_ewma_err_rate_add(&sta->metrics.err_rate, 1);
/* init data_rate to 1M */
sta->metrics.data_rate = 10;
sta->alive = _TRUE;
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
if (rtw_is_list_empty(&sta->asoc_list)) {
STA_SET_MESH_PLINK(sta, plink);
/* TBD: up layer timeout mechanism */
/* sta->expire_to = mcfg->plink_timeout / 2; */
rtw_list_insert_tail(&sta->asoc_list, &stapriv->asoc_list);
stapriv->asoc_list_cnt++;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (sta_tbtx_enable) {
sta->tbtx_enable = _TRUE;
stapriv->tbtx_asoc_list_cnt++;
}
#endif
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
bss_cap_update_on_sta_join(adapter, sta);
sta_info_update(adapter, sta);
report_add_sta_event(adapter, sta->phl_sta->mac_addr);
ret = _SUCCESS;
exit:
return ret;
}
int rtw_mesh_set_plink_state(_adapter *adapter, const u8 *mac, u8 plink_state)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *plink = NULL;
_irqL irqL2;
struct sta_priv *stapriv = &adapter->stapriv;
struct sta_info *sta = NULL;
_irqL irqL;
struct sta_info *del_sta = NULL;
int ret = _SUCCESS;
_rtw_spinlock_bh(&(plink_ctl->lock), &irqL2);
plink = _rtw_mesh_plink_get(adapter, mac);
if (!plink) {
ret = _FAIL;
goto release_plink_ctl;
}
plink->plink_state = plink_state;
#if CONFIG_RTW_MESH_ACNODE_PREVENT
if (plink_state == RTW_MESH_PLINK_OPN_SNT) {
if (rtw_mesh_scanned_is_acnode_confirmed(adapter, plink->scanned)
&& rtw_mesh_acnode_prevent_allow_sacrifice(adapter)
) {
struct sta_info *sac = rtw_mesh_acnode_prevent_pick_sacrifice(adapter);
if (sac) {
del_sta = sac;
_rtw_spinlock_bh(&stapriv->asoc_list_lock, &irqL);
if (!rtw_is_list_empty(&del_sta->asoc_list)) {
rtw_list_delete(&del_sta->asoc_list);
stapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (del_sta->tbtx_enable)
stapriv->tbtx_asoc_list_cnt--;
#endif
STA_SET_MESH_PLINK(del_sta, NULL);
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock, &irqL);
RTW_INFO(FUNC_ADPT_FMT" sacrifice "MAC_FMT" for acnode\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(del_sta->phl_sta->mac_addr));
}
}
} else
#endif
if (plink_state == RTW_MESH_PLINK_OPN_RCVD
|| plink_state == RTW_MESH_PLINK_CNF_RCVD
|| plink_state == RTW_MESH_PLINK_ESTAB
) {
sta = rtw_get_stainfo(stapriv, mac);
if (!sta) {
sta = rtw_alloc_stainfo(stapriv, mac);
if (!sta)
goto release_plink_ctl;
}
if (plink_state == RTW_MESH_PLINK_ESTAB) {
if (rtw_mesh_peer_establish(adapter, plink, sta) != _SUCCESS) {
del_sta = sta;
ret = _FAIL;
goto release_plink_ctl;
}
}
}
else if (plink_state == RTW_MESH_PLINK_HOLDING) {
del_sta = rtw_get_stainfo(stapriv, mac);
if (!del_sta)
goto release_plink_ctl;
_rtw_spinlock_bh(&stapriv->asoc_list_lock, &irqL);
if (!rtw_is_list_empty(&del_sta->asoc_list)) {
rtw_list_delete(&del_sta->asoc_list);
stapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (del_sta->tbtx_enable)
stapriv->tbtx_asoc_list_cnt--;
#endif
STA_SET_MESH_PLINK(del_sta, NULL);
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock, &irqL);
}
release_plink_ctl:
_rtw_spinunlock_bh(&(plink_ctl->lock), &irqL2);
if (del_sta) {
u8 sta_addr[ETH_ALEN];
u8 updated = _FALSE;
_rtw_memcpy(sta_addr, del_sta->phl_sta->mac_addr, ETH_ALEN);
updated = ap_free_sta(adapter, del_sta, 0, 0, 1, 0);
rtw_mesh_expire_peer(stapriv->padapter, sta_addr);
associated_clients_update(adapter, updated, STA_INFO_UPDATE_ALL);
}
return ret;
}
struct mesh_set_plink_cmd_parm {
const u8 *mac;
u8 plink_state;
};
u8 rtw_mesh_set_plink_state_cmd_hdl(_adapter *adapter, u8 *parmbuf)
{
struct mesh_set_plink_cmd_parm *parm = (struct mesh_set_plink_cmd_parm *)parmbuf;
if (rtw_mesh_set_plink_state(adapter, parm->mac, parm->plink_state) == _SUCCESS)
return H2C_SUCCESS;
return H2C_CMD_FAIL;
}
u8 rtw_mesh_set_plink_state_cmd(_adapter *adapter, const u8 *mac, u8 plink_state)
{
struct cmd_obj *cmdobj;
struct mesh_set_plink_cmd_parm *parm;
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
/* prepare cmd parameter */
parm = rtw_zmalloc(sizeof(*parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
parm->mac = mac;
parm->plink_state = plink_state;
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree(parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_MESH_PLINK_STATE);
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
if (res == _SUCCESS) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&cmdpriv->sctx_mutex, NULL);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&cmdpriv->sctx_mutex, NULL);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
exit:
return res;
}
void rtw_mesh_expire_peer_notify(_adapter *adapter, const u8 *peer_addr)
{
u8 null_ssid[2] = {0, 0};
#ifdef CONFIG_IOCTL_CFG80211
rtw_cfg80211_notify_new_peer_candidate(adapter->rtw_wdev
, peer_addr
, null_ssid
, 2
, 0
, GFP_ATOMIC
);
#endif
return;
}
static u8 *rtw_mesh_construct_peer_mesh_close(_adapter *adapter, struct mesh_plink_ent *plink, u16 reason, u32 *len)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
u8 *frame = NULL, *pos;
u32 flen;
struct rtw_ieee80211_hdr *whdr;
if (minfo->mesh_auth_id && !MESH_PLINK_AEK_VALID(plink))
goto exit;
flen = sizeof(struct rtw_ieee80211_hdr_3addr)
+ 2 /* category, action */
+ 2 + minfo->mesh_id_len /* mesh id */
+ 2 + 8 + (minfo->mesh_auth_id ? 16 : 0) /* mpm */
+ (minfo->mesh_auth_id ? 2 + 16 /* AES_BLOCK_SIZE */ : 0) /* mic */
+ (minfo->mesh_auth_id ? 70 : 0) /* ampe */
;
pos = frame = rtw_zmalloc(flen);
if (!frame)
goto exit;
whdr = (struct rtw_ieee80211_hdr *)frame;
_rtw_memcpy(whdr->addr1, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(whdr->addr2, plink->addr, ETH_ALEN);
_rtw_memcpy(whdr->addr3, adapter_mac_addr(adapter), ETH_ALEN);
set_frame_sub_type(frame, WIFI_ACTION);
pos += sizeof(struct rtw_ieee80211_hdr_3addr);
*(pos++) = RTW_WLAN_CATEGORY_SELF_PROTECTED;
*(pos++) = RTW_ACT_SELF_PROTECTED_MESH_CLOSE;
pos = rtw_set_ie_mesh_id(pos, NULL, minfo->mesh_id, minfo->mesh_id_len);
pos = rtw_set_ie_mpm(pos, NULL
, minfo->mesh_auth_id ? 1 : 0
, plink->plid
, &plink->llid
, &reason
, minfo->mesh_auth_id ? plink->chosen_pmk : NULL);
#ifdef CONFIG_RTW_MESH_AEK
if (minfo->mesh_auth_id) {
u8 ampe_buf[70];
int enc_ret;
*pos = WLAN_EID_MIC;
*(pos + 1) = 16 /* AES_BLOCK_SIZE */;
ampe_buf[0] = WLAN_EID_AMPE;
ampe_buf[1] = 68;
_rtw_memcpy(ampe_buf + 2, plink->sel_pcs, 4);
_rtw_memcpy(ampe_buf + 6, plink->p_nonce, 32);
_rtw_memcpy(ampe_buf + 38, plink->l_nonce, 32);
enc_ret = rtw_mpm_ampe_enc(adapter, plink
, frame + sizeof(struct rtw_ieee80211_hdr_3addr)
, pos, ampe_buf, 1);
if (enc_ret != _SUCCESS) {
rtw_mfree(frame, flen);
frame = NULL;
goto exit;
}
}
#endif
*len = flen;
exit:
return frame;
}
void _rtw_mesh_expire_peer_ent(_adapter *adapter, struct mesh_plink_ent *plink)
{
#if defined(CONFIG_RTW_MESH_STA_DEL_DISASOC)
_rtw_mesh_plink_del_ent(adapter, plink);
rtw_cfg80211_indicate_sta_disassoc(adapter, plink->addr, 0);
#else
u8 *frame = NULL;
u32 flen;
if (plink->plink_state == RTW_MESH_PLINK_ESTAB)
frame = rtw_mesh_construct_peer_mesh_close(adapter, plink, WLAN_REASON_MESH_CLOSE, &flen);
if (frame) {
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct wireless_dev *wdev = adapter->rtw_wdev;
s32 freq = rtw_ch2freq(mlmeext->chandef.chan);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) || defined(COMPAT_KERNEL_RELEASE)
rtw_cfg80211_rx_mgmt(wdev, freq, 0, frame, flen, GFP_ATOMIC);
#else
cfg80211_rx_action(adapter->pnetdev, freq, frame, flen, GFP_ATOMIC);
#endif
rtw_mfree(frame, flen);
} else {
rtw_mesh_expire_peer_notify(adapter, plink->addr);
RTW_INFO(FUNC_ADPT_FMT" set "MAC_FMT" plink unknown\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(plink->addr));
plink->plink_state = RTW_MESH_PLINK_UNKNOWN;
}
#endif
}
void rtw_mesh_expire_peer(_adapter *adapter, const u8 *peer_addr)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct mesh_plink_pool *plink_ctl = &minfo->plink_ctl;
struct mesh_plink_ent *plink;
_rtw_spinlock_bh(&(plink_ctl->lock));
plink = _rtw_mesh_plink_get(adapter, peer_addr);
if (!plink)
goto exit;
_rtw_mesh_expire_peer_ent(adapter, plink);
exit:
_rtw_spinunlock_bh(&(plink_ctl->lock));
}
u8 rtw_mesh_ps_annc(_adapter *adapter, u8 ps)
{
_list *head, *list;
struct sta_info *sta;
struct sta_priv *stapriv = &adapter->stapriv;
u8 sta_alive_num = 0, i;
char sta_alive_list[NUM_STA];
u8 annc_cnt = 0;
if (rtw_linked_check(adapter) == _FALSE)
goto exit;
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
head = &stapriv->asoc_list;
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
int stainfo_offset;
sta = LIST_CONTAINOR(list, struct sta_info, asoc_list);
list = get_next(list);
stainfo_offset = rtw_stainfo_offset(stapriv, sta);
if (stainfo_offset_valid(stainfo_offset))
sta_alive_list[sta_alive_num++] = stainfo_offset;
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
for (i = 0; i < sta_alive_num; i++) {
sta = rtw_get_stainfo_by_offset(stapriv, sta_alive_list[i]);
if (!sta)
continue;
issue_qos_nulldata(adapter, sta->phl_sta->mac_addr, 7, ps, 3, 500, _FALSE);
annc_cnt++;
}
exit:
return annc_cnt;
}
static void mpath_tx_tasklet_hdl(void *priv)
{
_adapter *adapter = (_adapter *)priv;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct xmit_frame *xframe;
_list *list, *head;
_list tmp;
u32 tmp_len;
s32 res;
_rtw_init_listhead(&tmp);
while (1) {
tmp_len = 0;
_rtw_spinlock_bh(&minfo->mpath_tx_queue.lock);
if (minfo->mpath_tx_queue_len) {
rtw_list_splice_init(&minfo->mpath_tx_queue.queue, &tmp);
tmp_len = minfo->mpath_tx_queue_len;
minfo->mpath_tx_queue_len = 0;
}
_rtw_spinunlock_bh(&minfo->mpath_tx_queue.lock);
if (!tmp_len)
break;
head = &tmp;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
xframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&xframe->list);
res = rtw_xmit_posthandle(adapter, xframe, xframe->pkt);
if (res < 0) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s rtw_xmit fail\n", __FUNCTION__);
#endif
adapter->xmitpriv.tx_drop++;
}
}
}
}
static void rtw_mpath_tx_queue_flush(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct xmit_frame *xframe;
_list *list, *head;
_list tmp;
_rtw_init_listhead(&tmp);
_rtw_spinlock_bh(&minfo->mpath_tx_queue.lock);
rtw_list_splice_init(&minfo->mpath_tx_queue.queue, &tmp);
minfo->mpath_tx_queue_len = 0;
_rtw_spinunlock_bh(&minfo->mpath_tx_queue.lock);
head = &tmp;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
xframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&xframe->list);
rtw_free_xmitframe(&adapter->xmitpriv, xframe);
}
}
#ifdef PLATFORM_LINUX /* 3.10 ~ 4.13 checked */
#if defined(CONFIG_SLUB)
#include <linux/slub_def.h>
#elif defined(CONFIG_SLAB)
#include <linux/slab_def.h>
#endif
typedef struct kmem_cache rtw_mcache;
#endif
rtw_mcache *rtw_mcache_create(const char *name, size_t size)
{
#ifdef PLATFORM_LINUX /* 3.10 ~ 4.13 checked */
return kmem_cache_create(name, size, 0, 0, NULL);
#else
#error "TBD\n";
#endif
}
void rtw_mcache_destroy(rtw_mcache *s)
{
#ifdef PLATFORM_LINUX /* 3.10 ~ 4.13 checked */
kmem_cache_destroy(s);
#else
#error "TBD\n";
#endif
}
void *_rtw_mcache_alloc(rtw_mcache *cachep)
{
#ifdef PLATFORM_LINUX /* 3.10 ~ 4.13 checked */
return kmem_cache_alloc(cachep, GFP_ATOMIC);
#else
#error "TBD\n";
#endif
}
void _rtw_mcache_free(rtw_mcache *cachep, void *objp)
{
#ifdef PLATFORM_LINUX /* 3.10 ~ 4.13 checked */
kmem_cache_free(cachep, objp);
#else
#error "TBD\n";
#endif
}
#ifdef DBG_MEM_ALLOC
inline void *dbg_rtw_mcache_alloc(rtw_mcache *cachep, const enum mstat_f flags, const char *func, const int line)
{
void *p;
u32 sz = cachep->size;
if (match_mstat_sniff_rules(flags, sz))
RTW_INFO("DBG_MEM_ALLOC %s:%d %s(%u)\n", func, line, __func__, sz);
p = _rtw_mcache_alloc(cachep);
rtw_mstat_update(
flags
, p ? MSTAT_ALLOC_SUCCESS : MSTAT_ALLOC_FAIL
, sz
);
return p;
}
inline void dbg_rtw_mcache_free(rtw_mcache *cachep, void *pbuf, const enum mstat_f flags, const char *func, const int line)
{
u32 sz = cachep->size;
if (match_mstat_sniff_rules(flags, sz))
RTW_INFO("DBG_MEM_ALLOC %s:%d %s(%u)\n", func, line, __func__, sz);
_rtw_mcache_free(cachep, pbuf);
rtw_mstat_update(
flags
, MSTAT_FREE
, sz
);
}
#define rtw_mcache_alloc(cachep) dbg_rtw_mcache_alloc(cachep, MSTAT_TYPE_PHY, __FUNCTION__, __LINE__)
#define rtw_mcache_free(cachep, objp) dbg_rtw_mcache_free(cachep, objp, MSTAT_TYPE_PHY, __FUNCTION__, __LINE__)
#else
#define rtw_mcache_alloc(cachep) _rtw_mcache_alloc(cachep)
#define rtw_mcache_free(cachep, objp) _rtw_mcache_free(cachep, objp)
#endif /* DBG_MEM_ALLOC */
/* Mesh Received Cache */
#define RTW_MRC_BUCKETS 256 /* must be a power of 2 */
#define RTW_MRC_QUEUE_MAX_LEN 4
#define RTW_MRC_TIMEOUT_MS (3 * 1000)
/**
* struct rtw_mrc_entry - entry in the Mesh Received Cache
*
* @seqnum: mesh sequence number of the frame
* @exp_time: expiration time of the entry
* @msa: mesh source address of the frame
* @list: hashtable list pointer
*
* The Mesh Received Cache keeps track of the latest received frames that
* have been received by a mesh interface and discards received frames
* that are found in the cache.
*/
struct rtw_mrc_entry {
rtw_hlist_node list;
systime exp_time;
u32 seqnum;
u8 msa[ETH_ALEN];
};
struct rtw_mrc {
rtw_hlist_head bucket[RTW_MRC_BUCKETS];
u32 idx_mask;
rtw_mcache *cache;
};
static int rtw_mrc_init(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
char cache_name[IFNAMSIZ + 8 + 1];
int i;
minfo->mrc = rtw_malloc(sizeof(struct rtw_mrc));
if (!minfo->mrc)
return -ENOMEM;
minfo->mrc->idx_mask = RTW_MRC_BUCKETS - 1;
for (i = 0; i < RTW_MRC_BUCKETS; i++)
rtw_hlist_head_init(&minfo->mrc->bucket[i]);
sprintf(cache_name, "rtw_mrc_%s", ADPT_ARG(adapter));
minfo->mrc->cache = rtw_mcache_create(cache_name, sizeof(struct rtw_mrc_entry));
return 0;
}
static void rtw_mrc_free(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mrc *mrc = minfo->mrc;
struct rtw_mrc_entry *p;
rtw_hlist_node *np, *n;
int i;
if (!mrc)
return;
for (i = 0; i < RTW_MRC_BUCKETS; i++) {
rtw_hlist_for_each_entry_safe(p, np, n, &mrc->bucket[i], list) {
rtw_hlist_del(&p->list);
rtw_mcache_free(mrc->cache, p);
}
}
rtw_mcache_destroy(mrc->cache);
rtw_mfree(mrc, sizeof(struct rtw_mrc));
minfo->mrc = NULL;
}
/**
* rtw_mrc_check - Check frame in mesh received cache and add if absent.
*
* @adapter: interface
* @msa: mesh source address
* @seq: mesh seq number
*
* Returns: 0 if the frame is not in the cache, nonzero otherwise.
*
* Checks using the mesh source address and the mesh sequence number if we have
* received this frame lately. If the frame is not in the cache, it is added to
* it.
*/
static int rtw_mrc_check(_adapter *adapter, const u8 *msa, u32 seq)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mrc *mrc = minfo->mrc;
int entries = 0;
u8 idx;
struct rtw_mrc_entry *p;
rtw_hlist_node *np, *n;
u8 timeout;
if (!mrc)
return -1;
idx = seq & mrc->idx_mask;
rtw_hlist_for_each_entry_safe(p, np, n, &mrc->bucket[idx], list) {
++entries;
timeout = rtw_time_after(rtw_get_current_time(), p->exp_time);
if (timeout || entries == RTW_MRC_QUEUE_MAX_LEN) {
if (!timeout)
minfo->mshstats.mrc_del_qlen++;
rtw_hlist_del(&p->list);
rtw_mcache_free(mrc->cache, p);
--entries;
} else if ((seq == p->seqnum) && _rtw_memcmp(msa, p->msa, ETH_ALEN) == _TRUE)
return -1;
}
p = rtw_mcache_alloc(mrc->cache);
if (!p)
return 0;
p->seqnum = seq;
p->exp_time = rtw_get_current_time() + rtw_ms_to_systime(RTW_MRC_TIMEOUT_MS);
_rtw_memcpy(p->msa, msa, ETH_ALEN);
rtw_hlist_add_head(&p->list, &mrc->bucket[idx]);
return 0;
}
static int rtw_mesh_decache(_adapter *adapter, const u8 *msa, u32 seq)
{
return rtw_mrc_check(adapter, msa, seq);
}
#ifndef RTW_MESH_SCAN_RESULT_EXP_MS
#define RTW_MESH_SCAN_RESULT_EXP_MS (10 * 1000)
#endif
#ifndef RTW_MESH_ACNODE_PREVENT
#define RTW_MESH_ACNODE_PREVENT 0
#endif
#ifndef RTW_MESH_ACNODE_CONF_TIMEOUT_MS
#define RTW_MESH_ACNODE_CONF_TIMEOUT_MS (20 * 1000)
#endif
#ifndef RTW_MESH_ACNODE_NOTIFY_TIMEOUT_MS
#define RTW_MESH_ACNODE_NOTIFY_TIMEOUT_MS (2 * 1000)
#endif
#ifndef RTW_MESH_OFFCH_CAND
#define RTW_MESH_OFFCH_CAND 1
#endif
#ifndef RTW_MESH_OFFCH_CAND_FIND_INT_MS
#define RTW_MESH_OFFCH_CAND_FIND_INT_MS (10 * 1000)
#endif
#ifndef RTW_MESH_PEER_CONF_TIMEOUT_MS
#define RTW_MESH_PEER_CONF_TIMEOUT_MS (20 * 1000)
#endif
#ifndef RTW_MESH_PEER_BLACKLIST_TIMEOUT_MS
#define RTW_MESH_PEER_BLACKLIST_TIMEOUT_MS (20 * 1000)
#endif
#ifndef RTW_MESH_CTO_MGATE_REQUIRE
#define RTW_MESH_CTO_MGATE_REQUIRE 0
#endif
#ifndef RTW_MESH_CTO_MGATE_CONF_TIMEOUT_MS
#define RTW_MESH_CTO_MGATE_CONF_TIMEOUT_MS (20 * 1000)
#endif
#ifndef RTW_MESH_CTO_MGATE_BLACKLIST_TIMEOUT_MS
#define RTW_MESH_CTO_MGATE_BLACKLIST_TIMEOUT_MS (20 * 1000)
#endif
void rtw_mesh_cfg_init_peer_sel_policy(struct rtw_mesh_cfg *mcfg)
{
struct mesh_peer_sel_policy *sel_policy = &mcfg->peer_sel_policy;
sel_policy->scanr_exp_ms = RTW_MESH_SCAN_RESULT_EXP_MS;
#if CONFIG_RTW_MESH_ACNODE_PREVENT
sel_policy->acnode_prevent = RTW_MESH_ACNODE_PREVENT;
sel_policy->acnode_conf_timeout_ms = RTW_MESH_ACNODE_CONF_TIMEOUT_MS;
sel_policy->acnode_notify_timeout_ms = RTW_MESH_ACNODE_NOTIFY_TIMEOUT_MS;
#endif
#if CONFIG_RTW_MESH_OFFCH_CAND
sel_policy->offch_cand = RTW_MESH_OFFCH_CAND;
sel_policy->offch_find_int_ms = RTW_MESH_OFFCH_CAND_FIND_INT_MS;
#endif
#if CONFIG_RTW_MESH_PEER_BLACKLIST
sel_policy->peer_conf_timeout_ms = RTW_MESH_PEER_CONF_TIMEOUT_MS;
sel_policy->peer_blacklist_timeout_ms = RTW_MESH_PEER_BLACKLIST_TIMEOUT_MS;
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
sel_policy->cto_mgate_require = RTW_MESH_CTO_MGATE_REQUIRE;
sel_policy->cto_mgate_conf_timeout_ms = RTW_MESH_CTO_MGATE_CONF_TIMEOUT_MS;
sel_policy->cto_mgate_blacklist_timeout_ms = RTW_MESH_CTO_MGATE_BLACKLIST_TIMEOUT_MS;
#endif
}
void rtw_mesh_cfg_init(_adapter *adapter)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
mcfg->max_peer_links = RTW_MESH_MAX_PEER_LINKS;
mcfg->plink_timeout = RTW_MESH_PEER_LINK_TIMEOUT;
mcfg->dot11MeshTTL = RTW_MESH_TTL;
mcfg->element_ttl = RTW_MESH_DEFAULT_ELEMENT_TTL;
mcfg->dot11MeshHWMPmaxPREQretries = RTW_MESH_MAX_PREQ_RETRIES;
mcfg->path_refresh_time = RTW_MESH_PATH_REFRESH_TIME;
mcfg->min_discovery_timeout = RTW_MESH_MIN_DISCOVERY_TIMEOUT;
mcfg->dot11MeshHWMPactivePathTimeout = RTW_MESH_PATH_TIMEOUT;
mcfg->dot11MeshHWMPpreqMinInterval = RTW_MESH_PREQ_MIN_INT;
mcfg->dot11MeshHWMPperrMinInterval = RTW_MESH_PERR_MIN_INT;
mcfg->dot11MeshHWMPnetDiameterTraversalTime = RTW_MESH_DIAM_TRAVERSAL_TIME;
mcfg->dot11MeshHWMPRootMode = RTW_IEEE80211_ROOTMODE_NO_ROOT;
mcfg->dot11MeshHWMPRannInterval = RTW_MESH_RANN_INTERVAL;
mcfg->dot11MeshGateAnnouncementProtocol = _FALSE;
mcfg->dot11MeshForwarding = _TRUE;
mcfg->rssi_threshold = 0;
mcfg->dot11MeshHWMPactivePathToRootTimeout = RTW_MESH_PATH_TO_ROOT_TIMEOUT;
mcfg->dot11MeshHWMProotInterval = RTW_MESH_ROOT_INTERVAL;
mcfg->dot11MeshHWMPconfirmationInterval = RTW_MESH_ROOT_CONFIRMATION_INTERVAL;
mcfg->path_gate_timeout_factor = 3;
rtw_mesh_cfg_init_peer_sel_policy(mcfg);
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
mcfg->sane_metric_delta = RTW_MESH_SANE_METRIC_DELTA;
mcfg->max_root_add_chk_cnt = RTW_MESH_MAX_ROOT_ADD_CHK_CNT;
#endif
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
mcfg->b2u_flags_msrc = 0;
mcfg->b2u_flags_mfwd = RTW_MESH_B2U_GA_UCAST;
#endif
}
void rtw_mesh_cfg_init_max_peer_links(_adapter *adapter, u8 stack_conf)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
mcfg->max_peer_links = RTW_MESH_MAX_PEER_LINKS;
if (mcfg->max_peer_links > stack_conf)
mcfg->max_peer_links = stack_conf;
}
void rtw_mesh_cfg_init_plink_timeout(_adapter *adapter, u32 stack_conf)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
mcfg->plink_timeout = stack_conf;
}
void rtw_mesh_init_mesh_info(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
_rtw_memset(minfo, 0, sizeof(struct rtw_mesh_info));
rtw_mesh_plink_ctl_init(adapter);
minfo->last_preq = rtw_get_current_time();
/* minfo->last_sn_update = rtw_get_current_time(); */
minfo->next_perr = rtw_get_current_time();
ATOMIC_SET(&minfo->mpaths, 0);
rtw_mesh_pathtbl_init(adapter);
_rtw_init_queue(&minfo->mpath_tx_queue);
tasklet_init(&minfo->mpath_tx_tasklet
, (void(*)(unsigned long))mpath_tx_tasklet_hdl
, (unsigned long)adapter);
rtw_mrc_init(adapter);
_rtw_init_listhead(&minfo->preq_queue.list);
_rtw_spinlock_init(&minfo->mesh_preq_queue_lock);
rtw_init_timer(&adapter->mesh_path_timer, rtw_ieee80211_mesh_path_timer, adapter);
rtw_init_timer(&adapter->mesh_path_root_timer, rtw_ieee80211_mesh_path_root_timer, adapter);
rtw_init_timer(&adapter->mesh_atlm_param_req_timer, rtw_mesh_atlm_param_req_timer, adapter);
_init_workitem(&adapter->mesh_work, rtw_mesh_work_hdl, NULL);
}
void rtw_mesh_deinit_mesh_info(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
tasklet_kill(&minfo->mpath_tx_tasklet);
rtw_mpath_tx_queue_flush(adapter);
_rtw_deinit_queue(&adapter->mesh_info.mpath_tx_queue);
rtw_mrc_free(adapter);
rtw_mesh_pathtbl_unregister(adapter);
rtw_mesh_plink_ctl_deinit(adapter);
_cancel_workitem_sync(&adapter->mesh_work);
_cancel_timer_ex(&adapter->mesh_path_timer);
_cancel_timer_ex(&adapter->mesh_path_root_timer);
_cancel_timer_ex(&adapter->mesh_atlm_param_req_timer);
}
/**
* rtw_mesh_nexthop_resolve - lookup next hop; conditionally start path discovery
*
* @skb: 802.11 frame to be sent
* @sdata: network subif the frame will be sent through
*
* Lookup next hop for given skb and start path discovery if no
* forwarding information is found.
*
* Returns: 0 if the next hop was found and -ENOENT if the frame was queued.
* skb is freeed here if no mpath could be allocated.
*/
int rtw_mesh_nexthop_resolve(_adapter *adapter,
struct xmit_frame *xframe)
{
struct pkt_attrib *attrib = &xframe->attrib;
struct rtw_mesh_path *mpath;
struct xmit_frame *xframe_to_free = NULL;
u8 *target_addr = attrib->mda;
int err = 0;
int ret = _SUCCESS;
rtw_rcu_read_lock();
err = rtw_mesh_nexthop_lookup(adapter, target_addr, attrib->msa, attrib->ra);
if (!err)
goto endlookup;
/* no nexthop found, start resolving */
mpath = rtw_mesh_path_lookup(adapter, target_addr);
if (!mpath) {
mpath = rtw_mesh_path_add(adapter, target_addr);
if (IS_ERR(mpath)) {
xframe->pkt = NULL; /* free pkt outside */
rtw_mesh_path_discard_frame(adapter, xframe);
err = PTR_ERR(mpath);
ret = _FAIL;
goto endlookup;
}
}
if (!(mpath->flags & RTW_MESH_PATH_RESOLVING))
rtw_mesh_queue_preq(mpath, RTW_PREQ_Q_F_START);
_rtw_spinlock_bh(&mpath->frame_queue.lock);
if (mpath->frame_queue_len >= RTW_MESH_FRAME_QUEUE_LEN) {
xframe_to_free = LIST_CONTAINOR(get_next(get_list_head(&mpath->frame_queue)), struct xmit_frame, list);
rtw_list_delete(&(xframe_to_free->list));
mpath->frame_queue_len--;
}
rtw_list_insert_tail(&xframe->list, get_list_head(&mpath->frame_queue));
mpath->frame_queue_len++;
_rtw_spinunlock_bh(&mpath->frame_queue.lock);
ret = RTW_RA_RESOLVING;
if (xframe_to_free)
rtw_mesh_path_discard_frame(adapter, xframe_to_free);
endlookup:
rtw_rcu_read_unlock();
return ret;
}
/**
* rtw_mesh_nexthop_lookup - put the appropriate next hop on a mesh frame. Calling
* this function is considered "using" the associated mpath, so preempt a path
* refresh if this mpath expires soon.
*
* @skb: 802.11 frame to be sent
* @sdata: network subif the frame will be sent through
*
* Returns: 0 if the next hop was found. Nonzero otherwise.
*/
int rtw_mesh_nexthop_lookup(_adapter *adapter,
const u8 *mda, const u8 *msa, u8 *ra)
{
struct rtw_mesh_path *mpath;
struct sta_info *next_hop;
const u8 *target_addr = mda;
int err = -ENOENT;
struct registry_priv *registry_par = &adapter->registrypriv;
u8 peer_alive_based_preq = registry_par->peer_alive_based_preq;
BOOLEAN nexthop_alive = _TRUE;
rtw_rcu_read_lock();
mpath = rtw_mesh_path_lookup(adapter, target_addr);
if (!mpath || !(mpath->flags & RTW_MESH_PATH_ACTIVE))
goto endlookup;
next_hop = rtw_rcu_dereference(mpath->next_hop);
if (next_hop) {
_rtw_memcpy(ra, next_hop->phl_sta->mac_addr, ETH_ALEN);
err = 0;
}
if (peer_alive_based_preq && next_hop)
nexthop_alive = next_hop->alive;
if (_rtw_memcmp(adapter_mac_addr(adapter), msa, ETH_ALEN) == _TRUE &&
!(mpath->flags & RTW_MESH_PATH_RESOLVING) &&
!(mpath->flags & RTW_MESH_PATH_FIXED)) {
u8 flags = RTW_PREQ_Q_F_START | RTW_PREQ_Q_F_REFRESH;
if (peer_alive_based_preq && nexthop_alive == _FALSE) {
flags |= RTW_PREQ_Q_F_BCAST_PREQ;
rtw_mesh_queue_preq(mpath, flags);
} else if (rtw_time_after(rtw_get_current_time(),
mpath->exp_time -
rtw_ms_to_systime(adapter->mesh_cfg.path_refresh_time))) {
rtw_mesh_queue_preq(mpath, flags);
}
/* Avoid keeping trying unicast PREQ toward root,
when next_hop leaves */
} else if (peer_alive_based_preq &&
_rtw_memcmp(adapter_mac_addr(adapter), msa, ETH_ALEN) == _TRUE &&
(mpath->flags & RTW_MESH_PATH_RESOLVING) &&
!(mpath->flags & RTW_MESH_PATH_FIXED) &&
!(mpath->flags & RTW_MESH_PATH_BCAST_PREQ) &&
mpath->is_root && nexthop_alive == _FALSE) {
_rtw_spinlock_bh(&mpath->state_lock);
mpath->flags |= RTW_MESH_PATH_BCAST_PREQ;
_rtw_spinunlock_bh(&mpath->state_lock);
}
endlookup:
rtw_rcu_read_unlock();
return err;
}
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
static bool rtw_mesh_data_bmc_to_uc(_adapter *adapter
, const u8 *da, const u8 *sa, const u8 *mda, const u8 *msa
, u8 ae_need, const u8 *ori_ta, u8 mfwd_ttl
, u16 os_qid, _list *b2u_list, u8 *b2u_num, u32 *b2u_mseq)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
_list *head, *list;
struct sta_info *sta;
char b2u_sta_id[NUM_STA];
u8 b2u_sta_num = 0;
bool bmc_need = _FALSE;
int i;
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
head = &stapriv->asoc_list;
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
int stainfo_offset;
sta = LIST_CONTAINOR(list, struct sta_info, asoc_list);
list = get_next(list);
stainfo_offset = rtw_stainfo_offset(stapriv, sta);
if (stainfo_offset_valid(stainfo_offset))
b2u_sta_id[b2u_sta_num++] = stainfo_offset;
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
if (!b2u_sta_num)
goto exit;
for (i = 0; i < b2u_sta_num; i++) {
struct xmit_frame *b2uframe;
struct pkt_attrib *attrib;
sta = rtw_get_stainfo_by_offset(stapriv, b2u_sta_id[i]);
if (!(sta->state & WIFI_ASOC_STATE)
|| _rtw_memcmp(sta->phl_sta->mac_addr, msa, ETH_ALEN) == _TRUE
|| (ori_ta && _rtw_memcmp(sta->phl_sta->mac_addr, ori_ta, ETH_ALEN) == _TRUE)
|| is_broadcast_mac_addr(sta->phl_sta->mac_addr)
|| is_zero_mac_addr(sta->phl_sta->mac_addr))
continue;
b2uframe = rtw_alloc_xmitframe(xmitpriv, os_qid);
if (!b2uframe) {
bmc_need = _TRUE;
break;
}
if ((*b2u_num)++ == 0 && !ori_ta) {
*b2u_mseq = (cpu_to_le32(adapter->mesh_info.mesh_seqnum));
adapter->mesh_info.mesh_seqnum++;
}
attrib = &b2uframe->attrib;
attrib->mb2u = 1;
attrib->mseq = *b2u_mseq;
attrib->mfwd_ttl = ori_ta ? mfwd_ttl : 0;
_rtw_memcpy(attrib->ra, sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(attrib->ta, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(attrib->mda, mda, ETH_ALEN);
_rtw_memcpy(attrib->msa, msa, ETH_ALEN);
_rtw_memcpy(attrib->dst, da, ETH_ALEN);
_rtw_memcpy(attrib->src, sa, ETH_ALEN);
attrib->mesh_frame_mode = ae_need ? MESH_UCAST_PX_DATA : MESH_UCAST_DATA;
rtw_list_insert_tail(&b2uframe->list, b2u_list);
}
exit:
return bmc_need;
}
void dump_mesh_b2u_flags(void *sel, _adapter *adapter)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
RTW_PRINT_SEL(sel, "%4s %4s\n", "msrc", "mfwd");
RTW_PRINT_SEL(sel, "0x%02x 0x%02x\n", mcfg->b2u_flags_msrc, mcfg->b2u_flags_mfwd);
}
#endif /* CONFIG_RTW_MESH_DATA_BMC_TO_UC */
int rtw_mesh_addr_resolve(_adapter *adapter, u16 os_qid, struct xmit_frame *xframe, _pkt *pkt, _list *b2u_list)
{
struct pkt_file pktfile;
struct ethhdr etherhdr;
struct pkt_attrib *attrib;
struct rtw_mesh_path *mpath = NULL, *mppath = NULL;
u8 is_da_mcast;
u8 ae_need;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
bool bmc_need = _TRUE;
u8 b2u_num = 0;
u32 b2u_mseq = 0;
#endif
int res = _SUCCESS;
_rtw_open_pktfile(pkt, &pktfile);
if (_rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN) != ETH_HLEN) {
res = _FAIL;
goto exit;
}
xframe->pkt = pkt;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
_rtw_init_listhead(b2u_list);
#endif
is_da_mcast = IS_MCAST(etherhdr.h_dest);
if (!is_da_mcast) {
struct sta_info *next_hop;
bool mpp_lookup = 1;
mpath = rtw_mesh_path_lookup(adapter, etherhdr.h_dest);
if (mpath) {
mpp_lookup = 0;
next_hop = rtw_rcu_dereference(mpath->next_hop);
if (!next_hop
|| !(mpath->flags & (RTW_MESH_PATH_ACTIVE | RTW_MESH_PATH_RESOLVING))
) {
/* mpath is not valid, search mppath */
mpp_lookup = 1;
}
}
if (mpp_lookup) {
mppath = rtw_mpp_path_lookup(adapter, etherhdr.h_dest);
if (mppath)
mppath->exp_time = rtw_get_current_time();
}
if (mppath && mpath)
rtw_mesh_path_del(adapter, mpath->dst);
ae_need = _rtw_memcmp(adapter_mac_addr(adapter), etherhdr.h_source, ETH_ALEN) == _FALSE
|| (mppath && _rtw_memcmp(mppath->mpp, etherhdr.h_dest, ETH_ALEN) == _FALSE);
} else {
ae_need = _rtw_memcmp(adapter_mac_addr(adapter), etherhdr.h_source, ETH_ALEN) == _FALSE;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
if (rtw_msrc_b2u_policy_chk(adapter->mesh_cfg.b2u_flags_msrc, etherhdr.h_dest)) {
bmc_need = rtw_mesh_data_bmc_to_uc(adapter
, etherhdr.h_dest, etherhdr.h_source
, etherhdr.h_dest, adapter_mac_addr(adapter), ae_need, NULL, 0
, os_qid, b2u_list, &b2u_num, &b2u_mseq);
if (bmc_need == _FALSE) {
res = RTW_ORI_NO_NEED;
goto exit;
}
}
#endif
}
attrib = &xframe->attrib;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
if (b2u_num) {
attrib->mb2u = 1;
attrib->mseq = b2u_mseq;
} else
attrib->mb2u = 0;
#endif
attrib->mfwd_ttl = 0;
_rtw_memcpy(attrib->dst, etherhdr.h_dest, ETH_ALEN);
_rtw_memcpy(attrib->src, etherhdr.h_source, ETH_ALEN);
_rtw_memcpy(attrib->ta, adapter_mac_addr(adapter), ETH_ALEN);
if (is_da_mcast) {
attrib->mesh_frame_mode = ae_need ? MESH_BMCAST_PX_DATA : MESH_BMCAST_DATA;
_rtw_memcpy(attrib->ra, attrib->dst, ETH_ALEN);
_rtw_memcpy(attrib->msa, adapter_mac_addr(adapter), ETH_ALEN);
} else {
attrib->mesh_frame_mode = ae_need ? MESH_UCAST_PX_DATA : MESH_UCAST_DATA;
_rtw_memcpy(attrib->mda, (mppath && ae_need) ? mppath->mpp : attrib->dst, ETH_ALEN);
_rtw_memcpy(attrib->msa, adapter_mac_addr(adapter), ETH_ALEN);
/* RA needs to be resolved */
res = rtw_mesh_nexthop_resolve(adapter, xframe);
}
exit:
return res;
}
s8 rtw_mesh_tx_set_whdr_mctrl_len(u8 mesh_frame_mode, struct pkt_attrib *attrib)
{
u8 ret = 0;
switch (mesh_frame_mode) {
case MESH_UCAST_DATA:
attrib->hdrlen = WLAN_HDR_A4_QOS_LEN;
/* mesh flag + mesh TTL + Mesh SN. no ext addr. */
attrib->meshctrl_len = 6;
break;
case MESH_BMCAST_DATA:
attrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
/* mesh flag + mesh TTL + Mesh SN. no ext addr. */
attrib->meshctrl_len = 6;
break;
case MESH_UCAST_PX_DATA:
attrib->hdrlen = WLAN_HDR_A4_QOS_LEN;
/* mesh flag + mesh TTL + Mesh SN + extaddr1 + extaddr2. */
attrib->meshctrl_len = 18;
break;
case MESH_BMCAST_PX_DATA:
attrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
/* mesh flag + mesh TTL + Mesh SN + extaddr1 */
attrib->meshctrl_len = 12;
break;
default:
RTW_WARN("Invalid mesh frame mode:%u\n", mesh_frame_mode);
ret = -1;
break;
}
return ret;
}
void rtw_mesh_tx_build_mctrl(_adapter *adapter, struct pkt_attrib *attrib, u8 *buf)
{
struct rtw_ieee80211s_hdr *mctrl = (struct rtw_ieee80211s_hdr *)buf;
_rtw_memset(mctrl, 0, XATTRIB_GET_MCTRL_LEN(attrib));
if (attrib->mfwd_ttl
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
|| attrib->mb2u
#endif
) {
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
if (!attrib->mfwd_ttl)
mctrl->ttl = adapter->mesh_cfg.dot11MeshTTL;
else
#endif
mctrl->ttl = attrib->mfwd_ttl;
mctrl->seqnum = (cpu_to_le32(attrib->mseq));
} else {
mctrl->ttl = adapter->mesh_cfg.dot11MeshTTL;
mctrl->seqnum = (cpu_to_le32(adapter->mesh_info.mesh_seqnum));
adapter->mesh_info.mesh_seqnum++;
}
switch (attrib->mesh_frame_mode){
case MESH_UCAST_DATA:
case MESH_BMCAST_DATA:
break;
case MESH_UCAST_PX_DATA:
mctrl->flags |= MESH_FLAGS_AE_A5_A6;
_rtw_memcpy(mctrl->eaddr1, attrib->dst, ETH_ALEN);
_rtw_memcpy(mctrl->eaddr2, attrib->src, ETH_ALEN);
break;
case MESH_BMCAST_PX_DATA:
mctrl->flags |= MESH_FLAGS_AE_A4;
_rtw_memcpy(mctrl->eaddr1, attrib->src, ETH_ALEN);
break;
case MESH_MHOP_UCAST_ACT:
/* TBD */
break;
case MESH_MHOP_BMCAST_ACT:
/* TBD */
break;
default:
break;
}
}
u8 rtw_mesh_tx_build_whdr(_adapter *adapter, struct pkt_attrib *attrib
, u16 *fctrl, struct rtw_ieee80211_hdr *whdr)
{
switch (attrib->mesh_frame_mode) {
case MESH_UCAST_DATA: /* 1, 1, RA, TA, mDA(=DA), mSA(=SA) */
case MESH_UCAST_PX_DATA: /* 1, 1, RA, TA, mDA, mSA, [DA, SA] */
SetToDs(fctrl);
SetFrDs(fctrl);
_rtw_memcpy(whdr->addr1, attrib->ra, ETH_ALEN);
_rtw_memcpy(whdr->addr2, attrib->ta, ETH_ALEN);
_rtw_memcpy(whdr->addr3, attrib->mda, ETH_ALEN);
_rtw_memcpy(whdr->addr4, attrib->msa, ETH_ALEN);
break;
case MESH_BMCAST_DATA: /* 0, 1, RA(DA), TA, mSA(SA) */
case MESH_BMCAST_PX_DATA: /* 0, 1, RA(DA), TA, mSA, [SA] */
SetFrDs(fctrl);
_rtw_memcpy(whdr->addr1, attrib->ra, ETH_ALEN);
_rtw_memcpy(whdr->addr2, attrib->ta, ETH_ALEN);
_rtw_memcpy(whdr->addr3, attrib->msa, ETH_ALEN);
break;
case MESH_MHOP_UCAST_ACT:
/* TBD */
RTW_INFO("MESH_MHOP_UCAST_ACT\n");
break;
case MESH_MHOP_BMCAST_ACT:
/* TBD */
RTW_INFO("MESH_MHOP_BMCAST_ACT\n");
break;
default:
RTW_WARN("Invalid mesh frame mode\n");
break;
}
return 0;
}
int rtw_mesh_rx_data_validate_hdr(_adapter *adapter, union recv_frame *rframe, struct sta_info **sta)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct rx_pkt_attrib *rattrib = &rframe->u.hdr.attrib;
u8 *whdr = get_recvframe_data(rframe);
u8 is_ra_bmc = 0;
u8 a4_shift = 0;
u8 ps;
u8 *qc;
u8 mps_mode = RTW_MESH_PS_UNKNOWN;
sint ret = _FAIL;
if (!(MLME_STATE(adapter) & WIFI_ASOC_STATE))
goto exit;
if (!rattrib->qos)
goto exit;
switch (rattrib->to_fr_ds) {
case 1:
if (!IS_MCAST(GetAddr1Ptr(whdr)))
goto exit;
*sta = rtw_get_stainfo(stapriv, get_addr2_ptr(whdr));
if (*sta == NULL) {
ret = _SUCCESS; /* return _SUCCESS to drop at sta checking */
goto exit;
}
_rtw_memcpy(rattrib->ra, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->ta, get_addr2_ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->mda, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->msa, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->dst, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->src, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking mesh ctrl field */
_rtw_memcpy(rattrib->bssid, get_addr2_ptr(whdr), ETH_ALEN);
is_ra_bmc = 1;
break;
case 3:
if (IS_MCAST(GetAddr1Ptr(whdr)))
goto exit;
*sta = rtw_get_stainfo(stapriv, get_addr2_ptr(whdr));
if (*sta == NULL) {
ret = _SUCCESS; /* return _SUCCESS to drop at sta checking */
goto exit;
}
_rtw_memcpy(rattrib->ra, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->ta, get_addr2_ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->mda, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->msa, GetAddr4Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->dst, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking mesh ctrl field */
_rtw_memcpy(rattrib->src, GetAddr4Ptr(whdr), ETH_ALEN); /* may change after checking mesh ctrl field */
_rtw_memcpy(rattrib->bssid, get_addr2_ptr(whdr), ETH_ALEN);
a4_shift = ETH_ALEN;
break;
default:
goto exit;
}
qc = whdr + WLAN_HDR_A3_LEN + a4_shift;
ps = GetPwrMgt(whdr);
mps_mode = ps ? (is_ra_bmc || (get_mps_lv(qc)) ? RTW_MESH_PS_DSLEEP : RTW_MESH_PS_LSLEEP) : RTW_MESH_PS_ACTIVE;
if (ps) {
if (!((*sta)->state & WIFI_SLEEP_STATE))
stop_sta_xmit(adapter, *sta);
} else {
if ((*sta)->state & WIFI_SLEEP_STATE)
wakeup_sta_to_xmit(adapter, *sta);
}
if (is_ra_bmc)
(*sta)->nonpeer_mps = mps_mode;
else {
(*sta)->peer_mps = mps_mode;
if (mps_mode != RTW_MESH_PS_ACTIVE && (*sta)->nonpeer_mps == RTW_MESH_PS_ACTIVE)
(*sta)->nonpeer_mps = RTW_MESH_PS_DSLEEP;
}
if (get_frame_sub_type(whdr) & BIT(6)) {
/* No data, will not indicate to upper layer, temporily count it here */
count_rx_stats(adapter, rframe, *sta);
ret = RTW_RX_HANDLED;
goto exit;
}
rattrib->mesh_ctrl_present = get_mctrl_present(qc) ? 1 : 0;
if (!rattrib->mesh_ctrl_present)
goto exit;
ret = _SUCCESS;
exit:
return ret;
}
int rtw_mesh_rx_data_validate_mctrl(_adapter *adapter, union recv_frame *rframe
, const struct rtw_ieee80211s_hdr *mctrl, const u8 *mda, const u8 *msa
, u8 *mctrl_len
, const u8 **da, const u8 **sa)
{
struct rx_pkt_attrib *rattrib = &rframe->u.hdr.attrib;
u8 mlen;
u8 ae;
int ret = _SUCCESS;
ae = mctrl->flags & MESH_FLAGS_AE;
mlen = ae_to_mesh_ctrl_len[ae];
switch (rattrib->to_fr_ds) {
case 1:
*da = mda;
if (ae == MESH_FLAGS_AE_A4)
*sa = mctrl->eaddr1;
else if (ae == 0)
*sa = msa;
else
ret = _FAIL;
break;
case 3:
if (ae == MESH_FLAGS_AE_A5_A6) {
*da = mctrl->eaddr1;
*sa = mctrl->eaddr2;
} else if (ae == 0) {
*da = mda;
*sa = msa;
} else
ret = _FAIL;
break;
default:
ret = _FAIL;
}
if (ret == _FAIL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" invalid tfDS:%u AE:%u combination ra="MAC_FMT" ta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), rattrib->to_fr_ds, ae, MAC_ARG(rattrib->ra), MAC_ARG(rattrib->ta));
#endif
*mctrl_len = 0;
} else
*mctrl_len = mlen;
return ret;
}
inline int rtw_mesh_rx_validate_mctrl_non_amsdu(_adapter *adapter, union recv_frame *rframe)
{
struct rx_pkt_attrib *rattrib = &rframe->u.hdr.attrib;
const u8 *da, *sa;
int ret;
ret = rtw_mesh_rx_data_validate_mctrl(adapter, rframe
, (struct rtw_ieee80211s_hdr *)(get_recvframe_data(rframe) + rattrib->hdrlen + rattrib->iv_len)
, rattrib->mda, rattrib->msa
, &rattrib->mesh_ctrl_len
, &da, &sa);
if (ret == _SUCCESS) {
_rtw_memcpy(rattrib->dst, da, ETH_ALEN);
_rtw_memcpy(rattrib->src, sa, ETH_ALEN);
}
return ret;
}
/**
* rtw_mesh_rx_nexthop_resolve - lookup next hop; conditionally start path discovery
*
* @skb: 802.11 frame to be sent
* @sdata: network subif the frame will be sent through
*
* Lookup next hop for given skb and start path discovery if no
* forwarding information is found.
*
* Returns: 0 if the next hop was found and -ENOENT if the frame was queued.
* skb is freeed here if no mpath could be allocated.
*/
static int rtw_mesh_rx_nexthop_resolve(_adapter *adapter,
const u8 *mda, const u8 *msa, u8 *ra)
{
struct rtw_mesh_path *mpath;
struct xmit_frame *xframe_to_free = NULL;
int err = 0;
int ret = _SUCCESS;
rtw_rcu_read_lock();
err = rtw_mesh_nexthop_lookup(adapter, mda, msa, ra);
if (!err)
goto endlookup;
/* no nexthop found, start resolving */
mpath = rtw_mesh_path_lookup(adapter, mda);
if (!mpath) {
mpath = rtw_mesh_path_add(adapter, mda);
if (IS_ERR(mpath)) {
err = PTR_ERR(mpath);
ret = _FAIL;
goto endlookup;
}
}
if (!(mpath->flags & RTW_MESH_PATH_RESOLVING))
rtw_mesh_queue_preq(mpath, RTW_PREQ_Q_F_START);
ret = _FAIL;
endlookup:
rtw_rcu_read_unlock();
return ret;
}
#define RTW_MESH_DECACHE_BMC 1
#define RTW_MESH_DECACHE_UC 0
#define RTW_MESH_FORWARD_MDA_SELF_COND 0
#define DBG_RTW_MESH_FORWARD_MDA_SELF_COND 0
int rtw_mesh_rx_msdu_act_check(union recv_frame *rframe
, const u8 *mda, const u8 *msa
, const u8 *da, const u8 *sa
, struct rtw_ieee80211s_hdr *mctrl
, u8 *msdu, enum rtw_rx_llc_hdl llc_hdl
, struct xmit_frame **fwd_frame, _list *b2u_list)
{
_adapter *adapter = rframe->u.hdr.adapter;
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rx_pkt_attrib *rattrib = &rframe->u.hdr.attrib;
struct rtw_mesh_path *mppath;
u8 is_mda_bmc = IS_MCAST(mda);
u8 is_mda_self = !is_mda_bmc && _rtw_memcmp(mda, adapter_mac_addr(adapter), ETH_ALEN);
u16 os_qid;
struct xmit_frame *xframe;
struct pkt_attrib *xattrib;
u8 fwd_ra[ETH_ALEN] = {0};
u8 fwd_mpp[ETH_ALEN] = {0}; /* forward to other gate */
u32 fwd_mseq;
int act = 0;
u8 ae_need;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
bool ori_need = _TRUE;
u8 b2u_num = 0;
#endif
/* fwd info lifetime update */
#if 0
if (!is_mda_self)
mDA(A3) fwinfo.lifetime
mSA(A4) fwinfo.lifetime
Precursor-to-mDA(A2) fwinfo.lifetime
#endif
/* update/create pxoxy info for SA, mSA */
if ((mctrl->flags & MESH_FLAGS_AE)
&& sa != msa && _rtw_memcmp(sa, msa, ETH_ALEN) == _FALSE
) {
const u8 *proxied_addr = sa;
const u8 *mpp_addr = msa;
rtw_rcu_read_lock();
mppath = rtw_mpp_path_lookup(adapter, proxied_addr);
if (!mppath)
rtw_mpp_path_add(adapter, proxied_addr, mpp_addr);
else {
_rtw_spinlock_bh(&mppath->state_lock);
if (_rtw_memcmp(mppath->mpp, mpp_addr, ETH_ALEN) == _FALSE)
_rtw_memcpy(mppath->mpp, mpp_addr, ETH_ALEN);
mppath->exp_time = rtw_get_current_time();
_rtw_spinunlock_bh(&mppath->state_lock);
}
rtw_rcu_read_unlock();
}
/* mSA is self, need no further process */
if (_rtw_memcmp(msa, adapter_mac_addr(adapter), ETH_ALEN) == _TRUE)
goto exit;
fwd_mseq = le32_to_cpu(mctrl->seqnum);
/* check duplicate MSDU from mSA */
if (((RTW_MESH_DECACHE_BMC && is_mda_bmc)
|| (RTW_MESH_DECACHE_UC && !is_mda_bmc))
&& rtw_mesh_decache(adapter, msa, fwd_mseq)
) {
minfo->mshstats.dropped_frames_duplicate++;
goto exit;
}
if (is_mda_bmc) {
/* mDA is bmc addr */
act |= RTW_RX_MSDU_ACT_INDICATE;
if (!mcfg->dot11MeshForwarding)
goto exit;
goto fwd_chk;
} else if (!is_mda_self) {
/* mDA is unicast but not self */
if (!mcfg->dot11MeshForwarding) {
rtw_mesh_path_error_tx(adapter
, adapter->mesh_cfg.element_ttl
, mda, 0
, WLAN_REASON_MESH_PATH_NOFORWARD
, rattrib->ta
);
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" mDA("MAC_FMT") not self, !dot11MeshForwarding\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(mda));
#endif
goto exit;
}
if (rtw_mesh_rx_nexthop_resolve(adapter, mda, msa, fwd_ra) != _SUCCESS) {
/* mDA is unknown */
rtw_mesh_path_error_tx(adapter
, adapter->mesh_cfg.element_ttl
, mda, 0
, WLAN_REASON_MESH_PATH_NOFORWARD
, rattrib->ta
);
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" mDA("MAC_FMT") unknown\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(mda));
#endif
minfo->mshstats.dropped_frames_no_route++;
goto exit;
} else {
/* mDA is known in fwd info */
#if 0
if (TA is not in precursors)
goto exit;
#endif
goto fwd_chk;
}
} else {
/* mDA is self */
#if RTW_MESH_FORWARD_MDA_SELF_COND
if (da == mda
|| _rtw_memcmp(da, adapter_mac_addr(adapter), ETH_ALEN)
) {
/* DA is self, indicate */
act |= RTW_RX_MSDU_ACT_INDICATE;
goto exit;
}
if (rtw_get_iface_by_macddr(adapter, da)) {
/* DA is buddy, indicate */
act |= RTW_RX_MSDU_ACT_INDICATE;
#if DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO(FUNC_ADPT_FMT" DA("MAC_FMT") is buddy("ADPT_FMT")\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da), ADPT_ARG(rtw_get_iface_by_macddr(adapter, da)));
#endif
goto exit;
}
/* DA is not self or buddy */
if (rtw_mesh_nexthop_lookup(adapter, da, msa, fwd_ra) == 0) {
/* DA is known in fwd info */
if (!mcfg->dot11MeshForwarding) {
/* path error to? */
#if defined(DBG_RX_DROP_FRAME) || DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" DA("MAC_FMT") not self, !dot11MeshForwarding\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da));
#endif
goto exit;
}
mda = da;
#if DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO(FUNC_ADPT_FMT" fwd to DA("MAC_FMT"), fwd_RA("MAC_FMT")\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da), MAC_ARG(fwd_ra));
#endif
goto fwd_chk;
}
rtw_rcu_read_lock();
mppath = rtw_mpp_path_lookup(adapter, da);
if (mppath) {
if (_rtw_memcmp(mppath->mpp, adapter_mac_addr(adapter), ETH_ALEN) == _FALSE) {
/* DA is proxied by others */
if (!mcfg->dot11MeshForwarding) {
/* path error to? */
#if defined(DBG_RX_DROP_FRAME) || DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" DA("MAC_FMT") is proxied by ("MAC_FMT"), !dot11MeshForwarding\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da), MAC_ARG(mppath->mpp));
#endif
rtw_rcu_read_unlock();
goto exit;
}
_rtw_memcpy(fwd_mpp, mppath->mpp, ETH_ALEN);
mda = fwd_mpp;
msa = adapter_mac_addr(adapter);
rtw_rcu_read_unlock();
/* resolve RA */
if (rtw_mesh_nexthop_lookup(adapter, mda, msa, fwd_ra) != 0) {
minfo->mshstats.dropped_frames_no_route++;
#if defined(DBG_RX_DROP_FRAME) || DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" DA("MAC_FMT") is proxied by ("MAC_FMT"), RA resolve fail\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da), MAC_ARG(mppath->mpp));
#endif
goto exit;
}
#if DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO(FUNC_ADPT_FMT" DA("MAC_FMT") is proxied by ("MAC_FMT"), fwd_RA("MAC_FMT")\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da), MAC_ARG(mppath->mpp), MAC_ARG(fwd_ra));
#endif
goto fwd_chk; /* forward to other gate */
} else {
#if DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO(FUNC_ADPT_FMT" DA("MAC_FMT") is proxied by self\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da));
#endif
}
}
rtw_rcu_read_unlock();
if (!mppath) {
#if DBG_RTW_MESH_FORWARD_MDA_SELF_COND
RTW_INFO(FUNC_ADPT_FMT" DA("MAC_FMT") unknown\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da));
#endif
/* DA is unknown */
#if 0 /* TODO: flags with AE bit */
rtw_mesh_path_error_tx(adapter
, adapter->mesh_cfg.element_ttl
, mda, adapter->mesh_info.last_sn_update
, WLAN_REASON_MESH_PATH_NOPROXY
, msa
);
#endif
}
/*
* indicate to DS for both cases:
* 1.) DA is proxied by self
* 2.) DA is unknown
*/
#endif /* RTW_MESH_FORWARD_MDA_SELF_COND */
act |= RTW_RX_MSDU_ACT_INDICATE;
goto exit;
}
fwd_chk:
if (adapter->stapriv.asoc_list_cnt <= 1)
goto exit;
if (mctrl->ttl == 1) {
minfo->mshstats.dropped_frames_ttl++;
if (!act) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" ttl reaches 0, not forwarding\n"
, FUNC_ADPT_ARG(adapter));
#endif
}
goto exit;
}
os_qid = rtw_os_recv_select_queue(msdu, llc_hdl);
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
_rtw_init_listhead(b2u_list);
#endif
ae_need = _rtw_memcmp(da , mda, ETH_ALEN) == _FALSE
|| _rtw_memcmp(sa , msa, ETH_ALEN) == _FALSE;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
if (is_mda_bmc
&& rtw_mfwd_b2u_policy_chk(mcfg->b2u_flags_mfwd, mda, rattrib->to_fr_ds == 3)
) {
ori_need = rtw_mesh_data_bmc_to_uc(adapter
, da, sa, mda, msa, ae_need, rframe->u.hdr.psta->phl_sta->mac_addr, mctrl->ttl - 1
, os_qid, b2u_list, &b2u_num, &fwd_mseq);
}
if (ori_need == _TRUE)
#endif
{
xframe = rtw_alloc_xmitframe(&adapter->xmitpriv, os_qid);
if (!xframe) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME "FUNC_ADPT_FMT" rtw_alloc_xmitframe fail\n"
, FUNC_ADPT_ARG(adapter));
#endif
goto exit;
}
xattrib = &xframe->attrib;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
if (b2u_num)
xattrib->mb2u = 1;
else
xattrib->mb2u = 0;
#endif
xattrib->mfwd_ttl = mctrl->ttl - 1;
xattrib->mseq = fwd_mseq;
_rtw_memcpy(xattrib->dst, da, ETH_ALEN);
_rtw_memcpy(xattrib->src, sa, ETH_ALEN);
_rtw_memcpy(xattrib->mda, mda, ETH_ALEN);
_rtw_memcpy(xattrib->msa, msa, ETH_ALEN);
_rtw_memcpy(xattrib->ta, adapter_mac_addr(adapter), ETH_ALEN);
if (is_mda_bmc) {
xattrib->mesh_frame_mode = ae_need ? MESH_BMCAST_PX_DATA : MESH_BMCAST_DATA;
_rtw_memcpy(xattrib->ra, mda, ETH_ALEN);
} else {
xattrib->mesh_frame_mode = ae_need ? MESH_UCAST_PX_DATA : MESH_UCAST_DATA;
_rtw_memcpy(xattrib->ra, fwd_ra, ETH_ALEN);
}
*fwd_frame = xframe;
}
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
if (ori_need || b2u_num)
#endif
{
act |= RTW_RX_MSDU_ACT_FORWARD;
if (is_mda_bmc)
minfo->mshstats.fwded_mcast++;
else
minfo->mshstats.fwded_unicast++;
minfo->mshstats.fwded_frames++;
}
exit:
return act;
}
void dump_mesh_stats(void *sel, _adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_stats *stats = &minfo->mshstats;
RTW_PRINT_SEL(sel, "fwd_bmc:%u\n", stats->fwded_mcast);
RTW_PRINT_SEL(sel, "fwd_uc:%u\n", stats->fwded_unicast);
RTW_PRINT_SEL(sel, "drop_ttl:%u\n", stats->dropped_frames_ttl);
RTW_PRINT_SEL(sel, "drop_no_route:%u\n", stats->dropped_frames_no_route);
RTW_PRINT_SEL(sel, "drop_congestion:%u\n", stats->dropped_frames_congestion);
RTW_PRINT_SEL(sel, "drop_dup:%u\n", stats->dropped_frames_duplicate);
RTW_PRINT_SEL(sel, "mrc_del_qlen:%u\n", stats->mrc_del_qlen);
}
#endif /* CONFIG_RTW_MESH */
|
2301_81045437/rtl8852be
|
core/mesh/rtw_mesh.c
|
C
|
agpl-3.0
| 122,929
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __RTW_MESH_H_
#define __RTW_MESH_H_
#ifndef CONFIG_AP_MODE
#error "CONFIG_RTW_MESH can't be enabled when CONFIG_AP_MODE is not defined\n"
#endif
#define RTW_MESH_TTL 31
#define RTW_MESH_PERR_MIN_INT 100
#define RTW_MESH_DEFAULT_ELEMENT_TTL 31
#define RTW_MESH_RANN_INTERVAL 5000
#define RTW_MESH_PATH_TO_ROOT_TIMEOUT 6000
#define RTW_MESH_DIAM_TRAVERSAL_TIME 50
#define RTW_MESH_PATH_TIMEOUT 5000
#define RTW_MESH_PREQ_MIN_INT 10
#define RTW_MESH_MAX_PREQ_RETRIES 4
#define RTW_MESH_MIN_DISCOVERY_TIMEOUT (2 * RTW_MESH_DIAM_TRAVERSAL_TIME)
#define RTW_MESH_ROOT_CONFIRMATION_INTERVAL 2000
#define RTW_MESH_PATH_REFRESH_TIME 1000
#define RTW_MESH_ROOT_INTERVAL 5000
#define RTW_MESH_SANE_METRIC_DELTA 100
#define RTW_MESH_MAX_ROOT_ADD_CHK_CNT 2
#define RTW_MESH_PLINK_UNKNOWN 0
#define RTW_MESH_PLINK_LISTEN 1
#define RTW_MESH_PLINK_OPN_SNT 2
#define RTW_MESH_PLINK_OPN_RCVD 3
#define RTW_MESH_PLINK_CNF_RCVD 4
#define RTW_MESH_PLINK_ESTAB 5
#define RTW_MESH_PLINK_HOLDING 6
#define RTW_MESH_PLINK_BLOCKED 7
extern const char *_rtw_mesh_plink_str[];
#define rtw_mesh_plink_str(s) ((s <= RTW_MESH_PLINK_BLOCKED) ? _rtw_mesh_plink_str[s] : _rtw_mesh_plink_str[RTW_MESH_PLINK_UNKNOWN])
#define RTW_MESH_PS_UNKNOWN 0
#define RTW_MESH_PS_ACTIVE 1
#define RTW_MESH_PS_LSLEEP 2
#define RTW_MESH_PS_DSLEEP 3
extern const char *_rtw_mesh_ps_str[];
#define rtw_mesh_ps_str(mps) ((mps <= RTW_MESH_PS_DSLEEP) ? _rtw_mesh_ps_str[mps] : _rtw_mesh_ps_str[RTW_MESH_PS_UNKNOWN])
#define GET_MESH_CONF_ELE_PATH_SEL_PROTO_ID(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 0, 0, 8)
#define GET_MESH_CONF_ELE_PATH_SEL_METRIC_ID(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 1, 0, 8)
#define GET_MESH_CONF_ELE_CONGEST_CTRL_MODE_ID(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 2, 0, 8)
#define GET_MESH_CONF_ELE_SYNC_METHOD_ID(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 3, 0, 8)
#define GET_MESH_CONF_ELE_AUTH_PROTO_ID(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 4, 0, 8)
#define GET_MESH_CONF_ELE_MESH_FORMATION(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 5, 0, 8)
#define GET_MESH_CONF_ELE_CTO_MGATE(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 5, 0, 1)
#define GET_MESH_CONF_ELE_NUM_OF_PEERINGS(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 5, 1, 6)
#define GET_MESH_CONF_ELE_CTO_AS(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 5, 7, 1)
#define GET_MESH_CONF_ELE_MESH_CAP(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 0, 8)
#define GET_MESH_CONF_ELE_ACCEPT_PEERINGS(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 0, 1)
#define GET_MESH_CONF_ELE_MCCA_SUP(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 1, 1)
#define GET_MESH_CONF_ELE_MCCA_EN(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 2, 1)
#define GET_MESH_CONF_ELE_FORWARDING(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 3, 1)
#define GET_MESH_CONF_ELE_MBCA_EN(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 4, 1)
#define GET_MESH_CONF_ELE_TBTT_ADJ(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 5, 1)
#define GET_MESH_CONF_ELE_PS_LEVEL(_iec) LE_BITS_TO_1BYTE(((u8 *)(_iec)) + 6, 6, 1)
#define SET_MESH_CONF_ELE_PATH_SEL_PROTO_ID(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 0, 0, 8, _val)
#define SET_MESH_CONF_ELE_PATH_SEL_METRIC_ID(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 1, 0, 8, _val)
#define SET_MESH_CONF_ELE_CONGEST_CTRL_MODE_ID(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 2, 0, 8, _val)
#define SET_MESH_CONF_ELE_SYNC_METHOD_ID(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 3, 0, 8, _val)
#define SET_MESH_CONF_ELE_AUTH_PROTO_ID(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 4, 0, 8, _val)
#define SET_MESH_CONF_ELE_CTO_MGATE(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 5, 0, 1, _val)
#define SET_MESH_CONF_ELE_NUM_OF_PEERINGS(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 5, 1, 6, _val)
#define SET_MESH_CONF_ELE_CTO_AS(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 5, 7, 1, _val)
#define SET_MESH_CONF_ELE_ACCEPT_PEERINGS(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 6, 0, 1, _val)
#define SET_MESH_CONF_ELE_MCCA_SUP(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 6, 1, 1, _val)
#define SET_MESH_CONF_ELE_MCCA_EN(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 6, 2, 1, _val)
#define SET_MESH_CONF_ELE_FORWARDING(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 6, 3, 1, _val)
#define SET_MESH_CONF_ELE_MBCA_EN(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 6, 4, 1, _val)
#define SET_MESH_CONF_ELE_TBTT_ADJ(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 6, 5, 1, _val)
#define SET_MESH_CONF_ELE_PS_LEVEL(_iec, _val) SET_BITS_TO_LE_1BYTE(((u8 *)(_iec)) + 6, 6, 1, _val)
/* Mesh flags */
#define MESH_FLAGS_AE 0x3 /* mask */
#define MESH_FLAGS_AE_A4 0x1
#define MESH_FLAGS_AE_A5_A6 0x2
/* Max number of paths */
#define RTW_MESH_MAX_PATHS 1024
#define RTW_PREQ_Q_F_START 0x1
#define RTW_PREQ_Q_F_REFRESH 0x2
#define RTW_PREQ_Q_F_CHK 0x4
#define RTW_PREQ_Q_F_PEER_AKA 0x8
#define RTW_PREQ_Q_F_BCAST_PREQ 0x10 /* force path_dicover using broadcast */
struct rtw_mesh_preq_queue {
_list list;
u8 dst[ETH_ALEN];
u8 flags;
};
extern const u8 ae_to_mesh_ctrl_len[];
enum mesh_frame_type {
MESH_UCAST_DATA = 0x0,
MESH_BMCAST_DATA = 0x1,
MESH_UCAST_PX_DATA = 0x2,
MESH_BMCAST_PX_DATA = 0x3,
MESH_MHOP_UCAST_ACT = 0x4,
MESH_MHOP_BMCAST_ACT = 0x5,
};
enum mpath_sel_frame_type {
MPATH_PREQ = 0,
MPATH_PREP,
MPATH_PERR,
MPATH_RANN
};
/**
* enum rtw_mesh_deferred_task_flags - mesh deferred tasks
*
*
*
* @RTW_MESH_WORK_HOUSEKEEPING: run the periodic mesh housekeeping tasks
* @RTW_MESH_WORK_ROOT: the mesh root station needs to send a frame
* @RTW_MESH_WORK_DRIFT_ADJUST: time to compensate for clock drift relative to other
* mesh nodes
* @RTW_MESH_WORK_MBSS_CHANGED: rebuild beacon and notify driver of BSS changes
*/
enum rtw_mesh_deferred_task_flags {
RTW_MESH_WORK_HOUSEKEEPING,
RTW_MESH_WORK_ROOT,
RTW_MESH_WORK_DRIFT_ADJUST,
RTW_MESH_WORK_MBSS_CHANGED,
};
#define RTW_MESH_MAX_PEER_CANDIDATES 15 /* aid consideration */
#define RTW_MESH_MAX_PEER_LINKS 8
#define RTW_MESH_PEER_LINK_TIMEOUT 20
#define RTW_MESH_PEER_CONF_DISABLED 0 /* special time value means no confirmation ongoing */
#if CONFIG_RTW_MESH_PEER_BLACKLIST
#define IS_PEER_CONF_DISABLED(plink) ((plink)->peer_conf_end_time == RTW_MESH_PEER_CONF_DISABLED)
#define IS_PEER_CONF_TIMEOUT(plink)(!IS_PEER_CONF_DISABLED(plink) && rtw_time_after(rtw_get_current_time(), (plink)->peer_conf_end_time))
#define SET_PEER_CONF_DISABLED(plink) (plink)->peer_conf_end_time = RTW_MESH_PEER_CONF_DISABLED
#define SET_PEER_CONF_END_TIME(plink, timeout_ms) \
do { \
(plink)->peer_conf_end_time = rtw_get_current_time() + rtw_ms_to_systime(timeout_ms); \
if ((plink)->peer_conf_end_time == RTW_MESH_PEER_CONF_DISABLED) \
(plink)->peer_conf_end_time++; \
} while (0)
#else
#define IS_PEER_CONF_DISABLED(plink) 1
#define IS_PEER_CONF_TIMEOUT(plink) 0
#define SET_PEER_CONF_DISABLED(plink) do {} while (0)
#define SET_PEER_CONF_END_TIME(plink, timeout_ms) do {} while (0)
#endif /* CONFIG_RTW_MESH_PEER_BLACKLIST */
#define RTW_MESH_CTO_MGATE_CONF_DISABLED 0 /* special time value means no confirmation ongoing */
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
#define IS_CTO_MGATE_CONF_DISABLED(plink) ((plink)->cto_mgate_conf_end_time == RTW_MESH_CTO_MGATE_CONF_DISABLED)
#define IS_CTO_MGATE_CONF_TIMEOUT(plink)(!IS_CTO_MGATE_CONF_DISABLED(plink) && rtw_time_after(rtw_get_current_time(), (plink)->cto_mgate_conf_end_time))
#define SET_CTO_MGATE_CONF_DISABLED(plink) (plink)->cto_mgate_conf_end_time = RTW_MESH_CTO_MGATE_CONF_DISABLED
#define SET_CTO_MGATE_CONF_END_TIME(plink, timeout_ms) \
do { \
(plink)->cto_mgate_conf_end_time = rtw_get_current_time() + rtw_ms_to_systime(timeout_ms); \
if ((plink)->cto_mgate_conf_end_time == RTW_MESH_CTO_MGATE_CONF_DISABLED) \
(plink)->cto_mgate_conf_end_time++; \
} while (0)
#else
#define IS_CTO_MGATE_CONF_DISABLED(plink) 1
#define IS_CTO_MGATE_CONF_TIMEOUT(plink) 0
#define SET_CTO_MGATE_CONF_DISABLED(plink) do {} while (0)
#define SET_CTO_MGATE_CONF_END_TIME(plink, timeout_ms) do {} while (0)
#endif /* CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST */
struct mesh_plink_ent {
u8 valid;
u8 addr[ETH_ALEN];
u8 plink_state;
#ifdef CONFIG_RTW_MESH_AEK
u8 aek_valid;
u8 aek[32];
#endif
u16 llid;
u16 plid;
#ifndef CONFIG_RTW_MESH_DRIVER_AID
u16 aid; /* aid assigned from upper layer */
#endif
u16 peer_aid; /* aid assigned from peer */
u8 chosen_pmk[16];
#ifdef CONFIG_RTW_MESH_AEK
u8 sel_pcs[4];
u8 l_nonce[32];
u8 p_nonce[32];
#endif
#ifdef CONFIG_RTW_MESH_DRIVER_AID
u8 *tx_conf_ies;
u16 tx_conf_ies_len;
#endif
u8 *rx_conf_ies;
u16 rx_conf_ies_len;
struct wlan_network *scanned;
#if CONFIG_RTW_MESH_PEER_BLACKLIST
systime peer_conf_end_time;
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
systime cto_mgate_conf_end_time;
#endif
};
#ifdef CONFIG_RTW_MESH_AEK
#define MESH_PLINK_AEK_VALID(ent) ent->aek_valid
#else
#define MESH_PLINK_AEK_VALID(ent) 0
#endif
struct mesh_plink_pool {
_lock lock;
u8 num; /* current ent being used */
struct mesh_plink_ent ent[RTW_MESH_MAX_PEER_CANDIDATES];
#if CONFIG_RTW_MESH_ACNODE_PREVENT
u8 acnode_rsvd;
#endif
#if CONFIG_RTW_MESH_PEER_BLACKLIST
_queue peer_blacklist;
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
_queue cto_mgate_blacklist;
#endif
};
struct mesh_peer_sel_policy {
u32 scanr_exp_ms;
#if CONFIG_RTW_MESH_ACNODE_PREVENT
u8 acnode_prevent;
u32 acnode_conf_timeout_ms;
u32 acnode_notify_timeout_ms;
#endif
#if CONFIG_RTW_MESH_OFFCH_CAND
u8 offch_cand;
u32 offch_find_int_ms; /* 0 means no offch find triggerred by driver self*/
#endif
#if CONFIG_RTW_MESH_PEER_BLACKLIST
u32 peer_conf_timeout_ms;
u32 peer_blacklist_timeout_ms;
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
u8 cto_mgate_require;
u32 cto_mgate_conf_timeout_ms;
u32 cto_mgate_blacklist_timeout_ms;
#endif
};
/* b2u flags */
#define RTW_MESH_B2U_ALL BIT0
#define RTW_MESH_B2U_GA_UCAST BIT1 /* Group addressed unicast frame, forward only */
#define RTW_MESH_B2U_BCAST BIT2
#define RTW_MESH_B2U_IP_MCAST BIT3
#define rtw_msrc_b2u_policy_chk(flags, mda) ( \
(flags & RTW_MESH_B2U_ALL) \
|| ((flags & RTW_MESH_B2U_BCAST) && is_broadcast_mac_addr(mda)) \
|| ((flags & RTW_MESH_B2U_IP_MCAST) && (IP_MCAST_MAC(mda) || ICMPV6_MCAST_MAC(mda))) \
)
#define rtw_mfwd_b2u_policy_chk(flags, mda, ucst) ( \
(flags & RTW_MESH_B2U_ALL) \
|| ((flags & RTW_MESH_B2U_GA_UCAST) && ucst) \
|| ((flags & RTW_MESH_B2U_BCAST) && is_broadcast_mac_addr(mda)) \
|| ((flags & RTW_MESH_B2U_IP_MCAST) && (IP_MCAST_MAC(mda) || ICMPV6_MCAST_MAC(mda))) \
)
/**
* @sane_metric_delta: Controlling if trigger additional path check mechanism
* @max_root_add_chk_cnt: The retry cnt to send additional root confirmation
* PREQ through old(last) path
*/
struct rtw_mesh_cfg {
u8 max_peer_links; /* peering limit */
u32 plink_timeout; /* seconds */
u8 dot11MeshTTL;
u8 element_ttl;
u32 path_refresh_time;
u16 dot11MeshHWMPpreqMinInterval;
u16 dot11MeshHWMPnetDiameterTraversalTime;
u32 dot11MeshHWMPactivePathTimeout;
u8 dot11MeshHWMPmaxPREQretries;
u16 min_discovery_timeout;
u16 dot11MeshHWMPconfirmationInterval;
u16 dot11MeshHWMPperrMinInterval;
u8 dot11MeshHWMPRootMode;
BOOLEAN dot11MeshForwarding;
s32 rssi_threshold; /* in dBm, 0: no specified */
u16 dot11MeshHWMPRannInterval;
BOOLEAN dot11MeshGateAnnouncementProtocol;
u32 dot11MeshHWMPactivePathToRootTimeout;
u16 dot11MeshHWMProotInterval;
u8 path_gate_timeout_factor;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
u16 sane_metric_delta;
u8 max_root_add_chk_cnt;
#endif
struct mesh_peer_sel_policy peer_sel_policy;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
u8 b2u_flags_msrc;
u8 b2u_flags_mfwd;
#endif
};
struct rtw_mesh_stats {
u32 fwded_mcast; /* Mesh forwarded multicast frames */
u32 fwded_unicast; /* Mesh forwarded unicast frames */
u32 fwded_frames; /* Mesh total forwarded frames */
u32 dropped_frames_ttl; /* Not transmitted since mesh_ttl == 0*/
u32 dropped_frames_no_route; /* Not transmitted, no route found */
u32 dropped_frames_congestion;/* Not forwarded due to congestion */
u32 dropped_frames_duplicate;
u32 mrc_del_qlen; /* MRC entry deleted cause by queue length limit */
};
struct rtw_mrc;
struct rtw_mesh_info {
u8 mesh_id[NDIS_802_11_LENGTH_SSID];
size_t mesh_id_len;
/* Active Path Selection Protocol Identifier */
u8 mesh_pp_id;
/* Active Path Selection Metric Identifier */
u8 mesh_pm_id;
/* Congestion Control Mode Identifier */
u8 mesh_cc_id;
/* Synchronization Protocol Identifier */
u8 mesh_sp_id;
/* Authentication Protocol Identifier */
u8 mesh_auth_id;
struct mesh_plink_pool plink_ctl;
u32 mesh_seqnum;
/* MSTA's own hwmp sequence number */
u32 sn;
systime last_preq;
systime last_sn_update;
systime next_perr;
/* Last used Path Discovery ID */
u32 preq_id;
ATOMIC_T mpaths;
struct rtw_mesh_table *mesh_paths;
struct rtw_mesh_table *mpp_paths;
int mesh_paths_generation;
int mpp_paths_generation;
int num_gates;
struct rtw_mesh_path *max_addr_gate;
bool max_addr_gate_is_larger_than_self;
struct rtw_mesh_stats mshstats;
_queue mpath_tx_queue;
u32 mpath_tx_queue_len;
_tasklet mpath_tx_tasklet;
struct rtw_mrc *mrc;
_lock mesh_preq_queue_lock;
struct rtw_mesh_preq_queue preq_queue;
int preq_queue_len;
};
extern const char *_action_self_protected_str[];
#define action_self_protected_str(action) ((action < RTW_ACT_SELF_PROTECTED_NUM) ? _action_self_protected_str[action] : _action_self_protected_str[0])
u8 *rtw_set_ie_mesh_id(u8 *buf, u32 *buf_len, const char *mesh_id, u8 id_len);
u8 *rtw_set_ie_mesh_config(u8 *buf, u32 *buf_len
, u8 path_sel_proto, u8 path_sel_metric, u8 congest_ctl_mode, u8 sync_method, u8 auth_proto
, u8 num_of_peerings, bool cto_mgate, bool cto_as
, bool accept_peerings, bool mcca_sup, bool mcca_en, bool forwarding
, bool mbca_en, bool tbtt_adj, bool ps_level);
int rtw_bss_is_same_mbss(WLAN_BSSID_EX *a, WLAN_BSSID_EX *b);
int rtw_bss_is_candidate_mesh_peer(_adapter *adapter, WLAN_BSSID_EX *target, u8 ch, u8 add_peer);
void rtw_chk_candidate_peer_notify(_adapter *adapter, struct wlan_network *scanned);
void rtw_mesh_peer_status_chk(_adapter *adapter);
#if CONFIG_RTW_MESH_ACNODE_PREVENT
void rtw_mesh_update_scanned_acnode_status(_adapter *adapter, struct wlan_network *scanned);
bool rtw_mesh_scanned_is_acnode_confirmed(_adapter *adapter, struct wlan_network *scanned);
bool rtw_mesh_acnode_prevent_allow_sacrifice(_adapter *adapter);
struct sta_info *rtw_mesh_acnode_prevent_pick_sacrifice(_adapter *adapter);
void dump_mesh_acnode_prevent_settings(void *sel, _adapter *adapter);
#endif
#if CONFIG_RTW_MESH_OFFCH_CAND
u8 rtw_mesh_offch_candidate_accepted(_adapter *adapter);
u8 rtw_mesh_select_operating_ch(_adapter *adapter);
void dump_mesh_offch_cand_settings(void *sel, _adapter *adapter);
#endif
#if CONFIG_RTW_MESH_PEER_BLACKLIST
int rtw_mesh_peer_blacklist_add(_adapter *adapter, const u8 *addr);
int rtw_mesh_peer_blacklist_del(_adapter *adapter, const u8 *addr);
int rtw_mesh_peer_blacklist_search(_adapter *adapter, const u8 *addr);
void rtw_mesh_peer_blacklist_flush(_adapter *adapter);
void dump_mesh_peer_blacklist(void *sel, _adapter *adapter);
void dump_mesh_peer_blacklist_settings(void *sel, _adapter *adapter);
#endif
#if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
u8 rtw_mesh_cto_mgate_required(_adapter *adapter);
u8 rtw_mesh_cto_mgate_network_filter(_adapter *adapter, struct wlan_network *scanned);
int rtw_mesh_cto_mgate_blacklist_add(_adapter *adapter, const u8 *addr);
int rtw_mesh_cto_mgate_blacklist_del(_adapter *adapter, const u8 *addr);
int rtw_mesh_cto_mgate_blacklist_search(_adapter *adapter, const u8 *addr);
void rtw_mesh_cto_mgate_blacklist_flush(_adapter *adapter);
void dump_mesh_cto_mgate_blacklist(void *sel, _adapter *adapter);
void dump_mesh_cto_mgate_blacklist_settings(void *sel, _adapter *adapter);
#endif
void dump_mesh_peer_sel_policy(void *sel, _adapter *adapter);
void dump_mesh_networks(void *sel, _adapter *adapter);
void rtw_mesh_adjust_chbw(u8 req_ch, u8 *req_bw, u8 *req_offset);
void rtw_mesh_sae_check_frames(_adapter *adapter, const u8 *buf, u32 len, u8 tx, u16 alg, u16 seq, u16 status);
int rtw_mesh_check_frames_tx(_adapter *adapter, const u8 **buf, size_t *len);
int rtw_mesh_check_frames_rx(_adapter *adapter, const u8 *buf, size_t len);
int rtw_mesh_on_auth(_adapter *adapter, union recv_frame *rframe);
unsigned int on_action_self_protected(_adapter *adapter, union recv_frame *rframe);
bool rtw_mesh_update_bss_peering_status(_adapter *adapter, WLAN_BSSID_EX *bss);
bool rtw_mesh_update_bss_formation_info(_adapter *adapter, WLAN_BSSID_EX *bss);
bool rtw_mesh_update_bss_forwarding_state(_adapter *adapter, WLAN_BSSID_EX *bss);
struct mesh_plink_ent *_rtw_mesh_plink_get(_adapter *adapter, const u8 *hwaddr);
struct mesh_plink_ent *rtw_mesh_plink_get(_adapter *adapter, const u8 *hwaddr);
struct mesh_plink_ent *rtw_mesh_plink_get_no_estab_by_idx(_adapter *adapter, u8 idx);
int _rtw_mesh_plink_add(_adapter *adapter, const u8 *hwaddr);
int rtw_mesh_plink_add(_adapter *adapter, const u8 *hwaddr);
int rtw_mesh_plink_set_state(_adapter *adapter, const u8 *hwaddr, u8 state);
#ifdef CONFIG_RTW_MESH_AEK
int rtw_mesh_plink_set_aek(_adapter *adapter, const u8 *hwaddr, const u8 *aek);
#endif
#if CONFIG_RTW_MESH_PEER_BLACKLIST
int rtw_mesh_plink_set_peer_conf_timeout(_adapter *adapter, const u8 *hwaddr);
#endif
void _rtw_mesh_plink_del_ent(_adapter *adapter, struct mesh_plink_ent *ent);
int rtw_mesh_plink_del(_adapter *adapter, const u8 *hwaddr);
void rtw_mesh_plink_ctl_init(_adapter *adapter);
void rtw_mesh_plink_ctl_deinit(_adapter *adapter);
void dump_mesh_plink_ctl(void *sel, _adapter *adapter);
u8 rtw_mesh_set_plink_state_cmd(_adapter *adapter, const u8 *mac, u8 plink_state);
void _rtw_mesh_expire_peer_ent(_adapter *adapter, struct mesh_plink_ent *plink);
void rtw_mesh_expire_peer(_adapter *adapter, const u8 *peer_addr);
u8 rtw_mesh_ps_annc(_adapter *adapter, u8 ps);
unsigned int on_action_mesh(_adapter *adapter, union recv_frame *rframe);
void rtw_mesh_cfg_init(_adapter *adapter);
void rtw_mesh_cfg_init_max_peer_links(_adapter *adapter, u8 stack_conf);
void rtw_mesh_cfg_init_plink_timeout(_adapter *adapter, u32 stack_conf);
void rtw_mesh_init_mesh_info(_adapter *adapter);
void rtw_mesh_deinit_mesh_info(_adapter *adapter);
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
void dump_mesh_b2u_flags(void *sel, _adapter *adapter);
#endif
int rtw_mesh_addr_resolve(_adapter *adapter, u16 os_qid, struct xmit_frame *xframe, _pkt *pkt, _list *b2u_list);
s8 rtw_mesh_tx_set_whdr_mctrl_len(u8 mesh_frame_mode, struct pkt_attrib *attrib);
void rtw_mesh_tx_build_mctrl(_adapter *adapter, struct pkt_attrib *attrib, u8 *buf);
u8 rtw_mesh_tx_build_whdr(_adapter *adapter, struct pkt_attrib *attrib
, u16 *fctrl, struct rtw_ieee80211_hdr *whdr);
int rtw_mesh_rx_data_validate_hdr(_adapter *adapter, union recv_frame *rframe, struct sta_info **sta);
int rtw_mesh_rx_data_validate_mctrl(_adapter *adapter, union recv_frame *rframe
, const struct rtw_ieee80211s_hdr *mctrl, const u8 *mda, const u8 *msa
, u8 *mctrl_len, const u8 **da, const u8 **sa);
int rtw_mesh_rx_validate_mctrl_non_amsdu(_adapter *adapter, union recv_frame *rframe);
int rtw_mesh_rx_msdu_act_check(union recv_frame *rframe
, const u8 *mda, const u8 *msa
, const u8 *da, const u8 *sa
, struct rtw_ieee80211s_hdr *mctrl
, u8 *msdu, enum rtw_rx_llc_hdl llc_hdl
, struct xmit_frame **fwd_frame, _list *b2u_list);
void dump_mesh_stats(void *sel, _adapter *adapter);
#if defined(PLATFORM_LINUX) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32))
#define rtw_lockdep_assert_held(l) lockdep_assert_held(l)
#define rtw_lockdep_is_held(l) lockdep_is_held(l)
#else
#error "TBD\n"
#endif
#include "rtw_mesh_pathtbl.h"
#include "rtw_mesh_hwmp.h"
#endif /* __RTW_MESH_H_ */
|
2301_81045437/rtl8852be
|
core/mesh/rtw_mesh.h
|
C
|
agpl-3.0
| 20,503
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_HWMP_C_
#ifdef CONFIG_RTW_MESH
#include <drv_types.h>
#define RTW_TEST_FRAME_LEN 8192
#define RTW_MAX_METRIC 0xffffffff
#define RTW_ARITH_SHIFT 8
#define RTW_LINK_FAIL_THRESH 95
#define RTW_MAX_PREQ_QUEUE_LEN 64
#define RTW_ATLM_REQ_CYCLE 1000
#define rtw_ilog2(n) \
( \
(n) < 2 ? 0 : \
(n) & (1ULL << 63) ? 63 : \
(n) & (1ULL << 62) ? 62 : \
(n) & (1ULL << 61) ? 61 : \
(n) & (1ULL << 60) ? 60 : \
(n) & (1ULL << 59) ? 59 : \
(n) & (1ULL << 58) ? 58 : \
(n) & (1ULL << 57) ? 57 : \
(n) & (1ULL << 56) ? 56 : \
(n) & (1ULL << 55) ? 55 : \
(n) & (1ULL << 54) ? 54 : \
(n) & (1ULL << 53) ? 53 : \
(n) & (1ULL << 52) ? 52 : \
(n) & (1ULL << 51) ? 51 : \
(n) & (1ULL << 50) ? 50 : \
(n) & (1ULL << 49) ? 49 : \
(n) & (1ULL << 48) ? 48 : \
(n) & (1ULL << 47) ? 47 : \
(n) & (1ULL << 46) ? 46 : \
(n) & (1ULL << 45) ? 45 : \
(n) & (1ULL << 44) ? 44 : \
(n) & (1ULL << 43) ? 43 : \
(n) & (1ULL << 42) ? 42 : \
(n) & (1ULL << 41) ? 41 : \
(n) & (1ULL << 40) ? 40 : \
(n) & (1ULL << 39) ? 39 : \
(n) & (1ULL << 38) ? 38 : \
(n) & (1ULL << 37) ? 37 : \
(n) & (1ULL << 36) ? 36 : \
(n) & (1ULL << 35) ? 35 : \
(n) & (1ULL << 34) ? 34 : \
(n) & (1ULL << 33) ? 33 : \
(n) & (1ULL << 32) ? 32 : \
(n) & (1ULL << 31) ? 31 : \
(n) & (1ULL << 30) ? 30 : \
(n) & (1ULL << 29) ? 29 : \
(n) & (1ULL << 28) ? 28 : \
(n) & (1ULL << 27) ? 27 : \
(n) & (1ULL << 26) ? 26 : \
(n) & (1ULL << 25) ? 25 : \
(n) & (1ULL << 24) ? 24 : \
(n) & (1ULL << 23) ? 23 : \
(n) & (1ULL << 22) ? 22 : \
(n) & (1ULL << 21) ? 21 : \
(n) & (1ULL << 20) ? 20 : \
(n) & (1ULL << 19) ? 19 : \
(n) & (1ULL << 18) ? 18 : \
(n) & (1ULL << 17) ? 17 : \
(n) & (1ULL << 16) ? 16 : \
(n) & (1ULL << 15) ? 15 : \
(n) & (1ULL << 14) ? 14 : \
(n) & (1ULL << 13) ? 13 : \
(n) & (1ULL << 12) ? 12 : \
(n) & (1ULL << 11) ? 11 : \
(n) & (1ULL << 10) ? 10 : \
(n) & (1ULL << 9) ? 9 : \
(n) & (1ULL << 8) ? 8 : \
(n) & (1ULL << 7) ? 7 : \
(n) & (1ULL << 6) ? 6 : \
(n) & (1ULL << 5) ? 5 : \
(n) & (1ULL << 4) ? 4 : \
(n) & (1ULL << 3) ? 3 : \
(n) & (1ULL << 2) ? 2 : \
1 \
)
enum rtw_mpath_frame_type {
RTW_MPATH_PREQ = 0,
RTW_MPATH_PREP,
RTW_MPATH_PERR,
RTW_MPATH_RANN
};
static inline u32 rtw_u32_field_get(const u8 *preq_elem, int shift, BOOLEAN ae)
{
if (ae)
shift += 6;
return LE_BITS_TO_4BYTE(preq_elem + shift, 0, 32);
}
static inline u16 rtw_u16_field_get(const u8 *preq_elem, int shift, BOOLEAN ae)
{
if (ae)
shift += 6;
return LE_BITS_TO_2BYTE(preq_elem + shift, 0, 16);
}
/* HWMP IE processing macros */
#define RTW_AE_F (1<<6)
#define RTW_AE_F_SET(x) (*x & RTW_AE_F)
#define RTW_PREQ_IE_FLAGS(x) (*(x))
#define RTW_PREQ_IE_HOPCOUNT(x) (*(x + 1))
#define RTW_PREQ_IE_TTL(x) (*(x + 2))
#define RTW_PREQ_IE_PREQ_ID(x) rtw_u32_field_get(x, 3, 0)
#define RTW_PREQ_IE_ORIG_ADDR(x) (x + 7)
#define RTW_PREQ_IE_ORIG_SN(x) rtw_u32_field_get(x, 13, 0)
#define RTW_PREQ_IE_LIFETIME(x) rtw_u32_field_get(x, 17, RTW_AE_F_SET(x))
#define RTW_PREQ_IE_METRIC(x) rtw_u32_field_get(x, 21, RTW_AE_F_SET(x))
#define RTW_PREQ_IE_TARGET_F(x) (*(RTW_AE_F_SET(x) ? x + 32 : x + 26))
#define RTW_PREQ_IE_TARGET_ADDR(x) (RTW_AE_F_SET(x) ? x + 33 : x + 27)
#define RTW_PREQ_IE_TARGET_SN(x) rtw_u32_field_get(x, 33, RTW_AE_F_SET(x))
#define RTW_PREP_IE_FLAGS(x) RTW_PREQ_IE_FLAGS(x)
#define RTW_PREP_IE_HOPCOUNT(x) RTW_PREQ_IE_HOPCOUNT(x)
#define RTW_PREP_IE_TTL(x) RTW_PREQ_IE_TTL(x)
#define RTW_PREP_IE_ORIG_ADDR(x) (RTW_AE_F_SET(x) ? x + 27 : x + 21)
#define RTW_PREP_IE_ORIG_SN(x) rtw_u32_field_get(x, 27, RTW_AE_F_SET(x))
#define RTW_PREP_IE_LIFETIME(x) rtw_u32_field_get(x, 13, RTW_AE_F_SET(x))
#define RTW_PREP_IE_METRIC(x) rtw_u32_field_get(x, 17, RTW_AE_F_SET(x))
#define RTW_PREP_IE_TARGET_ADDR(x) (x + 3)
#define RTW_PREP_IE_TARGET_SN(x) rtw_u32_field_get(x, 9, 0)
#define RTW_PERR_IE_TTL(x) (*(x))
#define RTW_PERR_IE_TARGET_FLAGS(x) (*(x + 2))
#define RTW_PERR_IE_TARGET_ADDR(x) (x + 3)
#define RTW_PERR_IE_TARGET_SN(x) rtw_u32_field_get(x, 9, 0)
#define RTW_PERR_IE_TARGET_RCODE(x) rtw_u16_field_get(x, 13, 0)
#define RTW_TU_TO_SYSTIME(x) (rtw_us_to_systime((x) * 1024))
#define RTW_TU_TO_EXP_TIME(x) (rtw_get_current_time() + RTW_TU_TO_SYSTIME(x))
#define RTW_MSEC_TO_TU(x) (x*1000/1024)
#define RTW_SN_GT(x, y) ((s32)(y - x) < 0)
#define RTW_SN_LT(x, y) ((s32)(x - y) < 0)
#define RTW_MAX_SANE_SN_DELTA 32
static inline u32 RTW_SN_DELTA(u32 x, u32 y)
{
return x >= y ? x - y : y - x;
}
#define rtw_net_traversal_jiffies(adapter) \
rtw_ms_to_systime(adapter->mesh_cfg.dot11MeshHWMPnetDiameterTraversalTime)
#define rtw_default_lifetime(adapter) \
RTW_MSEC_TO_TU(adapter->mesh_cfg.dot11MeshHWMPactivePathTimeout)
#define rtw_min_preq_int_jiff(adapter) \
(rtw_ms_to_systime(adapter->mesh_cfg.dot11MeshHWMPpreqMinInterval))
#define rtw_max_preq_retries(adapter) (adapter->mesh_cfg.dot11MeshHWMPmaxPREQretries)
#define rtw_disc_timeout_jiff(adapter) \
rtw_ms_to_systime(adapter->mesh_cfg.min_discovery_timeout)
#define rtw_root_path_confirmation_jiffies(adapter) \
rtw_ms_to_systime(adapter->mesh_cfg.dot11MeshHWMPconfirmationInterval)
static inline BOOLEAN rtw_ether_addr_equal(const u8 *addr1, const u8 *addr2)
{
return _rtw_memcmp(addr1, addr2, ETH_ALEN);
}
#ifdef PLATFORM_LINUX
#define rtw_print_ratelimit() printk_ratelimit()
#define rtw_mod_timer(ptimer, expires) mod_timer(&(ptimer)->timer, expires)
#else
#endif
#define RTW_MESH_EWMA_PRECISION 20
#define RTW_MESH_EWMA_WEIGHT_RCP 8
#define RTW_TOTAL_PKT_MIN_THRESHOLD 1
inline void rtw_ewma_err_rate_init(struct rtw_ewma_err_rate *e)
{
e->internal = 0;
}
inline unsigned long rtw_ewma_err_rate_read(struct rtw_ewma_err_rate *e)
{
return e->internal >> (RTW_MESH_EWMA_PRECISION);
}
inline void rtw_ewma_err_rate_add(struct rtw_ewma_err_rate *e,
unsigned long val)
{
unsigned long internal = e->internal;
unsigned long weight_rcp = rtw_ilog2(RTW_MESH_EWMA_WEIGHT_RCP);
unsigned long precision = RTW_MESH_EWMA_PRECISION;
(e->internal) = internal ? (((internal << weight_rcp) - internal) +
(val << precision)) >> weight_rcp :
(val << precision);
}
static const u8 bcast_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
static int rtw_mesh_path_sel_frame_tx(enum rtw_mpath_frame_type mpath_action, u8 flags,
const u8 *originator_addr, u32 originator_sn,
u8 target_flags, const u8 *target,
u32 target_sn, const u8 *da, u8 hopcount, u8 ttl,
u32 lifetime, u32 metric, u32 preq_id,
_adapter *adapter)
{
struct xmit_priv *pxmitpriv = &(adapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct xmit_frame *pmgntframe = NULL;
struct rtw_ieee80211_hdr *pwlanhdr = NULL;
struct pkt_attrib *pattrib = NULL;
u8 category = RTW_WLAN_CATEGORY_MESH;
u8 action = RTW_ACT_MESH_HWMP_PATH_SELECTION;
u16 *fctrl = NULL;
u8 *pos, ie_len;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return -1;
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pos = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pos;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(adapter), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pos, WIFI_ACTION);
pos += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pos = rtw_set_fixed_ie(pos, 1, &(category), &(pattrib->pktlen));
pos = rtw_set_fixed_ie(pos, 1, &(action), &(pattrib->pktlen));
switch (mpath_action) {
case RTW_MPATH_PREQ:
RTW_HWMP_DBG("sending PREQ to "MAC_FMT"\n", MAC_ARG(target));
ie_len = 37;
pattrib->pktlen += (ie_len + 2);
*pos++ = WLAN_EID_PREQ;
break;
case RTW_MPATH_PREP:
RTW_HWMP_DBG("sending PREP to "MAC_FMT"\n", MAC_ARG(originator_addr));
ie_len = 31;
pattrib->pktlen += (ie_len + 2);
*pos++ = WLAN_EID_PREP;
break;
case RTW_MPATH_RANN:
RTW_HWMP_DBG("sending RANN from "MAC_FMT"\n", MAC_ARG(originator_addr));
ie_len = sizeof(struct rtw_ieee80211_rann_ie);
pattrib->pktlen += (ie_len + 2);
*pos++ = WLAN_EID_RANN;
break;
default:
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
return _FAIL;
}
*pos++ = ie_len;
*pos++ = flags;
*pos++ = hopcount;
*pos++ = ttl;
if (mpath_action == RTW_MPATH_PREP) {
_rtw_memcpy(pos, target, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(target_sn);
pos += 4;
} else {
if (mpath_action == RTW_MPATH_PREQ) {
*(u32 *)pos = cpu_to_le32(preq_id);
pos += 4;
}
_rtw_memcpy(pos, originator_addr, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(originator_sn);
pos += 4;
}
*(u32 *)pos = cpu_to_le32(lifetime);
pos += 4;
*(u32 *)pos = cpu_to_le32(metric);
pos += 4;
if (mpath_action == RTW_MPATH_PREQ) {
*pos++ = 1; /* support only 1 destination now */
*pos++ = target_flags;
_rtw_memcpy(pos, target, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(target_sn);
pos += 4;
} else if (mpath_action == RTW_MPATH_PREP) {
_rtw_memcpy(pos, originator_addr, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(originator_sn);
pos += 4;
}
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(adapter, pmgntframe);
return 0;
}
int rtw_mesh_path_error_tx(_adapter *adapter,
u8 ttl, const u8 *target, u32 target_sn,
u16 perr_reason_code, const u8 *ra)
{
struct xmit_priv *pxmitpriv = &(adapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct xmit_frame *pmgntframe = NULL;
struct rtw_ieee80211_hdr *pwlanhdr = NULL;
struct pkt_attrib *pattrib = NULL;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
u8 category = RTW_WLAN_CATEGORY_MESH;
u8 action = RTW_ACT_MESH_HWMP_PATH_SELECTION;
u8 *pos, ie_len;
u16 *fctrl = NULL;
if (rtw_time_before(rtw_get_current_time(), minfo->next_perr))
return -1;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return -1;
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pos = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pos;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, ra, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(adapter), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pos, WIFI_ACTION);
pos += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pos = rtw_set_fixed_ie(pos, 1, &(category), &(pattrib->pktlen));
pos = rtw_set_fixed_ie(pos, 1, &(action), &(pattrib->pktlen));
ie_len = 15;
pattrib->pktlen += (2 + ie_len);
*pos++ = WLAN_EID_PERR;
*pos++ = ie_len;
/* ttl */
*pos++ = ttl;
/* The Number of Destinations N */
*pos++ = 1;
/* Flags format | B7 | B6 | B5:B0 | = | rsvd | AE | rsvd | */
*pos = 0;
pos++;
_rtw_memcpy(pos, target, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(target_sn);
pos += 4;
*(u16 *)pos = cpu_to_le16(perr_reason_code);
adapter->mesh_info.next_perr = RTW_TU_TO_EXP_TIME(
adapter->mesh_cfg.dot11MeshHWMPperrMinInterval);
pattrib->last_txcmdsz = pattrib->pktlen;
/* Send directly. Rewrite it if deferred tx is needed */
dump_mgntframe(adapter, pmgntframe);
RTW_HWMP_DBG("TX PERR toward "MAC_FMT", ra = "MAC_FMT"\n", MAC_ARG(target), MAC_ARG(ra));
return 0;
}
static u32 rtw_get_vht_bitrate(u8 mcs, u8 bw, u8 nss, u8 sgi)
{
static const u32 base[4][10] = {
{ 6500000,
13000000,
19500000,
26000000,
39000000,
52000000,
58500000,
65000000,
78000000,
/* not in the spec, but some devices use this: */
86500000,
},
{ 13500000,
27000000,
40500000,
54000000,
81000000,
108000000,
121500000,
135000000,
162000000,
180000000,
},
{ 29300000,
58500000,
87800000,
117000000,
175500000,
234000000,
263300000,
292500000,
351000000,
390000000,
},
{ 58500000,
117000000,
175500000,
234000000,
351000000,
468000000,
526500000,
585000000,
702000000,
780000000,
},
};
u32 bitrate;
int bw_idx;
if (mcs > 9) {
RTW_HWMP_INFO("Invalid mcs = %d\n", mcs);
return 0;
}
if (nss > 4 || nss < 1) {
RTW_HWMP_INFO("Now only support nss = 1, 2, 3, 4\n");
}
switch (bw) {
case CHANNEL_WIDTH_160:
bw_idx = 3;
break;
case CHANNEL_WIDTH_80:
bw_idx = 2;
break;
case CHANNEL_WIDTH_40:
bw_idx = 1;
break;
case CHANNEL_WIDTH_20:
bw_idx = 0;
break;
default:
RTW_HWMP_INFO("bw = %d currently not supported\n", bw);
return 0;
}
bitrate = base[bw_idx][mcs];
bitrate *= nss;
if (sgi)
bitrate = (bitrate / 9) * 10;
/* do NOT round down here */
return (bitrate + 50000) / 100000;
}
static u32 rtw_get_ht_bitrate(u8 mcs, u8 bw, u8 sgi)
{
int modulation, streams, bitrate;
/* the formula below does only work for MCS values smaller than 32 */
if (mcs >= 32) {
RTW_HWMP_INFO("Invalid mcs = %d\n", mcs);
return 0;
}
if (bw > 1) {
RTW_HWMP_INFO("Now HT only support bw = 0(20Mhz), 1(40Mhz)\n");
return 0;
}
modulation = mcs & 7;
streams = (mcs >> 3) + 1;
bitrate = (bw == 1) ? 13500000 : 6500000;
if (modulation < 4)
bitrate *= (modulation + 1);
else if (modulation == 4)
bitrate *= (modulation + 2);
else
bitrate *= (modulation + 3);
bitrate *= streams;
if (sgi)
bitrate = (bitrate / 9) * 10;
/* do NOT round down here */
return (bitrate + 50000) / 100000;
}
/**
* @bw: 0(20Mhz), 1(40Mhz), 2(80Mhz), 3(160Mhz)
* @rate_idx: DESC_RATEXXXX & 0x7f
* @sgi: DESC_RATEXXXX >> 7
* Returns: bitrate in 100kbps
*/
static u32 rtw_desc_rate_to_bitrate(u8 bw, u8 rate_idx, u8 sgi)
{
u32 bitrate;
if (rate_idx <= DESC_RATE54M){
u16 ofdm_rate[12] = {10, 20, 55, 110,
60, 90, 120, 180, 240, 360, 480, 540};
bitrate = ofdm_rate[rate_idx];
} else if ((DESC_RATEMCS0 <= rate_idx) &&
(rate_idx <= DESC_RATEMCS31)) {
u8 mcs = rate_idx - DESC_RATEMCS0;
bitrate = rtw_get_ht_bitrate(mcs, bw, sgi);
} else if ((DESC_RATEVHTSS1MCS0 <= rate_idx) &&
(rate_idx <= DESC_RATEVHTSS4MCS9)) {
u8 mcs = (rate_idx - DESC_RATEVHTSS1MCS0) % 10;
u8 nss = ((rate_idx - DESC_RATEVHTSS1MCS0) / 10) + 1;
bitrate = rtw_get_vht_bitrate(mcs, bw, nss, sgi);
} else {
/* 60Ghz ??? */
bitrate = 1;
}
return bitrate;
}
static u32 rtw_airtime_link_metric_get(_adapter *adapter, struct sta_info *sta)
{
int device_constant = rtw_hal_phydm_get_plcp(adapter, sta->phl_sta->macid) << RTW_ARITH_SHIFT;
u32 test_frame_len = RTW_TEST_FRAME_LEN << RTW_ARITH_SHIFT;
u32 s_unit = 1 << RTW_ARITH_SHIFT;
u32 err;
u16 rate;
u32 tx_time, estimated_retx;
u64 result;
/* The fail_avg should <= 100 here */
u32 fail_avg = (u32)rtw_ewma_err_rate_read(&sta->metrics.err_rate);
if (fail_avg > RTW_LINK_FAIL_THRESH)
return RTW_MAX_METRIC;
rate = sta->metrics.data_rate;
/* rate unit is 100Kbps, min rate = 10 */
if (rate < 10) {
RTW_HWMP_INFO("rate = %d\n", rate);
return RTW_MAX_METRIC;
}
err = (fail_avg << RTW_ARITH_SHIFT) / 100;
/* test_frame_len*10 to adjust the unit of rate(100kbps/unit) */
tx_time = (device_constant + 10 * test_frame_len / rate);
estimated_retx = ((1 << (2 * RTW_ARITH_SHIFT)) / (s_unit - err));
result = (tx_time * estimated_retx) >> (2 * RTW_ARITH_SHIFT);
/* Convert us to 0.01 TU(10.24us). x/10.24 = x*100/1024 */
result = (result * 100) >> 10;
return (u32)result;
}
void rtw_ieee80211s_update_metric(_adapter *adapter, u8 mac_id,
u8 per, u8 rate,
u8 bw, u8 total_pkt)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
struct sta_info *sta;
u8 rate_idx;
u8 sgi;
sta = macid_ctl->sta[mac_id];
if (!sta)
return;
/* if RA, use reported rate */
if (adapter->fix_rate == 0xff) {
rate_idx = rate & 0x7f;
sgi = rate >> 7;
} else {
rate_idx = adapter->fix_rate & 0x7f;
sgi = adapter->fix_rate >> 7;
}
sta->metrics.data_rate = rtw_desc_rate_to_bitrate(bw, rate_idx, sgi);
if (total_pkt < RTW_TOTAL_PKT_MIN_THRESHOLD)
return;
/* TBD: sta->metrics.overhead = phydm_get_plcp(void *dm_void, u16 macid); */
sta->metrics.total_pkt = total_pkt;
rtw_ewma_err_rate_add(&sta->metrics.err_rate, per);
if (rtw_ewma_err_rate_read(&sta->metrics.err_rate) >
RTW_LINK_FAIL_THRESH)
rtw_mesh_plink_broken(sta);
}
static void rtw_hwmp_preq_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *preq_elem, u32 originator_metric)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_path *path = NULL;
const u8 *target_addr, *originator_addr;
const u8 *da;
u8 target_flags, ttl, flags, to_gate_ask = 0;
u32 originator_sn, target_sn, lifetime, target_metric = 0;
BOOLEAN reply = _FALSE;
BOOLEAN forward = _TRUE;
BOOLEAN preq_is_gate;
/* Update target SN, if present */
target_addr = RTW_PREQ_IE_TARGET_ADDR(preq_elem);
originator_addr = RTW_PREQ_IE_ORIG_ADDR(preq_elem);
target_sn = RTW_PREQ_IE_TARGET_SN(preq_elem);
originator_sn = RTW_PREQ_IE_ORIG_SN(preq_elem);
target_flags = RTW_PREQ_IE_TARGET_F(preq_elem);
/* PREQ gate announcements */
flags = RTW_PREQ_IE_FLAGS(preq_elem);
preq_is_gate = !!(flags & RTW_IEEE80211_PREQ_IS_GATE_FLAG);
RTW_HWMP_DBG("received PREQ from "MAC_FMT"\n", MAC_ARG(originator_addr));
if (rtw_ether_addr_equal(target_addr, adapter_mac_addr(adapter))) {
RTW_HWMP_DBG("PREQ is for us\n");
#ifdef CONFIG_RTW_MESH_ON_DMD_GANN
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
if (preq_is_gate)
rtw_mesh_path_add_gate(path);
else if (path->is_gate) {
_rtw_spinlock_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
_rtw_spinunlock_bh(&path->state_lock);
}
}
path = NULL;
rtw_rcu_read_unlock();
#endif
forward = _FALSE;
reply = _TRUE;
to_gate_ask = 1;
target_metric = 0;
if (rtw_time_after(rtw_get_current_time(), minfo->last_sn_update +
rtw_net_traversal_jiffies(adapter)) ||
rtw_time_before(rtw_get_current_time(), minfo->last_sn_update)) {
++minfo->sn;
minfo->last_sn_update = rtw_get_current_time();
}
target_sn = minfo->sn;
} else if (is_broadcast_mac_addr(target_addr) &&
(target_flags & RTW_IEEE80211_PREQ_TO_FLAG)) {
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
if (flags & RTW_IEEE80211_PREQ_PROACTIVE_PREP_FLAG) {
reply = _TRUE;
target_addr = adapter_mac_addr(adapter);
target_sn = ++minfo->sn;
target_metric = 0;
minfo->last_sn_update = rtw_get_current_time();
}
if (preq_is_gate) {
lifetime = RTW_PREQ_IE_LIFETIME(preq_elem);
path->gate_ann_int = lifetime;
path->gate_asked = false;
rtw_mesh_path_add_gate(path);
} else if (path->is_gate) {
_rtw_spinlock_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
_rtw_spinunlock_bh(&path->state_lock);
}
}
rtw_rcu_read_unlock();
} else {
rtw_rcu_read_lock();
#ifdef CONFIG_RTW_MESH_ON_DMD_GANN
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
if (preq_is_gate)
rtw_mesh_path_add_gate(path);
else if (path->is_gate) {
_rtw_spinlock_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
_rtw_spinunlock_bh(&path->state_lock);
}
}
path = NULL;
#endif
path = rtw_mesh_path_lookup(adapter, target_addr);
if (path) {
if ((!(path->flags & RTW_MESH_PATH_SN_VALID)) ||
RTW_SN_LT(path->sn, target_sn)) {
path->sn = target_sn;
path->flags |= RTW_MESH_PATH_SN_VALID;
} else if ((!(target_flags & RTW_IEEE80211_PREQ_TO_FLAG)) &&
(path->flags & RTW_MESH_PATH_ACTIVE)) {
reply = _TRUE;
target_metric = path->metric;
target_sn = path->sn;
/* Case E2 of sec 13.10.9.3 IEEE 802.11-2012*/
target_flags |= RTW_IEEE80211_PREQ_TO_FLAG;
}
}
rtw_rcu_read_unlock();
}
if (reply) {
lifetime = RTW_PREQ_IE_LIFETIME(preq_elem);
ttl = mshcfg->element_ttl;
if (ttl != 0 && !to_gate_ask) {
RTW_HWMP_DBG("replying to the PREQ\n");
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREP, 0, originator_addr,
originator_sn, 0, target_addr,
target_sn, mgmt->addr2, 0, ttl,
lifetime, target_metric, 0,
adapter);
} else if (ttl != 0 && to_gate_ask) {
RTW_HWMP_DBG("replying to the PREQ (PREQ for us)\n");
if (mshcfg->dot11MeshGateAnnouncementProtocol) {
/* BIT 7 is used to identify the prep is from mesh gate */
to_gate_ask = RTW_IEEE80211_PREQ_IS_GATE_FLAG | BIT(7);
} else {
to_gate_ask = 0;
}
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREP, to_gate_ask, originator_addr,
originator_sn, 0, target_addr,
target_sn, mgmt->addr2, 0, ttl,
lifetime, target_metric, 0,
adapter);
} else {
minfo->mshstats.dropped_frames_ttl++;
}
}
if (forward && mshcfg->dot11MeshForwarding) {
u32 preq_id;
u8 hopcount;
ttl = RTW_PREQ_IE_TTL(preq_elem);
lifetime = RTW_PREQ_IE_LIFETIME(preq_elem);
if (ttl <= 1) {
minfo->mshstats.dropped_frames_ttl++;
return;
}
RTW_HWMP_DBG("forwarding the PREQ from "MAC_FMT"\n", MAC_ARG(originator_addr));
--ttl;
preq_id = RTW_PREQ_IE_PREQ_ID(preq_elem);
hopcount = RTW_PREQ_IE_HOPCOUNT(preq_elem) + 1;
da = (path && path->is_root) ?
path->rann_snd_addr : bcast_addr;
if (flags & RTW_IEEE80211_PREQ_PROACTIVE_PREP_FLAG) {
target_addr = RTW_PREQ_IE_TARGET_ADDR(preq_elem);
target_sn = RTW_PREQ_IE_TARGET_SN(preq_elem);
}
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREQ, flags, originator_addr,
originator_sn, target_flags, target_addr,
target_sn, da, hopcount, ttl, lifetime,
originator_metric, preq_id, adapter);
if (!is_multicast_mac_addr(da))
minfo->mshstats.fwded_unicast++;
else
minfo->mshstats.fwded_mcast++;
minfo->mshstats.fwded_frames++;
}
}
static inline struct sta_info *
rtw_next_hop_deref_protected(struct rtw_mesh_path *path)
{
return rtw_rcu_dereference_protected(path->next_hop,
rtw_lockdep_is_held(&path->state_lock));
}
static void rtw_hwmp_prep_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *prep_elem, u32 metric)
{
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_stats *mshstats = &adapter->mesh_info.mshstats;
struct rtw_mesh_path *path;
const u8 *target_addr, *originator_addr;
u8 ttl, hopcount, flags;
u8 next_hop[ETH_ALEN];
u32 target_sn, originator_sn, lifetime;
RTW_HWMP_DBG("received PREP from "MAC_FMT"\n",
MAC_ARG(RTW_PREP_IE_TARGET_ADDR(prep_elem)));
originator_addr = RTW_PREP_IE_ORIG_ADDR(prep_elem);
if (rtw_ether_addr_equal(originator_addr, adapter_mac_addr(adapter))) {
/* destination, no forwarding required */
rtw_rcu_read_lock();
target_addr = RTW_PREP_IE_TARGET_ADDR(prep_elem);
path = rtw_mesh_path_lookup(adapter, target_addr);
if (path && path->gate_asked) {
flags = RTW_PREP_IE_FLAGS(prep_elem);
if (flags & BIT(7)) {
_rtw_spinlock_bh(&path->state_lock);
path->gate_asked = false;
_rtw_spinunlock_bh(&path->state_lock);
if (!(flags & RTW_IEEE80211_PREQ_IS_GATE_FLAG)) {
_rtw_spinlock_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
_rtw_spinunlock_bh(&path->state_lock);
}
}
}
rtw_rcu_read_unlock();
return;
}
if (!mshcfg->dot11MeshForwarding)
return;
ttl = RTW_PREP_IE_TTL(prep_elem);
if (ttl <= 1) {
mshstats->dropped_frames_ttl++;
return;
}
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path)
_rtw_spinlock_bh(&path->state_lock);
else
goto fail;
if (!(path->flags & RTW_MESH_PATH_ACTIVE)) {
_rtw_spinunlock_bh(&path->state_lock);
goto fail;
}
_rtw_memcpy(next_hop, rtw_next_hop_deref_protected(path)->phl_sta->mac_addr, ETH_ALEN);
_rtw_spinunlock_bh(&path->state_lock);
--ttl;
flags = RTW_PREP_IE_FLAGS(prep_elem);
lifetime = RTW_PREP_IE_LIFETIME(prep_elem);
hopcount = RTW_PREP_IE_HOPCOUNT(prep_elem) + 1;
target_addr = RTW_PREP_IE_TARGET_ADDR(prep_elem);
target_sn = RTW_PREP_IE_TARGET_SN(prep_elem);
originator_sn = RTW_PREP_IE_ORIG_SN(prep_elem);
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREP, flags, originator_addr, originator_sn, 0,
target_addr, target_sn, next_hop, hopcount,
ttl, lifetime, metric, 0, adapter);
rtw_rcu_read_unlock();
mshstats->fwded_unicast++;
mshstats->fwded_frames++;
return;
fail:
rtw_rcu_read_unlock();
mshstats->dropped_frames_no_route++;
}
static void rtw_hwmp_perr_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *perr_elem)
{
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_stats *mshstats = &adapter->mesh_info.mshstats;
struct rtw_mesh_path *path;
u8 ttl;
const u8 *ta, *target_addr;
u32 target_sn;
u16 perr_reason_code;
ta = mgmt->addr2;
ttl = RTW_PERR_IE_TTL(perr_elem);
if (ttl <= 1) {
mshstats->dropped_frames_ttl++;
return;
}
ttl--;
target_addr = RTW_PERR_IE_TARGET_ADDR(perr_elem);
target_sn = RTW_PERR_IE_TARGET_SN(perr_elem);
perr_reason_code = RTW_PERR_IE_TARGET_RCODE(perr_elem);
RTW_HWMP_DBG("received PERR toward target "MAC_FMT"\n", MAC_ARG(target_addr));
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, target_addr);
if (path) {
struct sta_info *sta;
_rtw_spinlock_bh(&path->state_lock);
sta = rtw_next_hop_deref_protected(path);
if (path->flags & RTW_MESH_PATH_ACTIVE &&
rtw_ether_addr_equal(ta, sta->phl_sta->mac_addr) &&
!(path->flags & RTW_MESH_PATH_FIXED) &&
(!(path->flags & RTW_MESH_PATH_SN_VALID) ||
RTW_SN_GT(target_sn, path->sn) || target_sn == 0)) {
path->flags &= ~RTW_MESH_PATH_ACTIVE;
if (target_sn != 0)
path->sn = target_sn;
else
path->sn += 1;
_rtw_spinunlock_bh(&path->state_lock);
if (!mshcfg->dot11MeshForwarding)
goto endperr;
rtw_mesh_path_error_tx(adapter, ttl, target_addr,
target_sn, perr_reason_code,
bcast_addr);
} else
_rtw_spinunlock_bh(&path->state_lock);
}
endperr:
rtw_rcu_read_unlock();
}
static void rtw_hwmp_rann_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const struct rtw_ieee80211_rann_ie *rann)
{
struct sta_info *sta;
struct sta_priv *pstapriv = &adapter->stapriv;
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_stats *mshstats = &adapter->mesh_info.mshstats;
struct rtw_mesh_path *path;
u8 ttl, flags, hopcount;
const u8 *originator_addr;
u32 originator_sn, metric, metric_txsta, interval;
BOOLEAN root_is_gate;
ttl = rann->rann_ttl;
flags = rann->rann_flags;
root_is_gate = !!(flags & RTW_RANN_FLAG_IS_GATE);
originator_addr = rann->rann_addr;
originator_sn = le32_to_cpu(rann->rann_seq);
interval = le32_to_cpu(rann->rann_interval);
hopcount = rann->rann_hopcount;
hopcount++;
metric = le32_to_cpu(rann->rann_metric);
/* Ignore our own RANNs */
if (rtw_ether_addr_equal(originator_addr, adapter_mac_addr(adapter)))
return;
RTW_HWMP_DBG("received RANN from "MAC_FMT" via neighbour "MAC_FMT" (is_gate=%d)\n",
MAC_ARG(originator_addr), MAC_ARG(mgmt->addr2), root_is_gate);
rtw_rcu_read_lock();
sta = rtw_get_stainfo(pstapriv, mgmt->addr2);
if (!sta) {
rtw_rcu_read_unlock();
return;
}
metric_txsta = rtw_airtime_link_metric_get(adapter, sta);
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (!path) {
path = rtw_mesh_path_add(adapter, originator_addr);
if (IS_ERR(path)) {
rtw_rcu_read_unlock();
mshstats->dropped_frames_no_route++;
return;
}
}
if (!(RTW_SN_LT(path->sn, originator_sn)) &&
!(path->sn == originator_sn && metric < path->rann_metric)) {
rtw_rcu_read_unlock();
return;
}
if ((!(path->flags & (RTW_MESH_PATH_ACTIVE | RTW_MESH_PATH_RESOLVING)) ||
(rtw_time_after(rtw_get_current_time(), path->last_preq_to_root +
rtw_root_path_confirmation_jiffies(adapter)) ||
rtw_time_before(rtw_get_current_time(), path->last_preq_to_root))) &&
!(path->flags & RTW_MESH_PATH_FIXED) && (ttl != 0)) {
u8 preq_node_flag = RTW_PREQ_Q_F_START | RTW_PREQ_Q_F_REFRESH;
RTW_HWMP_DBG("time to refresh root path "MAC_FMT"\n",
MAC_ARG(originator_addr));
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (RTW_SN_LT(path->sn, originator_sn) &&
(path->rann_metric + mshcfg->sane_metric_delta < metric) &&
_rtw_memcmp(bcast_addr, path->rann_snd_addr, ETH_ALEN) == _FALSE) {
RTW_HWMP_DBG("Trigger additional check for root "
"confirm PREQ. rann_snd_addr = "MAC_FMT
"add_chk_rann_snd_addr= "MAC_FMT"\n",
MAC_ARG(mgmt->addr2),
MAC_ARG(path->rann_snd_addr));
_rtw_memcpy(path->add_chk_rann_snd_addr,
path->rann_snd_addr, ETH_ALEN);
preq_node_flag |= RTW_PREQ_Q_F_CHK;
}
#endif
rtw_mesh_queue_preq(path, preq_node_flag);
path->last_preq_to_root = rtw_get_current_time();
}
path->sn = originator_sn;
path->rann_metric = metric + metric_txsta;
path->is_root = _TRUE;
/* Recording RANNs sender address to send individually
* addressed PREQs destined for root mesh STA */
_rtw_memcpy(path->rann_snd_addr, mgmt->addr2, ETH_ALEN);
if (root_is_gate) {
path->gate_ann_int = interval;
path->gate_asked = false;
rtw_mesh_path_add_gate(path);
} else if (path->is_gate) {
_rtw_spinlock_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
_rtw_spinunlock_bh(&path->state_lock);
}
if (ttl <= 1) {
mshstats->dropped_frames_ttl++;
rtw_rcu_read_unlock();
return;
}
ttl--;
if (mshcfg->dot11MeshForwarding) {
rtw_mesh_path_sel_frame_tx(RTW_MPATH_RANN, flags, originator_addr,
originator_sn, 0, NULL, 0, bcast_addr,
hopcount, ttl, interval,
metric + metric_txsta, 0, adapter);
}
rtw_rcu_read_unlock();
}
static u32 rtw_hwmp_route_info_get(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *hwmp_ie, enum rtw_mpath_frame_type action)
{
struct rtw_mesh_path *path;
struct sta_priv *pstapriv = &adapter->stapriv;
struct sta_info *sta;
BOOLEAN fresh_info;
const u8 *originator_addr, *ta;
u32 originator_sn, originator_metric;
unsigned long originator_lifetime, exp_time;
u32 last_hop_metric, new_metric;
BOOLEAN process = _TRUE;
rtw_rcu_read_lock();
sta = rtw_get_stainfo(pstapriv, mgmt->addr2);
if (!sta) {
rtw_rcu_read_unlock();
return 0;
}
last_hop_metric = rtw_airtime_link_metric_get(adapter, sta);
/* Update and check originator routing info */
fresh_info = _TRUE;
switch (action) {
case RTW_MPATH_PREQ:
originator_addr = RTW_PREQ_IE_ORIG_ADDR(hwmp_ie);
originator_sn = RTW_PREQ_IE_ORIG_SN(hwmp_ie);
originator_lifetime = RTW_PREQ_IE_LIFETIME(hwmp_ie);
originator_metric = RTW_PREQ_IE_METRIC(hwmp_ie);
break;
case RTW_MPATH_PREP:
/* Note: For coding, the naming is not consist with spec */
originator_addr = RTW_PREP_IE_TARGET_ADDR(hwmp_ie);
originator_sn = RTW_PREP_IE_TARGET_SN(hwmp_ie);
originator_lifetime = RTW_PREP_IE_LIFETIME(hwmp_ie);
originator_metric = RTW_PREP_IE_METRIC(hwmp_ie);
break;
default:
rtw_rcu_read_unlock();
return 0;
}
new_metric = originator_metric + last_hop_metric;
if (new_metric < originator_metric)
new_metric = RTW_MAX_METRIC;
exp_time = RTW_TU_TO_EXP_TIME(originator_lifetime);
if (rtw_ether_addr_equal(originator_addr, adapter_mac_addr(adapter))) {
process = _FALSE;
fresh_info = _FALSE;
} else {
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
_rtw_spinlock_bh(&path->state_lock);
if (path->flags & RTW_MESH_PATH_FIXED)
fresh_info = _FALSE;
else if ((path->flags & RTW_MESH_PATH_ACTIVE) &&
(path->flags & RTW_MESH_PATH_SN_VALID)) {
if (RTW_SN_GT(path->sn, originator_sn) ||
(path->sn == originator_sn &&
new_metric >= path->metric)) {
process = _FALSE;
fresh_info = _FALSE;
}
} else if (!(path->flags & RTW_MESH_PATH_ACTIVE)) {
BOOLEAN have_sn, newer_sn, bounced;
have_sn = path->flags & RTW_MESH_PATH_SN_VALID;
newer_sn = have_sn && RTW_SN_GT(originator_sn, path->sn);
bounced = have_sn &&
(RTW_SN_DELTA(originator_sn, path->sn) >
RTW_MAX_SANE_SN_DELTA);
if (!have_sn || newer_sn) {
} else if (bounced) {
} else {
process = _FALSE;
fresh_info = _FALSE;
}
}
} else {
path = rtw_mesh_path_add(adapter, originator_addr);
if (IS_ERR(path)) {
rtw_rcu_read_unlock();
return 0;
}
_rtw_spinlock_bh(&path->state_lock);
}
if (fresh_info) {
rtw_mesh_path_assign_nexthop(path, sta);
path->flags |= RTW_MESH_PATH_SN_VALID;
path->metric = new_metric;
path->sn = originator_sn;
path->exp_time = rtw_time_after(path->exp_time, exp_time)
? path->exp_time : exp_time;
rtw_mesh_path_activate(path);
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (path->is_root && (action == RTW_MPATH_PREP)) {
_rtw_memcpy(path->rann_snd_addr,
mgmt->addr2, ETH_ALEN);
path->rann_metric = new_metric;
}
#endif
_rtw_spinunlock_bh(&path->state_lock);
rtw_mesh_path_tx_pending(path);
} else
_rtw_spinunlock_bh(&path->state_lock);
}
/* Update and check transmitter routing info */
ta = mgmt->addr2;
if (rtw_ether_addr_equal(originator_addr, ta))
fresh_info = _FALSE;
else {
fresh_info = _TRUE;
path = rtw_mesh_path_lookup(adapter, ta);
if (path) {
_rtw_spinlock_bh(&path->state_lock);
if ((path->flags & RTW_MESH_PATH_FIXED) ||
((path->flags & RTW_MESH_PATH_ACTIVE) &&
(last_hop_metric > path->metric)))
fresh_info = _FALSE;
} else {
path = rtw_mesh_path_add(adapter, ta);
if (IS_ERR(path)) {
rtw_rcu_read_unlock();
return 0;
}
_rtw_spinlock_bh(&path->state_lock);
}
if (fresh_info) {
rtw_mesh_path_assign_nexthop(path, sta);
path->metric = last_hop_metric;
path->exp_time = rtw_time_after(path->exp_time, exp_time)
? path->exp_time : exp_time;
rtw_mesh_path_activate(path);
_rtw_spinunlock_bh(&path->state_lock);
rtw_mesh_path_tx_pending(path);
} else
_rtw_spinunlock_bh(&path->state_lock);
}
rtw_rcu_read_unlock();
return process ? new_metric : 0;
}
static void rtw_mesh_rx_hwmp_frame_cnts(_adapter *adapter, u8 *addr)
{
struct sta_info *sta;
sta = rtw_get_stainfo(&adapter->stapriv, addr);
if (sta)
sta->sta_stats.rx_hwmp_pkts++;
}
void rtw_mesh_rx_path_sel_frame(_adapter *adapter, union recv_frame *rframe)
{
struct mesh_plink_ent *plink = NULL;
struct rtw_ieee802_11_elems elems;
u32 path_metric;
struct rx_pkt_attrib *attrib = &rframe->u.hdr.attrib;
u8 *pframe = rframe->u.hdr.rx_data, *start;
uint frame_len = rframe->u.hdr.len, left;
struct rtw_ieee80211_hdr_3addr *frame_hdr = (struct rtw_ieee80211_hdr_3addr *)pframe;
u8 *frame_body = (u8 *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
ParseRes parse_res;
plink = rtw_mesh_plink_get(adapter, get_addr2_ptr(pframe));
if (!plink || plink->plink_state != RTW_MESH_PLINK_ESTAB)
return;
rtw_mesh_rx_hwmp_frame_cnts(adapter, get_addr2_ptr(pframe));
/* Mesh action frame IE offset = 2 */
attrib->hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
left = frame_len - attrib->hdrlen - attrib->iv_len - attrib->icv_len - 2;
start = pframe + attrib->hdrlen + 2;
parse_res = rtw_ieee802_11_parse_elems(start, left, &elems, 1);
if (parse_res == ParseFailed)
RTW_HWMP_INFO(FUNC_ADPT_FMT" Path Select Frame ParseFailed\n"
, FUNC_ADPT_ARG(adapter));
else if (parse_res == ParseUnknown)
RTW_HWMP_INFO(FUNC_ADPT_FMT" Path Select Frame ParseUnknown\n"
, FUNC_ADPT_ARG(adapter));
if (elems.preq) {
if (elems.preq_len != 37)
/* Right now we support just 1 destination and no AE */
return;
path_metric = rtw_hwmp_route_info_get(adapter, frame_hdr, elems.preq,
MPATH_PREQ);
if (path_metric)
rtw_hwmp_preq_frame_process(adapter, frame_hdr, elems.preq,
path_metric);
}
if (elems.prep) {
if (elems.prep_len != 31)
/* Right now we support no AE */
return;
path_metric = rtw_hwmp_route_info_get(adapter, frame_hdr, elems.prep,
MPATH_PREP);
if (path_metric)
rtw_hwmp_prep_frame_process(adapter, frame_hdr, elems.prep,
path_metric);
}
if (elems.perr) {
if (elems.perr_len != 15)
/* Right now we support only one destination per PERR */
return;
rtw_hwmp_perr_frame_process(adapter, frame_hdr, elems.perr);
}
if (elems.rann)
rtw_hwmp_rann_frame_process(adapter, frame_hdr, (struct rtw_ieee80211_rann_ie *)elems.rann);
}
void rtw_mesh_queue_preq(struct rtw_mesh_path *path, u8 flags)
{
_adapter *adapter = path->adapter;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_preq_queue *preq_node;
preq_node = rtw_malloc(sizeof(struct rtw_mesh_preq_queue));
if (!preq_node) {
RTW_HWMP_INFO("could not allocate PREQ node\n");
return;
}
_rtw_spinlock_bh(&minfo->mesh_preq_queue_lock);
if (minfo->preq_queue_len == RTW_MAX_PREQ_QUEUE_LEN) {
_rtw_spinunlock_bh(&minfo->mesh_preq_queue_lock);
rtw_mfree(preq_node, sizeof(struct rtw_mesh_preq_queue));
if (rtw_print_ratelimit())
RTW_HWMP_INFO("PREQ node queue full\n");
return;
}
_rtw_spinlock(&path->state_lock);
if (path->flags & RTW_MESH_PATH_REQ_QUEUED) {
_rtw_spinunlock(&path->state_lock);
_rtw_spinunlock_bh(&minfo->mesh_preq_queue_lock);
rtw_mfree(preq_node, sizeof(struct rtw_mesh_preq_queue));
return;
}
_rtw_memcpy(preq_node->dst, path->dst, ETH_ALEN);
preq_node->flags = flags;
path->flags |= RTW_MESH_PATH_REQ_QUEUED;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (flags & RTW_PREQ_Q_F_CHK)
path->flags |= RTW_MESH_PATH_ROOT_ADD_CHK;
#endif
if (flags & RTW_PREQ_Q_F_PEER_AKA)
path->flags |= RTW_MESH_PATH_PEER_AKA;
if (flags & RTW_PREQ_Q_F_BCAST_PREQ)
path->flags |= RTW_MESH_PATH_BCAST_PREQ;
_rtw_spinunlock(&path->state_lock);
rtw_list_insert_tail(&preq_node->list, &minfo->preq_queue.list);
++minfo->preq_queue_len;
_rtw_spinunlock_bh(&minfo->mesh_preq_queue_lock);
if (rtw_time_after(rtw_get_current_time(), minfo->last_preq + rtw_min_preq_int_jiff(adapter)))
rtw_mesh_work(&adapter->mesh_work);
else if (rtw_time_before(rtw_get_current_time(), minfo->last_preq)) {
/* systime wrapped around issue */
minfo->last_preq = rtw_get_current_time() - rtw_min_preq_int_jiff(adapter) - 1;
rtw_mesh_work(&adapter->mesh_work);
} else
rtw_mod_timer(&adapter->mesh_path_timer, minfo->last_preq +
rtw_min_preq_int_jiff(adapter) + 1);
}
static const u8 *rtw_hwmp_preq_da(struct rtw_mesh_path *path,
BOOLEAN is_root_add_chk, BOOLEAN da_is_peer,
BOOLEAN force_preq_bcast)
{
const u8 *da;
if (da_is_peer)
da = path->dst;
else if (force_preq_bcast)
da = bcast_addr;
else if (path->is_root)
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
da = is_root_add_chk ? path->add_chk_rann_snd_addr:
path->rann_snd_addr;
#else
da = path->rann_snd_addr;
#endif
else
da = bcast_addr;
return da;
}
void rtw_mesh_path_start_discovery(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_preq_queue *preq_node;
struct rtw_mesh_path *path;
u8 ttl, target_flags = 0;
const u8 *da;
u32 lifetime;
u8 flags = 0;
BOOLEAN is_root_add_chk = _FALSE;
BOOLEAN da_is_peer, force_preq_bcast;
_rtw_spinlock_bh(&minfo->mesh_preq_queue_lock);
if (!minfo->preq_queue_len ||
rtw_time_before(rtw_get_current_time(), minfo->last_preq +
rtw_min_preq_int_jiff(adapter))) {
_rtw_spinunlock_bh(&minfo->mesh_preq_queue_lock);
return;
}
preq_node = rtw_list_first_entry(&minfo->preq_queue.list,
struct rtw_mesh_preq_queue, list);
rtw_list_delete(&preq_node->list); /* list_del_init(&preq_node->list); */
--minfo->preq_queue_len;
_rtw_spinunlock_bh(&minfo->mesh_preq_queue_lock);
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, preq_node->dst);
if (!path)
goto enddiscovery;
_rtw_spinlock_bh(&path->state_lock);
if (path->flags & (RTW_MESH_PATH_DELETED | RTW_MESH_PATH_FIXED)) {
_rtw_spinunlock_bh(&path->state_lock);
goto enddiscovery;
}
path->flags &= ~RTW_MESH_PATH_REQ_QUEUED;
if (preq_node->flags & RTW_PREQ_Q_F_START) {
if (path->flags & RTW_MESH_PATH_RESOLVING) {
_rtw_spinunlock_bh(&path->state_lock);
goto enddiscovery;
} else {
path->flags &= ~RTW_MESH_PATH_RESOLVED;
path->flags |= RTW_MESH_PATH_RESOLVING;
path->discovery_retries = 0;
path->discovery_timeout = rtw_disc_timeout_jiff(adapter);
}
} else if (!(path->flags & RTW_MESH_PATH_RESOLVING) ||
path->flags & RTW_MESH_PATH_RESOLVED) {
path->flags &= ~RTW_MESH_PATH_RESOLVING;
_rtw_spinunlock_bh(&path->state_lock);
goto enddiscovery;
}
minfo->last_preq = rtw_get_current_time();
if (rtw_time_after(rtw_get_current_time(), minfo->last_sn_update +
rtw_net_traversal_jiffies(adapter)) ||
rtw_time_before(rtw_get_current_time(), minfo->last_sn_update)) {
++minfo->sn;
minfo->last_sn_update = rtw_get_current_time();
}
lifetime = rtw_default_lifetime(adapter);
ttl = mshcfg->element_ttl;
if (ttl == 0) {
minfo->mshstats.dropped_frames_ttl++;
_rtw_spinunlock_bh(&path->state_lock);
goto enddiscovery;
}
if (preq_node->flags & RTW_PREQ_Q_F_REFRESH)
target_flags |= RTW_IEEE80211_PREQ_TO_FLAG;
else
target_flags &= ~RTW_IEEE80211_PREQ_TO_FLAG;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
is_root_add_chk = !!(path->flags & RTW_MESH_PATH_ROOT_ADD_CHK);
#endif
da_is_peer = !!(path->flags & RTW_MESH_PATH_PEER_AKA);
force_preq_bcast = !!(path->flags & RTW_MESH_PATH_BCAST_PREQ);
_rtw_spinunlock_bh(&path->state_lock);
da = rtw_hwmp_preq_da(path, is_root_add_chk,
da_is_peer, force_preq_bcast);
#ifdef CONFIG_RTW_MESH_ON_DMD_GANN
flags = (mshcfg->dot11MeshGateAnnouncementProtocol)
? RTW_IEEE80211_PREQ_IS_GATE_FLAG : 0;
#endif
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREQ, flags, adapter_mac_addr(adapter), minfo->sn,
target_flags, path->dst, path->sn, da, 0,
ttl, lifetime, 0, minfo->preq_id++, adapter);
rtw_mod_timer(&path->timer, rtw_get_current_time() + path->discovery_timeout);
enddiscovery:
rtw_rcu_read_unlock();
rtw_mfree(preq_node, sizeof(struct rtw_mesh_preq_queue));
}
void rtw_mesh_path_timer(void *ctx)
{
struct rtw_mesh_path *path = (void *) ctx;
_adapter *adapter = path->adapter;
int ret;
u8 retry = 0;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
#endif
/* TBD: Proctect for suspend */
#if 0
if (suspending)
return;
#endif
_rtw_spinlock_bh(&path->state_lock);
if (path->flags & RTW_MESH_PATH_RESOLVED ||
(!(path->flags & RTW_MESH_PATH_RESOLVING))) {
path->flags &= ~(RTW_MESH_PATH_RESOLVING |
RTW_MESH_PATH_RESOLVED |
RTW_MESH_PATH_ROOT_ADD_CHK |
RTW_MESH_PATH_PEER_AKA |
RTW_MESH_PATH_BCAST_PREQ);
_rtw_spinunlock_bh(&path->state_lock);
} else if (path->discovery_retries < rtw_max_preq_retries(adapter)) {
++path->discovery_retries;
path->discovery_timeout *= 2;
path->flags &= ~RTW_MESH_PATH_REQ_QUEUED;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (path->discovery_retries > mshcfg->max_root_add_chk_cnt)
path->flags &= ~RTW_MESH_PATH_ROOT_ADD_CHK;
#endif
if (path->gate_asked)
retry |= RTW_PREQ_Q_F_REFRESH;
_rtw_spinunlock_bh(&path->state_lock);
rtw_mesh_queue_preq(path, retry);
} else {
path->flags &= ~(RTW_MESH_PATH_RESOLVING |
RTW_MESH_PATH_RESOLVED |
RTW_MESH_PATH_REQ_QUEUED |
RTW_MESH_PATH_ROOT_ADD_CHK |
RTW_MESH_PATH_PEER_AKA |
RTW_MESH_PATH_BCAST_PREQ);
path->exp_time = rtw_get_current_time();
_rtw_spinunlock_bh(&path->state_lock);
if (!path->is_gate && rtw_mesh_gate_num(adapter) > 0) {
ret = rtw_mesh_path_send_to_gates(path);
if (ret)
RTW_HWMP_DBG("no gate was reachable\n");
} else
rtw_mesh_path_flush_pending(path);
}
}
void rtw_mesh_path_tx_root_frame(_adapter *adapter)
{
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
u32 interval = mshcfg->dot11MeshHWMPRannInterval;
u8 flags, target_flags = 0;
flags = (mshcfg->dot11MeshGateAnnouncementProtocol)
? RTW_RANN_FLAG_IS_GATE : 0;
switch (mshcfg->dot11MeshHWMPRootMode) {
case RTW_IEEE80211_PROACTIVE_RANN:
rtw_mesh_path_sel_frame_tx(RTW_MPATH_RANN, flags, adapter_mac_addr(adapter),
++minfo->sn, 0, NULL, 0, bcast_addr,
0, mshcfg->element_ttl,
interval, 0, 0, adapter);
break;
case RTW_IEEE80211_PROACTIVE_PREQ_WITH_PREP:
flags |= RTW_IEEE80211_PREQ_PROACTIVE_PREP_FLAG;
case RTW_IEEE80211_PROACTIVE_PREQ_NO_PREP:
interval = mshcfg->dot11MeshHWMPactivePathToRootTimeout;
target_flags |= RTW_IEEE80211_PREQ_TO_FLAG |
RTW_IEEE80211_PREQ_USN_FLAG;
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREQ, flags, adapter_mac_addr(adapter),
++minfo->sn, target_flags,
(u8 *) bcast_addr, 0, bcast_addr,
0, mshcfg->element_ttl, interval,
0, minfo->preq_id++, adapter);
break;
default:
RTW_HWMP_INFO("Proactive mechanism not supported\n");
return;
}
}
void rtw_mesh_work(_workitem *work)
{
/* use kernel global workqueue */
_set_workitem(work);
}
void rtw_ieee80211_mesh_path_timer(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
rtw_mesh_work(&adapter->mesh_work);
}
void rtw_ieee80211_mesh_path_root_timer(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
rtw_set_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags);
rtw_mesh_work(&adapter->mesh_work);
}
static void rtw_ieee80211_mesh_rootpath(_adapter *adapter)
{
u32 interval;
rtw_mesh_path_tx_root_frame(adapter);
if (adapter->mesh_cfg.dot11MeshHWMPRootMode == RTW_IEEE80211_PROACTIVE_RANN)
interval = adapter->mesh_cfg.dot11MeshHWMPRannInterval;
else
interval = adapter->mesh_cfg.dot11MeshHWMProotInterval;
rtw_mod_timer(&adapter->mesh_path_root_timer,
RTW_TU_TO_EXP_TIME(interval));
}
BOOLEAN rtw_ieee80211_mesh_root_setup(_adapter *adapter)
{
BOOLEAN root_enabled = _FALSE;
if (adapter->mesh_cfg.dot11MeshHWMPRootMode > RTW_IEEE80211_ROOTMODE_ROOT) {
rtw_set_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags);
root_enabled = _TRUE;
}
else {
rtw_clear_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags);
/* stop running timer */
_cancel_timer_ex(&adapter->mesh_path_root_timer);
root_enabled = _FALSE;
}
return root_enabled;
}
void rtw_mesh_work_hdl(_workitem *work)
{
_adapter *adapter = container_of(work, _adapter, mesh_work);
while(adapter->mesh_info.preq_queue_len) {
if (rtw_time_after(rtw_get_current_time(),
adapter->mesh_info.last_preq + rtw_min_preq_int_jiff(adapter)))
/* It will consume preq_queue_len */
rtw_mesh_path_start_discovery(adapter);
else {
struct rtw_mesh_info *minfo = &adapter->mesh_info;
rtw_mod_timer(&adapter->mesh_path_timer,
minfo->last_preq + rtw_min_preq_int_jiff(adapter) + 1);
break;
}
}
if (rtw_test_and_clear_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags))
rtw_ieee80211_mesh_rootpath(adapter);
}
#ifndef RTW_PER_CMD_SUPPORT_FW
static void rtw_update_metric_directly(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
u8 i;
for (i = 0; i < macid_ctl->num; i++) {
u8 role;
role = GET_H2CCMD_MSRRPT_PARM_ROLE(&macid_ctl->h2c_msr[i]);
if (role == H2C_MSR_ROLE_MESH) {
struct sta_info *sta = macid_ctl->sta[i];
u8 rate_idx, sgi, bw;
u32 rate;
if (!sta)
continue;
rate_idx = rtw_hal_get_current_tx_rate(adapter, sta);
sgi = rtw_get_current_tx_sgi(adapter, sta);
bw = sta->phl_sta->chandef.bw;
rate = rtw_desc_rate_to_bitrate(bw, rate_idx, sgi);
sta->metrics.data_rate = rate;
}
}
}
#endif
void rtw_mesh_atlm_param_req_timer(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
u8 ret = _FAIL;
#ifdef RTW_PER_CMD_SUPPORT_FW
ret = rtw_req_per_cmd(adapter);
if (ret == _FAIL)
RTW_HWMP_INFO("rtw_req_per_cmd fail\n");
#else
rtw_update_metric_directly(adapter);
#endif
_set_timer(&adapter->mesh_atlm_param_req_timer, RTW_ATLM_REQ_CYCLE);
}
#endif /* CONFIG_RTW_MESH */
|
2301_81045437/rtl8852be
|
core/mesh/rtw_mesh_hwmp.c
|
C
|
agpl-3.0
| 49,321
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __RTW_MESH_HWMP_H_
#define __RTW_MESH_HWMP_H_
#ifndef DBG_RTW_HWMP
#define DBG_RTW_HWMP 0
#endif
#if DBG_RTW_HWMP
#define RTW_HWMP_DBG(fmt, arg...) RTW_PRINT(fmt, ##arg)
#else
#define RTW_HWMP_DBG(fmt, arg...) RTW_DBG(fmt, ##arg)
#endif
#ifndef INFO_RTW_HWMP
#define INFO_RTW_HWMP 0
#endif
#if INFO_RTW_HWMP
#define RTW_HWMP_INFO(fmt, arg...) RTW_PRINT(fmt, ##arg)
#else
#define RTW_HWMP_INFO(fmt, arg...) RTW_INFO(fmt, ##arg)
#endif
void rtw_ewma_err_rate_init(struct rtw_ewma_err_rate *e);
unsigned long rtw_ewma_err_rate_read(struct rtw_ewma_err_rate *e);
void rtw_ewma_err_rate_add(struct rtw_ewma_err_rate *e, unsigned long val);
int rtw_mesh_path_error_tx(_adapter *adapter,
u8 ttl, const u8 *target, u32 target_sn,
u16 target_rcode, const u8 *ra);
void rtw_ieee80211s_update_metric(_adapter *adapter, u8 mac_id,
u8 per, u8 rate,
u8 bw, u8 total_pkt);
void rtw_mesh_rx_path_sel_frame(_adapter *adapter, union recv_frame *rframe);
void rtw_mesh_queue_preq(struct rtw_mesh_path *mpath, u8 flags);
void rtw_mesh_path_start_discovery(_adapter *adapter);
void rtw_mesh_path_timer(void *ctx);
void rtw_mesh_path_tx_root_frame(_adapter *adapter);
void rtw_mesh_work_hdl(_workitem *work);
void rtw_ieee80211_mesh_path_timer(void *ctx);
void rtw_ieee80211_mesh_path_root_timer(void *ctx);
BOOLEAN rtw_ieee80211_mesh_root_setup(_adapter *adapter);
void rtw_mesh_work(_workitem *work);
void rtw_mesh_atlm_param_req_timer(void *ctx);
#endif /* __RTW_MESH_HWMP_H_ */
|
2301_81045437/rtl8852be
|
core/mesh/rtw_mesh_hwmp.h
|
C
|
agpl-3.0
| 2,155
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_MESH_PATHTBL_C_
#ifdef CONFIG_RTW_MESH
#include <drv_types.h>
#include <linux/jhash.h>
#ifdef PLATFORM_LINUX
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0))
static void rtw_mpath_free_rcu(struct rtw_mesh_path *mpath)
{
kfree_rcu(mpath, rcu);
rtw_mstat_update(MSTAT_TYPE_PHY, MSTAT_FREE, sizeof(struct rtw_mesh_path));
}
#else
static void rtw_mpath_free_rcu_callback(rtw_rcu_head *head)
{
struct rtw_mesh_path *mpath;
mpath = container_of(head, struct rtw_mesh_path, rcu);
rtw_mfree(mpath, sizeof(struct rtw_mesh_path));
}
static void rtw_mpath_free_rcu(struct rtw_mesh_path *mpath)
{
call_rcu(&mpath->rcu, rtw_mpath_free_rcu_callback);
}
#endif
#endif /* PLATFORM_LINUX */
static void rtw_mesh_path_free_rcu(struct rtw_mesh_table *tbl, struct rtw_mesh_path *mpath);
static u32 rtw_mesh_table_hash(const void *addr, u32 len, u32 seed)
{
/* Use last four bytes of hw addr as hash index */
return jhash_1word(*(u32 *)(addr+2), seed);
}
static const rtw_rhashtable_params rtw_mesh_rht_params = {
.nelem_hint = 2,
.automatic_shrinking = true,
.key_len = ETH_ALEN,
.key_offset = offsetof(struct rtw_mesh_path, dst),
.head_offset = offsetof(struct rtw_mesh_path, rhash),
.hashfn = rtw_mesh_table_hash,
};
static inline bool rtw_mpath_expired(struct rtw_mesh_path *mpath)
{
return (mpath->flags & RTW_MESH_PATH_ACTIVE) &&
rtw_time_after(rtw_get_current_time(), mpath->exp_time) &&
!(mpath->flags & RTW_MESH_PATH_FIXED);
}
static void rtw_mesh_path_rht_free(void *ptr, void *tblptr)
{
struct rtw_mesh_path *mpath = ptr;
struct rtw_mesh_table *tbl = tblptr;
rtw_mesh_path_free_rcu(tbl, mpath);
}
static struct rtw_mesh_table *rtw_mesh_table_alloc(void)
{
struct rtw_mesh_table *newtbl;
newtbl = rtw_malloc(sizeof(struct rtw_mesh_table));
if (!newtbl)
return NULL;
rtw_hlist_head_init(&newtbl->known_gates);
ATOMIC_SET(&newtbl->entries, 0);
_rtw_spinlock_init(&newtbl->gates_lock);
return newtbl;
}
static void rtw_mesh_table_free(struct rtw_mesh_table *tbl)
{
rtw_rhashtable_free_and_destroy(&tbl->rhead,
rtw_mesh_path_rht_free, tbl);
rtw_mfree(tbl, sizeof(struct rtw_mesh_table));
}
/**
*
* rtw_mesh_path_assign_nexthop - update mesh path next hop
*
* @mpath: mesh path to update
* @sta: next hop to assign
*
* Locking: mpath->state_lock must be held when calling this function
*/
void rtw_mesh_path_assign_nexthop(struct rtw_mesh_path *mpath, struct sta_info *sta)
{
struct xmit_frame *xframe;
_list *list, *head;
rtw_rcu_assign_pointer(mpath->next_hop, sta);
_rtw_spinlock_bh(&mpath->frame_queue.lock);
head = &mpath->frame_queue.queue;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
xframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
_rtw_memcpy(xframe->attrib.ra, sta->phl_sta->mac_addr, ETH_ALEN);
}
_rtw_spinunlock_bh(&mpath->frame_queue.lock);
}
static void rtw_prepare_for_gate(struct xmit_frame *xframe, char *dst_addr,
struct rtw_mesh_path *gate_mpath)
{
struct pkt_attrib *attrib = &xframe->attrib;
char *next_hop;
if (attrib->mesh_frame_mode == MESH_UCAST_DATA)
attrib->mesh_frame_mode = MESH_UCAST_PX_DATA;
/* update next hop */
rtw_rcu_read_lock();
next_hop = rtw_rcu_dereference(gate_mpath->next_hop)->phl_sta->mac_addr;
_rtw_memcpy(attrib->ra, next_hop, ETH_ALEN);
rtw_rcu_read_unlock();
_rtw_memcpy(attrib->mda, dst_addr, ETH_ALEN);
}
/**
*
* rtw_mesh_path_move_to_queue - Move or copy frames from one mpath queue to another
*
* This function is used to transfer or copy frames from an unresolved mpath to
* a gate mpath. The function also adds the Address Extension field and
* updates the next hop.
*
* If a frame already has an Address Extension field, only the next hop and
* destination addresses are updated.
*
* The gate mpath must be an active mpath with a valid mpath->next_hop.
*
* @mpath: An active mpath the frames will be sent to (i.e. the gate)
* @from_mpath: The failed mpath
* @copy: When true, copy all the frames to the new mpath queue. When false,
* move them.
*/
static void rtw_mesh_path_move_to_queue(struct rtw_mesh_path *gate_mpath,
struct rtw_mesh_path *from_mpath,
bool copy)
{
struct xmit_frame *fskb;
_list *list, *head;
_list failq;
u32 failq_len;
if (rtw_warn_on(gate_mpath == from_mpath))
return;
if (rtw_warn_on(!gate_mpath->next_hop))
return;
_rtw_init_listhead(&failq);
_rtw_spinlock_bh(&from_mpath->frame_queue.lock);
rtw_list_splice_init(&from_mpath->frame_queue.queue, &failq);
failq_len = from_mpath->frame_queue_len;
from_mpath->frame_queue_len = 0;
_rtw_spinunlock_bh(&from_mpath->frame_queue.lock);
head = &failq;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
if (gate_mpath->frame_queue_len >= RTW_MESH_FRAME_QUEUE_LEN) {
RTW_MPATH_DBG(FUNC_ADPT_FMT" mpath queue for gate %pM is full!\n"
, FUNC_ADPT_ARG(gate_mpath->adapter), gate_mpath->dst);
break;
}
fskb = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&fskb->list);
failq_len--;
rtw_prepare_for_gate(fskb, gate_mpath->dst, gate_mpath);
_rtw_spinlock_bh(&gate_mpath->frame_queue.lock);
rtw_list_insert_tail(&fskb->list, get_list_head(&gate_mpath->frame_queue));
gate_mpath->frame_queue_len++;
_rtw_spinunlock_bh(&gate_mpath->frame_queue.lock);
#if 0 /* TODO: copy */
skb = rtw_skb_copy(fskb);
if (rtw_warn_on(!skb))
break;
rtw_prepare_for_gate(skb, gate_mpath->dst, gate_mpath);
skb_queue_tail(&gate_mpath->frame_queue, skb);
if (copy)
continue;
__skb_unlink(fskb, &failq);
rtw_skb_free(fskb);
#endif
}
RTW_MPATH_DBG(FUNC_ADPT_FMT" mpath queue for gate %pM has %d frames\n"
, FUNC_ADPT_ARG(gate_mpath->adapter), gate_mpath->dst, gate_mpath->frame_queue_len);
if (!copy)
return;
_rtw_spinlock_bh(&from_mpath->frame_queue.lock);
rtw_list_splice(&failq, &from_mpath->frame_queue.queue);
from_mpath->frame_queue_len += failq_len;
_rtw_spinunlock_bh(&from_mpath->frame_queue.lock);
}
static struct rtw_mesh_path *rtw_mpath_lookup(struct rtw_mesh_table *tbl, const u8 *dst)
{
struct rtw_mesh_path *mpath;
if (!tbl)
return NULL;
mpath = rtw_rhashtable_lookup_fast(&tbl->rhead, dst, rtw_mesh_rht_params);
if (mpath && rtw_mpath_expired(mpath)) {
_rtw_spinlock_bh(&mpath->state_lock);
mpath->flags &= ~RTW_MESH_PATH_ACTIVE;
_rtw_spinunlock_bh(&mpath->state_lock);
}
return mpath;
}
/**
* rtw_mesh_path_lookup - look up a path in the mesh path table
* @sdata: local subif
* @dst: hardware address (ETH_ALEN length) of destination
*
* Returns: pointer to the mesh path structure, or NULL if not found
*
* Locking: must be called within a read rcu section.
*/
struct rtw_mesh_path *
rtw_mesh_path_lookup(_adapter *adapter, const u8 *dst)
{
return rtw_mpath_lookup(adapter->mesh_info.mesh_paths, dst);
}
struct rtw_mesh_path *
rtw_mpp_path_lookup(_adapter *adapter, const u8 *dst)
{
return rtw_mpath_lookup(adapter->mesh_info.mpp_paths, dst);
}
static struct rtw_mesh_path *
__rtw_mesh_path_lookup_by_idx(struct rtw_mesh_table *tbl, int idx)
{
int i = 0, ret;
struct rtw_mesh_path *mpath = NULL;
rtw_rhashtable_iter iter;
if (!tbl)
return NULL;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return NULL;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto err;
while ((mpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
continue;
if (IS_ERR(mpath))
break;
if (i++ == idx)
break;
}
err:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
if (IS_ERR(mpath) || !mpath)
return NULL;
if (rtw_mpath_expired(mpath)) {
_rtw_spinlock_bh(&mpath->state_lock);
mpath->flags &= ~RTW_MESH_PATH_ACTIVE;
_rtw_spinunlock_bh(&mpath->state_lock);
}
return mpath;
}
/**
* rtw_mesh_path_lookup_by_idx - look up a path in the mesh path table by its index
* @idx: index
* @sdata: local subif, or NULL for all entries
*
* Returns: pointer to the mesh path structure, or NULL if not found.
*
* Locking: must be called within a read rcu section.
*/
struct rtw_mesh_path *
rtw_mesh_path_lookup_by_idx(_adapter *adapter, int idx)
{
return __rtw_mesh_path_lookup_by_idx(adapter->mesh_info.mesh_paths, idx);
}
void dump_mpath(void *sel, _adapter *adapter)
{
struct rtw_mesh_path *mpath;
int idx = 0;
char dst[ETH_ALEN];
char next_hop[ETH_ALEN];
u32 sn, metric, qlen;
u32 exp_ms = 0, dto_ms;
u8 drty;
enum rtw_mesh_path_flags flags;
RTW_PRINT_SEL(sel, "%-17s %-17s %-10s %-10s %-4s %-6s %-6s %-4s flags\n"
, "dst", "next_hop", "sn", "metric", "qlen", "exp_ms", "dto_ms", "drty"
);
do {
rtw_rcu_read_lock();
mpath = rtw_mesh_path_lookup_by_idx(adapter, idx);
if (mpath) {
_rtw_memcpy(dst, mpath->dst, ETH_ALEN);
_rtw_memcpy(next_hop, mpath->next_hop->phl_sta->mac_addr, ETH_ALEN);
sn = mpath->sn;
metric = mpath->metric;
qlen = mpath->frame_queue_len;
if (rtw_time_after(mpath->exp_time, rtw_get_current_time()))
exp_ms = rtw_get_remaining_time_ms(mpath->exp_time);
dto_ms = rtw_systime_to_ms(mpath->discovery_timeout);
drty = mpath->discovery_retries;
flags = mpath->flags;
}
rtw_rcu_read_unlock();
if (mpath) {
RTW_PRINT_SEL(sel, MAC_FMT" "MAC_FMT" %10u %10u %4u %6u %6u %4u%s%s%s%s%s%s%s%s%s%s\n"
, MAC_ARG(dst), MAC_ARG(next_hop), sn, metric, qlen
, exp_ms < 999999 ? exp_ms : 999999
, dto_ms < 999999 ? dto_ms : 999999
, drty
, (flags & RTW_MESH_PATH_ACTIVE) ? " ACT" : ""
, (flags & RTW_MESH_PATH_RESOLVING) ? " RSVING" : ""
, (flags & RTW_MESH_PATH_SN_VALID) ? " SN_VALID" : ""
, (flags & RTW_MESH_PATH_FIXED) ? " FIXED" : ""
, (flags & RTW_MESH_PATH_RESOLVED) ? " RSVED" : ""
, (flags & RTW_MESH_PATH_REQ_QUEUED) ? " REQ_IN_Q" : ""
, (flags & RTW_MESH_PATH_DELETED) ? " DELETED" : ""
, (flags & RTW_MESH_PATH_ROOT_ADD_CHK) ? " R_ADD_CHK" : ""
, (flags & RTW_MESH_PATH_PEER_AKA) ? " PEER_AKA" : ""
, (flags & RTW_MESH_PATH_BCAST_PREQ) ? " BC_PREQ" : ""
);
}
idx++;
} while (mpath);
}
/**
* rtw_mpp_path_lookup_by_idx - look up a path in the proxy path table by its index
* @idx: index
* @sdata: local subif, or NULL for all entries
*
* Returns: pointer to the proxy path structure, or NULL if not found.
*
* Locking: must be called within a read rcu section.
*/
struct rtw_mesh_path *
rtw_mpp_path_lookup_by_idx(_adapter *adapter, int idx)
{
return __rtw_mesh_path_lookup_by_idx(adapter->mesh_info.mpp_paths, idx);
}
/**
* rtw_mesh_path_add_gate - add the given mpath to a mesh gate to our path table
* @mpath: gate path to add to table
*/
int rtw_mesh_path_add_gate(struct rtw_mesh_path *mpath)
{
struct rtw_mesh_cfg *mcfg;
struct rtw_mesh_info *minfo;
struct rtw_mesh_table *tbl;
int err, ori_num_gates;
rtw_rcu_read_lock();
tbl = mpath->adapter->mesh_info.mesh_paths;
if (!tbl) {
err = -ENOENT;
goto err_rcu;
}
_rtw_spinlock_bh(&mpath->state_lock);
mcfg = &mpath->adapter->mesh_cfg;
mpath->gate_timeout = rtw_get_current_time() +
rtw_ms_to_systime(mcfg->path_gate_timeout_factor *
mpath->gate_ann_int);
if (mpath->is_gate) {
err = -EEXIST;
_rtw_spinunlock_bh(&mpath->state_lock);
goto err_rcu;
}
minfo = &mpath->adapter->mesh_info;
mpath->is_gate = true;
_rtw_spinlock(&tbl->gates_lock);
ori_num_gates = minfo->num_gates;
minfo->num_gates++;
rtw_hlist_add_head_rcu(&mpath->gate_list, &tbl->known_gates);
if (ori_num_gates == 0
|| rtw_macaddr_is_larger(mpath->dst, minfo->max_addr_gate->dst)
) {
minfo->max_addr_gate = mpath;
minfo->max_addr_gate_is_larger_than_self =
rtw_macaddr_is_larger(mpath->dst, adapter_mac_addr(mpath->adapter));
}
_rtw_spinunlock(&tbl->gates_lock);
_rtw_spinunlock_bh(&mpath->state_lock);
if (ori_num_gates == 0) {
rtw_update_beacon(mpath->adapter, WLAN_EID_MESH_CONFIG, NULL, _TRUE, 0);
#if CONFIG_RTW_MESH_CTO_MGATE_CARRIER
if (!rtw_mesh_cto_mgate_required(mpath->adapter))
rtw_netif_carrier_on(mpath->adapter->pnetdev);
#endif
}
RTW_MPATH_DBG(
FUNC_ADPT_FMT" Mesh path: Recorded new gate: %pM. %d known gates\n",
FUNC_ADPT_ARG(mpath->adapter),
mpath->dst, mpath->adapter->mesh_info.num_gates);
err = 0;
err_rcu:
rtw_rcu_read_unlock();
return err;
}
/**
* rtw_mesh_gate_del - remove a mesh gate from the list of known gates
* @tbl: table which holds our list of known gates
* @mpath: gate mpath
*/
void rtw_mesh_gate_del(struct rtw_mesh_table *tbl, struct rtw_mesh_path *mpath)
{
struct rtw_mesh_cfg *mcfg;
struct rtw_mesh_info *minfo;
int ori_num_gates;
rtw_lockdep_assert_held(&mpath->state_lock);
if (!mpath->is_gate)
return;
mcfg = &mpath->adapter->mesh_cfg;
minfo = &mpath->adapter->mesh_info;
mpath->is_gate = false;
_rtw_spinlock_bh(&tbl->gates_lock);
rtw_hlist_del_rcu(&mpath->gate_list);
ori_num_gates = minfo->num_gates;
minfo->num_gates--;
if (ori_num_gates == 1) {
minfo->max_addr_gate = NULL;
minfo->max_addr_gate_is_larger_than_self = 0;
} else if (minfo->max_addr_gate == mpath) {
struct rtw_mesh_path *gate, *max_addr_gate = NULL;
rtw_hlist_node *node;
rtw_hlist_for_each_entry_rcu(gate, node, &tbl->known_gates, gate_list) {
if (!max_addr_gate || rtw_macaddr_is_larger(gate->dst, max_addr_gate->dst))
max_addr_gate = gate;
}
minfo->max_addr_gate = max_addr_gate;
minfo->max_addr_gate_is_larger_than_self =
rtw_macaddr_is_larger(max_addr_gate->dst, adapter_mac_addr(mpath->adapter));
}
_rtw_spinunlock_bh(&tbl->gates_lock);
if (ori_num_gates == 1) {
rtw_update_beacon(mpath->adapter, WLAN_EID_MESH_CONFIG, NULL, _TRUE, 0);
#if CONFIG_RTW_MESH_CTO_MGATE_CARRIER
if (rtw_mesh_cto_mgate_required(mpath->adapter))
rtw_netif_carrier_off(mpath->adapter->pnetdev);
#endif
}
RTW_MPATH_DBG(
FUNC_ADPT_FMT" Mesh path: Deleted gate: %pM. %d known gates\n",
FUNC_ADPT_ARG(mpath->adapter),
mpath->dst, mpath->adapter->mesh_info.num_gates);
}
/**
* rtw_mesh_gate_search - search a mesh gate from the list of known gates
* @tbl: table which holds our list of known gates
* @addr: address of gate
*/
bool rtw_mesh_gate_search(struct rtw_mesh_table *tbl, const u8 *addr)
{
struct rtw_mesh_path *gate;
rtw_hlist_node *node;
bool exist = 0;
rtw_rcu_read_lock();
rtw_hlist_for_each_entry_rcu(gate, node, &tbl->known_gates, gate_list) {
if (_rtw_memcmp(gate->dst, addr, ETH_ALEN) == _TRUE) {
exist = 1;
break;
}
}
rtw_rcu_read_unlock();
return exist;
}
/**
* rtw_mesh_gate_num - number of gates known to this interface
* @sdata: subif data
*/
int rtw_mesh_gate_num(_adapter *adapter)
{
return adapter->mesh_info.num_gates;
}
bool rtw_mesh_is_primary_gate(_adapter *adapter)
{
struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
return mcfg->dot11MeshGateAnnouncementProtocol
&& !minfo->max_addr_gate_is_larger_than_self;
}
void dump_known_gates(void *sel, _adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_table *tbl;
struct rtw_mesh_path *gate;
rtw_hlist_node *node;
if (!rtw_mesh_gate_num(adapter))
goto exit;
rtw_rcu_read_lock();
tbl = minfo->mesh_paths;
if (!tbl)
goto unlock;
RTW_PRINT_SEL(sel, "num:%d\n", rtw_mesh_gate_num(adapter));
rtw_hlist_for_each_entry_rcu(gate, node, &tbl->known_gates, gate_list) {
RTW_PRINT_SEL(sel, "%c"MAC_FMT"\n"
, gate == minfo->max_addr_gate ? '*' : ' '
, MAC_ARG(gate->dst));
}
unlock:
rtw_rcu_read_unlock();
exit:
return;
}
static
struct rtw_mesh_path *rtw_mesh_path_new(_adapter *adapter,
const u8 *dst)
{
struct rtw_mesh_path *new_mpath;
new_mpath = rtw_zmalloc(sizeof(struct rtw_mesh_path));
if (!new_mpath)
return NULL;
_rtw_memcpy(new_mpath->dst, dst, ETH_ALEN);
_rtw_memset(new_mpath->rann_snd_addr, 0xFF, ETH_ALEN);
new_mpath->is_root = false;
new_mpath->adapter = adapter;
new_mpath->flags = 0;
new_mpath->gate_asked = false;
_rtw_init_queue(&new_mpath->frame_queue);
new_mpath->frame_queue_len = 0;
new_mpath->exp_time = rtw_get_current_time();
_rtw_spinlock_init(&new_mpath->state_lock);
rtw_init_timer(&new_mpath->timer, rtw_mesh_path_timer, new_mpath);
return new_mpath;
}
/**
* rtw_mesh_path_add - allocate and add a new path to the mesh path table
* @dst: destination address of the path (ETH_ALEN length)
* @sdata: local subif
*
* Returns: 0 on success
*
* State: the initial state of the new path is set to 0
*/
struct rtw_mesh_path *rtw_mesh_path_add(_adapter *adapter,
const u8 *dst)
{
struct rtw_mesh_table *tbl = adapter->mesh_info.mesh_paths;
struct rtw_mesh_path *mpath, *new_mpath;
int ret;
if (!tbl)
return ERR_PTR(-ENOTSUPP);
if (_rtw_memcmp(dst, adapter_mac_addr(adapter), ETH_ALEN) == _TRUE)
/* never add ourselves as neighbours */
return ERR_PTR(-ENOTSUPP);
if (is_multicast_mac_addr(dst))
return ERR_PTR(-ENOTSUPP);
if (ATOMIC_INC_UNLESS(&adapter->mesh_info.mpaths, RTW_MESH_MAX_MPATHS) == 0)
return ERR_PTR(-ENOSPC);
new_mpath = rtw_mesh_path_new(adapter, dst);
if (!new_mpath)
return ERR_PTR(-ENOMEM);
do {
ret = rtw_rhashtable_lookup_insert_fast(&tbl->rhead,
&new_mpath->rhash,
rtw_mesh_rht_params);
if (ret == -EEXIST)
mpath = rtw_rhashtable_lookup_fast(&tbl->rhead,
dst,
rtw_mesh_rht_params);
} while (unlikely(ret == -EEXIST && !mpath));
if (ret && ret != -EEXIST)
return ERR_PTR(ret);
/* At this point either new_mpath was added, or we found a
* matching entry already in the table; in the latter case
* free the unnecessary new entry.
*/
if (ret == -EEXIST) {
rtw_mfree(new_mpath, sizeof(struct rtw_mesh_path));
new_mpath = mpath;
}
adapter->mesh_info.mesh_paths_generation++;
return new_mpath;
}
int rtw_mpp_path_add(_adapter *adapter,
const u8 *dst, const u8 *mpp)
{
struct rtw_mesh_table *tbl = adapter->mesh_info.mpp_paths;
struct rtw_mesh_path *new_mpath;
int ret;
if (!tbl)
return -ENOTSUPP;
if (_rtw_memcmp(dst, adapter_mac_addr(adapter), ETH_ALEN) == _TRUE)
/* never add ourselves as neighbours */
return -ENOTSUPP;
if (is_multicast_mac_addr(dst))
return -ENOTSUPP;
new_mpath = rtw_mesh_path_new(adapter, dst);
if (!new_mpath)
return -ENOMEM;
_rtw_memcpy(new_mpath->mpp, mpp, ETH_ALEN);
ret = rtw_rhashtable_lookup_insert_fast(&tbl->rhead,
&new_mpath->rhash,
rtw_mesh_rht_params);
adapter->mesh_info.mpp_paths_generation++;
return ret;
}
void dump_mpp(void *sel, _adapter *adapter)
{
struct rtw_mesh_path *mpath;
int idx = 0;
char dst[ETH_ALEN];
char mpp[ETH_ALEN];
RTW_PRINT_SEL(sel, "%-17s %-17s\n", "dst", "mpp");
do {
rtw_rcu_read_lock();
mpath = rtw_mpp_path_lookup_by_idx(adapter, idx);
if (mpath) {
_rtw_memcpy(dst, mpath->dst, ETH_ALEN);
_rtw_memcpy(mpp, mpath->mpp, ETH_ALEN);
}
rtw_rcu_read_unlock();
if (mpath) {
RTW_PRINT_SEL(sel, MAC_FMT" "MAC_FMT"\n"
, MAC_ARG(dst), MAC_ARG(mpp));
}
idx++;
} while (mpath);
}
/**
* rtw_mesh_plink_broken - deactivates paths and sends perr when a link breaks
*
* @sta: broken peer link
*
* This function must be called from the rate control algorithm if enough
* delivery errors suggest that a peer link is no longer usable.
*/
void rtw_mesh_plink_broken(struct sta_info *sta)
{
_adapter *adapter = sta->padapter;
struct rtw_mesh_table *tbl = adapter->mesh_info.mesh_paths;
static const u8 bcast[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
struct rtw_mesh_path *mpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((mpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
continue;
if (IS_ERR(mpath))
break;
if (rtw_rcu_access_pointer(mpath->next_hop) == sta &&
mpath->flags & RTW_MESH_PATH_ACTIVE &&
!(mpath->flags & RTW_MESH_PATH_FIXED)) {
_rtw_spinlock_bh(&mpath->state_lock);
mpath->flags &= ~RTW_MESH_PATH_ACTIVE;
++mpath->sn;
_rtw_spinunlock_bh(&mpath->state_lock);
rtw_mesh_path_error_tx(adapter,
adapter->mesh_cfg.element_ttl,
mpath->dst, mpath->sn,
WLAN_REASON_MESH_PATH_DEST_UNREACHABLE, bcast);
}
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
static void rtw_mesh_path_free_rcu(struct rtw_mesh_table *tbl,
struct rtw_mesh_path *mpath)
{
_adapter *adapter = mpath->adapter;
_rtw_spinlock_bh(&mpath->state_lock);
mpath->flags |= RTW_MESH_PATH_RESOLVING | RTW_MESH_PATH_DELETED;
rtw_mesh_gate_del(tbl, mpath);
_rtw_spinunlock_bh(&mpath->state_lock);
_cancel_timer_ex(&mpath->timer);
ATOMIC_DEC(&adapter->mesh_info.mpaths);
ATOMIC_DEC(&tbl->entries);
_rtw_spinlock_free(&mpath->state_lock);
rtw_mesh_path_flush_pending(mpath);
rtw_mpath_free_rcu(mpath);
}
static void __rtw_mesh_path_del(struct rtw_mesh_table *tbl, struct rtw_mesh_path *mpath)
{
rtw_rhashtable_remove_fast(&tbl->rhead, &mpath->rhash, rtw_mesh_rht_params);
rtw_mesh_path_free_rcu(tbl, mpath);
}
/**
* rtw_mesh_path_flush_by_nexthop - Deletes mesh paths if their next hop matches
*
* @sta: mesh peer to match
*
* RCU notes: this function is called when a mesh plink transitions from
* PLINK_ESTAB to any other state, since PLINK_ESTAB state is the only one that
* allows path creation. This will happen before the sta can be freed (because
* sta_info_destroy() calls this) so any reader in a rcu read block will be
* protected against the plink disappearing.
*/
void rtw_mesh_path_flush_by_nexthop(struct sta_info *sta)
{
_adapter *adapter = sta->padapter;
struct rtw_mesh_table *tbl = adapter->mesh_info.mesh_paths;
struct rtw_mesh_path *mpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((mpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
continue;
if (IS_ERR(mpath))
break;
if (rtw_rcu_access_pointer(mpath->next_hop) == sta)
__rtw_mesh_path_del(tbl, mpath);
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
static void rtw_mpp_flush_by_proxy(_adapter *adapter,
const u8 *proxy)
{
struct rtw_mesh_table *tbl = adapter->mesh_info.mpp_paths;
struct rtw_mesh_path *mpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((mpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
continue;
if (IS_ERR(mpath))
break;
if (_rtw_memcmp(mpath->mpp, proxy, ETH_ALEN) == _TRUE)
__rtw_mesh_path_del(tbl, mpath);
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
static void rtw_table_flush_by_iface(struct rtw_mesh_table *tbl)
{
struct rtw_mesh_path *mpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((mpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
continue;
if (IS_ERR(mpath))
break;
__rtw_mesh_path_del(tbl, mpath);
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
/**
* rtw_mesh_path_flush_by_iface - Deletes all mesh paths associated with a given iface
*
* This function deletes both mesh paths as well as mesh portal paths.
*
* @sdata: interface data to match
*
*/
void rtw_mesh_path_flush_by_iface(_adapter *adapter)
{
rtw_table_flush_by_iface(adapter->mesh_info.mesh_paths);
rtw_table_flush_by_iface(adapter->mesh_info.mpp_paths);
}
/**
* rtw_table_path_del - delete a path from the mesh or mpp table
*
* @tbl: mesh or mpp path table
* @sdata: local subif
* @addr: dst address (ETH_ALEN length)
*
* Returns: 0 if successful
*/
static int rtw_table_path_del(struct rtw_mesh_table *tbl,
const u8 *addr)
{
struct rtw_mesh_path *mpath;
if (!tbl)
return -ENXIO;
rtw_rcu_read_lock();
mpath = rtw_rhashtable_lookup_fast(&tbl->rhead, addr, rtw_mesh_rht_params);
if (!mpath) {
rtw_rcu_read_unlock();
return -ENXIO;
}
__rtw_mesh_path_del(tbl, mpath);
rtw_rcu_read_unlock();
return 0;
}
/**
* rtw_mesh_path_del - delete a mesh path from the table
*
* @addr: dst address (ETH_ALEN length)
* @sdata: local subif
*
* Returns: 0 if successful
*/
int rtw_mesh_path_del(_adapter *adapter, const u8 *addr)
{
int err;
/* flush relevant mpp entries first */
rtw_mpp_flush_by_proxy(adapter, addr);
err = rtw_table_path_del(adapter->mesh_info.mesh_paths, addr);
adapter->mesh_info.mesh_paths_generation++;
return err;
}
/**
* rtw_mesh_path_tx_pending - sends pending frames in a mesh path queue
*
* @mpath: mesh path to activate
*
* Locking: the state_lock of the mpath structure must NOT be held when calling
* this function.
*/
void rtw_mesh_path_tx_pending(struct rtw_mesh_path *mpath)
{
if (mpath->flags & RTW_MESH_PATH_ACTIVE) {
struct rtw_mesh_info *minfo = &mpath->adapter->mesh_info;
_list q;
u32 q_len = 0;
_rtw_init_listhead(&q);
/* move to local queue */
_rtw_spinlock_bh(&mpath->frame_queue.lock);
if (mpath->frame_queue_len) {
rtw_list_splice_init(&mpath->frame_queue.queue, &q);
q_len = mpath->frame_queue_len;
mpath->frame_queue_len = 0;
}
_rtw_spinunlock_bh(&mpath->frame_queue.lock);
if (q_len) {
/* move to mpath_tx_queue */
_rtw_spinlock_bh(&minfo->mpath_tx_queue.lock);
rtw_list_splice_tail(&q, &minfo->mpath_tx_queue.queue);
minfo->mpath_tx_queue_len += q_len;
_rtw_spinunlock_bh(&minfo->mpath_tx_queue.lock);
/* schedule mpath_tx_tasklet */
tasklet_hi_schedule(&minfo->mpath_tx_tasklet);
}
}
}
/**
* rtw_mesh_path_send_to_gates - sends pending frames to all known mesh gates
*
* @mpath: mesh path whose queue will be emptied
*
* If there is only one gate, the frames are transferred from the failed mpath
* queue to that gate's queue. If there are more than one gates, the frames
* are copied from each gate to the next. After frames are copied, the
* mpath queues are emptied onto the transmission queue.
*/
int rtw_mesh_path_send_to_gates(struct rtw_mesh_path *mpath)
{
_adapter *adapter = mpath->adapter;
struct rtw_mesh_table *tbl;
struct rtw_mesh_path *from_mpath = mpath;
struct rtw_mesh_path *gate;
bool copy = false;
rtw_hlist_node *node;
tbl = adapter->mesh_info.mesh_paths;
if (!tbl)
return 0;
rtw_rcu_read_lock();
rtw_hlist_for_each_entry_rcu(gate, node, &tbl->known_gates, gate_list) {
if (gate->flags & RTW_MESH_PATH_ACTIVE) {
RTW_MPATH_DBG(FUNC_ADPT_FMT" Forwarding to %pM\n",
FUNC_ADPT_ARG(adapter), gate->dst);
rtw_mesh_path_move_to_queue(gate, from_mpath, copy);
from_mpath = gate;
copy = true;
} else {
RTW_MPATH_DBG(
FUNC_ADPT_FMT" Not forwarding to %pM (flags %#x)\n",
FUNC_ADPT_ARG(adapter), gate->dst, gate->flags);
}
}
rtw_hlist_for_each_entry_rcu(gate, node, &tbl->known_gates, gate_list) {
RTW_MPATH_DBG(FUNC_ADPT_FMT" Sending to %pM\n",
FUNC_ADPT_ARG(adapter), gate->dst);
rtw_mesh_path_tx_pending(gate);
}
rtw_rcu_read_unlock();
return (from_mpath == mpath) ? -EHOSTUNREACH : 0;
}
/**
* rtw_mesh_path_discard_frame - discard a frame whose path could not be resolved
*
* @skb: frame to discard
* @sdata: network subif the frame was to be sent through
*
* Locking: the function must me called within a rcu_read_lock region
*/
void rtw_mesh_path_discard_frame(_adapter *adapter,
struct xmit_frame *xframe)
{
rtw_free_xmitframe(&adapter->xmitpriv, xframe);
adapter->mesh_info.mshstats.dropped_frames_no_route++;
}
/**
* rtw_mesh_path_flush_pending - free the pending queue of a mesh path
*
* @mpath: mesh path whose queue has to be freed
*
* Locking: the function must me called within a rcu_read_lock region
*/
void rtw_mesh_path_flush_pending(struct rtw_mesh_path *mpath)
{
struct xmit_frame *xframe;
_list *list, *head;
_list tmp;
_rtw_init_listhead(&tmp);
_rtw_spinlock_bh(&mpath->frame_queue.lock);
rtw_list_splice_init(&mpath->frame_queue.queue, &tmp);
mpath->frame_queue_len = 0;
_rtw_spinunlock_bh(&mpath->frame_queue.lock);
head = &tmp;
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
xframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&xframe->list);
rtw_mesh_path_discard_frame(mpath->adapter, xframe);
}
}
/**
* rtw_mesh_path_fix_nexthop - force a specific next hop for a mesh path
*
* @mpath: the mesh path to modify
* @next_hop: the next hop to force
*
* Locking: this function must be called holding mpath->state_lock
*/
void rtw_mesh_path_fix_nexthop(struct rtw_mesh_path *mpath, struct sta_info *next_hop)
{
_rtw_spinlock_bh(&mpath->state_lock);
rtw_mesh_path_assign_nexthop(mpath, next_hop);
mpath->sn = 0xffff;
mpath->metric = 0;
mpath->hop_count = 0;
mpath->exp_time = 0;
mpath->flags = RTW_MESH_PATH_FIXED | RTW_MESH_PATH_SN_VALID;
rtw_mesh_path_activate(mpath);
_rtw_spinunlock_bh(&mpath->state_lock);
rtw_ewma_err_rate_init(&next_hop->metrics.err_rate);
/* init it at a low value - 0 start is tricky */
rtw_ewma_err_rate_add(&next_hop->metrics.err_rate, 1);
rtw_mesh_path_tx_pending(mpath);
}
int rtw_mesh_pathtbl_init(_adapter *adapter)
{
struct rtw_mesh_table *tbl_path, *tbl_mpp;
int ret;
tbl_path = rtw_mesh_table_alloc();
if (!tbl_path)
return -ENOMEM;
tbl_mpp = rtw_mesh_table_alloc();
if (!tbl_mpp) {
ret = -ENOMEM;
goto free_path;
}
rtw_rhashtable_init(&tbl_path->rhead, &rtw_mesh_rht_params);
rtw_rhashtable_init(&tbl_mpp->rhead, &rtw_mesh_rht_params);
adapter->mesh_info.mesh_paths = tbl_path;
adapter->mesh_info.mpp_paths = tbl_mpp;
return 0;
free_path:
rtw_mesh_table_free(tbl_path);
return ret;
}
static
void rtw_mesh_path_tbl_expire(_adapter *adapter,
struct rtw_mesh_table *tbl)
{
struct rtw_mesh_path *mpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((mpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(mpath) && PTR_ERR(mpath) == -EAGAIN)
continue;
if (IS_ERR(mpath))
break;
if ((!(mpath->flags & RTW_MESH_PATH_RESOLVING)) &&
(!(mpath->flags & RTW_MESH_PATH_FIXED)) &&
rtw_time_after(rtw_get_current_time(), mpath->exp_time + RTW_MESH_PATH_EXPIRE))
__rtw_mesh_path_del(tbl, mpath);
if (mpath->is_gate && /* need not to deal with non-gate case */
rtw_time_after(rtw_get_current_time(), mpath->gate_timeout)) {
RTW_MPATH_DBG(FUNC_ADPT_FMT"mpath [%pM] expired systime is %lu systime is %lu\n",
FUNC_ADPT_ARG(adapter), mpath->dst,
mpath->gate_timeout, rtw_get_current_time());
_rtw_spinlock_bh(&mpath->state_lock);
if (mpath->gate_asked) { /* asked gate before */
rtw_mesh_gate_del(tbl, mpath);
_rtw_spinunlock_bh(&mpath->state_lock);
} else {
mpath->gate_asked = true;
mpath->gate_timeout = rtw_get_current_time() + rtw_ms_to_systime(mpath->gate_ann_int);
_rtw_spinunlock_bh(&mpath->state_lock);
rtw_mesh_queue_preq(mpath, RTW_PREQ_Q_F_START | RTW_PREQ_Q_F_REFRESH);
RTW_MPATH_DBG(FUNC_ADPT_FMT"mpath [%pM] ask mesh gate existence (is_root=%d)\n",
FUNC_ADPT_ARG(adapter), mpath->dst, mpath->is_root);
}
}
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
void rtw_mesh_path_expire(_adapter *adapter)
{
rtw_mesh_path_tbl_expire(adapter, adapter->mesh_info.mesh_paths);
rtw_mesh_path_tbl_expire(adapter, adapter->mesh_info.mpp_paths);
}
void rtw_mesh_pathtbl_unregister(_adapter *adapter)
{
if (adapter->mesh_info.mesh_paths) {
rtw_mesh_table_free(adapter->mesh_info.mesh_paths);
adapter->mesh_info.mesh_paths = NULL;
}
if (adapter->mesh_info.mpp_paths) {
rtw_mesh_table_free(adapter->mesh_info.mpp_paths);
adapter->mesh_info.mpp_paths = NULL;
}
}
#endif /* CONFIG_RTW_MESH */
|
2301_81045437/rtl8852be
|
core/mesh/rtw_mesh_pathtbl.c
|
C
|
agpl-3.0
| 33,187
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __RTW_MESH_PATHTBL_H_
#define __RTW_MESH_PATHTBL_H_
#ifndef DBG_RTW_MPATH
#define DBG_RTW_MPATH 1
#endif
#if DBG_RTW_MPATH
#define RTW_MPATH_DBG(fmt, arg...) RTW_PRINT(fmt, ##arg)
#else
#define RTW_MPATH_DBG(fmt, arg...) do {} while (0)
#endif
/**
* enum rtw_mesh_path_flags - mesh path flags
*
* @RTW_MESH_PATH_ACTIVE: the mesh path can be used for forwarding
* @RTW_MESH_PATH_RESOLVING: the discovery process is running for this mesh path
* @RTW_MESH_PATH_SN_VALID: the mesh path contains a valid destination sequence
* number
* @RTW_MESH_PATH_FIXED: the mesh path has been manually set and should not be
* modified
* @RTW_MESH_PATH_RESOLVED: the mesh path can has been resolved
* @RTW_MESH_PATH_REQ_QUEUED: there is an unsent path request for this destination
* already queued up, waiting for the discovery process to start.
* @RTW_MESH_PATH_DELETED: the mesh path has been deleted and should no longer
* be used
* @RTW_MESH_PATH_ROOT_ADD_CHK: root additional check in root mode.
* With this flag, It will try the last used rann_snd_addr
* @RTW_MESH_PATH_PEER_AKA: only used toward a peer, only used in active keep
* alive mechanism. PREQ's da = path dst
* @RTW_MESH_PATH_BCAST_PREQ: for re-checking next hop resolve toward root.
* Use it to force path_discover sending broadcast PREQ for root.
*
* RTW_MESH_PATH_RESOLVED is used by the mesh path timer to
* decide when to stop or cancel the mesh path discovery.
*/
enum rtw_mesh_path_flags {
RTW_MESH_PATH_ACTIVE = BIT(0),
RTW_MESH_PATH_RESOLVING = BIT(1),
RTW_MESH_PATH_SN_VALID = BIT(2),
RTW_MESH_PATH_FIXED = BIT(3),
RTW_MESH_PATH_RESOLVED = BIT(4),
RTW_MESH_PATH_REQ_QUEUED = BIT(5),
RTW_MESH_PATH_DELETED = BIT(6),
RTW_MESH_PATH_ROOT_ADD_CHK = BIT(7),
RTW_MESH_PATH_PEER_AKA = BIT(8),
RTW_MESH_PATH_BCAST_PREQ = BIT(9),
};
/**
* struct rtw_mesh_path - mesh path structure
*
* @dst: mesh path destination mac address
* @mpp: mesh proxy mac address
* @rhash: rhashtable list pointer
* @gate_list: list pointer for known gates list
* @sdata: mesh subif
* @next_hop: mesh neighbor to which frames for this destination will be
* forwarded
* @timer: mesh path discovery timer
* @frame_queue: pending queue for frames sent to this destination while the
* path is unresolved
* @rcu: rcu head for freeing mesh path
* @sn: target sequence number
* @metric: current metric to this destination
* @hop_count: hops to destination
* @exp_time: in jiffies, when the path will expire or when it expired
* @discovery_timeout: timeout (lapse in jiffies) used for the last discovery
* retry
* @discovery_retries: number of discovery retries
* @flags: mesh path flags, as specified on &enum rtw_mesh_path_flags
* @state_lock: mesh path state lock used to protect changes to the
* mpath itself. No need to take this lock when adding or removing
* an mpath to a hash bucket on a path table.
* @rann_snd_addr: the RANN sender address
* @rann_metric: the aggregated path metric towards the root node
* @last_preq_to_root: Timestamp of last PREQ sent to root
* @is_root: the destination station of this path is a root node
* @is_gate: the destination station of this path is a mesh gate
*
*
* The dst address is unique in the mesh path table. Since the mesh_path is
* protected by RCU, deleting the next_hop STA must remove / substitute the
* mesh_path structure and wait until that is no longer reachable before
* destroying the STA completely.
*/
struct rtw_mesh_path {
u8 dst[ETH_ALEN];
u8 mpp[ETH_ALEN]; /* used for MPP or MAP */
rtw_rhash_head rhash;
rtw_hlist_node gate_list;
_adapter *adapter;
struct sta_info __rcu *next_hop;
_timer timer;
_queue frame_queue;
u32 frame_queue_len;
rtw_rcu_head rcu;
u32 sn;
u32 metric;
u8 hop_count;
systime exp_time;
systime discovery_timeout;
systime gate_timeout;
u32 gate_ann_int; /* gate announce interval */
u8 discovery_retries;
enum rtw_mesh_path_flags flags;
_lock state_lock;
u8 rann_snd_addr[ETH_ALEN];
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
u8 add_chk_rann_snd_addr[ETH_ALEN];
#endif
u32 rann_metric;
unsigned long last_preq_to_root;
bool is_root;
bool is_gate;
bool gate_asked;
};
/**
* struct rtw_mesh_table
*
* @known_gates: list of known mesh gates and their mpaths by the station. The
* gate's mpath may or may not be resolved and active.
* @gates_lock: protects updates to known_gates
* @rhead: the rhashtable containing struct mesh_paths, keyed by dest addr
* @entries: number of entries in the table
*/
struct rtw_mesh_table {
rtw_hlist_head known_gates;
_lock gates_lock;
rtw_rhashtable rhead;
ATOMIC_T entries;
};
#define RTW_MESH_PATH_EXPIRE (600 * HZ)
/* Maximum number of paths per interface */
#define RTW_MESH_MAX_MPATHS 1024
/* Number of frames buffered per destination for unresolved destinations */
#define RTW_MESH_FRAME_QUEUE_LEN 10
int rtw_mesh_nexthop_lookup(_adapter *adapter,
const u8 *mda, const u8 *msa, u8 *ra);
int rtw_mesh_nexthop_resolve(_adapter *adapter,
struct xmit_frame *xframe);
struct rtw_mesh_path *rtw_mesh_path_lookup(_adapter *adapter,
const u8 *dst);
struct rtw_mesh_path *rtw_mpp_path_lookup(_adapter *adapter,
const u8 *dst);
int rtw_mpp_path_add(_adapter *adapter,
const u8 *dst, const u8 *mpp);
void dump_mpp(void *sel, _adapter *adapter);
struct rtw_mesh_path *
rtw_mesh_path_lookup_by_idx(_adapter *adapter, int idx);
void dump_mpath(void *sel, _adapter *adapter);
struct rtw_mesh_path *
rtw_mpp_path_lookup_by_idx(_adapter *adapter, int idx);
void rtw_mesh_path_fix_nexthop(struct rtw_mesh_path *mpath, struct sta_info *next_hop);
void rtw_mesh_path_expire(_adapter *adapter);
struct rtw_mesh_path *
rtw_mesh_path_add(_adapter *adapter, const u8 *dst);
int rtw_mesh_path_add_gate(struct rtw_mesh_path *mpath);
void rtw_mesh_gate_del(struct rtw_mesh_table *tbl, struct rtw_mesh_path *mpath);
bool rtw_mesh_gate_search(struct rtw_mesh_table *tbl, const u8 *addr);
int rtw_mesh_path_send_to_gates(struct rtw_mesh_path *mpath);
int rtw_mesh_gate_num(_adapter *adapter);
bool rtw_mesh_is_primary_gate(_adapter *adapter);
void dump_known_gates(void *sel, _adapter *adapter);
void rtw_mesh_plink_broken(struct sta_info *sta);
void rtw_mesh_path_assign_nexthop(struct rtw_mesh_path *mpath, struct sta_info *sta);
void rtw_mesh_path_flush_pending(struct rtw_mesh_path *mpath);
void rtw_mesh_path_tx_pending(struct rtw_mesh_path *mpath);
int rtw_mesh_pathtbl_init(_adapter *adapter);
void rtw_mesh_pathtbl_unregister(_adapter *adapter);
int rtw_mesh_path_del(_adapter *adapter, const u8 *addr);
void rtw_mesh_path_flush_by_nexthop(struct sta_info *sta);
void rtw_mesh_path_discard_frame(_adapter *adapter,
struct xmit_frame *xframe);
static inline void rtw_mesh_path_activate(struct rtw_mesh_path *mpath)
{
mpath->flags |= RTW_MESH_PATH_ACTIVE | RTW_MESH_PATH_RESOLVED;
}
void rtw_mesh_path_flush_by_iface(_adapter *adapter);
#endif /* __RTW_MESH_PATHTBL_H_ */
|
2301_81045437/rtl8852be
|
core/mesh/rtw_mesh_pathtbl.h
|
C
|
agpl-3.0
| 7,614
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_RADIOTAP_C_
#ifdef CONFIG_WIFI_MONITOR
#include <drv_types.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0))
#include <linux/bitfield.h>
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0))
#define __bf_shf(x) (__builtin_ffsll(x) - 1)
/**
* FIELD_PREP() - prepare a bitfield element
* @_mask: shifted mask defining the field's length and position
* @_val: value to put in the field
*
* FIELD_PREP() masks and shifts up the value. The result should
* be combined with other fields of the bitfield using logical OR.
*/
#define FIELD_PREP(_mask, _val) \
({ \
((typeof(_mask))(_val) << __bf_shf(_mask)) & (_mask); \
})
#endif
#define __encode_bits(w, v, field) FIELD_PREP((u##w)(field), v)
#define __u16_encode_bits(v, field) __encode_bits(16, v, field)
#define __le16_encode_bits(v, field) cpu_to_le16(__encode_bits(16, v, field))
#define __be16_encode_bits(v, field) cpu_to_be16(__encode_bits(16, v, field))
#define __u32_encode_bits(v, field) __encode_bits(32, v, field)
#define __le32_encode_bits(v, field) cpu_to_le32(__encode_bits(32, v, field))
#define __be32_encode_bits(v, field) cpu_to_be32(__encode_bits(32, v, field))
#define __u64_encode_bits(v, field) __encode_bits(64, v, field)
#define __le64_encode_bits(v, field) cpu_to_le64(__encode_bits(64, v, field))
#define __be64_encode_bits(v, field) cpu_to_be64(__encode_bits(64, v, field))
#define CHAN2FREQ(a) ((a < 14) ? (2407+5*a) : (5000+5*a))
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 20, 0))
#define IEEE80211_RADIOTAP_ZERO_LEN_PSDU 26
#define IEEE80211_RADIOTAP_LSIG 27
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0))
#define IEEE80211_RADIOTAP_TIMESTAMP 22
/* For IEEE80211_RADIOTAP_TIMESTAMP */
#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_MASK 0x000F
#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_MS 0x0000
#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US 0x0001
#define IEEE80211_RADIOTAP_TIMESTAMP_UNIT_NS 0x0003
#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_MASK 0x00F0
#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_BEGIN_MDPU 0x0000
#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_EO_MPDU 0x0010
#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_EO_PPDU 0x0020
#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_PLCP_SIG_ACQ 0x0030
#define IEEE80211_RADIOTAP_TIMESTAMP_SPOS_UNKNOWN 0x00F0
#define IEEE80211_RADIOTAP_TIMESTAMP_FLAG_64BIT 0x00
#define IEEE80211_RADIOTAP_TIMESTAMP_FLAG_32BIT 0x01
#define IEEE80211_RADIOTAP_TIMESTAMP_FLAG_ACCURACY 0x02
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0))
/* for IEEE80211_RADIOTAP_CHANNEL */
#define IEEE80211_CHAN_GSM 0x1000 /* GSM (900 MHz) */
#define IEEE80211_CHAN_STURBO 0x2000 /* Static Turbo */
#define IEEE80211_CHAN_HALF 0x4000 /* Half channel (10 MHz wide) */
#define IEEE80211_CHAN_QUARTER 0x8000 /* Quarter channel (5 MHz wide) */
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 0))
#define IEEE80211_RADIOTAP_HE 23
struct ieee80211_radiotap_he {
u16 data1, data2, data3, data4, data5, data6;
};
enum ieee80211_radiotap_he_bits {
IEEE80211_RADIOTAP_HE_DATA1_FORMAT_MASK = 3,
IEEE80211_RADIOTAP_HE_DATA1_FORMAT_SU = 0,
IEEE80211_RADIOTAP_HE_DATA1_FORMAT_EXT_SU = 1,
IEEE80211_RADIOTAP_HE_DATA1_FORMAT_MU = 2,
IEEE80211_RADIOTAP_HE_DATA1_FORMAT_TRIG = 3,
IEEE80211_RADIOTAP_HE_DATA1_BSS_COLOR_KNOWN = 0x0004,
IEEE80211_RADIOTAP_HE_DATA1_BEAM_CHANGE_KNOWN = 0x0008,
IEEE80211_RADIOTAP_HE_DATA1_UL_DL_KNOWN = 0x0010,
IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN = 0x0020,
IEEE80211_RADIOTAP_HE_DATA1_DATA_DCM_KNOWN = 0x0040,
IEEE80211_RADIOTAP_HE_DATA1_CODING_KNOWN = 0x0080,
IEEE80211_RADIOTAP_HE_DATA1_LDPC_XSYMSEG_KNOWN = 0x0100,
IEEE80211_RADIOTAP_HE_DATA1_STBC_KNOWN = 0x0200,
IEEE80211_RADIOTAP_HE_DATA1_SPTL_REUSE_KNOWN = 0x0400,
IEEE80211_RADIOTAP_HE_DATA1_SPTL_REUSE2_KNOWN = 0x0800,
IEEE80211_RADIOTAP_HE_DATA1_SPTL_REUSE3_KNOWN = 0x1000,
IEEE80211_RADIOTAP_HE_DATA1_SPTL_REUSE4_KNOWN = 0x2000,
IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN = 0x4000,
IEEE80211_RADIOTAP_HE_DATA1_DOPPLER_KNOWN = 0x8000,
IEEE80211_RADIOTAP_HE_DATA2_PRISEC_80_KNOWN = 0x0001,
IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN = 0x0002,
IEEE80211_RADIOTAP_HE_DATA2_NUM_LTF_SYMS_KNOWN = 0x0004,
IEEE80211_RADIOTAP_HE_DATA2_PRE_FEC_PAD_KNOWN = 0x0008,
IEEE80211_RADIOTAP_HE_DATA2_TXBF_KNOWN = 0x0010,
IEEE80211_RADIOTAP_HE_DATA2_PE_DISAMBIG_KNOWN = 0x0020,
IEEE80211_RADIOTAP_HE_DATA2_TXOP_KNOWN = 0x0040,
IEEE80211_RADIOTAP_HE_DATA2_MIDAMBLE_KNOWN = 0x0080,
IEEE80211_RADIOTAP_HE_DATA2_RU_OFFSET = 0x3f00,
IEEE80211_RADIOTAP_HE_DATA2_RU_OFFSET_KNOWN = 0x4000,
IEEE80211_RADIOTAP_HE_DATA2_PRISEC_80_SEC = 0x8000,
IEEE80211_RADIOTAP_HE_DATA3_BSS_COLOR = 0x003f,
IEEE80211_RADIOTAP_HE_DATA3_BEAM_CHANGE = 0x0040,
IEEE80211_RADIOTAP_HE_DATA3_UL_DL = 0x0080,
IEEE80211_RADIOTAP_HE_DATA3_DATA_MCS = 0x0f00,
IEEE80211_RADIOTAP_HE_DATA3_DATA_DCM = 0x1000,
IEEE80211_RADIOTAP_HE_DATA3_CODING = 0x2000,
IEEE80211_RADIOTAP_HE_DATA3_LDPC_XSYMSEG = 0x4000,
IEEE80211_RADIOTAP_HE_DATA3_STBC = 0x8000,
IEEE80211_RADIOTAP_HE_DATA4_SU_MU_SPTL_REUSE = 0x000f,
IEEE80211_RADIOTAP_HE_DATA4_MU_STA_ID = 0x7ff0,
IEEE80211_RADIOTAP_HE_DATA4_TB_SPTL_REUSE1 = 0x000f,
IEEE80211_RADIOTAP_HE_DATA4_TB_SPTL_REUSE2 = 0x00f0,
IEEE80211_RADIOTAP_HE_DATA4_TB_SPTL_REUSE3 = 0x0f00,
IEEE80211_RADIOTAP_HE_DATA4_TB_SPTL_REUSE4 = 0xf000,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC = 0x000f,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_20MHZ = 0,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_40MHZ = 1,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_80MHZ = 2,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_160MHZ = 3,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_26T = 4,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_52T = 5,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_106T = 6,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_242T = 7,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_484T = 8,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_996T = 9,
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_2x996T = 10,
IEEE80211_RADIOTAP_HE_DATA5_GI = 0x0030,
IEEE80211_RADIOTAP_HE_DATA5_GI_0_8 = 0,
IEEE80211_RADIOTAP_HE_DATA5_GI_1_6 = 1,
IEEE80211_RADIOTAP_HE_DATA5_GI_3_2 = 2,
IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE = 0x00c0,
IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_UNKNOWN = 0,
IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_1X = 1,
IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_2X = 2,
IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_4X = 3,
IEEE80211_RADIOTAP_HE_DATA5_NUM_LTF_SYMS = 0x0700,
IEEE80211_RADIOTAP_HE_DATA5_PRE_FEC_PAD = 0x3000,
IEEE80211_RADIOTAP_HE_DATA5_TXBF = 0x4000,
IEEE80211_RADIOTAP_HE_DATA5_PE_DISAMBIG = 0x8000,
IEEE80211_RADIOTAP_HE_DATA6_NSTS = 0x000f,
IEEE80211_RADIOTAP_HE_DATA6_DOPPLER = 0x0010,
IEEE80211_RADIOTAP_HE_DATA6_TXOP = 0x7f00,
IEEE80211_RADIOTAP_HE_DATA6_MIDAMBLE_PDCTY = 0x8000,
};
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 8, 0))
#define IEEE80211_RADIOTAP_VHT 21
/* For IEEE80211_RADIOTAP_VHT */
#define IEEE80211_RADIOTAP_VHT_KNOWN_STBC 0x0001
#define IEEE80211_RADIOTAP_VHT_KNOWN_TXOP_PS_NA 0x0002
#define IEEE80211_RADIOTAP_VHT_KNOWN_GI 0x0004
#define IEEE80211_RADIOTAP_VHT_KNOWN_SGI_NSYM_DIS 0x0008
#define IEEE80211_RADIOTAP_VHT_KNOWN_LDPC_EXTRA_OFDM_SYM 0x0010
#define IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED 0x0020
#define IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH 0x0040
#define IEEE80211_RADIOTAP_VHT_KNOWN_GROUP_ID 0x0080
#define IEEE80211_RADIOTAP_VHT_KNOWN_PARTIAL_AID 0x0100
#define IEEE80211_RADIOTAP_VHT_FLAG_STBC 0x01
#define IEEE80211_RADIOTAP_VHT_FLAG_TXOP_PS_NA 0x02
#define IEEE80211_RADIOTAP_VHT_FLAG_SGI 0x04
#define IEEE80211_RADIOTAP_VHT_FLAG_SGI_NSYM_M10_9 0x08
#define IEEE80211_RADIOTAP_VHT_FLAG_LDPC_EXTRA_OFDM_SYM 0x10
#define IEEE80211_RADIOTAP_VHT_FLAG_BEAMFORMED 0x20
#elif (LINUX_VERSION_CODE < KERNEL_VERSION(3, 15, 0))
#define IEEE80211_RADIOTAP_CODING_LDPC_USER0 0x01
#define IEEE80211_RADIOTAP_CODING_LDPC_USER1 0x02
#define IEEE80211_RADIOTAP_CODING_LDPC_USER2 0x04
#define IEEE80211_RADIOTAP_CODING_LDPC_USER3 0x08
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0))
#define IEEE80211_RADIOTAP_AMPDU_STATUS 20
/* For IEEE80211_RADIOTAP_AMPDU_STATUS */
#define IEEE80211_RADIOTAP_AMPDU_REPORT_ZEROLEN 0x0001
#define IEEE80211_RADIOTAP_AMPDU_IS_ZEROLEN 0x0002
#define IEEE80211_RADIOTAP_AMPDU_LAST_KNOWN 0x0004
#define IEEE80211_RADIOTAP_AMPDU_IS_LAST 0x0008
#define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_ERR 0x0010
#define IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_KNOWN 0x0020
#elif (LINUX_VERSION_CODE < KERNEL_VERSION(4, 17, 0))
#define IEEE80211_RADIOTAP_AMPDU_EOF 0x0040
#define IEEE80211_RADIOTAP_AMPDU_EOF_KNOWN 0x0080
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39))
#define IEEE80211_RADIOTAP_MCS 19
/* For IEEE80211_RADIOTAP_MCS */
#define IEEE80211_RADIOTAP_MCS_HAVE_BW 0x01
#define IEEE80211_RADIOTAP_MCS_HAVE_MCS 0x02
#define IEEE80211_RADIOTAP_MCS_HAVE_GI 0x04
#define IEEE80211_RADIOTAP_MCS_HAVE_FMT 0x08
#define IEEE80211_RADIOTAP_MCS_HAVE_FEC 0x10
#define IEEE80211_RADIOTAP_MCS_BW_MASK 0x03
#define IEEE80211_RADIOTAP_MCS_BW_20 0
#define IEEE80211_RADIOTAP_MCS_BW_40 1
#define IEEE80211_RADIOTAP_MCS_BW_20L 2
#define IEEE80211_RADIOTAP_MCS_BW_20U 3
#define IEEE80211_RADIOTAP_MCS_SGI 0x04
#define IEEE80211_RADIOTAP_MCS_FMT_GF 0x08
#define IEEE80211_RADIOTAP_MCS_FEC_LDPC 0x10
#elif (LINUX_VERSION_CODE < KERNEL_VERSION(3, 11, 0))
#define IEEE80211_RADIOTAP_MCS_HAVE_STBC 0x20
#define IEEE80211_RADIOTAP_MCS_STBC_MASK 0x60
#define IEEE80211_RADIOTAP_MCS_STBC_1 1
#define IEEE80211_RADIOTAP_MCS_STBC_2 2
#define IEEE80211_RADIOTAP_MCS_STBC_3 3
#define IEEE80211_RADIOTAP_MCS_STBC_SHIFT 5
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34))
#define IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE 29
#define IEEE80211_RADIOTAP_VENDOR_NAMESPACE 30
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30))
#define IEEE80211_RADIOTAP_F_BADFCS 0x40
#endif
static inline void _rtw_radiotap_fill_flags(struct rx_pkt_attrib *a, u8 *flags)
{
struct moinfo *moif = (struct moinfo *)&a->moif;
if (0)
*flags |= IEEE80211_RADIOTAP_F_CFP;
if (0)
*flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
if ((a->encrypt == 1) || (a->encrypt == 5))
*flags |= IEEE80211_RADIOTAP_F_WEP;
if (a->mfrag)
*flags |= IEEE80211_RADIOTAP_F_FRAG;
if (1)
*flags |= IEEE80211_RADIOTAP_F_FCS;
if (0)
*flags |= IEEE80211_RADIOTAP_F_DATAPAD;
if (a->crc_err)
*flags |= IEEE80211_RADIOTAP_F_BADFCS;
/* Currently unspecified but used
for short guard interval (HT) */
if (moif->u.snif_info.sgi || a->sgi)
*flags |= 0x80;
}
sint rtw_fill_radiotap_hdr(_adapter *padapter,
struct rx_pkt_attrib *a, struct rtw_recv_pkt *rx_req, u8 *buf)
{
#define RTAP_HDR_MAX 64
sint ret = _SUCCESS;
struct moinfo *moif = (struct moinfo *)&a->moif;
u8 rx_cnt = 0;
int i = 0;
u8 tmp_8bit = 0;
u16 tmp_16bit = 0;
u32 tmp_32bit = 0;
u64 tmp_64bit = 0;
struct sk_buff *pskb = NULL;
struct ieee80211_radiotap_header *rtap_hdr = NULL;
u8 *ptr = NULL;
/*
radiotap length (include header 8)
11G length: 36 (0x0040002f)
11N length:
11AC length: 60 (0x0070002b)
*/
u8 hdr_buf[RTAP_HDR_MAX] = { 0 };
u16 rt_len = 8;
/* create header */
rtap_hdr = (struct ieee80211_radiotap_header *)&hdr_buf[0];
rtap_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
/* each antenna information */
rx_cnt = GET_HAL_RFPATH_NUM(padapter->dvobj);
#if 0
if (rx_cnt > 1) {
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE) |
BIT(IEEE80211_RADIOTAP_EXT);
for (i = 1; i < rx_cnt; i++) {
tmp_32bit = (BIT(IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
BIT(IEEE80211_RADIOTAP_LOCK_QUALITY) |
BIT(IEEE80211_RADIOTAP_ANTENNA) |
BIT(IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE) |
BIT(IEEE80211_RADIOTAP_EXT));
_rtw_memcpy(&hdr_buf[rt_len], &tmp_32bit, 4);
rt_len += 4;
}
tmp_32bit = (BIT(IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
BIT(IEEE80211_RADIOTAP_LOCK_QUALITY) |
BIT(IEEE80211_RADIOTAP_ANTENNA));
_rtw_memcpy(&hdr_buf[rt_len], &tmp_32bit, 4);
rt_len += 4;
}
#endif
/* tsft, Required Alignment: 8 bytes */
if (0) { //(a->free_cnt) {
/* TSFT + free_cnt */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_TSFT);
if (!IS_ALIGNED(rt_len, 8))
rt_len = ((rt_len + 7) & 0xFFF8); /* Alignment */
tmp_64bit = cpu_to_le64(rx_req->mdata.freerun_cnt);
_rtw_memcpy(&hdr_buf[rt_len], &tmp_64bit, 8);
rt_len += 8;
}
/* flags */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_FLAGS);
_rtw_radiotap_fill_flags(a, &hdr_buf[rt_len]);
rt_len += 1;
/* rate */
if (rx_req->mdata.rx_rate <= RTW_DATA_RATE_OFDM54) {
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_RATE);
hdr_buf[rt_len] = hwrate_to_mrate(rx_req->mdata.rx_rate);
rt_len += 1;
}
/* channel & flags, Required Alignment: 2 bytes */
if (1) {
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_CHANNEL);
rt_len += (rt_len % 2); /* Alignment */
tmp_16bit = CHAN2FREQ(rtw_get_oper_ch(padapter));
_rtw_memcpy(&hdr_buf[rt_len], &tmp_16bit, 2);
rt_len += 2;
/* channel flags */
tmp_16bit = 0;
if (WIFI_ROLE_IS_ON_24G(padapter))
tmp_16bit |= cpu_to_le16(IEEE80211_CHAN_2GHZ);
else
tmp_16bit |= cpu_to_le16(IEEE80211_CHAN_5GHZ);
if (rx_req->mdata.rx_rate <= RTW_DATA_RATE_CCK11) {
/* CCK */
tmp_16bit |= cpu_to_le16(IEEE80211_CHAN_CCK);
} else {
/* OFDM */
tmp_16bit |= cpu_to_le16(IEEE80211_CHAN_OFDM);
}
if (rtw_get_oper_bw(padapter) == CHANNEL_WIDTH_10) {
/* 10Mhz Channel Width */
tmp_16bit |= cpu_to_le16(IEEE80211_CHAN_HALF);
}
if (rtw_get_oper_bw(padapter) == CHANNEL_WIDTH_5) {
/* 5Mhz Channel Width */
tmp_16bit |= cpu_to_le16(IEEE80211_CHAN_QUARTER);
}
_rtw_memcpy(&hdr_buf[rt_len], &tmp_16bit, 2);
rt_len += 2;
}
/* dBm Antenna Signal */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
hdr_buf[rt_len] = a->phy_info.recv_signal_power;
rt_len += 1;
#if 0
/* dBm Antenna Noise */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_DBM_ANTNOISE);
hdr_buf[rt_len] = 0;
rt_len += 1;
#endif
#if 0
/* Signal Quality, Required Alignment: 2 bytes */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_LOCK_QUALITY);
if (!IS_ALIGNED(rt_len, 2))
rt_len++;
hdr_buf[rt_len] = a->phy_info.signal_quality;
rt_len += 2;
#endif
#if 0
/* Antenna */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_ANTENNA);
hdr_buf[rt_len] = 0; /* pHalData->rf_type; */
rt_len += 1;
#endif
#if 0
/* RX flags, Required Alignment: 2 bytes */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_RX_FLAGS);
tmp_16bit = 0;
_rtw_memcpy(&hdr_buf[rt_len], &tmp_16bit, 2);
rt_len += 2;
#endif
/* MCS information, Required Alignment: 1 bytes */
if (rx_req->mdata.rx_rate >= RTW_DATA_RATE_MCS0 && rx_req->mdata.rx_rate <= RTW_DATA_RATE_MCS31) {
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_MCS);
/* Structure u8 known, u8 flags, u8 mcs */
/* known.bandwidth */
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_MCS_HAVE_BW;
if (moif->u.snif_info.ofdm_bw)
hdr_buf[rt_len + 1] |= IEEE80211_RADIOTAP_MCS_BW_40;
if (rx_req->mdata.bw == CHANNEL_WIDTH_40)
hdr_buf[rt_len + 1] |= IEEE80211_RADIOTAP_MCS_BW_40;
else
hdr_buf[rt_len + 1] |= IEEE80211_RADIOTAP_MCS_BW_20;
/* known.guard interval */
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_MCS_HAVE_GI;
if (moif->u.snif_info.sgi) {
hdr_buf[rt_len + 1] |= IEEE80211_RADIOTAP_MCS_SGI;
} else {
hdr_buf[rt_len + 1] |= ((a->sgi & 0x01) << 2);
}
/* FEC Type */
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_MCS_HAVE_FEC;
if (moif->u.snif_info.ldpc) {
hdr_buf[rt_len + 1] |= ((moif->u.snif_info.ldpc & 0x01) << 4);
} else {
hdr_buf[rt_len + 1] |= ((a->ldpc & 0x01) << 4);
}
/* STBC */
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_MCS_HAVE_STBC;
if (moif->u.snif_info.stbc) {
hdr_buf[rt_len + 1] |= ((moif->u.snif_info.stbc & 0x03) << 5);
} else {
hdr_buf[rt_len + 1] |= ((a->stbc & 0x03) << 5);
}
/* known.MCS index */
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_MCS_HAVE_MCS;
/* u8 mcs */
hdr_buf[rt_len + 2] = rx_req->mdata.rx_rate - RTW_DATA_RATE_MCS0;
rt_len += 3;
}
/* AMPDU, Required Alignment: 4 bytes */
if (rx_req->mdata.ampdu) {
static u32 ref_num = 0x10000000;
static u8 ppdu_cnt = 0;
/* Structure u32 reference number, u16 flags, u8 delimiter CRC value, u8 reserved */
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_AMPDU_STATUS);
if (!IS_ALIGNED(rt_len, 4))
rt_len = ((rt_len + 3) & 0xFFFC); /* Alignment */
/* u32 reference number */
if (rx_req->mdata.ppdu_cnt != ppdu_cnt) {
ppdu_cnt = rx_req->mdata.ppdu_cnt;
ref_num += 1;
}
tmp_32bit = cpu_to_le32(ref_num);
_rtw_memcpy(&hdr_buf[rt_len], &tmp_32bit, 4);
rt_len += 4;
/* u16 flags */
tmp_16bit = 0;
if (0) {
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_REPORT_ZEROLEN);
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_IS_ZEROLEN);
}
if (0) {
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_IS_LAST);
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_LAST_KNOWN);
}
if (0) {
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_ERR);
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_DELIM_CRC_KNOWN);
}
if (rx_req->mdata.ampdu_end_pkt) {
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_EOF_KNOWN);
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_AMPDU_EOF);
}
_rtw_memcpy(&hdr_buf[rt_len], &tmp_16bit, 2);
rt_len += 2;
/* u8 delimiter CRC value, u8 reserved */
rt_len += 2;
}
/* VHT, Required Alignment: 2 bytes */
if (rx_req->mdata.rx_rate >= RTW_DATA_RATE_VHT_NSS1_MCS0 && rx_req->mdata.rx_rate <= RTW_DATA_RATE_VHT_NSS4_MCS9) {
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_VHT);
rt_len += (rt_len % 2); /* Alignment */
/* Structure
u16 known, u8 flags, u8 bandwidth, u8 mcs_nss[4],
u8 coding, u8 group_id, u16 partial_aid */
tmp_16bit = 0;
/* STBC */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_STBC);
if (moif->u.snif_info.stbc) {
hdr_buf[rt_len + 2] |= IEEE80211_RADIOTAP_VHT_FLAG_STBC;
} else {
hdr_buf[rt_len + 2] |= (a->stbc & 0x01);
}
/* TXOP_PS_NOT_ALLOWED */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_TXOP_PS_NA);
if (moif->u.snif_info.vht_txop_not_allow) {
hdr_buf[rt_len + 2] |= IEEE80211_RADIOTAP_VHT_FLAG_TXOP_PS_NA;
}
/* Guard interval */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_GI);
if (moif->u.snif_info.sgi) {
hdr_buf[rt_len + 2] |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
} else {
hdr_buf[rt_len + 2] |= ((a->sgi & 0x01) << 2);
}
/* Short GI NSYM */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_SGI_NSYM_DIS);
if (moif->u.snif_info.vht_nsym_dis) {
hdr_buf[rt_len + 2] |= IEEE80211_RADIOTAP_VHT_FLAG_SGI_NSYM_M10_9;
}
/* LDPC extra OFDM symbol */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_LDPC_EXTRA_OFDM_SYM);
if (moif->u.snif_info.vht_ldpc_extra) {
hdr_buf[rt_len + 2] |= IEEE80211_RADIOTAP_VHT_FLAG_LDPC_EXTRA_OFDM_SYM;
} else {
hdr_buf[rt_len + 2] |= ((a->ldpc & 0x01) << 4);
}
/* Short GI NSYM */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED);
if (moif->u.snif_info.vht_beamformed) {
hdr_buf[rt_len + 2] |= IEEE80211_RADIOTAP_VHT_FLAG_BEAMFORMED;
}
/* know.Bandwidth */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH);
/* Group ID */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_GROUP_ID);
/* Partial AID */
tmp_16bit |= cpu_to_le16(IEEE80211_RADIOTAP_VHT_KNOWN_PARTIAL_AID);
_rtw_memcpy(&hdr_buf[rt_len], &tmp_16bit, 2);
rt_len += 3;
/* u8 bandwidth */
if (moif->u.snif_info.ofdm_bw)
tmp_8bit = moif->u.snif_info.ofdm_bw;
else
tmp_8bit = rx_req->mdata.bw;
switch (tmp_8bit) {
case CHANNEL_WIDTH_20:
hdr_buf[rt_len] |= 0;
break;
case CHANNEL_WIDTH_40:
hdr_buf[rt_len] |= 1;
break;
case CHANNEL_WIDTH_80:
hdr_buf[rt_len] |= 4;
break;
case CHANNEL_WIDTH_160:
hdr_buf[rt_len] |= 11;
break;
default:
hdr_buf[rt_len] |= 0;
}
rt_len += 1;
/* u8 mcs_nss[4] */
if ((RTW_DATA_RATE_VHT_NSS1_MCS0 <= rx_req->mdata.rx_rate) &&
(rx_req->mdata.rx_rate <= RTW_DATA_RATE_VHT_NSS4_MCS9)) {
/* User 0 */
/* MCS */
hdr_buf[rt_len] = cpu_to_le16 (((rx_req->mdata.rx_rate - RTW_DATA_RATE_VHT_NSS1_MCS0) % 10) << 4);
/* NSS */
hdr_buf[rt_len] |= cpu_to_le16((((rx_req->mdata.rx_rate - RTW_DATA_RATE_VHT_NSS1_MCS0) / 10) + 1));
}
rt_len += 4;
/* u8 coding, phystat? */
hdr_buf[rt_len] = 0;
rt_len += 1;
/* u8 group_id */
hdr_buf[rt_len] = moif->u.snif_info.vht_group_id;
rt_len += 1;
/* u16 partial_aid */
tmp_16bit = cpu_to_le16(moif->u.snif_info.vht_nsts_aid);
_rtw_memcpy(&hdr_buf[rt_len], &tmp_16bit, 2);
rt_len += 2;
}
/* HE, Required Alignment: 2 bytes */
if (rx_req->mdata.rx_rate >= RTW_DATA_RATE_HE_NSS1_MCS0 && rx_req->mdata.rx_rate <= RTW_DATA_RATE_HE_NSS4_MCS11) {
struct ieee80211_radiotap_he he_hdr;
u8 ltf, he_gi, ss;
_rtw_memset(&he_hdr, 0, sizeof(struct ieee80211_radiotap_he));
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_HE);
rt_len += (rt_len % 2); /* Alignment */
/* Structure
u16 data1, data2, data3, data4, data5, data6 */
/* HE PPDU Format: 0=HE_SU, 1=HE_EXT_SU, 2=HE_MU, 3=HE_TRIG */
he_hdr.data1 |= 0x0000;
he_hdr.data1 |= cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN);
he_hdr.data1 |= cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN);
he_hdr.data2 |= cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN);
he_hdr.data2 |= cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_NUM_LTF_SYMS_KNOWN);
he_hdr.data3 |= __le16_encode_bits((rx_req->mdata.rx_rate & 0xf), IEEE80211_RADIOTAP_HE_DATA3_DATA_MCS);
he_hdr.data5 |= cpu_to_le16((rx_req->mdata.bw));
switch (rx_req->mdata.rx_gi_ltf) {
case 0x0:
he_gi = IEEE80211_RADIOTAP_HE_DATA5_GI_3_2;
ltf = IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_4X;
break;
case 0x1:
he_gi = IEEE80211_RADIOTAP_HE_DATA5_GI_0_8;
ltf = IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_4X;
break;
case 0x2:
he_gi = IEEE80211_RADIOTAP_HE_DATA5_GI_1_6;
ltf = IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_2X;
break;
case 0x3:
he_gi = IEEE80211_RADIOTAP_HE_DATA5_GI_0_8;
ltf = IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_2X;
break;
case 0x4:
he_gi = IEEE80211_RADIOTAP_HE_DATA5_GI_1_6;
ltf = IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_1X;
break;
case 0x5:
he_gi = IEEE80211_RADIOTAP_HE_DATA5_GI_0_8;
ltf = IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_1X;
break;
default:
he_gi = IEEE80211_RADIOTAP_HE_DATA5_GI_0_8;
ltf = IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE_1X;
break;
}
he_hdr.data5 |= __le16_encode_bits(he_gi, IEEE80211_RADIOTAP_HE_DATA5_GI);
he_hdr.data5 |= __le16_encode_bits(ltf, IEEE80211_RADIOTAP_HE_DATA5_LTF_SIZE);
ss = cpu_to_le16(((0x70 & rx_req->mdata.rx_rate) >> 4) + 1);
he_hdr.data6 |= __le16_encode_bits(ss, IEEE80211_RADIOTAP_HE_DATA6_NSTS);
_rtw_memcpy(&hdr_buf[rt_len], &he_hdr, sizeof(struct ieee80211_radiotap_he));
rt_len += sizeof(struct ieee80211_radiotap_he);
}
/* frame timestamp, Required Alignment: 8 bytes */
if (0) { //(a->free_cnt) {
rtap_hdr->it_present |= BIT(IEEE80211_RADIOTAP_TIMESTAMP);
if (!IS_ALIGNED(rt_len, 8))
rt_len = ((rt_len + 7) & 0xFFF8); /* Alignment */
/* u64 timestamp */
tmp_64bit = cpu_to_le64(rx_req->mdata.freerun_cnt);
_rtw_memcpy(&hdr_buf[rt_len], &tmp_64bit, 8);
rt_len += 8;
/* u16 accuracy */
tmp_16bit = cpu_to_le16(22);
_rtw_memcpy(&hdr_buf[rt_len], &tmp_16bit, 2);
rt_len += 2;
/* u8 unit/position */
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US;
rt_len += 1;
/* u8 flags */
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_TIMESTAMP_FLAG_32BIT;
hdr_buf[rt_len] |= IEEE80211_RADIOTAP_TIMESTAMP_FLAG_ACCURACY;
rt_len += 1;
}
/* each antenna information */
#if 0
if (rx_cnt > 1) {
for (i = 0; i <= rx_cnt; i++) {
/* dBm Antenna Signal */
hdr_buf[rt_len] = a->phy_info.rx_mimo_signal_strength[i];
rt_len += 1;
/* Signal Quality */
if (!IS_ALIGNED(rt_len, 2))
rt_len++;
hdr_buf[rt_len] = cpu_to_le16(a->phy_info.rx_mimo_signal_quality[i]);
rt_len += 2;
/* Antenna */
hdr_buf[rt_len] = i; /* pHalData->rf_type; */
rt_len += 1;
}
}
#endif
/* push to skb */
pskb = (struct sk_buff *)buf;
if (skb_headroom(pskb) < rt_len) {
RTW_INFO("%s:%d %s headroom is too small.\n", __FILE__, __LINE__, __func__);
ret = _FAIL;
return ret;
}
ptr = skb_push(pskb, rt_len);
if (ptr) {
rtap_hdr->it_len = cpu_to_le16(rt_len);
rtap_hdr->it_present = cpu_to_le32(rtap_hdr->it_present);
memcpy(ptr, rtap_hdr, rt_len);
} else
ret = _FAIL;
return ret;
}
void rx_query_moinfo(struct rx_pkt_attrib *a, u8 *desc)
{
switch (a->drvinfo_sz) {
case 40:
_rtw_memcpy(a->moif, &desc[32], 8);
break;
case 48:
_rtw_memcpy(a->moif, &desc[32], 12);
break;
case 32:
/* passthrough */
default:
break;
}
}
#endif /* CONFIG_WIFI_MONITOR */
|
2301_81045437/rtl8852be
|
core/monitor/rtw_radiotap.c
|
C
|
agpl-3.0
| 25,676
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __RTW_RADIOTAP_H_
#define __RTW_RADIOTAP_H_
struct mon_reg_backup {
/* flags */
u8 known_rcr:1;
u8 known_drvinfo:1;
u8 known_rxfilter:1;
u8 known_misc0:1;
/* data */
u8 drvinfo;
u16 rxfilter0;
u16 rxfilter1;
u16 rxfilter2;
u32 rcr;
u32 misc0;
};
struct moinfo {
union {
struct {
u32 sgi:1;
u32 ldpc:1;
u32 stbc:2;
u32 not_sounding:1;
u32 ofdm_bw:2;
u32 vht_group_id:2;
u32 vht_nsts_aid:12;
u32 vht_txop_not_allow:1;
u32 vht_nsym_dis:1;
u32 vht_ldpc_extra:1;
u32 vht_su_mcs:12;
u32 vht_beamformed:1;
}snif_info;
struct {
u32 A;
u32 B;
u32 C;
}plcp_info;
}u;
};
sint rtw_fill_radiotap_hdr(_adapter *padapter,
struct rx_pkt_attrib *a, struct rtw_recv_pkt *rx_req, u8 *buf);
void rx_query_moinfo(struct rx_pkt_attrib *a, u8 *desc);
#endif /* __RTW_RADIOTAP_H_ */
|
2301_81045437/rtl8852be
|
core/monitor/rtw_radiotap.h
|
C
|
agpl-3.0
| 1,500
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_AP_C_
#include <drv_types.h>
#ifdef CONFIG_AP_MODE
extern unsigned char RTW_WPA_OUI[];
extern unsigned char WMM_OUI[];
extern unsigned char WPS_OUI[];
extern unsigned char P2P_OUI[];
extern unsigned char WFD_OUI[];
void init_mlme_ap_info(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
_rtw_spinlock_init(&pmlmepriv->bcn_update_lock);
/* pmlmeext->bstart_bss = _FALSE; */
}
void free_mlme_ap_info(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
stop_ap_mode(padapter);
_rtw_spinlock_free(&pmlmepriv->bcn_update_lock);
}
/*
* Set TIM IE
* return length of total TIM IE
*/
u8 rtw_set_tim_ie(u8 dtim_cnt, u8 dtim_period
, const u8 *tim_bmp, u8 tim_bmp_len, u8 *tim_ie)
{
u8 *p = tim_ie;
u8 i, n1, n2;
u8 bmp_len;
if (rtw_bmp_not_empty(tim_bmp, tim_bmp_len)) {
/* find the first nonzero octet in tim_bitmap */
for (i = 0; i < tim_bmp_len; i++)
if (tim_bmp[i])
break;
n1 = i & 0xFE;
/* find the last nonzero octet in tim_bitmap, except octet 0 */
for (i = tim_bmp_len - 1; i > 0; i--)
if (tim_bmp[i])
break;
n2 = i;
bmp_len = n2 - n1 + 1;
} else {
n1 = n2 = 0;
bmp_len = 1;
}
*p++ = WLAN_EID_TIM;
*p++ = 2 + 1 + bmp_len;
*p++ = dtim_cnt;
*p++ = dtim_period;
*p++ = (rtw_bmp_is_set(tim_bmp, tim_bmp_len, 0) ? BIT0 : 0) | n1;
_rtw_memcpy(p, tim_bmp + n1, bmp_len);
#if 0
RTW_INFO("n1:%u, n2:%u, bmp_offset:%u, bmp_len:%u\n", n1, n2, n1 / 2, bmp_len);
RTW_INFO_DUMP("tim_ie: ", tim_ie + 2, 2 + 1 + bmp_len);
#endif
return 2 + 2 + 1 + bmp_len;
}
static void update_BCNTIM(_adapter *padapter)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork_mlmeext = &(pmlmeinfo->network);
unsigned char *pie = pnetwork_mlmeext->IEs;
#if 0
/* update TIM IE */
/* if(rtw_tim_map_anyone_be_set(padapter, pstapriv->tim_bitmap)) */
#endif
if (_TRUE) {
u8 *p, *dst_ie, *premainder_ie = NULL, *pbackup_remainder_ie = NULL;
uint offset, tmp_len, tim_ielen, tim_ie_offset, remainder_ielen;
p = rtw_get_ie(pie + _FIXED_IE_LENGTH_, _TIM_IE_, &tim_ielen, pnetwork_mlmeext->IELength - _FIXED_IE_LENGTH_);
if (p != NULL && tim_ielen > 0) {
tim_ielen += 2;
premainder_ie = p + tim_ielen;
tim_ie_offset = (sint)(p - pie);
remainder_ielen = pnetwork_mlmeext->IELength - tim_ie_offset - tim_ielen;
/*append TIM IE from dst_ie offset*/
dst_ie = p;
} else {
tim_ielen = 0;
/*calculate head_len*/
offset = _FIXED_IE_LENGTH_;
/* get ssid_ie len */
p = rtw_get_ie(pie + _BEACON_IE_OFFSET_, _SSID_IE_, &tmp_len, (pnetwork_mlmeext->IELength - _BEACON_IE_OFFSET_));
if (p != NULL)
offset += tmp_len + 2;
/*get supported rates len*/
p = rtw_get_ie(pie + _BEACON_IE_OFFSET_, _SUPPORTEDRATES_IE_, &tmp_len, (pnetwork_mlmeext->IELength - _BEACON_IE_OFFSET_));
if (p != NULL)
offset += tmp_len + 2;
/*DS Parameter Set IE, len=3*/
offset += 3;
premainder_ie = pie + offset;
remainder_ielen = pnetwork_mlmeext->IELength - offset - tim_ielen;
/*append TIM IE from offset*/
dst_ie = pie + offset;
}
if (remainder_ielen > 0) {
pbackup_remainder_ie = rtw_malloc(remainder_ielen);
if (pbackup_remainder_ie && premainder_ie)
_rtw_memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
}
/* append TIM IE */
dst_ie += rtw_set_tim_ie(0, 1, pstapriv->tim_bitmap, pstapriv->aid_bmp_len, dst_ie);
/*copy remainder IE*/
if (pbackup_remainder_ie) {
_rtw_memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen);
rtw_mfree(pbackup_remainder_ie, remainder_ielen);
}
offset = (uint)(dst_ie - pie);
pnetwork_mlmeext->IELength = offset + remainder_ielen;
}
}
void rtw_add_bcn_ie(_adapter *padapter, WLAN_BSSID_EX *pnetwork, u8 index, u8 *data, u8 len)
{
PNDIS_802_11_VARIABLE_IEs pIE;
u8 bmatch = _FALSE;
u8 *pie = pnetwork->IEs;
u8 *p = NULL, *dst_ie = NULL, *premainder_ie = NULL, *pbackup_remainder_ie = NULL;
u32 i, offset, ielen = 0, ie_offset, remainder_ielen = 0;
/* Search element id (index) exits or not */
for (i = sizeof(NDIS_802_11_FIXED_IEs); i < pnetwork->IELength;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(pnetwork->IEs + i);
if (pIE->ElementID > index)
break;
else if (pIE->ElementID == index) { /* already exist the same IE */
p = (u8 *)pIE;
ielen = pIE->Length;
bmatch = _TRUE;
break;
}
p = (u8 *)pIE;
ielen = pIE->Length;
i += (pIE->Length + 2);
}
/* Backup remainder IE */
if (p != NULL && ielen > 0) {
ielen += 2;
premainder_ie = p + ielen;
ie_offset = (sint)(p - pie);
remainder_ielen = pnetwork->IELength - ie_offset - ielen;
if (bmatch)
dst_ie = p;
else
dst_ie = (p + ielen);
}
if (dst_ie == NULL)
return;
if (remainder_ielen > 0) {
pbackup_remainder_ie = rtw_malloc(remainder_ielen);
if (pbackup_remainder_ie && premainder_ie)
_rtw_memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
}
*dst_ie++ = index;
*dst_ie++ = len;
_rtw_memcpy(dst_ie, data, len);
dst_ie += len;
/* Append remainder IE */
if (pbackup_remainder_ie) {
_rtw_memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen);
rtw_mfree(pbackup_remainder_ie, remainder_ielen);
}
offset = (uint)(dst_ie - pie);
pnetwork->IELength = offset + remainder_ielen;
}
void rtw_remove_bcn_ie(_adapter *padapter, WLAN_BSSID_EX *pnetwork, u8 index)
{
u8 *p, *dst_ie = NULL, *premainder_ie = NULL, *pbackup_remainder_ie = NULL;
uint offset, ielen, ie_offset, remainder_ielen = 0;
u8 *pie = pnetwork->IEs;
p = rtw_get_ie(pie + _FIXED_IE_LENGTH_, index, &ielen, pnetwork->IELength - _FIXED_IE_LENGTH_);
if (p != NULL && ielen > 0) {
ielen += 2;
premainder_ie = p + ielen;
ie_offset = (sint)(p - pie);
remainder_ielen = pnetwork->IELength - ie_offset - ielen;
dst_ie = p;
} else
return;
if (remainder_ielen > 0) {
pbackup_remainder_ie = rtw_malloc(remainder_ielen);
if (pbackup_remainder_ie && premainder_ie)
_rtw_memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
}
/* copy remainder IE */
if (pbackup_remainder_ie) {
_rtw_memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen);
rtw_mfree(pbackup_remainder_ie, remainder_ielen);
}
offset = (uint)(dst_ie - pie);
pnetwork->IELength = offset + remainder_ielen;
}
void rtw_remove_bcn_ie_ex(_adapter *padapter, WLAN_BSSID_EX *pnetwork, u8 index, u8* pindex_ex, u8 index_ex_len)
{
u8 *p, *dst_ie = NULL, *premainder_ie = NULL, *pbackup_remainder_ie = NULL;
uint offset, ielen, ie_offset, remainder_ielen = 0;
u8 *pie = pnetwork->IEs;
p = rtw_get_ie_ex(pie + _FIXED_IE_LENGTH_, pnetwork->IELength - _FIXED_IE_LENGTH_, index, pindex_ex, index_ex_len, NULL, &ielen);
if (p != NULL && ielen > 0) {
premainder_ie = p + ielen;
ie_offset = (sint)(p - pie);
remainder_ielen = pnetwork->IELength - ie_offset - ielen;
dst_ie = p;
} else
return;
if (remainder_ielen > 0) {
pbackup_remainder_ie = rtw_malloc(remainder_ielen);
if (pbackup_remainder_ie && premainder_ie)
_rtw_memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
}
/* copy remainder IE */
if (pbackup_remainder_ie) {
_rtw_memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen);
rtw_mfree(pbackup_remainder_ie, remainder_ielen);
}
offset = (uint)(dst_ie - pie);
pnetwork->IELength = offset + remainder_ielen;
}
u8 chk_sta_is_alive(struct sta_info *psta);
u8 chk_sta_is_alive(struct sta_info *psta)
{
u8 ret = _FALSE;
#ifdef DBG_EXPIRATION_CHK
RTW_INFO("sta:"MAC_FMT", rssi:%d, rx:"STA_PKTS_FMT", expire_to:%u, %s%ssq_len:%u\n"
, MAC_ARG(psta->phl_sta->mac_addr)
, 0 /* TODO: psta->phl_sta->hal_sta->rssi_stat.rssi */
/* , STA_RX_PKTS_ARG(psta) */
, STA_RX_PKTS_DIFF_ARG(psta)
, psta->expire_to
, psta->state & WIFI_SLEEP_STATE ? "PS, " : ""
, psta->state & WIFI_STA_ALIVE_CHK_STATE ? "SAC, " : ""
, psta->sleepq_len
);
#endif
/* if(sta_last_rx_pkts(psta) == sta_rx_pkts(psta)) */
if ((psta->sta_stats.last_rx_data_pkts + psta->sta_stats.last_rx_ctrl_pkts) == (psta->sta_stats.rx_data_pkts + psta->sta_stats.rx_ctrl_pkts)) {
#if 0
if (psta->state & WIFI_SLEEP_STATE)
ret = _TRUE;
#endif
} else
ret = _TRUE;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(psta->padapter)) {
u8 bcn_alive, hwmp_alive;
hwmp_alive = (psta->sta_stats.rx_hwmp_pkts !=
psta->sta_stats.last_rx_hwmp_pkts);
bcn_alive = (psta->sta_stats.rx_beacon_pkts !=
psta->sta_stats.last_rx_beacon_pkts);
/* The reference for nexthop_lookup */
psta->alive = ret || hwmp_alive || bcn_alive;
/* The reference for expire_timeout_chk */
/* Exclude bcn_alive to avoid a misjudge condition
that a peer unexpectedly leave and restart quickly*/
ret = ret || hwmp_alive;
}
#endif
sta_update_last_rx_pkts(psta);
return ret;
}
/**
* issue_aka_chk_frame - issue active keep alive check frame
* aka = active keep alive
*/
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
static int issue_aka_chk_frame(_adapter *adapter, struct sta_info *psta)
{
int ret = _FAIL;
u8 *target_addr = psta->phl_sta->mac_addr;
if (MLME_IS_AP(adapter)) {
/* issue null data to check sta alive */
if (psta->state & WIFI_SLEEP_STATE)
ret = issue_nulldata(adapter, target_addr, 0, 1, 50);
else
ret = issue_nulldata(adapter, target_addr, 0, 3, 50);
}
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(adapter)) {
struct rtw_mesh_path *mpath;
rtw_rcu_read_lock();
mpath = rtw_mesh_path_lookup(adapter, target_addr);
if (!mpath) {
mpath = rtw_mesh_path_add(adapter, target_addr);
if (IS_ERR(mpath)) {
rtw_rcu_read_unlock();
RTW_ERR(FUNC_ADPT_FMT" rtw_mesh_path_add for "MAC_FMT" fail.\n",
FUNC_ADPT_ARG(adapter), MAC_ARG(target_addr));
return _FAIL;
}
}
if (mpath->flags & RTW_MESH_PATH_ACTIVE)
ret = _SUCCESS;
else {
u8 flags = RTW_PREQ_Q_F_START | RTW_PREQ_Q_F_PEER_AKA;
/* issue PREQ to check peer alive */
rtw_mesh_queue_preq(mpath, flags);
ret = _FALSE;
}
rtw_rcu_read_unlock();
}
#endif
return ret;
}
#endif
void expire_timeout_chk(_adapter *padapter)
{
_list *phead, *plist;
u8 updated = _FALSE;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 chk_alive_num = 0;
char chk_alive_list[NUM_STA];
int i;
int stainfo_offset;
u8 flush_num = 0;
char flush_list[NUM_STA]={0};
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)
&& check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)
) {
struct rtw_mesh_cfg *mcfg = &padapter->mesh_cfg;
rtw_mesh_path_expire(padapter);
/* TBD: up layer timeout mechanism */
/* if (!mcfg->plink_timeout)
return; */
#ifndef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
return;
#endif
}
#endif
#ifdef CONFIG_RTW_WDS
rtw_wds_path_expire(padapter);
#endif
_rtw_spinlock_bh(&pstapriv->auth_list_lock);
phead = &pstapriv->auth_list;
plist = get_next(phead);
/* check auth_queue */
#ifdef DBG_EXPIRATION_CHK
if (rtw_end_of_queue_search(phead, plist) == _FALSE) {
RTW_INFO(FUNC_ADPT_FMT" auth_list, cnt:%u\n"
, FUNC_ADPT_ARG(padapter), pstapriv->auth_list_cnt);
}
#endif
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, auth_list);
plist = get_next(plist);
#ifdef CONFIG_ATMEL_RC_PATCH
if (_rtw_memcmp((void *)(pstapriv->atmel_rc_pattern), (void *)(psta->phl_sta->mac_addr), ETH_ALEN) == _TRUE)
continue;
if (psta->flag_atmel_rc)
continue;
#endif
if (psta->expire_to > 0) {
psta->expire_to--;
if (psta->expire_to == 0) {
stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
if (stainfo_offset_valid(stainfo_offset))
flush_list[flush_num++] = stainfo_offset;
else
rtw_warn_on(1);
}
}
}
_rtw_spinunlock_bh(&pstapriv->auth_list_lock);
for (i = 0; i < flush_num; i++) {
psta = rtw_get_stainfo_by_offset(pstapriv, flush_list[i]);
RTW_INFO(FUNC_ADPT_FMT" auth expire "MAC_FMT"\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(psta->phl_sta->mac_addr));
rtw_free_stainfo(padapter, psta);
psta = NULL;
}
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
/* check asoc_queue */
#ifdef DBG_EXPIRATION_CHK
if (rtw_end_of_queue_search(phead, plist) == _FALSE) {
RTW_INFO(FUNC_ADPT_FMT" asoc_list, cnt:%u\n"
, FUNC_ADPT_ARG(padapter), pstapriv->asoc_list_cnt);
}
#endif
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
#ifdef CONFIG_ATMEL_RC_PATCH
RTW_INFO("%s:%d psta=%p, %02x,%02x||%02x,%02x \n\n", __func__, __LINE__,
psta, pstapriv->atmel_rc_pattern[0], pstapriv->atmel_rc_pattern[5], psta->phl_sta->mac_addr[0], psta->phl_sta->mac_addr[5]);
if (_rtw_memcmp((void *)pstapriv->atmel_rc_pattern, (void *)(psta->phl_sta->mac_addr), ETH_ALEN) == _TRUE)
continue;
if (psta->flag_atmel_rc)
continue;
RTW_INFO("%s: debug line:%d\n", __func__, __LINE__);
#endif
#ifdef CONFIG_AUTO_AP_MODE
if (psta->isrc)
continue;
#endif
if (chk_sta_is_alive(psta) || !psta->expire_to) {
psta->expire_to = pstapriv->expire_to;
psta->keep_alive_trycnt = 0;
#if !defined(CONFIG_ACTIVE_KEEP_ALIVE_CHECK) && defined(CONFIG_80211N_HT)
psta->under_exist_checking = 0;
#endif
} else
psta->expire_to--;
#if !defined(CONFIG_ACTIVE_KEEP_ALIVE_CHECK) && defined(CONFIG_80211N_HT)
if ((psta->flags & WLAN_STA_HT) && (psta->htpriv.agg_enable_bitmap || psta->under_exist_checking)) {
/* check sta by delba(addba) for 11n STA */
/* ToDo: use CCX report to check for all STAs */
/* RTW_INFO("asoc check by DELBA/ADDBA! (pstapriv->expire_to=%d s)(psta->expire_to=%d s), [%02x, %d]\n", pstapriv->expire_to*2, psta->expire_to*2, psta->htpriv.agg_enable_bitmap, psta->under_exist_checking); */
if (psta->expire_to <= (pstapriv->expire_to - 50)) {
RTW_INFO("asoc expire by DELBA/ADDBA! (%d s)\n", (pstapriv->expire_to - psta->expire_to) * 2);
psta->under_exist_checking = 0;
psta->expire_to = 0;
} else if (psta->expire_to <= (pstapriv->expire_to - 3) && (psta->under_exist_checking == 0)) {
RTW_INFO("asoc check by DELBA/ADDBA! (%d s)\n", (pstapriv->expire_to - psta->expire_to) * 2);
psta->under_exist_checking = 1;
/* tear down TX AMPDU */
send_delba(padapter, 1, psta->phl_sta->mac_addr);/* */ /* originator */
psta->htpriv.agg_enable_bitmap = 0x0;/* reset */
psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */
}
}
#endif /* !defined(CONFIG_ACTIVE_KEEP_ALIVE_CHECK) && defined(CONFIG_80211N_HT) */
if (psta->expire_to <= 0) {
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
if (padapter->registrypriv.wifi_spec == 1) {
psta->expire_to = pstapriv->expire_to;
continue;
}
#ifndef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
#ifdef CONFIG_80211N_HT
#define KEEP_ALIVE_TRYCNT (3)
if (psta->keep_alive_trycnt > 0 && psta->keep_alive_trycnt <= KEEP_ALIVE_TRYCNT) {
if (psta->state & WIFI_STA_ALIVE_CHK_STATE)
psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
else
psta->keep_alive_trycnt = 0;
} else if ((psta->keep_alive_trycnt > KEEP_ALIVE_TRYCNT) && !(psta->state & WIFI_STA_ALIVE_CHK_STATE))
psta->keep_alive_trycnt = 0;
if ((psta->htpriv.ht_option == _TRUE) && (psta->htpriv.ampdu_enable == _TRUE)) {
uint priority = 1; /* test using BK */
u8 issued = 0;
/* issued = (psta->htpriv.agg_enable_bitmap>>priority)&0x1; */
issued |= (psta->htpriv.candidate_tid_bitmap >> priority) & 0x1;
if (0 == issued) {
if (!(psta->state & WIFI_STA_ALIVE_CHK_STATE)) {
psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
if (psta->state & WIFI_SLEEP_STATE)
psta->expire_to = 2; /* 2x2=4 sec */
else
psta->expire_to = 1; /* 2 sec */
psta->state |= WIFI_STA_ALIVE_CHK_STATE;
/* add_ba_hdl(padapter, (u8*)paddbareq_parm); */
RTW_INFO("issue addba_req to check if sta alive, keep_alive_trycnt=%d\n", psta->keep_alive_trycnt);
issue_addba_req(padapter, psta->phl_sta->mac_addr, (u8)priority);
_set_timer(&psta->addba_retry_timer, ADDBA_TO);
psta->keep_alive_trycnt++;
continue;
}
}
}
if (psta->keep_alive_trycnt > 0 && psta->state & WIFI_STA_ALIVE_CHK_STATE) {
psta->keep_alive_trycnt = 0;
psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
RTW_INFO("change to another methods to check alive if staion is at ps mode\n");
}
#endif /* CONFIG_80211N_HT */
#endif /* CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
if (psta->state & WIFI_SLEEP_STATE) {
if (!(psta->state & WIFI_STA_ALIVE_CHK_STATE)) {
/* to check if alive by another methods if staion is at ps mode. */
psta->expire_to = pstapriv->expire_to;
psta->state |= WIFI_STA_ALIVE_CHK_STATE;
/* RTW_INFO("alive chk, sta:" MAC_FMT " is at ps mode!\n", MAC_ARG(psta->phl_sta->mac_addr)); */
/* to update bcn with tim_bitmap for this station */
rtw_tim_map_set(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
rtw_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0);
if (!pmlmeext->active_keep_alive_check)
continue;
}
}
{
int stainfo_offset;
stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
if (stainfo_offset_valid(stainfo_offset))
chk_alive_list[chk_alive_num++] = stainfo_offset;
continue;
}
} else {
/* TODO: Aging mechanism to digest frames in sleep_q to avoid running out of xmitframe */
if (psta->sleepq_len > (NR_XMITFRAME / pstapriv->asoc_list_cnt)
&& padapter->xmitpriv.free_xmitframe_cnt < ((NR_XMITFRAME / pstapriv->asoc_list_cnt) / 2)
) {
RTW_INFO(FUNC_ADPT_FMT" sta:"MAC_FMT", sleepq_len:%u, free_xmitframe_cnt:%u, asoc_list_cnt:%u, clear sleep_q\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(psta->phl_sta->mac_addr)
, psta->sleepq_len, padapter->xmitpriv.free_xmitframe_cnt, pstapriv->asoc_list_cnt);
wakeup_sta_to_xmit(padapter, psta);
}
}
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
if (chk_alive_num) {
#if defined(CONFIG_ACTIVE_KEEP_ALIVE_CHECK)
u8 backup_ch = 0, backup_bw = 0, backup_offset = 0;
u8 union_ch = 0, union_bw = 0, union_offset = 0;
u8 switch_channel_by_drv = _TRUE;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
#endif
char del_asoc_list[NUM_STA];
_rtw_memset(del_asoc_list, NUM_STA, NUM_STA);
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
if (pmlmeext->active_keep_alive_check) {
if (!rtw_mi_get_ch_setting_union(padapter, &union_ch, &union_bw, &union_offset)
|| pmlmeext->chandef.chan != union_ch)
switch_channel_by_drv = _FALSE;
/* switch to correct channel of current network before issue keep-alive frames */
if (switch_channel_by_drv == _TRUE && rtw_get_oper_ch(padapter) != pmlmeext->chandef.chan) {
backup_ch = rtw_get_oper_ch(padapter);
backup_bw = rtw_get_oper_bw(padapter);
backup_offset = rtw_get_oper_choffset(padapter);
set_channel_bwmode(padapter, union_ch, union_offset, union_bw, _FALSE);
}
}
#endif /* CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
/* check loop */
for (i = 0; i < chk_alive_num; i++) {
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
int ret = _FAIL;
#endif
psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
#ifdef CONFIG_ATMEL_RC_PATCH
if (_rtw_memcmp(pstapriv->atmel_rc_pattern, psta->phl_sta->mac_addr, ETH_ALEN) == _TRUE)
continue;
if (psta->flag_atmel_rc)
continue;
#endif
if (!(psta->state & WIFI_ASOC_STATE))
continue;
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
if (pmlmeext->active_keep_alive_check) {
/* issue active keep alive frame to check */
ret = issue_aka_chk_frame(padapter, psta);
psta->keep_alive_trycnt++;
if (ret == _SUCCESS) {
RTW_INFO(FUNC_ADPT_FMT" asoc check, "MAC_FMT" is alive\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(psta->phl_sta->mac_addr));
psta->expire_to = pstapriv->expire_to;
psta->keep_alive_trycnt = 0;
continue;
} else if (psta->keep_alive_trycnt <= 3) {
RTW_INFO(FUNC_ADPT_FMT" asoc check, "MAC_FMT" keep_alive_trycnt=%d\n"
, FUNC_ADPT_ARG(padapter) , MAC_ARG(psta->phl_sta->mac_addr), psta->keep_alive_trycnt);
psta->expire_to = 1;
continue;
}
}
#endif /* CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
psta->keep_alive_trycnt = 0;
del_asoc_list[i] = chk_alive_list[i];
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
rtw_list_delete(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (psta->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt--;
#endif
STA_SET_MESH_PLINK(psta, NULL);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
}
/* delete loop */
for (i = 0; i < chk_alive_num; i++) {
u8 sta_addr[ETH_ALEN];
if (del_asoc_list[i] >= NUM_STA)
continue;
psta = rtw_get_stainfo_by_offset(pstapriv, del_asoc_list[i]);
_rtw_memcpy(sta_addr, psta->phl_sta->mac_addr, ETH_ALEN);
RTW_INFO(FUNC_ADPT_FMT" asoc expire "MAC_FMT", state=0x%x\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(psta->phl_sta->mac_addr), psta->state);
updated |= ap_free_sta(padapter, psta, _FALSE, WLAN_REASON_DEAUTH_LEAVING, _FALSE, _FALSE);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter))
rtw_mesh_expire_peer(padapter, sta_addr);
#endif
}
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
if (pmlmeext->active_keep_alive_check) {
/* back to the original operation channel */
if (switch_channel_by_drv == _TRUE && backup_ch > 0)
set_channel_bwmode(padapter, backup_ch, backup_offset, backup_bw, _FALSE);
}
#endif
}
associated_clients_update(padapter, updated, STA_INFO_UPDATE_ALL);
}
#ifdef CONFIG_BMC_TX_RATE_SELECT
u8 rtw_ap_find_mini_tx_rate(_adapter *adapter)
{
_list *phead, *plist;
u8 mini_tx_rate = DESC_RATEVHTSS4MCS9, sta_tx_rate;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &adapter->stapriv;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
sta_tx_rate = psta->phl_sta->ra_info.curr_tx_rate & 0x7F;
if (sta_tx_rate < mini_tx_rate)
mini_tx_rate = sta_tx_rate;
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
return mini_tx_rate;
}
u8 rtw_ap_find_bmc_rate(_adapter *adapter, u8 tx_rate)
{
u8 tx_ini_rate = DESC_RATE6M;
switch (tx_rate) {
case DESC_RATEVHTSS3MCS9:
case DESC_RATEVHTSS3MCS8:
case DESC_RATEVHTSS3MCS7:
case DESC_RATEVHTSS3MCS6:
case DESC_RATEVHTSS3MCS5:
case DESC_RATEVHTSS3MCS4:
case DESC_RATEVHTSS3MCS3:
case DESC_RATEVHTSS2MCS9:
case DESC_RATEVHTSS2MCS8:
case DESC_RATEVHTSS2MCS7:
case DESC_RATEVHTSS2MCS6:
case DESC_RATEVHTSS2MCS5:
case DESC_RATEVHTSS2MCS4:
case DESC_RATEVHTSS2MCS3:
case DESC_RATEVHTSS1MCS9:
case DESC_RATEVHTSS1MCS8:
case DESC_RATEVHTSS1MCS7:
case DESC_RATEVHTSS1MCS6:
case DESC_RATEVHTSS1MCS5:
case DESC_RATEVHTSS1MCS4:
case DESC_RATEVHTSS1MCS3:
case DESC_RATEMCS15:
case DESC_RATEMCS14:
case DESC_RATEMCS13:
case DESC_RATEMCS12:
case DESC_RATEMCS11:
case DESC_RATEMCS7:
case DESC_RATEMCS6:
case DESC_RATEMCS5:
case DESC_RATEMCS4:
case DESC_RATEMCS3:
case DESC_RATE54M:
case DESC_RATE48M:
case DESC_RATE36M:
case DESC_RATE24M:
tx_ini_rate = DESC_RATE24M;
break;
case DESC_RATEVHTSS3MCS2:
case DESC_RATEVHTSS3MCS1:
case DESC_RATEVHTSS2MCS2:
case DESC_RATEVHTSS2MCS1:
case DESC_RATEVHTSS1MCS2:
case DESC_RATEVHTSS1MCS1:
case DESC_RATEMCS10:
case DESC_RATEMCS9:
case DESC_RATEMCS2:
case DESC_RATEMCS1:
case DESC_RATE18M:
case DESC_RATE12M:
tx_ini_rate = DESC_RATE12M;
break;
case DESC_RATEVHTSS3MCS0:
case DESC_RATEVHTSS2MCS0:
case DESC_RATEVHTSS1MCS0:
case DESC_RATEMCS8:
case DESC_RATEMCS0:
case DESC_RATE9M:
case DESC_RATE6M:
tx_ini_rate = DESC_RATE6M;
break;
case DESC_RATE11M:
case DESC_RATE5_5M:
case DESC_RATE2M:
case DESC_RATE1M:
tx_ini_rate = DESC_RATE1M;
break;
default:
tx_ini_rate = DESC_RATE6M;
break;
}
if (WIFI_ROLE_IS_ON_5G(adapter))
if (tx_ini_rate < DESC_RATE6M)
tx_ini_rate = DESC_RATE6M;
return tx_ini_rate;
}
void rtw_update_bmc_sta_tx_rate(_adapter *adapter)
{
struct sta_info *psta = NULL;
u8 tx_rate;
psta = rtw_get_bcmc_stainfo(adapter);
if (psta == NULL) {
RTW_ERR(ADPT_FMT "could not get bmc_sta !!\n", ADPT_ARG(adapter));
return;
}
if (adapter->bmc_tx_rate != MGN_UNKNOWN) {
psta->init_rate = adapter->bmc_tx_rate;
goto _exit;
}
if (adapter->stapriv.asoc_sta_count <= 2)
goto _exit;
tx_rate = rtw_ap_find_mini_tx_rate(adapter);
#ifdef CONFIG_BMC_TX_LOW_RATE
tx_rate = rtw_ap_find_bmc_rate(adapter, tx_rate);
#endif
psta->init_rate = hwrate_to_mrate(tx_rate);
_exit:
RTW_INFO(ADPT_FMT" BMC Tx rate - %s\n", ADPT_ARG(adapter), MGN_RATE_STR(psta->init_rate));
}
#endif
void rtw_init_bmc_sta_tx_rate(_adapter *padapter, struct sta_info *psta)
{
/* ToDo: need API to query hal_sta->ra_info.ramask */
#if 0
#ifdef CONFIG_BMC_TX_LOW_RATE
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
#endif
u8 rate_idx = 0;
u8 brate_table[] = {MGN_1M, MGN_2M, MGN_5_5M, MGN_11M,
MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M};
if (!MLME_IS_AP(padapter) && !MLME_IS_MESH(padapter))
return;
if (padapter->bmc_tx_rate != MGN_UNKNOWN)
psta->init_rate = padapter->bmc_tx_rate;
else {
#ifdef CONFIG_BMC_TX_LOW_RATE
if (IsEnableHWOFDM(pmlmeext->cur_wireless_mode) && (psta->phl_sta->ra_info.ramask && 0xFF0))
rate_idx = get_lowest_rate_idx_ex(psta->phl_sta->ra_info.ramask, 4); /*from basic rate*/
else
rate_idx = get_lowest_rate_idx(psta->phl_sta->ra_info.ramask); /*from basic rate*/
#else
rate_idx = get_highest_rate_idx(psta->phl_sta->ra_info.ramask); /*from basic rate*/
#endif
if (rate_idx < 12)
psta->init_rate = brate_table[rate_idx];
else
psta->init_rate = MGN_1M;
}
#endif
RTW_INFO(ADPT_FMT" BMC Init Tx rate - %s\n", ADPT_ARG(padapter), MGN_RATE_STR(psta->init_rate));
}
#if defined(CONFIG_80211N_HT) && defined(CONFIG_BEAMFORMING)
void update_sta_info_apmode_ht_bf_cap(_adapter *padapter, struct sta_info *psta)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
struct ht_priv *phtpriv_sta = &psta->htpriv;
u8 cur_beamform_cap = 0;
/*Config Tx beamforming setting*/
if (TEST_FLAG(phtpriv_ap->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP((u8 *)(&phtpriv_sta->ht_cap))) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
/*Shift to BEAMFORMING_HT_BEAMFORMEE_CHNL_EST_CAP*/
SET_FLAG(cur_beamform_cap, GET_HT_CAP_TXBF_CHNL_ESTIMATION_NUM_ANTENNAS((u8 *)(&phtpriv_sta->ht_cap)) << 6);
}
if (TEST_FLAG(phtpriv_ap->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP((u8 *)(&phtpriv_sta->ht_cap))) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
/*Shift to BEAMFORMING_HT_BEAMFORMER_STEER_NUM*/
SET_FLAG(cur_beamform_cap, GET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS((u8 *)(&phtpriv_sta->ht_cap)) << 4);
}
if (cur_beamform_cap)
RTW_INFO("Client STA(%d) HT Beamforming Cap = 0x%02X\n", psta->phl_sta->aid, cur_beamform_cap);
phtpriv_sta->beamform_cap = cur_beamform_cap;
}
#endif /*CONFIG_80211N_HT && CONFIG_BEAMFORMING*/
/* notes:
* AID: 1~MAX for sta and 0 for bc/mc in ap/adhoc mode */
void update_sta_info_apmode(_adapter *padapter, struct sta_info *psta)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *proto_role_cap = &(wrole->proto_role_cap);
#ifdef CONFIG_80211N_HT
struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
struct ht_priv *phtpriv_sta = &psta->htpriv;
#endif /* CONFIG_80211N_HT */
u8 cur_ldpc_cap = 0, cur_stbc_cap = 0;
/* set intf_tag to if1 */
/* psta->intf_tag = 0; */
RTW_INFO("%s\n", __FUNCTION__);
/*alloc macid when call rtw_alloc_stainfo(),release macid when call rtw_free_stainfo()*/
if (!MLME_IS_MESH(padapter) && psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
psta->ieee8021x_blocked = _TRUE;
else
psta->ieee8021x_blocked = _FALSE;
/* update sta's cap */
psta->phl_sta->chandef.chan = pmlmeext->chandef.chan;
psta->phl_sta->chandef.band = (psta->phl_sta->chandef.chan > 14) ? BAND_ON_5G : BAND_ON_24G;
/* ERP */
VCS_update(padapter, psta);
#ifdef CONFIG_80211N_HT
/* HT related cap */
if (phtpriv_sta->ht_option) {
/* check if sta supports rx ampdu */
phtpriv_sta->ampdu_enable = phtpriv_ap->ampdu_enable;
phtpriv_sta->rx_ampdu_min_spacing = (phtpriv_sta->ht_cap.ampdu_params_info & IEEE80211_HT_CAP_AMPDU_DENSITY) >> 2;
/* bwmode */
if ((phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH))
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_40;
else
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_20;
if (phtpriv_sta->op_present
&& !GET_HT_OP_ELE_STA_CHL_WIDTH(phtpriv_sta->ht_op))
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_20;
if (psta->ht_40mhz_intolerant)
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_20;
if (pmlmeext->chandef.bw < psta->phl_sta->chandef.bw)
psta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
phtpriv_sta->ch_offset = pmlmeext->chandef.offset;
/* check if sta support s Short GI 20M */
if ((phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20))
phtpriv_sta->sgi_20m = _TRUE;
/* check if sta support s Short GI 40M */
if ((phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40)) {
if (psta->phl_sta->chandef.bw == CHANNEL_WIDTH_40) /* according to psta->bw_mode */
phtpriv_sta->sgi_40m = _TRUE;
else
phtpriv_sta->sgi_40m = _FALSE;
}
psta->qos_option = _TRUE;
/* B0 Config LDPC Coding Capability */
if (TEST_FLAG(phtpriv_ap->ldpc_cap, LDPC_HT_ENABLE_TX) &&
GET_HT_CAP_ELE_LDPC_CAP((u8 *)(&phtpriv_sta->ht_cap))) {
SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX));
RTW_INFO("Enable HT Tx LDPC for STA(%d)\n", psta->phl_sta->aid);
}
/* B7 B8 B9 Config STBC setting */
if (TEST_FLAG(phtpriv_ap->stbc_cap, STBC_HT_ENABLE_TX) &&
GET_HT_CAP_ELE_RX_STBC((u8 *)(&phtpriv_sta->ht_cap))) {
SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX));
RTW_INFO("Enable HT Tx STBC for STA(%d)\n", psta->phl_sta->aid);
}
psta->phl_sta->asoc_cap.stbc_ht_tx =
GET_HT_CAP_ELE_TX_STBC((u8 *)(&phtpriv_sta->ht_cap));
psta->phl_sta->asoc_cap.stbc_ht_rx =
proto_role_cap->stbc_ht_tx ?
GET_HT_CAP_ELE_RX_STBC((u8 *)(&phtpriv_sta->ht_cap)) : 0;
#ifdef CONFIG_BEAMFORMING
update_sta_info_apmode_ht_bf_cap(padapter, psta);
#endif
} else {
phtpriv_sta->ampdu_enable = _FALSE;
phtpriv_sta->sgi_20m = _FALSE;
phtpriv_sta->sgi_40m = _FALSE;
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_20;
phtpriv_sta->ch_offset = CHAN_OFFSET_NO_EXT;
}
phtpriv_sta->ldpc_cap = cur_ldpc_cap;
phtpriv_sta->stbc_cap = cur_stbc_cap;
/* Rx AMPDU */
send_delba(padapter, 0, psta->phl_sta->mac_addr);/* recipient */
/* TX AMPDU */
send_delba(padapter, 1, psta->phl_sta->mac_addr);/* */ /* originator */
phtpriv_sta->agg_enable_bitmap = 0x0;/* reset */
phtpriv_sta->candidate_tid_bitmap = 0x0;/* reset */
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
update_sta_vht_info_apmode(padapter, psta);
#endif
#ifdef CONFIG_80211AX_HE
update_sta_he_info_apmode(padapter, psta);
#endif
psta->phl_sta->chandef.offset = (psta->phl_sta->chandef.bw > CHANNEL_WIDTH_20) ?
pmlmeext->chandef.offset : CHAN_OFFSET_NO_EXT;
/* ToDo: need API to inform hal_sta->ra_info.is_support_sgi */
/* psta->phl_sta->ra_info.is_support_sgi = query_ra_short_GI(psta, rtw_get_tx_bw_mode(padapter, psta)); */
update_ldpc_stbc_cap(psta);
/* todo: init other variables */
_rtw_memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats));
_rtw_spinlock_bh(&psta->lock);
/* Check encryption */
if (!MLME_IS_MESH(padapter) && psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
psta->state |= WIFI_UNDER_KEY_HANDSHAKE;
psta->state |= WIFI_ASOC_STATE;
_rtw_spinunlock_bh(&psta->lock);
}
static void update_ap_info(_adapter *padapter, struct sta_info *psta)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)&pmlmepriv->cur_network.network;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
#ifdef CONFIG_80211N_HT
struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter))
psta->qos_option = 1;
#endif
psta->phl_sta->wmode = pmlmeext->cur_wireless_mode;
psta->bssratelen = rtw_get_rateset_len(pnetwork->SupportedRates);
_rtw_memcpy(psta->bssrateset, pnetwork->SupportedRates, psta->bssratelen);
#ifdef CONFIG_80211N_HT
/* HT related cap */
if (phtpriv_ap->ht_option) {
/* check if sta supports rx ampdu */
/* phtpriv_ap->ampdu_enable = phtpriv_ap->ampdu_enable; */
/* check if sta support s Short GI 20M */
if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20))
phtpriv_ap->sgi_20m = _TRUE;
/* check if sta support s Short GI 40M */
if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40))
phtpriv_ap->sgi_40m = _TRUE;
psta->qos_option = _TRUE;
} else {
phtpriv_ap->ampdu_enable = _FALSE;
phtpriv_ap->sgi_20m = _FALSE;
phtpriv_ap->sgi_40m = _FALSE;
}
psta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
phtpriv_ap->ch_offset = pmlmeext->chandef.offset;
phtpriv_ap->agg_enable_bitmap = 0x0;/* reset */
phtpriv_ap->candidate_tid_bitmap = 0x0;/* reset */
_rtw_memcpy(&psta->htpriv, &pmlmepriv->htpriv, sizeof(struct ht_priv));
#ifdef CONFIG_80211AC_VHT
_rtw_memcpy(&psta->vhtpriv, &pmlmepriv->vhtpriv, sizeof(struct vht_priv));
#ifdef CONFIG_80211AX_HE
_rtw_memcpy(&psta->hepriv, &pmlmepriv->hepriv, sizeof(struct he_priv));
#endif /* CONFIG_80211AX_HE */
#endif /* CONFIG_80211AC_VHT */
#endif /* CONFIG_80211N_HT */
_rtw_spinlock_bh(&psta->lock);
psta->state |= WIFI_AP_STATE; /* Aries, add,fix bug of flush_cam_entry at STOP AP mode , 0724 */
psta->state |= WIFI_ASOC_STATE;
_rtw_spinunlock_bh(&psta->lock);
rtw_init_bmc_sta_tx_rate(padapter, psta);
}
void rtw_ap_set_edca(_adapter *padapter, enum rtw_ac ac, u32 parm)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta = rtw_get_stainfo(pstapriv, padapter->phl_role->mac_addr);
if (psta && psta->phl_sta) {
psta->phl_sta->asoc_cap.edca[ac].ac = ac;
psta->phl_sta->asoc_cap.edca[ac].param = parm;
}
rtw_hw_set_edca(padapter, ac, parm);
}
static void rtw_set_hw_wmm_param(_adapter *padapter)
{
u8 AIFS, ECWMin, ECWMax, aSifsTime;
u8 acm_mask;
u16 TXOP;
u32 acParm, i;
u32 edca[4], inx[4];
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
acm_mask = 0;
#ifdef CONFIG_80211N_HT
if (pregpriv->ht_enable &&
(WIFI_ROLE_IS_ON_5G(padapter) ||
(pmlmeext->cur_wireless_mode & WLAN_MD_11N)))
aSifsTime = 16;
else
#endif /* CONFIG_80211N_HT */
aSifsTime = 10;
if (pmlmeinfo->WMM_enable == 0) {
padapter->mlmepriv.acm_mask = 0;
AIFS = aSifsTime + (2 * pmlmeinfo->slotTime);
if (pmlmeext->cur_wireless_mode & (WLAN_MD_11G | WLAN_MD_11A)) {
ECWMin = 4;
ECWMax = 10;
} else if (pmlmeext->cur_wireless_mode & WLAN_MD_11B) {
ECWMin = 5;
ECWMax = 10;
} else {
ECWMin = 4;
ECWMax = 10;
}
TXOP = 0;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_ap_set_edca(padapter, 0, acParm);
rtw_ap_set_edca(padapter, 1, acParm);
rtw_ap_set_edca(padapter, 2, acParm);
ECWMin = 2;
ECWMax = 3;
TXOP = 0x2f;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_ap_set_edca(padapter, 3, acParm);
} else {
edca[0] = edca[1] = edca[2] = edca[3] = 0;
/*TODO:*/
acm_mask = 0;
padapter->mlmepriv.acm_mask = acm_mask;
#if 0
/* BK */
/* AIFS = AIFSN * slot time + SIFS - r2t phy delay */
#endif
AIFS = (7 * pmlmeinfo->slotTime) + aSifsTime;
ECWMin = 4;
ECWMax = 10;
TXOP = 0;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_ap_set_edca(padapter, 1, acParm);
edca[XMIT_BK_QUEUE] = acParm;
RTW_INFO("WMM(BK): %x\n", acParm);
/* BE */
AIFS = (3 * pmlmeinfo->slotTime) + aSifsTime;
ECWMin = 4;
ECWMax = 6;
TXOP = 0;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_ap_set_edca(padapter, 0, acParm);
edca[XMIT_BE_QUEUE] = acParm;
RTW_INFO("WMM(BE): %x\n", acParm);
/* VI */
AIFS = (1 * pmlmeinfo->slotTime) + aSifsTime;
ECWMin = 3;
ECWMax = 4;
TXOP = 94;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_ap_set_edca(padapter, 2, acParm);
edca[XMIT_VI_QUEUE] = acParm;
RTW_INFO("WMM(VI): %x\n", acParm);
/* VO */
AIFS = (1 * pmlmeinfo->slotTime) + aSifsTime;
ECWMin = 2;
ECWMax = 3;
TXOP = 47;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_ap_set_edca(padapter, 3, acParm);
edca[XMIT_VO_QUEUE] = acParm;
RTW_INFO("WMM(VO): %x\n", acParm);
if (padapter->registrypriv.acm_method == 1)
rtw_hal_set_hwreg(padapter, HW_VAR_ACM_CTRL, (u8 *)(&acm_mask));
else
padapter->mlmepriv.acm_mask = acm_mask;
inx[0] = 0;
inx[1] = 1;
inx[2] = 2;
inx[3] = 3;
if (pregpriv->wifi_spec == 1) {
u32 j, tmp, change_inx = _FALSE;
/* entry indx: 0->vo, 1->vi, 2->be, 3->bk. */
for (i = 0 ; i < 4 ; i++) {
for (j = i + 1 ; j < 4 ; j++) {
/* compare CW and AIFS */
if ((edca[j] & 0xFFFF) < (edca[i] & 0xFFFF))
change_inx = _TRUE;
else if ((edca[j] & 0xFFFF) == (edca[i] & 0xFFFF)) {
/* compare TXOP */
if ((edca[j] >> 16) > (edca[i] >> 16))
change_inx = _TRUE;
}
if (change_inx) {
tmp = edca[i];
edca[i] = edca[j];
edca[j] = tmp;
tmp = inx[i];
inx[i] = inx[j];
inx[j] = tmp;
change_inx = _FALSE;
}
}
}
}
for (i = 0 ; i < 4 ; i++) {
pxmitpriv->wmm_para_seq[i] = inx[i];
RTW_INFO("wmm_para_seq(%d): %d\n", i, pxmitpriv->wmm_para_seq[i]);
}
}
}
#ifdef CONFIG_80211N_HT
static void update_hw_ht_param(_adapter *padapter)
{
unsigned char max_AMPDU_len;
unsigned char min_MPDU_spacing;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
RTW_INFO("%s\n", __FUNCTION__);
/* handle A-MPDU parameter field */
/*
AMPDU_para [1:0]:Max AMPDU Len => 0:8k , 1:16k, 2:32k, 3:64k
AMPDU_para [4:2]:Min MPDU Start Spacing
*/
max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) >> 2;
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, (u8 *)(&min_MPDU_spacing));
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&max_AMPDU_len));
/* */
/* Config SM Power Save setting */
/* */
pmlmeinfo->SM_PS = (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & 0x0C) >> 2;
if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC) {
#if 0
u8 i;
/* update the MCS rates */
for (i = 0; i < 16; i++)
pmlmeinfo->HT_caps.HT_cap_element.MCS_rate[i] &= MCS_rate_1R[i];
#endif
RTW_INFO("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __FUNCTION__);
}
/* */
/* Config current HT Protection mode. */
/* */
/* pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3; */
}
#endif /* CONFIG_80211N_HT */
static void rtw_ap_check_scan(_adapter *padapter)
{
_list *plist, *phead;
u32 delta_time, lifetime;
struct wlan_network *pnetwork = NULL;
WLAN_BSSID_EX *pbss = NULL;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
_queue *queue = &(pmlmepriv->scanned_queue);
u8 do_scan = _FALSE;
u8 reason = RTW_AUTO_SCAN_REASON_UNSPECIFIED;
lifetime = SCANQUEUE_LIFETIME; /* 20 sec */
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
if (rtw_end_of_queue_search(phead, get_next(phead)) == _TRUE)
if (padapter->registrypriv.wifi_spec) {
do_scan = _TRUE;
reason |= RTW_AUTO_SCAN_REASON_2040_BSS;
}
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
#if defined(CONFIG_RTW_ACS) && defined(WKARD_ACS)
if (padapter->registrypriv.acs_auto_scan) {
do_scan = _TRUE;
reason |= RTW_AUTO_SCAN_REASON_ACS;
rtw_acs_start(padapter);
}
#endif/*CONFIG_RTW_ACS*/
if (_TRUE == do_scan) {
RTW_INFO("%s : drv scans by itself and wait_completed\n", __func__);
rtw_drv_scan_by_self(padapter, reason);
rtw_scan_abort(padapter, 0);
}
#if defined(CONFIG_RTW_ACS) && defined(WKARD_ACS)
if (padapter->registrypriv.acs_auto_scan)
rtw_acs_stop(padapter);
#endif
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
plist = get_next(phead);
while (1) {
if (rtw_end_of_queue_search(phead, plist) == _TRUE)
break;
pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
if (rtw_chset_search_ch(adapter_to_chset(padapter), pnetwork->network.Configuration.DSConfig) >= 0
&& rtw_mlme_band_check(padapter, pnetwork->network.Configuration.DSConfig) == _TRUE
&& _TRUE == rtw_validate_ssid(&(pnetwork->network.Ssid))) {
delta_time = (u32) rtw_get_passing_time_ms(pnetwork->last_scanned);
if (delta_time < lifetime) {
uint ie_len = 0;
u8 *pbuf = NULL;
u8 *ie = NULL;
pbss = &pnetwork->network;
ie = pbss->IEs;
/*check if HT CAP INFO IE exists or not*/
pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_CAPABILITY_IE_, &ie_len, (pbss->IELength - _BEACON_IE_OFFSET_));
if (pbuf == NULL) {
/* HT CAP INFO IE don't exist, it is b/g mode bss.*/
if (_FALSE == ATOMIC_READ(&pmlmepriv->olbc))
ATOMIC_SET(&pmlmepriv->olbc, _TRUE);
if (_FALSE == ATOMIC_READ(&pmlmepriv->olbc_ht))
ATOMIC_SET(&pmlmepriv->olbc_ht, _TRUE);
if (padapter->registrypriv.wifi_spec)
RTW_INFO("%s: %s is a/b/g ap\n", __func__, pnetwork->network.Ssid.Ssid);
}
}
}
plist = get_next(plist);
}
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
#ifdef CONFIG_80211N_HT
pmlmepriv->num_sta_no_ht = 0; /* reset to 0 after ap do scanning*/
#endif
}
void rtw_start_bss_hdl_after_chbw_decided(_adapter *adapter)
{
WLAN_BSSID_EX *pnetwork = &(adapter->mlmepriv.cur_network.network);
struct sta_info *sta = NULL;
/* update cur_wireless_mode */
update_wireless_mode(adapter);
/* update RRSR and RTS_INIT_RATE register after set channel and bandwidth */
UpdateBrateTbl(adapter, pnetwork->SupportedRates);
rtw_hal_set_hwreg(adapter, HW_VAR_BASIC_RATE, pnetwork->SupportedRates);
/* update capability after cur_wireless_mode updated */
update_capinfo(adapter, rtw_get_capability(pnetwork));
/* update AP's sta info */
sta = rtw_get_stainfo(&adapter->stapriv, pnetwork->MacAddress);
if (!sta) {
RTW_INFO(FUNC_ADPT_FMT" !sta for macaddr="MAC_FMT"\n", FUNC_ADPT_ARG(adapter), MAC_ARG(pnetwork->MacAddress));
rtw_warn_on(1);
return;
}
update_ap_info(adapter, sta);
}
static void _rtw_iface_undersurvey_chk(const char *func, _adapter *adapter)
{
int i;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct mlme_priv *pmlmepriv;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
pmlmepriv = &iface->mlmepriv;
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY))
RTW_ERR("%s ("ADPT_FMT") under survey\n", func, ADPT_ARG(iface));
}
}
}
void rtw_core_ap_swch_start(_adapter *padapter, struct createbss_parm *parm)
{
struct dvobj_priv *pdvobj = padapter->dvobj;
int i;
u8 ht_option = 0;
RTW_INFO("%s\n", __func__);
if (!IS_CH_WAITING(adapter_to_rfctl(padapter)))
parm->do_rfk = _TRUE;
if (parm->ch_to_set != 0) {
set_channel_bwmode(padapter, parm->ch_to_set, parm->offset_to_set, parm->bw_to_set, parm->do_rfk);
rtw_phl_mr_dump_cur_chandef(adapter_to_dvobj(padapter)->phl, padapter->phl_role);
}
#if defined(CONFIG_IOCTL_CFG80211) && (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
for (i = 0; i < pdvobj->iface_nums; i++) {
if (!(parm->ifbmp_ch_changed & BIT(i)) || !pdvobj->padapters[i])
continue;
#ifdef CONFIG_80211N_HT
ht_option = pdvobj->padapters[i]->mlmepriv.htpriv.ht_option;
#endif
rtw_cfg80211_ch_switch_notify(pdvobj->padapters[i]
, pdvobj->padapters[i]->mlmeextpriv.chandef.chan
, pdvobj->padapters[i]->mlmeextpriv.chandef.bw
, pdvobj->padapters[i]->mlmeextpriv.chandef.offset
, ht_option, 0);
}
#endif /* defined(CONFIG_IOCTL_CFG80211) && (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)) */
rtw_rfctl_update_op_mode(adapter_to_rfctl(padapter), parm->ifbmp, 1);
}
void rtw_core_ap_start(_adapter *padapter, struct createbss_parm *parm)
{
#define DUMP_ADAPTERS_STATUS 0
struct dvobj_priv *pdvobj = padapter->dvobj;
int i;
RTW_INFO("%s\n", __func__);
if (DUMP_ADAPTERS_STATUS) {
RTW_INFO(FUNC_ADPT_FMT" done\n", FUNC_ADPT_ARG(padapter));
dump_adapters_status(RTW_DBGDUMP , adapter_to_dvobj(padapter));
}
for (i = 0; i < pdvobj->iface_nums; i++) {
struct mlme_priv *mlme;
if (!(parm->ifbmp & BIT(i)) || !pdvobj->padapters[i])
continue;
/* update beacon content only if bstart_bss is _TRUE */
if (pdvobj->padapters[i]->mlmeextpriv.bstart_bss != _TRUE)
continue;
mlme = &(pdvobj->padapters[i]->mlmepriv);
#ifdef CONFIG_80211N_HT
if ((ATOMIC_READ(&mlme->olbc) == _TRUE) || (ATOMIC_READ(&mlme->olbc_ht) == _TRUE)) {
/* AP is not starting a 40 MHz BSS in presence of an 802.11g BSS. */
mlme->ht_op_mode &= (~HT_INFO_OPERATION_MODE_OP_MODE_MASK);
mlme->ht_op_mode |= OP_MODE_MAY_BE_LEGACY_STAS;
rtw_update_beacon(pdvobj->padapters[i], _HT_ADD_INFO_IE_, NULL, _FALSE, 0);
}
#endif
rtw_update_beacon(pdvobj->padapters[i], _TIM_IE_, NULL, _FALSE, 0);
}
/* after chanctx_add & before send bcn */
#ifndef CONFIG_AP_CMD_DISPR
rtw_hw_start_bss_network(padapter);
#endif
rtw_scan_abort(padapter, 0);
_rtw_iface_undersurvey_chk(__func__, padapter);
/* send beacon */
rtw_hal_set_hwreg(padapter, HW_VAR_RESUME_BCN, NULL);
{
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI) || defined(CONFIG_PCI_BCN_POLLING) || defined(CONFIG_HWSIM)
for (i = 0; i < pdvobj->iface_nums; i++) {
if (!(parm->ifbmp & BIT(i)) || !pdvobj->padapters[i])
continue;
if (send_beacon(pdvobj->padapters[i]) == _FAIL)
RTW_INFO(ADPT_FMT" issue_beacon, fail!\n", ADPT_ARG(pdvobj->padapters[i]));
}
#endif
}
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (MLME_IS_AP(padapter) && padapter->tbtx_capability == _TRUE) {
_set_timer(&pmlmeext->tbtx_token_dispatch_timer, 1);
RTW_INFO("Start token dispatch\n");
}
#endif
}
void start_bss_network(_adapter *padapter, struct createbss_parm *parm)
{
#define DUMP_ADAPTERS_STATUS 0
u8 mlme_act = MLME_ACTION_UNKNOWN;
u16 bcn_interval;
u32 acparm;
struct registry_priv *pregpriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct security_priv *psecuritypriv = &(padapter->securitypriv);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)&pmlmepriv->cur_network.network; /* used as input */
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork_mlmeext = &(pmlmeinfo->network);
struct dvobj_priv *pdvobj = padapter->dvobj;
s16 req_ch = REQ_CH_NONE, req_bw = REQ_BW_NONE, req_offset = REQ_OFFSET_NONE;
struct rtw_chan_def chdef_to_set = {0};
u8 do_rfk = _FALSE;
int i;
u8 ifbmp_ch_changed = 0;
#ifdef CONFIG_MCC_MODE
struct rtw_phl_com_t *phl_com = GET_PHL_COM(pdvobj);
u8 mcc_sup = phl_com->dev_cap.mcc_sup;
#endif
if (parm->req_ch != 0) {
/* bypass other setting, go checking ch, bw, offset */
mlme_act = MLME_OPCH_SWITCH;
req_ch = parm->req_ch;
req_bw = parm->req_bw;
req_offset = parm->req_offset;
goto chbw_decision;
} else {
/* request comes from upper layer */
if (MLME_IS_AP(padapter))
mlme_act = MLME_AP_STARTED;
else if (MLME_IS_MESH(padapter))
mlme_act = MLME_MESH_STARTED;
else
rtw_warn_on(1);
req_ch = 0;
_rtw_memcpy(pnetwork_mlmeext, pnetwork, pnetwork->Length);
}
bcn_interval = (u16)pnetwork->Configuration.BeaconPeriod;
pmlmeinfo->bcn_interval = bcn_interval;
/* check if there is wps ie, */
/* if there is wpsie in beacon, the hostapd will update beacon twice when stating hostapd, */
/* and at first time the security ie ( RSN/WPA IE) will not include in beacon. */
if (NULL == rtw_get_wps_ie(pnetwork->IEs + _FIXED_IE_LENGTH_, pnetwork->IELength - _FIXED_IE_LENGTH_, NULL, NULL))
pmlmeext->bstart_bss = _TRUE;
/* todo: update wmm, ht cap */
/* pmlmeinfo->WMM_enable; */
/* pmlmeinfo->HT_enable; */
if (pmlmepriv->qospriv.qos_option)
pmlmeinfo->WMM_enable = _TRUE;
#ifdef CONFIG_80211N_HT
if (pmlmepriv->htpriv.ht_option) {
pmlmeinfo->WMM_enable = _TRUE;
pmlmeinfo->HT_enable = _TRUE;
/* pmlmeinfo->HT_info_enable = _TRUE; */
/* pmlmeinfo->HT_caps_enable = _TRUE; */
update_hw_ht_param(padapter);
} else
pmlmeinfo->HT_enable = _FALSE;
#endif /* #CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
if (pmlmepriv->vhtpriv.vht_option) {
pmlmeinfo->VHT_enable = _TRUE;
update_hw_vht_param(padapter);
} else
pmlmeinfo->VHT_enable = _FALSE;
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
if (pmlmepriv->hepriv.he_option) {
pmlmeinfo->HE_enable = _TRUE;
update_hw_he_param(padapter);
} else
pmlmeinfo->HE_enable = _FALSE;
#endif /* CONFIG_80211AX_HE */
if (pmlmepriv->cur_network.join_res != _TRUE) { /* setting only at first time */
/* WEP Key will be set before this function, do not clear CAM. */
if ((psecuritypriv->dot11PrivacyAlgrthm != _WEP40_) && (psecuritypriv->dot11PrivacyAlgrthm != _WEP104_)
&& !MLME_IS_MESH(padapter) /* mesh group key is set before this function */
)
flush_all_cam_entry(padapter, PHL_CMD_DIRECTLY, 0); /* clear CAM */
}
#ifdef CONFIG_RTW_MULTI_AP
rtw_map_config_monitor(padapter, mlme_act);
#endif
chbw_decision:
ifbmp_ch_changed = rtw_ap_chbw_decision(padapter, parm->ifbmp, parm->excl_ifbmp
, req_ch, req_bw, req_offset, &chdef_to_set);
for (i = 0; i < pdvobj->iface_nums; i++) {
if (!(parm->ifbmp & BIT(i)) || !pdvobj->padapters[i])
continue;
/* let pnetwork_mlme == pnetwork_mlmeext */
_rtw_memcpy(&(pdvobj->padapters[i]->mlmepriv.cur_network.network)
, &(pdvobj->padapters[i]->mlmeextpriv.mlmext_info.network)
, pdvobj->padapters[i]->mlmeextpriv.mlmext_info.network.Length);
rtw_start_bss_hdl_after_chbw_decided(pdvobj->padapters[i]);
/* Set EDCA param reg after update cur_wireless_mode & update_capinfo */
if (pregpriv->wifi_spec == 1)
rtw_set_hw_wmm_param(pdvobj->padapters[i]);
}
#if defined(CONFIG_DFS_MASTER)
rtw_dfs_rd_en_decision(padapter, mlme_act, parm->excl_ifbmp);
#endif
{
u8 phl_uch = pmlmeext->chandef.chan;
enum channel_width phl_ubw = pmlmeext->chandef.bw;
enum chan_offset phl_uoffset = pmlmeext->chandef.offset;
bool is_chctx_add = false;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
is_chctx_add = rtw_phl_chanctx_add(dvobj->phl, padapter->phl_role,
&phl_uch, &phl_ubw, &phl_uoffset);
rtw_hw_update_chan_def(padapter);
rtw_mi_update_union_chan_inf(padapter, phl_uch, phl_uoffset, phl_ubw);
RTW_INFO("%s => chctx_add:%s\n", __func__, (is_chctx_add) ? "Y" : "N");
RTW_INFO("Core - CH:%d, BW:%d OFF:%d\n", chdef_to_set.chan, chdef_to_set.bw, chdef_to_set.offset);
RTW_INFO("PHL- CH:%d, BW:%d OFF:%d\n",phl_uch, phl_ubw, phl_uoffset);
}
parm->ifbmp_ch_changed = ifbmp_ch_changed;
parm->ch_to_set = chdef_to_set.chan;
parm->offset_to_set = chdef_to_set.offset;
parm->bw_to_set = chdef_to_set.bw;
parm->do_rfk = do_rfk;
}
int rtw_check_beacon_data(_adapter *padapter, u8 *pbuf, int len)
{
int ret = _SUCCESS;
u8 *p;
u8 *pHT_caps_ie = NULL;
u8 *pHT_info_ie = NULL;
u16 cap, ht_cap = _FALSE;
uint ie_len = 0;
int group_cipher, pairwise_cipher, gmcs;
u32 akm;
u8 mfp_opt = MFP_NO;
u8 channel, network_type;
u8 OUI1[] = {0x00, 0x50, 0xf2, 0x01};
u8 WMM_PARA_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
u8 WIFI_ALLIANCE_OUI[] = {0x50, 0x6f, 0x9a};
HT_CAP_AMPDU_DENSITY best_ampdu_density = 0;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
WLAN_BSSID_EX *pbss_network = (WLAN_BSSID_EX *)&pmlmepriv->cur_network.network;
u8 *ie = pbss_network->IEs;
u8 vht_cap = _FALSE;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
u8 rf_num = 0;
int ret_rm;
/* SSID */
/* Supported rates */
/* DS Params */
/* WLAN_EID_COUNTRY */
/* ERP Information element */
/* Extended supported rates */
/* WPA/WPA2 */
/* Radio Resource Management */
/* Wi-Fi Wireless Multimedia Extensions */
/* ht_capab, ht_oper */
/* WPS IE */
RTW_INFO("%s, len=%d\n", __FUNCTION__, len);
if (!MLME_IS_AP(padapter) && !MLME_IS_MESH(padapter))
return _FAIL;
if (len > MAX_IE_SZ)
return _FAIL;
pbss_network->IELength = len;
_rtw_memset(ie, 0, MAX_IE_SZ);
_rtw_memcpy(ie, pbuf, pbss_network->IELength);
if (pbss_network->InfrastructureMode != Ndis802_11APMode
&& pbss_network->InfrastructureMode != Ndis802_11_mesh
) {
rtw_warn_on(1);
return _FAIL;
}
rtw_ap_check_scan(padapter);
pbss_network->PhyInfo.rssi= 0;
_rtw_memcpy(pbss_network->MacAddress, adapter_mac_addr(padapter), ETH_ALEN);
/* beacon interval */
p = rtw_get_beacon_interval_from_ie(ie);/* ie + 8; */ /* 8: TimeStamp, 2: Beacon Interval 2:Capability */
/* pbss_network->Configuration.BeaconPeriod = le16_to_cpu(*(unsigned short*)p); */
pbss_network->Configuration.BeaconPeriod = RTW_GET_LE16(p);
/* capability */
p = rtw_get_capability_from_ie(ie);
cap = RTW_GET_LE16(p);
/* SSID */
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _SSID_IE_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0) {
_rtw_memset(&pbss_network->Ssid, 0, sizeof(NDIS_802_11_SSID));
_rtw_memcpy(pbss_network->Ssid.Ssid, (p + 2), ie_len);
pbss_network->Ssid.SsidLength = ie_len;
}
#ifdef CONFIG_RTW_MESH
/* Mesh ID */
if (MLME_IS_MESH(padapter)) {
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, WLAN_EID_MESH_ID, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0) {
_rtw_memset(&pbss_network->mesh_id, 0, sizeof(NDIS_802_11_SSID));
_rtw_memcpy(pbss_network->mesh_id.Ssid, (p + 2), ie_len);
pbss_network->mesh_id.SsidLength = ie_len;
}
}
#endif
/* Parsing extended capabilities IE */
rtw_parse_ext_cap_ie(pmlmepriv->ext_capab_ie_data, &(pmlmepriv->ext_capab_ie_len), ie \
, pbss_network->IELength, _BEACON_IE_OFFSET_);
/* chnnel */
channel = 0;
pbss_network->Configuration.Length = 0;
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _DSSET_IE_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0)
channel = *(p + 2);
pbss_network->Configuration.DSConfig = channel;
/* support rate ie & ext support ie & IElen & SupportedRates */
network_type = rtw_update_rate_bymode(pbss_network, pregistrypriv->wireless_mode);
/* parsing ERP_IE */
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _ERPINFO_IE_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0) {
if(padapter->registrypriv.wireless_mode == WLAN_MD_11B) {
pbss_network->IELength = pbss_network->IELength - *(p+1) - 2;
ret_rm = rtw_ies_remove_ie(ie , &len, _BEACON_IE_OFFSET_, _ERPINFO_IE_,NULL,0);
RTW_DBG("%s, remove_ie of ERP_IE=%d\n", __FUNCTION__, ret_rm);
} else
ERP_IE_handler(padapter, (PNDIS_802_11_VARIABLE_IEs)p);
}
/* update privacy/security */
if (cap & BIT(4))
pbss_network->Privacy = 1;
else
pbss_network->Privacy = 0;
psecuritypriv->wpa_psk = 0;
/* wpa2 */
akm = 0;
gmcs = 0;
group_cipher = 0;
pairwise_cipher = 0;
psecuritypriv->wpa2_group_cipher = _NO_PRIVACY_;
psecuritypriv->wpa2_pairwise_cipher = _NO_PRIVACY_;
psecuritypriv->akmp = 0;
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _RSN_IE_2_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0) {
if (rtw_parse_wpa2_ie(p, ie_len + 2, &group_cipher, &pairwise_cipher, &gmcs, &akm, &mfp_opt, NULL) == _SUCCESS) {
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPA2PSK;
psecuritypriv->dot8021xalg = 1;/* psk, todo:802.1x */
psecuritypriv->wpa_psk |= BIT(1);
psecuritypriv->wpa2_group_cipher = group_cipher;
psecuritypriv->wpa2_pairwise_cipher = pairwise_cipher;
psecuritypriv->akmp = akm;
#ifdef CONFIG_IOCTL_CFG80211
/**
* Kernel < v5.x, the auth_type set as
* NL80211_AUTHTYPE_AUTOMATIC in
* cfg80211_rtw_start_ap(). if the AKM SAE in the RSN
* IE, we have to update the auth_type for SAE in
* rtw_check_beacon_data()
*/
if (CHECK_BIT(WLAN_AKM_TYPE_SAE, akm)) {
RTW_INFO("%s: Auth type as SAE\n", __func__);
psecuritypriv->auth_type = MLME_AUTHTYPE_SAE;
psecuritypriv->auth_alg = WLAN_AUTH_SAE;
}
#endif /* CONFIG_IOCTL_CFG80211 */
#if 0
switch (group_cipher) {
case WPA_CIPHER_NONE:
psecuritypriv->wpa2_group_cipher = _NO_PRIVACY_;
break;
case WPA_CIPHER_WEP40:
psecuritypriv->wpa2_group_cipher = _WEP40_;
break;
case WPA_CIPHER_TKIP:
psecuritypriv->wpa2_group_cipher = _TKIP_;
break;
case WPA_CIPHER_CCMP:
psecuritypriv->wpa2_group_cipher = _AES_;
break;
case WPA_CIPHER_WEP104:
psecuritypriv->wpa2_group_cipher = _WEP104_;
break;
}
switch (pairwise_cipher) {
case WPA_CIPHER_NONE:
psecuritypriv->wpa2_pairwise_cipher = _NO_PRIVACY_;
break;
case WPA_CIPHER_WEP40:
psecuritypriv->wpa2_pairwise_cipher = _WEP40_;
break;
case WPA_CIPHER_TKIP:
psecuritypriv->wpa2_pairwise_cipher = _TKIP_;
break;
case WPA_CIPHER_CCMP:
psecuritypriv->wpa2_pairwise_cipher = _AES_;
break;
case WPA_CIPHER_WEP104:
psecuritypriv->wpa2_pairwise_cipher = _WEP104_;
break;
}
#endif
}
}
/* wpa */
ie_len = 0;
group_cipher = 0;
pairwise_cipher = 0;
psecuritypriv->wpa_group_cipher = _NO_PRIVACY_;
psecuritypriv->wpa_pairwise_cipher = _NO_PRIVACY_;
for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) {
p = rtw_get_ie(p, _SSN_IE_1_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)));
if ((p) && (_rtw_memcmp(p + 2, OUI1, 4))) {
if (rtw_parse_wpa_ie(p, ie_len + 2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPAPSK;
psecuritypriv->dot8021xalg = 1;/* psk, todo:802.1x */
psecuritypriv->wpa_psk |= BIT(0);
psecuritypriv->wpa_group_cipher = group_cipher;
psecuritypriv->wpa_pairwise_cipher = pairwise_cipher;
#if 0
switch (group_cipher) {
case WPA_CIPHER_NONE:
psecuritypriv->wpa_group_cipher = _NO_PRIVACY_;
break;
case WPA_CIPHER_WEP40:
psecuritypriv->wpa_group_cipher = _WEP40_;
break;
case WPA_CIPHER_TKIP:
psecuritypriv->wpa_group_cipher = _TKIP_;
break;
case WPA_CIPHER_CCMP:
psecuritypriv->wpa_group_cipher = _AES_;
break;
case WPA_CIPHER_WEP104:
psecuritypriv->wpa_group_cipher = _WEP104_;
break;
}
switch (pairwise_cipher) {
case WPA_CIPHER_NONE:
psecuritypriv->wpa_pairwise_cipher = _NO_PRIVACY_;
break;
case WPA_CIPHER_WEP40:
psecuritypriv->wpa_pairwise_cipher = _WEP40_;
break;
case WPA_CIPHER_TKIP:
psecuritypriv->wpa_pairwise_cipher = _TKIP_;
break;
case WPA_CIPHER_CCMP:
psecuritypriv->wpa_pairwise_cipher = _AES_;
break;
case WPA_CIPHER_WEP104:
psecuritypriv->wpa_pairwise_cipher = _WEP104_;
break;
}
#endif
}
break;
}
if ((p == NULL) || (ie_len == 0))
break;
}
if (mfp_opt == MFP_INVALID) {
RTW_INFO(FUNC_ADPT_FMT" invalid MFP setting\n", FUNC_ADPT_ARG(padapter));
return _FAIL;
}
psecuritypriv->mfp_opt = mfp_opt;
/* RRM */
update_rm_cap(pbuf, padapter, len, _BEACON_IE_OFFSET_);
/* wmm */
ie_len = 0;
pmlmepriv->qospriv.qos_option = 0;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter))
pmlmepriv->qospriv.qos_option = 1;
#endif
if (pregistrypriv->wmm_enable) {
for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) {
p = rtw_get_ie(p, _VENDOR_SPECIFIC_IE_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)));
if ((p) && _rtw_memcmp(p + 2, WMM_PARA_IE, 6)) {
pmlmepriv->qospriv.qos_option = 1;
*(p + 8) |= BIT(7); /* QoS Info, support U-APSD */
/* disable all ACM bits since the WMM admission control is not supported */
*(p + 10) &= ~BIT(4); /* BE */
*(p + 14) &= ~BIT(4); /* BK */
*(p + 18) &= ~BIT(4); /* VI */
*(p + 22) &= ~BIT(4); /* VO */
WMM_param_handler(padapter, (PNDIS_802_11_VARIABLE_IEs)p);
break;
}
if ((p == NULL) || (ie_len == 0))
break;
}
}
#ifdef CONFIG_80211N_HT
if(padapter->registrypriv.ht_enable &&
is_supported_ht(padapter->registrypriv.wireless_mode)) {
/* parsing HT_CAP_IE */
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_CAPABILITY_IE_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0) {
HT_CAP_AMPDU_FACTOR max_rx_ampdu_factor = MAX_AMPDU_FACTOR_64K;
struct rtw_ieee80211_ht_cap *pht_cap = (struct rtw_ieee80211_ht_cap *)(p + 2);
if (0) {
RTW_INFO(FUNC_ADPT_FMT" HT_CAP_IE from upper layer:\n", FUNC_ADPT_ARG(padapter));
dump_ht_cap_ie_content(RTW_DBGDUMP, p + 2, ie_len);
}
pHT_caps_ie = p;
ht_cap = _TRUE;
network_type |= WLAN_MD_11N;
rtw_ht_use_default_setting(padapter);
/* Update HT Capabilities Info field */
if (pmlmepriv->htpriv.sgi_20m == _FALSE)
pht_cap->cap_info &= ~(IEEE80211_HT_CAP_SGI_20);
if (pmlmepriv->htpriv.sgi_40m == _FALSE)
pht_cap->cap_info &= ~(IEEE80211_HT_CAP_SGI_40);
if (!TEST_FLAG(pmlmepriv->htpriv.ldpc_cap, LDPC_HT_ENABLE_RX))
pht_cap->cap_info &= ~(IEEE80211_HT_CAP_LDPC_CODING);
if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_TX))
pht_cap->cap_info &= ~(IEEE80211_HT_CAP_TX_STBC);
if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_RX))
pht_cap->cap_info &= ~(IEEE80211_HT_CAP_RX_STBC_3R);
/* Update A-MPDU Parameters field */
pht_cap->ampdu_params_info &= ~(IEEE80211_HT_CAP_AMPDU_FACTOR | IEEE80211_HT_CAP_AMPDU_DENSITY);
if ((psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_CCMP) ||
(psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_CCMP)) {
rtw_hal_get_def_var(padapter, HW_VAR_BEST_AMPDU_DENSITY, &best_ampdu_density);
pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & (best_ampdu_density << 2));
} else
pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00);
rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor);
pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_FACTOR & max_rx_ampdu_factor); /* set Max Rx AMPDU size to 64K */
_rtw_memcpy(&(pmlmeinfo->HT_caps), pht_cap, sizeof(struct HT_caps_element));
/* Update Supported MCS Set field */
{
u8 rx_nss = 0;
int i;
rx_nss = GET_HAL_RX_NSS(adapter_to_dvobj(padapter));
/* RX MCS Bitmask */
switch (rx_nss) {
case 1:
set_mcs_rate_by_mask(HT_CAP_ELE_RX_MCS_MAP(pht_cap), MCS_RATE_1R);
break;
case 2:
set_mcs_rate_by_mask(HT_CAP_ELE_RX_MCS_MAP(pht_cap), MCS_RATE_2R);
break;
case 3:
set_mcs_rate_by_mask(HT_CAP_ELE_RX_MCS_MAP(pht_cap), MCS_RATE_3R);
break;
case 4:
set_mcs_rate_by_mask(HT_CAP_ELE_RX_MCS_MAP(pht_cap), MCS_RATE_4R);
break;
default:
RTW_WARN("rf_type:%d or rx_nss:%u is not expected\n",
GET_HAL_RFPATH(adapter_to_dvobj(padapter)), rx_nss);
}
for (i = 0; i < 10; i++)
*(HT_CAP_ELE_RX_MCS_MAP(pht_cap) + i) &= padapter->mlmeextpriv.default_supported_mcs_set[i];
}
#ifdef CONFIG_BEAMFORMING
/* Use registry value to enable HT Beamforming. */
/* ToDo: use configure file to set these capability. */
pht_cap->tx_BF_cap_info = 0;
/* HT Beamformer */
if (TEST_FLAG(pmlmepriv->htpriv.beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE)) {
/* Transmit NDP Capable */
SET_HT_CAP_TXBF_TRANSMIT_NDP_CAP(pht_cap, 1);
/* Explicit Compressed Steering Capable */
SET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP(pht_cap, 1);
/* Compressed Steering Number Antennas */
SET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(pht_cap, 1);
rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMER_CAP, (u8 *)&rf_num);
if (rf_num > 3)
rf_num = 3;
SET_HT_CAP_TXBF_CHNL_ESTIMATION_NUM_ANTENNAS(pht_cap, rf_num);
}
/* HT Beamformee */
if (TEST_FLAG(pmlmepriv->htpriv.beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE)) {
/* Receive NDP Capable */
SET_HT_CAP_TXBF_RECEIVE_NDP_CAP(pht_cap, 1);
/* Explicit Compressed Beamforming Feedback Capable */
SET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP(pht_cap, 2);
rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMEE_CAP, (u8 *)&rf_num);
if (rf_num > 3)
rf_num = 3;
SET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(pht_cap, rf_num);
}
#endif /* CONFIG_BEAMFORMING */
_rtw_memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len);
if (0) {
RTW_INFO(FUNC_ADPT_FMT" HT_CAP_IE driver masked:\n", FUNC_ADPT_ARG(padapter));
dump_ht_cap_ie_content(RTW_DBGDUMP, p + 2, ie_len);
}
}
/* parsing HT_INFO_IE */
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_ADD_INFO_IE_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0) {
pHT_info_ie = p;
if (channel == 0)
pbss_network->Configuration.DSConfig = GET_HT_OP_ELE_PRI_CHL(pHT_info_ie + 2);
else if (channel != GET_HT_OP_ELE_PRI_CHL(pHT_info_ie + 2)) {
RTW_INFO(FUNC_ADPT_FMT" ch inconsistent, DSSS:%u, HT primary:%u\n"
, FUNC_ADPT_ARG(padapter), channel, GET_HT_OP_ELE_PRI_CHL(pHT_info_ie + 2));
}
}
}
#endif /* CONFIG_80211N_HT */
pmlmepriv->cur_network.network_type = network_type;
#ifdef CONFIG_80211N_HT
pmlmepriv->htpriv.ht_option = _FALSE;
if ((psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) ||
(psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_TKIP)) {
/* todo: */
/* ht_cap = _FALSE; */
}
/* ht_cap */
if (padapter->registrypriv.ht_enable &&
is_supported_ht(padapter->registrypriv.wireless_mode) && ht_cap == _TRUE) {
pmlmepriv->htpriv.ht_option = _TRUE;
pmlmepriv->qospriv.qos_option = 1;
pmlmepriv->htpriv.ampdu_enable = pregistrypriv->ampdu_enable ? _TRUE : _FALSE;
HT_caps_handler(padapter, (PNDIS_802_11_VARIABLE_IEs)pHT_caps_ie);
HT_info_handler(padapter, (PNDIS_802_11_VARIABLE_IEs)pHT_info_ie);
}
#endif
#ifdef CONFIG_80211AC_VHT
pmlmepriv->vhtpriv.upper_layer_setting = _FALSE;
pmlmepriv->vhtpriv.vht_option = _FALSE;
if (pmlmepriv->htpriv.ht_option == _TRUE
&& pbss_network->Configuration.DSConfig > 14
&& REGSTY_IS_11AC_ENABLE(pregistrypriv)
&& is_supported_vht(pregistrypriv->wireless_mode)
&& RFCTL_REG_EN_11AC(rfctl)
) {
/* Parsing VHT_CAP_IE */
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, EID_VHTCapability,
&ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0)
vht_cap = _TRUE;
else
RTW_INFO(FUNC_ADPT_FMT" No vht_capability_ie from hostapd/wpa_supplicant\n", FUNC_ADPT_ARG(padapter));
/* Update VHT related IEs */
if (vht_cap == _TRUE) {
RTW_INFO(FUNC_ADPT_FMT" VHT IEs is configured by hostapd/wpa_supplicant\n", FUNC_ADPT_ARG(padapter));
pmlmepriv->vhtpriv.upper_layer_setting = _TRUE;
pmlmepriv->vhtpriv.vht_option = _TRUE;
rtw_check_for_vht20(padapter, ie + _BEACON_IE_OFFSET_,
pbss_network->IELength - _BEACON_IE_OFFSET_);
rtw_check_vht_ies(padapter, pbss_network);
} else if (REGSTY_IS_11AC_AUTO(pregistrypriv)) {
rtw_vht_ies_detach(padapter, pbss_network);
rtw_vht_ies_attach(padapter, pbss_network);
}
}
if (pmlmepriv->vhtpriv.vht_option == _FALSE)
rtw_vht_ies_detach(padapter, pbss_network);
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
pmlmepriv->hepriv.he_option = _FALSE;
/* An HE STA is also a VHT STA if operating in the 5 GHz band */
/* An HE STA is also a HT STA in the 2GHz band */
if (REGSTY_IS_11AX_ENABLE(pregistrypriv)
&& is_supported_he(pregistrypriv->wireless_mode)
&& RFCTL_REG_EN_11AX(rfctl)
&& ((channel > 14 && pmlmepriv->vhtpriv.vht_option == _TRUE) ||
(channel <= 14 && pmlmepriv->htpriv.ht_option == _TRUE))
) {
u8 he_cap = _FALSE;
u8 he_cap_eid_ext = WLAN_EID_EXTENSION_HE_CAPABILITY;
p = rtw_get_ie_ex(ie + _BEACON_IE_OFFSET_, pbss_network->IELength - _BEACON_IE_OFFSET_,
WLAN_EID_EXTENSION, &he_cap_eid_ext, 1, NULL, &ie_len);
if (p && ie_len > 0)
he_cap = _TRUE;
/* If He capability is in beacon IE, enable he_option */
pmlmepriv->hepriv.he_option = he_cap;
rtw_he_use_default_setting(padapter);
if (REGSTY_IS_11AX_AUTO(pregistrypriv)) {
rtw_he_ies_detach(padapter, pbss_network);
rtw_he_ies_attach(padapter, pbss_network);
}
}
if (pmlmepriv->hepriv.he_option == _FALSE)
rtw_he_ies_detach(padapter, pbss_network);
#endif
#ifdef CONFIG_80211N_HT
if(padapter->registrypriv.ht_enable &&
is_supported_ht(padapter->registrypriv.wireless_mode) &&
pbss_network->Configuration.DSConfig <= 14 /*&& padapter->registrypriv.wifi_spec == 1*/) {
#ifdef CONFIG_RTW_WNM
rtw_wnm_add_btm_ext_cap(pmlmepriv->ext_capab_ie_data,
&(pmlmepriv->ext_capab_ie_len));
#endif
#ifdef CONFIG_RTW_MBO
rtw_mbo_add_internw_ext_cap(pmlmepriv->ext_capab_ie_data,
&(pmlmepriv->ext_capab_ie_len));
#endif
rtw_add_ext_cap_info(pmlmepriv->ext_capab_ie_data, &(pmlmepriv->ext_capab_ie_len), BSS_COEXT);
rtw_update_ext_cap_ie(pmlmepriv->ext_capab_ie_data, pmlmepriv->ext_capab_ie_len, pbss_network->IEs, \
&(pbss_network->IELength), _BEACON_IE_OFFSET_);
}
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_RTW_80211K
padapter->rmpriv.enable = _FALSE;
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, EID_RMEnabledCapability, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len) {
RTW_INFO("[%s]Get EID_RMEnabledCapability, len = %d\n", __func__, ie_len);
padapter->rmpriv.enable = _TRUE;
_rtw_memcpy(padapter->rmpriv.rm_en_cap_def, p + 2, ie_len);
}
#endif /* CONFIG_RTW_80211K */
#ifdef CONFIG_RTW_MBO
ie_len = 0;
pmlmepriv->mbopriv.enable = _FALSE;
for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) {
p = rtw_get_ie(p, _SSN_IE_1_, &ie_len, (pbss_network->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)));
if ((p) && (_rtw_memcmp(p + 2, WIFI_ALLIANCE_OUI, 3)) && (*(p+5) == MBO_OUI_TYPE)) {
/* find MBO-OCE information element */
pmlmepriv->mbopriv.enable = _TRUE;
rtw_mbo_ie_handler(padapter, &pmlmepriv->mbopriv, p + 6, ie_len - 4);
break;
}
if ((p == NULL) || (ie_len == 0))
break;
}
#endif /* CONFIG_RTW_MBO */
pbss_network->Length = get_WLAN_BSSID_EX_sz((WLAN_BSSID_EX *)pbss_network);
rtw_ies_get_chbw(pbss_network->IEs + _BEACON_IE_OFFSET_, pbss_network->IELength - _BEACON_IE_OFFSET_
, &pmlmepriv->ori_chandef.chan, (u8 *)&pmlmepriv->ori_chandef.bw, (u8 *)&pmlmepriv->ori_chandef.offset, 1, 1);
rtw_warn_on(pmlmepriv->ori_chandef.chan == 0);
ret = rtw_startbss_cmd(padapter, RTW_CMDF_WAIT_ACK);
{
int sk_band = RTW_GET_SCAN_BAND_SKIP(padapter);
if (sk_band)
RTW_CLR_SCAN_BAND_SKIP(padapter, sk_band);
}
if (ret) {
rtw_indicate_connect(padapter);
pmlmepriv->cur_network.join_res = _TRUE;/* for check if already set beacon */
}
return ret;
}
#if CONFIG_RTW_MACADDR_ACL
void rtw_macaddr_acl_init(_adapter *adapter, u8 period)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct wlan_acl_pool *acl;
_queue *acl_node_q;
int i;
if (period >= RTW_ACL_PERIOD_NUM) {
rtw_warn_on(1);
return;
}
acl = &stapriv->acl_list[period];
acl_node_q = &acl->acl_node_q;
_rtw_spinlock_init(&(acl_node_q->lock));
_rtw_spinlock_bh(&(acl_node_q->lock));
_rtw_init_listhead(&(acl_node_q->queue));
acl->num = 0;
acl->mode = RTW_ACL_MODE_DISABLED;
for (i = 0; i < NUM_ACL; i++) {
_rtw_init_listhead(&acl->aclnode[i].list);
acl->aclnode[i].valid = _FALSE;
}
_rtw_spinunlock_bh(&(acl_node_q->lock));
}
static void _rtw_macaddr_acl_deinit(_adapter *adapter, u8 period, bool clear_only)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct wlan_acl_pool *acl;
_queue *acl_node_q;
_list *head, *list;
struct rtw_wlan_acl_node *acl_node;
if (period >= RTW_ACL_PERIOD_NUM) {
rtw_warn_on(1);
return;
}
acl = &stapriv->acl_list[period];
acl_node_q = &acl->acl_node_q;
_rtw_spinlock_bh(&(acl_node_q->lock));
head = get_list_head(acl_node_q);
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
acl_node = LIST_CONTAINOR(list, struct rtw_wlan_acl_node, list);
list = get_next(list);
if (acl_node->valid == _TRUE) {
acl_node->valid = _FALSE;
rtw_list_delete(&acl_node->list);
acl->num--;
}
}
_rtw_spinunlock_bh(&(acl_node_q->lock));
if (!clear_only)
_rtw_spinlock_free(&(acl_node_q->lock));
rtw_warn_on(acl->num);
acl->mode = RTW_ACL_MODE_DISABLED;
}
void rtw_macaddr_acl_deinit(_adapter *adapter, u8 period)
{
_rtw_macaddr_acl_deinit(adapter, period, 0);
}
void rtw_macaddr_acl_clear(_adapter *adapter, u8 period)
{
_rtw_macaddr_acl_deinit(adapter, period, 1);
}
void rtw_set_macaddr_acl(_adapter *adapter, u8 period, int mode)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct wlan_acl_pool *acl;
if (period >= RTW_ACL_PERIOD_NUM) {
rtw_warn_on(1);
return;
}
acl = &stapriv->acl_list[period];
RTW_INFO(FUNC_ADPT_FMT" p=%u, mode=%d\n"
, FUNC_ADPT_ARG(adapter), period, mode);
acl->mode = mode;
}
int rtw_acl_add_sta(_adapter *adapter, u8 period, const u8 *addr)
{
_list *list, *head;
u8 existed = 0;
int i = -1, ret = 0;
struct rtw_wlan_acl_node *acl_node;
struct sta_priv *stapriv = &adapter->stapriv;
struct wlan_acl_pool *acl;
_queue *acl_node_q;
if (period >= RTW_ACL_PERIOD_NUM) {
rtw_warn_on(1);
ret = -1;
goto exit;
}
acl = &stapriv->acl_list[period];
acl_node_q = &acl->acl_node_q;
_rtw_spinlock_bh(&(acl_node_q->lock));
head = get_list_head(acl_node_q);
list = get_next(head);
/* search for existed entry */
while (rtw_end_of_queue_search(head, list) == _FALSE) {
acl_node = LIST_CONTAINOR(list, struct rtw_wlan_acl_node, list);
list = get_next(list);
if (_rtw_memcmp(acl_node->addr, addr, ETH_ALEN)) {
if (acl_node->valid == _TRUE) {
existed = 1;
break;
}
}
}
if (existed)
goto release_lock;
if (acl->num >= NUM_ACL)
goto release_lock;
/* find empty one and use */
for (i = 0; i < NUM_ACL; i++) {
acl_node = &acl->aclnode[i];
if (acl_node->valid == _FALSE) {
_rtw_init_listhead(&acl_node->list);
_rtw_memcpy(acl_node->addr, addr, ETH_ALEN);
acl_node->valid = _TRUE;
rtw_list_insert_tail(&acl_node->list, get_list_head(acl_node_q));
acl->num++;
break;
}
}
release_lock:
_rtw_spinunlock_bh(&(acl_node_q->lock));
if (!existed && (i < 0 || i >= NUM_ACL))
ret = -1;
RTW_INFO(FUNC_ADPT_FMT" p=%u "MAC_FMT" %s (acl_num=%d)\n"
, FUNC_ADPT_ARG(adapter), period, MAC_ARG(addr)
, (existed ? "existed" : ((i < 0 || i >= NUM_ACL) ? "no room" : "added"))
, acl->num);
exit:
return ret;
}
int rtw_acl_remove_sta(_adapter *adapter, u8 period, const u8 *addr)
{
_list *list, *head;
int ret = 0;
struct rtw_wlan_acl_node *acl_node;
struct sta_priv *stapriv = &adapter->stapriv;
struct wlan_acl_pool *acl;
_queue *acl_node_q;
u8 is_baddr = is_broadcast_mac_addr(addr);
u8 match = 0;
if (period >= RTW_ACL_PERIOD_NUM) {
rtw_warn_on(1);
goto exit;
}
acl = &stapriv->acl_list[period];
acl_node_q = &acl->acl_node_q;
_rtw_spinlock_bh(&(acl_node_q->lock));
head = get_list_head(acl_node_q);
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
acl_node = LIST_CONTAINOR(list, struct rtw_wlan_acl_node, list);
list = get_next(list);
if (is_baddr || _rtw_memcmp(acl_node->addr, addr, ETH_ALEN)) {
if (acl_node->valid == _TRUE) {
acl_node->valid = _FALSE;
rtw_list_delete(&acl_node->list);
acl->num--;
match = 1;
}
}
}
_rtw_spinunlock_bh(&(acl_node_q->lock));
RTW_INFO(FUNC_ADPT_FMT" p=%u "MAC_FMT" %s (acl_num=%d)\n"
, FUNC_ADPT_ARG(adapter), period, MAC_ARG(addr)
, is_baddr ? "clear all" : (match ? "match" : "no found")
, acl->num);
exit:
return ret;
}
#endif /* CONFIG_RTW_MACADDR_ACL */
#ifdef CONFIG_CMD_DISP
u8 rtw_ap_set_sta_key(_adapter *adapter, const u8 *addr, u8 alg, const u8 *key, u8 keyid, u8 gk)
{
struct set_stakey_parm param;
u8 res = _SUCCESS;
_rtw_memcpy(param.addr, addr, ETH_ALEN);
param.algorithm = alg;
param.keyid = keyid;
if (!!(alg & _SEC_TYPE_256_))
_rtw_memcpy(param.key, key, 32);
else
_rtw_memcpy(param.key, key, 16);
param.gk = gk;
set_stakey_hdl(adapter, ¶m, PHL_CMD_NO_WAIT, 0);
exit:
return res;
}
u8 rtw_ap_set_pairwise_key(_adapter *padapter, struct sta_info *psta)
{
return rtw_ap_set_sta_key(padapter
, psta->phl_sta->mac_addr
, psta->dot118021XPrivacy
, psta->dot118021x_UncstKey.skey
, 0
, 0
);
}
static int rtw_ap_set_key(_adapter *padapter, u8 *key, u8 alg, int keyid, u8 set_tx)
{
u8 keylen;
struct setkey_parm setkeyparm;
int res = _SUCCESS;
/* RTW_INFO("%s\n", __FUNCTION__); */
_rtw_memset(&setkeyparm, 0, sizeof(struct setkey_parm));
setkeyparm.keyid = (u8)keyid;
if (is_wep_enc(alg))
padapter->securitypriv.key_mask |= BIT(setkeyparm.keyid);
setkeyparm.algorithm = alg;
setkeyparm.set_tx = set_tx;
switch (alg) {
case _WEP40_:
keylen = 5;
break;
case _WEP104_:
keylen = 13;
break;
case _GCMP_256_:
case _CCMP_256_:
keylen = 32;
break;
case _TKIP_:
case _TKIP_WTMIC_:
case _AES_:
case _GCMP_:
#ifdef CONFIG_IEEE80211W
case _BIP_CMAC_128_:
#endif
default:
keylen = 16;
}
_rtw_memcpy(&(setkeyparm.key[0]), key, keylen);
setkey_hdl(padapter, &setkeyparm, PHL_CMD_NO_WAIT, 0);
exit:
return res;
}
#else /* CONFIG_FSM */
u8 rtw_ap_set_sta_key(_adapter *adapter, const u8 *addr, u8 alg, const u8 *key, u8 keyid, u8 gk)
{
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct cmd_obj *cmd;
struct set_stakey_parm *param;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = adapter;
param = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
if (param == NULL) {
rtw_mfree((u8 *) cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
init_h2fwcmd_w_parm_no_rsp(cmd, param, CMD_SET_STAKEY);
_rtw_memcpy(param->addr, addr, ETH_ALEN);
param->algorithm = alg;
param->keyid = keyid;
if (!!(alg & _SEC_TYPE_256_))
_rtw_memcpy(param->key, key, 32);
else
_rtw_memcpy(param->key, key, 16);
param->gk = gk;
res = rtw_enqueue_cmd(cmdpriv, cmd);
exit:
return res;
}
u8 rtw_ap_set_pairwise_key(_adapter *padapter, struct sta_info *psta)
{
return rtw_ap_set_sta_key(padapter
, psta->phl_sta->mac_addr
, psta->dot118021XPrivacy
, psta->dot118021x_UncstKey.skey
, 0
, 0
);
}
static int rtw_ap_set_key(_adapter *padapter, u8 *key, u8 alg, int keyid, u8 set_tx)
{
u8 keylen;
struct cmd_obj *pcmd;
struct setkey_parm *psetkeyparm;
struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(padapter)->cmdpriv);
int res = _SUCCESS;
/* RTW_INFO("%s\n", __FUNCTION__); */
pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd == NULL) {
res = _FAIL;
goto exit;
}
pcmd->padapter = padapter;
psetkeyparm = (struct setkey_parm *)rtw_zmalloc(sizeof(struct setkey_parm));
if (psetkeyparm == NULL) {
rtw_mfree((unsigned char *)pcmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
_rtw_memset(psetkeyparm, 0, sizeof(struct setkey_parm));
psetkeyparm->keyid = (u8)keyid;
if (is_wep_enc(alg))
padapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
psetkeyparm->algorithm = alg;
psetkeyparm->set_tx = set_tx;
switch (alg) {
case _WEP40_:
keylen = 5;
break;
case _WEP104_:
keylen = 13;
break;
case _GCMP_256_:
case _CCMP_256_:
keylen = 32;
break;
case _TKIP_:
case _TKIP_WTMIC_:
case _AES_:
case _GCMP_:
#ifdef CONFIG_IEEE80211W
case _BIP_CMAC_128_:
#endif
default:
keylen = 16;
}
_rtw_memcpy(&(psetkeyparm->key[0]), key, keylen);
pcmd->cmdcode = CMD_SET_KEY; /*_SetKey_CMD_*/
pcmd->parmbuf = (u8 *)psetkeyparm;
pcmd->cmdsz = (sizeof(struct setkey_parm));
pcmd->rsp = NULL;
pcmd->rspsz = 0;
_rtw_init_listhead(&pcmd->list);
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
exit:
return res;
}
#endif
int rtw_ap_set_group_key(_adapter *padapter, u8 *key, u8 alg, int keyid)
{
RTW_INFO("%s\n", __FUNCTION__);
return rtw_ap_set_key(padapter, key, alg, keyid, 1);
}
int rtw_ap_set_wep_key(_adapter *padapter, u8 *key, u8 keylen, int keyid, u8 set_tx)
{
u8 alg;
switch (keylen) {
case 5:
alg = _WEP40_;
break;
case 13:
alg = _WEP104_;
break;
default:
alg = _NO_PRIVACY_;
}
RTW_INFO("%s\n", __FUNCTION__);
return rtw_ap_set_key(padapter, key, alg, keyid, set_tx);
}
u8 rtw_ap_bmc_frames_hdl(_adapter *padapter)
{
#define HIQ_XMIT_COUNTS (6)
struct sta_info *psta_bmc;
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
bool update_tim = _FALSE;
if (padapter->registrypriv.wifi_spec != 1)
return H2C_SUCCESS;
psta_bmc = rtw_get_bcmc_stainfo(padapter);
if (!psta_bmc)
return H2C_SUCCESS;
_rtw_spinlock_bh(&pxmitpriv->lock);
if ((rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, 0)) && (psta_bmc->sleepq_len > 0)) {
int tx_counts = 0;
_update_beacon(padapter, _TIM_IE_, NULL, _FALSE, 0, "update TIM with TIB=1");
RTW_INFO("sleepq_len of bmc_sta = %d\n", psta_bmc->sleepq_len);
xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
xmitframe_plist = get_next(xmitframe_plist);
rtw_list_delete(&pxmitframe->list);
psta_bmc->sleepq_len--;
tx_counts++;
if (psta_bmc->sleepq_len > 0)
pxmitframe->attrib.mdata = 1;
else
pxmitframe->attrib.mdata = 0;
if (tx_counts == HIQ_XMIT_COUNTS)
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.triggered = 1;
if (xmitframe_hiq_filter(pxmitframe) == _TRUE)
pxmitframe->attrib.qsel = rtw_hal_get_qsel(padapter,QSLT_HIGH_ID);/*HIQ*/
rtw_intf_xmitframe_enqueue(padapter, pxmitframe);
if (tx_counts == HIQ_XMIT_COUNTS)
break;
}
} else {
if (psta_bmc->sleepq_len == 0) {
/*RTW_INFO("sleepq_len of bmc_sta = %d\n", psta_bmc->sleepq_len);*/
if (rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, 0))
update_tim = _TRUE;
rtw_tim_map_clear(padapter, pstapriv->tim_bitmap, 0);
rtw_tim_map_clear(padapter, pstapriv->sta_dz_bitmap, 0);
if (update_tim == _TRUE) {
RTW_INFO("clear TIB\n");
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0, "bmc sleepq and HIQ empty");
}
}
}
_rtw_spinunlock_bh(&pxmitpriv->lock);
#if 0
/* HIQ Check */
rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &empty);
while (_FALSE == empty && rtw_get_passing_time_ms(start) < 3000) {
rtw_msleep_os(100);
rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &empty);
}
printk("check if hiq empty=%d\n", empty);
#endif
return H2C_SUCCESS;
}
#ifdef CONFIG_NATIVEAP_MLME
static void associated_stainfo_update(_adapter *padapter, struct sta_info *psta, u32 sta_info_type)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
RTW_INFO("%s: "MAC_FMT", updated_type=0x%x\n", __func__, MAC_ARG(psta->phl_sta->mac_addr), sta_info_type);
#ifdef CONFIG_80211N_HT
if (sta_info_type & STA_INFO_UPDATE_BW) {
if ((psta->flags & WLAN_STA_HT) && !psta->ht_20mhz_set) {
if (pmlmepriv->sw_to_20mhz) {
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_20;
/*psta->htpriv.ch_offset = CHAN_OFFSET_NO_EXT;*/
psta->htpriv.sgi_40m = _FALSE;
} else {
/*TODO: Switch back to 40MHZ?80MHZ*/
}
}
}
#endif /* CONFIG_80211N_HT */
/*
if (sta_info_type & STA_INFO_UPDATE_RATE) {
}
*/
if (sta_info_type & STA_INFO_UPDATE_PROTECTION_MODE)
VCS_update(padapter, psta);
/*
if (sta_info_type & STA_INFO_UPDATE_CAP) {
}
if (sta_info_type & STA_INFO_UPDATE_HT_CAP) {
}
if (sta_info_type & STA_INFO_UPDATE_VHT_CAP) {
}
*/
}
static void update_bcn_erpinfo_ie(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = &(pmlmeinfo->network);
unsigned char *p, *ie = pnetwork->IEs;
u32 len = 0;
RTW_INFO("%s, ERP_enable=%d\n", __FUNCTION__, pmlmeinfo->ERP_enable);
if (!pmlmeinfo->ERP_enable)
return;
/* parsing ERP_IE */
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _ERPINFO_IE_, &len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (p && len > 0) {
PNDIS_802_11_VARIABLE_IEs pIE = (PNDIS_802_11_VARIABLE_IEs)p;
if (pmlmepriv->num_sta_non_erp == 1)
pIE->data[0] |= RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION;
else
pIE->data[0] &= ~(RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION);
if (pmlmepriv->num_sta_no_short_preamble > 0)
pIE->data[0] |= RTW_ERP_INFO_BARKER_PREAMBLE_MODE;
else
pIE->data[0] &= ~(RTW_ERP_INFO_BARKER_PREAMBLE_MODE);
ERP_IE_handler(padapter, pIE);
}
}
static void update_bcn_htcap_ie(_adapter *padapter)
{
RTW_INFO("%s\n", __FUNCTION__);
}
static void update_bcn_htinfo_ie(_adapter *padapter)
{
#ifdef CONFIG_80211N_HT
/*
u8 beacon_updated = _FALSE;
u32 sta_info_update_type = STA_INFO_UPDATE_NONE;
*/
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = &(pmlmeinfo->network);
unsigned char *p, *ie = pnetwork->IEs;
u32 len = 0;
if (pmlmepriv->htpriv.ht_option == _FALSE)
return;
if (pmlmeinfo->HT_info_enable != 1)
return;
RTW_INFO("%s current operation mode=0x%X\n",
__FUNCTION__, pmlmepriv->ht_op_mode);
RTW_INFO("num_sta_40mhz_intolerant(%d), 20mhz_width_req(%d), intolerant_ch_rpt(%d), olbc(%d)\n",
pmlmepriv->num_sta_40mhz_intolerant, pmlmepriv->ht_20mhz_width_req, pmlmepriv->ht_intolerant_ch_reported, ATOMIC_READ(&pmlmepriv->olbc));
/*parsing HT_INFO_IE, currently only update ht_op_mode - pht_info->infos[1] & pht_info->infos[2] for wifi logo test*/
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_ADD_INFO_IE_, &len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (p && len > 0) {
struct HT_info_element *pht_info = NULL;
pht_info = (struct HT_info_element *)(p + 2);
/* for STA Channel Width/Secondary Channel Offset*/
if ((pmlmepriv->sw_to_20mhz == 0) && (pmlmeext->chandef.chan <= 14)) {
if ((pmlmepriv->num_sta_40mhz_intolerant > 0) || (pmlmepriv->ht_20mhz_width_req == _TRUE)
|| (pmlmepriv->ht_intolerant_ch_reported == _TRUE) || (ATOMIC_READ(&pmlmepriv->olbc) == _TRUE)) {
SET_HT_OP_ELE_2ND_CHL_OFFSET(pht_info, 0);
SET_HT_OP_ELE_STA_CHL_WIDTH(pht_info, 0);
pmlmepriv->sw_to_20mhz = 1;
/*
sta_info_update_type |= STA_INFO_UPDATE_BW;
beacon_updated = _TRUE;
*/
RTW_INFO("%s:switching to 20Mhz\n", __FUNCTION__);
/*TODO : cur_bwmode/cur_ch_offset switches to 20Mhz*/
}
} else {
if ((pmlmepriv->num_sta_40mhz_intolerant == 0) && (pmlmepriv->ht_20mhz_width_req == _FALSE)
&& (pmlmepriv->ht_intolerant_ch_reported == _FALSE) && (ATOMIC_READ(&pmlmepriv->olbc) == _FALSE)) {
if (pmlmeext->chandef.bw >= CHANNEL_WIDTH_40) {
SET_HT_OP_ELE_STA_CHL_WIDTH(pht_info, 1);
SET_HT_OP_ELE_2ND_CHL_OFFSET(pht_info,
(pmlmeext->chandef.offset == CHAN_OFFSET_UPPER) ?
HT_INFO_HT_PARAM_SECONDARY_CHNL_ABOVE : HT_INFO_HT_PARAM_SECONDARY_CHNL_BELOW);
pmlmepriv->sw_to_20mhz = 0;
/*
sta_info_update_type |= STA_INFO_UPDATE_BW;
beacon_updated = _TRUE;
*/
RTW_INFO("%s:switching back to 40Mhz\n", __FUNCTION__);
}
}
}
/* to update ht_op_mode*/
*(u16 *)(pht_info->infos + 1) = cpu_to_le16(pmlmepriv->ht_op_mode);
}
/*associated_clients_update(padapter, beacon_updated, sta_info_update_type);*/
#endif /* CONFIG_80211N_HT */
}
static void update_bcn_rsn_ie(_adapter *padapter)
{
RTW_INFO("%s\n", __FUNCTION__);
}
static void update_bcn_wpa_ie(_adapter *padapter)
{
RTW_INFO("%s\n", __FUNCTION__);
}
static void update_bcn_wmm_ie(_adapter *padapter)
{
RTW_INFO("%s\n", __FUNCTION__);
}
static void update_bcn_wps_ie(_adapter *padapter)
{
u8 *pwps_ie = NULL, *pwps_ie_src, *premainder_ie, *pbackup_remainder_ie = NULL;
uint wps_ielen = 0, wps_offset, remainder_ielen;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = &(pmlmeinfo->network);
unsigned char *ie = pnetwork->IEs;
u32 ielen = pnetwork->IELength;
RTW_INFO("%s\n", __FUNCTION__);
pwps_ie = rtw_get_wps_ie(ie + _FIXED_IE_LENGTH_, ielen - _FIXED_IE_LENGTH_, NULL, &wps_ielen);
if (pwps_ie == NULL || wps_ielen == 0)
return;
pwps_ie_src = pmlmepriv->wps_beacon_ie;
if (pwps_ie_src == NULL)
return;
wps_offset = (uint)(pwps_ie - ie);
premainder_ie = pwps_ie + wps_ielen;
remainder_ielen = ielen - wps_offset - wps_ielen;
if (remainder_ielen > 0) {
pbackup_remainder_ie = rtw_malloc(remainder_ielen);
if (pbackup_remainder_ie)
_rtw_memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
}
wps_ielen = (uint)pwps_ie_src[1];/* to get ie data len */
if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) {
_rtw_memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2);
pwps_ie += (wps_ielen + 2);
if (pbackup_remainder_ie)
_rtw_memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen);
/* update IELength */
pnetwork->IELength = wps_offset + (wps_ielen + 2) + remainder_ielen;
}
if (pbackup_remainder_ie)
rtw_mfree(pbackup_remainder_ie, remainder_ielen);
/* deal with the case without set_tx_beacon_cmd() in rtw_update_beacon() */
#if defined(CONFIG_INTERRUPT_BASED_TXBCN) || defined(CONFIG_PCI_HCI)
if ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) {
u8 sr = 0;
rtw_get_wps_attr_content(pwps_ie_src, wps_ielen, WPS_ATTR_SELECTED_REGISTRAR, (u8 *)(&sr), NULL);
if (sr) {
set_fwstate(pmlmepriv, WIFI_UNDER_WPS);
RTW_INFO("%s, set WIFI_UNDER_WPS\n", __func__);
} else {
clr_fwstate(pmlmepriv, WIFI_UNDER_WPS);
RTW_INFO("%s, clr WIFI_UNDER_WPS\n", __func__);
}
}
#endif
}
static void update_bcn_p2p_ie(_adapter *padapter)
{
}
static u8 update_csa_ie(_adapter *padapter)
{
u8 update = _FALSE;
#ifdef CONFIG_ECSA_PHL
struct core_ecsa_info *ecsa_info = &(padapter->ecsa_info);
struct rtw_phl_ecsa_param *ecsa_param = &(ecsa_info->phl_ecsa_param);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = &(pmlmeinfo->network);
u8 csa_data[CSA_IE_LEN] = {0};
u8 csa_ch = ecsa_param->new_chan_def.chan;
u8 csa_count = ecsa_param->count;
u8 *ies = pnetwork->IEs + _BEACON_IE_OFFSET_;
sint ies_len = pnetwork->IELength - _BEACON_IE_OFFSET_;
u8 *csa_ie;
sint csa_ie_len;
if (!CHK_ECSA_STATE(padapter, ECSA_ST_SW_START))
return update;
csa_ie = rtw_get_ie(ies, WLAN_EID_CHANNEL_SWITCH, &csa_ie_len, ies_len);
if (csa_ie == NULL) {
if (csa_count > 0) {
/* add new CSA IE */
RTW_INFO("CSA : "FUNC_ADPT_FMT" ch=%u, count=%u, add CSA IE\n",
FUNC_ADPT_ARG(padapter), csa_ch, csa_count);
csa_data[CSA_SWITCH_MODE] = ecsa_param->mode;
csa_data[CSA_NEW_CH] = csa_ch;
csa_data[CSA_SWITCH_COUNT] = csa_count;
rtw_add_bcn_ie(padapter, pnetwork, WLAN_EID_CHANNEL_SWITCH, csa_data, CSA_IE_LEN);
update = _TRUE;
} else if (csa_ch > 0) {
/* count = 0, means switching channel immediately */
RTW_INFO("CSA : "FUNC_ADPT_FMT" ch=%d, count=0, switch channel immediately\n",
FUNC_ADPT_ARG(padapter), csa_ch);
SET_ECSA_STATE(padapter, ECSA_ST_SW_DONE);
}
} else if (csa_ie && csa_ie_len == CSA_IE_LEN) {
if (csa_count > 0) {
/* update CSA IE */
#ifdef DBG_CSA
RTW_INFO("CSA : "FUNC_ADPT_FMT" ch=%u, count=%u, update CSA IE\n",
FUNC_ADPT_ARG(padapter), csa_ch, csa_count);
#endif
csa_ie[2 + CSA_SWITCH_COUNT] = csa_count;
} else {
/* remove CSA IE */
RTW_INFO("CSA : "FUNC_ADPT_FMT" ch=%u, count=%u, remove CSA IE\n",
FUNC_ADPT_ARG(padapter), csa_ch, csa_count);
rtw_remove_bcn_ie(padapter, pnetwork, WLAN_EID_CHANNEL_SWITCH);
SET_ECSA_STATE(padapter, ECSA_ST_SW_DONE);
}
update = _TRUE;
} else {
RTW_ERR("CSA : "FUNC_ADPT_FMT" unexpected case\n", FUNC_ADPT_ARG(padapter));
}
if (ecsa_param->count > 0)
ecsa_param->count--;
#endif /* CONFIG_ECSA_PHL */
return update;
}
static void update_bcn_vendor_spec_ie(_adapter *padapter, u8 *oui)
{
RTW_INFO("%s\n", __FUNCTION__);
if (_rtw_memcmp(RTW_WPA_OUI, oui, 4))
update_bcn_wpa_ie(padapter);
else if (_rtw_memcmp(WMM_OUI, oui, 4))
update_bcn_wmm_ie(padapter);
else if (_rtw_memcmp(WPS_OUI, oui, 4))
update_bcn_wps_ie(padapter);
else if (_rtw_memcmp(P2P_OUI, oui, 4))
update_bcn_p2p_ie(padapter);
else
RTW_INFO("unknown OUI type!\n");
}
void _update_beacon(_adapter *padapter, u8 ie_id, u8 *oui, u8 tx, u8 flags, const char *tag)
{
struct mlme_priv *pmlmepriv;
struct mlme_ext_priv *pmlmeext;
bool updated = 1; /* treat as upadated by default */
if (!padapter)
return;
pmlmepriv = &(padapter->mlmepriv);
pmlmeext = &(padapter->mlmeextpriv);
if (pmlmeext->bstart_bss == _FALSE)
return;
_rtw_spinlock_bh(&pmlmepriv->bcn_update_lock);
switch (ie_id) {
case _TIM_IE_:
update_BCNTIM(padapter);
break;
case _ERPINFO_IE_:
update_bcn_erpinfo_ie(padapter);
break;
case _HT_CAPABILITY_IE_:
update_bcn_htcap_ie(padapter);
break;
case _RSN_IE_2_:
update_bcn_rsn_ie(padapter);
break;
case _HT_ADD_INFO_IE_:
update_bcn_htinfo_ie(padapter);
break;
#ifdef CONFIG_RTW_MESH
case WLAN_EID_MESH_CONFIG:
updated = rtw_mesh_update_bss_peering_status(padapter, &(pmlmeext->mlmext_info.network));
updated |= rtw_mesh_update_bss_formation_info(padapter, &(pmlmeext->mlmext_info.network));
updated |= rtw_mesh_update_bss_forwarding_state(padapter, &(pmlmeext->mlmext_info.network));
break;
#endif
case WLAN_EID_CHANNEL_SWITCH:
updated = update_csa_ie(padapter);
break;
case _VENDOR_SPECIFIC_IE_:
update_bcn_vendor_spec_ie(padapter, oui);
break;
case 0xFF:
default:
break;
}
if (updated)
pmlmepriv->update_bcn = _TRUE;
_rtw_spinunlock_bh(&pmlmepriv->bcn_update_lock);
#ifndef CONFIG_INTERRUPT_BASED_TXBCN
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI) || defined(CONFIG_PCI_BCN_POLLING)
if (tx && updated) {
/* send_beacon(padapter); */ /* send_beacon must execute on TSR level */
if (0)
RTW_INFO(FUNC_ADPT_FMT" ie_id:%u - %s\n", FUNC_ADPT_ARG(padapter), ie_id, tag);
if(flags == RTW_CMDF_WAIT_ACK)
set_tx_beacon_cmd(padapter, RTW_CMDF_WAIT_ACK);
else
set_tx_beacon_cmd(padapter, 0);
}
#else
{
/* PCI will issue beacon when BCN interrupt occurs. */
}
#endif
#endif /* !CONFIG_INTERRUPT_BASED_TXBCN */
}
#ifdef CONFIG_80211N_HT
void rtw_process_public_act_bsscoex(_adapter *padapter, u8 *pframe, uint frame_len)
{
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 beacon_updated = _FALSE;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 *frame_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
uint frame_body_len = frame_len - sizeof(struct rtw_ieee80211_hdr_3addr);
u8 category, action;
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta == NULL)
return;
category = frame_body[0];
action = frame_body[1];
if (frame_body_len > 0) {
if ((frame_body[2] == EID_BSSCoexistence) && (frame_body[3] > 0)) {
u8 ie_data = frame_body[4];
if (ie_data & RTW_WLAN_20_40_BSS_COEX_40MHZ_INTOL) {
if (psta->ht_40mhz_intolerant == 0) {
psta->ht_40mhz_intolerant = 1;
pmlmepriv->num_sta_40mhz_intolerant++;
beacon_updated = _TRUE;
}
} else if (ie_data & RTW_WLAN_20_40_BSS_COEX_20MHZ_WIDTH_REQ) {
if (pmlmepriv->ht_20mhz_width_req == _FALSE) {
pmlmepriv->ht_20mhz_width_req = _TRUE;
beacon_updated = _TRUE;
}
} else
beacon_updated = _FALSE;
}
}
if (frame_body_len > 8) {
/* if EID_BSSIntolerantChlReport ie exists */
if ((frame_body[5] == EID_BSSIntolerantChlReport) && (frame_body[6] > 0)) {
/*todo:*/
if (pmlmepriv->ht_intolerant_ch_reported == _FALSE) {
pmlmepriv->ht_intolerant_ch_reported = _TRUE;
beacon_updated = _TRUE;
}
}
}
if (beacon_updated) {
rtw_update_beacon(padapter, _HT_ADD_INFO_IE_, NULL, _TRUE, 0);
associated_stainfo_update(padapter, psta, STA_INFO_UPDATE_BW);
}
}
void rtw_process_ht_action_smps(_adapter *padapter, u8 *ta, u8 ctrl_field)
{
u8 e_field, m_field;
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
psta = rtw_get_stainfo(pstapriv, ta);
if (psta == NULL)
return;
e_field = (ctrl_field & BIT(0)) ? 1 : 0; /*SM Power Save Enabled*/
m_field = (ctrl_field & BIT(1)) ? 1 : 0; /*SM Mode, 0:static SMPS, 1:dynamic SMPS*/
if (e_field) {
if (m_field) { /*mode*/
psta->htpriv.smps_cap = WLAN_HT_CAP_SM_PS_DYNAMIC;
RTW_ERR("Don't support dynamic SMPS\n");
}
else
psta->htpriv.smps_cap = WLAN_HT_CAP_SM_PS_STATIC;
} else {
/*disable*/
psta->htpriv.smps_cap = WLAN_HT_CAP_SM_PS_DISABLED;
}
if (psta->htpriv.smps_cap != WLAN_HT_CAP_SM_PS_DYNAMIC)
rtw_ssmps_wk_cmd(padapter, psta, e_field, 1);
}
/*
op_mode
Set to 0 (HT pure) under the followign conditions
- all STAs in the BSS are 20/40 MHz HT in 20/40 MHz BSS or
- all STAs in the BSS are 20 MHz HT in 20 MHz BSS
Set to 1 (HT non-member protection) if there may be non-HT STAs
in both the primary and the secondary channel
Set to 2 if only HT STAs are associated in BSS,
however and at least one 20 MHz HT STA is associated
Set to 3 (HT mixed mode) when one or more non-HT STAs are associated
(currently non-GF HT station is considered as non-HT STA also)
*/
int rtw_ht_operation_update(_adapter *padapter)
{
u16 cur_op_mode, new_op_mode;
int op_mode_changes = 0;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
if (pmlmepriv->htpriv.ht_option == _FALSE)
return 0;
/*if (!iface->conf->ieee80211n || iface->conf->ht_op_mode_fixed)
return 0;*/
RTW_INFO("%s current operation mode=0x%X\n",
__FUNCTION__, pmlmepriv->ht_op_mode);
if (!(pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT)
&& pmlmepriv->num_sta_ht_no_gf) {
pmlmepriv->ht_op_mode |=
HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT;
op_mode_changes++;
} else if ((pmlmepriv->ht_op_mode &
HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT) &&
pmlmepriv->num_sta_ht_no_gf == 0) {
pmlmepriv->ht_op_mode &=
~HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT;
op_mode_changes++;
}
if (!(pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT) &&
(pmlmepriv->num_sta_no_ht || ATOMIC_READ(&pmlmepriv->olbc_ht))) {
pmlmepriv->ht_op_mode |= HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT;
op_mode_changes++;
} else if ((pmlmepriv->ht_op_mode &
HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT) &&
(pmlmepriv->num_sta_no_ht == 0 && !ATOMIC_READ(&pmlmepriv->olbc_ht))) {
pmlmepriv->ht_op_mode &=
~HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT;
op_mode_changes++;
}
/* Note: currently we switch to the MIXED op mode if HT non-greenfield
* station is associated. Probably it's a theoretical case, since
* it looks like all known HT STAs support greenfield.
*/
new_op_mode = 0;
if (pmlmepriv->num_sta_no_ht /*||
(pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT)*/)
new_op_mode = OP_MODE_MIXED;
else if ((phtpriv_ap->ht_cap.cap_info & IEEE80211_HT_CAP_SUP_WIDTH)
&& pmlmepriv->num_sta_ht_20mhz)
new_op_mode = OP_MODE_20MHZ_HT_STA_ASSOCED;
else if (ATOMIC_READ(&pmlmepriv->olbc_ht))
new_op_mode = OP_MODE_MAY_BE_LEGACY_STAS;
else
new_op_mode = OP_MODE_PURE;
cur_op_mode = pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_OP_MODE_MASK;
if (cur_op_mode != new_op_mode) {
pmlmepriv->ht_op_mode &= ~HT_INFO_OPERATION_MODE_OP_MODE_MASK;
pmlmepriv->ht_op_mode |= new_op_mode;
op_mode_changes++;
}
RTW_INFO("%s new operation mode=0x%X changes=%d\n",
__FUNCTION__, pmlmepriv->ht_op_mode, op_mode_changes);
return op_mode_changes;
}
#endif /* CONFIG_80211N_HT */
void associated_clients_update(_adapter *padapter, u8 updated, u32 sta_info_type)
{
/* update associcated stations cap. */
if (updated == _TRUE) {
_list *phead, *plist;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
/* check asoc_queue */
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
associated_stainfo_update(padapter, psta, sta_info_type);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
}
}
/* called > TSR LEVEL for USB or SDIO Interface*/
void bss_cap_update_on_sta_join(_adapter *padapter, struct sta_info *psta)
{
u8 beacon_updated = _FALSE;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
#if 0
if (!(psta->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) &&
!psta->no_short_preamble_set) {
psta->no_short_preamble_set = 1;
pmlmepriv->num_sta_no_short_preamble++;
if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
(pmlmepriv->num_sta_no_short_preamble == 1))
ieee802_11_set_beacons(hapd->iface);
}
#endif
if (!(psta->flags & WLAN_STA_SHORT_PREAMBLE)) {
if (!psta->no_short_preamble_set) {
psta->no_short_preamble_set = 1;
pmlmepriv->num_sta_no_short_preamble++;
if ((pmlmeext->cur_wireless_mode > WLAN_MD_11B) &&
(pmlmepriv->num_sta_no_short_preamble == 1))
beacon_updated = _TRUE;
}
} else {
if (psta->no_short_preamble_set) {
psta->no_short_preamble_set = 0;
pmlmepriv->num_sta_no_short_preamble--;
if ((pmlmeext->cur_wireless_mode > WLAN_MD_11B) &&
(pmlmepriv->num_sta_no_short_preamble == 0))
beacon_updated = _TRUE;
}
}
#if 0
if (psta->flags & WLAN_STA_NONERP && !psta->nonerp_set) {
psta->nonerp_set = 1;
pmlmepriv->num_sta_non_erp++;
if (pmlmepriv->num_sta_non_erp == 1)
ieee802_11_set_beacons(hapd->iface);
}
#endif
if (psta->flags & WLAN_STA_NONERP) {
if (!psta->nonerp_set) {
psta->nonerp_set = 1;
pmlmepriv->num_sta_non_erp++;
if (pmlmepriv->num_sta_non_erp == 1) {
beacon_updated = _TRUE;
rtw_update_beacon(padapter, _ERPINFO_IE_, NULL, _FALSE, 0);
}
}
} else {
if (psta->nonerp_set) {
psta->nonerp_set = 0;
pmlmepriv->num_sta_non_erp--;
if (pmlmepriv->num_sta_non_erp == 0) {
beacon_updated = _TRUE;
rtw_update_beacon(padapter, _ERPINFO_IE_, NULL, _FALSE, 0);
}
}
}
#if 0
if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT) &&
!psta->no_short_slot_time_set) {
psta->no_short_slot_time_set = 1;
pmlmepriv->num_sta_no_short_slot_time++;
if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
(pmlmepriv->num_sta_no_short_slot_time == 1))
ieee802_11_set_beacons(hapd->iface);
}
#endif
if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT)) {
if (!psta->no_short_slot_time_set) {
psta->no_short_slot_time_set = 1;
pmlmepriv->num_sta_no_short_slot_time++;
if ((pmlmeext->cur_wireless_mode > WLAN_MD_11B) &&
(pmlmepriv->num_sta_no_short_slot_time == 1))
beacon_updated = _TRUE;
}
} else {
if (psta->no_short_slot_time_set) {
psta->no_short_slot_time_set = 0;
pmlmepriv->num_sta_no_short_slot_time--;
if ((pmlmeext->cur_wireless_mode > WLAN_MD_11B) &&
(pmlmepriv->num_sta_no_short_slot_time == 0))
beacon_updated = _TRUE;
}
}
#ifdef CONFIG_80211N_HT
if(padapter->registrypriv.ht_enable &&
is_supported_ht(padapter->registrypriv.wireless_mode)) {
if (psta->flags & WLAN_STA_HT) {
u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info);
RTW_INFO("HT: STA " MAC_FMT " HT Capabilities Info: 0x%04x\n",
MAC_ARG(psta->phl_sta->mac_addr), ht_capab);
if (psta->no_ht_set) {
psta->no_ht_set = 0;
pmlmepriv->num_sta_no_ht--;
}
if ((ht_capab & IEEE80211_HT_CAP_GRN_FLD) == 0) {
if (!psta->no_ht_gf_set) {
psta->no_ht_gf_set = 1;
pmlmepriv->num_sta_ht_no_gf++;
}
RTW_INFO("%s STA " MAC_FMT " - no "
"greenfield, num of non-gf stations %d\n",
__FUNCTION__, MAC_ARG(psta->phl_sta->mac_addr),
pmlmepriv->num_sta_ht_no_gf);
}
if ((ht_capab & IEEE80211_HT_CAP_SUP_WIDTH) == 0) {
if (!psta->ht_20mhz_set) {
psta->ht_20mhz_set = 1;
pmlmepriv->num_sta_ht_20mhz++;
}
RTW_INFO("%s STA " MAC_FMT " - 20 MHz HT, "
"num of 20MHz HT STAs %d\n",
__FUNCTION__, MAC_ARG(psta->phl_sta->mac_addr),
pmlmepriv->num_sta_ht_20mhz);
}
if (((ht_capab & RTW_IEEE80211_HT_CAP_40MHZ_INTOLERANT) != 0) &&
(psta->ht_40mhz_intolerant == 0)) {
psta->ht_40mhz_intolerant = 1;
pmlmepriv->num_sta_40mhz_intolerant++;
RTW_INFO("%s STA " MAC_FMT " - 40MHZ_INTOLERANT, ",
__FUNCTION__, MAC_ARG(psta->phl_sta->mac_addr));
}
} else {
if (!psta->no_ht_set) {
psta->no_ht_set = 1;
pmlmepriv->num_sta_no_ht++;
}
if (pmlmepriv->htpriv.ht_option == _TRUE) {
RTW_INFO("%s STA " MAC_FMT
" - no HT, num of non-HT stations %d\n",
__FUNCTION__, MAC_ARG(psta->phl_sta->mac_addr),
pmlmepriv->num_sta_no_ht);
}
}
if (rtw_ht_operation_update(padapter) > 0) {
rtw_update_beacon(padapter, _HT_CAPABILITY_IE_, NULL, _FALSE, 0);
rtw_update_beacon(padapter, _HT_ADD_INFO_IE_, NULL, _FALSE, 0);
beacon_updated = _TRUE;
}
}
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
struct sta_priv *pstapriv = &padapter->stapriv;
rtw_update_beacon(padapter, WLAN_EID_MESH_CONFIG, NULL, _FALSE, 0);
if (pstapriv->asoc_list_cnt == 1)
_set_timer(&padapter->mesh_atlm_param_req_timer, 0);
beacon_updated = _TRUE;
}
#endif
if (beacon_updated)
rtw_update_beacon(padapter, 0xFF, NULL, _TRUE, 0);
/* update associcated stations cap. */
associated_clients_update(padapter, beacon_updated, STA_INFO_UPDATE_ALL);
RTW_INFO("%s, updated=%d\n", __func__, beacon_updated);
}
u8 bss_cap_update_on_sta_leave(_adapter *padapter, struct sta_info *psta)
{
u8 beacon_updated = _FALSE;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
if (!psta)
return beacon_updated;
if (rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid)) {
rtw_tim_map_clear(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
beacon_updated = _TRUE;
rtw_update_beacon(padapter, _TIM_IE_, NULL, _FALSE, 0);
}
if (psta->no_short_preamble_set) {
psta->no_short_preamble_set = 0;
pmlmepriv->num_sta_no_short_preamble--;
if (pmlmeext->cur_wireless_mode > WLAN_MD_11B
&& pmlmepriv->num_sta_no_short_preamble == 0)
beacon_updated = _TRUE;
}
if (psta->nonerp_set) {
psta->nonerp_set = 0;
pmlmepriv->num_sta_non_erp--;
if (pmlmepriv->num_sta_non_erp == 0) {
beacon_updated = _TRUE;
rtw_update_beacon(padapter, _ERPINFO_IE_, NULL, _FALSE, 0);
}
}
if (psta->no_short_slot_time_set) {
psta->no_short_slot_time_set = 0;
pmlmepriv->num_sta_no_short_slot_time--;
if (pmlmeext->cur_wireless_mode > WLAN_MD_11B
&& pmlmepriv->num_sta_no_short_slot_time == 0)
beacon_updated = _TRUE;
}
#ifdef CONFIG_80211N_HT
if (psta->no_ht_gf_set) {
psta->no_ht_gf_set = 0;
pmlmepriv->num_sta_ht_no_gf--;
}
if (psta->no_ht_set) {
psta->no_ht_set = 0;
pmlmepriv->num_sta_no_ht--;
}
if (psta->ht_20mhz_set) {
psta->ht_20mhz_set = 0;
pmlmepriv->num_sta_ht_20mhz--;
}
if (psta->ht_40mhz_intolerant) {
psta->ht_40mhz_intolerant = 0;
if (pmlmepriv->num_sta_40mhz_intolerant > 0)
pmlmepriv->num_sta_40mhz_intolerant--;
else
rtw_warn_on(1);
}
if (rtw_ht_operation_update(padapter) > 0) {
rtw_update_beacon(padapter, _HT_CAPABILITY_IE_, NULL, _FALSE, 0);
rtw_update_beacon(padapter, _HT_ADD_INFO_IE_, NULL, _FALSE, 0);
}
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
rtw_update_beacon(padapter, WLAN_EID_MESH_CONFIG, NULL, _FALSE, 0);
if (pstapriv->asoc_list_cnt == 0)
_cancel_timer_ex(&padapter->mesh_atlm_param_req_timer);
beacon_updated = _TRUE;
}
#endif
if (beacon_updated == _TRUE)
rtw_update_beacon(padapter, 0xFF, NULL, _TRUE, 0);
#if 0
/* update associated stations cap. */
associated_clients_update(padapter, beacon_updated, STA_INFO_UPDATE_ALL); /* move it to avoid deadlock */
#endif
RTW_INFO("%s, updated=%d\n", __func__, beacon_updated);
return beacon_updated;
}
u8 ap_free_sta(_adapter *padapter, struct sta_info *psta, bool active, u16 reason, bool enqueue, u8 disassoc)
{
u8 beacon_updated = _FALSE;
if (!psta)
return beacon_updated;
RTW_INFO("%s sta "MAC_FMT"\n", __func__, MAC_ARG(psta->phl_sta->mac_addr));
if (active == _TRUE) {
#ifdef CONFIG_80211N_HT
/* tear down Rx AMPDU */
send_delba(padapter, 0, psta->phl_sta->mac_addr);/* recipient */
/* tear down TX AMPDU */
send_delba(padapter, 1, psta->phl_sta->mac_addr);/* */ /* originator */
#endif /* CONFIG_80211N_HT */
if (!MLME_IS_MESH(padapter)) {
if (disassoc == _TRUE)
issue_disassoc(padapter, psta->phl_sta->mac_addr, reason);
else
issue_deauth(padapter, psta->phl_sta->mac_addr, reason);
}
}
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter))
rtw_mesh_path_flush_by_nexthop(psta);
#endif
#ifdef CONFIG_80211N_HT
psta->htpriv.agg_enable_bitmap = 0x0;/* reset */
psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */
#endif
/* clear cam entry / key */
rtw_clearstakey_cmd(padapter, psta, enqueue);
_rtw_spinlock_bh(&psta->lock);
psta->state &= ~(WIFI_ASOC_STATE | WIFI_UNDER_KEY_HANDSHAKE);
#ifdef CONFIG_IOCTL_CFG80211
if ((psta->auth_len != 0) && (psta->pauth_frame != NULL)) {
rtw_mfree(psta->pauth_frame, psta->auth_len);
psta->pauth_frame = NULL;
psta->auth_len = 0;
}
if (psta->passoc_req && psta->assoc_req_len > 0) {
rtw_mfree(psta->passoc_req, psta->assoc_req_len);
psta->passoc_req = NULL;
psta->assoc_req_len = 0;
}
#endif /* CONFIG_IOCTL_CFG80211 */
_rtw_spinunlock_bh(&psta->lock);
if (!MLME_IS_MESH(padapter)) {
#ifdef CONFIG_RTW_WDS
rtw_wds_path_flush_by_nexthop(psta);
#endif
#ifdef CONFIG_IOCTL_CFG80211
#ifdef COMPAT_KERNEL_RELEASE
rtw_cfg80211_indicate_sta_disassoc(padapter, psta->phl_sta->mac_addr, reason);
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) && !defined(CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER)
rtw_cfg80211_indicate_sta_disassoc(padapter, psta->phl_sta->mac_addr, reason);
#else /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) && !defined(CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER) */
/* will call rtw_cfg80211_indicate_sta_disassoc() in cmd_thread for old API context */
#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) && !defined(CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER) */
#else
rtw_indicate_sta_disassoc_event(padapter, psta);
#endif
}
beacon_updated = bss_cap_update_on_sta_leave(padapter, psta);
report_del_sta_event(padapter, psta->phl_sta->mac_addr, reason, enqueue, _FALSE);
return beacon_updated;
}
int rtw_ap_inform_ch_switch(_adapter *padapter, u8 new_ch, u8 ch_offset)
{
_list *phead, *plist;
int ret = 0;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
return ret;
RTW_INFO(FUNC_NDEV_FMT" with ch:%u, offset:%u\n",
FUNC_NDEV_ARG(padapter->pnetdev), new_ch, ch_offset);
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
/* for each sta in asoc_queue */
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
issue_action_spct_ch_switch(padapter, psta->phl_sta->mac_addr, new_ch, ch_offset);
psta->expire_to = ((pstapriv->expire_to * 2) > 5) ? 5 : (pstapriv->expire_to * 2);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
issue_action_spct_ch_switch(padapter, bc_addr, new_ch, ch_offset);
return ret;
}
int rtw_sta_flush(_adapter *padapter, bool enqueue)
{
_list *phead, *plist;
int ret = 0;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 flush_num = 0;
char flush_list[NUM_STA];
int i;
if (!MLME_IS_AP(padapter) && !MLME_IS_MESH(padapter))
return ret;
/* pick sta from sta asoc_queue */
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
int stainfo_offset;
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
rtw_list_delete(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (psta->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt--;
#endif
STA_SET_MESH_PLINK(psta, NULL);
stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
if (stainfo_offset_valid(stainfo_offset))
flush_list[flush_num++] = stainfo_offset;
else
rtw_warn_on(1);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
RTW_INFO(FUNC_NDEV_FMT" flush_num:%d\n", FUNC_NDEV_ARG(padapter->pnetdev), flush_num);
/* call ap_free_sta() for each sta picked */
for (i = 0; i < flush_num; i++) {
u8 sta_addr[ETH_ALEN];
psta = rtw_get_stainfo_by_offset(pstapriv, flush_list[i]);
_rtw_memcpy(sta_addr, psta->phl_sta->mac_addr, ETH_ALEN);
ap_free_sta(padapter, psta, _TRUE, WLAN_REASON_DEAUTH_LEAVING, enqueue, _FALSE);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter))
rtw_mesh_expire_peer(padapter, sta_addr);
#endif
}
if (!MLME_IS_MESH(padapter))
issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING);
associated_clients_update(padapter, _TRUE, STA_INFO_UPDATE_ALL);
return ret;
}
/* called > TSR LEVEL for USB or SDIO Interface*/
void sta_info_update(_adapter *padapter, struct sta_info *psta)
{
int flags = psta->flags;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
/* update wmm cap. */
if (WLAN_STA_WME & flags)
psta->qos_option = 1;
else
psta->qos_option = 0;
if (pmlmepriv->qospriv.qos_option == 0)
psta->qos_option = 0;
#ifdef CONFIG_80211N_HT
/* update 802.11n ht cap. */
if (WLAN_STA_HT & flags) {
psta->htpriv.ht_option = _TRUE;
psta->qos_option = 1;
psta->htpriv.smps_cap = (psta->htpriv.ht_cap.cap_info & IEEE80211_HT_CAP_SM_PS) >> 2;
} else
psta->htpriv.ht_option = _FALSE;
if (pmlmepriv->htpriv.ht_option == _FALSE)
psta->htpriv.ht_option = _FALSE;
#endif
#ifdef CONFIG_80211AC_VHT
/* update 802.11AC vht cap. */
if (WLAN_STA_VHT & flags)
psta->vhtpriv.vht_option = _TRUE;
else
psta->vhtpriv.vht_option = _FALSE;
if (pmlmepriv->vhtpriv.vht_option == _FALSE)
psta->vhtpriv.vht_option = _FALSE;
#endif
#ifdef CONFIG_80211AX_HE
/* update 802.11AX he cap. */
if (WLAN_STA_HE & flags)
psta->hepriv.he_option = _TRUE;
else
psta->hepriv.he_option = _FALSE;
if (pmlmepriv->hepriv.he_option == _FALSE)
psta->hepriv.he_option = _FALSE;
#endif
update_sta_info_apmode(padapter, psta);
}
/* restore hw setting from sw data structures */
void rtw_ap_restore_network(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta;
struct security_priv *psecuritypriv = &(padapter->securitypriv);
_list *phead, *plist;
u8 chk_alive_num = 0;
char chk_alive_list[NUM_STA];
int i;
rtw_setopmode_cmd(padapter
, MLME_IS_AP(padapter) ? Ndis802_11APMode : Ndis802_11_mesh
, RTW_CMDF_DIRECTLY
);
set_channel_bwmode(padapter,
pmlmeext->chandef.chan,
pmlmeext->chandef.offset,
pmlmeext->chandef.bw,
_FALSE);
rtw_startbss_cmd(padapter, RTW_CMDF_DIRECTLY);
if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) ||
(padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
/* restore group key, WEP keys is restored in ips_leave() */
rtw_set_key(padapter, psecuritypriv, psecuritypriv->dot118021XGrpKeyid, 0, _FALSE);
}
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
int stainfo_offset;
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
if (stainfo_offset_valid(stainfo_offset))
chk_alive_list[chk_alive_num++] = stainfo_offset;
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
for (i = 0; i < chk_alive_num; i++) {
psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
if (psta == NULL){
RTW_INFO(FUNC_ADPT_FMT" sta_info is null\n", FUNC_ADPT_ARG(padapter));
} else if (psta->state & WIFI_ASOC_STATE) {
rtw_sta_media_status_rpt(padapter, psta, 1);
/*
rtw_phl_cmd_change_stainfo(adapter_to_dvobj(adapter)->phl,
sta->phl_sta,
STA_CHG_RAMASK,
NULL,
0,
PHL_CMD_DIRECTLY,
0);
*/
/* pairwise key */
/* per sta pairwise key and settings */
if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) ||
(padapter->securitypriv.dot11PrivacyAlgrthm == _AES_))
rtw_setstakey_cmd(padapter, psta, UNICAST_KEY, _FALSE);
}
}
}
void start_ap_mode(_adapter *padapter)
{
int i;
struct sta_info *psta = NULL;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
#ifdef CONFIG_CONCURRENT_MODE
struct security_priv *psecuritypriv = &padapter->securitypriv;
#endif
pmlmepriv->update_bcn = _FALSE;
/*init_mlme_ap_info(padapter);*/
pmlmeext->bstart_bss = _FALSE;
pmlmepriv->num_sta_non_erp = 0;
pmlmepriv->num_sta_no_short_slot_time = 0;
pmlmepriv->num_sta_no_short_preamble = 0;
pmlmepriv->num_sta_ht_no_gf = 0;
#ifdef CONFIG_80211N_HT
pmlmepriv->num_sta_no_ht = 0;
#endif /* CONFIG_80211N_HT */
pmlmeinfo->HT_info_enable = 0;
pmlmeinfo->HT_caps_enable = 0;
pmlmeinfo->HT_enable = 0;
pmlmepriv->num_sta_ht_20mhz = 0;
pmlmepriv->num_sta_40mhz_intolerant = 0;
ATOMIC_SET(&pmlmepriv->olbc, _FALSE);
ATOMIC_SET(&pmlmepriv->olbc_ht, _FALSE);
#ifdef CONFIG_80211N_HT
pmlmepriv->ht_20mhz_width_req = _FALSE;
pmlmepriv->ht_intolerant_ch_reported = _FALSE;
pmlmepriv->ht_op_mode = 0;
pmlmepriv->sw_to_20mhz = 0;
#endif
_rtw_memset(pmlmepriv->ext_capab_ie_data, 0, sizeof(pmlmepriv->ext_capab_ie_data));
pmlmepriv->ext_capab_ie_len = 0;
#ifdef CONFIG_CONCURRENT_MODE
psecuritypriv->dot118021x_bmc_cam_id = INVALID_SEC_MAC_CAM_ID;
#endif
for (i = 0 ; i < pstapriv->max_aid; i++)
pstapriv->sta_aid[i] = NULL;
#ifdef CONFIG_RTW_WDS
if (MLME_IS_AP(padapter))
rtw_wds_pathtbl_init(padapter);
#endif
if (rtw_mi_get_ap_num(padapter))
RTW_SET_SCAN_BAND_SKIP(padapter, BAND_5G);
}
void stop_ap_mode(_adapter *padapter)
{
u8 self_action = MLME_ACTION_UNKNOWN;
struct sta_info *psta = NULL;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
int chanctx_num = 0;
struct rtw_chan_def chan_def = {0};
RTW_INFO("%s -"ADPT_FMT"\n", __func__, ADPT_ARG(padapter));
if (MLME_IS_AP(padapter))
self_action = MLME_AP_STOPPED;
else if (MLME_IS_MESH(padapter))
self_action = MLME_MESH_STOPPED;
else
rtw_warn_on(1);
pmlmepriv->update_bcn = _FALSE;
/*pmlmeext->bstart_bss = _FALSE;*/
padapter->netif_up = _FALSE;
/* _rtw_spinlock_free(&pmlmepriv->bcn_update_lock); */
/* reset and init security priv , this can refine with rtw_reset_securitypriv */
_rtw_memset((unsigned char *)&padapter->securitypriv, 0, sizeof(struct security_priv));
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
padapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(padapter, self_action, 0);
#endif
rtw_rfctl_update_op_mode(adapter_to_rfctl(padapter), BIT(padapter->iface_id), 0);
/* free scan queue */
rtw_free_network_queue(padapter, _TRUE);
#if CONFIG_RTW_MACADDR_ACL
rtw_macaddr_acl_clear(padapter, RTW_ACL_PERIOD_BSS);
#endif
rtw_sta_flush(padapter, _TRUE);
/* free_assoc_sta_resources */
rtw_free_all_stainfo(padapter);
#ifdef CONFIG_RTW_WDS
adapter_set_use_wds(padapter, 0);
#endif
#ifdef CONFIG_RTW_MULTI_AP
padapter->multi_ap = 0;
#endif
rtw_free_mlme_priv_ie_data(pmlmepriv);
pmlmeext->bstart_bss = _FALSE;
rtw_hal_rcr_set_chk_bssid(padapter, self_action);
#ifdef CONFIG_RTW_MULTI_AP
rtw_map_config_monitor(padapter, self_action);
#endif
#if 0
chanctx_num = rtw_phl_chanctx_del(adapter_to_dvobj(padapter)->phl,
padapter->phl_role, &chan_def);
if (chanctx_num && chan_def.chan != 0) {
set_channel_bwmode(padapter, chan_def.chan, chan_def.offset, chan_def.bw, _FALSE);
rtw_mi_update_union_chan_inf(padapter, chan_def.chan, chan_def.offset, chan_def.bw);
}
#endif
#ifdef CONFIG_RTW_WDS
if (MLME_IS_AP(padapter))
rtw_wds_pathtbl_unregister(padapter);
#endif
}
#endif /* CONFIG_NATIVEAP_MLME */
void rtw_ap_update_clients_rainfo(struct _ADAPTER *a, enum phl_cmd_type flag)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct mlme_ext_priv *pmlmeext = &(a->mlmeextpriv);
struct sta_priv *pstapriv = &a->stapriv;
struct sta_info *psta;
const struct sta_info *ap_self_psta = rtw_get_stainfo(pstapriv, a->phl_role->mac_addr);
_list *plist, *phead;
u8 i;
/* update RA mask of all clients */
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
/* no need to update RA info of ap self */
if (psta && psta != ap_self_psta) {
psta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
rtw_phl_cmd_change_stainfo(GET_PHL_INFO(d),
psta->phl_sta,
STA_CHG_RAMASK,
NULL,
0,
flag,
0);
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
}
void rtw_ap_update_bss_chbw(_adapter *adapter, WLAN_BSSID_EX *bss, u8 ch, u8 bw, u8 offset)
{
#define UPDATE_VHT_CAP 1
#define UPDATE_HT_CAP 1
#ifdef CONFIG_80211AC_VHT
struct vht_priv *vhtpriv = &adapter->mlmepriv.vhtpriv;
#endif
#ifdef CONFIG_80211AX_HE
struct he_priv *hepriv = &adapter->mlmepriv.hepriv;
#endif
{
u8 *p;
int ie_len;
u8 old_ch = bss->Configuration.DSConfig;
bool change_band = _FALSE;
if ((ch <= 14 && old_ch >= 36) || (ch >= 36 && old_ch <= 14))
change_band = _TRUE;
/* update channel in IE */
p = rtw_get_ie((bss->IEs + sizeof(NDIS_802_11_FIXED_IEs)), _DSSET_IE_, &ie_len, (bss->IELength - sizeof(NDIS_802_11_FIXED_IEs)));
if (p && ie_len > 0)
*(p + 2) = ch;
bss->Configuration.DSConfig = ch;
/* band is changed, update ERP, support rate, ext support rate IE */
if (change_band == _TRUE)
change_band_update_ie(adapter, bss, ch);
}
#ifdef CONFIG_80211AX_HE
if (hepriv->he_option == _TRUE) {
/* CONFIG_80211AX_HE_TODO */
}
#endif
#ifdef CONFIG_80211AC_VHT
if (vhtpriv->vht_option == _TRUE) {
u8 *vht_cap_ie, *vht_op_ie;
int vht_cap_ielen, vht_op_ielen;
u8 center_freq;
vht_cap_ie = rtw_get_ie((bss->IEs + sizeof(NDIS_802_11_FIXED_IEs)), EID_VHTCapability, &vht_cap_ielen, (bss->IELength - sizeof(NDIS_802_11_FIXED_IEs)));
vht_op_ie = rtw_get_ie((bss->IEs + sizeof(NDIS_802_11_FIXED_IEs)), EID_VHTOperation, &vht_op_ielen, (bss->IELength - sizeof(NDIS_802_11_FIXED_IEs)));
center_freq = rtw_phl_get_center_ch(ch, bw, offset);
/* update vht cap ie */
if (vht_cap_ie && vht_cap_ielen) {
#if UPDATE_VHT_CAP
/* if ((bw == CHANNEL_WIDTH_160 || bw == CHANNEL_WIDTH_80_80) && pvhtpriv->sgi_160m)
SET_VHT_CAPABILITY_ELE_SHORT_GI160M(pvht_cap_ie + 2, 1);
else */
SET_VHT_CAPABILITY_ELE_SHORT_GI160M(vht_cap_ie + 2, 0);
if (bw >= CHANNEL_WIDTH_80 && vhtpriv->sgi_80m)
SET_VHT_CAPABILITY_ELE_SHORT_GI80M(vht_cap_ie + 2, 1);
else
SET_VHT_CAPABILITY_ELE_SHORT_GI80M(vht_cap_ie + 2, 0);
#endif
}
/* update vht op ie */
if (vht_op_ie && vht_op_ielen) {
if (bw < CHANNEL_WIDTH_80) {
RTW_INFO(FUNC_ADPT_FMT" update VHT 20/40M\n", FUNC_ADPT_ARG(adapter));
SET_VHT_OPERATION_ELE_CHL_WIDTH(vht_op_ie + 2, 0);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ1(vht_op_ie + 2, 0);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ2(vht_op_ie + 2, 0);
} else if (bw == CHANNEL_WIDTH_80) {
RTW_INFO(FUNC_ADPT_FMT" update VHT 80M, center_freq = %u\n", FUNC_ADPT_ARG(adapter), center_freq);
SET_VHT_OPERATION_ELE_CHL_WIDTH(vht_op_ie + 2, 1);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ1(vht_op_ie + 2, center_freq);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ2(vht_op_ie + 2, 0);
} else {
RTW_ERR(FUNC_ADPT_FMT" unsupported BW:%u\n", FUNC_ADPT_ARG(adapter), bw);
rtw_warn_on(1);
}
}
}
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211N_HT
{
struct ht_priv *htpriv = &adapter->mlmepriv.htpriv;
u8 *ht_cap_ie, *ht_op_ie;
int ht_cap_ielen, ht_op_ielen;
ht_cap_ie = rtw_get_ie((bss->IEs + sizeof(NDIS_802_11_FIXED_IEs)), EID_HTCapability, &ht_cap_ielen, (bss->IELength - sizeof(NDIS_802_11_FIXED_IEs)));
ht_op_ie = rtw_get_ie((bss->IEs + sizeof(NDIS_802_11_FIXED_IEs)), EID_HTInfo, &ht_op_ielen, (bss->IELength - sizeof(NDIS_802_11_FIXED_IEs)));
/* update ht cap ie */
if (ht_cap_ie && ht_cap_ielen) {
#if UPDATE_HT_CAP
if (bw >= CHANNEL_WIDTH_40)
SET_HT_CAP_ELE_CHL_WIDTH(ht_cap_ie + 2, 1);
else
SET_HT_CAP_ELE_CHL_WIDTH(ht_cap_ie + 2, 0);
if (bw >= CHANNEL_WIDTH_40 && htpriv->sgi_40m)
SET_HT_CAP_ELE_SHORT_GI40M(ht_cap_ie + 2, 1);
else
SET_HT_CAP_ELE_SHORT_GI40M(ht_cap_ie + 2, 0);
if (htpriv->sgi_20m)
SET_HT_CAP_ELE_SHORT_GI20M(ht_cap_ie + 2, 1);
else
SET_HT_CAP_ELE_SHORT_GI20M(ht_cap_ie + 2, 0);
#endif
}
/* update ht op ie */
if (ht_op_ie && ht_op_ielen) {
SET_HT_OP_ELE_PRI_CHL(ht_op_ie + 2, ch);
switch (offset) {
case CHAN_OFFSET_UPPER:
SET_HT_OP_ELE_2ND_CHL_OFFSET(ht_op_ie + 2, IEEE80211_SCA);
break;
case CHAN_OFFSET_LOWER:
SET_HT_OP_ELE_2ND_CHL_OFFSET(ht_op_ie + 2, IEEE80211_SCB);
break;
case CHAN_OFFSET_NO_EXT:
default:
break;
SET_HT_OP_ELE_2ND_CHL_OFFSET(ht_op_ie + 2, IEEE80211_SCN);
}
if (bw >= CHANNEL_WIDTH_40)
SET_HT_OP_ELE_STA_CHL_WIDTH(ht_op_ie + 2, 1);
else
SET_HT_OP_ELE_STA_CHL_WIDTH(ht_op_ie + 2, 0);
}
}
#endif /* CONFIG_80211N_HT */
}
static u8 rtw_ap_update_chbw_by_ifbmp(struct dvobj_priv *dvobj, u8 ifbmp
, u8 cur_ie_ch[], u8 cur_ie_bw[], u8 cur_ie_offset[]
, u8 dec_ch[], u8 dec_bw[], u8 dec_offset[]
, const char *caller)
{
_adapter *iface;
struct mlme_ext_priv *mlmeext;
WLAN_BSSID_EX *network;
u8 ifbmp_ch_changed = 0;
int i;
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
iface = dvobj->padapters[i];
mlmeext = &(iface->mlmeextpriv);
if (MLME_IS_ASOC(iface)) {
RTW_INFO(FUNC_ADPT_FMT" %u,%u,%u => %u,%u,%u%s\n", caller, ADPT_ARG(iface)
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset
, dec_ch[i], dec_bw[i], dec_offset[i]
, MLME_IS_OPCH_SW(iface) ? " OPCH_SW" : "");
} else {
RTW_INFO(FUNC_ADPT_FMT" %u,%u,%u => %u,%u,%u%s\n", caller, ADPT_ARG(iface)
, cur_ie_ch[i], cur_ie_bw[i], cur_ie_offset[i]
, dec_ch[i], dec_bw[i], dec_offset[i]
, MLME_IS_OPCH_SW(iface) ? " OPCH_SW" : "");
}
}
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
iface = dvobj->padapters[i];
mlmeext = &(iface->mlmeextpriv);
network = &(mlmeext->mlmext_info.network);
/* ch setting differs from mlmeext.network IE */
if (cur_ie_ch[i] != dec_ch[i]
|| cur_ie_bw[i] != dec_bw[i]
|| cur_ie_offset[i] != dec_offset[i])
ifbmp_ch_changed |= BIT(i);
/* ch setting differs from existing one */
if (MLME_IS_ASOC(iface)
&& (mlmeext->chandef.chan != dec_ch[i]
|| mlmeext->chandef.bw != dec_bw[i]
|| mlmeext->chandef.offset != dec_offset[i])
) {
if (rtw_linked_check(iface) == _TRUE) {
#ifdef CONFIG_SPCT_CH_SWITCH
if (1)
rtw_ap_inform_ch_switch(iface, dec_ch[i], dec_offset[i]);
else
#endif
#ifdef CONFIG_ECSA_PHL
if (CHK_ECSA_STATE(iface, ECSA_ST_NONE))
#endif
rtw_sta_flush(iface, _FALSE);
}
}
mlmeext->chandef.chan = dec_ch[i];
mlmeext->chandef.bw = dec_bw[i];
mlmeext->chandef.offset = dec_offset[i];
rtw_ap_update_bss_chbw(iface, network, dec_ch[i], dec_bw[i], dec_offset[i]);
}
return ifbmp_ch_changed;
}
static u8 rtw_ap_ch_specific_chk(_adapter *adapter, u8 ch, u8 *bw, u8 *offset, const char *caller)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
RT_CHANNEL_INFO *chset = adapter_to_chset(adapter);
int ch_idx;
u8 ret = _SUCCESS;
ch_idx = rtw_chset_search_ch(chset, ch);
if (ch_idx < 0) {
RTW_WARN("%s ch:%u doesn't fit in chplan\n", caller, ch);
ret = _FAIL;
goto exit;
}
if (chset[ch_idx].flags & RTW_CHF_NO_IR) {
RTW_WARN("%s ch:%u is passive\n", caller, ch);
ret = _FAIL;
goto exit;
}
rtw_adjust_chbw(adapter, ch, bw, offset);
if (!rtw_get_offset_by_chbw(ch, *bw, offset)) {
RTW_WARN("%s %u,%u has no valid offset\n", caller, ch, *bw);
ret = _FAIL;
goto exit;
}
while (!rtw_chset_is_chbw_valid(chset, ch, *bw, *offset, 0, 0)
|| (rtw_rfctl_dfs_domain_unknown(rfctl) && rtw_chset_is_dfs_chbw(chset, ch, *bw, *offset))
) {
if (*bw > CHANNEL_WIDTH_20)
(*bw)--;
if (*bw == CHANNEL_WIDTH_20) {
*offset = CHAN_OFFSET_NO_EXT;
break;
}
}
if (rtw_rfctl_dfs_domain_unknown(rfctl) && rtw_chset_is_dfs_chbw(chset, ch, *bw, *offset)) {
RTW_WARN("%s DFS channel %u can't be used\n", caller, ch);
ret = _FAIL;
goto exit;
}
exit:
return ret;
}
static bool rtw_ap_choose_chbw(_adapter *adapter, u8 sel_ch, u8 max_bw, u8 cur_ch
, u8 *ch, u8 *bw, u8 *offset, bool by_int_info, u8 mesh_only, const char *caller)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
bool ch_avail = _FALSE;
#if defined(CONFIG_DFS_MASTER)
if (!rtw_rfctl_dfs_domain_unknown(rfctl)) {
if (rfctl->radar_detected
&& rfctl->dbg_dfs_choose_dfs_ch_first
) {
ch_avail = rtw_choose_shortest_waiting_ch(rfctl, sel_ch, max_bw
, ch, bw, offset
, RTW_CHF_DFS, 0
, cur_ch, by_int_info, mesh_only);
if (ch_avail == _TRUE) {
RTW_INFO("%s choose 5G DFS channel for debug\n", caller);
goto exit;
}
}
if (rfctl->radar_detected
&& (rfctl->dfs_ch_sel_e_flags || rfctl->dfs_ch_sel_d_flags)
) {
ch_avail = rtw_choose_shortest_waiting_ch(rfctl, sel_ch, max_bw
, ch, bw, offset
, rfctl->dfs_ch_sel_e_flags, rfctl->dfs_ch_sel_d_flags
, cur_ch, by_int_info, mesh_only);
if (ch_avail == _TRUE) {
RTW_INFO("%s choose with dfs_ch_sel_ e_flags:0x%02x d_flags:0x%02x for debug\n"
, caller, rfctl->dfs_ch_sel_e_flags, rfctl->dfs_ch_sel_d_flags);
goto exit;
}
}
ch_avail = rtw_choose_shortest_waiting_ch(rfctl, sel_ch, max_bw
, ch, bw, offset
, 0, 0
, cur_ch, by_int_info, mesh_only);
} else
#endif /* defined(CONFIG_DFS_MASTER) */
{
ch_avail = rtw_choose_shortest_waiting_ch(rfctl, sel_ch, max_bw
, ch, bw, offset
, 0, RTW_CHF_DFS
, cur_ch, by_int_info, mesh_only);
}
#if defined(CONFIG_DFS_MASTER)
exit:
#endif
if (ch_avail == _FALSE)
RTW_WARN("%s no available channel\n", caller);
return ch_avail;
}
u8 rtw_ap_chbw_decision(_adapter *adapter, u8 ifbmp, u8 excl_ifbmp
, s16 req_ch, s8 req_bw, s8 req_offset, struct rtw_chan_def *chdef)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
RT_CHANNEL_INFO *chset = adapter_to_chset(adapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
bool ch_avail = _FALSE;
u8 cur_ie_ch[CONFIG_IFACE_NUMBER] = {0};
u8 cur_ie_bw[CONFIG_IFACE_NUMBER] = {0};
u8 cur_ie_offset[CONFIG_IFACE_NUMBER] = {0};
u8 dec_ch[CONFIG_IFACE_NUMBER] = {0};
u8 dec_bw[CONFIG_IFACE_NUMBER] = {0};
u8 dec_offset[CONFIG_IFACE_NUMBER] = {0};
u8 u_ch = 0, u_bw = 0, u_offset = 0;
struct mlme_ext_priv *mlmeext;
WLAN_BSSID_EX *network;
struct mi_state mstate;
struct mi_state mstate_others;
bool set_u_ch = _FALSE;
u8 ifbmp_others = 0xFF & ~ifbmp & ~excl_ifbmp;
u8 ifbmp_ch_changed = 0;
bool ifbmp_all_mesh = 0;
_adapter *iface;
int i;
#ifdef CONFIG_MCC_MODE
struct rtw_phl_com_t *phl_com = GET_PHL_COM(dvobj);
u8 mcc_sup = phl_com->dev_cap.mcc_sup;
#endif
#ifdef CONFIG_RTW_MESH
for (i = 0; i < dvobj->iface_nums; i++)
if ((ifbmp & BIT(i)) && dvobj->padapters)
if (!MLME_IS_MESH(dvobj->padapters[i]))
break;
ifbmp_all_mesh = i >= dvobj->iface_nums ? 1 : 0;
#endif
RTW_INFO("%s ifbmp:0x%02x excl_ifbmp:0x%02x req:%d,%d,%d\n", __func__
, ifbmp, excl_ifbmp, req_ch, req_bw, req_offset);
rtw_mi_status_by_ifbmp(dvobj, ifbmp, &mstate);
rtw_mi_status_by_ifbmp(dvobj, ifbmp_others, &mstate_others);
RTW_INFO("%s others ld_sta_num:%u, lg_sta_num:%u, ap_num:%u, mesh_num:%u\n"
, __func__, MSTATE_STA_LD_NUM(&mstate_others), MSTATE_STA_LG_NUM(&mstate_others)
, MSTATE_AP_NUM(&mstate_others), MSTATE_MESH_NUM(&mstate_others));
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
iface = dvobj->padapters[i];
mlmeext = &(iface->mlmeextpriv);
network = &(mlmeext->mlmext_info.network);
/* get current IE channel settings */
rtw_ies_get_chbw(BSS_EX_TLV_IES(network), BSS_EX_TLV_IES_LEN(network)
, &cur_ie_ch[i], &cur_ie_bw[i], &cur_ie_offset[i], 1, 1);
/* prepare temporary channel setting decision */
if (req_ch == 0) {
/* request comes from upper layer, use cur_ie values */
dec_ch[i] = cur_ie_ch[i];
dec_bw[i] = cur_ie_bw[i];
dec_offset[i] = cur_ie_offset[i];
} else {
/* use chbw of cur_ie updated with specifying req as temporary decision */
dec_ch[i] = (req_ch <= REQ_CH_NONE) ? cur_ie_ch[i] : req_ch;
if (req_bw <= REQ_BW_NONE) {
if (req_bw == REQ_BW_ORI)
dec_bw[i] = iface->mlmepriv.ori_chandef.bw;
else
dec_bw[i] = cur_ie_bw[i];
} else
dec_bw[i] = req_bw;
dec_offset[i] = (req_offset <= REQ_OFFSET_NONE) ? cur_ie_offset[i] : req_offset;
}
}
if (MSTATE_STA_LD_NUM(&mstate_others) || MSTATE_STA_LG_NUM(&mstate_others)
|| MSTATE_AP_NUM(&mstate_others) || MSTATE_MESH_NUM(&mstate_others)
) {
/* has linked/linking STA or has AP/Mesh mode */
rtw_warn_on(!rtw_mi_get_ch_setting_union_by_ifbmp(dvobj, ifbmp_others, &u_ch, &u_bw, &u_offset));
RTW_INFO("%s others union:%u,%u,%u\n", __func__, u_ch, u_bw, u_offset);
}
#ifdef CONFIG_MCC_MODE
if (mcc_sup && req_ch == 0) {
/* will disable MCC in ap starter prepare after v10 merge */
if (rtw_hw_mcc_chk_inprogress(adapter)) {
u8 if_id = adapter->iface_id;
mlmeext = &(adapter->mlmeextpriv);
/* check channel settings are the same */
if (cur_ie_ch[if_id] == mlmeext->chandef.chan
&& cur_ie_bw[if_id] == mlmeext->chandef.bw
&& cur_ie_offset[if_id] == mlmeext->chandef.offset) {
RTW_INFO(FUNC_ADPT_FMT"req ch settings are the same as current ch setting, go to exit\n"
, FUNC_ADPT_ARG(adapter));
goto exit;
} else {
RTW_WARN(FUNC_ADPT_FMT"request channel settings are different from current channel setting(%d,%d,%d,%d,%d,%d), restart MCC\n"
, FUNC_ADPT_ARG(adapter)
, cur_ie_ch[if_id], cur_ie_bw[if_id], cur_ie_offset[if_id]
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset);
#if 0
rtw_hal_set_mcc_setting_disconnect(adapter);
#endif
}
}
}
#endif /* CONFIG_MCC_MODE */
if (MSTATE_STA_LG_NUM(&mstate_others) && !MSTATE_STA_LD_NUM(&mstate_others)) {
/* has linking STA but no linked STA */
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
iface = dvobj->padapters[i];
rtw_adjust_chbw(iface, dec_ch[i], &dec_bw[i], &dec_offset[i]);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(iface))
rtw_mesh_adjust_chbw(dec_ch[i], &dec_bw[i], &dec_offset[i]);
#endif
if (rtw_is_chbw_grouped(u_ch, u_bw, u_offset, dec_ch[i], dec_bw[i], dec_offset[i])) {
rtw_chset_sync_chbw(chset
, &dec_ch[i], &dec_bw[i], &dec_offset[i]
, &u_ch, &u_bw, &u_offset, 1, 0);
set_u_ch = _TRUE;
} else {
#ifdef CONFIG_MCC_MODE
if (mcc_sup) {
mlmeext = &(iface->mlmeextpriv);
mlmeext->chandef.chan = chdef->chan= dec_ch[i];
mlmeext->chandef.bw = chdef->bw= dec_bw[i];
mlmeext->chandef.offset = chdef->offset= dec_offset[i];
RTW_INFO(FUNC_ADPT_FMT" enable mcc: %u,%u,%u\n", FUNC_ADPT_ARG(iface)
, chdef->chan, chdef->bw, chdef->offset);
goto exit;
}
#endif /* CONFIG_MCC_MODE */
/* set this for possible ch change when join down*/
set_fwstate(&iface->mlmepriv, WIFI_OP_CH_SWITCHING);
}
}
} else if (MSTATE_STA_LD_NUM(&mstate_others)
|| MSTATE_AP_NUM(&mstate_others) || MSTATE_MESH_NUM(&mstate_others)
) {
/* has linked STA mode or AP/Mesh mode */
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
iface = dvobj->padapters[i];
#ifdef CONFIG_MCC_MODE
if (mcc_sup) {
if (!rtw_is_chbw_grouped(u_ch, u_bw, u_offset, dec_ch[i], dec_bw[i], dec_offset[i])) {
mlmeext = &(iface->mlmeextpriv);
mlmeext->chandef.chan = chdef->chan = dec_ch[i] = cur_ie_ch[i];
mlmeext->chandef.bw = chdef->bw = dec_bw[i] = cur_ie_bw[i];
mlmeext->chandef.offset = chdef->offset = dec_offset[i] = cur_ie_offset[i];
RTW_INFO(FUNC_ADPT_FMT" enable mcc: %u,%u,%u\n", FUNC_ADPT_ARG(iface)
, chdef->chan, chdef->bw, chdef->offset);
goto exit;
}
}
#endif /* CONFIG_MCC_MODE */
rtw_adjust_chbw(iface, u_ch, &dec_bw[i], &dec_offset[i]);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(iface))
rtw_mesh_adjust_chbw(u_ch, &dec_bw[i], &dec_offset[i]);
#endif
if (req_ch == 0 && dec_bw[i] > u_bw
&& rtw_chset_is_dfs_chbw(chset, u_ch, u_bw, u_offset)
) {
/* request comes from upper layer, prevent from additional channel waiting */
dec_bw[i] = u_bw;
if (dec_bw[i] == CHANNEL_WIDTH_20)
dec_offset[i] = CHAN_OFFSET_NO_EXT;
}
/* follow */
rtw_chset_sync_chbw(chset
, &dec_ch[i], &dec_bw[i], &dec_offset[i]
, &u_ch, &u_bw, &u_offset, 1, 0);
}
set_u_ch = _TRUE;
} else {
/* autonomous decision */
u8 ori_ch = 0;
u8 max_bw;
bool by_int_info;
if (req_ch <= REQ_CH_NONE) /* channel is not specified */
goto choose_chbw;
/* get tmp dec union of ifbmp */
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
if (u_ch == 0) {
u_ch = dec_ch[i];
u_bw = dec_bw[i];
u_offset = dec_offset[i];
rtw_adjust_chbw(adapter, u_ch, &u_bw, &u_offset);
rtw_get_offset_by_chbw(u_ch, u_bw, &u_offset);
} else {
u8 tmp_ch = dec_ch[i];
u8 tmp_bw = dec_bw[i];
u8 tmp_offset = dec_offset[i];
rtw_adjust_chbw(adapter, tmp_ch, &tmp_bw, &tmp_offset);
rtw_get_offset_by_chbw(tmp_ch, tmp_bw, &tmp_offset);
rtw_warn_on(!rtw_is_chbw_grouped(u_ch, u_bw, u_offset, tmp_ch, tmp_bw, tmp_offset));
rtw_sync_chbw(&tmp_ch, &tmp_bw, &tmp_offset, &u_ch, &u_bw, &u_offset);
}
}
#ifdef CONFIG_RTW_MESH
/* if ifbmp are all mesh, apply bw restriction */
if (ifbmp_all_mesh)
rtw_mesh_adjust_chbw(u_ch, &u_bw, &u_offset);
#endif
RTW_INFO("%s ifbmp:0x%02x tmp union:%u,%u,%u\n", __func__, ifbmp, u_ch, u_bw, u_offset);
/* check if tmp dec union is usable */
if (rtw_ap_ch_specific_chk(adapter, u_ch, &u_bw, &u_offset, __func__) == _FAIL) {
/* channel can't be used */
if (req_ch > 0) {
/* specific channel and not from IE => don't change channel setting */
goto exit;
}
goto choose_chbw;
} else if (rtw_chset_is_chbw_non_ocp(chset, u_ch, u_bw, u_offset)) {
RTW_WARN("%s DFS channel %u,%u under non ocp\n", __func__, u_ch, u_bw);
if (req_ch > 0 && req_bw > REQ_BW_NONE) {
/* change_chbw with specific channel and specific bw, goto update_bss_chbw directly */
goto update_bss_chbw;
}
} else
goto update_bss_chbw;
choose_chbw:
by_int_info = req_ch == REQ_CH_INT_INFO ? 1 : 0;
req_ch = req_ch > 0 ? req_ch : 0;
max_bw = req_bw > REQ_BW_NONE ? req_bw : CHANNEL_WIDTH_20;
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
iface = dvobj->padapters[i];
mlmeext = &(iface->mlmeextpriv);
if (req_bw <= REQ_BW_NONE) {
if (req_bw == REQ_BW_ORI) {
if (max_bw < iface->mlmepriv.ori_chandef.bw)
max_bw = iface->mlmepriv.ori_chandef.bw;
} else {
if (max_bw < cur_ie_bw[i])
max_bw = cur_ie_bw[i];
}
}
if (MSTATE_AP_NUM(&mstate) || MSTATE_MESH_NUM(&mstate)) {
if (ori_ch == 0)
ori_ch = mlmeext->chandef.chan;
else if (ori_ch != mlmeext->chandef.chan)
rtw_warn_on(1);
} else {
if (ori_ch == 0)
ori_ch = cur_ie_ch[i];
else if (ori_ch != cur_ie_ch[i])
rtw_warn_on(1);
}
}
ch_avail = rtw_ap_choose_chbw(adapter, req_ch, max_bw
, ori_ch, &u_ch, &u_bw, &u_offset, by_int_info, ifbmp_all_mesh, __func__);
if (ch_avail == _FALSE)
goto exit;
update_bss_chbw:
for (i = 0; i < dvobj->iface_nums; i++) {
if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
continue;
iface = dvobj->padapters[i];
dec_ch[i] = u_ch;
if (dec_bw[i] > u_bw)
dec_bw[i] = u_bw;
if (dec_bw[i] == CHANNEL_WIDTH_20)
dec_offset[i] = CHAN_OFFSET_NO_EXT;
else
dec_offset[i] = u_offset;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(iface))
rtw_mesh_adjust_chbw(dec_ch[i], &dec_bw[i], &dec_offset[i]);
#endif
}
set_u_ch = _TRUE;
}
ifbmp_ch_changed = rtw_ap_update_chbw_by_ifbmp(dvobj, ifbmp
, cur_ie_ch, cur_ie_bw, cur_ie_offset
, dec_ch, dec_bw, dec_offset
, __func__);
if (u_ch != 0)
RTW_INFO("%s union:%u,%u,%u\n", __func__, u_ch, u_bw, u_offset);
if (rtw_mi_check_fwstate(adapter, WIFI_UNDER_SURVEY)) {
/* scanning, leave ch setting to scan state machine */
set_u_ch = _FALSE;
}
if (set_u_ch == _TRUE) {
chdef->chan= u_ch;
chdef->bw = u_bw;
chdef->offset= u_offset;
}
exit:
return ifbmp_ch_changed;
}
u8 rtw_ap_sta_states_check(_adapter *adapter)
{
struct sta_info *psta;
struct sta_priv *pstapriv = &adapter->stapriv;
_list *plist, *phead;
u8 rst = _FALSE;
if (!MLME_IS_AP(adapter) && !MLME_IS_MESH(adapter))
return _FALSE;
if (pstapriv->auth_list_cnt !=0)
return _TRUE;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
if (!(psta->state & WIFI_ASOC_STATE)) {
RTW_INFO(ADPT_FMT"- SoftAP/Mesh - sta under linking, its state = 0x%x\n", ADPT_ARG(adapter), psta->state);
rst = _TRUE;
break;
} else if (psta->state & WIFI_UNDER_KEY_HANDSHAKE) {
RTW_INFO(ADPT_FMT"- SoftAP/Mesh - sta under key handshaking, its state = 0x%x\n", ADPT_ARG(adapter), psta->state);
rst = _TRUE;
break;
}
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
return rst;
}
void rtw_ap_parse_sta_capability(_adapter *adapter, struct sta_info *sta, u8 *cap)
{
sta->capability = RTW_GET_LE16(cap);
if (sta->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
sta->flags |= WLAN_STA_SHORT_PREAMBLE;
else
sta->flags &= ~WLAN_STA_SHORT_PREAMBLE;
}
u16 rtw_ap_parse_sta_supported_rates(_adapter *adapter, struct sta_info *sta, u8 *tlv_ies, u16 tlv_ies_len)
{
u8 rate_set[12];
u8 rate_num;
int i;
u16 status = _STATS_SUCCESSFUL_;
rtw_ies_get_supported_rate(tlv_ies, tlv_ies_len, rate_set, &rate_num);
if (rate_num == 0) {
RTW_INFO(FUNC_ADPT_FMT" sta "MAC_FMT" with no supported rate\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
status = _STATS_FAILURE_;
goto exit;
}
_rtw_memcpy(sta->bssrateset, rate_set, rate_num);
sta->bssratelen = rate_num;
if (MLME_IS_AP(adapter)) {
/* this function force only CCK rates to be bassic rate... */
UpdateBrateTblForSoftAP(sta->bssrateset, sta->bssratelen);
}
/* if (hapd->iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G) */ /* ? */
sta->flags |= WLAN_STA_NONERP;
for (i = 0; i < sta->bssratelen; i++) {
if ((sta->bssrateset[i] & 0x7f) > 22) {
sta->flags &= ~WLAN_STA_NONERP;
break;
}
}
exit:
return status;
}
u16 rtw_ap_parse_sta_security_ie(_adapter *adapter, struct sta_info *sta, struct rtw_ieee802_11_elems *elems)
{
struct security_priv *sec = &adapter->securitypriv;
u8 *wpa_ie;
int wpa_ie_len;
int group_cipher = 0, pairwise_cipher = 0, gmcs = 0;
u32 akm = 0;
u8 mfp_opt = MFP_NO;
u8 spp_opt = 0;
u16 status = _STATS_SUCCESSFUL_;
sta->dot8021xalg = 0;
sta->wpa_psk = 0;
sta->wpa_group_cipher = 0;
sta->wpa2_group_cipher = 0;
sta->wpa_pairwise_cipher = 0;
sta->wpa2_pairwise_cipher = 0;
sta->akm_suite_type = 0;
_rtw_memset(sta->wpa_ie, 0, sizeof(sta->wpa_ie));
if ((sec->wpa_psk & BIT(1)) && elems->rsn_ie) {
wpa_ie = elems->rsn_ie;
wpa_ie_len = elems->rsn_ie_len;
if (rtw_parse_wpa2_ie(wpa_ie - 2, wpa_ie_len + 2, &group_cipher, &pairwise_cipher, &gmcs, &akm, &mfp_opt, &spp_opt) == _SUCCESS) {
sta->dot8021xalg = 1;/* psk, todo:802.1x */
sta->wpa_psk |= BIT(1);
/* RSN optional field absent; the validation is already checked in rtw_rsne_info_parse() */
if (!group_cipher) {
RTW_INFO("STA lacks WPA2 Group Suite Cipher --> Default\n");
group_cipher = sec->wpa2_group_cipher;
}
if (!pairwise_cipher) {
RTW_INFO("STA lacks WPA2 Pairwise Suite Cipher --> Default\n");
pairwise_cipher = sec->wpa2_pairwise_cipher;
}
if (!akm) {
RTW_INFO("STA lacks WPA2 AKM Cipher --> Default\n");
akm = sec->akmp;
}
sta->wpa2_group_cipher = group_cipher & sec->wpa2_group_cipher;
sta->wpa2_pairwise_cipher = pairwise_cipher & sec->wpa2_pairwise_cipher;
sta->akm_suite_type = akm;
if (MLME_IS_AP(adapter) && (CHECK_BIT(WLAN_AKM_TYPE_SAE, akm)) && (MFP_NO == mfp_opt)) {
status = WLAN_STATUS_ROBUST_MGMT_FRAME_POLICY_VIOLATION;
goto exit;
}
/* RSN optional field exists but no match */
if (!sta->wpa2_group_cipher) {
status = WLAN_STATUS_GROUP_CIPHER_NOT_VALID;
goto exit;
}
if (!sta->wpa2_pairwise_cipher) {
status = WLAN_STATUS_PAIRWISE_CIPHER_NOT_VALID;
goto exit;
}
if (MLME_IS_AP(adapter) && (!CHECK_BIT(sec->akmp, akm))) {
status = WLAN_STATUS_AKMP_NOT_VALID;
goto exit;
}
}
else {
status = WLAN_STATUS_INVALID_IE;
goto exit;
}
}
else if ((sec->wpa_psk & BIT(0)) && elems->wpa_ie) {
wpa_ie = elems->wpa_ie;
wpa_ie_len = elems->wpa_ie_len;
if (rtw_parse_wpa_ie(wpa_ie - 2, wpa_ie_len + 2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
sta->dot8021xalg = 1;/* psk, todo:802.1x */
sta->wpa_psk |= BIT(0);
sta->wpa_group_cipher = group_cipher & sec->wpa_group_cipher;
sta->wpa_pairwise_cipher = pairwise_cipher & sec->wpa_pairwise_cipher;
if (!sta->wpa_group_cipher) {
status = WLAN_STATUS_GROUP_CIPHER_NOT_VALID;
goto exit;
}
if (!sta->wpa_pairwise_cipher) {
status = WLAN_STATUS_PAIRWISE_CIPHER_NOT_VALID;
goto exit;
}
} else {
status = WLAN_STATUS_INVALID_IE;
goto exit;
}
} else {
wpa_ie = NULL;
wpa_ie_len = 0;
}
if (sec->dot11PrivacyAlgrthm != _NO_PRIVACY_) {
/*check if amsdu is allowed */
if (rtw_check_amsdu_disable(adapter->registrypriv.amsdu_mode, spp_opt) == _TRUE)
sta->flags |= WLAN_STA_AMSDU_DISABLE;
}
if ((sec->mfp_opt == MFP_REQUIRED && mfp_opt < MFP_OPTIONAL)
|| (mfp_opt == MFP_REQUIRED && sec->mfp_opt < MFP_OPTIONAL)
) {
status = WLAN_STATUS_ROBUST_MGMT_FRAME_POLICY_VIOLATION;
goto exit;
}
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(adapter)) {
/* MFP is mandatory for secure mesh */
if (adapter->mesh_info.mesh_auth_id)
sta->flags |= WLAN_STA_MFP;
} else
#endif
if (sec->mfp_opt >= MFP_OPTIONAL && mfp_opt >= MFP_OPTIONAL)
sta->flags |= WLAN_STA_MFP;
#ifdef CONFIG_IEEE80211W
if ((sta->flags & WLAN_STA_MFP)
&& (sec->mfp_opt >= MFP_OPTIONAL && mfp_opt >= MFP_OPTIONAL)
&& security_type_bip_to_gmcs(sec->dot11wCipher) != gmcs
) {
status = WLAN_STATUS_CIPHER_REJECTED_PER_POLICY;
goto exit;
}
#endif
#ifdef CONFIG_IOCTL_CFG80211
if (MLME_IS_AP(adapter) &&
(sec->auth_type == MLME_AUTHTYPE_SAE) &&
(CHECK_BIT(WLAN_AKM_TYPE_SAE, sta->akm_suite_type)) &&
(WLAN_AUTH_OPEN == sta->authalg)) {
/* WPA3-SAE, PMK caching */
if (rtw_cached_pmkid(adapter, sta->phl_sta->mac_addr) == -1) {
RTW_INFO("SAE: No PMKSA cache entry found\n");
status = WLAN_STATUS_INVALID_PMKID;
goto exit;
} else {
RTW_INFO("SAE: PMKSA cache entry found\n");
}
}
#endif /* CONFIG_IOCTL_CFG80211 */
if (!MLME_IS_AP(adapter))
goto exit;
sta->flags &= ~(WLAN_STA_WPS | WLAN_STA_MAYBE_WPS);
/* if (hapd->conf->wps_state && wpa_ie == NULL) { */ /* todo: to check ap if supporting WPS */
if (wpa_ie == NULL) {
if (elems->wps_ie) {
RTW_INFO("STA included WPS IE in "
"(Re)Association Request - assume WPS is "
"used\n");
sta->flags |= WLAN_STA_WPS;
/* wpabuf_free(sta->wps_ie); */
/* sta->wps_ie = wpabuf_alloc_copy(elems.wps_ie + 4, */
/* elems.wps_ie_len - 4); */
} else {
RTW_INFO("STA did not include WPA/RSN IE "
"in (Re)Association Request - possible WPS "
"use\n");
sta->flags |= WLAN_STA_MAYBE_WPS;
}
/* AP support WPA/RSN, and sta is going to do WPS, but AP is not ready */
/* that the selected registrar of AP is _FLASE */
if ((sec->wpa_psk > 0)
&& (sta->flags & (WLAN_STA_WPS | WLAN_STA_MAYBE_WPS))
) {
struct mlme_priv *mlme = &adapter->mlmepriv;
if (mlme->wps_beacon_ie) {
u8 selected_registrar = 0;
rtw_get_wps_attr_content(mlme->wps_beacon_ie, mlme->wps_beacon_ie_len, WPS_ATTR_SELECTED_REGISTRAR, &selected_registrar, NULL);
if (!selected_registrar) {
RTW_INFO("selected_registrar is _FALSE , or AP is not ready to do WPS\n");
status = _STATS_UNABLE_HANDLE_STA_;
goto exit;
}
}
}
} else {
int copy_len;
if (sec->wpa_psk == 0) {
RTW_INFO("STA " MAC_FMT
": WPA/RSN IE in association request, but AP don't support WPA/RSN\n",
MAC_ARG(sta->phl_sta->mac_addr));
status = WLAN_STATUS_INVALID_IE;
goto exit;
}
if (elems->wps_ie) {
RTW_INFO("STA included WPS IE in "
"(Re)Association Request - WPS is "
"used\n");
sta->flags |= WLAN_STA_WPS;
copy_len = 0;
} else
copy_len = ((wpa_ie_len + 2) > sizeof(sta->wpa_ie)) ? (sizeof(sta->wpa_ie)) : (wpa_ie_len + 2);
if (copy_len > 0)
_rtw_memcpy(sta->wpa_ie, wpa_ie - 2, copy_len);
}
exit:
return status;
}
void rtw_ap_parse_sta_wmm_ie(_adapter *adapter, struct sta_info *sta, u8 *tlv_ies, u16 tlv_ies_len)
{
struct mlme_priv *mlme = &adapter->mlmepriv;
unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01};
u8 *p;
sta->flags &= ~WLAN_STA_WME;
sta->qos_option = 0;
sta->qos_info = 0;
sta->has_legacy_ac = _TRUE;
sta->uapsd_vo = 0;
sta->uapsd_vi = 0;
sta->uapsd_be = 0;
sta->uapsd_bk = 0;
if (!mlme->qospriv.qos_option)
goto exit;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(adapter)) {
/* QoS is mandatory in mesh */
sta->flags |= WLAN_STA_WME;
}
#endif
p = rtw_get_ie_ex(tlv_ies, tlv_ies_len, WLAN_EID_VENDOR_SPECIFIC, WMM_IE, 6, NULL, NULL);
if (!p)
goto exit;
sta->flags |= WLAN_STA_WME;
sta->qos_option = 1;
sta->qos_info = *(p + 8);
sta->max_sp_len = (sta->qos_info >> 5) & 0x3;
if ((sta->qos_info & 0xf) != 0xf)
sta->has_legacy_ac = _TRUE;
else
sta->has_legacy_ac = _FALSE;
if (sta->qos_info & 0xf) {
if (sta->qos_info & BIT(0))
sta->uapsd_vo = BIT(0) | BIT(1);
else
sta->uapsd_vo = 0;
if (sta->qos_info & BIT(1))
sta->uapsd_vi = BIT(0) | BIT(1);
else
sta->uapsd_vi = 0;
if (sta->qos_info & BIT(2))
sta->uapsd_bk = BIT(0) | BIT(1);
else
sta->uapsd_bk = 0;
if (sta->qos_info & BIT(3))
sta->uapsd_be = BIT(0) | BIT(1);
else
sta->uapsd_be = 0;
}
exit:
return;
}
void rtw_ap_parse_sta_ht_ie(_adapter *adapter, struct sta_info *sta, struct rtw_ieee802_11_elems *elems)
{
struct mlme_priv *mlme = &adapter->mlmepriv;
sta->flags &= ~WLAN_STA_HT;
#ifdef CONFIG_80211N_HT
if (mlme->htpriv.ht_option == _FALSE)
goto exit;
/* save HT capabilities in the sta object */
_rtw_memset(&sta->htpriv.ht_cap, 0, sizeof(struct rtw_ieee80211_ht_cap));
if (elems->ht_capabilities && elems->ht_capabilities_len >= sizeof(struct rtw_ieee80211_ht_cap)) {
sta->flags |= WLAN_STA_HT;
sta->flags |= WLAN_STA_WME;
_rtw_memcpy(&sta->htpriv.ht_cap, elems->ht_capabilities, sizeof(struct rtw_ieee80211_ht_cap));
if (elems->ht_operation && elems->ht_operation_len == HT_OP_IE_LEN) {
_rtw_memcpy(sta->htpriv.ht_op, elems->ht_operation, HT_OP_IE_LEN);
sta->htpriv.op_present = 1;
}
}
exit:
#endif
return;
}
void rtw_ap_parse_sta_vht_ie(_adapter *adapter, struct sta_info *sta, struct rtw_ieee802_11_elems *elems)
{
struct mlme_priv *mlme = &adapter->mlmepriv;
sta->flags &= ~WLAN_STA_VHT;
#ifdef CONFIG_80211AC_VHT
if (mlme->vhtpriv.vht_option == _FALSE)
goto exit;
_rtw_memset(&sta->vhtpriv, 0, sizeof(struct vht_priv));
if (elems->vht_capabilities && elems->vht_capabilities_len == VHT_CAP_IE_LEN) {
sta->flags |= WLAN_STA_VHT;
_rtw_memcpy(sta->vhtpriv.vht_cap, elems->vht_capabilities, VHT_CAP_IE_LEN);
if (elems->vht_operation && elems->vht_operation_len== VHT_OP_IE_LEN) {
_rtw_memcpy(sta->vhtpriv.vht_op, elems->vht_operation, VHT_OP_IE_LEN);
sta->vhtpriv.op_present = 1;
}
if (elems->vht_op_mode_notify && elems->vht_op_mode_notify_len == 1) {
_rtw_memcpy(&sta->vhtpriv.vht_op_mode_notify, elems->vht_op_mode_notify, 1);
sta->vhtpriv.notify_present = 1;
}
}
exit:
#endif
return;
}
void rtw_ap_parse_sta_he_ie(_adapter *adapter, struct sta_info *sta, struct rtw_ieee802_11_elems *elems)
{
struct mlme_priv *mlme = &adapter->mlmepriv;
sta->flags &= ~WLAN_STA_HE;
#ifdef CONFIG_80211AX_HE
if (mlme->hepriv.he_option == _FALSE)
goto exit;
_rtw_memset(&sta->hepriv, 0, sizeof(struct he_priv));
if (elems->he_capabilities && (elems->he_capabilities_len <= HE_CAP_ELE_MAX_LEN)) {
sta->flags |= WLAN_STA_HE;
_rtw_memcpy(sta->hepriv.he_cap, elems->he_capabilities, elems->he_capabilities_len);
if (elems->he_operation && (elems->he_operation_len <= HE_OPER_ELE_MAX_LEN)) {
_rtw_memcpy(sta->hepriv.he_op, elems->he_operation, elems->he_operation_len);
sta->hepriv.op_present = 1;
}
#if 0
if (elems->vht_op_mode_notify && elems->vht_op_mode_notify_len == 1) {
_rtw_memcpy(&sta->vhtpriv.vht_op_mode_notify, elems->vht_op_mode_notify, 1);
sta->vhtpriv.notify_present = 1;
}
#endif
}
exit:
#endif
return;
}
void rtw_ap_parse_sta_multi_ap_ie(_adapter *adapter, struct sta_info *sta, u8 *ies, int ies_len)
{
sta->flags &= ~WLAN_STA_MULTI_AP;
#ifdef CONFIG_RTW_MULTI_AP
if (adapter->multi_ap
&& (rtw_get_multi_ap_ie_ext(ies, ies_len) & MULTI_AP_BACKHAUL_STA)
) {
if (adapter->multi_ap & MULTI_AP_BACKHAUL_BSS) /* with backhaul bss, enable WDS */
sta->flags |= WLAN_STA_MULTI_AP | WLAN_STA_WDS;
else if (adapter->multi_ap & MULTI_AP_FRONTHAUL_BSS) /* fronthaul bss only */
sta->flags |= WLAN_STA_MULTI_AP;
}
#endif
}
#if CONFIG_RTW_AP_DATA_BMC_TO_UC
static bool rtw_ap_data_bmc_to_uc(_adapter *adapter
, const u8 *da, const u8 *sa, const u8 *ori_ta
, u16 os_qid, _list *b2u_list)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
_list *head, *list;
struct sta_info *sta;
char b2u_sta_id[NUM_STA];
u8 b2u_sta_num = 0;
bool bmc_need = _FALSE;
int i;
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
head = &stapriv->asoc_list;
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
int stainfo_offset;
sta = LIST_CONTAINOR(list, struct sta_info, asoc_list);
list = get_next(list);
stainfo_offset = rtw_stainfo_offset(stapriv, sta);
if (stainfo_offset_valid(stainfo_offset))
b2u_sta_id[b2u_sta_num++] = stainfo_offset;
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
if (!b2u_sta_num)
goto exit;
for (i = 0; i < b2u_sta_num; i++) {
struct xmit_frame *b2uframe = NULL;
struct pkt_attrib *attrib;
sta = rtw_get_stainfo_by_offset(stapriv, b2u_sta_id[i]);
if (!(sta->state & WIFI_ASOC_STATE)
|| _rtw_memcmp(sta->phl_sta->mac_addr, sa, ETH_ALEN) == _TRUE
|| (ori_ta && _rtw_memcmp(sta->phl_sta->mac_addr, ori_ta, ETH_ALEN) == _TRUE)
|| is_broadcast_mac_addr(sta->phl_sta->mac_addr)
|| is_zero_mac_addr(sta->phl_sta->mac_addr))
continue;
if (core_tx_alloc_xmitframe(adapter, &b2uframe, os_qid) == FAIL) {
bmc_need = _TRUE;
break;
}
attrib = &b2uframe->attrib;
_rtw_memcpy(attrib->ra, sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(attrib->ta, adapter_mac_addr(adapter), ETH_ALEN);
#ifdef CONFIG_RTW_WDS
if (adapter_use_wds(adapter) && (sta->flags & WLAN_STA_WDS)) {
_rtw_memcpy(attrib->dst, da, ETH_ALEN);
attrib->wds = 1;
} else
#endif
_rtw_memcpy(attrib->dst, attrib->ra, ETH_ALEN);
_rtw_memcpy(attrib->src, sa, ETH_ALEN);
rtw_list_insert_tail(&b2uframe->list, b2u_list);
}
exit:
return bmc_need;
}
void dump_ap_b2u_flags(void *sel, _adapter *adapter)
{
RTW_PRINT_SEL(sel, "%4s %4s\n", "src", "fwd");
RTW_PRINT_SEL(sel, "0x%02x 0x%02x\n", adapter->b2u_flags_ap_src, adapter->b2u_flags_ap_fwd);
}
#endif /* CONFIG_RTW_AP_DATA_BMC_TO_UC */
static int rtw_ap_nexthop_resolve(_adapter *adapter, struct xmit_frame *xframe)
{
struct pkt_attrib *attrib = &xframe->attrib;
int ret = _SUCCESS;
#ifdef CONFIG_RTW_WDS
if (adapter_use_wds(adapter)) {
if (rtw_wds_nexthop_lookup(adapter, attrib->dst, attrib->ra) == 0) {
if (_rtw_memcmp(attrib->dst, attrib->ra, ETH_ALEN) == _FALSE)
attrib->wds = 1;
} else {
ret = _FAIL;
}
} else
#endif
_rtw_memcpy(attrib->ra, attrib->dst, ETH_ALEN);
return ret;
}
#ifdef CONFIG_RTW_WDS
static void rtw_ap_data_flood_for_unknown_da(_adapter *adapter, const u8 *da,
const u8 *sa, const u8 *ori_ta,
u16 os_qid, _list *f_list)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
_list *head, *list;
struct sta_info *sta;
char sta_id[NUM_STA];
u8 sta_num = 0;
int i;
_rtw_spinlock_bh(&stapriv->asoc_list_lock);
head = &stapriv->asoc_list;
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
int stainfo_offset;
sta = LIST_CONTAINOR(list, struct sta_info, asoc_list);
list = get_next(list);
stainfo_offset = rtw_stainfo_offset(stapriv, sta);
if (stainfo_offset_valid(stainfo_offset))
sta_id[sta_num++] = stainfo_offset;
}
_rtw_spinunlock_bh(&stapriv->asoc_list_lock);
if (!sta_num)
goto exit;
for (i = 0; i < sta_num; i++) {
struct xmit_frame *frame;
struct pkt_attrib *attrib;
sta = rtw_get_stainfo_by_offset(stapriv, sta_id[i]);
if (!(sta->state & WIFI_ASOC_STATE)
|| !(sta->flags & WLAN_STA_WDS)
|| _rtw_memcmp(sta->phl_sta->mac_addr, sa, ETH_ALEN) == _TRUE
|| (ori_ta && _rtw_memcmp(sta->phl_sta->mac_addr, ori_ta, ETH_ALEN) == _TRUE)
|| is_broadcast_mac_addr(sta->phl_sta->mac_addr)
|| is_zero_mac_addr(sta->phl_sta->mac_addr))
continue;
if (core_tx_alloc_xmitframe(adapter, &frame, os_qid) == FAIL)
break;
attrib = &frame->attrib;
_rtw_memcpy(attrib->ra, sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(attrib->ta, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(attrib->dst, da, ETH_ALEN);
_rtw_memcpy(attrib->src, sa, ETH_ALEN);
attrib->wds = 1;
rtw_list_insert_tail(&frame->list, f_list);
}
exit:
return;
}
#endif /* CONFIG_RTW_WDS */
int rtw_ap_addr_resolve(_adapter *adapter, u16 os_qid, struct xmit_frame *xframe,
struct sk_buff *pkt, _list *f_list)
{
struct pkt_file pktfile;
struct ethhdr etherhdr;
struct pkt_attrib *attrib;
u8 is_da_mcast;
int res = _SUCCESS;
_rtw_open_pktfile(pkt, &pktfile);
if (_rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN) != ETH_HLEN) {
res = _FAIL;
goto exit;
}
xframe->pkt = pkt;
#if defined(CONFIG_RTW_WDS) || CONFIG_RTW_AP_DATA_BMC_TO_UC
_rtw_init_listhead(f_list);
#endif
is_da_mcast = IS_MCAST(etherhdr.h_dest);
if (is_da_mcast) {
#if CONFIG_RTW_AP_DATA_BMC_TO_UC
if (rtw_ap_src_b2u_policy_chk(adapter->b2u_flags_ap_src, etherhdr.h_dest)
&& adapter->registrypriv.wifi_spec == 0
&& adapter->xmitpriv.free_xmitframe_cnt > (NR_XMITFRAME / 4)) {
if (rtw_ap_data_bmc_to_uc(adapter, etherhdr.h_dest,
etherhdr.h_source, NULL,
os_qid, f_list) == 0) {
res = RTW_ORI_NO_NEED;
goto exit;
}
}
#endif
}
attrib = &xframe->attrib;
_rtw_memcpy(attrib->dst, etherhdr.h_dest, ETH_ALEN);
_rtw_memcpy(attrib->src, etherhdr.h_source, ETH_ALEN);
_rtw_memcpy(attrib->ta, adapter_mac_addr(adapter), ETH_ALEN);
if (is_da_mcast) {
_rtw_memcpy(attrib->ra, attrib->dst, ETH_ALEN);
} else {
res = rtw_ap_nexthop_resolve(adapter, xframe);
#ifdef CONFIG_RTW_WDS
if (res != _SUCCESS) {
/* unknown DA, flood frame to every WDS STA */
rtw_ap_data_flood_for_unknown_da(adapter, etherhdr.h_dest,
etherhdr.h_source, NULL,
os_qid, f_list);
res = RTW_ORI_NO_NEED;
}
#endif
}
exit:
return res;
}
int rtw_ap_rx_data_validate_hdr(_adapter *adapter, union recv_frame *rframe, struct sta_info **sta)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct rx_pkt_attrib *rattrib = &rframe->u.hdr.attrib;
u8 *whdr = get_recvframe_data(rframe);
u8 is_ra_bmc = 0;
sint ret = _FAIL;
if (!(MLME_STATE(adapter) & WIFI_ASOC_STATE))
goto exit;
switch (rattrib->to_fr_ds) {
case 2:
if (IS_MCAST(GetAddr1Ptr(whdr)))
goto exit;
_rtw_memcpy(rattrib->ra, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->ta, get_addr2_ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->dst, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->src, get_addr2_ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->bssid, GetAddr1Ptr(whdr), ETH_ALEN);
break;
case 3:
is_ra_bmc = IS_MCAST(GetAddr1Ptr(whdr)) ? 1 : 0;
_rtw_memcpy(rattrib->ra, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->ta, get_addr2_ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->dst, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->src, GetAddr4Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
if (!is_ra_bmc)
_rtw_memcpy(rattrib->bssid, GetAddr1Ptr(whdr), ETH_ALEN);
break;
default:
ret = RTW_RX_HANDLED; /* don't count for drop */
goto exit;
}
*sta = rtw_get_stainfo(stapriv, rattrib->ta);
if (*sta == NULL) {
if (!is_ra_bmc && !IS_RADAR_DETECTED(adapter_to_rfctl(adapter))) {
#ifndef CONFIG_CUSTOMER_ALIBABA_GENERAL
RTW_INFO(FUNC_ADPT_FMT" issue_deauth to "MAC_FMT" with reason(7), unknown TA\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(rattrib->ta));
issue_deauth(adapter, rattrib->ta, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
#endif
}
ret = RTW_RX_HANDLED;
goto exit;
}
#ifdef CONFIG_RTW_WDS_AUTO_EN
if (rattrib->to_fr_ds == 3 && !(sta->flags & WLAN_STA_WDS))
sta->flags |= WLAN_STA_WDS;
#endif
process_pwrbit_data(adapter, rframe, *sta);
if ((get_frame_sub_type(whdr) & WIFI_QOS_DATA_TYPE) == WIFI_QOS_DATA_TYPE)
process_wmmps_data(adapter, rframe, *sta);
if (get_frame_sub_type(whdr) & BIT(6)) {
/* No data, will not indicate to upper layer, temporily count it here */
count_rx_stats(adapter, rframe, *sta);
ret = RTW_RX_HANDLED;
goto exit;
}
ret = _SUCCESS;
exit:
return ret;
}
int rtw_ap_rx_msdu_act_check(union recv_frame *rframe
, const u8 *da, const u8 *sa
, u8 *msdu, enum rtw_rx_llc_hdl llc_hdl
, struct xmit_frame **fwd_frame, _list *f_list)
{
_adapter *adapter = rframe->u.hdr.adapter;
struct rx_pkt_attrib *rattrib = &rframe->u.hdr.attrib;
struct rtw_wds_path *wpath;
u8 is_da_bmc = IS_MCAST(da);
u8 is_da_self = !is_da_bmc && _rtw_memcmp(da, adapter_mac_addr(adapter), ETH_ALEN);
u8 is_da_peer = 0;
int in_wds_tbl = 0;
u16 os_qid;
struct xmit_frame *xframe;
struct pkt_attrib *xattrib;
u8 fwd_ra[ETH_ALEN] = {0};
int act = 0;
#ifdef CONFIG_RTW_WDS
/* update/create wds info for SA, RA */
if (adapter_use_wds(adapter)
&& (rframe->u.hdr.psta->state & WIFI_ASOC_STATE)
&& _rtw_memcmp(sa, rframe->u.hdr.psta->phl_sta->mac_addr, ETH_ALEN) == _FALSE
) {
rtw_rcu_read_lock();
wpath = rtw_wds_path_lookup(adapter, sa);
if (!wpath)
rtw_wds_path_add(adapter, sa, rframe->u.hdr.psta);
else {
rtw_wds_path_assign_nexthop(wpath, rframe->u.hdr.psta);
wpath->last_update = rtw_get_current_time();
}
rtw_rcu_read_unlock();
}
#endif
/* SA is self, need no further process */
if (_rtw_memcmp(sa, adapter_mac_addr(adapter), ETH_ALEN) == _TRUE)
goto exit;
if (is_da_bmc) {
/* DA is bmc addr */
act |= RTW_RX_MSDU_ACT_INDICATE;
#if 0 /* TODO: ap_isolate */
if (adapter->mlmepriv.ap_isolate)
goto exit;
#endif
goto fwd_chk;
}
if (is_da_self) {
/* DA is self, indicate */
act |= RTW_RX_MSDU_ACT_INDICATE;
goto exit;
}
/* DA is not self */
#ifdef CONFIG_RTW_WDS
if (adapter_use_wds(adapter))
in_wds_tbl = rtw_wds_nexthop_lookup(adapter, da, fwd_ra) == 0;
#endif
if (!in_wds_tbl)
is_da_peer = rtw_get_stainfo(&adapter->stapriv, da) ? 1 : 0;
if (in_wds_tbl || is_da_peer) {
/* DA is known (peer or can be forwarded by peer) */
#if 0 /* TODO: ap_isolate */
if (adapter->mlmepriv.ap_isolate) {
#if defined(DBG_RX_DROP_FRAME)
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" DA("MAC_FMT") through peer, ap_isolate\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(da));
#endif
goto exit;
}
#endif
goto fwd_chk;
}
/* DA is unknown*/
act |= RTW_RX_MSDU_ACT_INDICATE;
#if 0 /* TODO: ap_isolate */
if (adapter->mlmepriv.ap_isolate) {
/*
* unknown DA and ap_isolate, indicate only
* (bridge will not forward packets to originating port)
*/
goto exit;
}
#endif
fwd_chk:
if (adapter->stapriv.asoc_list_cnt <= 1)
goto exit;
os_qid = rtw_os_recv_select_queue(msdu, llc_hdl);
#if defined(CONFIG_RTW_WDS) || CONFIG_RTW_AP_DATA_BMC_TO_UC
_rtw_init_listhead(f_list);
#endif
#if CONFIG_RTW_AP_DATA_BMC_TO_UC
if (is_da_bmc) {
if (rtw_ap_fwd_b2u_policy_chk(adapter->b2u_flags_ap_fwd, da, rattrib->to_fr_ds == 3 && !IS_MCAST(rattrib->ra))
&& adapter->registrypriv.wifi_spec == 0
&& adapter->xmitpriv.free_xmitframe_cnt > (NR_XMITFRAME / 4)
) {
if (rtw_ap_data_bmc_to_uc(adapter
, da, sa, rframe->u.hdr.psta->phl_sta->mac_addr
, os_qid, f_list) == 0
) {
if (!rtw_is_list_empty(f_list))
goto set_act_fwd;
else
goto exit;
}
}
} else
#endif
#ifdef CONFIG_RTW_WDS
if (adapter_use_wds(adapter) && !in_wds_tbl && !is_da_peer) {
/* unknown DA, flood frame to every WDS STA except receiving one */
rtw_ap_data_flood_for_unknown_da(adapter
, da, sa, rframe->u.hdr.psta->phl_sta->mac_addr
, os_qid, f_list);
if (!rtw_is_list_empty(f_list))
goto set_act_fwd;
else
goto exit;
} else
#endif
;
if (core_tx_alloc_xmitframe(adapter, &xframe, os_qid) == FAIL) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME "FUNC_ADPT_FMT" core_tx_alloc_xmitframe fail\n"
, FUNC_ADPT_ARG(adapter));
#endif
goto exit;
}
xattrib = &xframe->attrib;
_rtw_memcpy(xattrib->dst, da, ETH_ALEN);
_rtw_memcpy(xattrib->src, sa, ETH_ALEN);
_rtw_memcpy(xattrib->ta, adapter_mac_addr(adapter), ETH_ALEN);
#ifdef CONFIG_RTW_WDS
if (in_wds_tbl && _rtw_memcmp(da, fwd_ra, ETH_ALEN) == _FALSE) {
_rtw_memcpy(xattrib->ra, fwd_ra, ETH_ALEN);
xattrib->wds = 1;
} else
#endif
_rtw_memcpy(xattrib->ra, da, ETH_ALEN);
*fwd_frame = xframe;
#if defined(CONFIG_RTW_WDS) || CONFIG_RTW_AP_DATA_BMC_TO_UC
set_act_fwd:
#endif
act |= RTW_RX_MSDU_ACT_FORWARD;
exit:
return act;
}
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
void rtw_issue_action_token_req(_adapter *padapter, struct sta_info *pstat)
{
/* Token Request Format
Category code : 1 Byte
Action code : 1 Byte
Element field: 4 Bytes, the duration of data transmission requested for the station.
*/
u8 val = 0x0;
u8 category = RTW_WLAN_CATEGORY_TBTX;
u32 tbtx_duration = TBTX_TX_DURATION*1000;
u8 *pframe;
unsigned short *fctrl;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct rtw_ieee80211_hdr *pwlanhdr;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = &(pmlmeinfo->network);
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
RTW_DBG("%s: %6ph\n", __FUNCTION__, pstat->phl_sta->mac_addr);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgnt_tx_rate(padapter, IEEE80211_OFDM_RATE_24MB); // issue action request using OFDM rate? 20190320 Bruce add
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy((void *)GetAddr1Ptr(pwlanhdr), pstat->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy((void *)get_addr2_ptr(pwlanhdr), adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy((void *)GetAddr3Ptr(pwlanhdr), get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(val), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *)&(tbtx_duration), &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
padapter->stapriv.last_token_holder = pstat;
dump_mgntframe(padapter, pmgntframe);
}
#endif /* CONFIG_RTW_TOKEN_BASED_XMIT */
void rtw_ap_set_sta_wmode(_adapter *padapter, struct sta_info *sta)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
WLAN_BSSID_EX *pcur_network = (WLAN_BSSID_EX *)&pmlmepriv->cur_network.network;
enum wlan_mode network_type = WLAN_MD_INVALID;
#ifdef CONFIG_80211AX_HE
if (sta->hepriv.he_option == _TRUE)
network_type = WLAN_MD_11AX;
#endif
#ifdef CONFIG_80211AC_VHT
if (network_type == WLAN_MD_INVALID) {
if (sta->vhtpriv.vht_option == _TRUE)
network_type = WLAN_MD_11AC;
}
#endif
#ifdef CONFIG_80211N_HT
if (network_type == WLAN_MD_INVALID) {
if (sta->htpriv.ht_option == _TRUE)
network_type = WLAN_MD_11N;
}
#endif
if (pcur_network->Configuration.DSConfig > 14)
network_type |= WLAN_MD_11A;
else {
if ((cckratesonly_included(sta->bssrateset, sta->bssratelen)) == _TRUE)
network_type |= WLAN_MD_11B;
else if ((cckrates_included(sta->bssrateset, sta->bssratelen)) == _TRUE)
network_type |= WLAN_MD_11BG;
else
network_type |= WLAN_MD_11G;
}
sta->phl_sta->wmode = network_type;
}
#if defined(CONFIG_RTW_ACS) && defined(WKARD_ACS)
void rtw_acs_start(_adapter *padapter)
{
RTW_INFO(FUNC_ADPT_FMT" not support\n", FUNC_ADPT_ARG(padapter));
}
void rtw_acs_stop(_adapter *padapter)
{
RTW_INFO(FUNC_ADPT_FMT" not support\n", FUNC_ADPT_ARG(padapter));
}
#endif /* defined(CONFIG_RTW_ACS) && defined(WKARD_ACS) */
#ifdef CONFIG_AP_CMD_DISPR
static enum rtw_phl_status _ap_start_swch_start_notify(struct _ADAPTER *padapter)
{
struct dvobj_priv *d = adapter_to_dvobj(padapter);
struct rtw_wifi_role_t *role = padapter->phl_role;
enum rtw_phl_status status;
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_AP_START);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_SWCH_START);
msg.band_idx = padapter->phl_role->hw_band;
msg.rsvd[0] = (u8*)role;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
&msg, &attr, NULL);
return status;
}
static void _ap_start_swch_done_notify_cb(void *priv, struct phl_msg *msg)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
RTW_DBG(FUNC_ADPT_FMT ": ap_start_cmd_state=%u\n",
FUNC_ADPT_ARG(a), a->ap_start_cmd_state);
if (msg->inbuf) {
rtw_vmfree(msg->inbuf, msg->inlen);
msg->inbuf = NULL;
}
}
static enum rtw_phl_status
_ap_start_swch_done_notify(struct _ADAPTER *a, struct rtw_chan_def *chandef)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
u8 *info = NULL;
enum rtw_phl_status status;
info = rtw_vmalloc(sizeof(struct rtw_chan_def));
if (!info) {
RTW_ERR(FUNC_ADPT_FMT ": Allocate msg hub buffer fail!\n",
FUNC_ADPT_ARG(a));
return RTW_PHL_STATUS_RESOURCE;
}
_rtw_memcpy(info, chandef, sizeof(struct rtw_chan_def));
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_AP_START);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_SWCH_DONE);
msg.band_idx = a->phl_role->hw_band;
msg.inbuf = info;
msg.inlen = sizeof(struct rtw_chan_def);
attr.completion.completion = _ap_start_swch_done_notify_cb;
attr.completion.priv = a;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
&msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS) {
rtw_vmfree(info, sizeof(struct rtw_chan_def));
RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
}
return status;
}
static void _ap_start_end_notify_cb(void *priv, struct phl_msg *msg)
{
if (msg->inbuf) {
rtw_vmfree(msg->inbuf, msg->inlen);
msg->inbuf = NULL;
}
}
static enum rtw_phl_status
_ap_start_end_notify(struct _ADAPTER *padapter, bool success, bool abort)
{
struct rtw_wifi_role_t *role = padapter->phl_role;
struct dvobj_priv *d = adapter_to_dvobj(padapter);
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
u8 *info = NULL;
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_AP_START\n", FUNC_ADPT_ARG(padapter));
info = rtw_vmalloc(sizeof(u8));
if (info == NULL) {
RTW_ERR("%s: alloc buffer failed!\n", __func__);
return RTW_PHL_STATUS_RESOURCE;
}
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_AP_START);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_AP_START_END);
if (success) {
*info = RTW_PHL_STATUS_SUCCESS;
} else {
*info = RTW_PHL_STATUS_FAILURE;
}
msg.inbuf = info;
msg.inlen = 1;
msg.band_idx = role->hw_band;
msg.rsvd[0] = (u8*)role;
if(abort)
attr.opt = MSG_OPT_SEND_IN_ABORT;
attr.completion.completion = _ap_start_end_notify_cb;
attr.completion.priv = padapter;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
&msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS) {
rtw_vmfree(info, sizeof(u8));
RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
FUNC_ADPT_ARG(padapter), status);
}
return status;
}
static void ap_free_cmdobj(struct cmd_obj *pcmd)
{
struct _ADAPTER *padapter = pcmd->padapter;
if (!pcmd)
return;
if (pcmd->sctx) {
if (pcmd->res == H2C_SUCCESS)
rtw_sctx_done(&pcmd->sctx);
else
rtw_sctx_done_err(&pcmd->sctx, RTW_SCTX_DONE_CMD_ERROR);
}
rtw_free_cmd_obj(pcmd);
return;
}
static void _ap_start_cmd_done(struct cmd_obj *pcmd)
{
struct _ADAPTER *padapter = pcmd->padapter;
struct dvobj_priv *d = adapter_to_dvobj(padapter);
struct rtw_wifi_role_t *role = padapter->phl_role;
enum rtw_phl_status status;
RTW_INFO("%s: +\n", __func__);
if (!padapter->ap_start_cmd_token){
RTW_ERR("%s : token is NULL!\n", __func__);
return;
}
status = rtw_phl_free_cmd_token(GET_PHL_INFO(d),
role->hw_band, &padapter->ap_start_cmd_token);
padapter->ap_start_cmd_token = 0;
padapter->ap_start_cmd_state = 0;
if (status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": free_cmd_token fail(0x%x)!\n",
FUNC_ADPT_ARG(padapter), status);
ap_free_cmdobj(pcmd);
RTW_INFO("%s: -\n", __func__);
}
enum rtw_phl_status rtw_free_bcn_entry(struct _ADAPTER *padapter){
struct dvobj_priv *d = adapter_to_dvobj(padapter);
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
#ifdef RTW_PHL_BCN
status = rtw_phl_free_bcn_entry(d->phl, padapter->phl_role);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s - phl_free_bcn_entry failed\n", __func__);
}
#endif
return status;
}
static enum phl_mdl_ret_code _ap_start_req_acquired(void *dispr, void *priv)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
struct createbss_parm *parm = (struct createbss_parm *)pcmd->parmbuf;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct rtw_wifi_role_t *role = padapter->phl_role;
struct rtw_phl_com_t *phl_com = role->phl_com;
struct phl_info_t *phl_info = phl_com->phl_priv;
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(padapter));
if ((parm->req_ch == 0 && pmlmeinfo->state == WIFI_FW_AP_STATE)
|| parm->req_ch != 0
){
start_bss_network(padapter, parm);
}
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_AP_START);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_AP_START_PREPARE);
msg.band_idx = role->hw_band;
status = rtw_phl_send_msg_to_dispr(phl_info,
&msg,
&attr,
NULL);
if (status != RTW_PHL_STATUS_SUCCESS) {
return MDL_RET_FAIL;
} else {
SET_STATUS_FLAG(padapter->ap_start_cmd_state, CMD_APSTART_ACQUIRE);
return MDL_RET_SUCCESS;
}
}
static enum phl_mdl_ret_code _ap_start_req_abort(void *dispr, void *priv)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
if (TEST_STATUS_FLAG(padapter->ap_start_cmd_state, CMD_APSTART_ACQUIRE)) {
status = _ap_start_end_notify(padapter, false, true);
}
padapter->ap_start_cmd_state = 0;
RTW_INFO("%s\n", __func__);
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _ap_start_req_ev_hdlr(void *dispr, void *priv, struct phl_msg* msg)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
struct createbss_parm *parm = (struct createbss_parm *)pcmd->parmbuf;
struct rtw_wifi_role_t *wifi_role = padapter->phl_role;
struct rtw_phl_com_t *phl_com = wifi_role->phl_com;
void *d = phlcom_to_drvpriv(phl_com);
struct phl_msg nextmsg = {0};
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
RTW_DBG(FUNC_ADPT_FMT ": + msg_id=0x%08x\n",
FUNC_ADPT_ARG(padapter), msg->msg_id);
if (MSG_MDL_ID_FIELD(msg->msg_id) != PHL_FG_MDL_AP_START) {
RTW_INFO(FUNC_ADPT_FMT ": Message is not from ap start module, "
"skip msg_id=0x%08x\n", FUNC_ADPT_ARG(padapter), msg->msg_id);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(padapter));
return MDL_RET_IGNORE;
}
if (IS_MSG_FAIL(msg->msg_id)) {
RTW_WARN(FUNC_ADPT_FMT ": cmd dispatcher notify cmd failure on "
"msg_id=0x%08x\n", FUNC_ADPT_ARG(padapter), msg->msg_id);
}
SET_MSG_MDL_ID_FIELD(nextmsg.msg_id, PHL_FG_MDL_AP_START);
nextmsg.band_idx = wifi_role->hw_band;
switch(MSG_EVT_ID_FIELD(msg->msg_id)) {
case MSG_EVT_AP_START_PREPARE:
{
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_AP_START_PREPARE\n", FUNC_ADPT_ARG(padapter));
status = _ap_start_swch_start_notify(padapter);
if(status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR("%s :: [MSG_EVT_AP_START_PREPARE] rtw_phl_send_msg_to_dispr failed\n", __func__);
break;
}
case MSG_EVT_SWCH_START:
{
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_SWCH_START\n", FUNC_ADPT_ARG(padapter));
rtw_core_ap_swch_start(padapter, parm);
status = _ap_start_swch_done_notify(padapter, &wifi_role->chandef);
if(status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR("%s :: [SWCH_START] rtw_phl_send_msg_to_dispr failed\n", __func__);
break;
}
case MSG_EVT_SWCH_DONE:
{
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_SWCH_DONE\n", FUNC_ADPT_ARG(padapter));
status = rtw_phl_ap_started(adapter_to_dvobj(padapter)->phl, padapter->phl_role);
if(status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR("%s :: [MSG_EVT_SWCH_DONE] rtw_phl_send_msg_to_dispr failed\n", __func__);
break;
}
case MSG_EVT_AP_START:
{
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_AP_START\n", FUNC_ADPT_ARG(padapter));
rtw_core_ap_start(padapter, parm); /* send beacon */
status = _ap_start_end_notify(padapter, true, false);
break;
}
case MSG_EVT_AP_START_END:
{
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_AP_START_END\n", FUNC_ADPT_ARG(padapter));
if (msg->inbuf == NULL) {
RTW_WARN("[MSG_EVT_AP_START_END] Msg info buffer NULL!\n");
break;
}
if (*(msg->inbuf) == RTW_PHL_STATUS_FAILURE){
RTW_WARN("[MSG_EVT_AP_START_END] Msg_inbuf is FAIL!\n");
stop_ap_hdl(padapter);
}
_ap_start_cmd_done(pcmd);
break;
}
default:
/* unknown state */
break;
}
if (status != RTW_PHL_STATUS_SUCCESS) {
/* Trigger stop AP flow when start AP failure */
stop_ap_hdl(padapter);
_ap_start_cmd_done(pcmd);
}
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _ap_start_req_set_info(void *dispr, void *priv, struct phl_module_op_info* info)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(padapter));
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(padapter));
return MDL_RET_IGNORE;
}
static enum phl_mdl_ret_code _ap_start_req_query_info(void *dispr, void *priv, struct phl_module_op_info* info)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
enum phl_mdl_ret_code ret = MDL_RET_IGNORE;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(padapter));
switch (info->op_code) {
case FG_REQ_OP_GET_ROLE:
info->outbuf = (u8*)padapter->phl_role;
ret = MDL_RET_SUCCESS;
break;
default:
break;
}
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(padapter));
return ret;
}
static void rtw_cmd_ap_start_req_init(struct cmd_obj *pcmd, struct phl_cmd_token_req *fgreq)
{
struct _ADAPTER *padapter = pcmd->padapter;
u8 res = _SUCCESS;
/* Fill foreground command request */
fgreq->module_id= PHL_FG_MDL_AP_START;
fgreq->priv = pcmd;
fgreq->role = padapter->phl_role;
fgreq->acquired = _ap_start_req_acquired;
fgreq->abort = _ap_start_req_abort;
fgreq->msg_hdlr = _ap_start_req_ev_hdlr;
fgreq->set_info = _ap_start_req_set_info;
fgreq->query_info = _ap_start_req_query_info;
padapter->ap_start_cmd_state = 0;
padapter->ap_start_cmd_token = 0;
RTW_INFO("%s\n", __func__);
}
enum rtw_phl_status rtw_ap_start_cmd(struct cmd_obj *pcmd)
{
struct _ADAPTER *padapter = pcmd->padapter;
struct phl_cmd_token_req fgreq={0};
struct dvobj_priv *d = adapter_to_dvobj(padapter);
enum rtw_phl_status status;
struct rtw_wifi_role_t *role = padapter->phl_role;
rtw_cmd_ap_start_req_init(pcmd, &fgreq);
RTW_DBG(FUNC_ADPT_FMT ": \n", FUNC_ADPT_ARG(padapter));
/* cmd_dispatcher would copy whole phl_cmd_token_req */
status = rtw_phl_add_cmd_token_req(d->phl, role->hw_band, &fgreq, &padapter->ap_start_cmd_token);
if((status != RTW_PHL_STATUS_SUCCESS) &&
(status != RTW_PHL_STATUS_PENDING))
goto error;
status = RTW_PHL_STATUS_SUCCESS;
error:
return status;
}
static void _ap_stop_cmd_done(struct cmd_obj *pcmd)
{
struct _ADAPTER *padapter = pcmd->padapter;
struct dvobj_priv *d = adapter_to_dvobj(padapter);
struct rtw_wifi_role_t *role = padapter->phl_role;
enum rtw_phl_status status;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(padapter));
if (!padapter->ap_stop_cmd_token){
RTW_ERR("%s : token is NULL!\n", __func__);
return;
}
status = rtw_phl_free_cmd_token(GET_PHL_INFO(d),
role->hw_band, &padapter->ap_stop_cmd_token);
padapter->ap_stop_cmd_token = 0;
padapter->ap_stop_cmd_state = 0;
if (status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": free_cmd_token fail(0x%x)!\n",
FUNC_ADPT_ARG(padapter), status);
ap_free_cmdobj(pcmd);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(padapter));
}
static enum rtw_phl_status _ap_stop_ap_stop_notify(struct _ADAPTER *adapter)
{
struct dvobj_priv *d = adapter_to_dvobj(adapter);
struct rtw_wifi_role_t *role = adapter->phl_role;
enum rtw_phl_status status;
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_AP_STOP);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_AP_STOP);
msg.band_idx = adapter->phl_role->hw_band;
msg.rsvd[0] = (u8*)role;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
&msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n", FUNC_ADPT_ARG(adapter), status);
}
return status;
}
static void _ap_stop_abort_notify_cb(void *priv, struct phl_msg *msg)
{
_adapter *padapter = (_adapter *)priv;
struct dvobj_priv *d = adapter_to_dvobj(padapter);
struct _ADAPTER *adapter = (struct _ADAPTER *)priv;
enum rtw_phl_status phl_status = RTW_PHL_STATUS_SUCCESS;
struct rtw_chan_def chan_def = {0};
u8 chctx_num = 0;
#ifdef RTW_PHL_BCN
phl_status = rtw_phl_free_bcn_entry(d->phl, adapter->phl_role);
if (phl_status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s - phl_free_bcn_entry failed\n", __func__);
}
#endif
}
static enum rtw_phl_status _ap_stop_abort_notify(struct _ADAPTER *adapter, bool abort)
{
struct dvobj_priv *d = adapter_to_dvobj(adapter);
struct rtw_wifi_role_t *role = adapter->phl_role;
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_AP_STOP);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_AP_STOP);
msg.band_idx = role->hw_band;
msg.rsvd[0] = (u8*)role;
if(abort)
attr.opt = MSG_OPT_SEND_IN_ABORT;
attr.completion.completion = _ap_stop_abort_notify_cb;
attr.completion.priv = adapter;
status = rtw_phl_send_msg_to_dispr(d->phl,
&msg,
&attr,
NULL);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("[%s] Abort send msg fail!\n", __func__);
}
return status;
}
static enum phl_mdl_ret_code _ap_stop_req_acquired(void *dispr, void *priv)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
struct rtw_wifi_role_t *role = padapter->phl_role;
struct rtw_phl_com_t *phl_com = role->phl_com;
struct phl_info_t *phl_info = phl_com->phl_priv;
struct phl_msg msg = {0};
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(padapter));
SET_STATUS_FLAG(padapter->ap_stop_cmd_state, CMD_APSTOP_ACQUIRE);
rtw_phl_ap_stop(adapter_to_dvobj(padapter)->phl, role);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(padapter));
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _ap_stop_req_abort(void *dispr, void *priv)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
if(TEST_STATUS_FLAG(padapter->ap_stop_cmd_state, CMD_APSTOP_STARTED)){
/* case1: MSG_EVT_AP_STOP has been processed*/
}
else if(TEST_STATUS_FLAG(padapter->ap_stop_cmd_state, CMD_APSTOP_ACQUIRE)){
/* case2: MSG_EVT_AP_STOP in msgQ
case3: MSG_EVT_AP_STOP doesn't back to msg_hdlr yet */
if (RTW_PHL_STATUS_SUCCESS != _ap_stop_abort_notify(padapter, true)) {
/* do not execute core_mr_handle because do not know if the I/O operation is acceptable */
//core_mr_delete_chctx(adapter, &chctx_num, &chan_def);
}
}
else{
/* apstop token stay in tokenOpQ */
}
padapter->ap_stop_cmd_state = 0;
RTW_INFO("%s\n", __func__);
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _ap_stop_req_ev_hdlr(void *dispr, void *priv, struct phl_msg* msg)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
struct rtw_wifi_role_t *wifi_role = padapter->phl_role;
struct rtw_phl_com_t *phl_com = wifi_role->phl_com;
struct phl_info_t *phl_info = phl_com->phl_priv;
void *d = phlcom_to_drvpriv(phl_com);
struct phl_msg nextmsg = {0};
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
RTW_DBG(FUNC_ADPT_FMT ": + msg_id=0x%08x\n",
FUNC_ADPT_ARG(padapter), msg->msg_id);
if (MSG_MDL_ID_FIELD(msg->msg_id) != PHL_FG_MDL_AP_STOP) {
RTW_INFO(FUNC_ADPT_FMT ": Message is not from ap stop module, "
"skip msg_id=0x%08x\n", FUNC_ADPT_ARG(padapter), msg->msg_id);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(padapter));
return MDL_RET_IGNORE;
}
if (IS_MSG_FAIL(msg->msg_id)) {
RTW_WARN(FUNC_ADPT_FMT ": cmd dispatcher notify cmd failure on "
"msg_id=0x%08x\n", FUNC_ADPT_ARG(padapter), msg->msg_id);
}
SET_MSG_MDL_ID_FIELD(nextmsg.msg_id, PHL_FG_MDL_AP_STOP);
nextmsg.band_idx = wifi_role->hw_band;
switch(MSG_EVT_ID_FIELD(msg->msg_id)) {
case MSG_EVT_AP_STOP_PREPARE:
{
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_AP_STOP_PREPARE\n", FUNC_ADPT_ARG(padapter));
status = _ap_stop_ap_stop_notify(padapter);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s :: [MSG_EVT_AP_STOP_PREPARE] ap_stop_notify fail\n", __func__);
_ap_stop_cmd_done(pcmd);
}
break;
}
case MSG_EVT_AP_STOP:
{
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_SWCH_START\n", FUNC_ADPT_ARG(padapter));
stop_ap_hdl(padapter);
rtw_phl_ap_stop_resume_hdlr(phl_info, wifi_role);
_ap_stop_cmd_done(pcmd);
break;
}
default:
/* unknown state */
break;
}
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _ap_stop_req_set_info(void *dispr, void *priv, struct phl_module_op_info* info)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *padapter = pcmd->padapter;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(padapter));
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(padapter));
return MDL_RET_IGNORE;
}
static enum phl_mdl_ret_code _ap_stop_req_query_info(void *dispr, void *priv, struct phl_module_op_info* info)
{
struct cmd_obj *pcmd = (struct cmd_obj *)priv;
struct _ADAPTER *a = pcmd->padapter;
enum phl_mdl_ret_code ret = MDL_RET_IGNORE;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
switch (info->op_code) {
case FG_REQ_OP_GET_ROLE:
info->outbuf = (u8*)a->phl_role;
ret = MDL_RET_SUCCESS;
break;
default:
break;
}
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return ret;
}
static void rtw_cmd_ap_stop_req_init(struct cmd_obj *pcmd, struct phl_cmd_token_req *fgreq)
{
struct _ADAPTER *padapter = pcmd->padapter;
RTW_DBG(FUNC_ADPT_FMT ": \n", FUNC_ADPT_ARG(padapter));
/* Fill foreground command request */
fgreq->module_id= PHL_FG_MDL_AP_STOP;
fgreq->priv = pcmd;
fgreq->role = padapter->phl_role;
fgreq->acquired = _ap_stop_req_acquired;
fgreq->abort = _ap_stop_req_abort;
fgreq->msg_hdlr = _ap_stop_req_ev_hdlr;
fgreq->set_info = _ap_stop_req_set_info;
fgreq->query_info = _ap_stop_req_query_info;
padapter->ap_stop_cmd_state = 0;
padapter->ap_stop_cmd_token = 0;
}
enum rtw_phl_status rtw_ap_stop_cmd(struct cmd_obj *pcmd)
{
struct _ADAPTER *padapter = pcmd->padapter;
struct phl_cmd_token_req fgreq={0};
struct dvobj_priv *d = adapter_to_dvobj(padapter);
enum rtw_phl_status pstatus;
struct rtw_wifi_role_t *role = padapter->phl_role;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(padapter));
rtw_cmd_ap_stop_req_init(pcmd, &fgreq);
/* cmd_dispatcher would copy whole phl_cmd_token_req */
pstatus = rtw_phl_add_cmd_token_req(d->phl, role->hw_band, &fgreq, &padapter->ap_stop_cmd_token);
if((pstatus != RTW_PHL_STATUS_SUCCESS) &&
(pstatus != RTW_PHL_STATUS_PENDING))
goto error;
pstatus = RTW_PHL_STATUS_SUCCESS;
error:
return pstatus;
}
#endif
#endif /* CONFIG_AP_MODE */
|
2301_81045437/rtl8852be
|
core/rtw_ap.c
|
C
|
agpl-3.0
| 194,643
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_BEAMFORMING_C_
#include <drv_types.h>
#ifdef CONFIG_BEAMFORMING
#ifdef RTW_WKARD_TX_DISABLE_BFEE
void rtw_core_bf_watchdog(_adapter *padapter)
{
struct registry_priv *pregpriv = &padapter->registrypriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_phl_com_t *phl_com = GET_PHL_COM(dvobj);
struct rtw_wifi_role_t *wrole = NULL;
struct rtw_phl_stainfo_t *psta = NULL;
struct rtw_stats *phl_stats = NULL;
bool enable_bfee = false;
do {
if (padapter == NULL)
break;
if (1 != pregpriv->dyn_txbf) {
break;
}
wrole = padapter->phl_role;
//psta = padapter->stainfo;
if (wrole == NULL)
break;
psta = rtw_phl_get_stainfo_self(adapter_to_dvobj(padapter)->phl, wrole);
if (psta == NULL)
break;
if (PHL_RTYPE_STATION != wrole->type)
break;
if (MLME_NO_LINK == wrole->mstate)
break;
if ((wrole->proto_role_cap.he_su_bfme ||
wrole->proto_role_cap.he_mu_bfme) &&
(psta->asoc_cap.he_su_bfmr || psta->asoc_cap.he_mu_bfmr)) {
enable_bfee = true;
}
if ((wrole->proto_role_cap.vht_su_bfme ||
wrole->proto_role_cap.vht_mu_bfme) &&
(psta->asoc_cap.vht_su_bfmr ||
psta->asoc_cap.vht_mu_bfmr)) {
enable_bfee = true;
}
if (wrole->proto_role_cap.ht_su_bfme &&
psta->asoc_cap.ht_su_bfmr)
enable_bfee = true;
if (enable_bfee == false)
break;
phl_stats = &(phl_com->phl_stats);
if ((phl_stats->tx_traffic.lvl > phl_stats->rx_traffic.lvl) &&
(phl_stats->tx_traffic.lvl >= RTW_TFC_HIGH)) {
enable_bfee = false;
}
/*Per wrole->hw_band to control bfee, not per hw_port*/
rtw_phl_bfee_ctrl(GET_PHL_INFO(dvobj), wrole, enable_bfee);
/*RTW_INFO("[WKARD] Enable/Disable BFee function : BFee %d\n", enable_bfee);*/
} while (0);
}
#endif /*RTW_WKARD_TX_DISABLE_BFEE*/
#if 0
struct ndpa_sta_info {
u16 aid:12;
u16 feedback_type:1;
u16 nc_index:3;
};
static void _get_txvector_parameter(_adapter *adapter, struct sta_info *sta, u8 *g_id, u16 *p_aid)
{
struct mlme_priv *mlme;
u16 aid;
u8 *bssid;
u16 val16;
u8 i;
mlme = &adapter->mlmepriv;
if (check_fwstate(mlme, WIFI_AP_STATE)) {
/*
* Sent by an AP and addressed to a STA associated with that AP
* or sent by a DLS or TDLS STA in a direct path to
* a DLS or TDLS peer STA
*/
aid = sta->phl_sta->aid;
bssid = adapter_mac_addr(adapter);
RTW_INFO("%s: AID=0x%x BSSID=" MAC_FMT "\n",
__FUNCTION__, sta->phl_sta->aid, MAC_ARG(bssid));
/* AID[0:8] */
aid &= 0x1FF;
/* BSSID[44:47] xor BSSID[40:43] */
val16 = ((bssid[5] & 0xF0) >> 4) ^ (bssid[5] & 0xF);
/* (dec(AID[0:8]) + dec(BSSID)*2^5) mod 2^9 */
*p_aid = (aid + (val16 << 5)) & 0x1FF;
*g_id = 63;
} else if ((check_fwstate(mlme, WIFI_ADHOC_STATE) == _TRUE)
|| (check_fwstate(mlme, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
/*
* Otherwise, includes
* 1. Sent to an IBSS STA
* 2. Sent by an AP to a non associated STA
* 3. Sent to a STA for which it is not known
* which condition is applicable
*/
*p_aid = 0;
*g_id = 63;
} else {
/* Addressed to AP */
bssid = sta->phl_sta->mac_addr;
RTW_INFO("%s: BSSID=" MAC_FMT "\n", __FUNCTION__, MAC_ARG(bssid));
/* BSSID[39:47] */
*p_aid = (bssid[5] << 1) | (bssid[4] >> 7);
*g_id = 0;
}
RTW_INFO("%s: GROUP_ID=0x%02x PARTIAL_AID=0x%04x\n",
__FUNCTION__, *g_id, *p_aid);
}
/*
* Parameters
* adapter _adapter*
* sta struct sta_info*
* sta_bf_cap beamforming capabe of sta
* sounding_dim Number of Sounding Dimensions
* comp_steering Compressed Steering Number of Beamformer Antennas Supported
*/
static void _get_sta_beamform_cap(_adapter *adapter, struct sta_info *sta,
u8 *sta_bf_cap, u8 *sounding_dim, u8 *comp_steering)
{
struct beamforming_info *info;
struct ht_priv *ht;
#ifdef CONFIG_80211AC_VHT
struct vht_priv *vht;
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
struct he_priv *he;
#endif /* CONFIG_80211AX_HE */
u16 bf_cap;
*sta_bf_cap = 0;
*sounding_dim = 0;
*comp_steering = 0;
info = GET_BEAMFORM_INFO(adapter);
ht = &adapter->mlmepriv.htpriv;
#ifdef CONFIG_80211AC_VHT
vht = &adapter->mlmepriv.vhtpriv;
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
he = &adapter->mlmepriv.hepriv;
#endif /* CONFIG_80211AX_HE */
if (is_supported_ht(sta->phl_sta->wmode) == _TRUE) {
/* HT */
bf_cap = ht->beamform_cap;
if (TEST_FLAG(bf_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE)) {
info->beamforming_cap |= BEAMFORMEE_CAP_HT_EXPLICIT;
*sta_bf_cap |= BEAMFORMER_CAP_HT_EXPLICIT;
*sounding_dim = (bf_cap & BEAMFORMING_HT_BEAMFORMEE_CHNL_EST_CAP) >> 6;
}
if (TEST_FLAG(bf_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE)) {
info->beamforming_cap |= BEAMFORMER_CAP_HT_EXPLICIT;
*sta_bf_cap |= BEAMFORMEE_CAP_HT_EXPLICIT;
*comp_steering = (bf_cap & BEAMFORMING_HT_BEAMFORMER_STEER_NUM) >> 4;
}
}
#ifdef CONFIG_80211AC_VHT
if (is_supported_vht(sta->phl_sta->wmode) == _TRUE) {
/* VHT */
bf_cap = vht->beamform_cap;
/* We are SU Beamformee because the STA is SU Beamformer */
if (TEST_FLAG(bf_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE)) {
info->beamforming_cap |= BEAMFORMEE_CAP_VHT_SU;
*sta_bf_cap |= BEAMFORMER_CAP_VHT_SU;
/* We are MU Beamformee because the STA is MU Beamformer */
if (TEST_FLAG(bf_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE)) {
info->beamforming_cap |= BEAMFORMEE_CAP_VHT_MU;
*sta_bf_cap |= BEAMFORMER_CAP_VHT_MU;
}
*sounding_dim = (bf_cap & BEAMFORMING_VHT_BEAMFORMEE_SOUND_DIM) >> 12;
}
/* We are SU Beamformer because the STA is SU Beamformee */
if (TEST_FLAG(bf_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE)) {
info->beamforming_cap |= BEAMFORMER_CAP_VHT_SU;
*sta_bf_cap |= BEAMFORMEE_CAP_VHT_SU;
/* We are MU Beamformer because the STA is MU Beamformee */
if (TEST_FLAG(bf_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE)) {
info->beamforming_cap |= BEAMFORMER_CAP_VHT_MU;
*sta_bf_cap |= BEAMFORMEE_CAP_VHT_MU;
}
*comp_steering = (bf_cap & BEAMFORMING_VHT_BEAMFORMER_STS_CAP) >> 8;
}
}
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif /* CONFIG_80211AX_HE */
}
static u8 _send_ht_ndpa_packet(_adapter *adapter, u8 *ra, enum channel_width bw)
{
/* General */
struct xmit_priv *pxmitpriv;
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
struct xmit_frame *pmgntframe;
/* Beamforming */
struct beamforming_info *info;
struct beamformee_entry *bfee;
struct ndpa_sta_info sta_info;
u8 ActionHdr[4] = {ACT_CAT_VENDOR, 0x00, 0xE0, 0x4C};
/* MISC */
struct pkt_attrib *attrib;
struct rtw_ieee80211_hdr *pwlanhdr;
enum MGN_RATE txrate;
u8 *pframe;
u16 duration = 0;
u8 aSifsTime = 0;
RTW_INFO("+%s: Send to " MAC_FMT "\n", __FUNCTION__, MAC_ARG(ra));
pxmitpriv = &adapter->xmitpriv;
pmlmeext = &adapter->mlmeextpriv;
pmlmeinfo = &pmlmeext->mlmext_info;
bfee = rtw_bf_bfee_get_entry_by_addr(adapter, ra);
if (!bfee) {
RTW_ERR("%s: Cann't find beamformee entry!\n", __FUNCTION__);
return _FALSE;
}
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (!pmgntframe) {
RTW_ERR("%s: alloc mgnt frame fail!\n", __FUNCTION__);
return _FALSE;
}
txrate = rtw_hal_get_htndp_tx_rate(adapter, bfee->comp_steering_num_of_bfer);
/* update attribute */
attrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, attrib);
/*attrib->type = WIFI_MGT_TYPE;*/ /* set in update_mgntframe_attrib() */
attrib->subtype = WIFI_ACTION_NOACK;
attrib->bwmode = bw;
/*attrib->qsel = rtw_hal_get_qsel(padapter, QSLT_MGNT_ID);*/ /* set in update_mgntframe_attrib() */
attrib->order = 1;
attrib->rate = (u8)txrate;
attrib->bf_pkt_type = 0;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
/* Frame control */
pwlanhdr->frame_ctl = 0;
set_frame_sub_type(pframe, attrib->subtype);
set_htc_order_bit(pframe);
/* Duration */
if (pmlmeext->cur_wireless_mode == WIRELESS_11B)
aSifsTime = 10;
else
aSifsTime = 16;
duration = 2 * aSifsTime + 40;
if (bw == CHANNEL_WIDTH_40)
duration += 87;
else
duration += 180;
set_duration(pframe, duration);
/* DA */
_rtw_memcpy(pwlanhdr->addr1, ra, ETH_ALEN);
/* SA */
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
/* BSSID */
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
/* HT control field */
SET_HT_CTRL_CSI_STEERING(pframe + 24, 3);
SET_HT_CTRL_NDP_ANNOUNCEMENT(pframe + 24, 1);
/*
* Frame Body
* Category field: vender-specific value, 0x7F
* OUI: 0x00E04C
*/
_rtw_memcpy(pframe + 28, ActionHdr, 4);
attrib->pktlen = 32;
attrib->last_txcmdsz = attrib->pktlen;
dump_mgntframe(adapter, pmgntframe);
return _TRUE;
}
static u8 _send_vht_ndpa_packet(_adapter *adapter, u8 *ra, u16 aid, enum channel_width bw)
{
/* General */
struct xmit_priv *pxmitpriv;
struct mlme_ext_priv *pmlmeext;
struct xmit_frame *pmgntframe;
/* Beamforming */
struct beamforming_info *info;
struct beamformee_entry *bfee;
struct ndpa_sta_info sta_info;
/* MISC */
struct pkt_attrib *attrib;
struct rtw_ieee80211_hdr *pwlanhdr;
u8 *pframe;
enum MGN_RATE txrate;
u16 duration = 0;
u8 sequence = 0, aSifsTime = 0;
RTW_INFO("+%s: Send to " MAC_FMT "\n", __FUNCTION__, MAC_ARG(ra));
pxmitpriv = &adapter->xmitpriv;
pmlmeext = &adapter->mlmeextpriv;
info = GET_BEAMFORM_INFO(adapter);
bfee = rtw_bf_bfee_get_entry_by_addr(adapter, ra);
if (!bfee) {
RTW_ERR("%s: Cann't find beamformee entry!\n", __FUNCTION__);
return _FALSE;
}
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (!pmgntframe) {
RTW_ERR("%s: alloc mgnt frame fail!\n", __FUNCTION__);
return _FALSE;
}
txrate = rtw_hal_get_vht_ndp_tx_rate(adapter, bfee->comp_steering_num_of_bfer);
/* update attribute */
attrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, attrib);
/*pattrib->type = WIFI_MGT_TYPE;*/ /* set in update_mgntframe_attrib() */
attrib->subtype = WIFI_NDPA;
attrib->bwmode = bw;
/*attrib->qsel = rtw_hal_get_qsel(padapter, QSLT_MGNT_ID);*/ /* set in update_mgntframe_attrib() */
attrib->rate = (u8)txrate;
attrib->bf_pkt_type = 0;
_rtw_memset(pmgntframe->buf_addr, 0, TXDESC_OFFSET + WLANHDR_OFFSET);
pframe = pmgntframe->buf_addr + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
/* Frame control */
pwlanhdr->frame_ctl = 0;
set_frame_sub_type(pframe, attrib->subtype);
/* Duration */
if (WIFI_ROLE_IS_ON_5G(adapter) || is_supported_ht(pmlmeext->cur_wireless_mode))
aSifsTime = 16;
else
aSifsTime = 10;
duration = 2 * aSifsTime + 44;
if (bw == CHANNEL_WIDTH_80)
duration += 40;
else if (bw == CHANNEL_WIDTH_40)
duration += 87;
else
duration += 180;
set_duration(pframe, duration);
/* RA */
_rtw_memcpy(pwlanhdr->addr1, ra, ETH_ALEN);
/* TA */
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
/* Sounding Sequence, bit0~1 is reserved */
sequence = info->sounding_sequence << 2;
if (info->sounding_sequence >= 0x3f)
info->sounding_sequence = 0;
else
info->sounding_sequence++;
_rtw_memcpy(pframe + 16, &sequence, 1);
/* STA Info */
/*
* "AID12" Equal to 0 if the STA is an AP, mesh STA or
* STA that is a member of an IBSS
*/
if (check_fwstate(&adapter->mlmepriv, WIFI_AP_STATE) == _FALSE)
aid = 0;
sta_info.aid = aid;
/* "Feedback Type" set to 0 for SU */
sta_info.feedback_type = 0;
/* "Nc Index" reserved if the Feedback Type field indicates SU */
sta_info.nc_index = 0;
_rtw_memcpy(pframe + 17, (u8 *)&sta_info, 2);
attrib->pktlen = 19;
attrib->last_txcmdsz = attrib->pktlen;
dump_mgntframe(adapter, pmgntframe);
return _TRUE;
}
static u8 _send_vht_mu_ndpa_packet(_adapter *adapter, enum channel_width bw)
{
/* General */
struct xmit_priv *pxmitpriv;
struct mlme_ext_priv *pmlmeext;
struct xmit_frame *pmgntframe;
/* Beamforming */
struct beamforming_info *info;
struct sounding_info *sounding;
struct beamformee_entry *bfee;
struct ndpa_sta_info sta_info;
/* MISC */
struct pkt_attrib *attrib;
struct rtw_ieee80211_hdr *pwlanhdr;
enum MGN_RATE txrate;
u8 *pframe;
u8 *ra = NULL;
u16 duration = 0;
u8 sequence = 0, aSifsTime = 0;
u8 i;
RTW_INFO("+%s\n", __FUNCTION__);
pxmitpriv = &adapter->xmitpriv;
pmlmeext = &adapter->mlmeextpriv;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
txrate = MGN_VHT2SS_MCS0;
/*
* Fill the first MU BFee entry (STA1) MAC addr to destination address then
* HW will change A1 to broadcast addr.
* 2015.05.28. Suggested by SD1 Chunchu.
*/
bfee = &info->bfee_entry[sounding->mu_sounding_list[0]];
ra = bfee->mac_addr;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (!pmgntframe) {
RTW_ERR("%s: alloc mgnt frame fail!\n", __FUNCTION__);
return _FALSE;
}
/* update attribute */
attrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, attrib);
/*attrib->type = WIFI_MGT_TYPE;*/ /* set in update_mgntframe_attrib() */
attrib->subtype = WIFI_NDPA;
attrib->bwmode = bw;
/*attrib->qsel = rtw_hal_get_qsel(padapter, QSLT_MGNT_ID);*/ /* set in update_mgntframe_attrib() */
attrib->rate = (u8)txrate;
/* Set TxBFPktType of Tx desc to unicast type if there is only one MU STA for HW design */
if (info->sounding_info.candidate_mu_bfee_cnt > 1)
attrib->bf_pkt_type = 1;
else
attrib->bf_pkt_type = 0;
_rtw_memset(pmgntframe->buf_addr, 0, TXDESC_OFFSET + WLANHDR_OFFSET);
pframe = pmgntframe->buf_addr + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
/* Frame control */
pwlanhdr->frame_ctl = 0;
set_frame_sub_type(pframe, attrib->subtype);
/* Duration */
if (WIFI_ROLE_IS_ON_5G(adapter) || is_supported_ht(pmlmeext->cur_wireless_mode))
aSifsTime = 16;
else
aSifsTime = 10;
duration = 2 * aSifsTime + 44;
if (bw == CHANNEL_WIDTH_80)
duration += 40;
else if (bw == CHANNEL_WIDTH_40)
duration += 87;
else
duration += 180;
set_duration(pframe, duration);
/* RA */
_rtw_memcpy(pwlanhdr->addr1, ra, ETH_ALEN);
/* TA */
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
/* Sounding Sequence, bit0~1 is reserved */
sequence = info->sounding_sequence << 2;
if (info->sounding_sequence >= 0x3f)
info->sounding_sequence = 0;
else
info->sounding_sequence++;
_rtw_memcpy(pframe + 16, &sequence, 1);
attrib->pktlen = 17;
/*
* Construct STA info. for multiple STAs
* STA Info1, ..., STA Info n
*/
for (i = 0; i < sounding->candidate_mu_bfee_cnt; i++) {
bfee = &info->bfee_entry[sounding->mu_sounding_list[i]];
sta_info.aid = bfee->aid;
sta_info.feedback_type = 1; /* 1'b1: MU */
sta_info.nc_index = 0;
_rtw_memcpy(pframe + attrib->pktlen, (u8 *)&sta_info, 2);
attrib->pktlen += 2;
}
attrib->last_txcmdsz = attrib->pktlen;
dump_mgntframe(adapter, pmgntframe);
return _TRUE;
}
static u8 _send_bf_report_poll(_adapter *adapter, u8 *ra, u8 bFinalPoll)
{
/* General */
struct xmit_priv *pxmitpriv;
struct xmit_frame *pmgntframe;
/* MISC */
struct pkt_attrib *attrib;
struct rtw_ieee80211_hdr *pwlanhdr;
u8 *pframe;
RTW_INFO("+%s: Send to " MAC_FMT "\n", __FUNCTION__, MAC_ARG(ra));
pxmitpriv = &adapter->xmitpriv;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (!pmgntframe) {
RTW_ERR("%s: alloc mgnt frame fail!\n", __FUNCTION__);
return _FALSE;
}
/* update attribute */
attrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, attrib);
/*attrib->type = WIFI_MGT_TYPE;*/ /* set in update_mgntframe_attrib() */
attrib->subtype = WIFI_BF_REPORT_POLL;
attrib->bwmode = CHANNEL_WIDTH_20;
/*attrib->qsel = rtw_hal_get_qsel(padapter, QSLT_MGNT_ID);*/ /* set in update_mgntframe_attrib() */
attrib->rate = MGN_6M;
if (bFinalPoll)
attrib->bf_pkt_type = 3;
else
attrib->bf_pkt_type = 2;
_rtw_memset(pmgntframe->buf_addr, 0, TXDESC_OFFSET + WLANHDR_OFFSET);
pframe = pmgntframe->buf_addr + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
/* Frame control */
pwlanhdr->frame_ctl = 0;
set_frame_sub_type(pframe, attrib->subtype);
/* Duration */
set_duration(pframe, 100);
/* RA */
_rtw_memcpy(pwlanhdr->addr1, ra, ETH_ALEN);
/* TA */
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
/* Feedback Segment Retransmission Bitmap */
pframe[16] = 0xFF;
attrib->pktlen = 17;
attrib->last_txcmdsz = attrib->pktlen;
dump_mgntframe(adapter, pmgntframe);
return _TRUE;
}
static void _sounding_update_min_period(_adapter *adapter, u16 period, u8 leave)
{
struct beamforming_info *info;
struct beamformee_entry *bfee;
u8 i = 0;
u16 min_val = 0xFFFF;
info = GET_BEAMFORM_INFO(adapter);
if (_TRUE == leave) {
/*
* When a BFee left,
* we need to find the latest min sounding period
* from the remaining BFees
*/
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if ((bfee->used == _TRUE)
&& (bfee->sound_period < min_val))
min_val = bfee->sound_period;
}
if (min_val == 0xFFFF)
info->sounding_info.min_sounding_period = 0;
else
info->sounding_info.min_sounding_period = min_val;
} else {
if ((info->sounding_info.min_sounding_period == 0)
|| (period < info->sounding_info.min_sounding_period))
info->sounding_info.min_sounding_period = period;
}
}
static void _sounding_init(struct sounding_info *sounding)
{
_rtw_memset(sounding->su_sounding_list, 0xFF, MAX_NUM_BEAMFORMEE_SU);
_rtw_memset(sounding->mu_sounding_list, 0xFF, MAX_NUM_BEAMFORMEE_MU);
sounding->state = SOUNDING_STATE_NONE;
sounding->su_bfee_curidx = 0xFF;
sounding->candidate_mu_bfee_cnt = 0;
sounding->min_sounding_period = 0;
sounding->sound_remain_cnt_per_period = 0;
}
static void _sounding_reset_vars(_adapter *adapter)
{
struct beamforming_info *info;
struct sounding_info *sounding;
u8 idx;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
_rtw_memset(sounding->su_sounding_list, 0xFF, MAX_NUM_BEAMFORMEE_SU);
_rtw_memset(sounding->mu_sounding_list, 0xFF, MAX_NUM_BEAMFORMEE_MU);
sounding->su_bfee_curidx = 0xFF;
sounding->candidate_mu_bfee_cnt = 0;
/* Clear bSound flag for the new period */
for (idx = 0; idx < MAX_BEAMFORMEE_ENTRY_NUM; idx++) {
if ((info->bfee_entry[idx].used == _TRUE)
&& (info->bfee_entry[idx].sounding == _TRUE)) {
info->bfee_entry[idx].sounding = _FALSE;
info->bfee_entry[idx].bCandidateSoundingPeer = _FALSE;
}
}
}
/*
* Return
* 0 Prepare sounding list OK
* -1 Fail to prepare sounding list, because no beamformee need to souding
* -2 Fail to prepare sounding list, because beamformee state not ready
*
*/
static int _sounding_get_list(_adapter *adapter)
{
struct beamforming_info *info;
struct sounding_info *sounding;
struct beamformee_entry *bfee;
u8 i, mu_idx = 0, su_idx = 0, not_ready = 0;
int ret = 0;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
/* Add MU BFee list first because MU priority is higher than SU */
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (bfee->used == _FALSE)
continue;
if (bfee->state != BEAMFORM_ENTRY_HW_STATE_ADDED) {
RTW_ERR("%s: Invalid BFee idx(%d) Hw state=%d\n", __FUNCTION__, i, bfee->state);
not_ready++;
continue;
}
/*
* Decrease BFee's SoundCnt per period
* If the remain count is 0,
* then it can be sounded at this time
*/
if (bfee->SoundCnt) {
bfee->SoundCnt--;
if (bfee->SoundCnt)
continue;
}
/*
* <tynli_Note>
* If the STA supports MU BFee capability then we add it to MUSoundingList directly
* because we can only sound one STA by unicast NDPA with MU cap enabled to get correct channel info.
* Suggested by BB team Luke Lee. 2015.11.25.
*/
if (bfee->cap & BEAMFORMEE_CAP_VHT_MU) {
/* MU BFee */
if (mu_idx >= MAX_NUM_BEAMFORMEE_MU) {
RTW_ERR("%s: Too much MU bfee entry(Limit:%d)\n", __FUNCTION__, MAX_NUM_BEAMFORMEE_MU);
continue;
}
if (bfee->bApplySounding == _TRUE) {
bfee->bCandidateSoundingPeer = _TRUE;
bfee->SoundCnt = GetInitSoundCnt(bfee->sound_period, sounding->min_sounding_period);
sounding->mu_sounding_list[mu_idx] = i;
mu_idx++;
}
} else if (bfee->cap & (BEAMFORMEE_CAP_VHT_SU|BEAMFORMEE_CAP_HT_EXPLICIT)) {
/* SU BFee (HT/VHT) */
if (su_idx >= MAX_NUM_BEAMFORMEE_SU) {
RTW_ERR("%s: Too much SU bfee entry(Limit:%d)\n", __FUNCTION__, MAX_NUM_BEAMFORMEE_SU);
continue;
}
if (bfee->bDeleteSounding == _TRUE) {
sounding->su_sounding_list[su_idx] = i;
su_idx++;
} else if ((bfee->bApplySounding == _TRUE)
&& (bfee->bSuspendSUCap == _FALSE)) {
bfee->bCandidateSoundingPeer = _TRUE;
bfee->SoundCnt = GetInitSoundCnt(bfee->sound_period, sounding->min_sounding_period);
sounding->su_sounding_list[su_idx] = i;
su_idx++;
}
}
}
sounding->candidate_mu_bfee_cnt = mu_idx;
if (su_idx + mu_idx == 0) {
ret = -1;
if (not_ready)
ret = -2;
}
RTW_INFO("-%s: There are %d SU and %d MU BFees in this sounding period\n", __FUNCTION__, su_idx, mu_idx);
return ret;
}
static void _sounding_handler(_adapter *adapter)
{
struct beamforming_info *info;
struct sounding_info *sounding;
struct beamformee_entry *bfee;
u8 su_idx, i;
u32 timeout_period = 0;
u8 set_timer = _FALSE;
int ret = 0;
static u16 wait_cnt = 0;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
RTW_DBG("+%s: state=%d\n", __FUNCTION__, sounding->state);
if ((sounding->state != SOUNDING_STATE_INIT)
&& (sounding->state != SOUNDING_STATE_SU_SOUNDDOWN)
&& (sounding->state != SOUNDING_STATE_MU_SOUNDDOWN)
&& (sounding->state != SOUNDING_STATE_SOUNDING_TIMEOUT)) {
RTW_WARN("%s: Invalid State(%d) and return!\n", __FUNCTION__, sounding->state);
return;
}
if (sounding->state == SOUNDING_STATE_INIT) {
RTW_INFO("%s: Sounding start\n", __FUNCTION__);
/* Init Var */
_sounding_reset_vars(adapter);
/* Get the sounding list of this sounding period */
ret = _sounding_get_list(adapter);
if (ret == -1) {
wait_cnt = 0;
sounding->state = SOUNDING_STATE_NONE;
RTW_ERR("%s: No BFees found, set to SOUNDING_STATE_NONE\n", __FUNCTION__);
info->sounding_running--;
return;
}
if (ret == -2) {
RTW_WARN("%s: Temporarily cann't find BFee to sounding\n", __FUNCTION__);
if (wait_cnt < 5) {
wait_cnt++;
} else {
wait_cnt = 0;
sounding->state = SOUNDING_STATE_NONE;
RTW_ERR("%s: Wait changing state timeout!! Set to SOUNDING_STATE_NONE\n", __FUNCTION__);
}
info->sounding_running--;
return;
}
if (ret != 0) {
wait_cnt = 0;
RTW_ERR("%s: Unkown state(%d)!\n", __FUNCTION__, ret);
info->sounding_running--;
return;
}
wait_cnt = 0;
if (check_fwstate(&adapter->mlmepriv, WIFI_UNDER_SURVEY) == _TRUE) {
RTW_INFO("%s: Sounding abort! scanning APs...\n", __FUNCTION__);
info->sounding_running--;
return;
}
rtw_ps_deny(adapter, PS_DENY_BEAMFORMING);
LeaveAllPowerSaveModeDirect(adapter);
}
/* Get non-sound SU BFee index */
for (i = 0; i < MAX_NUM_BEAMFORMEE_SU; i++) {
su_idx = sounding->su_sounding_list[i];
if (su_idx >= MAX_BEAMFORMEE_ENTRY_NUM)
continue;
bfee = &info->bfee_entry[su_idx];
if (_FALSE == bfee->sounding)
break;
}
if (i < MAX_NUM_BEAMFORMEE_SU) {
sounding->su_bfee_curidx = su_idx;
/* Set to sounding start state */
sounding->state = SOUNDING_STATE_SU_START;
RTW_DBG("%s: Set to SOUNDING_STATE_SU_START\n", __FUNCTION__);
bfee->sounding = _TRUE;
/* Reset sounding timeout flag for the new sounding */
bfee->bSoundingTimeout = _FALSE;
if (_TRUE == bfee->bDeleteSounding) {
u8 res = _FALSE;
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_END_PERIOD, &res, 1, 0);
return;
}
/* Start SU sounding */
if (bfee->cap & BEAMFORMEE_CAP_VHT_SU)
_send_vht_ndpa_packet(adapter, bfee->mac_addr, bfee->aid, bfee->sound_bw);
else if (bfee->cap & BEAMFORMEE_CAP_HT_EXPLICIT)
_send_ht_ndpa_packet(adapter, bfee->mac_addr, bfee->sound_bw);
/* Set sounding timeout timer */
_set_timer(&info->sounding_timeout_timer, SU_SOUNDING_TIMEOUT);
return;
}
if (sounding->candidate_mu_bfee_cnt > 0) {
/*
* If there is no SU BFee then find MU BFee and perform MU sounding
*
* <tynli_note> Need to check the MU starting condition. 2015.12.15.
*/
sounding->state = SOUNDING_STATE_MU_START;
RTW_DBG("%s: Set to SOUNDING_STATE_MU_START\n", __FUNCTION__);
/* Update MU BFee info */
for (i = 0; i < sounding->candidate_mu_bfee_cnt; i++) {
bfee = &info->bfee_entry[sounding->mu_sounding_list[i]];
bfee->sounding = _TRUE;
}
/* Send MU NDPA */
bfee = &info->bfee_entry[sounding->mu_sounding_list[0]];
_send_vht_mu_ndpa_packet(adapter, bfee->sound_bw);
/* Send BF report poll if more than 1 MU STA */
for (i = 1; i < sounding->candidate_mu_bfee_cnt; i++) {
bfee = &info->bfee_entry[sounding->mu_sounding_list[i]];
if (i == (sounding->candidate_mu_bfee_cnt - 1))/* The last STA*/
_send_bf_report_poll(adapter, bfee->mac_addr, _TRUE);
else
_send_bf_report_poll(adapter, bfee->mac_addr, _FALSE);
}
sounding->candidate_mu_bfee_cnt = 0;
/* Set sounding timeout timer */
_set_timer(&info->sounding_timeout_timer, MU_SOUNDING_TIMEOUT);
return;
}
info->sounding_running--;
sounding->state = SOUNDING_STATE_INIT;
RTW_INFO("%s: Sounding finished!\n", __FUNCTION__);
rtw_ps_deny_cancel(adapter, PS_DENY_BEAMFORMING);
}
static void _sounding_force_stop(_adapter *adapter)
{
struct beamforming_info *info;
struct sounding_info *sounding;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
if ((sounding->state == SOUNDING_STATE_SU_START)
|| (sounding->state == SOUNDING_STATE_MU_START)) {
u8 res = _FALSE;
_cancel_timer_ex(&info->sounding_timeout_timer);
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_END_PERIOD, &res, 1, 1);
return;
}
info->sounding_running--;
sounding->state = SOUNDING_STATE_INIT;
RTW_INFO("%s: Sounding finished!\n", __FUNCTION__);
rtw_ps_deny_cancel(adapter, PS_DENY_BEAMFORMING);
}
static void _sounding_timer_handler(void *FunctionContext)
{
_adapter *adapter;
struct beamforming_info *info;
struct sounding_info *sounding;
static u8 delay = 0;
RTW_DBG("+%s\n", __FUNCTION__);
adapter = (_adapter *)FunctionContext;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
if (SOUNDING_STATE_NONE == sounding->state) {
RTW_INFO("%s: Stop!\n", __FUNCTION__);
if (info->sounding_running)
RTW_WARN("%s: souding_running=%d when thread stop!\n",
__FUNCTION__, info->sounding_running);
return;
}
_set_timer(&info->sounding_timer, sounding->min_sounding_period);
if (!info->sounding_running) {
if (SOUNDING_STATE_INIT != sounding->state) {
RTW_WARN("%s: state(%d) != SOUNDING_STATE_INIT!!\n", __FUNCTION__, sounding->state);
sounding->state = SOUNDING_STATE_INIT;
}
delay = 0;
info->sounding_running++;
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_START_PERIOD, NULL, 0, 1);
} else {
if (delay != 0xFF)
delay++;
RTW_WARN("%s: souding is still processing...(state:%d, running:%d, delay:%d)\n",
__FUNCTION__, sounding->state, info->sounding_running, delay);
if (delay > 3) {
RTW_WARN("%s: Stop sounding!!\n", __FUNCTION__);
_sounding_force_stop(adapter);
}
}
}
static void _sounding_timeout_timer_handler(void *FunctionContext)
{
_adapter *adapter;
struct beamforming_info *info;
struct sounding_info *sounding;
struct beamformee_entry *bfee;
RTW_WARN("+%s\n", __FUNCTION__);
adapter = (_adapter *)FunctionContext;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
if (SOUNDING_STATE_SU_START == sounding->state) {
sounding->state = SOUNDING_STATE_SOUNDING_TIMEOUT;
RTW_ERR("%s: Set to SU SOUNDING_STATE_SOUNDING_TIMEOUT\n", __FUNCTION__);
/* SU BFee */
bfee = &info->bfee_entry[sounding->su_bfee_curidx];
bfee->bSoundingTimeout = _TRUE;
RTW_WARN("%s: The BFee entry[%d] is Sounding Timeout!\n", __FUNCTION__, sounding->su_bfee_curidx);
} else if (SOUNDING_STATE_MU_START == sounding->state) {
sounding->state = SOUNDING_STATE_SOUNDING_TIMEOUT;
RTW_ERR("%s: Set to MU SOUNDING_STATE_SOUNDING_TIMEOUT\n", __FUNCTION__);
} else {
RTW_WARN("%s: unexpected sounding state:0x%02x\n", __FUNCTION__, sounding->state);
return;
}
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_START_PERIOD, NULL, 0, 1);
}
static struct beamformer_entry *_bfer_get_free_entry(_adapter *adapter)
{
u8 i = 0;
struct beamforming_info *info;
struct beamformer_entry *bfer;
info = GET_BEAMFORM_INFO(adapter);
for (i = 0; i < MAX_BEAMFORMER_ENTRY_NUM; i++) {
bfer = &info->bfer_entry[i];
if (bfer->used == _FALSE)
return bfer;
}
return NULL;
}
static struct beamformer_entry *_bfer_get_entry_by_addr(_adapter *adapter, u8 *ra)
{
u8 i = 0;
struct beamforming_info *info;
struct beamformer_entry *bfer;
info = GET_BEAMFORM_INFO(adapter);
for (i = 0; i < MAX_BEAMFORMER_ENTRY_NUM; i++) {
bfer = &info->bfer_entry[i];
if (bfer->used == _FALSE)
continue;
if (_rtw_memcmp(ra, bfer->mac_addr, ETH_ALEN) == _TRUE)
return bfer;
}
return NULL;
}
static struct beamformer_entry *_bfer_add_entry(_adapter *adapter,
struct sta_info *sta, u8 bf_cap, u8 sounding_dim, u8 comp_steering)
{
struct mlme_priv *mlme;
struct beamforming_info *info;
struct beamformer_entry *bfer;
u8 *bssid;
u16 val16;
u8 i;
mlme = &adapter->mlmepriv;
info = GET_BEAMFORM_INFO(adapter);
bfer = _bfer_get_entry_by_addr(adapter, sta->phl_sta->mac_addr);
if (!bfer) {
bfer = _bfer_get_free_entry(adapter);
if (!bfer)
return NULL;
}
bfer->used = _TRUE;
_get_txvector_parameter(adapter, sta, &bfer->g_id, &bfer->p_aid);
_rtw_memcpy(bfer->mac_addr, sta->phl_sta->mac_addr, ETH_ALEN);
bfer->cap = bf_cap;
bfer->state = BEAMFORM_ENTRY_HW_STATE_ADD_INIT;
bfer->NumofSoundingDim = sounding_dim;
if (TEST_FLAG(bf_cap, BEAMFORMER_CAP_VHT_MU)) {
info->beamformer_mu_cnt += 1;
bfer->aid = sta->phl_sta->aid;
} else if (TEST_FLAG(bf_cap, BEAMFORMER_CAP_VHT_SU|BEAMFORMER_CAP_HT_EXPLICIT)) {
info->beamformer_su_cnt += 1;
/* Record HW idx info */
for (i = 0; i < MAX_NUM_BEAMFORMER_SU; i++) {
if ((info->beamformer_su_reg_maping & BIT(i)) == 0) {
info->beamformer_su_reg_maping |= BIT(i);
bfer->su_reg_index = i;
break;
}
}
RTW_INFO("%s: Add BFer entry beamformer_su_reg_maping=%#x, su_reg_index=%d\n",
__FUNCTION__, info->beamformer_su_reg_maping, bfer->su_reg_index);
}
return bfer;
}
static void _bfer_remove_entry(_adapter *adapter, struct beamformer_entry *entry)
{
struct beamforming_info *info;
info = GET_BEAMFORM_INFO(adapter);
entry->state = BEAMFORM_ENTRY_HW_STATE_DELETE_INIT;
if (TEST_FLAG(entry->cap, BEAMFORMER_CAP_VHT_MU)) {
info->beamformer_mu_cnt -= 1;
_rtw_memset(entry->gid_valid, 0, 8);
_rtw_memset(entry->user_position, 0, 16);
} else if (TEST_FLAG(entry->cap, BEAMFORMER_CAP_VHT_SU|BEAMFORMER_CAP_HT_EXPLICIT)) {
info->beamformer_su_cnt -= 1;
}
if (info->beamformer_mu_cnt == 0)
info->beamforming_cap &= ~BEAMFORMEE_CAP_VHT_MU;
if (info->beamformer_su_cnt == 0)
info->beamforming_cap &= ~(BEAMFORMEE_CAP_VHT_SU|BEAMFORMEE_CAP_HT_EXPLICIT);
}
static u8 _bfer_set_entry_gid(_adapter *adapter, u8 *addr, u8 *gid, u8 *position)
{
struct beamformer_entry bfer;
_rtw_memset(&bfer, 0, sizeof(bfer));
_rtw_memcpy(bfer.mac_addr, addr, ETH_ALEN);
/* Parsing Membership Status Array */
_rtw_memcpy(bfer.gid_valid, gid, 8);
/* Parsing User Position Array */
_rtw_memcpy(bfer.user_position, position, 16);
/* Config HW GID table */
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_SET_GID_TABLE, (u8 *) &bfer,
sizeof(bfer), 1);
return _SUCCESS;
}
static struct beamformee_entry *_bfee_get_free_entry(_adapter *adapter)
{
u8 i = 0;
struct beamforming_info *info;
struct beamformee_entry *bfee;
info = GET_BEAMFORM_INFO(adapter);
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (bfee->used == _FALSE)
return bfee;
}
return NULL;
}
static struct beamformee_entry *_bfee_get_entry_by_addr(_adapter *adapter, u8 *ra)
{
u8 i = 0;
struct beamforming_info *info;
struct beamformee_entry *bfee;
info = GET_BEAMFORM_INFO(adapter);
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (bfee->used == _FALSE)
continue;
if (_rtw_memcmp(ra, bfee->mac_addr, ETH_ALEN) == _TRUE)
return bfee;
}
return NULL;
}
static u8 _bfee_get_first_su_entry_idx(_adapter *adapter, struct beamformee_entry *ignore)
{
struct beamforming_info *info;
struct beamformee_entry *bfee;
u8 i;
info = GET_BEAMFORM_INFO(adapter);
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (ignore && (bfee == ignore))
continue;
if (bfee->used == _FALSE)
continue;
if ((!TEST_FLAG(bfee->cap, BEAMFORMEE_CAP_VHT_MU))
&& TEST_FLAG(bfee->cap, BEAMFORMEE_CAP_VHT_SU|BEAMFORMEE_CAP_HT_EXPLICIT))
return i;
}
return 0xFF;
}
/*
* Description:
* Get the first entry index of MU Beamformee.
*
* Return Value:
* Index of the first MU sta, or 0xFF for invalid index.
*
* 2015.05.25. Created by tynli.
*
*/
static u8 _bfee_get_first_mu_entry_idx(_adapter *adapter, struct beamformee_entry *ignore)
{
struct beamforming_info *info;
struct beamformee_entry *bfee;
u8 i;
info = GET_BEAMFORM_INFO(adapter);
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (ignore && (bfee == ignore))
continue;
if (bfee->used == _FALSE)
continue;
if (TEST_FLAG(bfee->cap, BEAMFORMEE_CAP_VHT_MU))
return i;
}
return 0xFF;
}
static struct beamformee_entry *_bfee_add_entry(_adapter *adapter,
struct sta_info *sta, u8 bf_cap, u8 sounding_dim, u8 comp_steering)
{
struct mlme_priv *mlme;
struct beamforming_info *info;
struct beamformee_entry *bfee;
u8 *bssid;
u16 val16;
u8 i;
mlme = &adapter->mlmepriv;
info = GET_BEAMFORM_INFO(adapter);
bfee = _bfee_get_entry_by_addr(adapter, sta->phl_sta->mac_addr);
if (!bfee) {
bfee = _bfee_get_free_entry(adapter);
if (!bfee)
return NULL;
}
bfee->used = _TRUE;
bfee->aid = sta->phl_sta->aid;
bfee->mac_id = sta->phl_sta->macid;
bfee->sound_bw = sta->phl_sta->chandef.bw;
_get_txvector_parameter(adapter, sta, &bfee->g_id, &bfee->p_aid);
sta->phl_sta->bf_info.g_id = bfee->g_id;
sta->phl_sta->bf_info.p_aid = bfee->p_aid;
_rtw_memcpy(bfee->mac_addr, sta->phl_sta->mac_addr, ETH_ALEN);
bfee->txbf = _FALSE;
bfee->sounding = _FALSE;
bfee->sound_period = 40;
_sounding_update_min_period(adapter, bfee->sound_period, _FALSE);
bfee->SoundCnt = GetInitSoundCnt(bfee->sound_period, info->sounding_info.min_sounding_period);
bfee->cap = bf_cap;
bfee->state = BEAMFORM_ENTRY_HW_STATE_ADD_INIT;
bfee->bCandidateSoundingPeer = _FALSE;
bfee->bSoundingTimeout = _FALSE;
bfee->bDeleteSounding = _FALSE;
bfee->bApplySounding = _TRUE;
bfee->tx_timestamp = 0;
bfee->tx_bytes = 0;
bfee->LogStatusFailCnt = 0;
bfee->NumofSoundingDim = sounding_dim;
bfee->comp_steering_num_of_bfer = comp_steering;
bfee->bSuspendSUCap = _FALSE;
if (TEST_FLAG(bf_cap, BEAMFORMEE_CAP_VHT_MU)) {
info->beamformee_mu_cnt += 1;
info->first_mu_bfee_index = _bfee_get_first_mu_entry_idx(adapter, NULL);
if (_TRUE == info->bEnableSUTxBFWorkAround) {
/* When the first MU BFee added, discard SU BFee bfee's capability */
if ((info->beamformee_mu_cnt == 1) && (info->beamformee_su_cnt > 0)) {
if (info->TargetSUBFee) {
info->TargetSUBFee->bSuspendSUCap = _TRUE;
info->TargetSUBFee->bDeleteSounding = _TRUE;
} else {
RTW_ERR("%s: UNEXPECTED!! info->TargetSUBFee is NULL!", __FUNCTION__);
}
info->TargetSUBFee = NULL;
_rtw_memset(&info->TargetCSIInfo, 0, sizeof(struct _RT_CSI_INFO));
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_SET_CSI_REPORT, (u8*)&info->TargetCSIInfo, sizeof(struct _RT_CSI_INFO), 0);
}
}
/* Record HW idx info */
for (i = 0; i < MAX_NUM_BEAMFORMEE_MU; i++) {
if ((info->beamformee_mu_reg_maping & BIT(i)) == 0) {
info->beamformee_mu_reg_maping |= BIT(i);
bfee->mu_reg_index = i;
break;
}
}
RTW_INFO("%s: Add BFee entry beamformee_mu_reg_maping=%#x, mu_reg_index=%d\n",
__FUNCTION__, info->beamformee_mu_reg_maping, bfee->mu_reg_index);
} else if (TEST_FLAG(bf_cap, BEAMFORMEE_CAP_VHT_SU|BEAMFORMEE_CAP_HT_EXPLICIT)) {
info->beamformee_su_cnt += 1;
if (_TRUE == info->bEnableSUTxBFWorkAround) {
/* Record the first SU BFee index. We only allow the first SU BFee to be sound */
if ((info->beamformee_su_cnt == 1) && (info->beamformee_mu_cnt == 0)) {
info->TargetSUBFee = bfee;
_rtw_memset(&info->TargetCSIInfo, 0, sizeof(struct _RT_CSI_INFO));
bfee->bSuspendSUCap = _FALSE;
} else {
bfee->bSuspendSUCap = _TRUE;
}
}
/* Record HW idx info */
for (i = 0; i < MAX_NUM_BEAMFORMEE_SU; i++) {
if ((info->beamformee_su_reg_maping & BIT(i)) == 0) {
info->beamformee_su_reg_maping |= BIT(i);
bfee->su_reg_index = i;
break;
}
}
RTW_INFO("%s: Add BFee entry beamformee_su_reg_maping=%#x, su_reg_index=%d\n",
__FUNCTION__, info->beamformee_su_reg_maping, bfee->su_reg_index);
}
return bfee;
}
static void _bfee_remove_entry(_adapter *adapter, struct beamformee_entry *entry)
{
struct beamforming_info *info;
u8 idx;
info = GET_BEAMFORM_INFO(adapter);
entry->state = BEAMFORM_ENTRY_HW_STATE_DELETE_INIT;
if (TEST_FLAG(entry->cap, BEAMFORMEE_CAP_VHT_MU)) {
info->beamformee_mu_cnt -= 1;
info->first_mu_bfee_index = _bfee_get_first_mu_entry_idx(adapter, entry);
if (_TRUE == info->bEnableSUTxBFWorkAround) {
if ((info->beamformee_mu_cnt == 0) && (info->beamformee_su_cnt > 0)) {
idx = _bfee_get_first_su_entry_idx(adapter, NULL);
info->TargetSUBFee = &info->bfee_entry[idx];
_rtw_memset(&info->TargetCSIInfo, 0, sizeof(struct _RT_CSI_INFO));
info->TargetSUBFee->bSuspendSUCap = _FALSE;
}
}
} else if (TEST_FLAG(entry->cap, BEAMFORMEE_CAP_VHT_SU|BEAMFORMEE_CAP_HT_EXPLICIT)) {
info->beamformee_su_cnt -= 1;
/* When the target SU BFee leaves, disable workaround */
if ((_TRUE == info->bEnableSUTxBFWorkAround)
&& (entry == info->TargetSUBFee)) {
entry->bSuspendSUCap = _TRUE;
info->TargetSUBFee = NULL;
_rtw_memset(&info->TargetCSIInfo, 0, sizeof(struct _RT_CSI_INFO));
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_SET_CSI_REPORT, (u8*)&info->TargetCSIInfo, sizeof(struct _RT_CSI_INFO), 0);
}
}
if (info->beamformee_mu_cnt == 0)
info->beamforming_cap &= ~BEAMFORMER_CAP_VHT_MU;
if (info->beamformee_su_cnt == 0)
info->beamforming_cap &= ~(BEAMFORMER_CAP_VHT_SU|BEAMFORMER_CAP_HT_EXPLICIT);
_sounding_update_min_period(adapter, 0, _TRUE);
}
static enum beamforming_cap _bfee_get_entry_cap_by_macid(_adapter *adapter, u8 macid)
{
struct beamforming_info *info;
struct beamformee_entry *bfee;
u8 i;
info = GET_BEAMFORM_INFO(adapter);
for (i = 0; i < MAX_BEAMFORMER_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (bfee->used == _FALSE)
continue;
if (bfee->mac_id == macid)
return bfee->cap;
}
return BEAMFORMING_CAP_NONE;
}
static void _beamforming_enter(_adapter *adapter, void *p)
{
struct mlme_priv *mlme;
struct ht_priv *htpriv;
#ifdef CONFIG_80211AC_VHT
struct vht_priv *vhtpriv;
#endif
struct mlme_ext_priv *mlme_ext;
struct sta_info *sta, *sta_copy;
struct beamforming_info *info;
struct beamformer_entry *bfer = NULL;
struct beamformee_entry *bfee = NULL;
u8 wireless_mode;
u8 sta_bf_cap;
u8 sounding_dim = 0; /* number of sounding dimensions */
u8 comp_steering_num = 0; /* compressed steering number */
mlme = &adapter->mlmepriv;
htpriv = &mlme->htpriv;
#ifdef CONFIG_80211AC_VHT
vhtpriv = &mlme->vhtpriv;
#endif
mlme_ext = &adapter->mlmeextpriv;
info = GET_BEAMFORM_INFO(adapter);
sta_copy = (struct sta_info *)p;
sta = rtw_get_stainfo(&adapter->stapriv, sta_copy->phl_sta->mac_addr);
if (!sta) {
RTW_ERR("%s: Cann't find STA info for " MAC_FMT "\n",
__FUNCTION__, MAC_ARG(sta_copy->phl_sta->mac_addr));
return;
}
if (sta != sta_copy) {
RTW_WARN("%s: Origin sta(fake)=%p realsta=%p for " MAC_FMT "\n",
__FUNCTION__, sta_copy, sta, MAC_ARG(sta_copy->phl_sta->mac_addr));
}
/* The current setting does not support Beaforming */
wireless_mode = sta->phl_sta->wmode;
if ((is_supported_ht(wireless_mode) == _FALSE)
&& (is_supported_vht(wireless_mode) == _FALSE)) {
RTW_WARN("%s: Not support HT or VHT mode\n", __FUNCTION__);
return;
}
if ((0 == htpriv->beamform_cap)
#ifdef CONFIG_80211AC_VHT
&& (0 == vhtpriv->beamform_cap)
#endif
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif
) {
RTW_INFO("The configuration disabled Beamforming! Skip...\n");
return;
}
_get_sta_beamform_cap(adapter, sta,
&sta_bf_cap, &sounding_dim, &comp_steering_num);
RTW_INFO("STA Beamforming Capability=0x%02X\n", sta_bf_cap);
if (sta_bf_cap == BEAMFORMING_CAP_NONE)
return;
if ((sta_bf_cap & BEAMFORMEE_CAP_HT_EXPLICIT)
|| (sta_bf_cap & BEAMFORMEE_CAP_VHT_SU)
|| (sta_bf_cap & BEAMFORMEE_CAP_VHT_MU))
sta_bf_cap |= BEAMFORMEE_CAP;
if ((sta_bf_cap & BEAMFORMER_CAP_HT_EXPLICIT)
|| (sta_bf_cap & BEAMFORMER_CAP_VHT_SU)
|| (sta_bf_cap & BEAMFORMER_CAP_VHT_MU))
sta_bf_cap |= BEAMFORMER_CAP;
if (sta_bf_cap & BEAMFORMER_CAP) {
/* The other side is beamformer */
bfer = _bfer_add_entry(adapter, sta, sta_bf_cap, sounding_dim, comp_steering_num);
if (!bfer)
RTW_ERR("%s: Fail to allocate bfer entry!\n", __FUNCTION__);
}
if (sta_bf_cap & BEAMFORMEE_CAP) {
/* The other side is beamformee */
bfee = _bfee_add_entry(adapter, sta, sta_bf_cap, sounding_dim, comp_steering_num);
if (!bfee)
RTW_ERR("%s: Fail to allocate bfee entry!\n", __FUNCTION__);
}
if (!bfer && !bfee)
return;
rtw_hal_set_hwreg(adapter, HW_VAR_SOUNDING_ENTER, (u8*)sta);
/* Perform sounding if there is BFee */
if ((info->beamformee_su_cnt != 0)
|| (info->beamformee_mu_cnt != 0)) {
if (SOUNDING_STATE_NONE == info->sounding_info.state) {
info->sounding_info.state = SOUNDING_STATE_INIT;
/* Start sounding after 2 sec */
_set_timer(&info->sounding_timer, 2000);
}
}
}
static void _beamforming_reset(_adapter *adapter)
{
RTW_ERR("%s: Not ready!!\n", __FUNCTION__);
}
static void _beamforming_leave(_adapter *adapter, u8 *ra)
{
struct beamforming_info *info;
struct beamformer_entry *bfer = NULL;
struct beamformee_entry *bfee = NULL;
u8 bHwStateAddInit = _FALSE;
RTW_INFO("+%s\n", __FUNCTION__);
info = GET_BEAMFORM_INFO(adapter);
bfer = _bfer_get_entry_by_addr(adapter, ra);
bfee = _bfee_get_entry_by_addr(adapter, ra);
if (!bfer && !bfee) {
RTW_WARN("%s: " MAC_FMT " is neither beamforming ee or er!!\n",
__FUNCTION__, MAC_ARG(ra));
return;
}
if (bfer)
_bfer_remove_entry(adapter, bfer);
if (bfee)
_bfee_remove_entry(adapter, bfee);
rtw_hal_set_hwreg(adapter, HW_VAR_SOUNDING_LEAVE, ra);
/* Stop sounding if there is no any BFee */
if ((info->beamformee_su_cnt == 0)
&& (info->beamformee_mu_cnt == 0)) {
_cancel_timer_ex(&info->sounding_timer);
_sounding_init(&info->sounding_info);
}
RTW_INFO("-%s\n", __FUNCTION__);
}
static void _beamforming_sounding_down(_adapter *adapter, u8 status)
{
struct beamforming_info *info;
struct sounding_info *sounding;
struct beamformee_entry *bfee;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
RTW_INFO("+%s: sounding=%d, status=0x%02x\n", __FUNCTION__, sounding->state, status);
if (sounding->state == SOUNDING_STATE_MU_START) {
RTW_INFO("%s: MU sounding done\n", __FUNCTION__);
sounding->state = SOUNDING_STATE_MU_SOUNDDOWN;
RTW_INFO("%s: Set to SOUNDING_STATE_MU_SOUNDDOWN\n", __FUNCTION__);
info->SetHalSoundownOnDemandCnt++;
rtw_hal_set_hwreg(adapter, HW_VAR_SOUNDING_STATUS, &status);
} else if (sounding->state == SOUNDING_STATE_SU_START) {
RTW_INFO("%s: SU entry[%d] sounding down\n", __FUNCTION__, sounding->su_bfee_curidx);
bfee = &info->bfee_entry[sounding->su_bfee_curidx];
sounding->state = SOUNDING_STATE_SU_SOUNDDOWN;
RTW_INFO("%s: Set to SOUNDING_STATE_SU_SOUNDDOWN\n", __FUNCTION__);
/*
* <tynli_note>
* bfee->bSoundingTimeout this flag still cannot avoid
* old sound down event happens in the new sounding period.
* 2015.12.10
*/
if (_TRUE == bfee->bSoundingTimeout) {
RTW_WARN("%s: The entry[%d] is bSoundingTimeout!\n", __FUNCTION__, sounding->su_bfee_curidx);
bfee->bSoundingTimeout = _FALSE;
return;
}
if (_TRUE == status) {
/* success */
bfee->LogStatusFailCnt = 0;
info->SetHalSoundownOnDemandCnt++;
rtw_hal_set_hwreg(adapter, HW_VAR_SOUNDING_STATUS, &status);
} else if (_TRUE == bfee->bDeleteSounding) {
RTW_WARN("%s: Delete entry[%d] sounding info!\n", __FUNCTION__, sounding->su_bfee_curidx);
rtw_hal_set_hwreg(adapter, HW_VAR_SOUNDING_STATUS, &status);
bfee->bDeleteSounding = _FALSE;
} else {
bfee->LogStatusFailCnt++;
RTW_WARN("%s: LogStatusFailCnt=%d\n", __FUNCTION__, bfee->LogStatusFailCnt);
if (bfee->LogStatusFailCnt > 30) {
RTW_ERR("%s: LogStatusFailCnt > 30, Stop SOUNDING!!\n", __FUNCTION__);
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_LEAVE, bfee->mac_addr, ETH_ALEN, 1);
}
}
} else {
RTW_WARN("%s: unexpected sounding state:0x%02x\n", __FUNCTION__, sounding->state);
return;
}
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_START_PERIOD, NULL, 0, 0);
}
static void _c2h_snd_txbf(_adapter *adapter, u8 *buf, u8 buf_len)
{
struct beamforming_info *info;
u8 res;
info = GET_BEAMFORM_INFO(adapter);
_cancel_timer_ex(&info->sounding_timeout_timer);
res = C2H_SND_TXBF_GET_SND_RESULT(buf) ? _TRUE : _FALSE;
RTW_INFO("+%s: %s\n", __FUNCTION__, res==_TRUE?"Success":"Fail!");
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_END_PERIOD, &res, 1, 1);
}
/*
* Description:
* This function is for phydm only
*/
enum beamforming_cap rtw_bf_bfee_get_entry_cap_by_macid(void *mlme, u8 macid)
{
_adapter *adapter;
enum beamforming_cap cap = BEAMFORMING_CAP_NONE;
adapter = mlme_to_adapter((struct mlme_priv *)mlme);
cap = _bfee_get_entry_cap_by_macid(adapter, macid);
return cap;
}
struct beamformer_entry *rtw_bf_bfer_get_entry_by_addr(_adapter *adapter, u8 *ra)
{
return _bfer_get_entry_by_addr(adapter, ra);
}
struct beamformee_entry *rtw_bf_bfee_get_entry_by_addr(_adapter *adapter, u8 *ra)
{
return _bfee_get_entry_by_addr(adapter, ra);
}
void rtw_bf_get_ndpa_packet(_adapter *adapter, union recv_frame *precv_frame)
{
RTW_DBG("+%s\n", __FUNCTION__);
}
u32 rtw_bf_get_report_packet(_adapter *adapter, union recv_frame *precv_frame)
{
u32 ret = _SUCCESS;
struct beamforming_info *info;
struct beamformee_entry *bfee = NULL;
u8 *pframe;
u32 frame_len;
u8 *ta;
u8 *frame_body;
u8 category, action;
u8 *pMIMOCtrlField, *pCSIMatrix;
u8 Nc = 0, Nr = 0, CH_W = 0, Ng = 0, CodeBook = 0;
u16 CSIMatrixLen = 0;
RTW_INFO("+%s\n", __FUNCTION__);
info = GET_BEAMFORM_INFO(adapter);
pframe = precv_frame->u.hdr.rx_data;
frame_len = precv_frame->u.hdr.len;
/* Memory comparison to see if CSI report is the same with previous one */
ta = get_addr2_ptr(pframe);
bfee = _bfee_get_entry_by_addr(adapter, ta);
if (!bfee)
return _FAIL;
frame_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
category = frame_body[0];
action = frame_body[1];
if ((category == RTW_WLAN_CATEGORY_VHT)
&& (action == RTW_WLAN_ACTION_VHT_COMPRESSED_BEAMFORMING)) {
pMIMOCtrlField = pframe + 26;
Nc = (*pMIMOCtrlField) & 0x7;
Nr = ((*pMIMOCtrlField) & 0x38) >> 3;
CH_W = (((*pMIMOCtrlField) & 0xC0) >> 6);
Ng = (*(pMIMOCtrlField+1)) & 0x3;
CodeBook = ((*(pMIMOCtrlField+1)) & 0x4) >> 2;
/*
* 24+(1+1+3)+2
* ==> MAC header+(Category+ActionCode+MIMOControlField)+SNR(Nc=2)
*/
pCSIMatrix = pMIMOCtrlField + 3 + Nc;
CSIMatrixLen = frame_len - 26 - 3 - Nc;
info->TargetCSIInfo.bVHT = _TRUE;
} else if ((category == RTW_WLAN_CATEGORY_HT)
&& (action == RTW_WLAN_ACTION_HT_COMPRESS_BEAMFORMING)) {
pMIMOCtrlField = pframe + 26;
Nc = (*pMIMOCtrlField) & 0x3;
Nr = ((*pMIMOCtrlField) & 0xC) >> 2;
CH_W = ((*pMIMOCtrlField) & 0x10) >> 4;
Ng = ((*pMIMOCtrlField) & 0x60) >> 5;
CodeBook = ((*(pMIMOCtrlField+1)) & 0x6) >> 1;
/*
* 24+(1+1+6)+2
* ==> MAC header+(Category+ActionCode+MIMOControlField)+SNR(Nc=2)
*/
pCSIMatrix = pMIMOCtrlField + 6 + Nr;
CSIMatrixLen = frame_len - 26 - 6 - Nr;
info->TargetCSIInfo.bVHT = _FALSE;
}
/* Update current CSI report info */
if ((_TRUE == info->bEnableSUTxBFWorkAround)
&& (info->TargetSUBFee == bfee)) {
if ((info->TargetCSIInfo.Nc != Nc) || (info->TargetCSIInfo.Nr != Nr) ||
(info->TargetCSIInfo.ChnlWidth != CH_W) || (info->TargetCSIInfo.Ng != Ng) ||
(info->TargetCSIInfo.CodeBook != CodeBook)) {
info->TargetCSIInfo.Nc = Nc;
info->TargetCSIInfo.Nr = Nr;
info->TargetCSIInfo.ChnlWidth = CH_W;
info->TargetCSIInfo.Ng = Ng;
info->TargetCSIInfo.CodeBook = CodeBook;
rtw_bf_cmd(adapter, BEAMFORMING_CTRL_SET_CSI_REPORT, (u8*)&info->TargetCSIInfo, sizeof(struct _RT_CSI_INFO), 1);
}
}
RTW_INFO("%s: pkt type=%d-%d, Nc=%d, Nr=%d, CH_W=%d, Ng=%d, CodeBook=%d\n",
__FUNCTION__, category, action, Nc, Nr, CH_W, Ng, CodeBook);
return ret;
}
u8 rtw_bf_send_vht_gid_mgnt_packet(_adapter *adapter, u8 *ra, u8 *gid, u8 *position)
{
/* General */
struct xmit_priv *xmitpriv;
struct mlme_priv *mlmepriv;
struct xmit_frame *pmgntframe;
/* MISC */
struct pkt_attrib *attrib;
struct rtw_ieee80211_hdr *wlanhdr;
u8 *pframe, *ptr;
xmitpriv = &adapter->xmitpriv;
mlmepriv = &adapter->mlmepriv;
pmgntframe = alloc_mgtxmitframe(xmitpriv);
if (!pmgntframe)
return _FALSE;
/* update attribute */
attrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, attrib);
attrib->rate = MGN_6M;
attrib->bwmode = CHANNEL_WIDTH_20;
attrib->subtype = WIFI_ACTION;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)pmgntframe->buf_addr + TXDESC_OFFSET;
wlanhdr = (struct rtw_ieee80211_hdr *)pframe;
wlanhdr->frame_ctl = 0;
set_frame_sub_type(pframe, attrib->subtype);
set_duration(pframe, 0);
SetFragNum(pframe, 0);
SetSeqNum(pframe, 0);
_rtw_memcpy(wlanhdr->addr1, ra, ETH_ALEN);
_rtw_memcpy(wlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(wlanhdr->addr3, get_bssid(mlmepriv), ETH_ALEN);
pframe[24] = RTW_WLAN_CATEGORY_VHT;
pframe[25] = RTW_WLAN_ACTION_VHT_GROUPID_MANAGEMENT;
/* Set Membership Status Array */
ptr = pframe + 26;
_rtw_memcpy(ptr, gid, 8);
/* Set User Position Array */
ptr = pframe + 34;
_rtw_memcpy(ptr, position, 16);
attrib->pktlen = 54;
attrib->last_txcmdsz = attrib->pktlen;
dump_mgntframe(adapter, pmgntframe);
return _TRUE;
}
/*
* Description:
* On VHT GID management frame by an MU beamformee.
*/
void rtw_bf_get_vht_gid_mgnt_packet(_adapter *adapter, union recv_frame *precv_frame)
{
u8 *pframe;
u8 *ta, *gid, *position;
RTW_DBG("+%s\n", __FUNCTION__);
pframe = precv_frame->u.hdr.rx_data;
/* Get address by Addr2 */
ta = get_addr2_ptr(pframe);
/* Remove signaling TA */
ta[0] &= 0xFE;
/* Membership Status Array */
gid = pframe + 26;
/* User Position Array */
position= pframe + 34;
_bfer_set_entry_gid(adapter, ta, gid, position);
}
void rtw_bf_init(_adapter *adapter)
{
struct beamforming_info *info;
info = GET_BEAMFORM_INFO(adapter);
info->beamforming_cap = BEAMFORMING_CAP_NONE;
info->beamforming_state = BEAMFORMING_STATE_IDLE;
/*
info->bfee_entry[MAX_BEAMFORMEE_ENTRY_NUM];
info->bfer_entry[MAX_BEAMFORMER_ENTRY_NUM];
*/
info->sounding_sequence = 0;
info->beamformee_su_cnt = 0;
info->beamformer_su_cnt = 0;
info->beamformee_su_reg_maping = 0;
info->beamformer_su_reg_maping = 0;
info->beamformee_mu_cnt = 0;
info->beamformer_mu_cnt = 0;
info->beamformee_mu_reg_maping = 0;
info->first_mu_bfee_index = 0xFF;
info->mu_bfer_curidx = 0xFF;
info->cur_csi_rpt_rate = HALMAC_OFDM24;
_sounding_init(&info->sounding_info);
rtw_init_timer(&info->sounding_timer, _sounding_timer_handler, adapter);
rtw_init_timer(&info->sounding_timeout_timer, _sounding_timeout_timer_handler, adapter);
info->SetHalBFEnterOnDemandCnt = 0;
info->SetHalBFLeaveOnDemandCnt = 0;
info->SetHalSoundownOnDemandCnt = 0;
info->bEnableSUTxBFWorkAround = _TRUE;
info->TargetSUBFee = NULL;
info->sounding_running = 0;
}
void rtw_bf_cmd_hdl(_adapter *adapter, u8 type, u8 *pbuf)
{
switch (type) {
case BEAMFORMING_CTRL_ENTER:
_beamforming_enter(adapter, pbuf);
break;
case BEAMFORMING_CTRL_LEAVE:
if (pbuf == NULL)
_beamforming_reset(adapter);
else
_beamforming_leave(adapter, pbuf);
break;
case BEAMFORMING_CTRL_START_PERIOD:
_sounding_handler(adapter);
break;
case BEAMFORMING_CTRL_END_PERIOD:
_beamforming_sounding_down(adapter, *pbuf);
break;
case BEAMFORMING_CTRL_SET_GID_TABLE:
rtw_hal_set_hwreg(adapter, HW_VAR_SOUNDING_SET_GID_TABLE, pbuf);
break;
case BEAMFORMING_CTRL_SET_CSI_REPORT:
rtw_hal_set_hwreg(adapter, HW_VAR_SOUNDING_CSI_REPORT, pbuf);
break;
default:
break;
}
}
u8 rtw_bf_cmd(_adapter *adapter, s32 type, u8 *pbuf, s32 size, u8 enqueue)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 *wk_buf;
u8 res = _SUCCESS;
if (!enqueue) {
rtw_bf_cmd_hdl(adapter, type, pbuf);
goto exit;
}
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = adapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
if (pbuf != NULL) {
wk_buf = rtw_zmalloc(size);
if (wk_buf == NULL) {
rtw_mfree((u8 *)cmd, sizeof(struct cmd_obj));
rtw_mfree((u8 *)pdrvextra_cmd_parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
_rtw_memcpy(wk_buf, pbuf, size);
} else {
wk_buf = NULL;
size = 0;
}
pdrvextra_cmd_parm->ec_id = BEAMFORMING_WK_CID;
pdrvextra_cmd_parm->type = type;
pdrvextra_cmd_parm->size = size;
pdrvextra_cmd_parm->pbuf = wk_buf;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
void rtw_bf_update_attrib(_adapter *adapter, struct pkt_attrib *attrib, struct sta_info *sta)
{
/* bf_cmn_info move to hal_sta */
#if 0
if (sta) {
attrib->txbf_g_id = sta->phl_sta->bf_info.g_id;
attrib->txbf_p_aid = sta->phl_sta->bf_info.p_aid;
}
#endif
}
void rtw_bf_c2h_handler(_adapter *adapter, u8 id, u8 *buf, u8 buf_len)
{
switch (id) {
case CMD_ID_C2H_SND_TXBF:
_c2h_snd_txbf(adapter, buf, buf_len);
break;
}
}
#define toMbps(bytes, secs) (rtw_division64(bytes >> 17, secs))
void rtw_bf_update_traffic(_adapter *adapter)
{
struct beamforming_info *info;
struct sounding_info *sounding;
struct beamformee_entry *bfee;
struct sta_info *sta;
u8 bfee_cnt, sounding_idx, i;
u16 tp[MAX_BEAMFORMEE_ENTRY_NUM] = {0};
u8 tx_rate[MAX_BEAMFORMEE_ENTRY_NUM] = {0};
u64 tx_bytes, last_bytes;
u32 time;
systime last_timestamp;
u8 set_timer = _FALSE;
info = GET_BEAMFORM_INFO(adapter);
sounding = &info->sounding_info;
/* Check any bfee exist? */
bfee_cnt = info->beamformee_su_cnt + info->beamformee_mu_cnt;
if (bfee_cnt == 0)
return;
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (_FALSE == bfee->used)
continue;
sta = rtw_get_stainfo(&adapter->stapriv, bfee->mac_addr);
if (!sta) {
RTW_ERR("%s: Cann't find sta_info for " MAC_FMT "!\n", __FUNCTION__, MAC_ARG(bfee->mac_addr));
continue;
}
last_timestamp = bfee->tx_timestamp;
last_bytes = bfee->tx_bytes;
bfee->tx_timestamp = rtw_get_current_time();
bfee->tx_bytes = sta->sta_stats.tx_bytes;
if (last_timestamp) {
if (bfee->tx_bytes >= last_bytes)
tx_bytes = bfee->tx_bytes - last_bytes;
else
tx_bytes = bfee->tx_bytes + (~last_bytes);
time = rtw_get_time_interval_ms(last_timestamp, bfee->tx_timestamp);
time = (time > 1000) ? time/1000 : 1;
tp[i] = toMbps(tx_bytes, time);
tx_rate[i] = rtw_hal_get_current_tx_rate(adapter, sta);
RTW_INFO("%s: BFee idx(%d), MadId(%d), TxTP=%lld bytes (%d Mbps), txrate=%d\n",
__FUNCTION__, i, bfee->mac_id, tx_bytes, tp[i], tx_rate[i]);
}
}
sounding_idx = rtw_hal_get_sounding_info(adapter, tp, MAX_BEAMFORMEE_ENTRY_NUM, tx_rate);
for (i = 0; i < MAX_BEAMFORMEE_ENTRY_NUM; i++) {
bfee = &info->bfee_entry[i];
if (_FALSE == bfee->used) {
if (sounding_idx & BIT(i))
RTW_WARN("%s: bfee(%d) not in used but need sounding?!\n", __FUNCTION__, i);
continue;
}
if (sounding_idx & BIT(i)) {
if (_FALSE == bfee->bApplySounding) {
bfee->bApplySounding = _TRUE;
bfee->SoundCnt = 0;
set_timer = _TRUE;
}
} else {
if (_TRUE == bfee->bApplySounding) {
bfee->bApplySounding = _FALSE;
bfee->bDeleteSounding = _TRUE;
bfee->SoundCnt = 0;
set_timer = _TRUE;
}
}
}
if (_TRUE == set_timer) {
if (SOUNDING_STATE_NONE == info->sounding_info.state) {
info->sounding_info.state = SOUNDING_STATE_INIT;
_set_timer(&info->sounding_timer, 0);
}
}
}
#endif
#endif /* CONFIG_BEAMFORMING */
|
2301_81045437/rtl8852be
|
core/rtw_beamforming.c
|
C
|
agpl-3.0
| 57,990
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_BR_EXT_C_
#ifdef __KERNEL__
#include <linux/if_arp.h>
#include <net/ip.h>
#include <linux/version.h>
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 15, 0)
#include <net/ipx.h>
#endif
#include <linux/atalk.h>
#include <linux/udp.h>
#include <linux/if_pppox.h>
#endif
#if 1 /* rtw_wifi_driver */
#include <drv_types.h>
#else /* rtw_wifi_driver */
#include "./8192cd_cfg.h"
#ifndef __KERNEL__
#include "./sys-support.h"
#endif
#include "./8192cd.h"
#include "./8192cd_headers.h"
#include "./8192cd_br_ext.h"
#include "./8192cd_debug.h"
#endif /* rtw_wifi_driver */
#ifdef CL_IPV6_PASS
#ifdef __KERNEL__
#include <linux/ipv6.h>
#include <linux/icmpv6.h>
#include <net/ndisc.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
#include <net/ip6_checksum.h>
#else
#include <net/checksum.h>
#endif
#endif
#endif
#ifdef CONFIG_BR_EXT
/* #define BR_EXT_DEBUG */
#define NAT25_IPV4 01
#define NAT25_IPV6 02
#define NAT25_IPX 03
#define NAT25_APPLE 04
#define NAT25_PPPOE 05
#define RTL_RELAY_TAG_LEN (ETH_ALEN)
#define TAG_HDR_LEN 4
#define MAGIC_CODE 0x8186
#define MAGIC_CODE_LEN 2
#define WAIT_TIME_PPPOE 5 /* waiting time for pppoe server in sec */
/*-----------------------------------------------------------------
How database records network address:
0 1 2 3 4 5 6 7 8 9 10
|----|----|----|----|----|----|----|----|----|----|----|
IPv4 |type| | IP addr |
IPX |type| Net addr | Node addr |
IPX |type| Net addr |Sckt addr|
Apple |type| Network |node|
PPPoE |type| SID | AC MAC |
-----------------------------------------------------------------*/
/* Find a tag in pppoe frame and return the pointer */
static __inline__ unsigned char *__nat25_find_pppoe_tag(struct pppoe_hdr *ph, unsigned short type)
{
unsigned char *cur_ptr, *start_ptr;
unsigned short tagLen, tagType;
start_ptr = cur_ptr = (unsigned char *)ph->tag;
while ((cur_ptr - start_ptr) < ntohs(ph->length)) {
/* prevent un-alignment access */
tagType = (unsigned short)((cur_ptr[0] << 8) + cur_ptr[1]);
tagLen = (unsigned short)((cur_ptr[2] << 8) + cur_ptr[3]);
if (tagType == type)
return cur_ptr;
cur_ptr = cur_ptr + TAG_HDR_LEN + tagLen;
}
return 0;
}
static __inline__ int __nat25_add_pppoe_tag(struct sk_buff *skb, struct pppoe_tag *tag)
{
struct pppoe_hdr *ph = (struct pppoe_hdr *)(skb->data + ETH_HLEN);
int data_len;
data_len = tag->tag_len + TAG_HDR_LEN;
if (skb_tailroom(skb) < data_len) {
_DEBUG_ERR("skb_tailroom() failed in add SID tag!\n");
return -1;
}
skb_put(skb, data_len);
/* have a room for new tag */
_rtw_memmove(((unsigned char *)ph->tag + data_len), (unsigned char *)ph->tag, ntohs(ph->length));
ph->length = htons(ntohs(ph->length) + data_len);
_rtw_memcpy((unsigned char *)ph->tag, tag, data_len);
return data_len;
}
static int skb_pull_and_merge(struct sk_buff *skb, unsigned char *src, int len)
{
int tail_len;
unsigned long end, tail;
if ((src + len) > skb_tail_pointer(skb) || skb->len < len)
return -1;
tail = (unsigned long)skb_tail_pointer(skb);
end = (unsigned long)src + len;
if (tail < end)
return -1;
tail_len = (int)(tail - end);
if (tail_len > 0)
_rtw_memmove(src, src + len, tail_len);
skb_trim(skb, skb->len - len);
return 0;
}
static __inline__ unsigned long __nat25_timeout(_adapter *priv)
{
unsigned long timeout;
timeout = jiffies - NAT25_AGEING_TIME * HZ;
return timeout;
}
static __inline__ int __nat25_has_expired(_adapter *priv,
struct nat25_network_db_entry *fdb)
{
if (time_before_eq(fdb->ageing_timer, __nat25_timeout(priv)))
return 1;
return 0;
}
static __inline__ void __nat25_generate_ipv4_network_addr(unsigned char *networkAddr,
unsigned int *ipAddr)
{
_rtw_memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
networkAddr[0] = NAT25_IPV4;
_rtw_memcpy(networkAddr + 7, (unsigned char *)ipAddr, 4);
}
#ifdef _NET_INET_IPX_H_
static __inline__ void __nat25_generate_ipx_network_addr_with_node(unsigned char *networkAddr,
unsigned int *ipxNetAddr, unsigned char *ipxNodeAddr)
{
_rtw_memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
networkAddr[0] = NAT25_IPX;
_rtw_memcpy(networkAddr + 1, (unsigned char *)ipxNetAddr, 4);
_rtw_memcpy(networkAddr + 5, ipxNodeAddr, 6);
}
static __inline__ void __nat25_generate_ipx_network_addr_with_socket(unsigned char *networkAddr,
unsigned int *ipxNetAddr, unsigned short *ipxSocketAddr)
{
_rtw_memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
networkAddr[0] = NAT25_IPX;
_rtw_memcpy(networkAddr + 1, (unsigned char *)ipxNetAddr, 4);
_rtw_memcpy(networkAddr + 5, (unsigned char *)ipxSocketAddr, 2);
}
static __inline__ void __nat25_generate_apple_network_addr(unsigned char *networkAddr,
unsigned short *network, unsigned char *node)
{
_rtw_memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
networkAddr[0] = NAT25_APPLE;
_rtw_memcpy(networkAddr + 1, (unsigned char *)network, 2);
networkAddr[3] = *node;
}
#endif
static __inline__ void __nat25_generate_pppoe_network_addr(unsigned char *networkAddr,
unsigned char *ac_mac, unsigned short *sid)
{
_rtw_memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
networkAddr[0] = NAT25_PPPOE;
_rtw_memcpy(networkAddr + 1, (unsigned char *)sid, 2);
_rtw_memcpy(networkAddr + 3, (unsigned char *)ac_mac, 6);
}
#ifdef CL_IPV6_PASS
static void __nat25_generate_ipv6_network_addr(unsigned char *networkAddr,
unsigned int *ipAddr)
{
_rtw_memset(networkAddr, 0, MAX_NETWORK_ADDR_LEN);
networkAddr[0] = NAT25_IPV6;
_rtw_memcpy(networkAddr + 1, (unsigned char *)ipAddr, 16);
}
static unsigned char *scan_tlv(unsigned char *data, int len, unsigned char tag, unsigned char len8b)
{
while (len > 0) {
if (*data == tag && *(data + 1) == len8b && len >= len8b * 8)
return data + 2;
len -= (*(data + 1)) * 8;
data += (*(data + 1)) * 8;
}
return NULL;
}
static int update_nd_link_layer_addr(unsigned char *data, int len, unsigned char *replace_mac)
{
struct icmp6hdr *icmphdr = (struct icmp6hdr *)data;
unsigned char *mac;
if (icmphdr->icmp6_type == NDISC_ROUTER_SOLICITATION) {
if (len >= 8) {
mac = scan_tlv(&data[8], len - 8, 1, 1);
if (mac) {
RTW_INFO("Router Solicitation, replace MAC From: %02x:%02x:%02x:%02x:%02x:%02x, To: %02x:%02x:%02x:%02x:%02x:%02x\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
replace_mac[0], replace_mac[1], replace_mac[2], replace_mac[3], replace_mac[4], replace_mac[5]);
_rtw_memcpy(mac, replace_mac, 6);
return 1;
}
}
} else if (icmphdr->icmp6_type == NDISC_ROUTER_ADVERTISEMENT) {
if (len >= 16) {
mac = scan_tlv(&data[16], len - 16, 1, 1);
if (mac) {
RTW_INFO("Router Advertisement, replace MAC From: %02x:%02x:%02x:%02x:%02x:%02x, To: %02x:%02x:%02x:%02x:%02x:%02x\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
replace_mac[0], replace_mac[1], replace_mac[2], replace_mac[3], replace_mac[4], replace_mac[5]);
_rtw_memcpy(mac, replace_mac, 6);
return 1;
}
}
} else if (icmphdr->icmp6_type == NDISC_NEIGHBOUR_SOLICITATION) {
if (len >= 24) {
mac = scan_tlv(&data[24], len - 24, 1, 1);
if (mac) {
RTW_INFO("Neighbor Solicitation, replace MAC From: %02x:%02x:%02x:%02x:%02x:%02x, To: %02x:%02x:%02x:%02x:%02x:%02x\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
replace_mac[0], replace_mac[1], replace_mac[2], replace_mac[3], replace_mac[4], replace_mac[5]);
_rtw_memcpy(mac, replace_mac, 6);
return 1;
}
}
} else if (icmphdr->icmp6_type == NDISC_NEIGHBOUR_ADVERTISEMENT) {
if (len >= 24) {
mac = scan_tlv(&data[24], len - 24, 2, 1);
if (mac) {
RTW_INFO("Neighbor Advertisement, replace MAC From: %02x:%02x:%02x:%02x:%02x:%02x, To: %02x:%02x:%02x:%02x:%02x:%02x\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
replace_mac[0], replace_mac[1], replace_mac[2], replace_mac[3], replace_mac[4], replace_mac[5]);
_rtw_memcpy(mac, replace_mac, 6);
return 1;
}
}
} else if (icmphdr->icmp6_type == NDISC_REDIRECT) {
if (len >= 40) {
mac = scan_tlv(&data[40], len - 40, 2, 1);
if (mac) {
RTW_INFO("Redirect, replace MAC From: %02x:%02x:%02x:%02x:%02x:%02x, To: %02x:%02x:%02x:%02x:%02x:%02x\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
replace_mac[0], replace_mac[1], replace_mac[2], replace_mac[3], replace_mac[4], replace_mac[5]);
_rtw_memcpy(mac, replace_mac, 6);
return 1;
}
}
}
return 0;
}
#ifdef SUPPORT_RX_UNI2MCAST
static void convert_ipv6_mac_to_mc(struct sk_buff *skb)
{
struct ipv6hdr *iph = (struct ipv6hdr *)(skb->data + ETH_HLEN);
unsigned char *dst_mac = skb->data;
/* dst_mac[0] = 0xff; */
/* dst_mac[1] = 0xff; */
/*modified by qinjunjie,ipv6 multicast address ix 0x33-33-xx-xx-xx-xx*/
dst_mac[0] = 0x33;
dst_mac[1] = 0x33;
_rtw_memcpy(&dst_mac[2], &iph->daddr.s6_addr32[3], 4);
#if defined(__LINUX_2_6__)
/*modified by qinjunjie,warning:should not remove next line*/
skb->pkt_type = PACKET_MULTICAST;
#endif
}
#endif /* CL_IPV6_PASS */
#endif /* SUPPORT_RX_UNI2MCAST */
static __inline__ int __nat25_network_hash(unsigned char *networkAddr)
{
if (networkAddr[0] == NAT25_IPV4) {
unsigned long x;
x = networkAddr[7] ^ networkAddr[8] ^ networkAddr[9] ^ networkAddr[10];
return x & (NAT25_HASH_SIZE - 1);
#ifdef _NET_INET_IPX_H_
} else if (networkAddr[0] == NAT25_IPX) {
unsigned long x;
x = networkAddr[1] ^ networkAddr[2] ^ networkAddr[3] ^ networkAddr[4] ^ networkAddr[5] ^
networkAddr[6] ^ networkAddr[7] ^ networkAddr[8] ^ networkAddr[9] ^ networkAddr[10];
return x & (NAT25_HASH_SIZE - 1);
} else if (networkAddr[0] == NAT25_APPLE) {
unsigned long x;
x = networkAddr[1] ^ networkAddr[2] ^ networkAddr[3];
return x & (NAT25_HASH_SIZE - 1);
#endif
} else if (networkAddr[0] == NAT25_PPPOE) {
unsigned long x;
x = networkAddr[0] ^ networkAddr[1] ^ networkAddr[2] ^ networkAddr[3] ^ networkAddr[4] ^ networkAddr[5] ^ networkAddr[6] ^ networkAddr[7] ^ networkAddr[8];
return x & (NAT25_HASH_SIZE - 1);
}
#ifdef CL_IPV6_PASS
else if (networkAddr[0] == NAT25_IPV6) {
unsigned long x;
x = networkAddr[1] ^ networkAddr[2] ^ networkAddr[3] ^ networkAddr[4] ^ networkAddr[5] ^
networkAddr[6] ^ networkAddr[7] ^ networkAddr[8] ^ networkAddr[9] ^ networkAddr[10] ^
networkAddr[11] ^ networkAddr[12] ^ networkAddr[13] ^ networkAddr[14] ^ networkAddr[15] ^
networkAddr[16];
return x & (NAT25_HASH_SIZE - 1);
}
#endif
else {
unsigned long x = 0;
int i;
for (i = 0; i < MAX_NETWORK_ADDR_LEN; i++)
x ^= networkAddr[i];
return x & (NAT25_HASH_SIZE - 1);
}
}
static __inline__ void __network_hash_link(_adapter *priv,
struct nat25_network_db_entry *ent, int hash)
{
/* Caller must _rtw_spinlock_bh already! */
/* _rtw_spinlock_bh(&priv->br_ext_lock); */
ent->next_hash = priv->nethash[hash];
if (ent->next_hash != NULL)
ent->next_hash->pprev_hash = &ent->next_hash;
priv->nethash[hash] = ent;
ent->pprev_hash = &priv->nethash[hash];
/* _rtw_spinunlock_bh(&priv->br_ext_lock); */
}
static __inline__ void __network_hash_unlink(struct nat25_network_db_entry *ent)
{
/* Caller must _rtw_spinlock_bh already! */
/* _rtw_spinlock_bh(&priv->br_ext_lock); */
*(ent->pprev_hash) = ent->next_hash;
if (ent->next_hash != NULL)
ent->next_hash->pprev_hash = ent->pprev_hash;
ent->next_hash = NULL;
ent->pprev_hash = NULL;
/* _rtw_spinunlock_bh(&priv->br_ext_lock); */
}
static int __nat25_db_network_lookup_and_replace(_adapter *priv,
struct sk_buff *skb, unsigned char *networkAddr)
{
struct nat25_network_db_entry *db;
_rtw_spinlock_bh(&priv->br_ext_lock);
db = priv->nethash[__nat25_network_hash(networkAddr)];
while (db != NULL) {
if (!_rtw_memcmp(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN)) {
if (!__nat25_has_expired(priv, db)) {
/* replace the destination mac address */
_rtw_memcpy(skb->data, db->macAddr, ETH_ALEN);
atomic_inc(&db->use_count);
#ifdef CL_IPV6_PASS
RTW_INFO("NAT25: Lookup M:%02x%02x%02x%02x%02x%02x N:%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
"%02x%02x%02x%02x%02x%02x\n",
db->macAddr[0],
db->macAddr[1],
db->macAddr[2],
db->macAddr[3],
db->macAddr[4],
db->macAddr[5],
db->networkAddr[0],
db->networkAddr[1],
db->networkAddr[2],
db->networkAddr[3],
db->networkAddr[4],
db->networkAddr[5],
db->networkAddr[6],
db->networkAddr[7],
db->networkAddr[8],
db->networkAddr[9],
db->networkAddr[10],
db->networkAddr[11],
db->networkAddr[12],
db->networkAddr[13],
db->networkAddr[14],
db->networkAddr[15],
db->networkAddr[16]);
#else
RTW_INFO("NAT25: Lookup M:%02x%02x%02x%02x%02x%02x N:%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
db->macAddr[0],
db->macAddr[1],
db->macAddr[2],
db->macAddr[3],
db->macAddr[4],
db->macAddr[5],
db->networkAddr[0],
db->networkAddr[1],
db->networkAddr[2],
db->networkAddr[3],
db->networkAddr[4],
db->networkAddr[5],
db->networkAddr[6],
db->networkAddr[7],
db->networkAddr[8],
db->networkAddr[9],
db->networkAddr[10]);
#endif
}
_rtw_spinunlock_bh(&priv->br_ext_lock);
return 1;
}
db = db->next_hash;
}
_rtw_spinunlock_bh(&priv->br_ext_lock);
return 0;
}
static void __nat25_db_network_insert(_adapter *priv,
unsigned char *macAddr, unsigned char *networkAddr)
{
struct nat25_network_db_entry *db;
int hash;
_rtw_spinlock_bh(&priv->br_ext_lock);
hash = __nat25_network_hash(networkAddr);
db = priv->nethash[hash];
while (db != NULL) {
if (!_rtw_memcmp(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN)) {
_rtw_memcpy(db->macAddr, macAddr, ETH_ALEN);
db->ageing_timer = jiffies;
_rtw_spinunlock_bh(&priv->br_ext_lock);
return;
}
db = db->next_hash;
}
db = (struct nat25_network_db_entry *) rtw_malloc(sizeof(*db));
if (db == NULL) {
_rtw_spinunlock_bh(&priv->br_ext_lock);
return;
}
_rtw_memcpy(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN);
_rtw_memcpy(db->macAddr, macAddr, ETH_ALEN);
atomic_set(&db->use_count, 1);
db->ageing_timer = jiffies;
__network_hash_link(priv, db, hash);
_rtw_spinunlock_bh(&priv->br_ext_lock);
}
static void __nat25_db_print(_adapter *priv)
{
_rtw_spinlock_bh(&priv->br_ext_lock);
#ifdef BR_EXT_DEBUG
static int counter = 0;
int i, j;
struct nat25_network_db_entry *db;
counter++;
if ((counter % 16) != 0)
return;
for (i = 0, j = 0; i < NAT25_HASH_SIZE; i++) {
db = priv->nethash[i];
while (db != NULL) {
#ifdef CL_IPV6_PASS
panic_printk("NAT25: DB(%d) H(%02d) C(%d) M:%02x%02x%02x%02x%02x%02x N:%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
"%02x%02x%02x%02x%02x%02x\n",
j,
i,
atomic_read(&db->use_count),
db->macAddr[0],
db->macAddr[1],
db->macAddr[2],
db->macAddr[3],
db->macAddr[4],
db->macAddr[5],
db->networkAddr[0],
db->networkAddr[1],
db->networkAddr[2],
db->networkAddr[3],
db->networkAddr[4],
db->networkAddr[5],
db->networkAddr[6],
db->networkAddr[7],
db->networkAddr[8],
db->networkAddr[9],
db->networkAddr[10],
db->networkAddr[11],
db->networkAddr[12],
db->networkAddr[13],
db->networkAddr[14],
db->networkAddr[15],
db->networkAddr[16]);
#else
panic_printk("NAT25: DB(%d) H(%02d) C(%d) M:%02x%02x%02x%02x%02x%02x N:%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
j,
i,
atomic_read(&db->use_count),
db->macAddr[0],
db->macAddr[1],
db->macAddr[2],
db->macAddr[3],
db->macAddr[4],
db->macAddr[5],
db->networkAddr[0],
db->networkAddr[1],
db->networkAddr[2],
db->networkAddr[3],
db->networkAddr[4],
db->networkAddr[5],
db->networkAddr[6],
db->networkAddr[7],
db->networkAddr[8],
db->networkAddr[9],
db->networkAddr[10]);
#endif
j++;
db = db->next_hash;
}
}
#endif
_rtw_spinunlock_bh(&priv->br_ext_lock);
}
/*
* NAT2.5 interface
*/
void nat25_db_cleanup(_adapter *priv)
{
int i;
_rtw_spinlock_bh(&priv->br_ext_lock);
for (i = 0; i < NAT25_HASH_SIZE; i++) {
struct nat25_network_db_entry *f;
f = priv->nethash[i];
while (f != NULL) {
struct nat25_network_db_entry *g;
g = f->next_hash;
if (priv->scdb_entry == f) {
_rtw_memset(priv->scdb_mac, 0, ETH_ALEN);
_rtw_memset(priv->scdb_ip, 0, 4);
priv->scdb_entry = NULL;
}
__network_hash_unlink(f);
rtw_mfree((u8 *) f, sizeof(struct nat25_network_db_entry));
f = g;
}
}
_rtw_spinunlock_bh(&priv->br_ext_lock);
}
void nat25_db_expire(_adapter *priv)
{
int i;
_rtw_spinlock_bh(&priv->br_ext_lock);
/* if(!priv->ethBrExtInfo.nat25_disable) */
{
for (i = 0; i < NAT25_HASH_SIZE; i++) {
struct nat25_network_db_entry *f;
f = priv->nethash[i];
while (f != NULL) {
struct nat25_network_db_entry *g;
g = f->next_hash;
if (__nat25_has_expired(priv, f)) {
if (atomic_dec_and_test(&f->use_count)) {
#ifdef BR_EXT_DEBUG
#ifdef CL_IPV6_PASS
panic_printk("NAT25 Expire H(%02d) M:%02x%02x%02x%02x%02x%02x N:%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
"%02x%02x%02x%02x%02x%02x\n",
i,
f->macAddr[0],
f->macAddr[1],
f->macAddr[2],
f->macAddr[3],
f->macAddr[4],
f->macAddr[5],
f->networkAddr[0],
f->networkAddr[1],
f->networkAddr[2],
f->networkAddr[3],
f->networkAddr[4],
f->networkAddr[5],
f->networkAddr[6],
f->networkAddr[7],
f->networkAddr[8],
f->networkAddr[9],
f->networkAddr[10],
f->networkAddr[11],
f->networkAddr[12],
f->networkAddr[13],
f->networkAddr[14],
f->networkAddr[15],
f->networkAddr[16]);
#else
panic_printk("NAT25 Expire H(%02d) M:%02x%02x%02x%02x%02x%02x N:%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
i,
f->macAddr[0],
f->macAddr[1],
f->macAddr[2],
f->macAddr[3],
f->macAddr[4],
f->macAddr[5],
f->networkAddr[0],
f->networkAddr[1],
f->networkAddr[2],
f->networkAddr[3],
f->networkAddr[4],
f->networkAddr[5],
f->networkAddr[6],
f->networkAddr[7],
f->networkAddr[8],
f->networkAddr[9],
f->networkAddr[10]);
#endif
#endif
if (priv->scdb_entry == f) {
_rtw_memset(priv->scdb_mac, 0, ETH_ALEN);
_rtw_memset(priv->scdb_ip, 0, 4);
priv->scdb_entry = NULL;
}
__network_hash_unlink(f);
rtw_mfree((u8 *) f, sizeof(struct nat25_network_db_entry));
}
}
f = g;
}
}
}
_rtw_spinunlock_bh(&priv->br_ext_lock);
}
#ifdef SUPPORT_TX_MCAST2UNI
static int checkIPMcAndReplace(_adapter *priv, struct sk_buff *skb, unsigned int *dst_ip)
{
struct stat_info *pstat;
struct list_head *phead, *plist;
int i;
phead = &priv->asoc_list;
plist = phead->next;
while (plist != phead) {
pstat = list_entry(plist, struct stat_info, asoc_list);
plist = plist->next;
if (pstat->ipmc_num == 0)
continue;
for (i = 0; i < MAX_IP_MC_ENTRY; i++) {
if (pstat->ipmc[i].used && !_rtw_memcmp(&pstat->ipmc[i].mcmac[3], ((unsigned char *)dst_ip) + 1, 3)) {
_rtw_memcpy(skb->data, pstat->ipmc[i].mcmac, ETH_ALEN);
return 1;
}
}
}
return 0;
}
#endif
int nat25_db_handle(_adapter *priv, struct sk_buff *skb, int method)
{
unsigned short protocol;
unsigned char networkAddr[MAX_NETWORK_ADDR_LEN];
if (skb == NULL)
return -1;
if ((method <= NAT25_MIN) || (method >= NAT25_MAX))
return -1;
protocol = *((unsigned short *)(skb->data + 2 * ETH_ALEN));
/*---------------------------------------------------*/
/* Handle IP frame */
/*---------------------------------------------------*/
if (protocol == __constant_htons(ETH_P_IP)) {
struct iphdr *iph = (struct iphdr *)(skb->data + ETH_HLEN);
if (((unsigned char *)(iph) + (iph->ihl << 2)) >= (skb->data + ETH_HLEN + skb->len)) {
DEBUG_WARN("NAT25: malformed IP packet !\n");
return -1;
}
switch (method) {
case NAT25_CHECK:
return -1;
case NAT25_INSERT: {
/* some muticast with source IP is all zero, maybe other case is illegal */
/* in class A, B, C, host address is all zero or all one is illegal */
if (iph->saddr == 0)
return 0;
RTW_INFO("NAT25: Insert IP, SA=%08x, DA=%08x\n", iph->saddr, iph->daddr);
__nat25_generate_ipv4_network_addr(networkAddr, &iph->saddr);
/* record source IP address and , source mac address into db */
__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
__nat25_db_print(priv);
}
return 0;
case NAT25_LOOKUP: {
RTW_INFO("NAT25: Lookup IP, SA=%08x, DA=%08x\n", iph->saddr, iph->daddr);
#ifdef SUPPORT_TX_MCAST2UNI
if (priv->pshare->rf_ft_var.mc2u_disable ||
((((OPMODE & (WIFI_STATION_STATE | WIFI_ASOC_STATE))
== (WIFI_STATION_STATE | WIFI_ASOC_STATE)) &&
!checkIPMcAndReplace(priv, skb, &iph->daddr)) ||
(OPMODE & WIFI_ADHOC_STATE)))
#endif
{
__nat25_generate_ipv4_network_addr(networkAddr, &iph->daddr);
if (!__nat25_db_network_lookup_and_replace(priv, skb, networkAddr)) {
if (*((unsigned char *)&iph->daddr + 3) == 0xff) {
/* L2 is unicast but L3 is broadcast, make L2 bacome broadcast */
RTW_INFO("NAT25: Set DA as boardcast\n");
_rtw_memset(skb->data, 0xff, ETH_ALEN);
} else {
/* forward unknow IP packet to upper TCP/IP */
RTW_INFO("NAT25: Replace DA with BR's MAC\n");
if ((*(u32 *)priv->br_mac) == 0 && (*(u16 *)(priv->br_mac + 4)) == 0) {
void netdev_br_init(struct net_device *netdev);
printk("Re-init netdev_br_init() due to br_mac==0!\n");
netdev_br_init(priv->pnetdev);
}
_rtw_memcpy(skb->data, priv->br_mac, ETH_ALEN);
}
}
}
}
return 0;
default:
return -1;
}
}
/*---------------------------------------------------*/
/* Handle ARP frame */
/*---------------------------------------------------*/
else if (protocol == __constant_htons(ETH_P_ARP)) {
struct arphdr *arp = (struct arphdr *)(skb->data + ETH_HLEN);
unsigned char *arp_ptr = (unsigned char *)(arp + 1);
unsigned int *sender, *target;
if (arp->ar_pro != __constant_htons(ETH_P_IP)) {
DEBUG_WARN("NAT25: arp protocol unknown (%4x)!\n", htons(arp->ar_pro));
return -1;
}
switch (method) {
case NAT25_CHECK:
return 0; /* skb_copy for all ARP frame */
case NAT25_INSERT: {
RTW_INFO("NAT25: Insert ARP, MAC=%02x%02x%02x%02x%02x%02x\n", arp_ptr[0],
arp_ptr[1], arp_ptr[2], arp_ptr[3], arp_ptr[4], arp_ptr[5]);
/* change to ARP sender mac address to wlan STA address */
_rtw_memcpy(arp_ptr, GET_MY_HWADDR(priv), ETH_ALEN);
arp_ptr += arp->ar_hln;
sender = (unsigned int *)arp_ptr;
__nat25_generate_ipv4_network_addr(networkAddr, sender);
__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
__nat25_db_print(priv);
}
return 0;
case NAT25_LOOKUP: {
RTW_INFO("NAT25: Lookup ARP\n");
arp_ptr += arp->ar_hln;
sender = (unsigned int *)arp_ptr;
arp_ptr += (arp->ar_hln + arp->ar_pln);
target = (unsigned int *)arp_ptr;
__nat25_generate_ipv4_network_addr(networkAddr, target);
__nat25_db_network_lookup_and_replace(priv, skb, networkAddr);
/* change to ARP target mac address to Lookup result */
arp_ptr = (unsigned char *)(arp + 1);
arp_ptr += (arp->ar_hln + arp->ar_pln);
_rtw_memcpy(arp_ptr, skb->data, ETH_ALEN);
}
return 0;
default:
return -1;
}
}
#ifdef _NET_INET_IPX_H_
/*---------------------------------------------------*/
/* Handle IPX and Apple Talk frame */
/*---------------------------------------------------*/
else if ((protocol == __constant_htons(ETH_P_IPX)) ||
(protocol == __constant_htons(ETH_P_ATALK)) ||
(protocol == __constant_htons(ETH_P_AARP))) {
unsigned char ipx_header[2] = {0xFF, 0xFF};
struct ipxhdr *ipx = NULL;
struct elapaarp *ea = NULL;
struct ddpehdr *ddp = NULL;
unsigned char *framePtr = skb->data + ETH_HLEN;
if (protocol == __constant_htons(ETH_P_IPX)) {
RTW_INFO("NAT25: Protocol=IPX (Ethernet II)\n");
ipx = (struct ipxhdr *)framePtr;
} else { /* if(protocol <= __constant_htons(ETH_FRAME_LEN)) */
if (!_rtw_memcmp(ipx_header, framePtr, 2)) {
RTW_INFO("NAT25: Protocol=IPX (Ethernet 802.3)\n");
ipx = (struct ipxhdr *)framePtr;
} else {
unsigned char ipx_8022_type = 0xE0;
unsigned char snap_8022_type = 0xAA;
if (*framePtr == snap_8022_type) {
unsigned char ipx_snap_id[5] = {0x0, 0x0, 0x0, 0x81, 0x37}; /* IPX SNAP ID */
unsigned char aarp_snap_id[5] = {0x00, 0x00, 0x00, 0x80, 0xF3}; /* Apple Talk AARP SNAP ID */
unsigned char ddp_snap_id[5] = {0x08, 0x00, 0x07, 0x80, 0x9B}; /* Apple Talk DDP SNAP ID */
framePtr += 3; /* eliminate the 802.2 header */
if (!_rtw_memcmp(ipx_snap_id, framePtr, 5)) {
framePtr += 5; /* eliminate the SNAP header */
RTW_INFO("NAT25: Protocol=IPX (Ethernet SNAP)\n");
ipx = (struct ipxhdr *)framePtr;
} else if (!_rtw_memcmp(aarp_snap_id, framePtr, 5)) {
framePtr += 5; /* eliminate the SNAP header */
ea = (struct elapaarp *)framePtr;
} else if (!_rtw_memcmp(ddp_snap_id, framePtr, 5)) {
framePtr += 5; /* eliminate the SNAP header */
ddp = (struct ddpehdr *)framePtr;
} else {
DEBUG_WARN("NAT25: Protocol=Ethernet SNAP %02x%02x%02x%02x%02x\n", framePtr[0],
framePtr[1], framePtr[2], framePtr[3], framePtr[4]);
return -1;
}
} else if (*framePtr == ipx_8022_type) {
framePtr += 3; /* eliminate the 802.2 header */
if (!_rtw_memcmp(ipx_header, framePtr, 2)) {
RTW_INFO("NAT25: Protocol=IPX (Ethernet 802.2)\n");
ipx = (struct ipxhdr *)framePtr;
} else
return -1;
}
}
}
/* IPX */
if (ipx != NULL) {
switch (method) {
case NAT25_CHECK:
if (!_rtw_memcmp(skb->data + ETH_ALEN, ipx->ipx_source.node, ETH_ALEN)) {
RTW_INFO("NAT25: Check IPX skb_copy\n");
return 0;
}
return -1;
case NAT25_INSERT: {
RTW_INFO("NAT25: Insert IPX, Dest=%08x,%02x%02x%02x%02x%02x%02x,%04x Source=%08x,%02x%02x%02x%02x%02x%02x,%04x\n",
ipx->ipx_dest.net,
ipx->ipx_dest.node[0],
ipx->ipx_dest.node[1],
ipx->ipx_dest.node[2],
ipx->ipx_dest.node[3],
ipx->ipx_dest.node[4],
ipx->ipx_dest.node[5],
ipx->ipx_dest.sock,
ipx->ipx_source.net,
ipx->ipx_source.node[0],
ipx->ipx_source.node[1],
ipx->ipx_source.node[2],
ipx->ipx_source.node[3],
ipx->ipx_source.node[4],
ipx->ipx_source.node[5],
ipx->ipx_source.sock);
if (!_rtw_memcmp(skb->data + ETH_ALEN, ipx->ipx_source.node, ETH_ALEN)) {
RTW_INFO("NAT25: Use IPX Net, and Socket as network addr\n");
__nat25_generate_ipx_network_addr_with_socket(networkAddr, &ipx->ipx_source.net, &ipx->ipx_source.sock);
/* change IPX source node addr to wlan STA address */
_rtw_memcpy(ipx->ipx_source.node, GET_MY_HWADDR(priv), ETH_ALEN);
} else
__nat25_generate_ipx_network_addr_with_node(networkAddr, &ipx->ipx_source.net, ipx->ipx_source.node);
__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
__nat25_db_print(priv);
}
return 0;
case NAT25_LOOKUP: {
if (!_rtw_memcmp(GET_MY_HWADDR(priv), ipx->ipx_dest.node, ETH_ALEN)) {
RTW_INFO("NAT25: Lookup IPX, Modify Destination IPX Node addr\n");
__nat25_generate_ipx_network_addr_with_socket(networkAddr, &ipx->ipx_dest.net, &ipx->ipx_dest.sock);
__nat25_db_network_lookup_and_replace(priv, skb, networkAddr);
/* replace IPX destination node addr with Lookup destination MAC addr */
_rtw_memcpy(ipx->ipx_dest.node, skb->data, ETH_ALEN);
} else {
__nat25_generate_ipx_network_addr_with_node(networkAddr, &ipx->ipx_dest.net, ipx->ipx_dest.node);
__nat25_db_network_lookup_and_replace(priv, skb, networkAddr);
}
}
return 0;
default:
return -1;
}
}
/* AARP */
else if (ea != NULL) {
/* Sanity check fields. */
if (ea->hw_len != ETH_ALEN || ea->pa_len != AARP_PA_ALEN) {
DEBUG_WARN("NAT25: Appletalk AARP Sanity check fail!\n");
return -1;
}
switch (method) {
case NAT25_CHECK:
return 0;
case NAT25_INSERT: {
/* change to AARP source mac address to wlan STA address */
_rtw_memcpy(ea->hw_src, GET_MY_HWADDR(priv), ETH_ALEN);
RTW_INFO("NAT25: Insert AARP, Source=%d,%d Destination=%d,%d\n",
ea->pa_src_net,
ea->pa_src_node,
ea->pa_dst_net,
ea->pa_dst_node);
__nat25_generate_apple_network_addr(networkAddr, &ea->pa_src_net, &ea->pa_src_node);
__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
__nat25_db_print(priv);
}
return 0;
case NAT25_LOOKUP: {
RTW_INFO("NAT25: Lookup AARP, Source=%d,%d Destination=%d,%d\n",
ea->pa_src_net,
ea->pa_src_node,
ea->pa_dst_net,
ea->pa_dst_node);
__nat25_generate_apple_network_addr(networkAddr, &ea->pa_dst_net, &ea->pa_dst_node);
__nat25_db_network_lookup_and_replace(priv, skb, networkAddr);
/* change to AARP destination mac address to Lookup result */
_rtw_memcpy(ea->hw_dst, skb->data, ETH_ALEN);
}
return 0;
default:
return -1;
}
}
/* DDP */
else if (ddp != NULL) {
switch (method) {
case NAT25_CHECK:
return -1;
case NAT25_INSERT: {
RTW_INFO("NAT25: Insert DDP, Source=%d,%d Destination=%d,%d\n",
ddp->deh_snet,
ddp->deh_snode,
ddp->deh_dnet,
ddp->deh_dnode);
__nat25_generate_apple_network_addr(networkAddr, &ddp->deh_snet, &ddp->deh_snode);
__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
__nat25_db_print(priv);
}
return 0;
case NAT25_LOOKUP: {
RTW_INFO("NAT25: Lookup DDP, Source=%d,%d Destination=%d,%d\n",
ddp->deh_snet,
ddp->deh_snode,
ddp->deh_dnet,
ddp->deh_dnode);
__nat25_generate_apple_network_addr(networkAddr, &ddp->deh_dnet, &ddp->deh_dnode);
__nat25_db_network_lookup_and_replace(priv, skb, networkAddr);
}
return 0;
default:
return -1;
}
}
return -1;
}
#endif
/*---------------------------------------------------*/
/* Handle PPPoE frame */
/*---------------------------------------------------*/
else if ((protocol == __constant_htons(ETH_P_PPP_DISC)) ||
(protocol == __constant_htons(ETH_P_PPP_SES))) {
struct pppoe_hdr *ph = (struct pppoe_hdr *)(skb->data + ETH_HLEN);
unsigned short *pMagic;
switch (method) {
case NAT25_CHECK:
if (ph->sid == 0)
return 0;
return 1;
case NAT25_INSERT:
if (ph->sid == 0) { /* Discovery phase according to tag */
if (ph->code == PADI_CODE || ph->code == PADR_CODE) {
if (priv->ethBrExtInfo.addPPPoETag) {
struct pppoe_tag *tag, *pOldTag;
unsigned char tag_buf[40];
int old_tag_len = 0;
tag = (struct pppoe_tag *)tag_buf;
pOldTag = (struct pppoe_tag *)__nat25_find_pppoe_tag(ph, ntohs(PTT_RELAY_SID));
if (pOldTag) { /* if SID existed, copy old value and delete it */
old_tag_len = ntohs(pOldTag->tag_len);
if (old_tag_len + TAG_HDR_LEN + MAGIC_CODE_LEN + RTL_RELAY_TAG_LEN > sizeof(tag_buf)) {
DEBUG_ERR("SID tag length too long!\n");
return -1;
}
_rtw_memcpy(tag->tag_data + MAGIC_CODE_LEN + RTL_RELAY_TAG_LEN,
pOldTag->tag_data, old_tag_len);
if (skb_pull_and_merge(skb, (unsigned char *)pOldTag, TAG_HDR_LEN + old_tag_len) < 0) {
DEBUG_ERR("call skb_pull_and_merge() failed in PADI/R packet!\n");
return -1;
}
ph->length = htons(ntohs(ph->length) - TAG_HDR_LEN - old_tag_len);
}
tag->tag_type = PTT_RELAY_SID;
tag->tag_len = htons(MAGIC_CODE_LEN + RTL_RELAY_TAG_LEN + old_tag_len);
/* insert the magic_code+client mac in relay tag */
pMagic = (unsigned short *)tag->tag_data;
*pMagic = htons(MAGIC_CODE);
_rtw_memcpy(tag->tag_data + MAGIC_CODE_LEN, skb->data + ETH_ALEN, ETH_ALEN);
/* Add relay tag */
if (__nat25_add_pppoe_tag(skb, tag) < 0)
return -1;
RTW_INFO("NAT25: Insert PPPoE, forward %s packet\n",
(ph->code == PADI_CODE ? "PADI" : "PADR"));
} else { /* not add relay tag */
if (priv->pppoe_connection_in_progress &&
_rtw_memcmp(skb->data + ETH_ALEN, priv->pppoe_addr, ETH_ALEN)) {
DEBUG_ERR("Discard PPPoE packet due to another PPPoE connection is in progress!\n");
return -2;
}
if (priv->pppoe_connection_in_progress == 0)
_rtw_memcpy(priv->pppoe_addr, skb->data + ETH_ALEN, ETH_ALEN);
priv->pppoe_connection_in_progress = WAIT_TIME_PPPOE;
}
} else
return -1;
} else { /* session phase */
RTW_INFO("NAT25: Insert PPPoE, insert session packet to %s\n", skb->dev->name);
__nat25_generate_pppoe_network_addr(networkAddr, skb->data, &(ph->sid));
__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
__nat25_db_print(priv);
if (!priv->ethBrExtInfo.addPPPoETag &&
priv->pppoe_connection_in_progress &&
!_rtw_memcmp(skb->data + ETH_ALEN, priv->pppoe_addr, ETH_ALEN))
priv->pppoe_connection_in_progress = 0;
}
return 0;
case NAT25_LOOKUP:
if (ph->code == PADO_CODE || ph->code == PADS_CODE) {
if (priv->ethBrExtInfo.addPPPoETag) {
struct pppoe_tag *tag;
unsigned char *ptr;
unsigned short tagType, tagLen;
int offset = 0;
ptr = __nat25_find_pppoe_tag(ph, ntohs(PTT_RELAY_SID));
if (ptr == 0) {
DEBUG_ERR("Fail to find PTT_RELAY_SID in FADO!\n");
return -1;
}
tag = (struct pppoe_tag *)ptr;
tagType = (unsigned short)((ptr[0] << 8) + ptr[1]);
tagLen = (unsigned short)((ptr[2] << 8) + ptr[3]);
if ((tagType != ntohs(PTT_RELAY_SID)) || (tagLen < (MAGIC_CODE_LEN + RTL_RELAY_TAG_LEN))) {
DEBUG_ERR("Invalid PTT_RELAY_SID tag length [%d]!\n", tagLen);
return -1;
}
pMagic = (unsigned short *)tag->tag_data;
if (ntohs(*pMagic) != MAGIC_CODE) {
DEBUG_ERR("Can't find MAGIC_CODE in %s packet!\n",
(ph->code == PADO_CODE ? "PADO" : "PADS"));
return -1;
}
_rtw_memcpy(skb->data, tag->tag_data + MAGIC_CODE_LEN, ETH_ALEN);
if (tagLen > MAGIC_CODE_LEN + RTL_RELAY_TAG_LEN)
offset = TAG_HDR_LEN;
if (skb_pull_and_merge(skb, ptr + offset, TAG_HDR_LEN + MAGIC_CODE_LEN + RTL_RELAY_TAG_LEN - offset) < 0) {
DEBUG_ERR("call skb_pull_and_merge() failed in PADO packet!\n");
return -1;
}
ph->length = htons(ntohs(ph->length) - (TAG_HDR_LEN + MAGIC_CODE_LEN + RTL_RELAY_TAG_LEN - offset));
if (offset > 0)
tag->tag_len = htons(tagLen - MAGIC_CODE_LEN - RTL_RELAY_TAG_LEN);
RTW_INFO("NAT25: Lookup PPPoE, forward %s Packet from %s\n",
(ph->code == PADO_CODE ? "PADO" : "PADS"), skb->dev->name);
} else { /* not add relay tag */
if (!priv->pppoe_connection_in_progress) {
DEBUG_ERR("Discard PPPoE packet due to no connection in progresss!\n");
return -1;
}
_rtw_memcpy(skb->data, priv->pppoe_addr, ETH_ALEN);
priv->pppoe_connection_in_progress = WAIT_TIME_PPPOE;
}
} else {
if (ph->sid != 0) {
RTW_INFO("NAT25: Lookup PPPoE, lookup session packet from %s\n", skb->dev->name);
__nat25_generate_pppoe_network_addr(networkAddr, skb->data + ETH_ALEN, &(ph->sid));
__nat25_db_network_lookup_and_replace(priv, skb, networkAddr);
__nat25_db_print(priv);
} else
return -1;
}
return 0;
default:
return -1;
}
}
/*---------------------------------------------------*/
/* Handle EAP frame */
/*---------------------------------------------------*/
else if (protocol == __constant_htons(0x888e)) {
switch (method) {
case NAT25_CHECK:
return -1;
case NAT25_INSERT:
return 0;
case NAT25_LOOKUP:
return 0;
default:
return -1;
}
}
/*---------------------------------------------------*/
/* Handle C-Media proprietary frame */
/*---------------------------------------------------*/
else if ((protocol == __constant_htons(0xe2ae)) ||
(protocol == __constant_htons(0xe2af))) {
switch (method) {
case NAT25_CHECK:
return -1;
case NAT25_INSERT:
return 0;
case NAT25_LOOKUP:
return 0;
default:
return -1;
}
}
/*---------------------------------------------------*/
/* Handle IPV6 frame */
/*---------------------------------------------------*/
#ifdef CL_IPV6_PASS
else if (protocol == __constant_htons(ETH_P_IPV6)) {
struct ipv6hdr *iph = (struct ipv6hdr *)(skb->data + ETH_HLEN);
if (sizeof(*iph) >= (skb->len - ETH_HLEN)) {
DEBUG_WARN("NAT25: malformed IPv6 packet !\n");
return -1;
}
switch (method) {
case NAT25_CHECK:
if (skb->data[0] & 1)
return 0;
return -1;
case NAT25_INSERT: {
RTW_INFO("NAT25: Insert IP, SA=%4x:%4x:%4x:%4x:%4x:%4x:%4x:%4x,"
" DA=%4x:%4x:%4x:%4x:%4x:%4x:%4x:%4x\n",
iph->saddr.s6_addr16[0], iph->saddr.s6_addr16[1], iph->saddr.s6_addr16[2], iph->saddr.s6_addr16[3],
iph->saddr.s6_addr16[4], iph->saddr.s6_addr16[5], iph->saddr.s6_addr16[6], iph->saddr.s6_addr16[7],
iph->daddr.s6_addr16[0], iph->daddr.s6_addr16[1], iph->daddr.s6_addr16[2], iph->daddr.s6_addr16[3],
iph->daddr.s6_addr16[4], iph->daddr.s6_addr16[5], iph->daddr.s6_addr16[6], iph->daddr.s6_addr16[7]);
if (_rtw_memcmp(&iph->saddr, "\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0\x0", 16)) {
__nat25_generate_ipv6_network_addr(networkAddr, (unsigned int *)&iph->saddr);
__nat25_db_network_insert(priv, skb->data + ETH_ALEN, networkAddr);
__nat25_db_print(priv);
if (iph->nexthdr == IPPROTO_ICMPV6 &&
skb->len > (ETH_HLEN + sizeof(*iph) + 4)) {
if (update_nd_link_layer_addr(skb->data + ETH_HLEN + sizeof(*iph),
skb->len - ETH_HLEN - sizeof(*iph), GET_MY_HWADDR(priv))) {
struct icmp6hdr *hdr = (struct icmp6hdr *)(skb->data + ETH_HLEN + sizeof(*iph));
hdr->icmp6_cksum = 0;
hdr->icmp6_cksum = csum_ipv6_magic(&iph->saddr, &iph->daddr,
iph->payload_len,
IPPROTO_ICMPV6,
csum_partial((__u8 *)hdr, iph->payload_len, 0));
}
}
}
}
return 0;
case NAT25_LOOKUP:
RTW_INFO("NAT25: Lookup IP, SA=%4x:%4x:%4x:%4x:%4x:%4x:%4x:%4x,"
" DA=%4x:%4x:%4x:%4x:%4x:%4x:%4x:%4x\n",
iph->saddr.s6_addr16[0], iph->saddr.s6_addr16[1], iph->saddr.s6_addr16[2], iph->saddr.s6_addr16[3],
iph->saddr.s6_addr16[4], iph->saddr.s6_addr16[5], iph->saddr.s6_addr16[6], iph->saddr.s6_addr16[7],
iph->daddr.s6_addr16[0], iph->daddr.s6_addr16[1], iph->daddr.s6_addr16[2], iph->daddr.s6_addr16[3],
iph->daddr.s6_addr16[4], iph->daddr.s6_addr16[5], iph->daddr.s6_addr16[6], iph->daddr.s6_addr16[7]);
__nat25_generate_ipv6_network_addr(networkAddr, (unsigned int *)&iph->daddr);
if (!__nat25_db_network_lookup_and_replace(priv, skb, networkAddr)) {
#ifdef SUPPORT_RX_UNI2MCAST
if (iph->daddr.s6_addr[0] == 0xff)
convert_ipv6_mac_to_mc(skb);
#endif
}
return 0;
default:
return -1;
}
}
#endif /* CL_IPV6_PASS */
return -1;
}
int nat25_handle_frame(_adapter *priv, struct sk_buff *skb)
{
#ifdef BR_EXT_DEBUG
if ((!priv->ethBrExtInfo.nat25_disable) && (!(skb->data[0] & 1))) {
panic_printk("NAT25: Input Frame: DA=%02x%02x%02x%02x%02x%02x SA=%02x%02x%02x%02x%02x%02x\n",
skb->data[0],
skb->data[1],
skb->data[2],
skb->data[3],
skb->data[4],
skb->data[5],
skb->data[6],
skb->data[7],
skb->data[8],
skb->data[9],
skb->data[10],
skb->data[11]);
}
#endif
if (!(skb->data[0] & 1)) {
int is_vlan_tag = 0, i, retval = 0;
unsigned short vlan_hdr = 0;
if (*((unsigned short *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_8021Q)) {
is_vlan_tag = 1;
vlan_hdr = *((unsigned short *)(skb->data + ETH_ALEN * 2 + 2));
for (i = 0; i < 6; i++)
*((unsigned short *)(skb->data + ETH_ALEN * 2 + 2 - i * 2)) = *((unsigned short *)(skb->data + ETH_ALEN * 2 - 2 - i * 2));
skb_pull(skb, 4);
}
if (!priv->ethBrExtInfo.nat25_disable) {
_rtw_spinlock_bh(&priv->br_ext_lock);
/*
* This function look up the destination network address from
* the NAT2.5 database. Return value = -1 means that the
* corresponding network protocol is NOT support.
*/
if (!priv->ethBrExtInfo.nat25sc_disable &&
(*((unsigned short *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_IP)) &&
!_rtw_memcmp(priv->scdb_ip, skb->data + ETH_HLEN + 16, 4)) {
_rtw_memcpy(skb->data, priv->scdb_mac, ETH_ALEN);
_rtw_spinunlock_bh(&priv->br_ext_lock);
} else {
_rtw_spinunlock_bh(&priv->br_ext_lock);
retval = nat25_db_handle(priv, skb, NAT25_LOOKUP);
}
} else {
if (((*((unsigned short *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_IP)) &&
!_rtw_memcmp(priv->br_ip, skb->data + ETH_HLEN + 16, 4)) ||
((*((unsigned short *)(skb->data + ETH_ALEN * 2)) == __constant_htons(ETH_P_ARP)) &&
!_rtw_memcmp(priv->br_ip, skb->data + ETH_HLEN + 24, 4))) {
/* for traffic to upper TCP/IP */
retval = nat25_db_handle(priv, skb, NAT25_LOOKUP);
}
}
if (is_vlan_tag) {
skb_push(skb, 4);
for (i = 0; i < 6; i++)
*((unsigned short *)(skb->data + i * 2)) = *((unsigned short *)(skb->data + 4 + i * 2));
*((unsigned short *)(skb->data + ETH_ALEN * 2)) = __constant_htons(ETH_P_8021Q);
*((unsigned short *)(skb->data + ETH_ALEN * 2 + 2)) = vlan_hdr;
}
if (retval == -1) {
/* DEBUG_ERR("NAT25: Lookup fail!\n"); */
return -1;
}
}
return 0;
}
#if 0
void mac_clone(_adapter *priv, unsigned char *addr)
{
struct sockaddr sa;
_rtw_memcpy(sa.sa_data, addr, ETH_ALEN);
RTW_INFO("MAC Clone: Addr=%02x%02x%02x%02x%02x%02x\n",
addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
rtl8192cd_set_hwaddr(priv->dev, &sa);
}
int mac_clone_handle_frame(_adapter *priv, struct sk_buff *skb)
{
if (priv->ethBrExtInfo.macclone_enable && !priv->macclone_completed) {
if (!(skb->data[ETH_ALEN] & 1)) { /* check any other particular MAC add */
if (_rtw_memcmp(skb->data + ETH_ALEN, GET_MY_HWADDR(priv), ETH_ALEN) &&
((priv->dev->br_port) &&
_rtw_memcmp(skb->data + ETH_ALEN, priv->br_mac, ETH_ALEN))) {
mac_clone(priv, skb->data + ETH_ALEN);
priv->macclone_completed = 1;
}
}
}
return 0;
}
#endif /* 0 */
#define SERVER_PORT 67
#define CLIENT_PORT 68
#define DHCP_MAGIC 0x63825363
#define BROADCAST_FLAG 0x8000
struct dhcpMessage {
u_int8_t op;
u_int8_t htype;
u_int8_t hlen;
u_int8_t hops;
u_int32_t xid;
u_int16_t secs;
u_int16_t flags;
u_int32_t ciaddr;
u_int32_t yiaddr;
u_int32_t siaddr;
u_int32_t giaddr;
u_int8_t chaddr[16];
u_int8_t sname[64];
u_int8_t file[128];
u_int32_t cookie;
u_int8_t options[308]; /* 312 - cookie */
};
void dhcp_flag_bcast(_adapter *priv, struct sk_buff *skb)
{
if (skb == NULL)
return;
if (!priv->ethBrExtInfo.dhcp_bcst_disable) {
unsigned short protocol = *((unsigned short *)(skb->data + 2 * ETH_ALEN));
if (protocol == __constant_htons(ETH_P_IP)) { /* IP */
struct iphdr *iph = (struct iphdr *)(skb->data + ETH_HLEN);
if (iph->protocol == IPPROTO_UDP) { /* UDP */
struct udphdr *udph = (struct udphdr *)((SIZE_PTR)iph + (iph->ihl << 2));
if ((udph->source == __constant_htons(CLIENT_PORT))
&& (udph->dest == __constant_htons(SERVER_PORT))) { /* DHCP request */
struct dhcpMessage *dhcph =
(struct dhcpMessage *)((SIZE_PTR)udph + sizeof(struct udphdr));
if (dhcph->cookie == __constant_htonl(DHCP_MAGIC)) { /* match magic word */
if (!(dhcph->flags & htons(BROADCAST_FLAG))) { /* if not broadcast */
register int sum = 0;
RTW_INFO("DHCP: change flag of DHCP request to broadcast.\n");
/* or BROADCAST flag */
dhcph->flags |= htons(BROADCAST_FLAG);
/* recalculate checksum */
sum = ~(udph->check) & 0xffff;
sum += dhcph->flags;
while (sum >> 16)
sum = (sum & 0xffff) + (sum >> 16);
udph->check = ~sum;
}
}
}
}
}
}
}
void *scdb_findEntry(_adapter *priv, unsigned char *macAddr,
unsigned char *ipAddr)
{
unsigned char networkAddr[MAX_NETWORK_ADDR_LEN];
struct nat25_network_db_entry *db;
int hash;
/* _rtw_spinlock_bh(&priv->br_ext_lock); */
__nat25_generate_ipv4_network_addr(networkAddr, (unsigned int *)ipAddr);
hash = __nat25_network_hash(networkAddr);
db = priv->nethash[hash];
while (db != NULL) {
if (!_rtw_memcmp(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN)) {
/* _rtw_spinunlock_bh(&priv->br_ext_lock); */
return (void *)db;
}
db = db->next_hash;
}
/* _rtw_spinunlock_bh(&priv->br_ext_lock); */
return NULL;
}
#endif /* CONFIG_BR_EXT */
|
2301_81045437/rtl8852be
|
core/rtw_br_ext.c
|
C
|
agpl-3.0
| 46,479
|
/******************************************************************************
*
* Copyright(c) 2013 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifdef CONFIG_BTC
#include <drv_types.h>
typedef struct _btcdbginfo {
void* p_msgprn_hdl;
struct submit_ctx btc_dbg_info_sctx;
} BTCDBGINFO, *PBTCDBGINFO;
BTCDBGINFO GLBtcDbgInfo;
#define BTC_INFO_DUMP_TIMEOUT_MS 3000
static void rtw_btc_info_dump_init(_adapter *padapter)
{
GLBtcDbgInfo.p_msgprn_hdl = NULL;
}
static void rtw_btc_info_dump_set(_adapter *padapter, void* p_msgprn_hdl, u32 timeout_ms)
{
GLBtcDbgInfo.p_msgprn_hdl = p_msgprn_hdl;
rtw_sctx_init(&GLBtcDbgInfo.btc_dbg_info_sctx, timeout_ms);
}
static void rtw_btc_info_dump(const char *pmsg)
{
if (GLBtcDbgInfo.p_msgprn_hdl == NULL)
return;
_RTW_PRINT_SEL(GLBtcDbgInfo.p_msgprn_hdl, "%s", pmsg);
}
static int rtw_btc_info_dump_callback(void *priv, enum RTW_PHL_BTC_NOTIFY ntfy, struct rtw_phl_btc_ntfy *info)
{
struct submit_ctx *sctx = &GLBtcDbgInfo.btc_dbg_info_sctx;
rtw_sctx_done(&sctx);
return 0;
}
static int rtw_btc_info_dump_wait(_adapter *padapter)
{
return rtw_sctx_wait(&GLBtcDbgInfo.btc_dbg_info_sctx, __func__);
}
void rtw_btc_disp_btc_info(_adapter *padapter, void* p_msgprn_hdl, u8 info_type)
{
struct rtw_phl_btc_ntfy ntfy = {0};
struct rtw_phl_btc_coex_info_param *pcinfo = &ntfy.u.cinfo;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_phl_btc_ops phl_btc_ops = {rtw_btc_info_dump};
pcinfo->query_type = info_type;
ntfy.notify = PHL_BTC_NTFY_COEX_INFO;
ntfy.ops = &phl_btc_ops;
ntfy.priv = padapter;
ntfy.ntfy_cb = rtw_btc_info_dump_callback;
rtw_btc_info_dump_set(padapter, p_msgprn_hdl, BTC_INFO_DUMP_TIMEOUT_MS);
rtw_phl_btc_notify(dvobj->phl, ntfy.notify, &ntfy);
/* wait here until info dump finishes or timeout expires */
rtw_btc_info_dump_wait(padapter);
rtw_btc_info_dump_init(padapter);
}
void rtw_btc_set_dbg(_adapter *padapter, u32 *pDbgModule)
{
}
u32 rtw_btc_get_dbg(_adapter *padapter, u8 *pStrBuf, u32 bufSize)
{
return 0;
}
#if 0
u16 rtw_btc_btreg_read(_adapter *padapter, u8 type, u16 addr, u32 *data)
{
return 0;
}
u16 rtw_btc_btreg_write(_adapter *padapter, u8 type, u16 addr, u16 val)
{
return _SUCCESS;
}
#endif
#endif /* CONFIG_BTC */
|
2301_81045437/rtl8852be
|
core/rtw_btc.c
|
C
|
agpl-3.0
| 2,769
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_CHPLAN_C_
#include <drv_types.h>
#ifndef USE_RTW_REGD
#define USE_RTW_REGD 0
#endif
#if defined(PHL_FEATURE_NIC)
/*
* some PHL regulation APIs doesn't have pure database query function, even have, still need pointer of phl as context
* here use a global variable to workaround, this is workable for one-driver-one-dev situation
*/
static void *phl_info;
static enum rtw_regd phl_regulation_to_regd(enum REGULATION reg)
{
switch (reg) {
case REGULATION_WW:
return RTW_REGD_WW;
case REGULATION_ETSI:
return RTW_REGD_ETSI;
case REGULATION_FCC:
return RTW_REGD_FCC;
case REGULATION_MKK:
return RTW_REGD_MKK;
case REGULATION_KCC:
return RTW_REGD_KCC;
case REGULATION_NCC:
return RTW_REGD_NCC;
case REGULATION_ACMA:
return RTW_REGD_ACMA;
case REGULATION_NA:
return RTW_REGD_NA;
case REGULATION_IC:
return RTW_REGD_IC;
case REGULATION_CHILE:
return RTW_REGD_CHILE;
case REGULATION_MEX:
return RTW_REGD_MEX;
case REGULATION_MAX:
default:
RTW_WARN("unknown reg:%d\n", reg);
rtw_warn_on(1);
return RTW_REGD_NA;
}
};
static REGULATION_TXPWR_LMT phl_tpo_to_txpwr_lmt(enum TP_OVERWRITE tpo)
{
switch (tpo) {
case TPO_CHILE:
return TXPWR_LMT_CHILE;
case TPO_QATAR:
return TXPWR_LMT_QATAR;
case TPO_UKRAINE:
return TXPWR_LMT_UKRAINE;
case TPO_CN:
return TXPWR_LMT_CN;
case TPO_NA:
return TXPWR_LMT_DEF;
default:
RTW_WARN("unknown tpo:%d\n", tpo);
rtw_warn_on(1);
return TXPWR_LMT_DEF;
}
}
#endif
#if USE_RTW_REGD
#define RTW_DOMAIN_MAP_VER "57"
#define RTW_DOMAIN_MAP_M_VER "h"
#define RTW_COUNTRY_MAP_VER "31"
struct ch_list_t {
u8 *len_ch_attr;
};
#define CLA_2G_12_14_PASSIVE BIT0
#define CLA_5G_B1_PASSIVE BIT0
#define CLA_5G_B2_PASSIVE BIT1
#define CLA_5G_B3_PASSIVE BIT2
#define CLA_5G_B4_PASSIVE BIT3
#define CLA_5G_B2_DFS BIT4
#define CLA_5G_B3_DFS BIT5
#define CLA_5G_B4_DFS BIT6
#define CLA_6G_B1_PASSIVE BIT0
#define CLA_6G_B2_PASSIVE BIT1
#define CLA_6G_B3_PASSIVE BIT2
#define CLA_6G_B4_PASSIVE BIT3
#define CH_LIST_ENT(_len, arg...) \
{.len_ch_attr = (u8[_len + 2]) {_len, ##arg}, }
#define CH_LIST_LEN(_ch_list) (_ch_list.len_ch_attr[0])
#define CH_LIST_CH(_ch_list, _i) (_ch_list.len_ch_attr[_i + 1])
#define CH_LIST_ATTRIB(_ch_list) (_ch_list.len_ch_attr[CH_LIST_LEN(_ch_list) + 1])
enum rtw_chd_2g {
RTW_CHD_2G_INVALID = 0,
RTW_CHD_2G_00,
RTW_CHD_2G_01,
RTW_CHD_2G_02,
RTW_CHD_2G_03,
RTW_CHD_2G_04,
RTW_CHD_2G_05,
RTW_CHD_2G_06,
RTW_CHD_2G_MAX,
RTW_CHD_2G_NULL = RTW_CHD_2G_00,
};
enum rtw_chd_5g {
RTW_CHD_5G_INVALID = 0,
RTW_CHD_5G_00,
RTW_CHD_5G_01,
RTW_CHD_5G_02,
RTW_CHD_5G_03,
RTW_CHD_5G_04,
RTW_CHD_5G_05,
RTW_CHD_5G_06,
RTW_CHD_5G_07,
RTW_CHD_5G_08,
RTW_CHD_5G_09,
RTW_CHD_5G_10,
RTW_CHD_5G_11,
RTW_CHD_5G_12,
RTW_CHD_5G_13,
RTW_CHD_5G_14,
RTW_CHD_5G_15,
RTW_CHD_5G_16,
RTW_CHD_5G_17,
RTW_CHD_5G_18,
RTW_CHD_5G_19,
RTW_CHD_5G_20,
RTW_CHD_5G_21,
RTW_CHD_5G_22,
RTW_CHD_5G_23,
RTW_CHD_5G_24,
RTW_CHD_5G_25,
RTW_CHD_5G_26,
RTW_CHD_5G_27,
RTW_CHD_5G_28,
RTW_CHD_5G_29,
RTW_CHD_5G_30,
RTW_CHD_5G_31,
RTW_CHD_5G_32,
RTW_CHD_5G_33,
RTW_CHD_5G_34,
RTW_CHD_5G_35,
RTW_CHD_5G_36,
RTW_CHD_5G_37,
RTW_CHD_5G_38,
RTW_CHD_5G_39,
RTW_CHD_5G_40,
RTW_CHD_5G_41,
RTW_CHD_5G_42,
RTW_CHD_5G_43,
RTW_CHD_5G_44,
RTW_CHD_5G_45,
RTW_CHD_5G_46,
RTW_CHD_5G_47,
RTW_CHD_5G_48,
RTW_CHD_5G_49,
RTW_CHD_5G_50,
RTW_CHD_5G_51,
RTW_CHD_5G_52,
RTW_CHD_5G_MAX,
RTW_CHD_5G_NULL = RTW_CHD_5G_00,
};
static const struct ch_list_t rtw_channel_def_2g[] = {
/* RTW_CHD_2G_INVALID */ CH_LIST_ENT(0, 0),
/* RTW_CHD_2G_00 */ CH_LIST_ENT(0, 0),
/* RTW_CHD_2G_01 */ CH_LIST_ENT(13, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, CLA_2G_12_14_PASSIVE),
/* RTW_CHD_2G_02 */ CH_LIST_ENT(13, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0),
/* RTW_CHD_2G_03 */ CH_LIST_ENT(11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0),
/* RTW_CHD_2G_04 */ CH_LIST_ENT(14, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0),
/* RTW_CHD_2G_05 */ CH_LIST_ENT(4, 10, 11, 12, 13, 0),
/* RTW_CHD_2G_06 */ CH_LIST_ENT(14, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, CLA_2G_12_14_PASSIVE),
};
#if CONFIG_IEEE80211_BAND_5GHZ
static const struct ch_list_t rtw_channel_def_5g[] = {
/* RTW_CHD_5G_INVALID */ CH_LIST_ENT(0, 0),
/* RTW_CHD_5G_00 */ CH_LIST_ENT(0, 0),
/* RTW_CHD_5G_01 */ CH_LIST_ENT(21, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_02 */ CH_LIST_ENT(19, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_03 */ CH_LIST_ENT(24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_04 */ CH_LIST_ENT(22, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_05 */ CH_LIST_ENT(19, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 149, 153, 157, 161, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_06 */ CH_LIST_ENT(9, 36, 40, 44, 48, 149, 153, 157, 161, 165, 0),
/* RTW_CHD_5G_07 */ CH_LIST_ENT(13, 36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161, 165, CLA_5G_B2_DFS),
/* RTW_CHD_5G_08 */ CH_LIST_ENT(12, 36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161, CLA_5G_B2_DFS),
/* RTW_CHD_5G_09 */ CH_LIST_ENT(5, 149, 153, 157, 161, 165, 0),
/* RTW_CHD_5G_10 */ CH_LIST_ENT(8, 36, 40, 44, 48, 52, 56, 60, 64, CLA_5G_B2_DFS),
/* RTW_CHD_5G_11 */ CH_LIST_ENT(11, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, CLA_5G_B3_DFS),
/* RTW_CHD_5G_12 */ CH_LIST_ENT(16, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_13 */ CH_LIST_ENT(8, 56, 60, 64, 149, 153, 157, 161, 165, CLA_5G_B2_DFS),
/* RTW_CHD_5G_14 */ CH_LIST_ENT(4, 36, 40, 44, 48, 0),
/* RTW_CHD_5G_15 */ CH_LIST_ENT(4, 149, 153, 157, 161, 0),
/* RTW_CHD_5G_16 */ CH_LIST_ENT(11, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 0),
/* RTW_CHD_5G_17 */ CH_LIST_ENT(16, 36, 40, 44, 48, 52, 56, 60, 64, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_18 */ CH_LIST_ENT(17, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_19 */ CH_LIST_ENT(16, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_20 */ CH_LIST_ENT(20, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_21 */ CH_LIST_ENT(11, 36, 40, 44, 48, 52, 56, 60, 64, 132, 136, 140, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_22 */ CH_LIST_ENT(25, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_23 */ CH_LIST_ENT(21, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_24 */ CH_LIST_ENT(24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_25 */ CH_LIST_ENT(24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE),
/* RTW_CHD_5G_26 */ CH_LIST_ENT(24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE),
/* RTW_CHD_5G_27 */ CH_LIST_ENT(21, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE),
/* RTW_CHD_5G_28 */ CH_LIST_ENT(13, 36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161, 165, CLA_5G_B2_PASSIVE),
/* RTW_CHD_5G_29 */ CH_LIST_ENT(13, 36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE),
/* RTW_CHD_5G_30 */ CH_LIST_ENT(9, 36, 40, 44, 48, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_31 */ CH_LIST_ENT(24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_32 */ CH_LIST_ENT(9, 52, 56, 60, 64, 149, 153, 157, 161, 165, CLA_5G_B2_DFS),
/* RTW_CHD_5G_33 */ CH_LIST_ENT(22, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 144, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_34 */ CH_LIST_ENT(13, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B3_DFS),
/* RTW_CHD_5G_35 */ CH_LIST_ENT(8, 100, 104, 108, 112, 116, 132, 136, 140, CLA_5G_B3_DFS),
/* RTW_CHD_5G_36 */ CH_LIST_ENT(25, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE | CLA_5G_B2_DFS | CLA_5G_B3_PASSIVE | CLA_5G_B3_DFS | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_37 */ CH_LIST_ENT(8, 36, 40, 44, 48, 52, 56, 60, 64, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE),
/* RTW_CHD_5G_38 */ CH_LIST_ENT(16, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_39 */ CH_LIST_ENT(21, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_DFS | CLA_5G_B3_DFS | CLA_5G_B4_DFS),
/* RTW_CHD_5G_40 */ CH_LIST_ENT(21, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_41 */ CH_LIST_ENT(24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_42 */ CH_LIST_ENT(24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_DFS | CLA_5G_B3_DFS | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_43 */ CH_LIST_ENT(23, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_44 */ CH_LIST_ENT(21, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 132, 136, 140, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_45 */ CH_LIST_ENT(13, 36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161, 165, CLA_5G_B1_PASSIVE | CLA_5G_B2_PASSIVE | CLA_5G_B4_PASSIVE),
/* RTW_CHD_5G_46 */ CH_LIST_ENT(12, 36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161, CLA_5G_B2_PASSIVE),
/* RTW_CHD_5G_47 */ CH_LIST_ENT(19, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, CLA_5G_B2_PASSIVE | CLA_5G_B3_PASSIVE),
/* RTW_CHD_5G_48 */ CH_LIST_ENT(20, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_49 */ CH_LIST_ENT(17, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_50 */ CH_LIST_ENT(17, 36, 40, 44, 48, 52, 56, 60, 64, 132, 136, 140, 144, 149, 153, 157, 161, 165, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_51 */ CH_LIST_ENT(13, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
/* RTW_CHD_5G_52 */ CH_LIST_ENT(28, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165, 169, 173, 177, CLA_5G_B2_DFS | CLA_5G_B3_DFS),
};
#endif /* CONFIG_IEEE80211_BAND_5GHZ */
struct chplan_ent_t {
u8 regd_2g; /* value of enum rtw_regd */
u8 chd_2g;
#if CONFIG_IEEE80211_BAND_5GHZ
u8 regd_5g; /* value of enum rtw_regd */
u8 chd_5g;
#endif
};
#if CONFIG_IEEE80211_BAND_5GHZ
#define CHPLAN_ENT(_regd_2g, _chd_2g, _regd_5g, _chd_5g) {.regd_2g = RTW_REGD_##_regd_2g, .chd_2g = RTW_CHD_2G_##_chd_2g, .regd_5g = RTW_REGD_##_regd_5g, .chd_5g = RTW_CHD_5G_##_chd_5g}
#else
#define CHPLAN_ENT(_regd_2g, _chd_2g, _regd_5g, _chd_5g) {.regd_2g = RTW_REGD_##_regd_2g, .chd_2g = RTW_CHD_2G_##_chd_2g}
#endif
#define CHPLAN_ENT_NOT_DEFINED CHPLAN_ENT(NA, INVALID, NA, INVALID)
static const struct chplan_ent_t RTW_ChannelPlanMap[] = {
[0x00] = CHPLAN_ENT(ETSI , 02, ETSI , 49),
[0x01] = CHPLAN_ENT(ETSI , 02, ETSI , 50),
[0x02] = CHPLAN_ENT(ETSI , 03, ETSI , 07),
[0x03] = CHPLAN_ENT(ACMA , 02, ACMA , 33),
[0x04] = CHPLAN_ENT(ETSI , 02, ETSI , 51),
[0x05] = CHPLAN_ENT(ETSI , 02, ETSI , 06),
[0x06] = CHPLAN_ENT(ETSI , 02, ETSI , 07),
[0x07] = CHPLAN_ENT(ETSI , 02, ETSI , 23),
[0x08] = CHPLAN_ENT(ETSI , 02, ETSI , 21),
[0x09] = CHPLAN_ENT(ETSI , 02, ETSI , 17),
[0x1A] = CHPLAN_ENT(NA , 00, NA , 00),
[0x1B] = CHPLAN_ENT(FCC , 02, FCC , 52),
[0x20] = CHPLAN_ENT(WW , 01, NA , 00),
[0x21] = CHPLAN_ENT(ETSI , 02, NA , 00),
[0x22] = CHPLAN_ENT(FCC , 03, NA , 00),
[0x23] = CHPLAN_ENT(MKK , 04, NA , 00),
[0x24] = CHPLAN_ENT(ETSI , 05, NA , 00),
[0x25] = CHPLAN_ENT(FCC , 03, FCC , 03),
[0x26] = CHPLAN_ENT(ETSI , 01, ETSI , 02),
[0x27] = CHPLAN_ENT(MKK , 04, MKK , 02),
[0x28] = CHPLAN_ENT(KCC , 01, KCC , 05),
[0x29] = CHPLAN_ENT(FCC , 01, FCC , 06),
[0x2A] = CHPLAN_ENT(FCC , 02, NA , 00),
[0x2B] = CHPLAN_ENT(IC , 02, IC , 33),
[0x2C] = CHPLAN_ENT(MKK , 02, NA , 00),
[0x2D] = CHPLAN_ENT(CHILE, 01, CHILE, 22),
[0x2E] = CHPLAN_ENT(WW , 03, WW , 37),
[0x2F] = CHPLAN_ENT(CHILE, 01, CHILE, 38),
[0x30] = CHPLAN_ENT(FCC , 01, FCC , 07),
[0x31] = CHPLAN_ENT(FCC , 01, FCC , 08),
[0x32] = CHPLAN_ENT(FCC , 01, FCC , 09),
[0x33] = CHPLAN_ENT(FCC , 01, FCC , 10),
[0x34] = CHPLAN_ENT(FCC , 03, FCC , 01),
[0x35] = CHPLAN_ENT(ETSI , 01, ETSI , 03),
[0x36] = CHPLAN_ENT(ETSI , 01, ETSI , 04),
[0x37] = CHPLAN_ENT(MKK , 04, MKK , 10),
[0x38] = CHPLAN_ENT(MKK , 04, MKK , 11),
[0x39] = CHPLAN_ENT(NCC , 03, NCC , 12),
[0x3A] = CHPLAN_ENT(ETSI , 02, ETSI , 02),
[0x3B] = CHPLAN_ENT(ACMA , 02, ACMA , 01),
[0x3C] = CHPLAN_ENT(ETSI , 02, ETSI , 10),
[0x3D] = CHPLAN_ENT(ETSI , 02, ETSI , 15),
[0x3E] = CHPLAN_ENT(KCC , 02, KCC , 03),
[0x3F] = CHPLAN_ENT(FCC , 03, FCC , 22),
[0x40] = CHPLAN_ENT(NCC , 03, NCC , 13),
[0x41] = CHPLAN_ENT(WW , 06, NA , 00),
[0x42] = CHPLAN_ENT(ETSI , 02, ETSI , 14),
[0x43] = CHPLAN_ENT(FCC , 03, FCC , 06),
[0x44] = CHPLAN_ENT(NCC , 03, NCC , 09),
[0x45] = CHPLAN_ENT(ACMA , 01, ACMA , 01),
[0x46] = CHPLAN_ENT(FCC , 03, FCC , 15),
[0x47] = CHPLAN_ENT(ETSI , 01, ETSI , 10),
[0x48] = CHPLAN_ENT(ETSI , 01, ETSI , 07),
[0x49] = CHPLAN_ENT(ETSI , 01, ETSI , 06),
[0x4A] = CHPLAN_ENT(IC , 03, IC , 33),
[0x4B] = CHPLAN_ENT(KCC , 02, KCC , 22),
[0x4C] = CHPLAN_ENT(FCC , 03, FCC , 28),
[0x4D] = CHPLAN_ENT(MEX , 02, MEX , 01),
[0x4E] = CHPLAN_ENT(ETSI , 02, ETSI , 42),
[0x4F] = CHPLAN_ENT(NA , 00, MKK , 43),
[0x50] = CHPLAN_ENT(ETSI , 01, ETSI , 16),
[0x51] = CHPLAN_ENT(ETSI , 01, ETSI , 09),
[0x52] = CHPLAN_ENT(ETSI , 01, ETSI , 17),
[0x53] = CHPLAN_ENT(NCC , 03, NCC , 18),
[0x54] = CHPLAN_ENT(ETSI , 01, ETSI , 15),
[0x55] = CHPLAN_ENT(FCC , 03, FCC , 01),
[0x56] = CHPLAN_ENT(ETSI , 01, ETSI , 19),
[0x57] = CHPLAN_ENT(FCC , 03, FCC , 20),
[0x58] = CHPLAN_ENT(MKK , 02, MKK , 14),
[0x59] = CHPLAN_ENT(ETSI , 01, ETSI , 21),
[0x5A] = CHPLAN_ENT(NA , 00, FCC , 44),
[0x5B] = CHPLAN_ENT(NA , 00, FCC , 45),
[0x5C] = CHPLAN_ENT(NA , 00, FCC , 43),
[0x5D] = CHPLAN_ENT(ETSI , 02, ETSI , 08),
[0x5E] = CHPLAN_ENT(ETSI , 02, ETSI , 03),
[0x5F] = CHPLAN_ENT(MKK , 02, MKK , 47),
[0x60] = CHPLAN_ENT(FCC , 03, FCC , 09),
[0x61] = CHPLAN_ENT(FCC , 02, FCC , 01),
[0x62] = CHPLAN_ENT(FCC , 02, FCC , 03),
[0x63] = CHPLAN_ENT(ETSI , 01, ETSI , 23),
[0x64] = CHPLAN_ENT(MKK , 02, MKK , 24),
[0x65] = CHPLAN_ENT(ETSI , 02, ETSI , 24),
[0x66] = CHPLAN_ENT(FCC , 03, FCC , 27),
[0x67] = CHPLAN_ENT(FCC , 03, FCC , 25),
[0x68] = CHPLAN_ENT(FCC , 02, FCC , 27),
[0x69] = CHPLAN_ENT(FCC , 02, FCC , 25),
[0x6A] = CHPLAN_ENT(ETSI , 02, ETSI , 25),
[0x6B] = CHPLAN_ENT(FCC , 01, FCC , 29),
[0x6C] = CHPLAN_ENT(FCC , 01, FCC , 26),
[0x6D] = CHPLAN_ENT(FCC , 02, FCC , 28),
[0x6E] = CHPLAN_ENT(FCC , 01, FCC , 25),
[0x6F] = CHPLAN_ENT(NA , 00, ETSI , 06),
[0x70] = CHPLAN_ENT(NA , 00, ETSI , 30),
[0x71] = CHPLAN_ENT(NA , 00, ETSI , 25),
[0x72] = CHPLAN_ENT(NA , 00, ETSI , 31),
[0x73] = CHPLAN_ENT(FCC , 01, FCC , 01),
[0x74] = CHPLAN_ENT(FCC , 02, FCC , 19),
[0x75] = CHPLAN_ENT(ETSI , 01, ETSI , 32),
[0x76] = CHPLAN_ENT(FCC , 02, FCC , 22),
[0x77] = CHPLAN_ENT(ETSI , 01, ETSI , 34),
[0x78] = CHPLAN_ENT(FCC , 03, FCC , 35),
[0x79] = CHPLAN_ENT(MKK , 02, MKK , 02),
[0x7A] = CHPLAN_ENT(ETSI , 02, ETSI , 28),
[0x7B] = CHPLAN_ENT(ETSI , 02, ETSI , 46),
[0x7C] = CHPLAN_ENT(ETSI , 02, ETSI , 47),
[0x7D] = CHPLAN_ENT(MKK , 04, MKK , 48),
[0x7E] = CHPLAN_ENT(MKK , 02, MKK , 48),
[0x7F] = CHPLAN_ENT(WW , 01, WW , 36),
};
const int RTW_ChannelPlanMap_size = sizeof(RTW_ChannelPlanMap) / sizeof(RTW_ChannelPlanMap[0]);
#endif /* USE_RTW_REGD */
u8 rtw_chplan_get_default_regd_2g(u8 id)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
return phl_regulation_to_regd(rtw_phl_get_domain_regulation_2g(id));
#else
if (id < RTW_ChannelPlanMap_size)
return RTW_ChannelPlanMap[id].regd_2g;
return RTW_REGD_NA;
#endif
}
u8 rtw_chplan_get_default_regd_5g(u8 id)
{
#if CONFIG_IEEE80211_BAND_5GHZ
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
return phl_regulation_to_regd(rtw_phl_get_domain_regulation_5g(id));
#else
if (id < RTW_ChannelPlanMap_size)
return RTW_ChannelPlanMap[id].regd_5g;
#endif
#endif
return RTW_REGD_NA;
}
bool rtw_is_channel_plan_valid(u8 id)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
if (rtw_phl_valid_regulation_domain(id))
return _TRUE;
else
return _FALSE;
#else
if (id < RTW_ChannelPlanMap_size) {
const struct chplan_ent_t *chplan_map = &RTW_ChannelPlanMap[id];
if (chplan_map->chd_2g != RTW_CHD_2G_INVALID
#if CONFIG_IEEE80211_BAND_5GHZ
&& chplan_map->chd_5g != RTW_CHD_5G_INVALID
#endif
)
return _TRUE;
}
return _FALSE;
#endif
}
bool rtw_regsty_is_excl_chs(struct registry_priv *regsty, u8 ch)
{
int i;
for (i = 0; i < MAX_CHANNEL_NUM_2G_5G; i++) {
if (regsty->excl_chs[i] == 0)
break;
if (regsty->excl_chs[i] == ch)
return _TRUE;
}
return _FALSE;
}
/*
* Search the @param ch in chplan by given @param id
* @id: the given channel plan id
* @ch: the given channel number
*
* return the index of channel_num in channel_set, -1 if not found
*/
static bool rtw_chplan_get_ch(u8 id, const u32 ch, u8 *flags)
{
u8 index, chan, attrib;
if (flags)
*flags = 0;
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
if (phl_info) {
struct rtw_regulation_chplan plan;
/* this function check for capability inside */
if (rtw_phl_query_specific_chplan(phl_info, id, &plan)) {
for (index = 0; index < plan.cnt; index++) {
if (plan.ch[index].band != BAND_ON_24G && plan.ch[index].band != BAND_ON_5G)
continue;
if (plan.ch[index].channel != ch)
continue;
if (flags) {
if (plan.ch[index].property & CH_PASSIVE)
*flags |= RTW_CHF_NO_IR;
if (plan.ch[index].property & CH_DFS)
*flags |= RTW_CHF_DFS;
}
return 1;
}
}
}
#else
#if CONFIG_IEEE80211_BAND_5GHZ
if (ch > 14) {
u8 chd_5g = RTW_ChannelPlanMap[id].chd_5g;
attrib = CH_LIST_ATTRIB(rtw_channel_def_5g[chd_5g]);
for (index = 0; index < CH_LIST_LEN(rtw_channel_def_5g[chd_5g]); index++) {
if (CH_LIST_CH(rtw_channel_def_5g[chd_5g], index) == ch) {
if (flags) {
if ((rtw_is_5g_band1(ch) && (attrib & CLA_5G_B1_PASSIVE)) /* band1 passive */
|| (rtw_is_5g_band2(ch) && (attrib & CLA_5G_B2_PASSIVE)) /* band2 passive */
|| (rtw_is_5g_band3(ch) && (attrib & CLA_5G_B3_PASSIVE)) /* band3 passive */
|| (rtw_is_5g_band4(ch) && (attrib & CLA_5G_B4_PASSIVE)) /* band4 passive */
)
*flags |= RTW_CHF_NO_IR;
if ((rtw_is_5g_band2(ch) && (attrib & CLA_5G_B2_DFS))
|| (rtw_is_5g_band3(ch) && (attrib & CLA_5G_B3_DFS))
|| (rtw_is_5g_band4(ch) && (attrib & CLA_5G_B4_DFS)))
*flags |= RTW_CHF_DFS;
}
return 1;
}
}
} else
#endif /* CONFIG_IEEE80211_BAND_5GHZ */
{
u8 chd_2g = RTW_ChannelPlanMap[id].chd_2g;
attrib = CH_LIST_ATTRIB(rtw_channel_def_2g[chd_2g]);
for (index = 0; index < CH_LIST_LEN(rtw_channel_def_2g[chd_2g]); index++) {
if (CH_LIST_CH(rtw_channel_def_2g[chd_2g], index) == ch) {
if (flags) {
if (ch >= 12 && ch <= 14 && (attrib & CLA_2G_12_14_PASSIVE))
*flags |= RTW_CHF_NO_IR;
}
return 1;
}
}
}
#endif /* defined(PHL_FEATURE_NIC) && !USE_RTW_REGD */
return 0;
}
#if CONFIG_IEEE80211_BAND_6GHZ
#if USE_RTW_REGD
enum rtw_chd_6g {
RTW_CHD_6G_INVALID = 0,
RTW_CHD_6G_00,
RTW_CHD_6G_01,
RTW_CHD_6G_02,
RTW_CHD_6G_03,
RTW_CHD_6G_04,
RTW_CHD_6G_05, /* 6G Worldwide */
RTW_CHD_6G_MAX,
RTW_CHD_6G_NULL = RTW_CHD_6G_00,
};
static const struct ch_list_t rtw_channel_def_6g[] = {
/* RTW_CHD_6G_INVALID */ CH_LIST_ENT(0, 0),
/* RTW_CHD_6G_00 */ CH_LIST_ENT(0, 0),
/* RTW_CHD_6G_01 */ CH_LIST_ENT(24, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 0),
/* RTW_CHD_6G_02 */ CH_LIST_ENT(6, 97, 101, 105, 109, 113, 117, 0),
/* RTW_CHD_6G_03 */ CH_LIST_ENT(18, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 169, 173, 177, 181, 185, 189, 0),
/* RTW_CHD_6G_04 */ CH_LIST_ENT(11, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 233, 0),
/* RTW_CHD_6G_05 */ CH_LIST_ENT(59, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 169, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 233, CLA_6G_B1_PASSIVE | CLA_6G_B2_PASSIVE | CLA_6G_B3_PASSIVE | CLA_6G_B4_PASSIVE),
};
struct chplan_6g_ent_t {
u8 regd; /* value of enum rtw_regd */
u8 chd;
};
#define CHPLAN_6G_ENT(_regd, _chd) {.regd = RTW_REGD_##_regd, .chd = RTW_CHD_6G_##_chd}
#define CHPLAN_6G_ENT_NOT_DEFINED CHPLAN_6G_ENT(NA, INVALID)
static const struct chplan_6g_ent_t rtw_chplan_6g_map[] = {
[0x00] = CHPLAN_6G_ENT(NA , 00),
[0x01] = CHPLAN_6G_ENT(FCC , 01),
[0x02] = CHPLAN_6G_ENT(FCC , 02),
[0x03] = CHPLAN_6G_ENT(FCC , 03),
[0x04] = CHPLAN_6G_ENT(FCC , 04),
[0x7F] = CHPLAN_6G_ENT(WW , 05),
};
const int rtw_chplan_6g_map_size = sizeof(rtw_chplan_6g_map) / sizeof(rtw_chplan_6g_map[0]);
#endif /* USE_RTW_REGD */
u8 rtw_chplan_get_default_regd_6g(u8 id)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
/* wait PHL ready */
return RTW_REGD_NA;
#else
if (id < rtw_chplan_6g_map_size)
return rtw_chplan_6g_map[id].regd;
return RTW_REGD_NA;
#endif
}
bool rtw_is_channel_plan_6g_valid(u8 id)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
/* TODO: wait PHL ready */
return _FALSE;
#else
if (id < rtw_chplan_6g_map_size) {
const struct chplan_6g_ent_t *chplan_map = &rtw_chplan_6g_map[id];
if (chplan_map->chd != RTW_CHD_6G_INVALID)
return _TRUE;
}
return _FALSE;
#endif
}
bool rtw_regsty_is_excl_chs_6g(struct registry_priv *regsty, u8 ch)
{
int i;
for (i = 0; i < MAX_CHANNEL_NUM_6G; i++) {
if (regsty->excl_chs_6g[i] == 0)
break;
if (regsty->excl_chs_6g[i] == ch)
return _TRUE;
}
return _FALSE;
}
/*
* Search the @param ch in chplan by given @param id
* @id: the given channel plan id
* @ch: the given channel number
*
* return the index of channel_num in channel_set, -1 if not found
*/
static bool rtw_chplan_6g_get_ch(u8 id, const u32 ch, u8 *flags)
{
u8 index, chan, attrib;
u8 chd_6g;
if (flags)
*flags = 0;
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
if (phl_info) {
/* Wait PHL ready */
}
#else
chd_6g = rtw_chplan_6g_map[id].chd;
attrib = CH_LIST_ATTRIB(rtw_channel_def_6g[chd_6g]);
for (index = 0; index < CH_LIST_LEN(rtw_channel_def_6g[chd_6g]); index++) {
if (CH_LIST_CH(rtw_channel_def_6g[chd_6g], index) == ch) {
if (flags) {
if ((rtw_is_6g_band1(ch) && (attrib & CLA_6G_B1_PASSIVE)) /* band1 passive */
|| (rtw_is_6g_band2(ch) && (attrib & CLA_6G_B2_PASSIVE)) /* band2 passive */
|| (rtw_is_6g_band3(ch) && (attrib & CLA_6G_B3_PASSIVE)) /* band3 passive */
|| (rtw_is_6g_band4(ch) && (attrib & CLA_6G_B4_PASSIVE)) /* band4 passive */
)
*flags |= RTW_CHF_NO_IR;
}
return 1;
}
}
#endif
return 0;
}
#endif /* CONFIG_IEEE80211_BAND_6GHZ */
/*
* Check if the @param ch, bw, offset is valid for the given @param id, id_6g
* @ch_set: the given channel set
* @ch: the given channel number
* @bw: the given bandwidth
* @offset: the given channel offset
*
* return valid (1) or not (0)
*/
u8 rtw_chplan_is_chbw_valid(u8 id, u8 id_6g, enum band_type band, u8 ch, u8 bw, u8 offset
, bool allow_primary_passive, bool allow_passive, struct registry_priv *regsty)
{
u8 cch;
u8 *op_chs;
u8 op_ch_num;
u8 op_ch;
u8 valid = 0;
int i;
int ch_idx;
u8 flags;
#if CONFIG_IEEE80211_BAND_6GHZ
if (band == BAND_ON_6G)
goto exit;
#endif
cch = rtw_get_center_ch(ch, bw, offset); /* TODO: 6G */
if (!rtw_get_op_chs_by_cch_bw(cch, bw, &op_chs, &op_ch_num)) /* TODO: 6G */
goto exit;
for (i = 0; i < op_ch_num; i++) {
op_ch = *(op_chs + i);
if (0)
RTW_INFO("%u,%u,%u - cch:%u, bw:%u, op_ch:%u\n", ch, bw, offset, cch, bw, op_ch);
#if CONFIG_IEEE80211_BAND_6GHZ
if (band == BAND_ON_6G) {
if (!rtw_chplan_6g_get_ch(id_6g, op_ch, &flags)
|| (regsty && rtw_regsty_is_excl_chs_6g(regsty, op_ch) == _TRUE))
break;
} else
#endif
{
if (!rtw_chplan_get_ch(id, op_ch, &flags)
|| (regsty && rtw_regsty_is_excl_chs(regsty, op_ch) == _TRUE))
break;
}
if (flags & RTW_CHF_NO_IR) {
if (!allow_passive
|| (!allow_primary_passive && op_ch == ch))
break;
}
}
if (op_ch_num != 0 && i == op_ch_num)
valid = 1;
exit:
return valid;
}
const char *_regd_src_str[] = {
[REGD_SRC_RTK_PRIV] = "RTK_PRIV",
[REGD_SRC_OS] = "OS",
[REGD_SRC_NUM] = "UNKNOWN",
};
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
static u8 init_channel_set_from_rtk_priv(_adapter *adapter, RT_CHANNEL_INFO *channel_set)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct registry_priv *regsty = adapter_to_regsty(adapter);
u8 ChannelPlan = rfctl->ChannelPlan;
struct rtw_regulation_chplan plan = {0};
u8 index, chanset_size = 0;
int i = 0;
_rtw_memset(channel_set, 0, sizeof(RT_CHANNEL_INFO) * MAX_CHANNEL_NUM);
/* Set and query channel plan from PHL*/
if (IS_ALPHA2_WORLDWIDE(rfctl->alpha2) || IS_ALPHA2_UNSPEC(rfctl->alpha2)) {
if (rtw_phl_regulation_set_domain(GET_PHL_INFO(dvobj), rfctl->ChannelPlan, REGU_RSN_DEFAULT) != true) {
RTW_WARN("rtw_phl_regulation_set_domain() != true\n");
goto exit;
}
#if CONFIG_IEEE80211_BAND_6GHZ && 0 /* Wait PHL ready */
/* set 6g domain code */
#endif
} else {
if (rtw_phl_regulation_set_country(GET_PHL_INFO(dvobj), rfctl->alpha2, REGU_RSN_DEFAULT) != true) {
RTW_WARN("rtw_phl_regulation_set_country() != true\n");
goto exit;
}
}
if (rtw_phl_regulation_query_chplan(GET_PHL_INFO(dvobj), REGULQ_CHPLAN_FULL, NULL, &plan) != true) {
RTW_WARN("rtw_phl_regulation_query_chplan() return false\n");
goto exit;
}
for (i = 0; i < plan.cnt; i++) {
if (rtw_regsty_is_excl_chs(regsty, plan.ch[i].channel) == _TRUE)
continue;
if (plan.ch[i].property & CH_DFS) {
#if CONFIG_DFS
channel_set[chanset_size].flags |= RTW_CHF_DFS;
#else
continue;
#endif
}
channel_set[chanset_size].band = plan.ch[i].band;
channel_set[chanset_size].ChannelNum = plan.ch[i].channel;
if (plan.ch[i].property & CH_PASSIVE)
channel_set[chanset_size].flags |= RTW_CHF_NO_IR;
if (channel_set[chanset_size].flags & RTW_CHF_NO_IR) {
if (!rtw_rfctl_reg_allow_beacon_hint(rfctl) || !rtw_chinfo_allow_beacon_hint(&channel_set[chanset_size]))
RTW_INFO("band:%s ch%u is NO_IR%s while beacon hint not allowed\n"
, band_str(plan.ch[i].band), plan.ch[i].channel, plan.ch[i].property & CH_DFS ? " DFS" : "");
}
chanset_size++;
}
#ifdef CONFIG_DFS_MASTER
for (i = 0; i < chanset_size; i++)
channel_set[i].non_ocp_end_time = rtw_get_current_time();
#endif
exit:
if (chanset_size)
RTW_INFO(FUNC_ADPT_FMT" ch num:%d\n", FUNC_ADPT_ARG(adapter), chanset_size);
else
RTW_WARN(FUNC_ADPT_FMT" final chset has no channel\n", FUNC_ADPT_ARG(adapter));
return chanset_size;
}
#else
static u8 init_channel_set_from_rtk_priv_2g_5g(_adapter *adapter, RT_CHANNEL_INFO *channel_set, u8 *ch_num)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct registry_priv *regsty = adapter_to_regsty(adapter);
u8 chplan = rfctl->ChannelPlan;
u8 index, chanset_size = *ch_num;
u8 b5GBand = _FALSE, b2_4GBand = _FALSE;
u8 ch, attrib;
if (!rtw_is_channel_plan_valid(chplan)) {
RTW_ERR(FUNC_ADPT_FMT" invalid chplan:0x%02X\n", FUNC_ADPT_ARG(adapter), chplan);
goto exit;
}
RTW_INFO(FUNC_ADPT_FMT" chplan:0x%02X\n", FUNC_ADPT_ARG(adapter), chplan);
if (is_supported_24g(regsty->band_type) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_2G))
b2_4GBand = _TRUE;
if (is_supported_5g(regsty->band_type) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_5G))
b5GBand = _TRUE;
if (b2_4GBand) {
u8 chd_2g = RTW_ChannelPlanMap[chplan].chd_2g;
attrib = CH_LIST_ATTRIB(rtw_channel_def_2g[chd_2g]);
for (index = 0; index < CH_LIST_LEN(rtw_channel_def_2g[chd_2g]); index++) {
ch = CH_LIST_CH(rtw_channel_def_2g[chd_2g], index);
if (rtw_regsty_is_excl_chs(regsty, ch) == _TRUE)
continue;
if (chanset_size >= MAX_CHANNEL_NUM) {
RTW_WARN("chset size can't exceed MAX_CHANNEL_NUM(%u)\n", MAX_CHANNEL_NUM);
break;
}
channel_set[chanset_size].band = BAND_ON_24G;
channel_set[chanset_size].ChannelNum = ch;
if (ch >= 12 && ch <= 14 && (attrib & CLA_2G_12_14_PASSIVE))
channel_set[chanset_size].flags |= RTW_CHF_NO_IR;
if (channel_set[chanset_size].flags & RTW_CHF_NO_IR) {
if (!rtw_rfctl_reg_allow_beacon_hint(rfctl) || !rtw_chinfo_allow_beacon_hint(&channel_set[chanset_size]))
RTW_INFO("band:%s ch%u is NO_IR while beacon hint not allowed\n", band_str(BAND_ON_24G), ch);
}
chanset_size++;
}
}
#if CONFIG_IEEE80211_BAND_5GHZ
if (b5GBand) {
bool dfs;
u8 chd_5g = RTW_ChannelPlanMap[chplan].chd_5g;
attrib = CH_LIST_ATTRIB(rtw_channel_def_5g[chd_5g]);
for (index = 0; index < CH_LIST_LEN(rtw_channel_def_5g[chd_5g]); index++) {
ch = CH_LIST_CH(rtw_channel_def_5g[chd_5g], index);
if (rtw_regsty_is_excl_chs(regsty, ch) == _TRUE)
continue;
dfs = (rtw_is_5g_band2(ch) && (attrib & CLA_5G_B2_DFS))
|| (rtw_is_5g_band3(ch) && (attrib & CLA_5G_B3_DFS))
|| (rtw_is_5g_band4(ch) && (attrib & CLA_5G_B4_DFS));
#if !CONFIG_DFS
if (dfs)
continue;
#endif
if (chanset_size >= MAX_CHANNEL_NUM) {
RTW_WARN("chset size can't exceed MAX_CHANNEL_NUM(%u)\n", MAX_CHANNEL_NUM);
break;
}
channel_set[chanset_size].band = BAND_ON_5G;
channel_set[chanset_size].ChannelNum = ch;
if ((rtw_is_5g_band1(ch) && (attrib & CLA_5G_B1_PASSIVE)) /* band1 passive */
|| (rtw_is_5g_band2(ch) && (attrib & CLA_5G_B2_PASSIVE)) /* band2 passive */
|| (rtw_is_5g_band3(ch) && (attrib & CLA_5G_B3_PASSIVE)) /* band3 passive */
|| (rtw_is_5g_band4(ch) && (attrib & CLA_5G_B4_PASSIVE)) /* band4 passive */
)
channel_set[chanset_size].flags |= RTW_CHF_NO_IR;
if (dfs)
channel_set[chanset_size].flags |= RTW_CHF_DFS;
if (channel_set[chanset_size].flags & RTW_CHF_NO_IR) {
if (!rtw_rfctl_reg_allow_beacon_hint(rfctl) || !rtw_chinfo_allow_beacon_hint(&channel_set[chanset_size]))
RTW_INFO("band:%s ch%u is NO_IR%s while beacon hint not allowed\n", band_str(BAND_ON_5G), ch, dfs ? " DFS" : "");
}
chanset_size++;
}
}
#endif /* CONFIG_IEEE80211_BAND_5GHZ */
exit:
*ch_num = chanset_size;
return chanset_size;
}
#if CONFIG_IEEE80211_BAND_6GHZ
static u8 init_channel_set_from_rtk_priv_6g(_adapter *adapter, RT_CHANNEL_INFO *channel_set, u8 *ch_num)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct registry_priv *regsty = adapter_to_regsty(adapter);
u8 chplan_6g = rfctl->chplan_6g;
u8 index, chanset_size = *ch_num;
bool band_6g = _FALSE;
u8 chd_6g;
u8 ch, attrib;
if (!rtw_is_channel_plan_6g_valid(chplan_6g)) {
RTW_ERR(FUNC_ADPT_FMT" invalid chplan_6g:0x%02X\n", FUNC_ADPT_ARG(adapter), chplan_6g);
goto exit;
}
RTW_INFO(FUNC_ADPT_FMT" chplan_6g:0x%02X\n", FUNC_ADPT_ARG(adapter), chplan_6g);
if (is_supported_6g(regsty->band_type) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_6G))
band_6g = _TRUE;
if (!band_6g)
goto exit;
chd_6g = rtw_chplan_6g_map[chplan_6g].chd;
attrib = CH_LIST_ATTRIB(rtw_channel_def_6g[chd_6g]);
for (index = 0; index < CH_LIST_LEN(rtw_channel_def_6g[chd_6g]); index++) {
ch = CH_LIST_CH(rtw_channel_def_6g[chd_6g], index);
if (rtw_regsty_is_excl_chs_6g(regsty, ch) == _TRUE)
continue;
if (chanset_size >= MAX_CHANNEL_NUM) {
RTW_WARN("chset size can't exceed MAX_CHANNEL_NUM(%u)\n", MAX_CHANNEL_NUM);
break;
}
channel_set[chanset_size].band = BAND_ON_6G;
channel_set[chanset_size].ChannelNum = ch;
if ((rtw_is_6g_band1(ch) && (attrib & CLA_6G_B1_PASSIVE)) /* band1 passive */
|| (rtw_is_6g_band2(ch) && (attrib & CLA_6G_B2_PASSIVE)) /* band2 passive */
|| (rtw_is_6g_band3(ch) && (attrib & CLA_6G_B3_PASSIVE)) /* band3 passive */
|| (rtw_is_6g_band4(ch) && (attrib & CLA_6G_B4_PASSIVE)) /* band4 passive */
)
channel_set[chanset_size].flags |= RTW_CHF_NO_IR;
chanset_size++;
}
exit:
*ch_num = chanset_size;
return chanset_size;
}
#endif /* CONFIG_IEEE80211_BAND_6GHZ */
static u8 init_channel_set_from_rtk_priv(_adapter *adapter, RT_CHANNEL_INFO *channel_set)
{
u8 chanset_size = 0;
#ifdef CONFIG_DFS_MASTER
int i;
#endif
_rtw_memset(channel_set, 0, sizeof(RT_CHANNEL_INFO) * MAX_CHANNEL_NUM);
init_channel_set_from_rtk_priv_2g_5g(adapter, channel_set, &chanset_size);
#if CONFIG_IEEE80211_BAND_6GHZ
init_channel_set_from_rtk_priv_6g(adapter, channel_set, &chanset_size);
#endif
#ifdef CONFIG_DFS_MASTER
for (i = 0; i < chanset_size; i++)
channel_set[i].non_ocp_end_time = rtw_get_current_time();
#endif
if (chanset_size)
RTW_INFO(FUNC_ADPT_FMT" ch num:%d\n", FUNC_ADPT_ARG(adapter), chanset_size);
else
RTW_WARN(FUNC_ADPT_FMT" final chset has no channel\n", FUNC_ADPT_ARG(adapter));
return chanset_size;
}
#endif /* defined(PHL_FEATURE_NIC) && !USE_RTW_REGD */
u8 init_channel_set(_adapter *adapter)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
if (rfctl->regd_src == REGD_SRC_RTK_PRIV)
rfctl->max_chan_nums = init_channel_set_from_rtk_priv(adapter, rfctl->channel_set);
#ifdef CONFIG_REGD_SRC_FROM_OS
else if (rfctl->regd_src == REGD_SRC_OS)
rfctl->max_chan_nums = rtw_os_init_channel_set(adapter, rfctl->channel_set);
#endif
else {
rfctl->max_chan_nums = 0;
rtw_warn_on(1);
}
return rfctl->max_chan_nums;
}
bool rtw_chset_is_dfs_range(struct _RT_CHANNEL_INFO *chset, u32 hi, u32 lo)
{
u8 hi_ch = rtw_freq2ch(hi);
u8 lo_ch = rtw_freq2ch(lo);
int i;
for (i = 0; i < MAX_CHANNEL_NUM && chset[i].ChannelNum != 0; i++){
if (!(chset[i].flags & RTW_CHF_DFS))
continue;
if (hi_ch > chset[i].ChannelNum && lo_ch < chset[i].ChannelNum)
return 1;
}
return 0;
}
bool rtw_chset_is_dfs_ch(struct _RT_CHANNEL_INFO *chset, u8 ch)
{
int i;
for (i = 0; i < MAX_CHANNEL_NUM && chset[i].ChannelNum != 0; i++){
if (chset[i].ChannelNum == ch)
return chset[i].flags & RTW_CHF_DFS ? 1 : 0;
}
return 0;
}
bool rtw_chset_is_dfs_chbw(struct _RT_CHANNEL_INFO *chset, u8 ch, u8 bw, u8 offset)
{
u32 hi, lo;
if (!rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo))
return 0;
return rtw_chset_is_dfs_range(chset, hi, lo);
}
/* channel specific beacon hint rules */
#ifndef RTW_CHPLAN_BEACON_HINT_ON_2G_CH_1_11
#define RTW_CHPLAN_BEACON_HINT_ON_2G_CH_1_11 0
#endif
#ifndef RTW_CHPLAN_BEACON_HINT_ON_DFS_CH
#define RTW_CHPLAN_BEACON_HINT_ON_DFS_CH 0
#endif
bool rtw_chinfo_allow_beacon_hint(struct _RT_CHANNEL_INFO *chinfo)
{
return (RTW_CHPLAN_BEACON_HINT_ON_2G_CH_1_11 || !(chinfo->band == BAND_ON_24G && chinfo->ChannelNum <= 11))
&& (RTW_CHPLAN_BEACON_HINT_ON_DFS_CH || !(chinfo->flags & RTW_CHF_DFS));
}
u8 rtw_process_beacon_hint(_adapter *adapter, WLAN_BSSID_EX *bss)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
RT_CHANNEL_INFO *chset = rfctl->channel_set;
u8 ch = bss->Configuration.DSConfig;
int chset_idx = rtw_chset_search_ch(chset, ch);
RT_CHANNEL_INFO *chinfo;
u8 act_cnt = 0;
if (chset_idx < 0)
goto exit;
chinfo = &chset[chset_idx];
if ((chinfo->flags & RTW_CHF_NO_IR)
&& rtw_rfctl_reg_allow_beacon_hint(rfctl)
&& rtw_chinfo_allow_beacon_hint(chinfo)
) {
RTW_INFO("%s: change band:%s ch:%d to active\n", __func__, band_str(chinfo->band), ch);
chinfo->flags &= ~RTW_CHF_NO_IR;
act_cnt++;
}
exit:
return act_cnt;
}
const char *const _regd_inr_str[] = {
[RTW_REGD_SET_BY_INIT] = "INIT",
[RTW_REGD_SET_BY_USER] = "USER",
[RTW_REGD_SET_BY_COUNTRY_IE] = "COUNTRY_IE",
[RTW_REGD_SET_BY_DRIVER] = "DRIVER",
[RTW_REGD_SET_BY_CORE] = "CORE",
[RTW_REGD_SET_BY_NUM] = "UNKNOWN",
};
const char *const _regd_str[] = {
[RTW_REGD_NA] = "NA",
[RTW_REGD_FCC] = "FCC",
[RTW_REGD_MKK] = "MKK",
[RTW_REGD_ETSI] = "ETSI",
[RTW_REGD_IC] = "IC",
[RTW_REGD_KCC] = "KCC",
[RTW_REGD_NCC] = "NCC",
[RTW_REGD_ACMA] = "ACMA",
[RTW_REGD_CHILE] = "CHILE",
[RTW_REGD_MEX] = "MEX",
[RTW_REGD_WW] = "WW",
};
const char *const _rtw_edcca_mode_str[] = {
[RTW_EDCCA_NORM] = "NORMAL",
[RTW_EDCCA_ADAPT] = "ADAPT",
[RTW_EDCCA_CS] = "CS",
};
const char *const _rtw_dfs_regd_str[] = {
[RTW_DFS_REGD_NONE] = "NONE",
[RTW_DFS_REGD_FCC] = "FCC",
[RTW_DFS_REGD_MKK] = "MKK",
[RTW_DFS_REGD_ETSI] = "ETSI",
};
const char *const _txpwr_lmt_str[] = {
[TXPWR_LMT_NONE] = "NONE",
[TXPWR_LMT_FCC] = "FCC",
[TXPWR_LMT_MKK] = "MKK",
[TXPWR_LMT_ETSI] = "ETSI",
[TXPWR_LMT_IC] = "IC",
[TXPWR_LMT_KCC] = "KCC",
[TXPWR_LMT_NCC] = "NCC",
[TXPWR_LMT_ACMA] = "ACMA",
[TXPWR_LMT_CHILE] = "CHILE",
[TXPWR_LMT_UKRAINE] = "UKRAINE",
[TXPWR_LMT_MEXICO] = "MEXICO",
[TXPWR_LMT_CN] = "CN",
[TXPWR_LMT_QATAR] = "QATAR",
[TXPWR_LMT_WW] = "WW",
[TXPWR_LMT_NUM] = NULL,
};
const REGULATION_TXPWR_LMT _txpwr_lmt_alternate[] = {
[TXPWR_LMT_NONE] = TXPWR_LMT_NONE,
[TXPWR_LMT_FCC] = TXPWR_LMT_FCC,
[TXPWR_LMT_MKK] = TXPWR_LMT_MKK,
[TXPWR_LMT_ETSI] = TXPWR_LMT_ETSI,
[TXPWR_LMT_WW] = TXPWR_LMT_WW,
[TXPWR_LMT_NUM] = TXPWR_LMT_NUM,
[TXPWR_LMT_IC] = TXPWR_LMT_FCC,
[TXPWR_LMT_KCC] = TXPWR_LMT_ETSI,
[TXPWR_LMT_NCC] = TXPWR_LMT_FCC,
[TXPWR_LMT_ACMA] = TXPWR_LMT_ETSI,
[TXPWR_LMT_CHILE] = TXPWR_LMT_FCC,
[TXPWR_LMT_UKRAINE] = TXPWR_LMT_ETSI,
[TXPWR_LMT_MEXICO] = TXPWR_LMT_FCC,
[TXPWR_LMT_CN] = TXPWR_LMT_ETSI,
[TXPWR_LMT_QATAR] = TXPWR_LMT_ETSI,
};
const enum rtw_edcca_mode_t _rtw_regd_to_edcca_mode[RTW_REGD_NUM] = {
[RTW_REGD_NA] = RTW_EDCCA_MODE_NUM,
[RTW_REGD_MKK] = RTW_EDCCA_CS,
[RTW_REGD_ETSI] = RTW_EDCCA_ADAPT,
[RTW_REGD_WW] = RTW_EDCCA_ADAPT,
};
const REGULATION_TXPWR_LMT _rtw_regd_to_txpwr_lmt[] = {
[RTW_REGD_NA] = TXPWR_LMT_NUM,
[RTW_REGD_FCC] = TXPWR_LMT_FCC,
[RTW_REGD_MKK] = TXPWR_LMT_MKK,
[RTW_REGD_ETSI] = TXPWR_LMT_ETSI,
[RTW_REGD_IC] = TXPWR_LMT_IC,
[RTW_REGD_KCC] = TXPWR_LMT_KCC,
[RTW_REGD_NCC] = TXPWR_LMT_NCC,
[RTW_REGD_ACMA] = TXPWR_LMT_ACMA,
[RTW_REGD_CHILE] = TXPWR_LMT_CHILE,
[RTW_REGD_MEX] = TXPWR_LMT_MEXICO,
[RTW_REGD_WW] = TXPWR_LMT_WW,
};
char *rtw_get_edcca_modes_str(char *buf, u8 modes[])
{
#define EDCCA_MODE_SEQ_COMPARE(result, operand) (result == RTW_EDCCA_MODE_NUM ? operand : (operand == RTW_EDCCA_MODE_NUM ? result : (result != operand ? -1 : result)))
int mode = RTW_EDCCA_MODE_NUM;
int cnt = 0;
mode = EDCCA_MODE_SEQ_COMPARE(mode, modes[BAND_ON_24G]);
#if CONFIG_IEEE80211_BAND_5GHZ
mode = EDCCA_MODE_SEQ_COMPARE(mode, modes[BAND_ON_5G]);
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
mode = EDCCA_MODE_SEQ_COMPARE(mode, modes[BAND_ON_6G]);
#endif
if (mode != -1) { /* all available values are the same */
cnt += snprintf(buf + cnt, EDCCA_MODES_STR_LEN - cnt - 1, "%s(%u)", rtw_edcca_mode_str(mode), mode);
if (cnt >= EDCCA_MODES_STR_LEN - 1)
goto exit;
} else {
cnt += snprintf(buf + cnt, EDCCA_MODES_STR_LEN - cnt - 1, "%s(%u) ", rtw_edcca_mode_str(modes[BAND_ON_24G]), modes[BAND_ON_24G]);
if (cnt >= EDCCA_MODES_STR_LEN - 1)
goto exit;
#if CONFIG_IEEE80211_BAND_5GHZ
cnt += snprintf(buf + cnt, EDCCA_MODES_STR_LEN - cnt - 1, "%s(%u) ", rtw_edcca_mode_str(modes[BAND_ON_5G]), modes[BAND_ON_5G]);
if (cnt >= EDCCA_MODES_STR_LEN - 1)
goto exit;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
cnt += snprintf(buf + cnt, EDCCA_MODES_STR_LEN - cnt - 1, "%s(%u) ", rtw_edcca_mode_str(modes[BAND_ON_6G]), modes[BAND_ON_6G]);
if (cnt >= EDCCA_MODES_STR_LEN - 1)
goto exit;
#endif
buf[cnt - 1] = 0;
}
exit:
return buf;
}
void rtw_edcca_mode_update(struct dvobj_priv *dvobj)
{
struct registry_priv *regsty = dvobj_to_regsty(dvobj);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
if (regsty->adaptivity_en == 0) {
/* force disable */
rfctl->edcca_mode_2g = RTW_EDCCA_NORM;
#if CONFIG_IEEE80211_BAND_5GHZ
rfctl->edcca_mode_5g = RTW_EDCCA_NORM;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->edcca_mode_6g = RTW_EDCCA_NORM;
#endif
} else if (regsty->adaptivity_en == 1) {
/* force enable */
if (!regsty->adaptivity_mode) {
/* adaptivity */
rfctl->edcca_mode_2g = RTW_EDCCA_ADAPT;
#if CONFIG_IEEE80211_BAND_5GHZ
rfctl->edcca_mode_5g = RTW_EDCCA_ADAPT;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->edcca_mode_6g = RTW_EDCCA_ADAPT;
#endif
} else {
/* carrier sense */
rfctl->edcca_mode_2g = RTW_EDCCA_CS;
#if CONFIG_IEEE80211_BAND_5GHZ
rfctl->edcca_mode_5g = RTW_EDCCA_CS;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->edcca_mode_6g = RTW_EDCCA_CS;
#endif
}
} else {
u8 modes[BAND_MAX];
char buf[EDCCA_MODES_STR_LEN];
/* by regulatory setting */
#ifdef CONFIG_REGD_SRC_FROM_OS
if (rfctl->regd_src == REGD_SRC_OS
&& rfctl->ChannelPlan == RTW_CHPLAN_UNSPECIFIED
) {
modes[BAND_ON_24G] = rfctl->edcca_mode_2g = RTW_EDCCA_ADAPT;
#if CONFIG_IEEE80211_BAND_5GHZ
modes[BAND_ON_5G] = rfctl->edcca_mode_5g = RTW_EDCCA_ADAPT;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
modes[BAND_ON_6G] = rfctl->edcca_mode_6g = RTW_EDCCA_ADAPT;
#endif
RTW_PRINT("mapping %scountry:%c%c to edcca_mode:%s\n"
, RFCTL_REG_WORLDWIDE(rfctl) ? "" : "unsupported "
, rfctl->alpha2[0]
, rfctl->alpha2[1]
, rtw_get_edcca_modes_str(buf, modes)
);
} else
#endif
{
modes[BAND_ON_24G] = rfctl->edcca_mode_2g =
rfctl->edcca_mode_2g_override != RTW_EDCCA_DEF ? rfctl->edcca_mode_2g_override :
rtw_regd_to_edcca_mode(rtw_chplan_get_default_regd_2g(rfctl->ChannelPlan));
#if CONFIG_IEEE80211_BAND_5GHZ
modes[BAND_ON_5G] = rfctl->edcca_mode_5g =
rfctl->edcca_mode_5g_override != RTW_EDCCA_DEF ? rfctl->edcca_mode_5g_override :
rtw_regd_to_edcca_mode(rtw_chplan_get_default_regd_5g(rfctl->ChannelPlan));
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
modes[BAND_ON_6G] = rfctl->edcca_mode_6g =
rfctl->edcca_mode_6g_override != RTW_EDCCA_DEF ? rfctl->edcca_mode_6g_override :
rtw_regd_to_edcca_mode(rtw_chplan_get_default_regd_6g(rfctl->chplan_6g));
#endif
RTW_PRINT("update edcca_mode:%s\n"
, rtw_get_edcca_modes_str(buf, modes)
);
}
}
}
u8 rtw_get_edcca_mode(struct dvobj_priv *dvobj, enum band_type band)
{
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
u8 edcca_mode = RTW_EDCCA_NORM;
if (band == BAND_ON_24G)
edcca_mode = rfctl->edcca_mode_2g;
#if CONFIG_IEEE80211_BAND_5GHZ
else if (band == BAND_ON_5G)
edcca_mode = rfctl->edcca_mode_5g;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
else if (band == BAND_ON_6G)
edcca_mode = rfctl->edcca_mode_6g;
#endif
return edcca_mode;
}
char *rtw_get_txpwr_lmt_names_str(char *buf, const char *names[], u8 unknown_bmp)
{
#define NAME_DIFF ((void *)1)
/* input comes form organized database, string with same content will not have different pointer */
#define NAME_SEQ_COMPARE(result, operand) (result == NULL ? operand : (operand == NULL ? result : (result != operand ? NAME_DIFF : result)))
const char *name = NULL;
int cnt = 0;
name = NAME_SEQ_COMPARE(name, names[BAND_ON_24G]);
#if CONFIG_IEEE80211_BAND_5GHZ
name = NAME_SEQ_COMPARE(name, names[BAND_ON_5G]);
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
name = NAME_SEQ_COMPARE(name, names[BAND_ON_6G]);
#endif
if (name != NAME_DIFF) { /* all available values are the same */
cnt += snprintf(buf + cnt, TXPWR_NAMES_STR_LEN - cnt - 1, "%s%s", (unknown_bmp & BIT(BAND_ON_24G)) ? "?" : "", name);
if (cnt >= TXPWR_NAMES_STR_LEN - 1)
goto exit;
} else {
cnt += snprintf(buf + cnt, TXPWR_NAMES_STR_LEN - cnt - 1, "%s%s ", (unknown_bmp & BIT(BAND_ON_24G)) ? "?" : "", names[BAND_ON_24G]);
if (cnt >= TXPWR_NAMES_STR_LEN - 1)
goto exit;
#if CONFIG_IEEE80211_BAND_5GHZ
cnt += snprintf(buf + cnt, TXPWR_NAMES_STR_LEN - cnt - 1, "%s%s ", (unknown_bmp & BIT(BAND_ON_5G)) ? "?" : "", names[BAND_ON_5G]);
if (cnt >= TXPWR_NAMES_STR_LEN - 1)
goto exit;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
cnt += snprintf(buf + cnt, TXPWR_NAMES_STR_LEN - cnt - 1, "%s%s ", (unknown_bmp & BIT(BAND_ON_6G)) ? "?" : "", names[BAND_ON_6G]);
if (cnt >= TXPWR_NAMES_STR_LEN - 1)
goto exit;
#endif
buf[cnt - 1] = 0;
}
exit:
return buf;
}
#if CONFIG_IEEE80211_BAND_5GHZ
#define COUNTRY_CHPLAN_ASSIGN_EDCCA_MODE_5G_OVERRIDE(_val) , .edcca_mode_5g_override = (_val)
#else
#define COUNTRY_CHPLAN_ASSIGN_EDCCA_MODE_5G_OVERRIDE(_val)
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
#define COUNTRY_CHPLAN_ASSIGN_CHPLAN_6G(_val) , .chplan_6g = (_val)
#define COUNTRY_CHPLAN_ASSIGN_EDCCA_MODE_6G_OVERRIDE(_val) , .edcca_mode_6g_override = (_val)
#else
#define COUNTRY_CHPLAN_ASSIGN_CHPLAN_6G(_val)
#define COUNTRY_CHPLAN_ASSIGN_EDCCA_MODE_6G_OVERRIDE(_val)
#endif
#if defined(CONFIG_80211AC_VHT) || defined(CONFIG_80211AX_HE)
#define COUNTRY_CHPLAN_ASSIGN_PROTO_EN(_val) , .proto_en = (_val)
#else
#define COUNTRY_CHPLAN_ASSIGN_PROTO_EN(_val)
#endif
#define COUNTRY_CHPLAN_ENT(_alpha2, _chplan, _chplan_6g, _txpwr_lmt_override, _en_11ax, _en_11ac) \
{.alpha2 = (_alpha2), .chplan = (_chplan) \
COUNTRY_CHPLAN_ASSIGN_CHPLAN_6G(_chplan_6g) \
, .edcca_mode_2g_override = RTW_EDCCA_DEF \
COUNTRY_CHPLAN_ASSIGN_EDCCA_MODE_5G_OVERRIDE(RTW_EDCCA_DEF) \
COUNTRY_CHPLAN_ASSIGN_EDCCA_MODE_6G_OVERRIDE(RTW_EDCCA_DEF) \
, .txpwr_lmt_override = TXPWR_LMT_##_txpwr_lmt_override \
COUNTRY_CHPLAN_ASSIGN_PROTO_EN((_en_11ax ? CHPLAN_PROTO_EN_AX : 0) | (_en_11ac ? CHPLAN_PROTO_EN_AC : 0)) \
}
static const struct country_chplan world_wide_chplan =
COUNTRY_CHPLAN_ENT(WORLDWIDE_ALPHA2, RTW_CHPLAN_WORLDWIDE, RTW_CHPLAN_6G_WORLDWIDE, DEF, 1, 1);
#ifdef CONFIG_CUSTOMIZED_COUNTRY_CHPLAN_MAP
#include "../platform/custom_country_chplan.h"
#elif RTW_DEF_MODULE_REGULATORY_CERT
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8821AE_HMC_M2) /* 2013 certify */
static const struct country_chplan RTL8821AE_HMC_M2_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x3D, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x36, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8821AU) /* 2014 certify */
static const struct country_chplan RTL8821AU_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x3D, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x36, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8812AENF_NGFF) /* 2014 certify */
static const struct country_chplan RTL8812AENF_NGFF_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8812AEBT_HMC) /* 2013 certify */
static const struct country_chplan RTL8812AEBT_HMC_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x36, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8188EE_HMC_M2) /* 2012 certify */
static const struct country_chplan RTL8188EE_HMC_M2_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AW", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BB", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x20, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ET", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GD", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HT", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x5D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ML", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NP", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UZ", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8723BE_HMC_M2) /* 2013 certify */
static const struct country_chplan RTL8723BE_HMC_M2_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AO", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AW", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BS", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x20, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ET", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GD", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x5D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ML", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NP", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UZ", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8723BS_NGFF1216) /* 2014 certify */
static const struct country_chplan RTL8723BS_NGFF1216_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AO", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BB", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x20, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HT", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x5D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NP", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UZ", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("YE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8192EEBT_HMC_M2) /* 2013 certify */
static const struct country_chplan RTL8192EEBT_HMC_M2_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AO", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AW", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x20, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EH", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ET", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GD", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x5D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ML", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NP", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SC", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ST", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x39, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UZ", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("YT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8723DE_NGFF1630) /* 2016 certify */
static const struct country_chplan RTL8723DE_NGFF1630_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x2A, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x5D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x34, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8822BE) /* 2016 certify */
static const struct country_chplan RTL8822BE_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AO", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BB", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BM", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BS", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x2B, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EH", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FJ", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GP", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GU", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x3D, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ML", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MO", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x4D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NP", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SC", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ST", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, UKRAINE, 0, 1),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UZ", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("YT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8821CE) /* 2016 certify */
static const struct country_chplan RTL8821CE_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AO", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BB", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BM", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BS", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x2B, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EH", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ET", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FJ", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GP", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GU", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ID", 0x3D, 0x00, DEF , 0, 0),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x28, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ML", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MO", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x4D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NP", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SC", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ST", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, UKRAINE, 0, 1),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UZ", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("YT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
#if (RTW_DEF_MODULE_REGULATORY_CERT & RTW_MODULE_RTL8822CE) /* 2018 certify */
static const struct country_chplan RTL8822CE_country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AE", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AO", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AR", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AU", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AW", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("AZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BB", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BH", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BM", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BO", 0x73, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BS", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BW", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("BY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CA", 0x2B, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CL", 0x2D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CN", 0x48, 0x00, CN , 0, 1),
COUNTRY_CHPLAN_ENT("CO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CY", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("CZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DO", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EC", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EG", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("EH", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ES", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ET", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FJ", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("FR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GP", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GT", 0x61, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GU", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("GW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HK", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HT", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("HU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IL", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IN", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("IT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JM", 0x32, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JO", 0x49, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("JP", 0x27, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KE", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KH", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KR", 0x4B, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("KZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LB", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("LV", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MA", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MC", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ME", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ML", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MO", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MQ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MU", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MW", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MX", 0x4D, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MY", 0x63, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("MZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NA", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NI", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NP", 0x48, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("NZ", 0x45, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("OM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PA", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PE", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PR", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("PY", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("QA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RO", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RS", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("RU", 0x59, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SC", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SE", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SG", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SI", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SK", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SL", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SN", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ST", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SV", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("SZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TD", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TF", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TH", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TJ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TN", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TR", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TW", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("TZ", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UA", 0x35, 0x00, UKRAINE, 0, 1),
COUNTRY_CHPLAN_ENT("UG", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("US", 0x76, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("UZ", 0x47, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("VN", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("YT", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZA", 0x35, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZM", 0x26, 0x00, DEF , 0, 1),
COUNTRY_CHPLAN_ENT("ZW", 0x26, 0x00, DEF , 0, 1),
};
#endif
/**
* rtw_def_module_country_chplan_map -
* @hal_map: returned map
* @return: size of map
*/
static u16 rtw_def_module_country_chplan_map(const struct country_chplan **hal_map)
{
u16 hal_map_sz = 0;
/* TODO: runtime selection for multi driver */
#if (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8821AE_HMC_M2)
*hal_map = RTL8821AE_HMC_M2_country_chplan_map;
hal_map_sz = sizeof(RTL8821AE_HMC_M2_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8821AU)
*hal_map = RTL8821AU_country_chplan_map;
hal_map_sz = sizeof(RTL8821AU_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8812AENF_NGFF)
*hal_map = RTL8812AENF_NGFF_country_chplan_map;
hal_map_sz = sizeof(RTL8812AENF_NGFF_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8812AEBT_HMC)
*hal_map = RTL8812AEBT_HMC_country_chplan_map;
hal_map_sz = sizeof(RTL8812AEBT_HMC_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8188EE_HMC_M2)
*hal_map = RTL8188EE_HMC_M2_country_chplan_map;
hal_map_sz = sizeof(RTL8188EE_HMC_M2_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8723BE_HMC_M2)
*hal_map = RTL8723BE_HMC_M2_country_chplan_map;
hal_map_sz = sizeof(RTL8723BE_HMC_M2_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8723BS_NGFF1216)
*hal_map = RTL8723BS_NGFF1216_country_chplan_map;
hal_map_sz = sizeof(RTL8723BS_NGFF1216_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8192EEBT_HMC_M2)
*hal_map = RTL8192EEBT_HMC_M2_country_chplan_map;
hal_map_sz = sizeof(RTL8192EEBT_HMC_M2_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8723DE_NGFF1630)
*hal_map = RTL8723DE_NGFF1630_country_chplan_map;
hal_map_sz = sizeof(RTL8723DE_NGFF1630_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8822BE)
*hal_map = RTL8822BE_country_chplan_map;
hal_map_sz = sizeof(RTL8822BE_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8821CE)
*hal_map = RTL8821CE_country_chplan_map;
hal_map_sz = sizeof(RTL8821CE_country_chplan_map) / sizeof(struct country_chplan);
#elif (RTW_DEF_MODULE_REGULATORY_CERT == RTW_MODULE_RTL8822CE)
*hal_map = RTL8822CE_country_chplan_map;
hal_map_sz = sizeof(RTL8822CE_country_chplan_map) / sizeof(struct country_chplan);
#endif
return hal_map_sz;
}
#else
static const struct country_chplan country_chplan_map[] = {
COUNTRY_CHPLAN_ENT("AD", 0x3A, 0x00, DEF , 1, 1), /* Andorra */
COUNTRY_CHPLAN_ENT("AE", 0x5E, 0x00, DEF , 1, 1), /* United Arab Emirates */
COUNTRY_CHPLAN_ENT("AF", 0x42, 0x00, DEF , 1, 1), /* Afghanistan */
COUNTRY_CHPLAN_ENT("AG", 0x76, 0x00, DEF , 1, 1), /* Antigua & Barbuda */
COUNTRY_CHPLAN_ENT("AI", 0x5E, 0x00, DEF , 1, 1), /* Anguilla(UK) */
COUNTRY_CHPLAN_ENT("AL", 0x5E, 0x00, DEF , 1, 1), /* Albania */
COUNTRY_CHPLAN_ENT("AM", 0x5E, 0x00, DEF , 1, 1), /* Armenia */
COUNTRY_CHPLAN_ENT("AN", 0x76, 0x00, DEF , 1, 1), /* Netherlands Antilles */
COUNTRY_CHPLAN_ENT("AO", 0x5E, 0x00, DEF , 1, 1), /* Angola */
COUNTRY_CHPLAN_ENT("AQ", 0x26, 0x00, DEF , 1, 1), /* Antarctica */
COUNTRY_CHPLAN_ENT("AR", 0x4D, 0x00, DEF , 1, 1), /* Argentina */
COUNTRY_CHPLAN_ENT("AS", 0x76, 0x00, DEF , 1, 1), /* American Samoa */
COUNTRY_CHPLAN_ENT("AT", 0x5E, 0x00, DEF , 1, 1), /* Austria */
COUNTRY_CHPLAN_ENT("AU", 0x03, 0x00, DEF , 1, 1), /* Australia */
COUNTRY_CHPLAN_ENT("AW", 0x76, 0x00, DEF , 1, 1), /* Aruba */
COUNTRY_CHPLAN_ENT("AZ", 0x5E, 0x00, DEF , 1, 1), /* Azerbaijan */
COUNTRY_CHPLAN_ENT("BA", 0x5E, 0x00, DEF , 1, 1), /* Bosnia & Herzegovina */
COUNTRY_CHPLAN_ENT("BB", 0x76, 0x00, DEF , 1, 1), /* Barbados */
COUNTRY_CHPLAN_ENT("BD", 0x5E, 0x00, DEF , 1, 1), /* Bangladesh */
COUNTRY_CHPLAN_ENT("BE", 0x5E, 0x00, DEF , 1, 1), /* Belgium */
COUNTRY_CHPLAN_ENT("BF", 0x5E, 0x00, DEF , 1, 1), /* Burkina Faso */
COUNTRY_CHPLAN_ENT("BG", 0x5E, 0x00, DEF , 1, 1), /* Bulgaria */
COUNTRY_CHPLAN_ENT("BH", 0x06, 0x00, DEF , 1, 1), /* Bahrain */
COUNTRY_CHPLAN_ENT("BI", 0x3A, 0x00, DEF , 1, 1), /* Burundi */
COUNTRY_CHPLAN_ENT("BJ", 0x3A, 0x00, DEF , 1, 1), /* Benin */
COUNTRY_CHPLAN_ENT("BM", 0x76, 0x00, DEF , 1, 1), /* Bermuda (UK) */
COUNTRY_CHPLAN_ENT("BN", 0x06, 0x00, DEF , 1, 1), /* Brunei */
COUNTRY_CHPLAN_ENT("BO", 0x61, 0x00, DEF , 1, 1), /* Bolivia */
COUNTRY_CHPLAN_ENT("BR", 0x62, 0x00, DEF , 1, 1), /* Brazil */
COUNTRY_CHPLAN_ENT("BS", 0x76, 0x00, DEF , 1, 1), /* Bahamas */
COUNTRY_CHPLAN_ENT("BT", 0x5E, 0x00, DEF , 1, 1), /* Bhutan */
COUNTRY_CHPLAN_ENT("BV", 0x5E, 0x00, DEF , 1, 1), /* Bouvet Island (Norway) */
COUNTRY_CHPLAN_ENT("BW", 0x5E, 0x00, DEF , 1, 1), /* Botswana */
COUNTRY_CHPLAN_ENT("BY", 0x08, 0x00, DEF , 0, 1), /* Belarus */
COUNTRY_CHPLAN_ENT("BZ", 0x76, 0x00, DEF , 1, 1), /* Belize */
COUNTRY_CHPLAN_ENT("CA", 0x2B, 0x00, DEF , 1, 1), /* Canada */
COUNTRY_CHPLAN_ENT("CC", 0x3A, 0x00, DEF , 1, 1), /* Cocos (Keeling) Islands (Australia) */
COUNTRY_CHPLAN_ENT("CD", 0x3A, 0x00, DEF , 1, 1), /* Congo, Republic of the */
COUNTRY_CHPLAN_ENT("CF", 0x3A, 0x00, DEF , 1, 1), /* Central African Republic */
COUNTRY_CHPLAN_ENT("CG", 0x3A, 0x00, DEF , 1, 1), /* Congo, Democratic Republic of the. Zaire */
COUNTRY_CHPLAN_ENT("CH", 0x5E, 0x00, DEF , 1, 1), /* Switzerland */
COUNTRY_CHPLAN_ENT("CI", 0x42, 0x00, DEF , 1, 1), /* Cote d'Ivoire */
COUNTRY_CHPLAN_ENT("CK", 0x5E, 0x00, DEF , 1, 1), /* Cook Islands */
COUNTRY_CHPLAN_ENT("CL", 0x76, 0x00, CHILE , 1, 1), /* Chile */
COUNTRY_CHPLAN_ENT("CM", 0x5E, 0x00, DEF , 1, 1), /* Cameroon */
COUNTRY_CHPLAN_ENT("CN", 0x06, 0x00, CN , 1, 1), /* China */
COUNTRY_CHPLAN_ENT("CO", 0x76, 0x00, DEF , 1, 1), /* Colombia */
COUNTRY_CHPLAN_ENT("CR", 0x76, 0x00, DEF , 1, 1), /* Costa Rica */
COUNTRY_CHPLAN_ENT("CV", 0x5E, 0x00, DEF , 1, 1), /* Cape Verde */
COUNTRY_CHPLAN_ENT("CX", 0x03, 0x00, DEF , 1, 1), /* Christmas Island (Australia) */
COUNTRY_CHPLAN_ENT("CY", 0x5E, 0x00, DEF , 1, 1), /* Cyprus */
COUNTRY_CHPLAN_ENT("CZ", 0x5E, 0x00, DEF , 1, 1), /* Czech Republic */
COUNTRY_CHPLAN_ENT("DE", 0x5E, 0x00, DEF , 1, 1), /* Germany */
COUNTRY_CHPLAN_ENT("DJ", 0x3A, 0x00, DEF , 1, 1), /* Djibouti */
COUNTRY_CHPLAN_ENT("DK", 0x5E, 0x00, DEF , 1, 1), /* Denmark */
COUNTRY_CHPLAN_ENT("DM", 0x76, 0x00, DEF , 1, 1), /* Dominica */
COUNTRY_CHPLAN_ENT("DO", 0x76, 0x00, DEF , 1, 1), /* Dominican Republic */
COUNTRY_CHPLAN_ENT("DZ", 0x00, 0x00, DEF , 1, 1), /* Algeria */
COUNTRY_CHPLAN_ENT("EC", 0x76, 0x00, DEF , 1, 1), /* Ecuador */
COUNTRY_CHPLAN_ENT("EE", 0x5E, 0x00, DEF , 1, 1), /* Estonia */
COUNTRY_CHPLAN_ENT("EG", 0x3C, 0x00, DEF , 1, 1), /* Egypt */
COUNTRY_CHPLAN_ENT("EH", 0x3C, 0x00, DEF , 1, 1), /* Western Sahara */
COUNTRY_CHPLAN_ENT("ER", 0x3A, 0x00, DEF , 1, 1), /* Eritrea */
COUNTRY_CHPLAN_ENT("ES", 0x5E, 0x00, DEF , 1, 1), /* Spain, Canary Islands, Ceuta, Melilla */
COUNTRY_CHPLAN_ENT("ET", 0x3A, 0x00, DEF , 1, 1), /* Ethiopia */
COUNTRY_CHPLAN_ENT("FI", 0x5E, 0x00, DEF , 1, 1), /* Finland */
COUNTRY_CHPLAN_ENT("FJ", 0x76, 0x00, DEF , 1, 1), /* Fiji */
COUNTRY_CHPLAN_ENT("FK", 0x3A, 0x00, DEF , 1, 1), /* Falkland Islands (Islas Malvinas) (UK) */
COUNTRY_CHPLAN_ENT("FM", 0x76, 0x00, DEF , 1, 1), /* Micronesia, Federated States of (USA) */
COUNTRY_CHPLAN_ENT("FO", 0x3A, 0x00, DEF , 1, 1), /* Faroe Islands (Denmark) */
COUNTRY_CHPLAN_ENT("FR", 0x5E, 0x00, DEF , 1, 1), /* France */
COUNTRY_CHPLAN_ENT("GA", 0x5E, 0x00, DEF , 1, 1), /* Gabon */
COUNTRY_CHPLAN_ENT("GB", 0x5E, 0x00, DEF , 1, 1), /* Great Britain (United Kingdom; England) */
COUNTRY_CHPLAN_ENT("GD", 0x76, 0x00, DEF , 1, 1), /* Grenada */
COUNTRY_CHPLAN_ENT("GE", 0x5E, 0x00, DEF , 1, 1), /* Georgia */
COUNTRY_CHPLAN_ENT("GF", 0x3A, 0x00, DEF , 1, 1), /* French Guiana */
COUNTRY_CHPLAN_ENT("GG", 0x5E, 0x00, DEF , 1, 1), /* Guernsey (UK) */
COUNTRY_CHPLAN_ENT("GH", 0x5E, 0x00, DEF , 1, 1), /* Ghana */
COUNTRY_CHPLAN_ENT("GI", 0x3A, 0x00, DEF , 1, 1), /* Gibraltar (UK) */
COUNTRY_CHPLAN_ENT("GL", 0x5E, 0x00, DEF , 1, 1), /* Greenland (Denmark) */
COUNTRY_CHPLAN_ENT("GM", 0x3A, 0x00, DEF , 1, 1), /* Gambia */
COUNTRY_CHPLAN_ENT("GN", 0x3A, 0x00, DEF , 1, 1), /* Guinea */
COUNTRY_CHPLAN_ENT("GP", 0x3A, 0x00, DEF , 1, 1), /* Guadeloupe (France) */
COUNTRY_CHPLAN_ENT("GQ", 0x5E, 0x00, DEF , 1, 1), /* Equatorial Guinea */
COUNTRY_CHPLAN_ENT("GR", 0x5E, 0x00, DEF , 1, 1), /* Greece */
COUNTRY_CHPLAN_ENT("GS", 0x3A, 0x00, DEF , 1, 1), /* South Georgia and the Sandwich Islands (UK) */
COUNTRY_CHPLAN_ENT("GT", 0x76, 0x00, DEF , 1, 1), /* Guatemala */
COUNTRY_CHPLAN_ENT("GU", 0x76, 0x00, DEF , 1, 1), /* Guam (USA) */
COUNTRY_CHPLAN_ENT("GW", 0x3A, 0x00, DEF , 1, 1), /* Guinea-Bissau */
COUNTRY_CHPLAN_ENT("GY", 0x44, 0x00, DEF , 1, 1), /* Guyana */
COUNTRY_CHPLAN_ENT("HK", 0x5E, 0x00, DEF , 1, 1), /* Hong Kong */
COUNTRY_CHPLAN_ENT("HM", 0x03, 0x00, DEF , 1, 1), /* Heard and McDonald Islands (Australia) */
COUNTRY_CHPLAN_ENT("HN", 0x32, 0x00, DEF , 1, 1), /* Honduras */
COUNTRY_CHPLAN_ENT("HR", 0x5E, 0x00, DEF , 1, 1), /* Croatia */
COUNTRY_CHPLAN_ENT("HT", 0x76, 0x00, DEF , 0, 1), /* Haiti */
COUNTRY_CHPLAN_ENT("HU", 0x5E, 0x00, DEF , 1, 1), /* Hungary */
COUNTRY_CHPLAN_ENT("ID", 0x5D, 0x00, DEF , 1, 1), /* Indonesia */
COUNTRY_CHPLAN_ENT("IE", 0x5E, 0x00, DEF , 1, 1), /* Ireland */
COUNTRY_CHPLAN_ENT("IL", 0x5E, 0x00, DEF , 1, 1), /* Israel */
COUNTRY_CHPLAN_ENT("IM", 0x3A, 0x00, DEF , 1, 1), /* Isle of Man (UK) */
COUNTRY_CHPLAN_ENT("IN", 0x06, 0x00, DEF , 1, 1), /* India */
COUNTRY_CHPLAN_ENT("IO", 0x3A, 0x00, DEF , 1, 1), /* British Indian Ocean Territory (UK) */
COUNTRY_CHPLAN_ENT("IQ", 0x05, 0x00, DEF , 1, 1), /* Iraq */
COUNTRY_CHPLAN_ENT("IR", 0x3A, 0x00, DEF , 0, 0), /* Iran */
COUNTRY_CHPLAN_ENT("IS", 0x5E, 0x00, DEF , 1, 1), /* Iceland */
COUNTRY_CHPLAN_ENT("IT", 0x5E, 0x00, DEF , 1, 1), /* Italy */
COUNTRY_CHPLAN_ENT("JE", 0x3A, 0x00, DEF , 1, 1), /* Jersey (UK) */
COUNTRY_CHPLAN_ENT("JM", 0x76, 0x00, DEF , 1, 1), /* Jamaica */
COUNTRY_CHPLAN_ENT("JO", 0x05, 0x00, DEF , 1, 1), /* Jordan */
COUNTRY_CHPLAN_ENT("JP", 0x7D, 0x00, DEF , 1, 1), /* Japan- Telec */
COUNTRY_CHPLAN_ENT("KE", 0x5E, 0x00, DEF , 1, 1), /* Kenya */
COUNTRY_CHPLAN_ENT("KG", 0x5E, 0x00, DEF , 1, 1), /* Kyrgyzstan */
COUNTRY_CHPLAN_ENT("KH", 0x5E, 0x00, DEF , 1, 1), /* Cambodia */
COUNTRY_CHPLAN_ENT("KI", 0x5E, 0x00, DEF , 1, 1), /* Kiribati */
COUNTRY_CHPLAN_ENT("KM", 0x3A, 0x00, DEF , 1, 1), /* Comoros */
COUNTRY_CHPLAN_ENT("KN", 0x76, 0x00, DEF , 1, 1), /* Saint Kitts and Nevis */
COUNTRY_CHPLAN_ENT("KR", 0x4B, 0x00, DEF , 1, 1), /* South Korea */
COUNTRY_CHPLAN_ENT("KW", 0x5E, 0x00, DEF , 1, 1), /* Kuwait */
COUNTRY_CHPLAN_ENT("KY", 0x76, 0x00, DEF , 1, 1), /* Cayman Islands (UK) */
COUNTRY_CHPLAN_ENT("KZ", 0x5E, 0x00, DEF , 1, 1), /* Kazakhstan */
COUNTRY_CHPLAN_ENT("LA", 0x5E, 0x00, DEF , 1, 1), /* Laos */
COUNTRY_CHPLAN_ENT("LB", 0x5E, 0x00, DEF , 1, 1), /* Lebanon */
COUNTRY_CHPLAN_ENT("LC", 0x76, 0x00, DEF , 1, 1), /* Saint Lucia */
COUNTRY_CHPLAN_ENT("LI", 0x5E, 0x00, DEF , 1, 1), /* Liechtenstein */
COUNTRY_CHPLAN_ENT("LK", 0x5E, 0x00, DEF , 1, 1), /* Sri Lanka */
COUNTRY_CHPLAN_ENT("LR", 0x5E, 0x00, DEF , 1, 1), /* Liberia */
COUNTRY_CHPLAN_ENT("LS", 0x5E, 0x00, DEF , 1, 1), /* Lesotho */
COUNTRY_CHPLAN_ENT("LT", 0x5E, 0x00, DEF , 1, 1), /* Lithuania */
COUNTRY_CHPLAN_ENT("LU", 0x5E, 0x00, DEF , 1, 1), /* Luxembourg */
COUNTRY_CHPLAN_ENT("LV", 0x5E, 0x00, DEF , 1, 1), /* Latvia */
COUNTRY_CHPLAN_ENT("LY", 0x5E, 0x00, DEF , 1, 1), /* Libya */
COUNTRY_CHPLAN_ENT("MA", 0x3C, 0x00, DEF , 1, 1), /* Morocco */
COUNTRY_CHPLAN_ENT("MC", 0x5E, 0x00, DEF , 1, 1), /* Monaco */
COUNTRY_CHPLAN_ENT("MD", 0x5E, 0x00, DEF , 1, 1), /* Moldova */
COUNTRY_CHPLAN_ENT("ME", 0x3A, 0x00, DEF , 1, 1), /* Montenegro */
COUNTRY_CHPLAN_ENT("MF", 0x76, 0x00, DEF , 1, 1), /* Saint Martin */
COUNTRY_CHPLAN_ENT("MG", 0x5E, 0x00, DEF , 1, 1), /* Madagascar */
COUNTRY_CHPLAN_ENT("MH", 0x76, 0x00, DEF , 1, 1), /* Marshall Islands (USA) */
COUNTRY_CHPLAN_ENT("MK", 0x3A, 0x00, DEF , 1, 1), /* Republic of Macedonia (FYROM) */
COUNTRY_CHPLAN_ENT("ML", 0x5E, 0x00, DEF , 1, 1), /* Mali */
COUNTRY_CHPLAN_ENT("MM", 0x3A, 0x00, DEF , 1, 1), /* Burma (Myanmar) */
COUNTRY_CHPLAN_ENT("MN", 0x5E, 0x00, DEF , 1, 1), /* Mongolia */
COUNTRY_CHPLAN_ENT("MO", 0x5E, 0x00, DEF , 1, 1), /* Macau */
COUNTRY_CHPLAN_ENT("MP", 0x76, 0x00, DEF , 1, 1), /* Northern Mariana Islands (USA) */
COUNTRY_CHPLAN_ENT("MQ", 0x3A, 0x00, DEF , 1, 1), /* Martinique (France) */
COUNTRY_CHPLAN_ENT("MR", 0x5E, 0x00, DEF , 1, 1), /* Mauritania */
COUNTRY_CHPLAN_ENT("MS", 0x3A, 0x00, DEF , 1, 1), /* Montserrat (UK) */
COUNTRY_CHPLAN_ENT("MT", 0x5E, 0x00, DEF , 1, 1), /* Malta */
COUNTRY_CHPLAN_ENT("MU", 0x5E, 0x00, DEF , 1, 1), /* Mauritius */
COUNTRY_CHPLAN_ENT("MV", 0x3C, 0x00, DEF , 1, 1), /* Maldives */
COUNTRY_CHPLAN_ENT("MW", 0x5E, 0x00, DEF , 1, 1), /* Malawi */
COUNTRY_CHPLAN_ENT("MX", 0x4D, 0x00, DEF , 1, 1), /* Mexico */
COUNTRY_CHPLAN_ENT("MY", 0x07, 0x00, DEF , 1, 1), /* Malaysia */
COUNTRY_CHPLAN_ENT("MZ", 0x5E, 0x00, DEF , 1, 1), /* Mozambique */
COUNTRY_CHPLAN_ENT("NA", 0x5E, 0x00, DEF , 1, 1), /* Namibia */
COUNTRY_CHPLAN_ENT("NC", 0x3A, 0x00, DEF , 1, 1), /* New Caledonia */
COUNTRY_CHPLAN_ENT("NE", 0x5E, 0x00, DEF , 1, 1), /* Niger */
COUNTRY_CHPLAN_ENT("NF", 0x03, 0x00, DEF , 1, 1), /* Norfolk Island (Australia) */
COUNTRY_CHPLAN_ENT("NG", 0x75, 0x00, DEF , 1, 1), /* Nigeria */
COUNTRY_CHPLAN_ENT("NI", 0x76, 0x00, DEF , 1, 1), /* Nicaragua */
COUNTRY_CHPLAN_ENT("NL", 0x5E, 0x00, DEF , 1, 1), /* Netherlands */
COUNTRY_CHPLAN_ENT("NO", 0x5E, 0x00, DEF , 1, 1), /* Norway */
COUNTRY_CHPLAN_ENT("NP", 0x06, 0x00, DEF , 1, 1), /* Nepal */
COUNTRY_CHPLAN_ENT("NR", 0x3A, 0x00, DEF , 1, 1), /* Nauru */
COUNTRY_CHPLAN_ENT("NU", 0x03, 0x00, DEF , 1, 1), /* Niue */
COUNTRY_CHPLAN_ENT("NZ", 0x03, 0x00, DEF , 1, 1), /* New Zealand */
COUNTRY_CHPLAN_ENT("OM", 0x5E, 0x00, DEF , 1, 1), /* Oman */
COUNTRY_CHPLAN_ENT("PA", 0x76, 0x00, DEF , 1, 1), /* Panama */
COUNTRY_CHPLAN_ENT("PE", 0x76, 0x00, DEF , 1, 1), /* Peru */
COUNTRY_CHPLAN_ENT("PF", 0x3A, 0x00, DEF , 1, 1), /* French Polynesia (France) */
COUNTRY_CHPLAN_ENT("PG", 0x5E, 0x00, DEF , 1, 1), /* Papua New Guinea */
COUNTRY_CHPLAN_ENT("PH", 0x5E, 0x00, DEF , 1, 1), /* Philippines */
COUNTRY_CHPLAN_ENT("PK", 0x51, 0x00, DEF , 1, 1), /* Pakistan */
COUNTRY_CHPLAN_ENT("PL", 0x5E, 0x00, DEF , 1, 1), /* Poland */
COUNTRY_CHPLAN_ENT("PM", 0x3A, 0x00, DEF , 1, 1), /* Saint Pierre and Miquelon (France) */
COUNTRY_CHPLAN_ENT("PR", 0x76, 0x00, DEF , 1, 1), /* Puerto Rico */
COUNTRY_CHPLAN_ENT("PS", 0x5E, 0x00, DEF , 1, 1), /* Palestine */
COUNTRY_CHPLAN_ENT("PT", 0x5E, 0x00, DEF , 1, 1), /* Portugal */
COUNTRY_CHPLAN_ENT("PW", 0x76, 0x00, DEF , 1, 1), /* Palau */
COUNTRY_CHPLAN_ENT("PY", 0x76, 0x00, DEF , 1, 1), /* Paraguay */
COUNTRY_CHPLAN_ENT("QA", 0x5E, 0x00, QATAR , 1, 1), /* Qatar */
COUNTRY_CHPLAN_ENT("RE", 0x3A, 0x00, DEF , 1, 1), /* Reunion (France) */
COUNTRY_CHPLAN_ENT("RO", 0x5E, 0x00, DEF , 1, 1), /* Romania */
COUNTRY_CHPLAN_ENT("RS", 0x5E, 0x00, DEF , 1, 1), /* Serbia */
COUNTRY_CHPLAN_ENT("RU", 0x09, 0x00, DEF , 1, 1), /* Russia(fac/gost), Kaliningrad */
COUNTRY_CHPLAN_ENT("RW", 0x5E, 0x00, DEF , 1, 1), /* Rwanda */
COUNTRY_CHPLAN_ENT("SA", 0x5E, 0x00, DEF , 1, 1), /* Saudi Arabia */
COUNTRY_CHPLAN_ENT("SB", 0x3A, 0x00, DEF , 1, 1), /* Solomon Islands */
COUNTRY_CHPLAN_ENT("SC", 0x76, 0x00, DEF , 1, 1), /* Seychelles */
COUNTRY_CHPLAN_ENT("SE", 0x5E, 0x00, DEF , 1, 1), /* Sweden */
COUNTRY_CHPLAN_ENT("SG", 0x5E, 0x00, DEF , 1, 1), /* Singapore */
COUNTRY_CHPLAN_ENT("SH", 0x3A, 0x00, DEF , 1, 1), /* Saint Helena (UK) */
COUNTRY_CHPLAN_ENT("SI", 0x5E, 0x00, DEF , 1, 1), /* Slovenia */
COUNTRY_CHPLAN_ENT("SJ", 0x3A, 0x00, DEF , 1, 1), /* Svalbard (Norway) */
COUNTRY_CHPLAN_ENT("SK", 0x5E, 0x00, DEF , 1, 1), /* Slovakia */
COUNTRY_CHPLAN_ENT("SL", 0x5E, 0x00, DEF , 1, 1), /* Sierra Leone */
COUNTRY_CHPLAN_ENT("SM", 0x3A, 0x00, DEF , 1, 1), /* San Marino */
COUNTRY_CHPLAN_ENT("SN", 0x3A, 0x00, DEF , 1, 1), /* Senegal */
COUNTRY_CHPLAN_ENT("SO", 0x3A, 0x00, DEF , 1, 1), /* Somalia */
COUNTRY_CHPLAN_ENT("SR", 0x74, 0x00, DEF , 1, 1), /* Suriname */
COUNTRY_CHPLAN_ENT("ST", 0x76, 0x00, DEF , 1, 1), /* Sao Tome and Principe */
COUNTRY_CHPLAN_ENT("SV", 0x76, 0x00, DEF , 1, 1), /* El Salvador */
COUNTRY_CHPLAN_ENT("SX", 0x76, 0x00, DEF , 1, 1), /* Sint Marteen */
COUNTRY_CHPLAN_ENT("SZ", 0x5E, 0x00, DEF , 1, 1), /* Swaziland */
COUNTRY_CHPLAN_ENT("TC", 0x3A, 0x00, DEF , 1, 1), /* Turks and Caicos Islands (UK) */
COUNTRY_CHPLAN_ENT("TD", 0x3A, 0x00, DEF , 1, 1), /* Chad */
COUNTRY_CHPLAN_ENT("TF", 0x3A, 0x00, DEF , 1, 1), /* French Southern and Antarctic Lands (FR Southern Territories) */
COUNTRY_CHPLAN_ENT("TG", 0x5E, 0x00, DEF , 1, 1), /* Togo */
COUNTRY_CHPLAN_ENT("TH", 0x5E, 0x00, DEF , 1, 1), /* Thailand */
COUNTRY_CHPLAN_ENT("TJ", 0x5E, 0x00, DEF , 1, 1), /* Tajikistan */
COUNTRY_CHPLAN_ENT("TK", 0x03, 0x00, DEF , 1, 1), /* Tokelau */
COUNTRY_CHPLAN_ENT("TM", 0x3A, 0x00, DEF , 1, 1), /* Turkmenistan */
COUNTRY_CHPLAN_ENT("TN", 0x04, 0x00, DEF , 1, 1), /* Tunisia */
COUNTRY_CHPLAN_ENT("TO", 0x3A, 0x00, DEF , 1, 1), /* Tonga */
COUNTRY_CHPLAN_ENT("TR", 0x5E, 0x00, DEF , 1, 1), /* Turkey, Northern Cyprus */
COUNTRY_CHPLAN_ENT("TT", 0x76, 0x00, DEF , 1, 1), /* Trinidad & Tobago */
COUNTRY_CHPLAN_ENT("TV", 0x21, 0x00, DEF , 0, 0), /* Tuvalu */
COUNTRY_CHPLAN_ENT("TW", 0x76, 0x00, DEF , 1, 1), /* Taiwan */
COUNTRY_CHPLAN_ENT("TZ", 0x5E, 0x00, DEF , 1, 1), /* Tanzania */
COUNTRY_CHPLAN_ENT("UA", 0x5E, 0x00, UKRAINE, 1, 1), /* Ukraine */
COUNTRY_CHPLAN_ENT("UG", 0x3A, 0x00, DEF , 1, 1), /* Uganda */
COUNTRY_CHPLAN_ENT("US", 0x76, 0x7F, DEF , 1, 1), /* United States of America (USA) */
COUNTRY_CHPLAN_ENT("UY", 0x30, 0x00, DEF , 1, 1), /* Uruguay */
COUNTRY_CHPLAN_ENT("UZ", 0x3C, 0x00, DEF , 1, 1), /* Uzbekistan */
COUNTRY_CHPLAN_ENT("VA", 0x3A, 0x00, DEF , 1, 1), /* Holy See (Vatican City) */
COUNTRY_CHPLAN_ENT("VC", 0x76, 0x00, DEF , 1, 1), /* Saint Vincent and the Grenadines */
COUNTRY_CHPLAN_ENT("VE", 0x30, 0x00, DEF , 1, 1), /* Venezuela */
COUNTRY_CHPLAN_ENT("VG", 0x76, 0x00, DEF , 1, 1), /* British Virgin Islands (UK) */
COUNTRY_CHPLAN_ENT("VI", 0x76, 0x00, DEF , 1, 1), /* United States Virgin Islands (USA) */
COUNTRY_CHPLAN_ENT("VN", 0x5E, 0x00, DEF , 1, 1), /* Vietnam */
COUNTRY_CHPLAN_ENT("VU", 0x26, 0x00, DEF , 1, 1), /* Vanuatu */
COUNTRY_CHPLAN_ENT("WF", 0x3A, 0x00, DEF , 1, 1), /* Wallis and Futuna (France) */
COUNTRY_CHPLAN_ENT("WS", 0x76, 0x00, DEF , 1, 1), /* Samoa */
COUNTRY_CHPLAN_ENT("XK", 0x3A, 0x00, DEF , 1, 1), /* Kosovo */
COUNTRY_CHPLAN_ENT("YE", 0x3A, 0x00, DEF , 1, 1), /* Yemen */
COUNTRY_CHPLAN_ENT("YT", 0x5E, 0x00, DEF , 1, 1), /* Mayotte (France) */
COUNTRY_CHPLAN_ENT("ZA", 0x5E, 0x00, DEF , 1, 1), /* South Africa */
COUNTRY_CHPLAN_ENT("ZM", 0x5E, 0x00, DEF , 1, 1), /* Zambia */
COUNTRY_CHPLAN_ENT("ZW", 0x5E, 0x00, DEF , 1, 1), /* Zimbabwe */
};
#endif /* CONFIG_CUSTOMIZED_COUNTRY_CHPLAN_MAP or RTW_DEF_MODULE_REGULATORY_CERT or newest */
/*
* rtw_get_chplan_worldwide -
* @ent: the buf to copy country_chplan entry content
*/
void rtw_get_chplan_worldwide(struct country_chplan *ent)
{
_rtw_memcpy(ent, &world_wide_chplan, sizeof(*ent));
}
/*
* rtw_get_chplan_from_country -
* @country_code: string of country code
* @ent: the buf to copy country_chplan entry content
*
* Return _TRUE or _FALSE when unsupported country_code is given
*/
bool rtw_get_chplan_from_country(const char *country_code, struct country_chplan *ent)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
struct country_chplan phl_ent = {.alpha2 = "\0\0"};
#endif
const struct country_chplan *map = NULL;
u16 map_sz = 0;
char code[2];
int i;
code[0] = alpha_to_upper(country_code[0]);
code[1] = alpha_to_upper(country_code[1]);
#ifdef CONFIG_CUSTOMIZED_COUNTRY_CHPLAN_MAP
map = CUSTOMIZED_country_chplan_map;
map_sz = sizeof(CUSTOMIZED_country_chplan_map) / sizeof(struct country_chplan);
#elif RTW_DEF_MODULE_REGULATORY_CERT
map_sz = rtw_def_module_country_chplan_map(&map);
#else
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
{
struct rtw_regulation_country_chplan plan;
_rtw_memset(&plan, 0, sizeof(plan));
if (rtw_phl_query_country_chplan(code, &plan)) {
_rtw_memcpy(phl_ent.alpha2, code, 2);
phl_ent.chplan = plan.domain_code;
#if CONFIG_IEEE80211_BAND_6GHZ
phl_ent.chplan_6g = RTW_CHPLAN_6G_NULL; /* TODO: get from PHL */
#endif
phl_ent.edcca_mode_2g_override = RTW_EDCCA_DEF;
#if CONFIG_IEEE80211_BAND_5GHZ
phl_ent.edcca_mode_5g_override = RTW_EDCCA_DEF;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
phl_ent.edcca_mode_6g_override = RTW_EDCCA_DEF;
#endif
phl_ent.txpwr_lmt_override = phl_tpo_to_txpwr_lmt(plan.tpo);
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
phl_ent.proto_en = 0
| ((plan.support_mode & SUPPORT_11AC) ? CHPLAN_PROTO_EN_AC : 0)
| ((plan.support_mode & SUPPORT_11AX) ? CHPLAN_PROTO_EN_AX : 0)
;
#endif
map = &phl_ent;
map_sz = 1;
}
}
#else
map = country_chplan_map;
map_sz = sizeof(country_chplan_map) / sizeof(struct country_chplan);
#endif
#endif
for (i = 0; i < map_sz; i++) {
if (strncmp(code, map[i].alpha2, 2) == 0) {
if (ent)
_rtw_memcpy(ent, &map[i], sizeof(*ent));
return _TRUE;
}
}
return _FALSE;
}
void rtw_chplan_ioctl_input_mapping(u16 *chplan, u16 *chplan_6g)
{
if (chplan) {
if (*chplan == RTW_CHPLAN_IOCTL_UNSPECIFIED)
*chplan = RTW_CHPLAN_UNSPECIFIED;
else if (*chplan == RTW_CHPLAN_IOCTL_NULL)
*chplan = RTW_CHPLAN_NULL;
}
if (chplan_6g) {
if (*chplan_6g == RTW_CHPLAN_IOCTL_UNSPECIFIED)
*chplan_6g = RTW_CHPLAN_6G_UNSPECIFIED;
else if (*chplan_6g == RTW_CHPLAN_IOCTL_NULL)
*chplan_6g = RTW_CHPLAN_6G_NULL;
}
}
bool rtw_chplan_ids_is_world_wide(u8 chplan, u8 chplan_6g)
{
return !(chplan == RTW_CHPLAN_NULL
#if CONFIG_IEEE80211_BAND_6GHZ
&& chplan_6g == RTW_CHPLAN_6G_NULL
#endif
)
&& (chplan == RTW_CHPLAN_WORLDWIDE || chplan == RTW_CHPLAN_NULL)
#if CONFIG_IEEE80211_BAND_6GHZ
&& (chplan_6g == RTW_CHPLAN_6G_WORLDWIDE || chplan_6g == RTW_CHPLAN_6G_NULL)
#endif
;
}
/*
* Check if the @param ch, bw, offset is valid for the given @param ent
* @ch_set: the given channel set
* @ch: the given channel number
* @bw: the given bandwidth
* @offset: the given channel offset
*
* return valid (1) or not (0)
*/
u8 rtw_country_chplan_is_chbw_valid(struct country_chplan *ent, enum band_type band, u8 ch, u8 bw, u8 offset
, bool allow_primary_passive, bool allow_passive, struct registry_priv *regsty)
{
u8 chplan_6g = RTW_CHPLAN_6G_NULL;
u8 valid = 0;
if (bw >= CHANNEL_WIDTH_80 && !COUNTRY_CHPLAN_EN_11AC(ent))
goto exit;
#if CONFIG_IEEE80211_BAND_6GHZ
chplan_6g = ent->chplan_6g;
#endif
valid = rtw_chplan_is_chbw_valid(ent->chplan, chplan_6g, band, ch, bw, offset
, allow_primary_passive, allow_passive, regsty);
exit:
return valid;
}
static void rtw_country_chplan_get_edcca_modes(const struct country_chplan *ent, u8 modes[])
{
modes[BAND_ON_24G] =
ent->edcca_mode_2g_override != RTW_EDCCA_DEF ? ent->edcca_mode_2g_override :
rtw_regd_to_edcca_mode(rtw_chplan_get_default_regd_2g(ent->chplan));
#if CONFIG_IEEE80211_BAND_5GHZ
modes[BAND_ON_5G] =
ent->edcca_mode_5g_override != RTW_EDCCA_DEF ? ent->edcca_mode_5g_override :
rtw_regd_to_edcca_mode(rtw_chplan_get_default_regd_5g(ent->chplan));
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
modes[BAND_ON_6G] =
ent->edcca_mode_6g_override != RTW_EDCCA_DEF ? ent->edcca_mode_6g_override :
rtw_regd_to_edcca_mode(rtw_chplan_get_default_regd_6g(ent->chplan_6g));
#endif
}
static void rtw_country_chplan_get_txpwr_lmts(const struct country_chplan *ent, u8 txpwr_lmt[])
{
txpwr_lmt[BAND_ON_24G] =
ent->txpwr_lmt_override != TXPWR_LMT_DEF ? ent->txpwr_lmt_override :
rtw_regd_to_txpwr_lmt(rtw_chplan_get_default_regd_2g(ent->chplan));
#if CONFIG_IEEE80211_BAND_5GHZ
txpwr_lmt[BAND_ON_5G] =
ent->txpwr_lmt_override != TXPWR_LMT_DEF ? ent->txpwr_lmt_override :
rtw_regd_to_txpwr_lmt(rtw_chplan_get_default_regd_5g(ent->chplan));
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
txpwr_lmt[BAND_ON_6G] =
ent->txpwr_lmt_override != TXPWR_LMT_DEF ? ent->txpwr_lmt_override :
rtw_regd_to_txpwr_lmt(rtw_chplan_get_default_regd_6g(ent->chplan_6g));
#endif
}
#ifdef CONFIG_80211D
const char *const _cis_status_str[] = {
[COUNTRY_IE_SLAVE_NOCOUNTRY] = "NOCOUNTRY",
[COUNTRY_IE_SLAVE_UNKNOWN] = "UNKNOWN",
[COUNTRY_IE_SLAVE_OPCH_NOEXIST] = "OPCH_NOEXIST",
[COUNTRY_IE_SLAVE_APPLICABLE] = "APPLICABLE",
[COUNTRY_IE_SLAVE_STATUS_NUM] = "INVALID",
};
void dump_country_ie_slave_records(void *sel, struct rf_ctl_t *rfctl, bool skip_noset)
{
int i;
RTW_PRINT_SEL(sel, " %-6s %-4s %-4s %s\n", "alpha2", "band", "opch", "status");
for (i = 0; i < CONFIG_IFACE_NUMBER; i++) {
if (skip_noset && strncmp(rfctl->cisr[i].alpha2, "\x00\x00", 2) == 0)
continue;
RTW_PRINT_SEL(sel, "%c%d "ALPHA2_FMT" %4s %4u %s\n"
, i == rfctl->effected_cisr_id ? '*' : ' ', i, ALPHA2_ARG(rfctl->cisr[i].alpha2)
, band_str(rfctl->cisr[i].band), rfctl->cisr[i].opch, cis_status_str(rfctl->cisr[i].status));
}
}
enum country_ie_slave_status rtw_get_chplan_from_recv_country_ie(_adapter *adapter
, enum band_type band, u8 opch, const u8 *country_ie, struct country_chplan *ent
, struct country_ie_slave_record *cisr, const char *caller_msg)
{
struct registry_priv *regsty = adapter_to_regsty(adapter);
const char *country_code = country_ie ? country_ie + 2 : NULL;
u8 chplan_6g = RTW_CHPLAN_6G_NULL;
enum country_ie_slave_status ret;
_rtw_memset(ent, 0, sizeof(*ent));
if (!country_code || strncmp(country_code, "XX", 2) == 0) {
if (caller_msg && country_code)
RTW_INFO("%s("ADPT_FMT") noncountry \"XX\"\n", caller_msg, ADPT_ARG(adapter));
ret = COUNTRY_IE_SLAVE_NOCOUNTRY;
goto exit;
}
if (!rtw_get_chplan_from_country(country_code, ent)) {
if (caller_msg) {
if (is_alpha(country_code[0]) == _FALSE || is_alpha(country_code[1]) == _FALSE) {
RTW_INFO("%s("ADPT_FMT") country_code is not alpha2, use world wide instead\n"
, caller_msg, ADPT_ARG(adapter));
} else {
RTW_INFO("%s("ADPT_FMT") unsupported country_code:\"%c%c\", use world wide\n"
, caller_msg, ADPT_ARG(adapter), country_code[0], country_code[1]);
}
}
rtw_get_chplan_worldwide(ent);
ret = COUNTRY_IE_SLAVE_UNKNOWN;
goto exit;
}
#if CONFIG_IEEE80211_BAND_6GHZ
chplan_6g = ent->chplan_6g;
#endif
if (!rtw_chplan_is_chbw_valid(ent->chplan, chplan_6g, band, opch
, CHANNEL_WIDTH_20, CHAN_OFFSET_NO_EXT, 1, 1, regsty)
) {
u8 edcca_modes[BAND_MAX];
if (caller_msg) {
RTW_INFO("%s("ADPT_FMT") \"%c%c\" no band:%s ch:%u, use world wide with ori edcca modes\n"
, caller_msg, ADPT_ARG(adapter), country_code[0], country_code[1], band_str(band), opch);
}
rtw_country_chplan_get_edcca_modes(ent, edcca_modes);
rtw_get_chplan_worldwide(ent);
ent->edcca_mode_2g_override = edcca_modes[BAND_ON_24G];
#if CONFIG_IEEE80211_BAND_5GHZ
ent->edcca_mode_5g_override = edcca_modes[BAND_ON_5G];
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
ent->edcca_mode_6g_override = edcca_modes[BAND_ON_6G];
#endif
ret = COUNTRY_IE_SLAVE_OPCH_NOEXIST;
goto exit;
}
if (caller_msg) {
RTW_INFO("%s("ADPT_FMT") country_code:\"%c%c\" is applicapble\n"
, caller_msg, ADPT_ARG(adapter), country_code[0], country_code[1]);
}
ret = COUNTRY_IE_SLAVE_APPLICABLE;
exit:
if (cisr) {
_rtw_memcpy(cisr->alpha2, country_code ? country_code : "\x00\x00", 2);
cisr->band = band;
cisr->opch = opch;
cisr->status = ret;
}
return ret;
}
enum country_ie_slave_status rtw_get_chplan_from_cisrs(struct rf_ctl_t *rfctl
, struct country_chplan *ent, const char *caller_msg)
{
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
_adapter *adapter = dvobj->padapters[rfctl->effected_cisr_id];
struct country_ie_slave_record *cisr = &rfctl->cisr[rfctl->effected_cisr_id];
const u8 country_ie[4] = {WLAN_EID_COUNTRY, 2, cisr->alpha2[0], cisr->alpha2[1]};
enum country_ie_slave_status status;
status = rtw_get_chplan_from_recv_country_ie(adapter, cisr->band, cisr->opch, country_ie, ent, NULL, caller_msg);
rtw_warn_on(cisr->status != status);
return status;
}
#endif /* CONFIG_80211D */
void dump_country_chplan(void *sel, const struct country_chplan *ent, bool regd_info)
{
char buf[16];
char *pos = buf;
if (ent->chplan == RTW_CHPLAN_UNSPECIFIED)
pos += sprintf(pos, "NA");
else
pos += sprintf(pos, "0x%02X", ent->chplan);
#if CONFIG_IEEE80211_BAND_6GHZ
if (ent->chplan_6g == RTW_CHPLAN_6G_UNSPECIFIED)
pos += sprintf(pos, " NA");
else
pos += sprintf(pos, " 0x%02X", ent->chplan_6g);
#endif
RTW_PRINT_SEL(sel, "\"%c%c\", %s"
, ent->alpha2[0], ent->alpha2[1], buf);
if (regd_info) {
u8 edcca_modes[BAND_MAX];
u8 txpwr_lmts[BAND_MAX];
rtw_country_chplan_get_edcca_modes(ent, edcca_modes);
_RTW_PRINT_SEL(sel, " {%-6s", rtw_edcca_mode_str(edcca_modes[BAND_ON_24G]));
#if CONFIG_IEEE80211_BAND_5GHZ
_RTW_PRINT_SEL(sel, " %-6s", rtw_edcca_mode_str(edcca_modes[BAND_ON_5G]));
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
_RTW_PRINT_SEL(sel, " %-6s", rtw_edcca_mode_str(edcca_modes[BAND_ON_6G]));
#endif
_RTW_PRINT_SEL(sel, "}");
rtw_country_chplan_get_txpwr_lmts(ent, txpwr_lmts);
_RTW_PRINT_SEL(sel, " {%-7s", txpwr_lmt_str(txpwr_lmts[BAND_ON_24G]));
#if CONFIG_IEEE80211_BAND_5GHZ
_RTW_PRINT_SEL(sel, " %-7s", txpwr_lmt_str(txpwr_lmts[BAND_ON_5G]));
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
_RTW_PRINT_SEL(sel, " %-7s", txpwr_lmt_str(txpwr_lmts[BAND_ON_6G]));
#endif
_RTW_PRINT_SEL(sel, "}");
}
_RTW_PRINT_SEL(sel, " %s", COUNTRY_CHPLAN_EN_11AX(ent) ? "ax" : " ");
_RTW_PRINT_SEL(sel, " %s", COUNTRY_CHPLAN_EN_11AC(ent) ? "ac" : " ");
_RTW_PRINT_SEL(sel, "\n");
}
void dump_country_chplan_map(void *sel, bool regd_info)
{
struct country_chplan ent;
u8 code[2];
#if RTW_DEF_MODULE_REGULATORY_CERT
RTW_PRINT_SEL(sel, "RTW_DEF_MODULE_REGULATORY_CERT:0x%x\n", RTW_DEF_MODULE_REGULATORY_CERT);
#endif
#ifdef CONFIG_CUSTOMIZED_COUNTRY_CHPLAN_MAP
RTW_PRINT_SEL(sel, "CONFIG_CUSTOMIZED_COUNTRY_CHPLAN_MAP\n");
#endif
rtw_get_chplan_worldwide(&ent);
dump_country_chplan(sel, &ent, regd_info);
for (code[0] = 'A'; code[0] <= 'Z'; code[0]++) {
for (code[1] = 'A'; code[1] <= 'Z'; code[1]++) {
if (rtw_get_chplan_from_country(code, &ent) == _FALSE)
continue;
dump_country_chplan(sel, &ent, regd_info);
}
}
}
void dump_country_list(void *sel)
{
u8 code[2];
RTW_PRINT_SEL(sel, "%s ", WORLDWIDE_ALPHA2);
for (code[0] = 'A'; code[0] <= 'Z'; code[0]++) {
for (code[1] = 'A'; code[1] <= 'Z'; code[1]++) {
if (!rtw_get_chplan_from_country(code, NULL))
continue;
_RTW_PRINT_SEL(sel, "%c%c ", code[0], code[1]);
}
}
_RTW_PRINT_SEL(sel, "\n");
}
void dump_chplan_id_list(void *sel)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
u8 id_search_max = 255;
#else
u8 id_search_max = RTW_ChannelPlanMap_size - 1;
#endif
u8 first = 1;
int i;
for (i = 0; i <= id_search_max; i++) {
if (!rtw_is_channel_plan_valid(i))
continue;
if (first) {
RTW_PRINT_SEL(sel, "0x%02X ", i);
first = 0;
} else
_RTW_PRINT_SEL(sel, "0x%02X ", i);
}
if (first == 0)
_RTW_PRINT_SEL(sel, "\n");
}
void dump_chplan_country_list(void *sel)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
u8 id_search_max = 255;
#else
u8 id_search_max = RTW_ChannelPlanMap_size - 1;
#endif
int i;
for (i = 0; i <= id_search_max; i++) {
struct country_chplan ent;
u8 code[2];
u8 first;
if (!rtw_is_channel_plan_valid(i))
continue;
first = 1;
for (code[0] = 'A'; code[0] <= 'Z'; code[0]++) {
for (code[1] = 'A'; code[1] <= 'Z'; code[1]++) {
if (!rtw_get_chplan_from_country(code, &ent) || ent.chplan != i)
continue;
if (first) {
RTW_PRINT_SEL(sel, "0x%02X %c%c ", i, code[0], code[1]);
first = 0;
} else
_RTW_PRINT_SEL(sel, "%c%c ", code[0], code[1]);
}
}
if (first == 0)
_RTW_PRINT_SEL(sel, "\n");
}
}
#if CONFIG_IEEE80211_BAND_6GHZ
void dump_chplan_6g_id_list(void *sel)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
u8 id_search_max = 255;
#else
u8 id_search_max = rtw_chplan_6g_map_size - 1;
#endif
u8 first = 1;
int i;
for (i = 0; i <= id_search_max; i++) {
if (!rtw_is_channel_plan_6g_valid(i))
continue;
if (first) {
RTW_PRINT_SEL(sel, "0x%02X ", i);
first = 0;
} else
_RTW_PRINT_SEL(sel, "0x%02X ", i);
}
if (first == 0)
_RTW_PRINT_SEL(sel, "\n");
}
void dump_chplan_6g_country_list(void *sel)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
u8 id_search_max = 255;
#else
u8 id_search_max = rtw_chplan_6g_map_size - 1;
#endif
int i;
for (i = 0; i <= id_search_max; i++) {
struct country_chplan ent;
u8 code[2];
u8 first;
if (!rtw_is_channel_plan_6g_valid(i))
continue;
first = 1;
for (code[0] = 'A'; code[0] <= 'Z'; code[0]++) {
for (code[1] = 'A'; code[1] <= 'Z'; code[1]++) {
if (!rtw_get_chplan_from_country(code, &ent) || ent.chplan_6g != i)
continue;
if (first) {
RTW_PRINT_SEL(sel, "0x%02X %c%c ", i, code[0], code[1]);
first = 0;
} else
_RTW_PRINT_SEL(sel, "%c%c ", code[0], code[1]);
}
}
if (first == 0)
_RTW_PRINT_SEL(sel, "\n");
}
}
#endif /* CONFIG_IEEE80211_BAND_6GHZ */
#ifdef CONFIG_RTW_DEBUG
void dump_chplan_test(void *sel)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
#else
int i, j;
/* check 2G CHD redundent */
for (i = RTW_CHD_2G_00; i < RTW_CHD_2G_MAX; i++) {
for (j = RTW_CHD_2G_00; j < i; j++) {
if (CH_LIST_LEN(rtw_channel_def_2g[i]) == CH_LIST_LEN(rtw_channel_def_2g[j])
&& _rtw_memcmp(&CH_LIST_CH(rtw_channel_def_2g[i], 0), &CH_LIST_CH(rtw_channel_def_2g[j], 0), CH_LIST_LEN(rtw_channel_def_2g[i]) + 1) == _TRUE)
RTW_PRINT_SEL(sel, "2G chd:%u and %u is the same\n", i, j);
}
}
/* check 2G CHD invalid channel */
for (i = RTW_CHD_2G_00; i < RTW_CHD_2G_MAX; i++) {
for (j = 0; j < CH_LIST_LEN(rtw_channel_def_2g[i]); j++) {
if (rtw_ch2freq(CH_LIST_CH(rtw_channel_def_2g[i], j)) == 0)
RTW_PRINT_SEL(sel, "2G invalid ch:%u at (%d,%d)\n", CH_LIST_CH(rtw_channel_def_2g[i], j), i, j);
}
}
#if CONFIG_IEEE80211_BAND_5GHZ
/* check 5G CHD redundent */
for (i = RTW_CHD_5G_00; i < RTW_CHD_5G_MAX; i++) {
for (j = RTW_CHD_5G_00; j < i; j++) {
if (CH_LIST_LEN(rtw_channel_def_5g[i]) == CH_LIST_LEN(rtw_channel_def_5g[j])
&& _rtw_memcmp(&CH_LIST_CH(rtw_channel_def_5g[i], 0), &CH_LIST_CH(rtw_channel_def_5g[j], 0), CH_LIST_LEN(rtw_channel_def_5g[i]) + 1) == _TRUE)
RTW_PRINT_SEL(sel, "5G chd:%u and %u is the same\n", i, j);
}
}
/* check 5G CHD invalid channel */
for (i = RTW_CHD_5G_00; i < RTW_CHD_5G_MAX; i++) {
for (j = 0; j < CH_LIST_LEN(rtw_channel_def_5g[i]); j++) {
if (rtw_ch2freq(CH_LIST_CH(rtw_channel_def_5g[i], j)) == 0)
RTW_PRINT_SEL(sel, "5G invalid ch:%u at (%d,%d)\n", CH_LIST_CH(rtw_channel_def_5g[i], j), i, j);
}
}
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
/* check 6G CHD redundent */
for (i = RTW_CHD_6G_00; i < RTW_CHD_6G_MAX; i++) {
for (j = RTW_CHD_6G_00; j < i; j++) {
if (CH_LIST_LEN(rtw_channel_def_6g[i]) == CH_LIST_LEN(rtw_channel_def_6g[j])
&& _rtw_memcmp(&CH_LIST_CH(rtw_channel_def_6g[i], 0), &CH_LIST_CH(rtw_channel_def_6g[j], 0), CH_LIST_LEN(rtw_channel_def_6g[i]) + 1) == _TRUE)
RTW_PRINT_SEL(sel, "6G chd:%u and %u is the same\n", i, j);
}
}
/* check 6G CHD invalid channel */
for (i = RTW_CHD_6G_00; i < RTW_CHD_6G_MAX; i++) {
for (j = 0; j < CH_LIST_LEN(rtw_channel_def_6g[i]); j++) {
if (rtw_6gch2freq(CH_LIST_CH(rtw_channel_def_6g[i], j)) == 0)
RTW_PRINT_SEL(sel, "6G invalid ch:%u at (%d,%d)\n", CH_LIST_CH(rtw_channel_def_6g[i], j), i, j);
}
}
#endif
/* check chplan 2G_5G redundent */
for (i = 0; i < RTW_ChannelPlanMap_size; i++) {
if (!rtw_is_channel_plan_valid(i))
continue;
for (j = 0; j < i; j++) {
if (!rtw_is_channel_plan_valid(j))
continue;
if (_rtw_memcmp(&RTW_ChannelPlanMap[i], &RTW_ChannelPlanMap[j], sizeof(RTW_ChannelPlanMap[i])) == _TRUE)
RTW_PRINT_SEL(sel, "channel plan 0x%02x and 0x%02x is the same\n", i, j);
}
}
#if CONFIG_IEEE80211_BAND_6GHZ
/* check chplan 6G redundent */
for (i = 0; i < rtw_chplan_6g_map_size; i++) {
if (!rtw_is_channel_plan_6g_valid(i))
continue;
for (j = 0; j < i; j++) {
if (!rtw_is_channel_plan_6g_valid(j))
continue;
if (_rtw_memcmp(&rtw_chplan_6g_map[i], &rtw_chplan_6g_map[j], sizeof(rtw_chplan_6g_map[i])) == _TRUE)
RTW_PRINT_SEL(sel, "channel plan 6g 0x%02x and 0x%02x is the same\n", i, j);
}
}
#endif
/* check country invalid chplan/chplan_6g */
{
struct country_chplan ent;
u8 code[2];
for (code[0] = 'A'; code[0] <= 'Z'; code[0]++) {
for (code[1] = 'A'; code[1] <= 'Z'; code[1]++) {
if (!rtw_get_chplan_from_country(code, &ent))
continue;
if (!rtw_is_channel_plan_valid(ent.chplan))
RTW_PRINT_SEL(sel, "country \"%c%c\" has invalid chplan:0x%02X\n", code[0], code[1], ent.chplan);
#if CONFIG_IEEE80211_BAND_6GHZ
if (!rtw_is_channel_plan_6g_valid(ent.chplan_6g))
RTW_PRINT_SEL(sel, "country \"%c%c\" has invalid chplan_6g:0x%02X\n", code[0], code[1], ent.chplan_6g);
#endif
}
}
}
#endif
}
#endif /* CONFIG_RTW_DEBUG */
void dump_chplan_ver(void *sel)
{
#if defined(PHL_FEATURE_NIC) && !USE_RTW_REGD
struct rtw_regulation_info info = {0};
if (!rtw_phl_query_regulation_info(phl_info, &info)) {
RTW_PRINT_SEL(sel, "query chplan version fail\n");
return;
}
RTW_PRINT_SEL(sel, "%d-%d\n", info.chplan_ver, info.country_ver);
#else
RTW_PRINT_SEL(sel, "%s%s-%s\n", RTW_DOMAIN_MAP_VER, RTW_DOMAIN_MAP_M_VER, RTW_COUNTRY_MAP_VER);
#endif
}
void rtw_set_phl_regulation_ctx(struct dvobj_priv *dvobj)
{
#ifdef PHL_FEATURE_NIC
if (!phl_info)
phl_info = GET_PHL_INFO(dvobj);
#endif
}
void rtw_clear_phl_regulation_ctx(struct dvobj_priv *dvobj)
{
#ifdef PHL_FEATURE_NIC
if (phl_info == GET_PHL_INFO(dvobj))
phl_info = NULL;
#endif
}
|
2301_81045437/rtl8852be
|
core/rtw_chplan.c
|
C
|
agpl-3.0
| 164,190
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __RTW_CHPLAN_H__
#define __RTW_CHPLAN_H__
#define RTW_CHPLAN_IOCTL_NULL 0xFFFE /* special value by ioctl: null(empty) chplan */
#define RTW_CHPLAN_IOCTL_UNSPECIFIED 0xFFFF /* special value by ioctl: no change (keep original) */
#define RTW_CHPLAN_NULL 0x1A
#define RTW_CHPLAN_WORLDWIDE 0x7F
#define RTW_CHPLAN_UNSPECIFIED 0xFF
#define RTW_CHPLAN_6G_NULL 0x00
#define RTW_CHPLAN_6G_WORLDWIDE 0x7F
#define RTW_CHPLAN_6G_UNSPECIFIED 0xFF
u8 rtw_chplan_get_default_regd_2g(u8 id);
u8 rtw_chplan_get_default_regd_5g(u8 id);
bool rtw_is_channel_plan_valid(u8 id);
bool rtw_regsty_is_excl_chs(struct registry_priv *regsty, u8 ch);
#if CONFIG_IEEE80211_BAND_6GHZ
u8 rtw_chplan_get_default_regd_6g(u8 id);
bool rtw_is_channel_plan_6g_valid(u8 id);
bool rtw_regsty_is_excl_chs_6g(struct registry_priv *regsty, u8 ch);
#endif
u8 rtw_chplan_is_chbw_valid(u8 id, u8 id_6g, enum band_type band, u8 ch, u8 bw, u8 offset
, bool allow_primary_passive, bool allow_passive, struct registry_priv *regsty);
enum regd_src_t {
REGD_SRC_RTK_PRIV = 0, /* Regulatory settings from Realtek framework (Realtek defined or customized) */
REGD_SRC_OS = 1, /* Regulatory settings from OS */
REGD_SRC_NUM,
};
#define regd_src_is_valid(src) ((src) < REGD_SRC_NUM)
extern const char *_regd_src_str[];
#define regd_src_str(src) ((src) >= REGD_SRC_NUM ? _regd_src_str[REGD_SRC_NUM] : _regd_src_str[src])
struct _RT_CHANNEL_INFO;
u8 init_channel_set(_adapter *adapter);
bool rtw_chset_is_dfs_range(struct _RT_CHANNEL_INFO *chset, u32 hi, u32 lo);
bool rtw_chset_is_dfs_ch(struct _RT_CHANNEL_INFO *chset, u8 ch);
bool rtw_chset_is_dfs_chbw(struct _RT_CHANNEL_INFO *chset, u8 ch, u8 bw, u8 offset);
bool rtw_chinfo_allow_beacon_hint(struct _RT_CHANNEL_INFO *chinfo);
u8 rtw_process_beacon_hint(_adapter *adapter, WLAN_BSSID_EX *bss);
#define ALPHA2_FMT "%c%c"
#define ALPHA2_ARG(a2) ((is_alpha(a2[0]) || is_decimal(a2[0])) ? a2[0] : '-'), ((is_alpha(a2[1]) || is_decimal(a2[1])) ? a2[1] : '-')
#define WORLDWIDE_ALPHA2 "00"
#define UNSPEC_ALPHA2 "99"
#define IS_ALPHA2_WORLDWIDE(_alpha2) (strncmp(_alpha2, WORLDWIDE_ALPHA2, 2) == 0)
#define IS_ALPHA2_UNSPEC(_alpha2) (strncmp(_alpha2, UNSPEC_ALPHA2, 2) == 0)
#define SET_UNSPEC_ALPHA2(_alpha2) do { _rtw_memcpy(_alpha2, UNSPEC_ALPHA2, 2); } while (0)
#define RTW_MODULE_RTL8821AE_HMC_M2 BIT0 /* RTL8821AE(HMC + M.2) */
#define RTW_MODULE_RTL8821AU BIT1 /* RTL8821AU */
#define RTW_MODULE_RTL8812AENF_NGFF BIT2 /* RTL8812AENF(8812AE+8761)_NGFF */
#define RTW_MODULE_RTL8812AEBT_HMC BIT3 /* RTL8812AEBT(8812AE+8761)_HMC */
#define RTW_MODULE_RTL8188EE_HMC_M2 BIT4 /* RTL8188EE(HMC + M.2) */
#define RTW_MODULE_RTL8723BE_HMC_M2 BIT5 /* RTL8723BE(HMC + M.2) */
#define RTW_MODULE_RTL8723BS_NGFF1216 BIT6 /* RTL8723BS(NGFF1216) */
#define RTW_MODULE_RTL8192EEBT_HMC_M2 BIT7 /* RTL8192EEBT(8192EE+8761AU)_(HMC + M.2) */
#define RTW_MODULE_RTL8723DE_NGFF1630 BIT8 /* RTL8723DE(NGFF1630) */
#define RTW_MODULE_RTL8822BE BIT9 /* RTL8822BE */
#define RTW_MODULE_RTL8821CE BIT10 /* RTL8821CE */
enum rtw_regd_inr {
RTW_REGD_SET_BY_INIT = 0,
RTW_REGD_SET_BY_USER = 1,
RTW_REGD_SET_BY_COUNTRY_IE = 2,
/* below is not used for REGD_SRC_RTK_PRIV */
RTW_REGD_SET_BY_DRIVER = 3,
RTW_REGD_SET_BY_CORE = 4,
RTW_REGD_SET_BY_NUM,
};
extern const char *const _regd_inr_str[];
#define regd_inr_str(inr) (((inr) >= RTW_REGD_SET_BY_NUM) ? _regd_inr_str[RTW_REGD_SET_BY_NUM] : _regd_inr_str[(inr)])
enum rtw_regd {
RTW_REGD_NA = 0,
RTW_REGD_FCC = 1,
RTW_REGD_MKK = 2,
RTW_REGD_ETSI = 3,
RTW_REGD_IC = 4,
RTW_REGD_KCC = 5,
RTW_REGD_NCC = 6,
RTW_REGD_ACMA = 7,
RTW_REGD_CHILE = 8,
RTW_REGD_MEX = 9,
RTW_REGD_WW,
RTW_REGD_NUM,
};
extern const char *const _regd_str[];
#define regd_str(regd) (((regd) >= RTW_REGD_NUM) ? _regd_str[RTW_REGD_NA] : _regd_str[(regd)])
enum rtw_edcca_mode_t {
RTW_EDCCA_NORM = 0, /* normal */
RTW_EDCCA_ADAPT = 1, /* adaptivity */
RTW_EDCCA_CS = 2, /* carrier sense */
RTW_EDCCA_MODE_NUM,
RTW_EDCCA_DEF = RTW_EDCCA_MODE_NUM, /* default (ref to domain code), used at country chplan map's override field */
};
extern const char *const _rtw_edcca_mode_str[];
#define rtw_edcca_mode_str(mode) (((mode) >= RTW_EDCCA_MODE_NUM) ? _rtw_edcca_mode_str[RTW_EDCCA_NORM] : _rtw_edcca_mode_str[(mode)])
enum rtw_dfs_regd {
RTW_DFS_REGD_NONE = 0,
RTW_DFS_REGD_FCC = 1,
RTW_DFS_REGD_MKK = 2,
RTW_DFS_REGD_ETSI = 3,
RTW_DFS_REGD_NUM,
RTW_DFS_REGD_AUTO = 0xFF, /* follow channel plan */
};
extern const char *const _rtw_dfs_regd_str[];
#define rtw_dfs_regd_str(region) (((region) >= RTW_DFS_REGD_NUM) ? _rtw_dfs_regd_str[RTW_DFS_REGD_NONE] : _rtw_dfs_regd_str[(region)])
typedef enum _REGULATION_TXPWR_LMT {
TXPWR_LMT_NONE = 0, /* no limit */
TXPWR_LMT_FCC = 1,
TXPWR_LMT_MKK = 2,
TXPWR_LMT_ETSI = 3,
TXPWR_LMT_IC = 4,
TXPWR_LMT_KCC = 5,
TXPWR_LMT_NCC = 6,
TXPWR_LMT_ACMA = 7,
TXPWR_LMT_CHILE = 8,
TXPWR_LMT_UKRAINE = 9,
TXPWR_LMT_MEXICO = 10,
TXPWR_LMT_CN = 11,
TXPWR_LMT_QATAR = 12,
TXPWR_LMT_WW, /* smallest of all available limit, keep last */
TXPWR_LMT_NUM,
TXPWR_LMT_DEF = TXPWR_LMT_NUM, /* default (ref to domain code), used at country chplan map's override field */
} REGULATION_TXPWR_LMT;
extern const char *const _txpwr_lmt_str[];
#define txpwr_lmt_str(regd) (((regd) >= TXPWR_LMT_NUM) ? _txpwr_lmt_str[TXPWR_LMT_NUM] : _txpwr_lmt_str[(regd)])
extern const REGULATION_TXPWR_LMT _txpwr_lmt_alternate[];
#define txpwr_lmt_alternate(ori) (((ori) > TXPWR_LMT_NUM) ? _txpwr_lmt_alternate[TXPWR_LMT_WW] : _txpwr_lmt_alternate[(ori)])
#define TXPWR_LMT_ALTERNATE_DEFINED(txpwr_lmt) (txpwr_lmt_alternate(txpwr_lmt) != txpwr_lmt)
extern const enum rtw_edcca_mode_t _rtw_regd_to_edcca_mode[RTW_REGD_NUM];
#define rtw_regd_to_edcca_mode(regd) (((regd) >= RTW_REGD_NUM) ? RTW_EDCCA_NORM : _rtw_regd_to_edcca_mode[(regd)])
extern const REGULATION_TXPWR_LMT _rtw_regd_to_txpwr_lmt[];
#define rtw_regd_to_txpwr_lmt(regd) (((regd) >= RTW_REGD_NUM) ? TXPWR_LMT_WW : _rtw_regd_to_txpwr_lmt[(regd)])
#define EDCCA_MODES_STR_LEN (((6 + 3 + 1) * BAND_MAX) + 1)
char *rtw_get_edcca_modes_str(char *buf, u8 modes[]);
void rtw_edcca_mode_update(struct dvobj_priv *dvobj);
u8 rtw_get_edcca_mode(struct dvobj_priv *dvobj, enum band_type band);
#define TXPWR_NAMES_STR_LEN (((1 + 7 + 1) * BAND_MAX) + 1)
char *rtw_get_txpwr_lmt_names_str(char *buf, const char *names[], u8 unknown_bmp);
#define CHPLAN_PROTO_EN_AC BIT0
#define CHPLAN_PROTO_EN_AX BIT1
#define CHPLAN_PROTO_EN_ALL 0xFF
struct country_chplan {
char alpha2[2];
u8 chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
u8 chplan_6g;
#endif
u8 edcca_mode_2g_override:2;
#if CONFIG_IEEE80211_BAND_5GHZ
u8 edcca_mode_5g_override:2;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
u8 edcca_mode_6g_override:2;
#endif
u8 txpwr_lmt_override;
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
u8 proto_en;
#endif
};
#ifdef CONFIG_80211AC_VHT
#define COUNTRY_CHPLAN_EN_11AC(_ent) (((_ent)->proto_en & CHPLAN_PROTO_EN_AC) ? 1 : 0)
#else
#define COUNTRY_CHPLAN_EN_11AC(_ent) 0
#endif
#ifdef CONFIG_80211AX_HE
#define COUNTRY_CHPLAN_EN_11AX(_ent) (((_ent)->proto_en & CHPLAN_PROTO_EN_AX) ? 1 : 0)
#else
#define COUNTRY_CHPLAN_EN_11AX(_ent) 0
#endif
void rtw_get_chplan_worldwide(struct country_chplan *ent);
bool rtw_get_chplan_from_country(const char *country_code, struct country_chplan *ent);
void rtw_chplan_ioctl_input_mapping(u16 *chplan, u16 *chplan_6g);
bool rtw_chplan_ids_is_world_wide(u8 chplan, u8 chplan_6g);
u8 rtw_country_chplan_is_chbw_valid(struct country_chplan *ent, enum band_type band, u8 ch, u8 bw, u8 offset
, bool allow_primary_passive, bool allow_passive, struct registry_priv *regsty);
enum country_ie_slave_status {
COUNTRY_IE_SLAVE_NOCOUNTRY = 0,
COUNTRY_IE_SLAVE_UNKNOWN = 1,
COUNTRY_IE_SLAVE_OPCH_NOEXIST = 2,
COUNTRY_IE_SLAVE_APPLICABLE = 3,
COUNTRY_IE_SLAVE_STATUS_NUM,
};
struct country_ie_slave_record {
char alpha2[2]; /* country code get from connected AP of STA ifaces, "\x00\x00" is not set */
enum band_type band;
u8 opch;
enum country_ie_slave_status status;
};
#ifdef CONFIG_80211D
extern const char *const _cis_status_str[];
#define cis_status_str(s) (((s) >= COUNTRY_IE_SLAVE_STATUS_NUM) ? _cis_status_str[COUNTRY_IE_SLAVE_STATUS_NUM] : _cis_status_str[(s)])
void dump_country_ie_slave_records(void *sel, struct rf_ctl_t *rfctl, bool skip_noset);
enum country_ie_slave_status rtw_get_chplan_from_recv_country_ie(_adapter *adapter
, enum band_type band, u8 opch, const u8 *country_ie, struct country_chplan *ent
, struct country_ie_slave_record *cisr, const char *caller_msg);
enum country_ie_slave_status rtw_get_chplan_from_cisrs(struct rf_ctl_t *rfctl
, struct country_chplan *ent, const char *caller_msg);
#endif
void dump_country_chplan(void *sel, const struct country_chplan *ent, bool regd_info);
void dump_country_chplan_map(void *sel, bool regd_info);
void dump_country_list(void *sel);
void dump_chplan_id_list(void *sel);
void dump_chplan_country_list(void *sel);
#if CONFIG_IEEE80211_BAND_6GHZ
void dump_chplan_6g_id_list(void *sel);
void dump_chplan_6g_country_list(void *sel);
#endif
#ifdef CONFIG_RTW_DEBUG
void dump_chplan_test(void *sel);
#endif
void dump_chplan_ver(void *sel);
void rtw_set_phl_regulation_ctx(struct dvobj_priv *dvobj);
void rtw_clear_phl_regulation_ctx(struct dvobj_priv *dvobj);
#endif /* __RTW_CHPLAN_H__ */
|
2301_81045437/rtl8852be
|
core/rtw_chplan.h
|
C
|
agpl-3.0
| 10,017
|
/******************************************************************************
*
* Copyright(c) 2007 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_CMD_C_
#include <drv_types.h>
#ifndef DBG_CMD_EXECUTE
#define DBG_CMD_EXECUTE 0
#endif
/*
Caller and the rtw_cmd_thread can protect cmd_q by spin_lock.
No irqsave is necessary.
*/
u32 rtw_init_cmd_priv(struct dvobj_priv *dvobj)
{
u32 res = _SUCCESS;
struct cmd_priv *pcmdpriv = &dvobj->cmdpriv;
pcmdpriv->dvobj = dvobj;
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
_rtw_init_sema(&(pcmdpriv->cmd_queue_sema), 0);
_rtw_init_sema(&(pcmdpriv->start_cmdthread_sema), 0);
_rtw_init_queue(&(pcmdpriv->cmd_queue));
#endif
/* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
pcmdpriv->cmd_seq = 1;
pcmdpriv->cmd_allocated_buf = rtw_zmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ);
if (pcmdpriv->cmd_allocated_buf == NULL) {
res = _FAIL;
goto exit;
}
pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ - ((SIZE_PTR)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ - 1));
pcmdpriv->rsp_allocated_buf = rtw_zmalloc(MAX_RSPSZ + 4);
if (pcmdpriv->rsp_allocated_buf == NULL) {
res = _FAIL;
goto exit;
}
pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 - ((SIZE_PTR)(pcmdpriv->rsp_allocated_buf) & 3);
pcmdpriv->cmd_issued_cnt = 0;
_rtw_mutex_init(&pcmdpriv->sctx_mutex);
ATOMIC_SET(&pcmdpriv->event_seq, 0);
pcmdpriv->evt_done_cnt = 0;
exit:
return res;
}
void rtw_free_cmd_priv(struct dvobj_priv *dvobj)
{
struct cmd_priv *pcmdpriv = &dvobj->cmdpriv;
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
_rtw_spinlock_free(&(pcmdpriv->cmd_queue.lock));
_rtw_free_sema(&(pcmdpriv->cmd_queue_sema));
_rtw_free_sema(&(pcmdpriv->start_cmdthread_sema));
#endif
if (pcmdpriv->cmd_allocated_buf)
rtw_mfree(pcmdpriv->cmd_allocated_buf, MAX_CMDSZ + CMDBUFF_ALIGN_SZ);
if (pcmdpriv->rsp_allocated_buf)
rtw_mfree(pcmdpriv->rsp_allocated_buf, MAX_RSPSZ + 4);
_rtw_mutex_free(&pcmdpriv->sctx_mutex);
}
static int rtw_cmd_filter(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
{
u8 bAllow = _FALSE; /* set to _TRUE to allow enqueuing cmd when hw_init_completed is _FALSE */
struct dvobj_priv *dvobj = pcmdpriv->dvobj;
if (cmd_obj->cmdcode == CMD_SET_CHANPLAN)
bAllow = _TRUE;
if (cmd_obj->no_io)
bAllow = _TRUE;
return _SUCCESS;
}
/*
Calling Context:
rtw_enqueue_cmd can only be called between kernel thread,
since only spin_lock is used.
ISR/Call-Back functions can't call this sub-function.
*/
#ifdef DBG_CMD_QUEUE
extern u8 dump_cmd_id;
#endif
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
static sint _rtw_enqueue_cmd(_queue *queue, struct cmd_obj *obj, bool to_head)
{
unsigned long sp_flags;
if (obj == NULL)
goto exit;
/* _rtw_spinlock_bh(&queue->lock); */
_rtw_spinlock_irq(&queue->lock, &sp_flags);
if (to_head)
rtw_list_insert_head(&obj->list, &queue->queue);
else
rtw_list_insert_tail(&obj->list, &queue->queue);
#ifdef DBG_CMD_QUEUE
if (dump_cmd_id) {
RTW_INFO("%s===> cmdcode:0x%02x\n", __FUNCTION__, obj->cmdcode);
if (obj->cmdcode == CMD_SET_MLME_EVT) {
if (obj->parmbuf) {
struct rtw_evt_header *evt_hdr = (struct rtw_evt_header *)(obj->parmbuf);
RTW_INFO("evt_hdr->id:%d\n", evt_hdr->id);
}
}
if (obj->cmdcode == CMD_SET_DRV_EXTRA) {
if (obj->parmbuf) {
struct drvextra_cmd_parm *pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)(obj->parmbuf);
RTW_INFO("pdrvextra_cmd_parm->ec_id:0x%02x\n", pdrvextra_cmd_parm->ec_id);
}
}
}
if (queue->queue.prev->next != &queue->queue) {
RTW_INFO("[%d] head %p, tail %p, tail->prev->next %p[tail], tail->next %p[head]\n", __LINE__,
&queue->queue, queue->queue.prev, queue->queue.prev->prev->next, queue->queue.prev->next);
RTW_INFO("==========%s============\n", __FUNCTION__);
RTW_INFO("head:%p,obj_addr:%p\n", &queue->queue, obj);
RTW_INFO("padapter: %p\n", obj->padapter);
RTW_INFO("cmdcode: 0x%02x\n", obj->cmdcode);
RTW_INFO("res: %d\n", obj->res);
RTW_INFO("parmbuf: %p\n", obj->parmbuf);
RTW_INFO("cmdsz: %d\n", obj->cmdsz);
RTW_INFO("rsp: %p\n", obj->rsp);
RTW_INFO("rspsz: %d\n", obj->rspsz);
RTW_INFO("sctx: %p\n", obj->sctx);
RTW_INFO("list->next: %p\n", obj->list.next);
RTW_INFO("list->prev: %p\n", obj->list.prev);
}
#endif /* DBG_CMD_QUEUE */
/* _rtw_spinunlock_bh(&queue->lock); */
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
exit:
return _SUCCESS;
}
#else
static sint _rtw_enqueue_cmd(struct cmd_obj *obj, bool to_head)
{
u32 res;
res = rtw_enqueue_phl_cmd(obj);
#ifdef DBG_CMD_QUEUE
if (dump_cmd_id) {
RTW_INFO("%s===> cmdcode:0x%02x\n", __FUNCTION__, obj->cmdcode);
if (obj->cmdcode == CMD_SET_MLME_EVT) {
if (obj->parmbuf) {
struct rtw_evt_header *evt_hdr = (struct rtw_evt_header *)(obj->parmbuf);
RTW_INFO("evt_hdr->id:%d\n", evt_hdr->id);
}
}
if (obj->cmdcode == CMD_SET_DRV_EXTRA) {
if (obj->parmbuf) {
struct drvextra_cmd_parm *pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)(obj->parmbuf);
RTW_INFO("pdrvextra_cmd_parm->ec_id:0x%02x\n", pdrvextra_cmd_parm->ec_id);
}
}
}
#endif /* DBG_CMD_QUEUE */
return res;
}
#endif
u32 rtw_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
{
int res = _FAIL;
if (cmd_obj == NULL)
goto exit;
res = rtw_cmd_filter(pcmdpriv, cmd_obj);
if ((_FAIL == res) || (cmd_obj->cmdsz > MAX_CMDSZ)) {
if (cmd_obj->cmdsz > MAX_CMDSZ) {
RTW_INFO("%s failed due to obj->cmdsz(%d) > MAX_CMDSZ(%d)\n", __func__, cmd_obj->cmdsz, MAX_CMDSZ);
rtw_warn_on(1);
}
if (cmd_obj->cmdcode == CMD_SET_DRV_EXTRA) {
struct drvextra_cmd_parm *extra_parm = (struct drvextra_cmd_parm *)cmd_obj->parmbuf;
if (extra_parm->pbuf && extra_parm->size > 0)
rtw_mfree(extra_parm->pbuf, extra_parm->size);
}
rtw_free_cmd_obj(cmd_obj);
goto exit;
}
res = _rtw_enqueue_cmd(cmd_obj, 0);
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
if (res == _SUCCESS)
_rtw_up_sema(&pcmdpriv->cmd_queue_sema);
#endif
exit:
return res;
}
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
struct cmd_obj *_rtw_dequeue_cmd(_queue *queue)
{
struct cmd_obj *obj;
unsigned long sp_flags;
/* _rtw_spinlock_bh(&(queue->lock)); */
_rtw_spinlock_irq(&queue->lock, &sp_flags);
#ifdef DBG_CMD_QUEUE
if (queue->queue.prev->next != &queue->queue) {
RTW_INFO("[%d] head %p, tail %p, tail->prev->next %p[tail], tail->next %p[head]\n", __LINE__,
&queue->queue, queue->queue.prev, queue->queue.prev->prev->next, queue->queue.prev->next);
}
#endif /* DBG_CMD_QUEUE */
if (rtw_is_list_empty(&(queue->queue)))
obj = NULL;
else {
obj = LIST_CONTAINOR(get_next(&(queue->queue)), struct cmd_obj, list);
#ifdef DBG_CMD_QUEUE
if (queue->queue.prev->next != &queue->queue) {
RTW_INFO("==========%s============\n", __FUNCTION__);
RTW_INFO("head:%p,obj_addr:%p\n", &queue->queue, obj);
RTW_INFO("padapter: %p\n", obj->padapter);
RTW_INFO("cmdcode: 0x%02x\n", obj->cmdcode);
RTW_INFO("res: %d\n", obj->res);
RTW_INFO("parmbuf: %p\n", obj->parmbuf);
RTW_INFO("cmdsz: %d\n", obj->cmdsz);
RTW_INFO("rsp: %p\n", obj->rsp);
RTW_INFO("rspsz: %d\n", obj->rspsz);
RTW_INFO("sctx: %p\n", obj->sctx);
RTW_INFO("list->next: %p\n", obj->list.next);
RTW_INFO("list->prev: %p\n", obj->list.prev);
}
if (dump_cmd_id) {
RTW_INFO("%s===> cmdcode:0x%02x\n", __FUNCTION__, obj->cmdcode);
if (obj->cmdcode == CMD_SET_DRV_EXTRA) {
if (obj->parmbuf) {
struct drvextra_cmd_parm *pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)(obj->parmbuf);
printk("pdrvextra_cmd_parm->ec_id:0x%02x\n", pdrvextra_cmd_parm->ec_id);
}
}
}
#endif /* DBG_CMD_QUEUE */
rtw_list_delete(&obj->list);
}
/* _rtw_spinunlock_bh(&(queue->lock)); */
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
return obj;
}
struct cmd_obj *rtw_dequeue_cmd(struct cmd_priv *pcmdpriv)
{
struct cmd_obj *cmd_obj;
cmd_obj = _rtw_dequeue_cmd(&pcmdpriv->cmd_queue);
return cmd_obj;
}
#endif
void rtw_free_cmd_obj(struct cmd_obj *pcmd)
{
if (pcmd->parmbuf != NULL) {
/* free parmbuf in cmd_obj */
rtw_mfree((unsigned char *)pcmd->parmbuf, pcmd->cmdsz);
}
if (pcmd->rsp != NULL) {
if (pcmd->rspsz != 0) {
/* free rsp in cmd_obj */
rtw_mfree((unsigned char *)pcmd->rsp, pcmd->rspsz);
}
}
/* free cmd_obj */
rtw_mfree((unsigned char *)pcmd, sizeof(struct cmd_obj));
}
void rtw_run_cmd(_adapter *padapter, struct cmd_obj *pcmd, bool discard)
{
u8 ret;
u8 *pcmdbuf;
systime cmd_start_time;
u32 cmd_process_time;
u8(*cmd_hdl)(_adapter *padapter, u8 *pbuf);
void (*pcmd_callback)(_adapter *dev, struct cmd_obj *pcmd);
struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(padapter)->cmdpriv);
struct drvextra_cmd_parm *extra_parm = NULL;
cmd_start_time = rtw_get_current_time();
pcmdpriv->cmd_issued_cnt++;
if (discard)
goto post_process;
if (pcmd->cmdsz > MAX_CMDSZ) {
RTW_ERR("%s cmdsz:%d > MAX_CMDSZ:%d\n", __func__, pcmd->cmdsz, MAX_CMDSZ);
pcmd->res = H2C_PARAMETERS_ERROR;
goto post_process;
}
if (pcmd->cmdcode >= (sizeof(wlancmds) / sizeof(struct rtw_cmd))) {
RTW_ERR("%s undefined cmdcode:%d\n", __func__, pcmd->cmdcode);
pcmd->res = H2C_PARAMETERS_ERROR;
goto post_process;
}
cmd_hdl = wlancmds[pcmd->cmdcode].cmd_hdl;
if (!cmd_hdl) {
RTW_ERR("%s no cmd_hdl for cmdcode:%d\n", __func__, pcmd->cmdcode);
pcmd->res = H2C_PARAMETERS_ERROR;
goto post_process;
}
if (DBG_CMD_EXECUTE)
RTW_INFO(ADPT_FMT" "CMD_FMT" %sexecute\n", ADPT_ARG(pcmd->padapter), CMD_ARG(pcmd)
, pcmd->res == H2C_ENQ_HEAD ? "ENQ_HEAD " : (pcmd->res == H2C_ENQ_HEAD_FAIL ? "ENQ_HEAD_FAIL " : ""));
pcmdbuf = pcmdpriv->cmd_buf;
_rtw_memcpy(pcmdbuf, pcmd->parmbuf, pcmd->cmdsz);
ret = cmd_hdl(pcmd->padapter, pcmdbuf);
pcmd->res = ret;
pcmdpriv->cmd_seq++;
post_process:
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (pcmd->sctx) {
if (0)
RTW_PRINT(FUNC_ADPT_FMT" pcmd->sctx\n", FUNC_ADPT_ARG(pcmd->padapter));
if (pcmd->res == H2C_SUCCESS)
rtw_sctx_done(&pcmd->sctx);
else
rtw_sctx_done_err(&pcmd->sctx, RTW_SCTX_DONE_CMD_ERROR);
}
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
cmd_process_time = rtw_get_passing_time_ms(cmd_start_time);
if (cmd_process_time > 1000) {
RTW_INFO(ADPT_FMT" "CMD_FMT" process_time=%d\n", ADPT_ARG(pcmd->padapter), CMD_ARG(pcmd), cmd_process_time);
if (0)
rtw_warn_on(1);
}
/* call callback function for post-processed */
if (pcmd->cmdcode >= (sizeof(wlancmds) / sizeof(struct rtw_cmd)))
pcmd_callback = wlancmds[pcmd->cmdcode].callback;
else
pcmd_callback = NULL;
if (pcmd_callback == NULL) {
rtw_free_cmd_obj(pcmd);
} else {
/* todo: !!! fill rsp_buf to pcmd->rsp if (pcmd->rsp!=NULL) */
pcmd_callback(pcmd->padapter, pcmd);/* need conider that free cmd_obj in rtw_cmd_callback */
}
}
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
void rtw_stop_cmd_thread(_adapter *adapter)
{
if (adapter->cmdThread) {
_rtw_up_sema(&adapter->cmdpriv.cmd_queue_sema);
rtw_thread_stop(adapter->cmdThread);
adapter->cmdThread = NULL;
}
}
thread_return rtw_cmd_thread(thread_context context)
{
u8 ret;
struct cmd_obj *pcmd;
u8 *pcmdbuf, *prspbuf;
systime cmd_start_time;
u32 cmd_process_time;
u8(*cmd_hdl)(_adapter *padapter, u8 *pbuf);
void (*pcmd_callback)(_adapter *dev, struct cmd_obj *pcmd);
_adapter *padapter = (_adapter *)context;
struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
struct drvextra_cmd_parm *extra_parm = NULL;
unsigned long sp_flags;
rtw_thread_enter("RTW_CMD_THREAD");
pcmdbuf = pcmdpriv->cmd_buf;
prspbuf = pcmdpriv->rsp_buf;
ATOMIC_SET(&(pcmdpriv->cmdthd_running), _TRUE);
_rtw_up_sema(&pcmdpriv->start_cmdthread_sema);
while (1) {
if (_rtw_down_sema(&pcmdpriv->cmd_queue_sema) == _FAIL) {
RTW_PRINT(FUNC_ADPT_FMT" _rtw_down_sema(&pcmdpriv->cmd_queue_sema) return _FAIL, break\n", FUNC_ADPT_ARG(padapter));
break;
}
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
RTW_DBG(FUNC_ADPT_FMT "- bDriverStopped(%s) bSurpriseRemoved(%s)\n",
FUNC_ADPT_ARG(padapter),
dev_is_drv_stopped(adapter_to_dvobj(padapter)) ? "True" : "False",
dev_is_surprise_removed(adapter_to_dvobj(padapter)) ? "True" : "False");
break;
}
_rtw_spinlock_irq(&pcmdpriv->cmd_queue.lock, &sp_flags);
if (rtw_is_list_empty(&(pcmdpriv->cmd_queue.queue))) {
/* RTW_INFO("%s: cmd queue is empty!\n", __func__); */
_rtw_spinunlock_irq(&pcmdpriv->cmd_queue.lock, &sp_flags);
continue;
}
_rtw_spinunlock_irq(&pcmdpriv->cmd_queue.lock, &sp_flags);
_next:
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
RTW_PRINT("%s: DriverStopped(%s) SurpriseRemoved(%s) break at line %d\n",
__func__
, dev_is_drv_stopped(adapter_to_dvobj(padapter)) ? "True" : "False"
, dev_is_surprise_removed(adapter_to_dvobj(padapter)) ? "True" : "False"
, __LINE__);
break;
}
pcmd = rtw_dequeue_cmd(pcmdpriv);
if (!pcmd) {
#ifdef CONFIG_LPS_LCLK
rtw_unregister_cmd_alive(padapter);
#endif
continue;
}
cmd_start_time = rtw_get_current_time();
pcmdpriv->cmd_issued_cnt++;
if (pcmd->cmdsz > MAX_CMDSZ) {
RTW_ERR("%s cmdsz:%d > MAX_CMDSZ:%d\n", __func__, pcmd->cmdsz, MAX_CMDSZ);
pcmd->res = H2C_PARAMETERS_ERROR;
goto post_process;
}
if (pcmd->cmdcode >= (sizeof(wlancmds) / sizeof(struct rtw_cmd))) {
RTW_ERR("%s undefined cmdcode:%d\n", __func__, pcmd->cmdcode);
pcmd->res = H2C_PARAMETERS_ERROR;
goto post_process;
}
cmd_hdl = wlancmds[pcmd->cmdcode].cmd_hdl;
if (!cmd_hdl) {
RTW_ERR("%s no cmd_hdl for cmdcode:%d\n", __func__, pcmd->cmdcode);
pcmd->res = H2C_PARAMETERS_ERROR;
goto post_process;
}
if (_FAIL == rtw_cmd_filter(pcmdpriv, pcmd)) {
pcmd->res = H2C_DROPPED;
if (pcmd->cmdcode == CMD_SET_DRV_EXTRA) {
extra_parm = (struct drvextra_cmd_parm *)pcmd->parmbuf;
if (extra_parm && extra_parm->pbuf && extra_parm->size > 0)
rtw_mfree(extra_parm->pbuf, extra_parm->size);
}
#if CONFIG_DFS
else if (pcmd->cmdcode == CMD_SET_CHANSWITCH)
adapter_to_rfctl(padapter)->csa_chandef.chan = 0;
#endif
goto post_process;
}
#ifdef CONFIG_LPS_LCLK
if (pcmd->no_io)
rtw_unregister_cmd_alive(padapter);
else {
if (rtw_register_cmd_alive(padapter) != _SUCCESS) {
if (DBG_CMD_EXECUTE)
RTW_PRINT("%s: wait to leave LPS_LCLK\n", __func__);
pcmd->res = H2C_ENQ_HEAD;
ret = _rtw_enqueue_cmd(&pcmdpriv->cmd_queue, pcmd, 1);
if (ret == _SUCCESS) {
if (DBG_CMD_EXECUTE)
RTW_INFO(ADPT_FMT" "CMD_FMT" ENQ_HEAD\n", ADPT_ARG(pcmd->padapter), CMD_ARG(pcmd));
continue;
}
RTW_INFO(ADPT_FMT" "CMD_FMT" ENQ_HEAD_FAIL\n", ADPT_ARG(pcmd->padapter), CMD_ARG(pcmd));
pcmd->res = H2C_ENQ_HEAD_FAIL;
rtw_warn_on(1);
}
}
#endif /* CONFIG_LPS_LCLK */
if (DBG_CMD_EXECUTE)
RTW_INFO(ADPT_FMT" "CMD_FMT" %sexecute\n", ADPT_ARG(pcmd->padapter), CMD_ARG(pcmd)
, pcmd->res == H2C_ENQ_HEAD ? "ENQ_HEAD " : (pcmd->res == H2C_ENQ_HEAD_FAIL ? "ENQ_HEAD_FAIL " : ""));
_rtw_memcpy(pcmdbuf, pcmd->parmbuf, pcmd->cmdsz);
ret = cmd_hdl(pcmd->padapter, pcmdbuf);
pcmd->res = ret;
pcmdpriv->cmd_seq++;
post_process:
_rtw_mutex_lock_interruptible(&(pcmd->padapter->cmdpriv.sctx_mutex));
if (pcmd->sctx) {
if (0)
RTW_PRINT(FUNC_ADPT_FMT" pcmd->sctx\n", FUNC_ADPT_ARG(pcmd->padapter));
if (pcmd->res == H2C_SUCCESS)
rtw_sctx_done(&pcmd->sctx);
else
rtw_sctx_done_err(&pcmd->sctx, RTW_SCTX_DONE_CMD_ERROR);
}
_rtw_mutex_unlock(&(pcmd->padapter->cmdpriv.sctx_mutex));
cmd_process_time = rtw_get_passing_time_ms(cmd_start_time);
if (cmd_process_time > 1000) {
RTW_INFO(ADPT_FMT" "CMD_FMT" process_time=%d\n", ADPT_ARG(pcmd->padapter), CMD_ARG(pcmd), cmd_process_time);
if (0)
rtw_warn_on(1);
}
/* call callback function for post-processed */
if (pcmd->cmdcode >= (sizeof(wlancmds) / sizeof(struct rtw_cmd)))
pcmd_callback = wlancmds[pcmd->cmdcode].callback;
else
pcmd_callback = NULL;
if (pcmd_callback == NULL) {
rtw_free_cmd_obj(pcmd);
} else {
/* todo: !!! fill rsp_buf to pcmd->rsp if (pcmd->rsp!=NULL) */
pcmd_callback(pcmd->padapter, pcmd);/* need conider that free cmd_obj in rtw_cmd_callback */
}
flush_signals_thread();
goto _next;
}
#ifdef CONFIG_LPS_LCLK
rtw_unregister_cmd_alive(padapter);
#endif
/* to avoid enqueue cmd after free all cmd_obj */
ATOMIC_SET(&(pcmdpriv->cmdthd_running), _FALSE);
/* free all cmd_obj resources */
do {
pcmd = rtw_dequeue_cmd(pcmdpriv);
if (pcmd == NULL)
break;
if (0)
RTW_INFO("%s: leaving... drop "CMD_FMT"\n", __func__, CMD_ARG(pcmd));
if (pcmd->cmdcode == CMD_SET_DRV_EXTRA) {
extra_parm = (struct drvextra_cmd_parm *)pcmd->parmbuf;
if (extra_parm->pbuf && extra_parm->size > 0)
rtw_mfree(extra_parm->pbuf, extra_parm->size);
}
#if CONFIG_DFS
else if (pcmd->cmdcode == CMD_SET_CHANSWITCH)
adapter_to_rfctl(padapter)->csa_chandef.chan = 0;
#endif
_rtw_mutex_lock_interruptible(&(pcmd->padapter->cmdpriv.sctx_mutex));
if (pcmd->sctx) {
if (0)
RTW_PRINT(FUNC_ADPT_FMT" pcmd->sctx\n", FUNC_ADPT_ARG(pcmd->padapter));
rtw_sctx_done_err(&pcmd->sctx, RTW_SCTX_DONE_CMD_DROP);
}
_rtw_mutex_unlock(&(pcmd->padapter->cmdpriv.sctx_mutex));
rtw_free_cmd_obj(pcmd);
} while (1);
RTW_INFO(FUNC_ADPT_FMT " Exit\n", FUNC_ADPT_ARG(padapter));
rtw_thread_wait_stop();
return 0;
}
#endif
void rtw_readtssi_cmdrsp_callback(_adapter *padapter, struct cmd_obj *pcmd)
{
rtw_mfree((unsigned char *) pcmd->parmbuf, pcmd->cmdsz);
rtw_mfree((unsigned char *) pcmd, sizeof(struct cmd_obj));
#ifdef CONFIG_MP_INCLUDED
if (padapter->registrypriv.mp_mode == 1)
padapter->mppriv.workparam.bcompleted = _TRUE;
#endif
}
static u8 rtw_createbss_cmd(_adapter *adapter, int flags, bool adhoc
, u8 ifbmp, u8 excl_ifbmp, s16 req_ch, s8 req_bw, s8 req_offset)
{
struct cmd_obj *cmdobj;
struct createbss_parm *parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
if (req_ch > 0 && req_bw >= 0 && req_offset >= 0) {
if (!rtw_chset_is_chbw_valid(adapter_to_chset(adapter), req_ch, req_bw, req_offset, 0, 0)) {
res = _FAIL;
goto exit;
}
}
/* prepare cmd parameter */
parm = (struct createbss_parm *)rtw_zmalloc(sizeof(*parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
if (adhoc) {
/* for now, adhoc doesn't support ch,bw,offset request */
parm->adhoc = 1;
} else {
parm->adhoc = 0;
parm->ifbmp = ifbmp;
parm->excl_ifbmp = excl_ifbmp;
parm->req_ch = req_ch;
parm->req_bw = req_bw;
parm->req_offset = req_offset;
parm->ifbmp_ch_changed = 0;
parm->ch_to_set = 0;
parm->bw_to_set = 0;
parm->offset_to_set = 0;
parm->do_rfk = _FALSE;
}
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != createbss_hdl(adapter, (u8 *)parm))
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_CREATE_BSS);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 5000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
res = rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
}
}
exit:
return res;
}
inline u8 rtw_create_ibss_cmd(_adapter *adapter, int flags)
{
return rtw_createbss_cmd(adapter, flags
, 1
, 0, 0
, 0, REQ_BW_NONE, REQ_OFFSET_NONE /* for now, adhoc doesn't support ch,bw,offset request */
);
}
inline u8 rtw_startbss_cmd(_adapter *adapter, int flags)
{
return rtw_createbss_cmd(adapter, flags
, 0
, BIT(adapter->iface_id), 0
, 0, REQ_BW_NONE, REQ_OFFSET_NONE /* excute entire AP setup cmd */
);
}
inline u8 rtw_change_bss_chbw_cmd(_adapter *adapter, int flags
, u8 ifbmp, u8 excl_ifbmp, s16 req_ch, s8 req_bw, s8 req_offset)
{
return rtw_createbss_cmd(adapter, flags
, 0
, ifbmp, excl_ifbmp
, req_ch, req_bw, req_offset
);
}
#ifdef CONFIG_80211D
/* Return corresponding country_chplan setting */
static bool rtw_joinbss_check_country_ie(_adapter *adapter, const WLAN_BSSID_EX *network, struct country_chplan *ent, WLAN_BSSID_EX *out_network)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
bool ret = 0;
if (rfctl->regd_src == REGD_SRC_RTK_PRIV
&& !rtw_rfctl_is_disable_sw_channel_plan(rfctl_to_dvobj(rfctl))
) {
struct mlme_priv *mlme = &adapter->mlmepriv;
const u8 *country_ie = NULL;
sint country_ie_len = 0;
if (rtw_iface_accept_country_ie(adapter)) {
country_ie = rtw_get_ie(BSS_EX_TLV_IES(network)
, WLAN_EID_COUNTRY, &country_ie_len, BSS_EX_TLV_IES_LEN(network));
if (country_ie) {
if (country_ie_len < 6) {
country_ie = NULL;
country_ie_len = 0;
} else
country_ie_len += 2;
}
}
if (country_ie) {
enum country_ie_slave_status status;
rtw_buf_update(&mlme->recv_country_ie, &mlme->recv_country_ie_len, country_ie, country_ie_len);
status = rtw_get_chplan_from_recv_country_ie(adapter
, network->Configuration.DSConfig > 14 ? BAND_ON_5G : BAND_ON_24G
, network->Configuration.DSConfig, country_ie, ent, NULL, __func__);
if (status != COUNTRY_IE_SLAVE_NOCOUNTRY)
ret = 1;
if (out_network) {
_rtw_memcpy(BSS_EX_IES(out_network) + BSS_EX_IES_LEN(out_network)
, country_ie, country_ie_len);
BSS_EX_IES_LEN(out_network) += country_ie_len;
}
} else
rtw_buf_free(&mlme->recv_country_ie, &mlme->recv_country_ie_len);
}
return ret;
}
#endif /* CONFIG_80211D */
u8 rtw_joinbss_cmd(_adapter *padapter, struct wlan_network *pnetwork)
{
u8 *auth, res = _SUCCESS;
uint t_len = 0;
WLAN_BSSID_EX *psecnetwork;
struct cmd_obj *pcmd;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
#ifdef CONFIG_80211D
struct country_chplan country_ent;
#endif
struct country_chplan *req_chplan = NULL;
#ifdef CONFIG_80211N_HT
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
struct he_priv *phepriv = &pmlmepriv->hepriv;
#endif /* CONFIG_80211AX_HE */
NDIS_802_11_NETWORK_INFRASTRUCTURE ndis_network_mode = pnetwork->network.InfrastructureMode;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
u32 tmp_len;
u8 *ptmp = NULL;
rtw_led_control(padapter, LED_CTL_START_TO_LINK);
pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd == NULL) {
res = _FAIL;
goto exit;
}
pcmd->padapter = padapter;
/* for IEs is fix buf size */
t_len = sizeof(WLAN_BSSID_EX);
/* for hidden ap to set fw_state here */
if (!MLME_IS_STA(padapter) || !MLME_IS_ADHOC(padapter)) {
switch (ndis_network_mode) {
case Ndis802_11IBSS:
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
break;
case Ndis802_11Infrastructure:
set_fwstate(pmlmepriv, WIFI_STATION_STATE);
break;
default:
rtw_warn_on(1);
break;
}
}
pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pnetwork->network.IEs, pnetwork->network.IELength);
#ifdef CONFIG_80211AC_VHT
/* save AP beamform_cap info for BCM IOT issue */
if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_BROADCOM)
get_vht_bf_cap(pnetwork->network.IEs,
pnetwork->network.IELength,
&pvhtpriv->ap_bf_cap);
#endif
/*
Modified by Arvin 2015/05/13
Solution for allocating a new WLAN_BSSID_EX to avoid race condition issue between disconnect and joinbss
*/
psecnetwork = (WLAN_BSSID_EX *)rtw_zmalloc(sizeof(WLAN_BSSID_EX));
if (psecnetwork == NULL) {
if (pcmd != NULL)
rtw_mfree((unsigned char *)pcmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
_rtw_memset(psecnetwork, 0, t_len);
_rtw_memcpy(psecnetwork, &pnetwork->network, get_WLAN_BSSID_EX_sz(&pnetwork->network));
auth = &psecuritypriv->authenticator_ie[0];
psecuritypriv->authenticator_ie[0] = (unsigned char)psecnetwork->IELength;
if ((psecnetwork->IELength - 12) < (256 - 1))
_rtw_memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], psecnetwork->IELength - 12);
else
_rtw_memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], (256 - 1));
psecnetwork->IELength = 0;
/* Added by Albert 2009/02/18 */
/* If the the driver wants to use the bssid to create the connection. */
/* If not, we have to copy the connecting AP's MAC address to it so that */
/* the driver just has the bssid information for PMKIDList searching. */
if (pmlmepriv->assoc_by_bssid == _FALSE)
_rtw_memcpy(&pmlmepriv->assoc_bssid[0], &pnetwork->network.MacAddress[0], ETH_ALEN);
/* copy fixed ie */
_rtw_memcpy(psecnetwork->IEs, pnetwork->network.IEs, 12);
psecnetwork->IELength = 12;
psecnetwork->IELength += rtw_restruct_sec_ie(padapter, psecnetwork->IEs + psecnetwork->IELength);
pqospriv->qos_option = 0;
if (pregistrypriv->wmm_enable) {
#ifdef CONFIG_WMMPS_STA
rtw_uapsd_use_default_setting(padapter);
#endif /* CONFIG_WMMPS_STA */
tmp_len = rtw_restruct_wmm_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength, psecnetwork->IELength);
if (psecnetwork->IELength != tmp_len) {
psecnetwork->IELength = tmp_len;
pqospriv->qos_option = 1; /* There is WMM IE in this corresp. beacon */
} else {
pqospriv->qos_option = 0;/* There is no WMM IE in this corresp. beacon */
}
}
#ifdef RTW_WKARD_UPDATE_PHL_ROLE_CAP
rtw_update_phl_cap_by_rgstry(padapter);
#endif
#ifdef CONFIG_80211D
if (rtw_joinbss_check_country_ie(padapter, &pnetwork->network, &country_ent, psecnetwork))
req_chplan = &country_ent;
#endif
#ifdef CONFIG_80211N_HT
phtpriv->ht_option = _FALSE;
if (pregistrypriv->ht_enable && is_supported_ht(pregistrypriv->wireless_mode)) {
ptmp = rtw_get_ie(&pnetwork->network.IEs[12], _HT_CAPABILITY_IE_, &tmp_len, pnetwork->network.IELength - 12);
if (ptmp && tmp_len > 0) {
/* Added by Albert 2010/06/23 */
/* For the WEP mode, we will use the bg mode to do the connection to avoid some IOT issue. */
/* Especially for Realtek 8192u SoftAP. */
if ((padapter->securitypriv.dot11PrivacyAlgrthm != _WEP40_) &&
(padapter->securitypriv.dot11PrivacyAlgrthm != _WEP104_) &&
(padapter->securitypriv.dot11PrivacyAlgrthm != _TKIP_)) {
rtw_ht_use_default_setting(padapter);
/* rtw_restructure_ht_ie */
rtw_restructure_ht_ie(padapter, &pnetwork->network.IEs[12], &psecnetwork->IEs[0],
pnetwork->network.IELength - 12, &psecnetwork->IELength,
pnetwork->network.Configuration.DSConfig, req_chplan);
}
}
}
#ifdef CONFIG_80211AC_VHT
pvhtpriv->vht_option = _FALSE;
if (phtpriv->ht_option
&& REGSTY_IS_11AC_ENABLE(pregistrypriv)
&& is_supported_vht(pregistrypriv->wireless_mode)
&& ((req_chplan && COUNTRY_CHPLAN_EN_11AC(req_chplan))
|| (!req_chplan && RFCTL_REG_EN_11AC(rfctl)))
) {
u8 vht_enable = 0;
if (pnetwork->network.Configuration.DSConfig > 14)
vht_enable = 1;
else if ((REGSTY_IS_11AC_24G_ENABLE(pregistrypriv)) && (padapter->registrypriv.wifi_spec == 0))
vht_enable = 1;
if (vht_enable == 1)
rtw_restructure_vht_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0],
pnetwork->network.IELength, &psecnetwork->IELength, req_chplan);
}
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
phepriv->he_option = _FALSE;
if (((phtpriv->ht_option && pnetwork->network.Configuration.DSConfig <= 14)
#ifdef CONFIG_80211AC_VHT
|| (pvhtpriv->vht_option && pnetwork->network.Configuration.DSConfig > 14)
#endif
)
&& REGSTY_IS_11AX_ENABLE(pregistrypriv)
&& is_supported_he(pregistrypriv->wireless_mode)
&& ((req_chplan && COUNTRY_CHPLAN_EN_11AX(req_chplan))
|| (!req_chplan && RFCTL_REG_EN_11AX(rfctl)))
) {
rtw_restructure_he_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0],
pnetwork->network.IELength, &psecnetwork->IELength, req_chplan);
}
#endif /* CONFIG_80211AX_HE */
#endif /* CONFIG_80211N_HT */
rtw_append_extended_cap(padapter, &psecnetwork->IEs[0], &psecnetwork->IELength);
#ifdef CONFIG_RTW_80211R
rtw_ft_validate_akm_type(padapter, pnetwork);
#endif
#if 0
psecuritypriv->supplicant_ie[0] = (u8)psecnetwork->IELength;
if (psecnetwork->IELength < (256 - 1))
_rtw_memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0], psecnetwork->IELength);
else
_rtw_memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0], (256 - 1));
#endif
pcmd->cmdsz = sizeof(WLAN_BSSID_EX);
_rtw_init_listhead(&pcmd->list);
pcmd->cmdcode = CMD_JOINBSS; /*_JoinBss_CMD_;*/
pcmd->parmbuf = (unsigned char *)psecnetwork;
pcmd->rsp = NULL;
pcmd->rspsz = 0;
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
exit:
return res;
}
#ifdef CONFIG_STA_CMD_DISPR
/* for sta_mode only */
static u8 sta_disassoc_cmd(struct _ADAPTER *a, u32 deauth_timeout_ms, int flags)
{
struct cmd_priv *cmdpriv = &adapter_to_dvobj(a)->cmdpriv;
struct cmd_obj *cmd = NULL;
struct disconnect_parm *param = NULL;
struct submit_ctx sctx;
enum rtw_phl_status status;
int ret;
u8 res = _FAIL;
if (!MLME_IS_ASOC(a))
return _SUCCESS;
param = (struct disconnect_parm *)rtw_zmalloc(sizeof(*param));
if (!param) {
RTW_ERR(FUNC_ADPT_FMT ": alloc param FAIL!", FUNC_ADPT_ARG(a));
goto exit;
}
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmd));
if (!cmd) {
RTW_ERR(FUNC_ADPT_FMT ": alloc cmd FAIL!", FUNC_ADPT_ARG(a));
rtw_mfree((u8 *)param, sizeof(*param));
goto exit;
}
param->deauth_timeout_ms = deauth_timeout_ms;
init_h2fwcmd_w_parm_no_rsp(cmd, param, CMD_DISCONNECT);
cmd->padapter = a;
if (flags & RTW_CMDF_WAIT_ACK) {
cmd->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
status = rtw_disconnect_cmd(a, cmd);
if (status != RTW_PHL_STATUS_SUCCESS) {
/* param & cmd would be freed in rtw_enqueue_cmd() */
RTW_ERR(FUNC_ADPT_FMT ": send disconnect cmd FAIL!(0x%x)\n",
FUNC_ADPT_ARG(a), status);
goto exit;
}
res = _SUCCESS;
if (flags & RTW_CMDF_WAIT_ACK) {
ret = rtw_sctx_wait(&sctx, __func__);
if (ret == _FAIL)
res = _FAIL;
_rtw_spinlock(&a->disconnect_lock);
if (a->discon_cmd) {
a->discon_cmd->sctx = NULL;
/*
* a->discon_param would be
* freed by disconnect cmd dispatcher.
*/
}
_rtw_spinunlock(&a->disconnect_lock);
}
exit:
return res;
}
#endif /* CONFIG_STA_CMD_DISPR */
u8 rtw_disassoc_cmd(_adapter *padapter, u32 deauth_timeout_ms, int flags) /* for sta_mode */
{
struct cmd_obj *cmdobj = NULL;
struct disconnect_parm *param = NULL;
struct cmd_priv *cmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
#ifdef CONFIG_STA_CMD_DISPR
if (MLME_IS_STA(padapter))
return sta_disassoc_cmd(padapter, deauth_timeout_ms, flags);
#endif /* CONFIG_STA_CMD_DISPR */
/* prepare cmd parameter */
param = (struct disconnect_parm *)rtw_zmalloc(sizeof(*param));
if (param == NULL) {
res = _FAIL;
goto exit;
}
param->deauth_timeout_ms = deauth_timeout_ms;
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (disconnect_hdl(padapter, (u8 *)param) != H2C_SUCCESS)
res = _FAIL;
rtw_mfree((u8 *)param, sizeof(*param));
} else {
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)param, sizeof(*param));
goto exit;
}
cmdobj->padapter = padapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, param, CMD_DISCONNECT);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
if (res == _FAIL) {
RTW_ERR(FUNC_ADPT_FMT ": enqueue disconnect cmd FAIL!\n",
FUNC_ADPT_ARG(padapter));
goto exit;
}
if (flags & RTW_CMDF_WAIT_ACK) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&cmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&cmdpriv->sctx_mutex);
}
}
exit:
return res;
}
u8 rtw_stop_ap_cmd(_adapter *adapter, u8 flags)
{
#ifdef CONFIG_AP_MODE
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != stop_ap_hdl(adapter))
res = _FAIL;
} else {
parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
parm->ec_id = STOP_AP_WK_CID;
parm->type = 0;
parm->size = 0;
parm->pbuf = NULL;
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
}
}
exit:
return res;
#endif
}
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
u8 rtw_tx_control_cmd(_adapter *adapter)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL){
res = _FAIL;
goto exit;
}
cmd->padapter = adapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = TBTX_CONTROL_TX_WK_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
#endif
u8 rtw_setopmode_cmd(_adapter *adapter, NDIS_802_11_NETWORK_INFRASTRUCTURE networktype, u8 flags)
{
struct cmd_obj *cmdobj;
struct setopmode_parm *parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
/* prepare cmd parameter */
parm = (struct setopmode_parm *)rtw_zmalloc(sizeof(*parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
parm->mode = (u8)networktype;
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != setopmode_hdl(adapter, (u8 *)parm))
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_OPMODE);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
}
}
exit:
return res;
}
#ifdef CONFIG_CMD_DISP
u8 rtw_setstakey_cmd(_adapter *padapter, struct sta_info *sta, u8 key_type, bool enqueue)
{
struct set_stakey_parm setstakey_para;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
u8 key_len =16;
u8 res = _SUCCESS;
_rtw_memset(&setstakey_para, 0, sizeof(struct set_stakey_parm));
_rtw_memcpy(setstakey_para.addr, sta->phl_sta->mac_addr, ETH_ALEN);
if (MLME_IS_STA(padapter))
setstakey_para.algorithm = (unsigned char) psecuritypriv->dot11PrivacyAlgrthm;
else
GET_ENCRY_ALGO(psecuritypriv, sta, setstakey_para.algorithm, _FALSE);
if ((setstakey_para.algorithm == _GCMP_256_) || (setstakey_para.algorithm == _CCMP_256_))
key_len = 32;
if (key_type == GROUP_KEY) {
_rtw_memcpy(&setstakey_para.key, &psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey, key_len);
setstakey_para.gk = 1;
} else if (key_type == UNICAST_KEY)
_rtw_memcpy(&setstakey_para.key, &sta->dot118021x_UncstKey, key_len);
#ifdef CONFIG_TDLS
else if (key_type == TDLS_KEY) {
_rtw_memcpy(&setstakey_para.key, sta->tpk.tk, key_len);
setstakey_para.algorithm = (u8)sta->dot118021XPrivacy;
}
#endif /* CONFIG_TDLS */
/* jeff: set this becasue at least sw key is ready */
padapter->securitypriv.busetkipkey = _TRUE;
if (enqueue) {
set_stakey_hdl(padapter, &setstakey_para, PHL_CMD_NO_WAIT, 0);
} else {
set_stakey_hdl(padapter, &setstakey_para, PHL_CMD_DIRECTLY, 0);
}
exit:
return res;
}
u8 rtw_clearstakey_cmd(_adapter *padapter, struct sta_info *sta, u8 enqueue)
{
struct cmd_obj *cmd;
struct set_stakey_parm *psetstakey_para;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct set_stakey_rsp *psetstakey_rsp = NULL;
s16 cam_id = 0;
u8 res = _SUCCESS;
if (!sta) {
RTW_ERR("%s sta == NULL\n", __func__);
goto exit;
}
if (!enqueue)
rtw_hw_del_all_key(padapter, sta, PHL_CMD_DIRECTLY, 0);
else
rtw_hw_del_all_key(padapter, sta, PHL_CMD_NO_WAIT, 0);
exit:
return res;
}
#else /* CONFIG_FSM */
u8 rtw_setstakey_cmd(_adapter *padapter, struct sta_info *sta, u8 key_type, bool enqueue)
{
struct cmd_obj *pcmd;
struct set_stakey_parm *psetstakey_para;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct set_stakey_rsp *psetstakey_rsp = NULL;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
u8 key_len =16;
u8 res = _SUCCESS;
psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
if (psetstakey_para == NULL) {
res = _FAIL;
goto exit;
}
_rtw_memcpy(psetstakey_para->addr, sta->phl_sta->mac_addr, ETH_ALEN);
if (MLME_IS_STA(padapter))
psetstakey_para->algorithm = (unsigned char) psecuritypriv->dot11PrivacyAlgrthm;
else
GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, _FALSE);
if ((psetstakey_para->algorithm == _GCMP_256_) || (psetstakey_para->algorithm == _CCMP_256_))
key_len = 32;
if (key_type == GROUP_KEY) {
_rtw_memcpy(&psetstakey_para->key, &psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey, key_len);
psetstakey_para->gk = 1;
} else if (key_type == UNICAST_KEY)
_rtw_memcpy(&psetstakey_para->key, &sta->dot118021x_UncstKey, key_len);
#ifdef CONFIG_TDLS
else if (key_type == TDLS_KEY) {
_rtw_memcpy(&psetstakey_para->key, sta->tpk.tk, key_len);
psetstakey_para->algorithm = (u8)sta->dot118021XPrivacy;
}
#endif /* CONFIG_TDLS */
/* jeff: set this becasue at least sw key is ready */
padapter->securitypriv.busetkipkey = _TRUE;
if (enqueue) {
pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd == NULL) {
rtw_mfree((u8 *) psetstakey_para, sizeof(struct set_stakey_parm));
res = _FAIL;
goto exit;
}
pcmd->padapter = padapter;
psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
if (psetstakey_rsp == NULL) {
rtw_mfree((u8 *) pcmd, sizeof(struct cmd_obj));
rtw_mfree((u8 *) psetstakey_para, sizeof(struct set_stakey_parm));
res = _FAIL;
goto exit;
}
init_h2fwcmd_w_parm_no_rsp(pcmd, psetstakey_para, CMD_SET_STAKEY);
pcmd->rsp = (u8 *) psetstakey_rsp;
pcmd->rspsz = sizeof(struct set_stakey_rsp);
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
} else {
set_stakey_hdl(padapter, (u8 *)psetstakey_para);
rtw_mfree((u8 *) psetstakey_para, sizeof(struct set_stakey_parm));
}
exit:
return res;
}
u8 rtw_clearstakey_cmd(_adapter *padapter, struct sta_info *sta, u8 enqueue)
{
struct cmd_obj *cmd;
struct set_stakey_parm *psetstakey_para;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct set_stakey_rsp *psetstakey_rsp = NULL;
s16 cam_id = 0;
u8 res = _SUCCESS;
if (!sta) {
RTW_ERR("%s sta == NULL\n", __func__);
goto exit;
}
if (!enqueue) {
rtw_hw_del_all_key(padapter, sta, PHL_CMD_DIRECTLY, 0);
} else {
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
if (psetstakey_para == NULL) {
rtw_mfree((u8 *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
if (psetstakey_rsp == NULL) {
rtw_mfree((u8 *)cmd, sizeof(struct cmd_obj));
rtw_mfree((u8 *)psetstakey_para, sizeof(struct set_stakey_parm));
res = _FAIL;
goto exit;
}
init_h2fwcmd_w_parm_no_rsp(cmd, psetstakey_para, CMD_SET_STAKEY);
cmd->rsp = (u8 *) psetstakey_rsp;
cmd->rspsz = sizeof(struct set_stakey_rsp);
_rtw_memcpy(psetstakey_para->addr, sta->phl_sta->mac_addr, ETH_ALEN);
psetstakey_para->algorithm = _NO_PRIVACY_;
res = rtw_enqueue_cmd(pcmdpriv, cmd);
}
exit:
return res;
}
#endif
u8 rtw_addbareq_cmd(_adapter *padapter, u8 tid, u8 *addr)
{
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct cmd_obj *cmd;
struct addBaReq_parm *paddbareq_parm;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
paddbareq_parm = (struct addBaReq_parm *)rtw_zmalloc(sizeof(struct addBaReq_parm));
if (paddbareq_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
paddbareq_parm->tid = tid;
_rtw_memcpy(paddbareq_parm->addr, addr, ETH_ALEN);
init_h2fwcmd_w_parm_no_rsp(cmd, paddbareq_parm, CMD_ADD_BAREQ);
/* RTW_INFO("rtw_addbareq_cmd, tid=%d\n", tid); */
/* rtw_enqueue_cmd(pcmdpriv, ph2c); */
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
u8 rtw_addbarsp_cmd(_adapter *padapter, u8 *addr, u16 tid,
struct ADDBA_request *paddba_req, u8 status,
u8 size, u16 start_seq)
{
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct cmd_obj *cmd;
struct addBaRsp_parm *paddBaRsp_parm;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
paddBaRsp_parm = (struct addBaRsp_parm *)rtw_zmalloc(sizeof(struct addBaRsp_parm));
if (paddBaRsp_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
_rtw_memcpy(paddBaRsp_parm->addr, addr, ETH_ALEN);
_rtw_memcpy(&(paddBaRsp_parm->preq), paddba_req, sizeof(struct ADDBA_request));
paddBaRsp_parm->tid = tid;
paddBaRsp_parm->status = status;
paddBaRsp_parm->size = size;
paddBaRsp_parm->start_seq = start_seq;
init_h2fwcmd_w_parm_no_rsp(cmd, paddBaRsp_parm, CMD_ADD_BARSP);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
u8 rtw_delba_cmd(struct _ADAPTER *a, u8 *addr, u16 tid)
{
struct cmd_priv *cmdpriv = &adapter_to_dvobj(a)->cmdpriv;
struct cmd_obj *cmd = NULL;
struct addBaReq_parm *parm = NULL;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (!cmd)
return _FAIL;
cmd->padapter = a;
parm = (struct addBaReq_parm *)rtw_zmalloc(sizeof(struct addBaReq_parm));
if (!parm) {
rtw_mfree(cmd, sizeof(struct cmd_obj));
return _FAIL;
}
parm->tid = tid;
_rtw_memcpy(parm->addr, addr, ETH_ALEN);
init_h2fwcmd_w_parm_no_rsp(cmd, parm, CMD_DELBA);
return rtw_enqueue_cmd(cmdpriv, cmd);
}
/* add for CONFIG_IEEE80211W, none 11w can use it */
u8 rtw_reset_securitypriv_cmd(_adapter *padapter)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = RESET_SECURITYPRIV;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
/* rtw_enqueue_cmd(pcmdpriv, ph2c); */
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
void free_assoc_resources_hdl(_adapter *padapter, u8 lock_scanned_queue)
{
rtw_free_assoc_resources(padapter, lock_scanned_queue);
}
u8 rtw_free_assoc_resources_cmd(_adapter *padapter, u8 lock_scanned_queue, int flags)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
if (flags & RTW_CMDF_DIRECTLY) {
free_assoc_resources_hdl(padapter, lock_scanned_queue);
}
else {
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = FREE_ASSOC_RESOURCES;
pdrvextra_cmd_parm->type = lock_scanned_queue;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
if (flags & RTW_CMDF_WAIT_ACK) {
cmd->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmd);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmd->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
}
}
exit:
return res;
}
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
u8 rtw_dynamic_chk_wk_cmd(_adapter *padapter)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
/* only primary padapter does this cmd */
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = DYNAMIC_CHK_WK_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
/* rtw_enqueue_cmd(pcmdpriv, ph2c); */
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
#endif
u8 rtw_set_chbw_cmd(_adapter *padapter, u8 ch, u8 bw, u8 ch_offset, u8 flags)
{
struct cmd_obj *pcmdobj;
struct set_ch_parm *set_ch_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
RTW_INFO(FUNC_NDEV_FMT" ch:%u, bw:%u, ch_offset:%u\n",
FUNC_NDEV_ARG(padapter->pnetdev), ch, bw, ch_offset);
/* check input parameter */
/* prepare cmd parameter */
set_ch_parm = (struct set_ch_parm *)rtw_zmalloc(sizeof(*set_ch_parm));
if (set_ch_parm == NULL) {
res = _FAIL;
goto exit;
}
set_ch_parm->ch = ch;
set_ch_parm->bw = bw;
set_ch_parm->ch_offset = ch_offset;
set_ch_parm->do_rfk = _FALSE;/*TODO - Need check if do_rfk*/
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != rtw_set_chbw_hdl(padapter, (u8 *)set_ch_parm))
res = _FAIL;
rtw_mfree((u8 *)set_ch_parm, sizeof(*set_ch_parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmdobj == NULL) {
rtw_mfree((u8 *)set_ch_parm, sizeof(*set_ch_parm));
res = _FAIL;
goto exit;
}
pcmdobj->padapter = padapter;
init_h2fwcmd_w_parm_no_rsp(pcmdobj, set_ch_parm, CMD_SET_CHANNEL);
if (flags & RTW_CMDF_WAIT_ACK) {
pcmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 10 * 1000);
}
res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
pcmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
}
}
/* do something based on res... */
exit:
RTW_INFO(FUNC_NDEV_FMT" res:%u\n", FUNC_NDEV_ARG(padapter->pnetdev), res);
return res;
}
static u8 _rtw_set_chplan_cmd(_adapter *adapter, int flags
, u8 chplan, u8 chplan_6g, const struct country_chplan *country_ent
, enum regd_src_t regd_src, enum rtw_regd_inr inr
, const struct country_ie_slave_record *cisr)
{
struct cmd_obj *cmdobj;
struct SetChannelPlan_param *parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
#ifdef PLATFORM_LINUX
bool rtnl_lock_needed = rtw_rtnl_lock_needed(adapter_to_dvobj(adapter));
#endif
u8 res = _SUCCESS;
/* check if allow software config */
if (rtw_rfctl_is_disable_sw_channel_plan(adapter_to_dvobj(adapter)) == _TRUE) {
res = _FAIL;
goto exit;
}
if (country_ent) {
/* if country_entry is provided, replace chplan */
chplan = country_ent->chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
chplan_6g = country_ent->chplan_6g;
#endif
}
/* prepare cmd parameter */
parm = (struct SetChannelPlan_param *)rtw_zmalloc(sizeof(*parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
parm->regd_src = regd_src;
parm->inr = inr;
if (country_ent) {
_rtw_memcpy(&parm->country_ent, country_ent, sizeof(parm->country_ent));
parm->has_country = 1;
}
parm->channel_plan = chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
parm->channel_plan_6g = chplan_6g;
#endif
#ifdef CONFIG_80211D
if (cisr) {
_rtw_memcpy(&parm->cisr, cisr, sizeof(*cisr));
parm->has_cisr = 1;
}
#endif
#ifdef PLATFORM_LINUX
if (flags & (RTW_CMDF_DIRECTLY | RTW_CMDF_WAIT_ACK))
parm->rtnl_lock_needed = rtnl_lock_needed; /* synchronous call, follow caller's */
else
parm->rtnl_lock_needed = 1; /* asynchronous call, always needed */
#endif
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != rtw_set_chplan_hdl(adapter, (u8 *)parm))
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_CHANPLAN);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
/* allow set channel plan when cmd_thread is not running */
if (res != _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
parm = (struct SetChannelPlan_param *)rtw_zmalloc(sizeof(*parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
parm->regd_src = regd_src;
parm->inr = inr;
if (country_ent) {
_rtw_memcpy(&parm->country_ent, country_ent, sizeof(parm->country_ent));
parm->has_country = 1;
}
parm->channel_plan = chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
parm->channel_plan_6g = chplan_6g;
#endif
#ifdef CONFIG_80211D
if (cisr) {
_rtw_memcpy(&parm->cisr, cisr, sizeof(*cisr));
parm->has_cisr = 1;
}
#endif
#ifdef PLATFORM_LINUX
parm->rtnl_lock_needed = rtnl_lock_needed; /* synchronous call, follow caller's */
#endif
if (H2C_SUCCESS != rtw_set_chplan_hdl(adapter, (u8 *)parm))
res = _FAIL;
else
res = _SUCCESS;
rtw_mfree((u8 *)parm, sizeof(*parm));
}
}
exit:
return res;
}
inline u8 rtw_set_chplan_cmd(_adapter *adapter, int flags, u8 chplan, u8 chplan_6g, enum rtw_regd_inr inr)
{
return _rtw_set_chplan_cmd(adapter, flags, chplan, chplan_6g, NULL, REGD_SRC_RTK_PRIV, inr, NULL);
}
inline u8 rtw_set_country_cmd(_adapter *adapter, int flags, const char *country_code, enum rtw_regd_inr inr)
{
struct country_chplan ent;
if (IS_ALPHA2_WORLDWIDE(country_code)) {
rtw_get_chplan_worldwide(&ent);
goto cmd;
}
if (is_alpha(country_code[0]) == _FALSE
|| is_alpha(country_code[1]) == _FALSE
) {
RTW_PRINT("%s input country_code is not alpha2\n", __func__);
return _FAIL;
}
if (!rtw_get_chplan_from_country(country_code, &ent)) {
RTW_PRINT("%s unsupported country_code:\"%c%c\"\n", __func__, country_code[0], country_code[1]);
return _FAIL;
}
cmd:
RTW_PRINT("%s country_code:\"%c%c\"\n", __func__, country_code[0], country_code[1]);
return _rtw_set_chplan_cmd(adapter, flags, RTW_CHPLAN_UNSPECIFIED, RTW_CHPLAN_6G_UNSPECIFIED, &ent, REGD_SRC_RTK_PRIV, inr, NULL);
}
#ifdef CONFIG_REGD_SRC_FROM_OS
inline u8 rtw_sync_os_regd_cmd(_adapter *adapter, int flags, const char *country_code, u8 dfs_region, enum rtw_regd_inr inr)
{
struct country_chplan ent;
struct country_chplan rtk_ent;
bool rtk_ent_exist;
rtk_ent_exist = rtw_get_chplan_from_country(country_code, &rtk_ent);
_rtw_memcpy(ent.alpha2, country_code, 2);
/*
* Regulation follows OS, the internal txpwr limit selection is searched by alpha2
* "00" => WW, others use string mapping
* When no matching txpwr limit selection is found, use
* 1. txpwr lmit selection associated with alpha2 inside driver regulation database
* 2. WW when driver has no support of this alpha2
*/
ent.chplan = rtk_ent_exist ? rtk_ent.chplan : RTW_CHPLAN_UNSPECIFIED;
#if CONFIG_IEEE80211_BAND_6GHZ
ent.chplan_6g = rtk_ent_exist ? rtk_ent.chplan_6g : RTW_CHPLAN_6G_UNSPECIFIED;
#endif
ent.edcca_mode_2g_override = rtk_ent_exist ? rtk_ent.edcca_mode_2g_override : RTW_EDCCA_DEF;
#if CONFIG_IEEE80211_BAND_5GHZ
ent.edcca_mode_5g_override = rtk_ent_exist ? rtk_ent.edcca_mode_5g_override : RTW_EDCCA_DEF;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
ent.edcca_mode_6g_override = rtk_ent_exist ? rtk_ent.edcca_mode_6g_override : RTW_EDCCA_DEF;
#endif
ent.txpwr_lmt_override = rtk_ent_exist ? rtk_ent.txpwr_lmt_override : TXPWR_LMT_DEF;
#if defined(CONFIG_80211AC_VHT) || defined(CONFIG_80211AX_HE)
ent.proto_en = CHPLAN_PROTO_EN_ALL;
#endif
/* TODO: dfs_region */
return _rtw_set_chplan_cmd(adapter, flags, RTW_CHPLAN_UNSPECIFIED, RTW_CHPLAN_6G_UNSPECIFIED, &ent, REGD_SRC_OS, inr, NULL);
}
#endif /* CONFIG_REGD_SRC_FROM_OS */
u8 rtw_get_chplan_cmd(_adapter *adapter, int flags, struct get_chplan_resp **chplan)
{
struct cmd_obj *cmdobj;
struct get_channel_plan_param *parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _FAIL;
if (!(flags & (RTW_CMDF_DIRECTLY | RTW_CMDF_WAIT_ACK)))
goto exit;
/* prepare cmd parameter */
parm = rtw_zmalloc(sizeof(*parm));
if (parm == NULL)
goto exit;
parm->chplan = chplan;
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS == rtw_get_chplan_hdl(adapter, (u8 *)parm))
res = _SUCCESS;
rtw_mfree((u8 *)parm, sizeof(*parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_GET_CHANPLAN);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
/* allow get channel plan when cmd_thread is not running */
if (res != _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
parm = rtw_zmalloc(sizeof(*parm));
if (parm == NULL)
goto exit;
parm->chplan = chplan;
if (H2C_SUCCESS == rtw_get_chplan_hdl(adapter, (u8 *)parm))
res = _SUCCESS;
rtw_mfree((u8 *)parm, sizeof(*parm));
}
}
exit:
return res;
}
#ifdef CONFIG_80211D
inline u8 rtw_apply_recv_country_ie_cmd(_adapter *adapter, int flags, enum band_type band,u8 opch, const u8 *country_ie)
{
struct country_chplan ent;
struct country_ie_slave_record cisr;
rtw_get_chplan_from_recv_country_ie(adapter, band, opch, country_ie, &ent, &cisr, NULL);
return _rtw_set_chplan_cmd(adapter, flags, RTW_CHPLAN_UNSPECIFIED, RTW_CHPLAN_6G_UNSPECIFIED
, NULL, REGD_SRC_RTK_PRIV, RTW_REGD_SET_BY_COUNTRY_IE, &cisr);
}
#endif /* CONFIG_80211D */
#ifdef CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD
u8 rtw_led_blink_cmd(_adapter *padapter, void *pLed)
{
struct cmd_obj *pcmdobj;
struct LedBlink_param *ledBlink_param;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmdobj == NULL) {
res = _FAIL;
goto exit;
}
pcmdobj->padapter = padapter;
ledBlink_param = (struct LedBlink_param *)rtw_zmalloc(sizeof(struct LedBlink_param));
if (ledBlink_param == NULL) {
rtw_mfree((u8 *)pcmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
ledBlink_param->pLed = pLed;
init_h2fwcmd_w_parm_no_rsp(pcmdobj, ledBlink_param, CMD_LEDBLINK);
res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
exit:
return res;
}
#endif /*CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD*/
u8 rtw_set_csa_cmd(_adapter *adapter)
{
struct cmd_obj *cmdobj;
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _SUCCESS;
cmdobj = rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_parm_rsp(cmdobj, CMD_SET_CHANSWITCH);
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
exit:
return res;
}
u8 rtw_tdls_cmd(_adapter *padapter, u8 *addr, u8 option)
{
u8 res = _SUCCESS;
#ifdef CONFIG_TDLS
struct cmd_obj *pcmdobj;
struct TDLSoption_param *TDLSoption;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmdobj == NULL) {
res = _FAIL;
goto exit;
}
pcmdobj->padapter = padapter;
TDLSoption = (struct TDLSoption_param *)rtw_zmalloc(sizeof(struct TDLSoption_param));
if (TDLSoption == NULL) {
rtw_mfree((u8 *)pcmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
_rtw_spinlock(&(padapter->tdlsinfo.cmd_lock));
if (addr != NULL)
_rtw_memcpy(TDLSoption->addr, addr, 6);
TDLSoption->option = option;
_rtw_spinunlock(&(padapter->tdlsinfo.cmd_lock));
init_h2fwcmd_w_parm_no_rsp(pcmdobj, TDLSoption, CMD_TDLS);
res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
exit:
#endif /* CONFIG_TDLS */
return res;
}
u8 rtw_ssmps_wk_hdl(_adapter *adapter, struct ssmps_cmd_parm *ssmp_param)
{
u8 res = _SUCCESS;
struct sta_info *sta = ssmp_param->sta;
u8 smps = ssmp_param->smps;
if (sta == NULL)
return _FALSE;
if (smps)
rtw_ssmps_enter(adapter, sta);
else
rtw_ssmps_leave(adapter, sta);
return res;
}
u8 rtw_ssmps_wk_cmd(_adapter *adapter, struct sta_info *sta, u8 smps, u8 enqueue)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *cmd_parm;
struct ssmps_cmd_parm *ssmp_param;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _SUCCESS;
if (enqueue) {
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
ssmp_param = (struct ssmps_cmd_parm *)rtw_zmalloc(sizeof(struct ssmps_cmd_parm));
if (ssmp_param == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
rtw_mfree((u8 *)cmd_parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
ssmp_param->smps = smps;
ssmp_param->sta = sta;
cmd_parm->ec_id = SSMPS_WK_CID;
cmd_parm->type = 0;
cmd_parm->size = sizeof(struct ssmps_cmd_parm);
cmd_parm->pbuf = (u8 *)ssmp_param;
init_h2fwcmd_w_parm_no_rsp(cmdobj, cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
} else {
struct ssmps_cmd_parm tmp_ssmp_param;
tmp_ssmp_param.smps = smps;
tmp_ssmp_param.sta = sta;
rtw_ssmps_wk_hdl(adapter, &tmp_ssmp_param);
}
exit:
return res;
}
#ifdef CONFIG_SUPPORT_STATIC_SMPS
u8 _ssmps_chk_by_tp(_adapter *adapter, u8 from_timer)
{
u8 enter_smps = _FALSE;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct sta_priv *pstapriv = &adapter->stapriv;
struct sta_info *psta;
u32 tx_tp_mbits, rx_tp_mbits;
if (!MLME_IS_STA(adapter) ||
!rtw_hw_is_mimo_support(adapter_to_dvobj(adapter)) ||
!pmlmeext->ssmps_en ||
(pmlmeext->chandef.chan > 14)
)
return enter_smps;
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (psta == NULL) {
RTW_ERR(ADPT_FMT" sta == NULL\n", ADPT_ARG(adapter));
rtw_warn_on(1);
return enter_smps;
}
/*TODO*/
if (psta->phl_sta->asoc_cap.nss_tx == 1)
return enter_smps;
tx_tp_mbits = psta->sta_stats.tx_tp_kbits >> 10;
rx_tp_mbits = psta->sta_stats.rx_tp_kbits >> 10;
#ifdef DBG_STATIC_SMPS
if (pmlmeext->ssmps_test) {
enter_smps = (pmlmeext->ssmps_test_en == 1) ? _TRUE : _FALSE;
}
else
#endif
{
if ((tx_tp_mbits <= pmlmeext->ssmps_tx_tp_th) &&
(rx_tp_mbits <= pmlmeext->ssmps_rx_tp_th))
enter_smps = _TRUE;
else
enter_smps = _FALSE;
}
if (1) {
RTW_INFO(FUNC_ADPT_FMT" tx_tp:%d [%d], rx_tp:%d [%d] , SSMPS enter :%s\n",
FUNC_ADPT_ARG(adapter),
tx_tp_mbits, pmlmeext->ssmps_tx_tp_th,
rx_tp_mbits, pmlmeext->ssmps_rx_tp_th,
(enter_smps == _TRUE) ? "True" : "False");
#ifdef DBG_STATIC_SMPS
RTW_INFO(FUNC_ADPT_FMT" test:%d test_en:%d\n",
FUNC_ADPT_ARG(adapter),
pmlmeext->ssmps_test,
pmlmeext->ssmps_test_en);
#endif
}
if (enter_smps) {
if (!from_timer && psta->phl_sta->sm_ps != SM_PS_STATIC)
rtw_ssmps_enter(adapter, psta);
} else {
if (!from_timer && psta->phl_sta->sm_ps != SM_PS_DISABLE)
rtw_ssmps_leave(adapter, psta);
else {
u8 ps_change = _FALSE;
if (enter_smps && psta->phl_sta->sm_ps != SM_PS_STATIC)
ps_change = _TRUE;
else if (!enter_smps && psta->phl_sta->sm_ps != SM_PS_DISABLE)
ps_change = _TRUE;
if (ps_change)
rtw_ssmps_wk_cmd(adapter, psta, enter_smps, 1);
}
}
return enter_smps;
}
#endif /*CONFIG_SUPPORT_STATIC_SMPS*/
#ifdef CONFIG_CTRL_TXSS_BY_TP
void rtw_ctrl_txss_update(_adapter *adapter, struct sta_info *sta)
{
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
pmlmeext->txss_bk = sta->phl_sta->asoc_cap.nss_rx;
}
u8 rtw_ctrl_txss(_adapter *adapter, struct sta_info *sta, bool tx_1ss)
{
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
u8 lps_changed = _FALSE;
u8 rst = _SUCCESS;
if (pmlmeext->txss_1ss == tx_1ss)
return _FALSE;
/*
if (pwrpriv->bLeisurePs && pwrpriv->pwr_mode != PM_PS_MODE_ACTIVE) {
lps_changed = _TRUE;
LPS_Leave(adapter, "LPS_CTRL_TXSS");
}
*/
RTW_INFO(ADPT_FMT" STA [" MAC_FMT "] set tx to %d ss\n",
ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr),
(tx_1ss) ? 1 : rtw_get_sta_tx_nss(adapter, sta));
/*update ra*/
if (tx_1ss)
sta->phl_sta->asoc_cap.nss_rx = 1;
else
sta->phl_sta->asoc_cap.nss_rx = pmlmeext->txss_bk;
rtw_phl_cmd_change_stainfo(adapter_to_dvobj(adapter)->phl,
sta->phl_sta,
STA_CHG_RAMASK,
NULL,
0,
PHL_CMD_DIRECTLY,
0);
/*configure trx mode*/
/*rtw_phydm_trx_cfg(adapter, tx_1ss);*/
pmlmeext->txss_1ss = tx_1ss;
/*
if (lps_changed)
LPS_Enter(adapter, "LPS_CTRL_TXSS");
*/
return rst;
}
u8 rtw_ctrl_txss_wk_hdl(_adapter *adapter, struct txss_cmd_parm *txss_param)
{
if (!txss_param->sta)
return _FALSE;
return rtw_ctrl_txss(adapter, txss_param->sta, txss_param->tx_1ss);
}
u8 rtw_ctrl_txss_wk_cmd(_adapter *adapter, struct sta_info *sta, bool tx_1ss, u8 flag)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *cmd_parm;
struct txss_cmd_parm *txss_param;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
txss_param = (struct txss_cmd_parm *)rtw_zmalloc(sizeof(struct txss_cmd_parm));
if (txss_param == NULL) {
res = _FAIL;
goto exit;
}
txss_param->tx_1ss = tx_1ss;
txss_param->sta = sta;
if (flag & RTW_CMDF_DIRECTLY) {
res = rtw_ctrl_txss_wk_hdl(adapter, txss_param);
rtw_mfree((u8 *)txss_param, sizeof(*txss_param));
} else {
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (cmd_parm == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
cmd_parm->ec_id = TXSS_WK_CID;
cmd_parm->type = 0;
cmd_parm->size = sizeof(struct txss_cmd_parm);
cmd_parm->pbuf = (u8 *)txss_param;
init_h2fwcmd_w_parm_no_rsp(cmdobj, cmd_parm, CMD_SET_DRV_EXTRA);
if (flag & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 10 * 1000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flag & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
}
exit:
return res;
}
void rtw_ctrl_tx_ss_by_tp(_adapter *adapter, u8 from_timer)
{
bool tx_1ss = _FALSE; /*change tx from 2ss to 1ss*/
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct sta_priv *pstapriv = &adapter->stapriv;
struct sta_info *psta;
u32 tx_tp_mbits;
if (!MLME_IS_STA(adapter) ||
!rtw_hw_is_mimo_support(adapter_to_dvobj(adapter)) ||
!pmlmeext->txss_ctrl_en
)
return;
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (psta == NULL) {
RTW_ERR(ADPT_FMT" sta == NULL\n", ADPT_ARG(adapter));
rtw_warn_on(1);
return;
}
tx_tp_mbits = psta->sta_stats.tx_tp_kbits >> 10;
if (tx_tp_mbits >= pmlmeext->txss_tp_th) {
tx_1ss = _FALSE;
} else {
if (pmlmeext->txss_tp_chk_cnt && --pmlmeext->txss_tp_chk_cnt)
tx_1ss = _FALSE;
else
tx_1ss = _TRUE;
}
if (1) {
RTW_INFO(FUNC_ADPT_FMT" tx_tp:%d [%d] tx_1ss(%d):%s\n",
FUNC_ADPT_ARG(adapter),
tx_tp_mbits, pmlmeext->txss_tp_th,
pmlmeext->txss_tp_chk_cnt,
(tx_1ss == _TRUE) ? "True" : "False");
}
if (pmlmeext->txss_1ss != tx_1ss) {
if (from_timer)
rtw_ctrl_txss_wk_cmd(adapter, psta, tx_1ss, 0);
else
rtw_ctrl_txss(adapter, psta, tx_1ss);
}
}
#ifdef DBG_CTRL_TXSS
void dbg_ctrl_txss(_adapter *adapter, bool tx_1ss)
{
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct sta_priv *pstapriv = &adapter->stapriv;
struct sta_info *psta;
if (!MLME_IS_STA(adapter) ||
!rtw_hw_is_mimo_support(adapter_to_dvobj(adapter))
)
return;
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (psta == NULL) {
RTW_ERR(ADPT_FMT" sta == NULL\n", ADPT_ARG(adapter));
rtw_warn_on(1);
return;
}
rtw_ctrl_txss(adapter, psta, tx_1ss);
}
#endif
#endif /*CONFIG_CTRL_TXSS_BY_TP*/
#ifdef CONFIG_LPS
#ifdef CONFIG_LPS_CHK_BY_TP
#ifdef LPS_BCN_CNT_MONITOR
static u8 _bcn_cnt_expected(struct sta_info *psta)
{
_adapter *adapter = psta->padapter;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 dtim = rtw_get_bcn_dtim_period(adapter);
u8 bcn_cnt = 0;
if ((pmlmeinfo->bcn_interval !=0) && (dtim != 0))
bcn_cnt = 2000 / pmlmeinfo->bcn_interval / dtim * 4 / 5; /*2s*/
if (0)
RTW_INFO("%s bcn_cnt:%d\n", __func__, bcn_cnt);
if (bcn_cnt == 0) {
RTW_ERR(FUNC_ADPT_FMT" bcn_cnt == 0\n", FUNC_ADPT_ARG(adapter));
rtw_warn_on(1);
}
return bcn_cnt;
}
#endif
u8 _lps_chk_by_tp(_adapter *adapter, u8 from_timer)
{
u8 enter_ps = _FALSE;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct sta_priv *pstapriv = &adapter->stapriv;
struct sta_info *psta;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
u32 tx_tp_mbits, rx_tp_mbits, bi_tp_mbits;
u8 rx_bcn_cnt;
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (psta == NULL) {
RTW_ERR(ADPT_FMT" sta == NULL\n", ADPT_ARG(adapter));
rtw_warn_on(1);
return enter_ps;
}
rx_bcn_cnt = rtw_get_bcn_cnt(psta->padapter);
psta->sta_stats.acc_tx_bytes = psta->sta_stats.tx_bytes;
psta->sta_stats.acc_rx_bytes = psta->sta_stats.rx_bytes;
#if 1
tx_tp_mbits = psta->sta_stats.tx_tp_kbits >> 10;
rx_tp_mbits = psta->sta_stats.rx_tp_kbits >> 10;
bi_tp_mbits = tx_tp_mbits + rx_tp_mbits;
#else
tx_tp_mbits = psta->sta_stats.smooth_tx_tp_kbits >> 10;
rx_tp_mbits = psta->sta_stats.smooth_rx_tp_kbits >> 10;
bi_tp_mbits = tx_tp_mbits + rx_tp_mbits;
#endif
if ((bi_tp_mbits >= pwrpriv->lps_bi_tp_th) ||
(tx_tp_mbits >= pwrpriv->lps_tx_tp_th) ||
(rx_tp_mbits >= pwrpriv->lps_rx_tp_th)) {
enter_ps = _FALSE;
pwrpriv->lps_chk_cnt = pwrpriv->lps_chk_cnt_th;
}
else {
#ifdef LPS_BCN_CNT_MONITOR
u8 bcn_cnt = _bcn_cnt_expected(psta);
if (bcn_cnt && (rx_bcn_cnt < bcn_cnt)) {
pwrpriv->lps_chk_cnt = 2;
RTW_ERR(FUNC_ADPT_FMT" BCN_CNT:%d(%d) invalid\n",
FUNC_ADPT_ARG(adapter), rx_bcn_cnt, bcn_cnt);
}
#endif
if (pwrpriv->lps_chk_cnt && --pwrpriv->lps_chk_cnt)
enter_ps = _FALSE;
else
enter_ps = _TRUE;
}
if (1) {
RTW_INFO(FUNC_ADPT_FMT" tx_tp:%d [%d], rx_tp:%d [%d], bi_tp:%d [%d], enter_ps(%d):%s\n",
FUNC_ADPT_ARG(adapter),
tx_tp_mbits, pwrpriv->lps_tx_tp_th,
rx_tp_mbits, pwrpriv->lps_rx_tp_th,
bi_tp_mbits, pwrpriv->lps_bi_tp_th,
pwrpriv->lps_chk_cnt,
(enter_ps == _TRUE) ? "True" : "False");
RTW_INFO(FUNC_ADPT_FMT" tx_pkt_cnt :%d [%d], rx_pkt_cnt :%d [%d]\n",
FUNC_ADPT_ARG(adapter),
pmlmepriv->LinkDetectInfo.NumTxOkInPeriod,
pwrpriv->lps_tx_pkts,
pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod,
pwrpriv->lps_rx_pkts);
if (!adapter->bsta_tp_dump)
RTW_INFO(FUNC_ADPT_FMT" bcn_cnt:%d (per-%d second)\n",
FUNC_ADPT_ARG(adapter),
rx_bcn_cnt,
2);
}
if (enter_ps) {
if (!from_timer)
LPS_Enter(adapter, "TRAFFIC_IDLE");
} else {
if (!from_timer)
LPS_Leave(adapter, "TRAFFIC_BUSY");
else {
#ifdef CONFIG_CONCURRENT_MODE
#ifndef CONFIG_FW_MULTI_PORT_SUPPORT
if (adapter->hw_port == HW_PORT0)
#endif
#endif
rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_TRAFFIC_BUSY, 0);
}
}
return enter_ps;
}
#endif
static u8 _lps_chk_by_pkt_cnts(_adapter *padapter, u8 from_timer, u8 bBusyTraffic)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 bEnterPS = _FALSE;
/* check traffic for powersaving. */
if (((pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod + pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
#ifdef CONFIG_LPS_SLOW_TRANSITION
(pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 2)
#else /* CONFIG_LPS_SLOW_TRANSITION */
(pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 4)
#endif /* CONFIG_LPS_SLOW_TRANSITION */
) {
#ifdef DBG_RX_COUNTER_DUMP
if (padapter->dump_rx_cnt_mode & DUMP_DRV_TRX_COUNTER_DATA)
RTW_INFO("(-)Tx = %d, Rx = %d\n", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod, pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod);
#endif
bEnterPS = _FALSE;
#ifdef CONFIG_LPS_SLOW_TRANSITION
if (bBusyTraffic == _TRUE) {
if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount <= 4)
pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 4;
pmlmepriv->LinkDetectInfo.TrafficTransitionCount++;
/* RTW_INFO("Set TrafficTransitionCount to %d\n", pmlmepriv->LinkDetectInfo.TrafficTransitionCount); */
if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount > 30/*TrafficTransitionLevel*/)
pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 30;
}
#endif /* CONFIG_LPS_SLOW_TRANSITION */
} else {
#ifdef DBG_RX_COUNTER_DUMP
if (padapter->dump_rx_cnt_mode & DUMP_DRV_TRX_COUNTER_DATA)
RTW_INFO("(+)Tx = %d, Rx = %d\n", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod, pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod);
#endif
#ifdef CONFIG_LPS_SLOW_TRANSITION
if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount >= 2)
pmlmepriv->LinkDetectInfo.TrafficTransitionCount -= 2;
else
pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount == 0)
bEnterPS = _TRUE;
#else /* CONFIG_LPS_SLOW_TRANSITION */
bEnterPS = _TRUE;
#endif /* CONFIG_LPS_SLOW_TRANSITION */
}
#ifdef CONFIG_DYNAMIC_DTIM
if (pmlmepriv->LinkDetectInfo.LowPowerTransitionCount == 8)
bEnterPS = _FALSE;
RTW_INFO("LowPowerTransitionCount=%d\n", pmlmepriv->LinkDetectInfo.LowPowerTransitionCount);
#endif /* CONFIG_DYNAMIC_DTIM */
/* LeisurePS only work in infra mode. */
if (bEnterPS) {
if (!from_timer) {
#ifdef CONFIG_DYNAMIC_DTIM
if (pmlmepriv->LinkDetectInfo.LowPowerTransitionCount < 8)
adapter_to_pwrctl(padapter)->dtim = 1;
else
adapter_to_pwrctl(padapter)->dtim = 3;
#endif /* CONFIG_DYNAMIC_DTIM */
LPS_Enter(padapter, "TRAFFIC_IDLE");
} else {
/* do this at caller */
/* rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_ENTER, 0); */
/* rtw_hal_dm_watchdog_in_lps(padapter); */
}
#ifdef CONFIG_DYNAMIC_DTIM
if (adapter_to_pwrctl(padapter)->bFwCurrentInPSMode == _TRUE)
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount++;
#endif /* CONFIG_DYNAMIC_DTIM */
} else {
#ifdef CONFIG_DYNAMIC_DTIM
if (pmlmepriv->LinkDetectInfo.LowPowerTransitionCount != 8)
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
else
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount++;
#endif /* CONFIG_DYNAMIC_DTIM */
if (!from_timer)
LPS_Leave(padapter, "TRAFFIC_BUSY");
else {
#ifdef CONFIG_CONCURRENT_MODE
#ifndef CONFIG_FW_MULTI_PORT_SUPPORT
if (padapter->hw_port == HW_PORT0)
#endif
#endif
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_TRAFFIC_BUSY, 0);
}
}
return bEnterPS;
}
#endif /* CONFIG_LPS */
/* from_timer == 1 means driver is in LPS */
u8 traffic_status_watchdog(_adapter *padapter, u8 from_timer)
{
u8 bEnterPS = _FALSE;
u16 BusyThresholdHigh;
u16 BusyThresholdLow;
u16 BusyThreshold;
u8 bBusyTraffic = _FALSE, bTxBusyTraffic = _FALSE, bRxBusyTraffic = _FALSE;
u8 bHigherBusyTraffic = _FALSE, bHigherBusyRxTraffic = _FALSE, bHigherBusyTxTraffic = _FALSE;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &(padapter->tdlsinfo);
struct tdls_txmgmt txmgmt;
u8 baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
#endif /* CONFIG_TDLS */
#ifdef CONFIG_TRAFFIC_PROTECT
RT_LINK_DETECT_T *link_detect = &pmlmepriv->LinkDetectInfo;
#endif
#ifdef CONFIG_BTC
if (padapter->registrypriv.wifi_spec != 1) {
BusyThresholdHigh = 25;
BusyThresholdLow = 10;
} else
#endif /* CONFIG_BTC */
{
BusyThresholdHigh = 100;
BusyThresholdLow = 75;
}
BusyThreshold = BusyThresholdHigh;
/* */
/* Determine if our traffic is busy now */
/* */
if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
/*&& !MgntInitAdapterInProgress(pMgntInfo)*/) {
/* if we raise bBusyTraffic in last watchdog, using lower threshold. */
if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
BusyThreshold = BusyThresholdLow;
if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > BusyThreshold ||
pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > BusyThreshold) {
bBusyTraffic = _TRUE;
if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
bRxBusyTraffic = _TRUE;
else
bTxBusyTraffic = _TRUE;
}
/* Higher Tx/Rx data. */
if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 4000 ||
pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 4000) {
bHigherBusyTraffic = _TRUE;
if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
bHigherBusyRxTraffic = _TRUE;
else
bHigherBusyTxTraffic = _TRUE;
}
#ifdef CONFIG_TRAFFIC_PROTECT
#define TX_ACTIVE_TH 10
#define RX_ACTIVE_TH 20
#define TRAFFIC_PROTECT_PERIOD_MS 4500
if (link_detect->NumTxOkInPeriod > TX_ACTIVE_TH
|| link_detect->NumRxUnicastOkInPeriod > RX_ACTIVE_TH) {
RTW_INFO(FUNC_ADPT_FMT" acqiure wake_lock for %u ms(tx:%d,rx_unicast:%d)\n",
FUNC_ADPT_ARG(padapter),
TRAFFIC_PROTECT_PERIOD_MS,
link_detect->NumTxOkInPeriod,
link_detect->NumRxUnicastOkInPeriod);
rtw_lock_traffic_suspend_timeout(TRAFFIC_PROTECT_PERIOD_MS);
}
#endif
#ifdef CONFIG_TDLS
#ifdef CONFIG_TDLS_AUTOSETUP
/* TDLS_WATCHDOG_PERIOD * 2sec, periodically send */
if (rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_TDLS) == _TRUE) {
if ((ptdlsinfo->watchdog_count % TDLS_WATCHDOG_PERIOD) == 0) {
_rtw_memcpy(txmgmt.peer, baddr, ETH_ALEN);
issue_tdls_dis_req(padapter, &txmgmt);
}
ptdlsinfo->watchdog_count++;
}
#endif /* CONFIG_TDLS_AUTOSETUP */
#endif /* CONFIG_TDLS */
#ifdef CONFIG_SUPPORT_STATIC_SMPS
_ssmps_chk_by_tp(padapter, from_timer);
#endif
#ifdef CONFIG_CTRL_TXSS_BY_TP
rtw_ctrl_tx_ss_by_tp(padapter, from_timer);
#endif
#ifdef CONFIG_LPS
if (adapter_to_pwrctl(padapter)->bLeisurePs && MLME_IS_STA(padapter)) {
#ifdef CONFIG_LPS_CHK_BY_TP
if (adapter_to_pwrctl(padapter)->lps_chk_by_tp)
bEnterPS = _lps_chk_by_tp(padapter, from_timer);
else
#endif /*CONFIG_LPS_CHK_BY_TP*/
bEnterPS = _lps_chk_by_pkt_cnts(padapter, from_timer, bBusyTraffic);
}
#endif /* CONFIG_LPS */
} else {
#ifdef CONFIG_LPS
if (!from_timer && rtw_mi_get_assoc_if_num(padapter) == 0)
LPS_Leave(padapter, "NON_LINKED");
#endif
}
session_tracker_chk_cmd(padapter, NULL);
#ifdef CONFIG_BEAMFORMING
#ifdef RTW_WKARD_TX_DISABLE_BFEE
/*For each padapter*/
rtw_core_bf_watchdog(padapter);
#endif
#endif
pmlmepriv->LinkDetectInfo.NumRxOkInPeriod = 0;
pmlmepriv->LinkDetectInfo.NumTxOkInPeriod = 0;
pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
pmlmepriv->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
pmlmepriv->LinkDetectInfo.bTxBusyTraffic = bTxBusyTraffic;
pmlmepriv->LinkDetectInfo.bRxBusyTraffic = bRxBusyTraffic;
pmlmepriv->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;
pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
pmlmepriv->LinkDetectInfo.bHigherBusyTxTraffic = bHigherBusyTxTraffic;
return bEnterPS;
}
/* for 11n Logo 4.2.31/4.2.32 */
static void dynamic_update_bcn_check(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
if (!padapter->registrypriv.wifi_spec)
return;
if (!padapter->registrypriv.ht_enable || !is_supported_ht(padapter->registrypriv.wireless_mode))
return;
if (!MLME_IS_AP(padapter))
return;
if (pmlmeext->bstart_bss) {
/* In 10 * 2 = 20s, there are no legacy AP, update HT info */
static u8 count = 1;
if (count % 10 == 0) {
count = 1;
#ifdef CONFIG_80211N_HT
if (_FALSE == ATOMIC_READ(&pmlmepriv->olbc)
&& _FALSE == ATOMIC_READ(&pmlmepriv->olbc_ht)) {
if (rtw_ht_operation_update(padapter) > 0) {
rtw_update_beacon(padapter, _HT_CAPABILITY_IE_, NULL, _FALSE, 0);
rtw_update_beacon(padapter, _HT_ADD_INFO_IE_, NULL, _TRUE, 0);
}
}
#endif /* CONFIG_80211N_HT */
}
#ifdef CONFIG_80211N_HT
/* In 2s, there are any legacy AP, update HT info, and then reset count */
if (_FALSE != ATOMIC_READ(&pmlmepriv->olbc)
&& _FALSE != ATOMIC_READ(&pmlmepriv->olbc_ht)) {
if (rtw_ht_operation_update(padapter) > 0) {
rtw_update_beacon(padapter, _HT_CAPABILITY_IE_, NULL, _FALSE, 0);
rtw_update_beacon(padapter, _HT_ADD_INFO_IE_, NULL, _TRUE, 0);
}
ATOMIC_SET(&pmlmepriv->olbc, _FALSE);
ATOMIC_SET(&pmlmepriv->olbc_ht, _FALSE);
count = 0;
}
#endif /* CONFIG_80211N_HT */
count ++;
}
}
struct turbo_edca_setting{
u32 edca_ul; /* uplink, tx */
u32 edca_dl; /* downlink, rx */
};
#define TURBO_EDCA_ENT(UL, DL) {UL, DL}
#define TURBO_EDCA_MODE_NUM 8
static struct turbo_edca_setting ctrl_turbo_edca[TURBO_EDCA_MODE_NUM] = {
/* { UL, DL } */
TURBO_EDCA_ENT(0x5e431c, 0x431c), /* mode 0 */
TURBO_EDCA_ENT(0x431c, 0x431c), /* mode 1 */
TURBO_EDCA_ENT(0x5e431c, 0x5e431c), /* mode 2 */
TURBO_EDCA_ENT(0x5ea42b, 0x5ea42b), /* mode 3 */
TURBO_EDCA_ENT(0x5ea42b, 0x431c), /* mode 4 */
TURBO_EDCA_ENT(0x6ea42b, 0x6ea42b), /* mode 5 */
TURBO_EDCA_ENT(0xa42b, 0xa42b), /* mode 6 */
TURBO_EDCA_ENT(0x5e431c, 0xa42b), /* mode 7 */
};
void rtw_turbo_edca(_adapter *padapter)
{
struct registry_priv *pregpriv = &padapter->registrypriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_phl_com_t *phl_com = GET_PHL_COM(dvobj);
u32 edca_be_ul = padapter->last_edca;
u32 edca_be_dl = padapter->last_edca;
u32 ac_parm = padapter->last_edca;
u8 ac;
u8 is_linked = _FALSE;
if (padapter->dis_turboedca == DIS_TURBO)
return;
if (rtw_mi_check_status(padapter, MI_ASSOC))
is_linked = _TRUE;
if (is_linked != _TRUE)
return;
if (pregpriv->wifi_spec == 1)
return;
/* keep this condition at last check */
if (padapter->dis_turboedca == DIS_TURBO_USE_MANUAL) {
if (padapter->edca_param_mode < TURBO_EDCA_MODE_NUM) {
struct turbo_edca_setting param;
param = ctrl_turbo_edca[padapter->edca_param_mode];
edca_be_ul = param.edca_ul;
edca_be_dl = param.edca_dl;
} else {
edca_be_ul = padapter->edca_param_mode;
edca_be_dl = padapter->edca_param_mode;
}
}
if (phl_com->phl_stats.tx_traffic.lvl == RTW_TFC_HIGH)
ac_parm = edca_be_ul;
else if (phl_com->phl_stats.tx_traffic.lvl != RTW_TFC_HIGH)
ac_parm = edca_be_dl;
else
return;
if (padapter->last_edca != ac_parm) {
ac = 0;
/*RTW_INFO("%s, edca(0x%08x), lvl(%d), sts(%d)\n", __func__, ac_parm,
phl_com->phl_stats.tx_traffic.lvl, phl_com->phl_stats.tx_traffic.sts);*/
rtw_hw_set_edca(padapter, ac, ac_parm);
padapter->last_edca = ac_parm;
}
}
u32 rtw_get_turbo_edca(_adapter *padapter, u8 aifs, u8 ecwmin, u8 ecwmax, u8 txop)
{
struct registry_priv *pregpriv = &padapter->registrypriv;
u32 ret = 0;
u8 decide_txop = txop;
u8 default_txop = 0x5e;
u32 ac_parm = padapter->last_edca;
u8 ac = 0;/*BE*/
if (padapter->dis_turboedca == DIS_TURBO)
return ret;
if (pregpriv->wifi_spec == 1)
return ret;
if (default_txop > txop)
decide_txop = default_txop;
else
decide_txop = txop;
ac_parm = aifs | (ecwmin << 8) | (ecwmax << 12) | (decide_txop << 16);
return ac_parm;
}
void rtw_iface_dynamic_chk_wk_hdl(_adapter *padapter)
{
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
#ifdef CONFIG_AP_MODE
if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter)) {
expire_timeout_chk(padapter);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter) && MLME_IS_ASOC(padapter))
rtw_mesh_peer_status_chk(padapter);
#endif
}
#endif
#endif /* CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
dynamic_update_bcn_check(padapter);
linked_status_chk(padapter, 0);
traffic_status_watchdog(padapter, 0);
rtw_turbo_edca(padapter);
/* for debug purpose */
_linked_info_dump(padapter);
#ifdef CONFIG_RTW_CFGVENDOR_RSSIMONITOR
rtw_cfgvendor_rssi_monitor_evt(padapter);
#endif
}
void rtw_dynamic_chk_wk_hdl(_adapter *padapter)
{
rtw_mi_dynamic_chk_wk_hdl(padapter);
#ifdef DBG_CONFIG_ERROR_DETECT
rtw_hal_sreset_xmit_status_check(padapter);
rtw_hal_sreset_linked_status_check(padapter);
#endif
/* if(check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_SURVEY)==_FALSE) */
{
#ifdef DBG_RX_COUNTER_DUMP
rtw_dump_rx_counters(padapter);
#endif
}
#ifdef CONFIG_RTW_MULTI_AP
rtw_ch_util_rpt(padapter);
#endif
#ifdef CONFIG_DFS_MASTER
rtw_chset_chk_non_ocp_finish(adapter_to_rfctl(padapter));
#endif
#ifdef CONFIG_IPS_CHECK_IN_WD
/* always call rtw_ps_processor() at last one. */
rtw_ps_processor(padapter);
#endif
}
void rtw_dynamic_chk_wk_sw_hdl(_adapter *padapter)
{
#ifdef CONFIG_RTW_MULTI_AP
rtw_ch_util_rpt(padapter);
#endif
rtw_update_phl_edcca_mode(padapter);
#ifdef CONFIG_DFS_MASTER
rtw_chset_chk_non_ocp_finish(adapter_to_rfctl(padapter));
#endif
}
void rtw_dynamic_chk_wk_hw_hdl(_adapter *padapter)
{
rtw_mi_dynamic_chk_wk_hdl(padapter);
#ifdef DBG_CONFIG_ERROR_DETECT
rtw_hal_sreset_xmit_status_check(padapter);
rtw_hal_sreset_linked_status_check(padapter);
#endif
/* if(check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_SURVEY)==_FALSE) */
{
#ifdef DBG_RX_COUNTER_DUMP
rtw_dump_rx_counters(padapter);
#endif
}
#ifdef CONFIG_IPS_CHECK_IN_WD
/* always call rtw_ps_processor() at last one. */
rtw_ps_processor(padapter);
#endif
}
#ifdef CONFIG_LPS
struct lps_ctrl_wk_parm {
s8 lps_level;
#ifdef CONFIG_LPS_1T1R
s8 lps_1t1r;
#endif
};
void lps_ctrl_wk_hdl(_adapter *padapter, u8 lps_ctrl_type, u8 *buf)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct lps_ctrl_wk_parm *parm = (struct lps_ctrl_wk_parm *)buf;
u8 mstatus;
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)
|| (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE))
return;
switch (lps_ctrl_type) {
case LPS_CTRL_SCAN:
/* RTW_INFO("LPS_CTRL_SCAN\n"); */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
/* connect */
LPS_Leave(padapter, "LPS_CTRL_SCAN");
}
break;
case LPS_CTRL_JOINBSS:
/* RTW_INFO("LPS_CTRL_JOINBSS\n"); */
LPS_Leave(padapter, "LPS_CTRL_JOINBSS");
break;
case LPS_CTRL_CONNECT:
/* RTW_INFO("LPS_CTRL_CONNECT\n"); */
mstatus = 1;/* connect */
/* Reset LPS Setting */
pwrpriv->LpsIdleCount = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
break;
case LPS_CTRL_DISCONNECT:
/* RTW_INFO("LPS_CTRL_DISCONNECT\n"); */
mstatus = 0;/* disconnect */
LPS_Leave(padapter, "LPS_CTRL_DISCONNECT");
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
break;
case LPS_CTRL_SPECIAL_PACKET:
/* RTW_INFO("LPS_CTRL_SPECIAL_PACKET\n"); */
rtw_set_lps_deny(padapter, LPS_DELAY_MS);
LPS_Leave(padapter, "LPS_CTRL_SPECIAL_PACKET");
break;
case LPS_CTRL_LEAVE:
LPS_Leave(padapter, "LPS_CTRL_LEAVE");
break;
case LPS_CTRL_LEAVE_SET_OPTION:
LPS_Leave(padapter, "LPS_CTRL_LEAVE_SET_OPTION");
if (parm) {
if (parm->lps_level >= 0)
pwrpriv->lps_level = parm->lps_level;
#ifdef CONFIG_LPS_1T1R
if (parm->lps_1t1r >= 0)
pwrpriv->lps_1t1r = parm->lps_1t1r;
#endif
}
break;
case LPS_CTRL_LEAVE_CFG80211_PWRMGMT:
LPS_Leave(padapter, "CFG80211_PWRMGMT");
break;
case LPS_CTRL_TRAFFIC_BUSY:
LPS_Leave(padapter, "LPS_CTRL_TRAFFIC_BUSY");
break;
case LPS_CTRL_TX_TRAFFIC_LEAVE:
LPS_Leave(padapter, "LPS_CTRL_TX_TRAFFIC_LEAVE");
break;
case LPS_CTRL_RX_TRAFFIC_LEAVE:
LPS_Leave(padapter, "LPS_CTRL_RX_TRAFFIC_LEAVE");
break;
case LPS_CTRL_ENTER:
LPS_Enter(padapter, "TRAFFIC_IDLE_1");
break;
default:
break;
}
}
static u8 _rtw_lps_ctrl_wk_cmd(_adapter *adapter, u8 lps_ctrl_type, s8 lps_level, s8 lps_1t1r, u8 flags)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct lps_ctrl_wk_parm *wk_parm = NULL;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
if (lps_ctrl_type == LPS_CTRL_LEAVE_SET_OPTION) {
wk_parm = rtw_zmalloc(sizeof(*wk_parm));
if (wk_parm == NULL) {
res = _FAIL;
goto exit;
}
wk_parm->lps_level = lps_level;
#ifdef CONFIG_LPS_1T1R
wk_parm->lps_1t1r = lps_1t1r;
#endif
}
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly */
lps_ctrl_wk_hdl(adapter, lps_ctrl_type, (u8 *)wk_parm);
if (wk_parm)
rtw_mfree(wk_parm, sizeof(*wk_parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
parm = rtw_zmalloc(sizeof(*parm));
if (parm == NULL) {
if (wk_parm)
rtw_mfree(wk_parm, sizeof(*wk_parm));
res = _FAIL;
goto exit;
}
parm->ec_id = LPS_CTRL_WK_CID;
parm->type = lps_ctrl_type;
parm->size = wk_parm ? sizeof(*wk_parm) : 0;
parm->pbuf = (u8 *)wk_parm;
cmdobj = rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
rtw_mfree(parm, sizeof(*parm));
if (wk_parm)
rtw_mfree(wk_parm, sizeof(*wk_parm));
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
}
exit:
return res;
}
u8 rtw_lps_ctrl_wk_cmd(_adapter *adapter, u8 lps_ctrl_type, u8 flags)
{
return _rtw_lps_ctrl_wk_cmd(adapter, lps_ctrl_type, -1, -1, flags);
}
u8 rtw_lps_ctrl_leave_set_level_cmd(_adapter *adapter, u8 lps_level, u8 flags)
{
return _rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_LEAVE_SET_OPTION, lps_level, -1, flags);
}
#ifdef CONFIG_LPS_1T1R
u8 rtw_lps_ctrl_leave_set_1t1r_cmd(_adapter *adapter, u8 lps_1t1r, u8 flags)
{
return _rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_LEAVE_SET_OPTION, -1, lps_1t1r, flags);
}
#endif
void rtw_dm_in_lps_hdl(_adapter *padapter)
{
rtw_hal_set_hwreg(padapter, HW_VAR_DM_IN_LPS_LCLK, NULL);
}
u8 rtw_dm_in_lps_wk_cmd(_adapter *padapter)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = DM_IN_LPS_WK_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
void rtw_lps_change_dtim_hdl(_adapter *padapter, u8 dtim)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
if (dtim <= 0 || dtim > 16)
return;
#ifdef CONFIG_LPS_LCLK
_enter_pwrlock(&pwrpriv->lock);
#endif
if (pwrpriv->dtim != dtim) {
RTW_INFO("change DTIM from %d to %d, bFwCurrentInPSMode=%d, ps_mode=%d\n", pwrpriv->dtim, dtim,
pwrpriv->bFwCurrentInPSMode, pwrpriv->pwr_mode);
pwrpriv->dtim = dtim;
}
if ((pwrpriv->bFwCurrentInPSMode == _TRUE) && (pwrpriv->pwr_mode > PM_PS_MODE_ACTIVE)) {
u8 ps_mode = pwrpriv->pwr_mode;
/* RTW_INFO("change DTIM from %d to %d, ps_mode=%d\n", pwrpriv->dtim, dtim, ps_mode); */
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
}
#ifdef CONFIG_LPS_LCLK
_exit_pwrlock(&pwrpriv->lock);
#endif
}
#endif
u8 rtw_lps_change_dtim_cmd(_adapter *padapter, u8 dtim)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
/*
#ifdef CONFIG_CONCURRENT_MODE
if (padapter->hw_port != HW_PORT0)
return res;
#endif
*/
{
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = LPS_CHANGE_DTIM_CID;
pdrvextra_cmd_parm->type = dtim;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
}
exit:
return res;
}
#ifdef CONFIG_POWER_SAVING
void power_saving_wk_hdl(_adapter *padapter)
{
rtw_ps_processor(padapter);
}
#endif
/* add for CONFIG_IEEE80211W, none 11w can use it */
void reset_securitypriv_hdl(_adapter *padapter)
{
rtw_reset_securitypriv(padapter);
}
#ifdef CONFIG_IOCTL_CFG80211
#if 0 /*!CONFIG_PHL_ARCH*/
static u8 _p2p_roch_cmd(_adapter *adapter
, u64 cookie, struct wireless_dev *wdev
, struct ieee80211_channel *ch, enum nl80211_channel_type ch_type
, unsigned int duration
, u8 flags
)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct p2p_roch_parm *roch_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 cancel = duration ? 0 : 1;
u8 res = _SUCCESS;
roch_parm = (struct p2p_roch_parm *)rtw_zmalloc(sizeof(struct p2p_roch_parm));
if (roch_parm == NULL) {
res = _FAIL;
goto exit;
}
roch_parm->cookie = cookie;
roch_parm->wdev = wdev;
if (!cancel) {
_rtw_memcpy(&roch_parm->ch, ch, sizeof(struct ieee80211_channel));
roch_parm->ch_type = ch_type;
roch_parm->duration = duration;
}
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != p2p_protocol_wk_hdl(adapter, cancel ? P2P_CANCEL_RO_CH_WK : P2P_RO_CH_WK, (u8 *)roch_parm))
res = _FAIL;
rtw_mfree((u8 *)roch_parm, sizeof(*roch_parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
rtw_mfree((u8 *)roch_parm, sizeof(*roch_parm));
res = _FAIL;
goto exit;
}
parm->ec_id = P2P_PROTO_WK_CID;
parm->type = cancel ? P2P_CANCEL_RO_CH_WK : P2P_RO_CH_WK;
parm->size = sizeof(*roch_parm);
parm->pbuf = (u8 *)roch_parm;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)roch_parm, sizeof(*roch_parm));
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 10 * 1000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
}
exit:
return res;
}
#endif /*!CONFIG_PHL_ARCH*/
inline u8 rtw_mgnt_tx_cmd(_adapter *adapter, u8 tx_ch, u8 no_cck, const u8 *buf, size_t len, int wait_ack, u8 flags)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct mgnt_tx_parm *mgnt_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
mgnt_parm = (struct mgnt_tx_parm *)rtw_zmalloc(sizeof(struct mgnt_tx_parm));
if (mgnt_parm == NULL) {
res = _FAIL;
goto exit;
}
mgnt_parm->tx_ch = tx_ch;
mgnt_parm->no_cck = no_cck;
mgnt_parm->buf = buf;
mgnt_parm->len = len;
mgnt_parm->wait_ack = wait_ack;
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != rtw_mgnt_tx_handler(adapter, (u8 *)mgnt_parm))
res = _FAIL;
rtw_mfree((u8 *)mgnt_parm, sizeof(*mgnt_parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
rtw_mfree((u8 *)mgnt_parm, sizeof(*mgnt_parm));
res = _FAIL;
goto exit;
}
parm->ec_id = MGNT_TX_WK_CID;
parm->type = 0;
parm->size = sizeof(*mgnt_parm);
parm->pbuf = (u8 *)mgnt_parm;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)mgnt_parm, sizeof(*mgnt_parm));
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 10 * 1000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
}
exit:
return res;
}
#endif
#ifdef CONFIG_POWER_SAVING
u8 rtw_ps_cmd(_adapter *padapter)
{
struct cmd_obj *ppscmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
#ifdef CONFIG_CONCURRENT_MODE
if (!is_primary_adapter(padapter))
goto exit;
#endif
ppscmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (ppscmd == NULL) {
res = _FAIL;
goto exit;
}
ppscmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)ppscmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = POWER_SAVING_CTRL_WK_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(ppscmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, ppscmd);
exit:
return res;
}
#endif /*CONFIG_POWER_SAVING*/
#if CONFIG_DFS
void rtw_dfs_ch_switch_hdl(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
u8 ifbmp_m = rtw_mi_get_ap_mesh_ifbmp(adapter);
u8 ifbmp_s = rtw_mi_get_ld_sta_ifbmp(adapter);
s16 req_ch;
u8 req_bw = CHANNEL_WIDTH_20, req_offset = CHAN_OFFSET_NO_EXT, csa_timer = _FALSE;
u8 need_discon = _FALSE;
rtw_hal_macid_sleep_all_used(adapter);
if (rtw_chset_search_ch(rfctl->channel_set, rfctl->csa_chandef.chan) >= 0
&& !rtw_chset_is_ch_non_ocp(rfctl->channel_set, rfctl->csa_chandef.chan)
) {
/* CSA channel available and valid */
req_ch = rfctl->csa_chandef.chan;
RTW_INFO("CSA : %s valid CSA ch%u\n", __func__, rfctl->csa_chandef.chan);
csa_timer = _TRUE;
} else if (ifbmp_m) {
/* no available or valid CSA channel, having AP/MESH ifaces */
req_ch = REQ_CH_NONE;
need_discon = _TRUE;
RTW_INFO("CSA : %s ch sel by AP/MESH ifaces\n", __func__);
} else {
/* no available or valid CSA channel and no AP/MESH ifaces */
if (!is_supported_24g(dvobj_to_regsty(dvobj)->band_type)
#ifdef CONFIG_DFS_MASTER
|| rfctl->radar_detected
#endif
)
req_ch = 36;
else
req_ch = 1;
need_discon = _TRUE;
RTW_INFO("CSA : %s switch to ch%d\n", __func__, req_ch);
}
if (!need_discon) {
if (rfctl->csa_ch_width == 1) {
req_bw = CHANNEL_WIDTH_80;
req_offset = rfctl->csa_chandef.offset;
} else if (rfctl->csa_ch_width == 0 && rfctl->csa_chandef.offset != CHAN_OFFSET_NO_EXT) {
req_bw = CHANNEL_WIDTH_40;
req_offset = rfctl->csa_chandef.offset;
} else {
req_bw = CHANNEL_WIDTH_20;
req_offset = CHAN_OFFSET_NO_EXT;
}
/* get correct offset and check ch/bw/offset is valid or not */
if (!rtw_get_offset_by_chbw(req_ch, req_bw, &req_offset)) {
req_bw = CHANNEL_WIDTH_20;
req_offset = CHAN_OFFSET_NO_EXT;
}
}
RTW_INFO("CSA : req_ch=%d, req_bw=%d, req_offset=%d, ifbmp_m=0x%02x, ifbmp_s=0x%02x\n"
, req_ch, req_bw, req_offset, ifbmp_m, ifbmp_s);
/* check all STA ifaces status */
if (ifbmp_s) {
_adapter *iface;
int i;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface || !(ifbmp_s & BIT(iface->iface_id)))
continue;
if (need_discon) {
set_fwstate(&iface->mlmepriv, WIFI_OP_CH_SWITCHING);
issue_deauth(iface, get_bssid(&iface->mlmepriv), WLAN_REASON_DEAUTH_LEAVING);
} else {
/* update STA mode ch/bw/offset */
iface->mlmeextpriv.chandef.chan= req_ch;
iface->mlmeextpriv.chandef.bw = req_bw;
iface->mlmeextpriv.chandef.offset = req_offset;
/* updaet STA mode DSConfig , ap mode will update in rtw_change_bss_chbw_cmd */
iface->mlmepriv.cur_network.network.Configuration.DSConfig = req_ch;
set_fwstate(&iface->mlmepriv, WIFI_CSA_UPDATE_BEACON);
#ifdef CONFIG_80211D
if (iface->mlmepriv.recv_country_ie) {
if (rtw_apply_recv_country_ie_cmd(iface, RTW_CMDF_DIRECTLY
, req_ch > 14 ? BAND_ON_5G : BAND_ON_24G, req_ch
, iface->mlmepriv.recv_country_ie) != _SUCCESS
)
RTW_WARN(FUNC_ADPT_FMT" rtw_apply_recv_country_ie_cmd() fail\n", FUNC_ADPT_ARG(iface));
}
#endif
}
}
}
if (csa_timer) {
RTW_INFO("pmlmeext->csa_timer 70 seconds\n");
/* wait 70 seconds for receiving beacons */
_set_timer(&pmlmeext->csa_timer, CAC_TIME_MS + 10000);
}
#ifdef CONFIG_AP_MODE
if (ifbmp_m) {
u8 execlude = 0;
if (need_discon)
execlude = ifbmp_s;
/* trigger channel selection with consideraton of asoc STA ifaces */
rtw_change_bss_chbw_cmd(dvobj_get_primary_adapter(dvobj), RTW_CMDF_DIRECTLY
, ifbmp_m, execlude, req_ch, REQ_BW_ORI, REQ_OFFSET_NONE);
} else
#endif
{
/* no AP/MESH iface, switch DFS status and channel directly */
rtw_warn_on(req_ch <= 0);
#ifdef CONFIG_DFS_MASTER
if (need_discon)
rtw_dfs_rd_en_decision(adapter, MLME_OPCH_SWITCH, ifbmp_s);
else
rtw_dfs_rd_en_decision(adapter, MLME_OPCH_SWITCH, 0);
#endif
set_channel_bwmode(adapter, req_ch, req_offset, req_bw, _TRUE);
/* update union ch/bw/offset for STA only */
rtw_mi_update_union_chan_inf(adapter, req_ch, req_offset, req_bw);
rtw_rfctl_update_op_mode(rfctl, 0, 0);
}
/* make asoc STA ifaces disconnect */
if (ifbmp_s && need_discon) {
_adapter *iface;
int i;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface || !(ifbmp_s & BIT(iface->iface_id)))
continue;
rtw_disassoc_cmd(iface, 0, RTW_CMDF_DIRECTLY);
rtw_indicate_disconnect(iface, 0, _FALSE);
#ifndef CONFIG_STA_CMD_DISPR
rtw_free_assoc_resources(iface, _TRUE);
#endif
rtw_free_network_queue(iface, _TRUE);
}
}
reset_csa_param(rfctl);
rtw_hal_macid_wakeup_all_used(adapter);
rtw_mi_os_xmit_schedule(adapter);
}
#endif /* CONFIG_DFS */
#ifdef CONFIG_AP_MODE
static void rtw_chk_hi_queue_hdl(_adapter *padapter)
{
struct sta_info *psta_bmc;
struct sta_priv *pstapriv = &padapter->stapriv;
systime start = rtw_get_current_time();
u8 empty = _FALSE;
psta_bmc = rtw_get_bcmc_stainfo(padapter);
if (!psta_bmc)
return;
rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &empty);
while (_FALSE == empty && rtw_get_passing_time_ms(start) < rtw_get_wait_hiq_empty_ms()) {
rtw_msleep_os(100);
rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &empty);
}
if (psta_bmc->sleepq_len == 0) {
if (empty == _SUCCESS) {
bool update_tim = _FALSE;
if (rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, 0))
update_tim = _TRUE;
rtw_tim_map_clear(padapter, pstapriv->tim_bitmap, 0);
rtw_tim_map_clear(padapter, pstapriv->sta_dz_bitmap, 0);
if (update_tim == _TRUE)
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0,"bmc sleepq and HIQ empty");
} else /* re check again */
rtw_chk_hi_queue_cmd(padapter);
}
}
u8 rtw_chk_hi_queue_cmd(_adapter *padapter)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = CHECK_HIQ_WK_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
#ifdef CONFIG_DFS_MASTER
u8 rtw_dfs_rd_hdl(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
u8 open_chan;
u8 cch;
if (!rfctl->radar_detect_enabled)
goto exit;
cch = rtw_get_center_ch(rfctl->radar_detect_ch, rfctl->radar_detect_bw, rfctl->radar_detect_offset);
open_chan = rtw_get_oper_ch(adapter);
if (open_chan != rfctl->radar_detect_ch
|| rtw_get_passing_time_ms(rtw_get_on_oper_ch_time(adapter)) < 300
) {
/* offchannel, bypass radar detect */
goto cac_status_chk;
}
if (IS_CH_WAITING(rfctl) && !IS_UNDER_CAC(rfctl)) {
/* non_ocp, bypass radar detect */
goto cac_status_chk;
}
if (!rfctl->dbg_dfs_fake_radar_detect_cnt
&& rtw_odm_radar_detect(adapter) != _TRUE)
goto cac_status_chk;
if (!rfctl->dbg_dfs_fake_radar_detect_cnt
&& rfctl->dbg_dfs_radar_detect_trigger_non
) {
/* radar detect debug mode, trigger no mlme flow */
RTW_INFO("%s radar detected on test mode, trigger no mlme flow\n", __func__);
goto cac_status_chk;
}
if (rfctl->dbg_dfs_fake_radar_detect_cnt != 0) {
RTW_INFO("%s fake radar detected, cnt:%d\n", __func__
, rfctl->dbg_dfs_fake_radar_detect_cnt);
rfctl->dbg_dfs_fake_radar_detect_cnt--;
} else
RTW_INFO("%s radar detected\n", __func__);
rfctl->radar_detected = 1;
rtw_chset_update_non_ocp(rfctl->channel_set
, rfctl->radar_detect_ch, rfctl->radar_detect_bw, rfctl->radar_detect_offset);
if (IS_UNDER_CAC(rfctl))
rtw_nlrtw_cac_abort_event(adapter, cch, rfctl->radar_detect_bw);
rtw_nlrtw_radar_detect_event(adapter, cch, rfctl->radar_detect_bw);
rtw_dfs_ch_switch_hdl(adapter);
if (rfctl->radar_detect_enabled)
goto set_timer;
goto exit;
cac_status_chk:
if (!IS_CAC_STOPPED(rfctl)
&& ((IS_UNDER_CAC(rfctl) && rfctl->cac_force_stop)
|| !IS_CH_WAITING(rfctl)
)
) {
u8 pause = 0x00;
rtw_hal_set_hwreg(adapter, HW_VAR_TXPAUSE, &pause);
rfctl->cac_start_time = rfctl->cac_end_time = RTW_CAC_STOPPED;
rtw_nlrtw_cac_finish_event(adapter, cch, rfctl->radar_detect_bw);
if (rtw_mi_check_fwstate(adapter, WIFI_UNDER_LINKING|WIFI_UNDER_SURVEY) == _FALSE) {
u8 do_rfk = _TRUE;
u8 u_ch, u_bw, u_offset;
if (rtw_mi_get_ch_setting_union(adapter, &u_ch, &u_bw, &u_offset))
set_channel_bwmode(adapter, u_ch, u_offset, u_bw, do_rfk);
else
rtw_warn_on(1);
rtw_hal_set_hwreg(adapter, HW_VAR_RESUME_BCN, NULL);
rtw_mi_tx_beacon_hdl(adapter);
}
}
set_timer:
_set_timer(&rfctl->radar_detect_timer
, rtw_odm_radar_detect_polling_int_ms(dvobj));
exit:
return H2C_SUCCESS;
}
u8 rtw_dfs_rd_cmd(_adapter *adapter, bool enqueue)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _FAIL;
if (enqueue) {
cmdobj = rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL)
goto exit;
cmdobj->padapter = adapter;
parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
rtw_mfree(cmdobj, sizeof(struct cmd_obj));
goto exit;
}
parm->ec_id = DFS_RADAR_DETECT_WK_CID;
parm->type = 0;
parm->size = 0;
parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
} else {
rtw_dfs_rd_hdl(adapter);
res = _SUCCESS;
}
exit:
return res;
}
void rtw_dfs_rd_timer_hdl(void *ctx)
{
struct rf_ctl_t *rfctl = (struct rf_ctl_t *)ctx;
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
rtw_dfs_rd_cmd(dvobj_get_primary_adapter(dvobj), _TRUE);
}
static void rtw_dfs_rd_enable(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset, bool bypass_cac)
{
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
RTW_INFO("%s on %u,%u,%u\n", __func__, ch, bw, offset);
if (bypass_cac)
rfctl->cac_start_time = rfctl->cac_end_time = RTW_CAC_STOPPED;
else if (rtw_is_cac_reset_needed(rfctl, ch, bw, offset) == _TRUE)
rtw_reset_cac(rfctl, ch, bw, offset);
rfctl->radar_detect_by_others = _FALSE;
rfctl->radar_detect_ch = ch;
rfctl->radar_detect_bw = bw;
rfctl->radar_detect_offset = offset;
rfctl->radar_detected = 0;
if (IS_CH_WAITING(rfctl))
rtw_hal_set_hwreg(adapter, HW_VAR_STOP_BCN, NULL);
if (!rfctl->radar_detect_enabled) {
RTW_INFO("%s set radar_detect_enabled\n", __func__);
rfctl->radar_detect_enabled = 1;
#ifdef CONFIG_LPS
LPS_Leave(adapter, "RADAR_DETECT_EN");
#endif
_set_timer(&rfctl->radar_detect_timer
, rtw_odm_radar_detect_polling_int_ms(dvobj));
if (rtw_rfctl_overlap_radar_detect_ch(rfctl)) {
if (IS_CH_WAITING(rfctl)) {
u8 pause = 0xFF;
rtw_hal_set_hwreg(adapter, HW_VAR_TXPAUSE, &pause);
}
rtw_odm_radar_detect_enable(adapter);
}
}
}
static void rtw_dfs_rd_disable(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset, bool by_others)
{
_adapter *adapter = dvobj_get_primary_adapter(rfctl_to_dvobj(rfctl));
rfctl->radar_detect_by_others = by_others;
if (rfctl->radar_detect_enabled) {
bool overlap_radar_detect_ch = rtw_rfctl_overlap_radar_detect_ch(rfctl);
RTW_INFO("%s clear radar_detect_enabled\n", __func__);
rfctl->radar_detect_enabled = 0;
rfctl->radar_detected = 0;
rfctl->radar_detect_ch = 0;
rfctl->radar_detect_bw = 0;
rfctl->radar_detect_offset = 0;
rfctl->cac_start_time = rfctl->cac_end_time = RTW_CAC_STOPPED;
_cancel_timer_ex(&rfctl->radar_detect_timer);
if (rtw_mi_check_fwstate(adapter, WIFI_UNDER_LINKING|WIFI_UNDER_SURVEY) == _FALSE) {
rtw_hal_set_hwreg(adapter, HW_VAR_RESUME_BCN, NULL);
rtw_mi_tx_beacon_hdl(adapter);
}
if (overlap_radar_detect_ch) {
u8 pause = 0x00;
rtw_hal_set_hwreg(adapter, HW_VAR_TXPAUSE, &pause);
rtw_odm_radar_detect_disable(adapter);
}
}
if (by_others) {
rfctl->radar_detect_ch = ch;
rfctl->radar_detect_bw = bw;
rfctl->radar_detect_offset = offset;
}
}
void rtw_dfs_rd_en_decision(_adapter *adapter, u8 mlme_act, u8 excl_ifbmp)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct mi_state mstate;
u8 ifbmp;
u8 u_ch, u_bw, u_offset;
bool ld_sta_in_dfs = _FALSE;
bool sync_ch = _FALSE; /* _FALSE: asign channel directly */
bool needed = _FALSE;
if (mlme_act == MLME_OPCH_SWITCH
|| mlme_act == MLME_ACTION_NONE
) {
ifbmp = ~excl_ifbmp;
rtw_mi_status_by_ifbmp(dvobj, ifbmp, &mstate);
rtw_mi_get_ch_setting_union_by_ifbmp(dvobj, ifbmp, &u_ch, &u_bw, &u_offset);
} else {
ifbmp = ~excl_ifbmp & ~BIT(adapter->iface_id);
rtw_mi_status_by_ifbmp(dvobj, ifbmp, &mstate);
rtw_mi_get_ch_setting_union_by_ifbmp(dvobj, ifbmp, &u_ch, &u_bw, &u_offset);
if (u_ch != 0)
sync_ch = _TRUE;
switch (mlme_act) {
case MLME_STA_CONNECTING:
MSTATE_STA_LG_NUM(&mstate)++;
break;
case MLME_STA_CONNECTED:
MSTATE_STA_LD_NUM(&mstate)++;
break;
case MLME_STA_DISCONNECTED:
break;
#ifdef CONFIG_AP_MODE
case MLME_AP_STARTED:
MSTATE_AP_NUM(&mstate)++;
break;
case MLME_AP_STOPPED:
break;
#endif
#ifdef CONFIG_RTW_MESH
case MLME_MESH_STARTED:
MSTATE_MESH_NUM(&mstate)++;
break;
case MLME_MESH_STOPPED:
break;
#endif
default:
rtw_warn_on(1);
break;
}
if (sync_ch == _TRUE) {
if (!MLME_IS_OPCH_SW(adapter)) {
if (!rtw_is_chbw_grouped(mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset, u_ch, u_bw, u_offset)) {
RTW_INFO(FUNC_ADPT_FMT" can't sync %u,%u,%u with %u,%u,%u\n", FUNC_ADPT_ARG(adapter)
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset, u_ch, u_bw, u_offset);
goto apply;
}
rtw_sync_chbw(&mlmeext->chandef.chan, (u8 *)(&mlmeext->chandef.bw), (u8 *)(&mlmeext->chandef.offset)
, &u_ch, &u_bw, &u_offset);
}
} else {
u_ch = mlmeext->chandef.chan;
u_bw = mlmeext->chandef.bw;
u_offset = mlmeext->chandef.offset;
}
}
if (MSTATE_STA_LG_NUM(&mstate) > 0) {
/* STA mode is linking */
goto apply;
}
if (MSTATE_STA_LD_NUM(&mstate) > 0) {
if (rtw_chset_is_dfs_chbw(rfctl->channel_set, u_ch, u_bw, u_offset)) {
/*
* if operate as slave w/o radar detect,
* rely on AP on which STA mode connects
*/
if (IS_DFS_SLAVE_WITH_RD(rfctl) && !rtw_rfctl_dfs_domain_unknown(rfctl))
needed = _TRUE;
ld_sta_in_dfs = _TRUE;
}
goto apply;
}
if (!MSTATE_AP_NUM(&mstate) && !MSTATE_MESH_NUM(&mstate)) {
/* No working AP/Mesh mode */
goto apply;
}
if (rtw_chset_is_dfs_chbw(rfctl->channel_set, u_ch, u_bw, u_offset))
needed = _TRUE;
apply:
RTW_INFO(FUNC_ADPT_FMT" needed:%d, mlme_act:%u, excl_ifbmp:0x%02x\n"
, FUNC_ADPT_ARG(adapter), needed, mlme_act, excl_ifbmp);
RTW_INFO(FUNC_ADPT_FMT" ld_sta_num:%u, lg_sta_num:%u, ap_num:%u, mesh_num:%u, %u,%u,%u\n"
, FUNC_ADPT_ARG(adapter), MSTATE_STA_LD_NUM(&mstate), MSTATE_STA_LG_NUM(&mstate)
, MSTATE_AP_NUM(&mstate), MSTATE_MESH_NUM(&mstate)
, u_ch, u_bw, u_offset);
if (needed == _TRUE)
rtw_dfs_rd_enable(rfctl, u_ch, u_bw, u_offset, ld_sta_in_dfs);
else
rtw_dfs_rd_disable(rfctl, u_ch, u_bw, u_offset, ld_sta_in_dfs);
}
u8 rtw_dfs_rd_en_decision_cmd(_adapter *adapter)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _FAIL;
cmdobj = rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL)
goto exit;
cmdobj->padapter = adapter;
parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
rtw_mfree(cmdobj, sizeof(struct cmd_obj));
goto exit;
}
parm->ec_id = DFS_RADAR_DETECT_EN_DEC_WK_CID;
parm->type = 0;
parm->size = 0;
parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
exit:
return res;
}
#endif /* CONFIG_DFS_MASTER */
#endif /* CONFIG_AP_MODE */
#if 0 /*def RTW_PHL_DBG_CMD*/
u8 sample_txwd[] =
{
/*dword 00*/ 0x80, 0x00, 0x40, 0x00,
/*dword 01*/ 0x00, 0x00, 0x00, 0x00,
/*dword 02*/ 0xF2, 0x05, 0x00, 0x00,
/*dword 03*/ 0x3E, 0x11, 0x00, 0x00,
/*dword 04*/ 0x00, 0x00, 0x00, 0x00,
/*dword 05*/ 0x00, 0x00, 0x00, 0x00,
/*dword 06*/ 0x00, 0x07, 0x9B, 0x63,
/*dword 07*/ 0x3F, 0x00, 0x00, 0x00,
/*dword 08*/ 0x00, 0x00, 0x00, 0x00,
/*dword 09*/ 0x00, 0x00, 0x00, 0x00,
/*dword 10*/ 0x0C, 0x00, 0x00, 0x00,
/*dword 11*/ 0x00, 0x00, 0x00, 0x00,
};
#define WD_SPEC(_name, _idx_dw, _bit_start, _bit_end) { \
.name = (_name), \
.idx_dw = (_idx_dw), \
.bit_start = (_bit_start), \
.bit_end = (_bit_end) \
}
struct parse_wd {
char name[32];
u8 idx_dw;
u8 bit_start;
u8 bit_end;
};
#define MAX_PHL_CMD_LEN 200
#define MAX_PHL_CMD_NUM 10
#define MAX_PHL_CMD_STR_LEN 200
char *get_next_para_str(char *para)
{
return (para+MAX_PHL_CMD_STR_LEN);
}
static struct parse_wd parse_txwd_8852ae_full[] = {
WD_SPEC("EN_HWSEQ_MODE" , 0, 0, 1),
WD_SPEC("HW_SSN_SEL" , 0, 2, 3),
WD_SPEC("SMH_EN" , 0, 4, 4),
WD_SPEC("HWAMSDU" , 0, 5, 5),
WD_SPEC("HW_AES_IV" , 0, 6, 6),
WD_SPEC("WD page" , 0, 7, 7),
WD_SPEC("CHK_EN" , 0, 8, 8),
WD_SPEC("WP_INT" , 0, 9, 9),
WD_SPEC("STF mode" , 0, 10, 10),
WD_SPEC("HEADERwLLC_LEN" , 0, 11, 15),
WD_SPEC("CHANNEL_DMA" , 0, 16, 19),
WD_SPEC("FW_download" , 0, 20, 20),
WD_SPEC("PKT_OFFSET" , 0, 21, 21),
WD_SPEC("WDINFO_EN" , 0, 22, 22),
WD_SPEC("MOREDATA" , 0, 23, 23),
WD_SPEC("WP_OFFSET" , 0, 24, 31),
WD_SPEC("SHCUT_CAMID" , 1, 0, 7),
WD_SPEC("DMA_TXAGG_NUM" , 1, 8, 15),
WD_SPEC("PLD(Packet ID)" , 1, 16, 31),
WD_SPEC("TXPKTSIZE" , 2, 0, 13),
WD_SPEC("RU_TC" , 2, 14, 16),
WD_SPEC("QSEL" , 2, 17, 22),
WD_SPEC("TID_indicate" , 2, 23, 23),
WD_SPEC("MACID" , 2, 24, 30),
WD_SPEC("RSVD" , 2, 31, 31),
WD_SPEC("Wifi_SEQ" , 3, 0, 11),
WD_SPEC("AGG_EN" , 3, 12, 12),
WD_SPEC("BK" , 3, 13, 13),
WD_SPEC("RTS_TC" , 3, 14, 19),
WD_SPEC("DATA_TC" , 3, 20, 25),
WD_SPEC("MU_2nd_TC" , 3, 26, 28),
WD_SPEC("MU_TC" , 3, 29, 31),
WD_SPEC("TIMESTAMP" , 4, 0, 15),
WD_SPEC("AES_IV_L" , 4, 16, 31),
WD_SPEC("AES_IV_H" , 5, 0, 31),
WD_SPEC("MBSSID" , 6, 0, 3),
WD_SPEC("Multiport_ID" , 6, 4, 6),
WD_SPEC("RSVD" , 6, 7, 7),
WD_SPEC("DATA_BW_ER" , 6, 8, 8),
WD_SPEC("DISRTSFB" , 6, 9, 9),
WD_SPEC("DISDATAFB" , 6, 10, 10),
WD_SPEC("DATA_LDPC" , 6, 11, 11),
WD_SPEC("DATA_STBC" , 6, 12, 13),
WD_SPEC("DATA_DCM" , 6, 14, 14),
WD_SPEC("DATA_ER" , 6, 15, 15),
WD_SPEC("DataRate" , 6, 16, 24),
WD_SPEC("GI_LTF" , 6, 25, 27),
WD_SPEC("DATA_BW" , 6, 28, 29),
WD_SPEC("USERATE_SEL" , 6, 30, 30),
WD_SPEC("ACK_CH_INFO" , 6, 31, 31),
WD_SPEC("MAX_AGG_NUM" , 7, 0, 7),
WD_SPEC("BCN_SRCH_SEQ" , 7, 8, 9),
WD_SPEC("NAVUSEHDR" , 7, 10, 10),
WD_SPEC("BMC" , 7, 11, 11),
WD_SPEC("A_CTRL_BQR" , 7, 12, 12),
WD_SPEC("A_CTRL_UPH" , 7, 13, 13),
WD_SPEC("A_CTRL_BSR" , 7, 14, 14),
WD_SPEC("A_CTRL_CAS" , 7, 15, 15),
WD_SPEC("DATA_RTY_LOWEST_RATE" , 7, 16, 24),
WD_SPEC("DATA_TXCNT_LMT" , 7, 25, 30),
WD_SPEC("DATA_TXCNT_LMT_SEL" , 7, 31, 31),
WD_SPEC("SEC_CAM_IDX" , 8, 0, 7),
WD_SPEC("SEC_HW_ENC" , 8, 8, 8),
WD_SPEC("SECTYPE" , 8, 9, 12),
WD_SPEC("lifetime_sel" , 8, 13, 15),
WD_SPEC("RSVD" , 8, 16, 16),
WD_SPEC("FORCE_TXOP" , 8, 17, 17),
WD_SPEC("AMPDU_DENSITY" , 8, 18, 20),
WD_SPEC("LSIG_TXOP_EN" , 8, 21, 21),
WD_SPEC("TXPWR_OFSET_TYPE" , 8, 22, 24),
WD_SPEC("RSVD" , 8, 25, 25),
WD_SPEC("obw_cts2self_dup_type" , 8, 26, 29),
WD_SPEC("RSVD" , 8, 30, 31),
WD_SPEC("Signaling_TA_PKT_EN" , 9, 0, 0),
WD_SPEC("NDPA" , 9, 1, 2),
WD_SPEC("SND_PKT_SEL" , 9, 3, 5),
WD_SPEC("SIFS_Tx" , 9, 6, 6),
WD_SPEC("HT_DATA_SND" , 9, 7, 7),
WD_SPEC("RSVD" , 9, 8, 8),
WD_SPEC("RTT_EN" , 9, 9, 9),
WD_SPEC("SPE_RPT" , 9, 10, 10),
WD_SPEC("BT_NULL" , 9, 11, 11),
WD_SPEC("TRI_FRAME" , 9, 12, 12),
WD_SPEC("NULL_1" , 9, 13, 13),
WD_SPEC("NULL_0" , 9, 14, 14),
WD_SPEC("RAW" , 9, 15, 15),
WD_SPEC("Group_bit" , 9, 16, 23),
WD_SPEC("RSVD" , 9, 24, 25),
WD_SPEC("BCNPKT_TSF_CTRL" , 9, 26, 26),
WD_SPEC("Signaling_TA_PKT_SC" , 9, 27, 30),
WD_SPEC("FORCE_BSS_CLR" , 9, 31, 31),
WD_SPEC("SW_DEFINE" , 10, 0, 3),
WD_SPEC("RSVD" , 10, 4, 26),
WD_SPEC("RTS_EN" , 10, 27, 27),
WD_SPEC("CTS2SELF" , 10, 28, 28),
WD_SPEC("CCA_RTS" , 10, 29, 30),
WD_SPEC("HW_RTS_EN" , 10, 31, 31),
WD_SPEC("RSVD" , 11, 0, 3),
WD_SPEC("NDPA_duration" , 11, 4, 26),
};
static struct parse_wd parse_rxwd_8852ae[] = {
WD_SPEC("PKT_LEN" , 0, 0, 13),
WD_SPEC("SHIFT" , 0, 14, 15),
WD_SPEC("WL_HD_IV_LEN" , 0, 16, 21),
WD_SPEC("BB_SEL" , 0, 22, 22),
WD_SPEC("MAC_INFO_VLD" , 0, 23, 23),
WD_SPEC("RPKT_TYPE" , 0, 24, 27),
WD_SPEC("DRV_INFO_SIZE" , 0, 28, 30),
WD_SPEC("LONG_RXD" , 0, 31, 31),
WD_SPEC("PPDU_TYPE" , 1, 0, 3),
WD_SPEC("PPDU_CNT" , 1, 4, 6),
WD_SPEC("SR_EN" , 1, 7, 7),
WD_SPEC("USER_ID" , 1, 8, 15),
WD_SPEC("RX_DATARATE" , 1, 16, 24),
WD_SPEC("RX_GI_LTF" , 1, 25, 27),
WD_SPEC("NON_SRG_PPDU" , 1, 28, 28),
WD_SPEC("INTER_PPDU" , 1, 29, 29),
WD_SPEC("BW" , 1, 30, 31),
WD_SPEC("FREERUN_CNT" , 2, 0, 31),
WD_SPEC("A1_MATCH" , 3, 1, 1),
WD_SPEC("SW_DEC" , 3, 2, 2),
WD_SPEC("HW_DEC" , 3, 3, 3),
WD_SPEC("AMPDU" , 3, 4, 4),
WD_SPEC("AMPDU_END_PKT" , 3, 5, 5),
WD_SPEC("AMSDU" , 3, 6, 6),
WD_SPEC("AMSDU_CUT" , 3, 7, 7),
WD_SPEC("LAST_MSDU" , 3, 8, 8),
WD_SPEC("BYPASS" , 3, 9, 9),
WD_SPEC("CRC32" , 3, 10, 10),
WD_SPEC("MAGIC_WAKE" , 3, 11, 11),
WD_SPEC("UNICAST_WAKE" , 3, 12, 12),
WD_SPEC("PATTERN_WAKE" , 3, 13, 13),
WD_SPEC("GET_CH_INFO" , 3, 14, 14),
WD_SPEC("RX_STATISTICS" , 3, 15, 15),
WD_SPEC("PATTERN_IDX" , 3, 16, 20),
WD_SPEC("TARGET_IDC" , 3, 21, 23),
WD_SPEC("CHKSUM_OFFLOAD_EN" , 3, 24, 24),
WD_SPEC("WITH_LLC" , 3, 25, 25),
WD_SPEC("RSVD" , 3, 26, 31),
WD_SPEC("TYPE" , 4, 0, 1),
WD_SPEC("MC" , 4, 2, 2),
WD_SPEC("BC" , 4, 3, 3),
WD_SPEC("MD" , 4, 4, 4),
WD_SPEC("MF" , 4, 5, 5),
WD_SPEC("PWR" , 4, 6, 6),
WD_SPEC("QOS" , 4, 7, 7),
WD_SPEC("TID" , 4, 8, 11),
WD_SPEC("EOSP" , 4, 12, 12),
WD_SPEC("HTC" , 4, 13, 13),
WD_SPEC("QNULL" , 4, 14, 14),
WD_SPEC("RSVD" , 4, 15, 15),
WD_SPEC("SEQ" , 4, 16, 27),
WD_SPEC("FRAG" , 4, 28, 31),
WD_SPEC("SEC_CAM_IDX" , 5, 0, 7),
WD_SPEC("ADDR_CAM" , 5, 8, 15),
WD_SPEC("MAC_ID" , 5, 16, 23),
WD_SPEC("RX_PL_ID" , 5, 24, 27),
WD_SPEC("ADDR_CAM_VLD" , 5, 28, 28),
WD_SPEC("ADDR_FWD_EN" , 5, 29, 29),
WD_SPEC("RX_PL_MATCH" , 5, 30, 30),
WD_SPEC("RSVD" , 5, 31, 31),
};
enum WD_TYPE {
TXWD_INFO = 0,
TXWD_INFO_BODY,
RXWD,
};
u32 get_txdesc_element_val(u32 val_dw, u8 bit_start, u8 bit_end)
{
u32 mask = 0;
u32 i = 0;
if(bit_start>31
|| bit_end>31
|| (bit_start>bit_end)){
printk("[%s] error %d %d\n", __FUNCTION__, bit_start, bit_end);
return 0;
}
for(i = bit_start; i<=bit_end; i++){
mask |= (1<<i);
}
return ((val_dw & mask)>>bit_start);
}
void parse_wd_8852ae(_adapter *adapter, u32 type, u32 idx_wd, u8 *wd)
{
u32 i, val = 0;
u32 cur_dw = 0xFF;
u32 idx, val_dw = 0;
u32 array_size = 0;
struct parse_wd *parser = NULL;
if(wd==NULL)
return;
if(type == TXWD_INFO_BODY){
parser = parse_txwd_8852ae_full;
array_size = ARRAY_SIZE(parse_txwd_8852ae_full);
}
else if(type == RXWD){
parser = parse_rxwd_8852ae;
array_size = ARRAY_SIZE(parse_rxwd_8852ae);
}
for(i = 0; i<array_size; i++){
if(cur_dw != parser[i].idx_dw){
cur_dw = parser[i].idx_dw;
idx = (parser[i].idx_dw*4);
val_dw = wd[idx] + (wd[idx+1]<<8) + (wd[idx+2]<<16) + (wd[idx+3]<<24);
printk(">>>> WD[%03d].dw%02d = 0x%08x \n", idx_wd, cur_dw, val_dw);
}
val = get_txdesc_element_val(val_dw,
parser[i].bit_start, parser[i].bit_end);
printk("%s[%d:%d] = (0x%x)\n",
parser[i].name,
parser[i].bit_end, parser[i].bit_start, val);
}
printk("\n");
}
void compare_wd_8852ae(_adapter *adapter, u32 type, u8 *wd1, u8 *wd2)
{
u32 i, val1, val2 = 0;
u32 cur_dw = 0xFF;
u32 idx, val_dw1, val_dw2 = 0;
u32 array_size = 0;
struct parse_wd *parser = NULL;
if((wd1==NULL) ||(wd2==NULL))
return;
if(type == TXWD_INFO_BODY){
parser = parse_txwd_8852ae_full;
array_size = ARRAY_SIZE(parse_txwd_8852ae_full);
}
for(i = 0; i<array_size; i++){
if(cur_dw != parser[i].idx_dw){
cur_dw = parser[i].idx_dw;
idx = (parser[i].idx_dw*4);
val_dw1 = wd1[idx] + (wd1[idx+1]<<8) + (wd1[idx+2]<<16) + (wd1[idx+3]<<24);
val_dw2 = wd2[idx] + (wd2[idx+1]<<8) + (wd2[idx+2]<<16) + (wd2[idx+3]<<24);
}
val1 = get_txdesc_element_val(val_dw1,
parser[i].bit_start, parser[i].bit_end);
val2 = get_txdesc_element_val(val_dw2,
parser[i].bit_start, parser[i].bit_end);
if(val1 != val2){
printk("Diff dw%02d: %s[%d:%d] = (0x%x) vs (0x%x)\n", cur_dw,
parser[i].name,
parser[i].bit_end, parser[i].bit_start, val1, val2);
}
}
printk("\n");
}
void core_dump_map_tx(_adapter *adapter)
{
struct core_logs *log = &adapter->core_logs;
u32 idx = 0;
printk("drvTx MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct core_record *record = &log->drvTx[idx];
if(idx >= log->txCnt_all)
break;
printk("[drvTx %03d]\n", idx);
printk("type=%d totalSz=%d virtAddr=%p\n", record->type, record->totalSz, record->virtAddr[0]);
}
printk("========= \n\n");
printk("phlTx MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct core_record *record = &log->phlTx[idx];
u32 idx1 = 0;
if(idx >= log->txCnt_phl)
break;
printk("[phlTx %03d]\n", idx);
printk("type=%d totalSz=%d fragNum=%d\n", record->type, record->totalSz, record->fragNum);
for(idx1=0; idx1<record->fragNum; idx1++){
printk("frag#%d: len=%d virtaddr=%p \n", idx1,
record->fragLen[idx1], record->virtAddr[idx1]);
printk("frag#%d: phyAddrH=%d phyAddrL=%p \n", idx1,
record->phyAddrH[idx1], record->phyAddrL[idx1]);
}
}
printk("========= \n\n");
printk("TxRcycle MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct core_record *record = &log->txRcycle[idx];
u32 idx1 = 0;
if(idx >= log->txCnt_recycle)
break;
printk("[TxRcycle %03d]\n", idx);
printk("type=%d totalSz=%d fragNum=%d\n", record->type, record->totalSz, record->fragNum);
for(idx1=0; idx1<record->fragNum; idx1++){
printk("frag#%d: len=%d virtaddr=%p \n", idx1,
record->fragLen[idx1], record->virtAddr[idx1]);
printk("frag#%d: phyAddrH=%d phyAddrL=%p \n", idx1,
record->phyAddrH[idx1], record->phyAddrL[idx1]);
}
}
}
void core_dump_map_rx(_adapter *adapter)
{
struct core_logs *log = &adapter->core_logs;
u32 idx = 0;
printk("drvRx MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct core_record *record = &log->drvRx[idx];
if(idx >= log->rxCnt_all)
break;
printk("[drvRx %03d]\n", idx);
printk("type=%d totalSz=%d virtAddr=%p\n", record->type, record->totalSz, record->virtAddr[0]);
printk("wl_seq=%d wl_type=0x%x wl_subtype=0x%x\n", record->wl_seq, record->wl_type, record->wl_subtype);
}
printk("========= \n\n");
printk("phlRx MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct core_record *record = &log->phlRx[idx];
if(idx >= log->rxCnt_phl)
break;
printk("[phlRx %03d]\n", idx);
printk("type=%d totalSz=%d virtAddr=%p\n", record->type, record->totalSz, record->virtAddr[0]);
}
printk("========= \n\n");
printk("rxRcycle MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct core_record *record = &log->rxRcycle[idx];
if(idx >= log->rxCnt_recycle)
break;
printk("[rxRcycle %03d]\n", idx);
printk("type=%d totalSz=%d virtAddr=%p\n", record->type, record->totalSz, record->virtAddr[0]);
}
}
void core_dump_record(_adapter *adapter, u8 dump_type)
{
struct core_logs *log = &adapter->core_logs;
u32 idx = 0;
printk("txCnt_all: %d (%d) \n", log->txCnt_all, log->txCnt_all%CORE_LOG_NUM);
printk("txCnt_data: %d \n", log->txCnt_data);
printk("txCnt_mgmt: %d \n", log->txCnt_mgmt);
printk("txCnt_phl: %d (%d), Sz=%d \n", log->txCnt_phl, log->txCnt_phl%CORE_LOG_NUM, log->txSize_phl);
printk("txCnt_recycle: %d (%d), Sz=%d \n", log->txCnt_recycle, log->txCnt_recycle%CORE_LOG_NUM, log->txSize_recycle);
printk("rxCnt_all: %d (%d) \n", log->rxCnt_all, log->rxCnt_all%CORE_LOG_NUM);
printk("rxCnt_data: %d (retry=%d)\n", log->rxCnt_data, log->rxCnt_data_retry);
printk("rxCnt_mgmt: %d \n", log->rxCnt_mgmt);
printk("rxCnt_phl: %d (%d), Sz=%d \n", log->rxCnt_phl, log->rxCnt_phl%CORE_LOG_NUM, log->rxSize_phl);
printk("rxCnt_recycle: %d (%d), Sz=%d\n", log->rxCnt_recycle, log->rxCnt_recycle%CORE_LOG_NUM, log->rxSize_recycle);
#ifdef CONFIG_RTW_CORE_RXSC
printk("enable_rxsc: %d \n", adapter->enable_rxsc);
printk("rxCnt_data: orig=%d shortcut=%d(ratio=%d)\n",
log->rxCnt_data_orig, log->rxCnt_data_shortcut,
log->rxCnt_data_shortcut*100/(log->rxCnt_data_orig+log->rxCnt_data_shortcut));
printk("rxCnt_coreInd: %d \n", log->rxCnt_coreInd);
#endif
if(dump_type == REC_DUMP_TX){
core_dump_map_tx(adapter);
}
else if(dump_type == REC_DUMP_RX){
core_dump_map_rx(adapter);
}
else if(dump_type == REC_DUMP_ALL){
core_dump_map_tx(adapter);
core_dump_map_rx(adapter);
}
}
void core_add_record(_adapter *adapter, u8 type, void *p)
{
struct core_logs *log = &adapter->core_logs;
if(!adapter->record_enable)
return;
if(type == REC_TX_DATA){
u32 idx = log->txCnt_all%CORE_LOG_NUM;
struct core_record *record = &(log->drvTx[idx]);
struct sk_buff *skb = p;
log->txCnt_data++;
record->type = type;
record->totalSz = skb->len;
record->virtAddr[0] = skb->data;
}
if(type == REC_TX_MGMT){
u32 idx = log->txCnt_all%CORE_LOG_NUM;
struct core_record *record = &(log->drvTx[idx]);
struct xmit_frame *pxframe = p;
log->txCnt_mgmt++;
record->type = type;
record->totalSz = pxframe->attrib.pktlen;
record->virtAddr[0] = pxframe->buf_addr;
}
if(type == REC_TX_PHL || type == REC_TX_PHL_RCC){
u32 idx = 0;
struct core_record *record = NULL;
struct rtw_xmit_req *txreq = p;
if(type == REC_TX_PHL){
idx = log->txCnt_phl%CORE_LOG_NUM;
record = &(log->phlTx[idx]);
log->txCnt_phl++;
}
if(type == REC_TX_PHL_RCC){
idx = log->txCnt_recycle%CORE_LOG_NUM;
record = &(log->txRcycle[idx]);
log->txCnt_recycle++;
}
record->type = type;
record->totalSz = 0;
record->fragNum = txreq->pkt_cnt;
{
struct rtw_pkt_buf_list *pkt_list =(struct rtw_pkt_buf_list *)txreq->pkt_list;
u32 idx1 = 0;
for(idx1=0; idx1<txreq->pkt_cnt; idx1++){
if(idx1 >= MAX_FRAG){
printk("!! WARN[%s][%d] type=%d frag>= %d \n",
__FUNCTION__, __LINE__, type, MAX_FRAG);
break;
}
record->totalSz += pkt_list->length;
record->fragLen[idx1] = pkt_list->length;
record->virtAddr[idx1] = pkt_list->vir_addr;
record->phyAddrL[idx1] = pkt_list->phy_addr_l;
record->phyAddrH[idx1] = pkt_list->phy_addr_h;
pkt_list++;
}
}
if(type == REC_TX_PHL)
log->txSize_phl += record->totalSz;
else if(type == REC_TX_PHL_RCC)
log->txSize_recycle += record->totalSz;
}
if(type == REC_RX_PHL || type == REC_RX_PHL_RCC){
u32 idx = 0;
struct core_record *record = NULL;
struct rtw_recv_pkt *rx_req = p;
struct rtw_pkt_buf_list *pkt = rx_req->pkt_list;
if(type == REC_RX_PHL){
idx = log->rxCnt_phl%CORE_LOG_NUM;
record = &(log->phlRx[idx]);
log->rxCnt_phl++;
}
if(type == REC_RX_PHL_RCC){
idx = log->rxCnt_recycle%CORE_LOG_NUM;
record = &(log->rxRcycle[idx]);
log->rxCnt_recycle++;
}
record->type = type;
record->totalSz = pkt->length;
record->virtAddr[0] = pkt->vir_addr;
if(type == REC_RX_PHL)
log->rxSize_phl += record->totalSz;
else if(type == REC_RX_PHL_RCC)
log->rxSize_recycle += record->totalSz;
}
if(type == REC_RX_DATA || type == REC_RX_MGMT){
u32 idx = log->rxCnt_all%CORE_LOG_NUM;
struct core_record *record = &(log->drvRx[idx]);
union recv_frame *prframe = p;
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
if(type == REC_RX_DATA){
log->rxCnt_data++;
}
if(type == REC_RX_MGMT){
log->rxCnt_mgmt++;
}
record->type = type;
record->totalSz = prframe->u.hdr.len;
record->virtAddr[0] = prframe->u.hdr.rx_data;
record->wl_seq = pattrib->seq_num;
record->wl_type = pattrib->wl_type;
record->wl_subtype = pattrib->wl_subtype;
}
if(type == REC_RX_DATA_RETRY){
log->rxCnt_data_retry++;
}
log->txCnt_all = log->txCnt_mgmt + log->txCnt_data;
log->rxCnt_all = log->rxCnt_mgmt + log->rxCnt_data;
}
void phl_dump_map_tx(_adapter *adapter)
{
struct phl_logs *log = &adapter->phl_logs;
u32 idx = 0;
printk("txBd MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct record_txbd *record = &log->txBd[idx];
if(idx >= log->txCnt_bd)
break;
printk("[txBd %03d]\n", idx);
{
u8 *tmp=record->bd_buf;
u32 len = record->bd_len;
u32 idx1 = 0;
if(tmp == NULL)
break;
for(idx1=0; idx1<len; idx1++){
if(idx1%8==0) {
printk("[%03d] %02x %02x %02x %02x %02x %02x %02x %02x \n",
idx1, tmp[idx1], tmp[idx1+1], tmp[idx1+2], tmp[idx1+3],
tmp[idx1+4], tmp[idx1+5], tmp[idx1+6], tmp[idx1+7]);
}
}
printk("\n");
}
}
printk("========= \n\n");
printk("txWd MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct record_txwd *record = &log->txWd[idx];
if(idx >= log->txCnt_wd)
break;
printk("[txWd %03d]\n", idx);
{
u8 *tmp=record->wd_buf;
u32 len = record->wd_len;
u32 idx1 = 0;
if(tmp == NULL)
break;
for(idx1=0; idx1<len; idx1++){
if(idx1%8==0) {
printk("[%03d] %02x %02x %02x %02x %02x %02x %02x %02x \n",
idx1, tmp[idx1], tmp[idx1+1], tmp[idx1+2], tmp[idx1+3],
tmp[idx1+4], tmp[idx1+5], tmp[idx1+6], tmp[idx1+7]);
}
}
printk("\n");
}
parse_wd_8852ae(adapter, TXWD_INFO_BODY, idx, record->wd_buf);
//compare_wd_8852ae(adapter, TXWD_INFO_BODY, record->wd_buf, sample_txwd);
}
printk("========= \n\n");
printk("wpRecycle MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct record_wp_rcc *record = &log->wpRecycle[idx];
if(idx >= log->txCnt_recycle)
break;
printk("[txRecycle %03d]\n", idx);
printk("wp_seq=%d \n", record->wp_seq);
}
}
void phl_dump_map_rx(_adapter *adapter)
{
struct phl_logs *log = &adapter->phl_logs;
u32 idx = 0;
printk("rxPciMap MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct record_pci *record = &log->rxPciMap[idx];
if(idx >= log->rxCnt_map)
break;
printk("[rxPciMap %03d]\n", idx);
printk("phyAddrL=%p len=%d\n", record->phyAddrL, record->map_len);
}
printk("========= \n\n");
printk("rxPciUnmap MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct record_pci *record = &log->rxPciUnmap[idx];
if(idx >= log->rxCnt_unmap)
break;
printk("[rxPciUnmap %03d]\n", idx);
printk("phyAddrL=%p len=%d\n", record->phyAddrL, record->map_len);
}
printk("========= \n\n");
printk("rxWd MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
struct record_rxwd *record = &log->rxWd[idx];
if(idx >= log->rxCnt_wd)
break;
printk("[rxWd %03d]\n", idx);
{
u8 *tmp = record->wd_buf;
u32 len = record->wd_len;
u32 idx1 = 0;
if(tmp == NULL)
break;
for(idx1=0; idx1<len; idx1++){
if(idx1%8==0) {
printk("[%03d] %02x %02x %02x %02x %02x %02x %02x %02x \n",
idx1, tmp[idx1], tmp[idx1+1], tmp[idx1+2], tmp[idx1+3],
tmp[idx1+4], tmp[idx1+5], tmp[idx1+6], tmp[idx1+7]);
}
}
printk("\n");
}
parse_wd_8852ae(adapter, RXWD, idx, record->wd_buf);
}
printk("========= \n\n");
printk("rxAmpdu MAP");
for(idx=0; idx<CORE_LOG_NUM; idx++){
if(idx >= log->rxCnt_ampdu)
break;
printk("[rxAmpdu %03d] = %d\n", idx, log->rxAmpdu[idx]);
}
}
void phl_dump_record(_adapter *adapter, u8 dump_type)
{
struct phl_logs *log = &adapter->phl_logs;
u32 idx = 0;
printk("txBd: %d (%d) \n", log->txCnt_bd, log->txCnt_bd%CORE_LOG_NUM);
printk("txWd: %d (%d) \n", log->txCnt_wd, log->txCnt_wd%CORE_LOG_NUM);
printk("wpCnt_recycle: %d (%d) \n", log->txCnt_recycle, log->txCnt_recycle%CORE_LOG_NUM);
printk("rxMap: %d (%d), Sz=%d \n", log->rxCnt_map, log->rxCnt_map%CORE_LOG_NUM, log->rxSize_map);
printk("rxUnmap: %d (%d), Sz=%d \n", log->rxCnt_unmap, log->txCnt_wd%CORE_LOG_NUM, log->rxSize_map);
printk("rxWd: %d (%d) \n", log->rxCnt_wd, log->rxCnt_wd%CORE_LOG_NUM);
printk("rxCnt_ampdu: %d (%d) \n", log->rxCnt_ampdu, log->rxCnt_ampdu%CORE_LOG_NUM);
if(dump_type == REC_DUMP_TX)
phl_dump_map_tx(adapter);
else if(dump_type == REC_DUMP_RX)
phl_dump_map_rx(adapter);
else if(dump_type == REC_DUMP_ALL){
phl_dump_map_tx(adapter);
phl_dump_map_rx(adapter);
}
}
u32 tmp_rx_last_ppdu = 0;
void phl_add_record(void *d, u8 type, void *p, u32 num)
{
struct dvobj_priv *pobj = (struct dvobj_priv *)d;
_adapter *adapter = dvobj_get_primary_adapter(pobj);
struct phl_logs *log = &adapter->phl_logs;
if(!adapter->record_enable)
return;
if(type == REC_TXWD){
u32 idx = log->txCnt_wd%CORE_LOG_NUM;
struct record_txwd *record = &(log->txWd[idx]);
log->txCnt_wd++;
record->wd_len = num;
memset((u8 *)record->wd_buf, 0, MAX_TXWD_SIZE);
memcpy((u8 *)record->wd_buf, p, num);
}
if(type == REC_TXBD){
u32 idx = log->txCnt_bd%CORE_LOG_NUM;
struct record_txbd *record = &(log->txBd[idx]);
log->txCnt_bd++;
record->bd_len = num;
memset((u8 *)record->bd_buf, 0, MAX_TXBD_SIZE);
memcpy((u8 *)record->bd_buf, p, num);
}
if(type == REC_WP_RCC){
u32 idx = log->txCnt_recycle%CORE_LOG_NUM;
struct record_wp_rcc *record = &(log->wpRecycle[idx]);
log->txCnt_recycle++;
record->wp_seq = num;
}
if(type == REC_RX_MAP || type == REC_RX_UNMAP){
struct record_pci *record = NULL;
if(type == REC_RX_MAP) {
u32 idx = log->rxCnt_map%CORE_LOG_NUM;
record = &(log->rxPciMap[idx]);
log->rxCnt_map++;
log->rxSize_map+=num;
}
else if(type == REC_RX_UNMAP) {
u32 idx = log->rxCnt_unmap%CORE_LOG_NUM;
record = &(log->rxPciUnmap[idx]);
log->rxCnt_unmap++;
log->rxSize_map+=num;
}
record->phyAddrL = p;
record->map_len = num;
}
if(type == REC_RXWD){
u32 idx = log->rxCnt_wd%CORE_LOG_NUM;
struct record_rxwd *record = &(log->rxWd[idx]);
log->rxCnt_wd++;
record->wd_len = num;
memset((u8 *)record->wd_buf, 0, MAX_RXWD_SIZE);
memcpy((u8 *)record->wd_buf, p, num);
}
if(type == REC_RX_AMPDU){
u32 idx = 0;
if(log->rxCnt_ampdu == 0 && (log->rxAmpdu[0] == 0))
tmp_rx_last_ppdu = num;
if(tmp_rx_last_ppdu != num){
tmp_rx_last_ppdu = num;
log->rxCnt_ampdu ++;
idx = log->rxCnt_ampdu%CORE_LOG_NUM;
log->rxAmpdu[idx] = 1;
}
else{
idx = log->rxCnt_ampdu%CORE_LOG_NUM;
log->rxAmpdu[idx]++;
}
}
}
void core_cmd_record_trx(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 idx = 0;
char *para = (char *)cmd_para;
if(para_num<=0)
return;
if(!strcmp(para, "start")){
u8 *log = NULL;
log = (u8*)&adapter->core_logs;
memset(log, 0, sizeof(struct core_logs));
log = (u8*)&adapter->phl_logs;
memset(log, 0, sizeof(struct phl_logs));
adapter->record_enable = 1;
}else if(!strcmp(para, "stop")){
adapter->record_enable = 0;
}else if(!strcmp(para, "dump")){
u32 dump_type = 0;
para=get_next_para_str(para);
sscanf(para, "%d", &dump_type);
phl_dump_record(adapter, (u8)dump_type);
}
}
void reset_txforce_para(_adapter *adapter)
{
adapter->txForce_rate = INV_TXFORCE_VAL;
adapter->txForce_agg = INV_TXFORCE_VAL;
adapter->txForce_aggnum = INV_TXFORCE_VAL;
adapter->txForce_gi = INV_TXFORCE_VAL;
}
void core_cmd_txforce(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 idx = 0;
char *para = (char *)cmd_para;
if(para_num<=0)
return;
if(!strcmp(para, "start")){
adapter->txForce_enable = 1;
reset_txforce_para(adapter);
}else if(!strcmp(para, "stop")){
adapter->txForce_enable = 0;
reset_txforce_para(adapter);
}else if(!strcmp(para, "rate")){
u32 rate = 0;
para=get_next_para_str(para);
sscanf(para, "%x", &rate);
adapter->txForce_rate = rate;
}else if(!strcmp(para, "agg")){
u32 agg = 0;
para=get_next_para_str(para);
sscanf(para, "%x", &agg);
adapter->txForce_agg = agg;
}else if(!strcmp(para, "aggnum")){
u32 aggnum = 0;
para=get_next_para_str(para);
sscanf(para, "%d", &aggnum);
adapter->txForce_aggnum = aggnum;
}else if(!strcmp(para, "gi")){
u32 gi = 0;
para=get_next_para_str(para);
sscanf(para, "%d", &gi);
adapter->txForce_gi = gi;
}else if(!strcmp(para, "macid")){
}else if(!strcmp(para, "retry")){
}
}
#ifdef CONFIG_RTW_CORE_RXSC
void core_cmd_rxsc(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 idx = 0;
char *para = (char *)cmd_para;
printk("core_cmd_rxsc \n");
if(para_num<=0)
return;
if(!strcmp(para, "enable")){
printk("enable");
adapter->enable_rxsc = 1;
}else if(!strcmp(para, "disable")){
printk("disable");
adapter->enable_rxsc = 0;
}else if(!strcmp(para, "dump")){
struct core_logs *log = &adapter->core_logs;
printk("dump");
printk("enable_rxsc: %d \n", adapter->enable_rxsc);
printk("rxCnt_data: orig=%d shortcut=%d(ratio=%d)\n",
log->rxCnt_data_orig, log->rxCnt_data_shortcut,
log->rxCnt_data_shortcut*100/(log->rxCnt_data_orig+log->rxCnt_data_shortcut));
}
}
#endif
void core_sniffer_rx(_adapter *adapter, u8 *pkt, u32 pktlen)
{
struct sk_buff* pskb = NULL;
if(!adapter->sniffer_enable)
return;
if(pkt==NULL)
return;
pskb = dev_alloc_skb(pktlen+200);
if(pskb == NULL){
return;
}
_rtw_memcpy(pskb->data, pkt, pktlen);
pskb->len = pktlen;
skb_reset_mac_header(pskb);
pskb->dev = adapter->pnetdev;
pskb->dev->type = ARPHRD_IEEE80211;
pskb->ip_summed = CHECKSUM_UNNECESSARY;
pskb->pkt_type = PACKET_OTHERHOST;
pskb->protocol = htons(ETH_P_802_2);
netif_receive_skb(pskb);
return;
}
void core_cmd_sniffer(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 idx=0;
char *para = (char *)cmd_para;
if(para_num<=0)
return;
if(!strcmp(para, "start")){
adapter->sniffer_enable = 1;
}else if(!strcmp(para, "stop")){
adapter->sniffer_enable = 0;
}
}
#define LEN_TEST_BUF 2000
u8 test_buf[LEN_TEST_BUF];
#ifdef CONFIG_PCI_HCI
#include <rtw_trx_pci.h>
#endif
#include "../phl/phl_headers.h"
#include "../phl/phl_api.h"
#include "../phl/hal_g6/hal_api_mac.h"
#include "../phl/hal_g6/mac/mac_reg.h"
#define SHOW_REG32(adapter, reg) \
do { \
printk("\t%04X = %08X\n", \
(reg), rtw_phl_read32(adapter->dvobj->phl, reg)); \
} while (0)
#define SHOW_REG32_MSG(adapter, reg, msg) \
do { \
printk("\t%04X = %08X - %s\n", \
(reg), rtw_phl_read32(adapter->dvobj->phl, reg), msg); \
} while (0)
#define SHOW_REG16(adapter, reg) \
do { \
printk("\t%04X = %04X\n", \
(reg), rtw_phl_read16(adapter->dvobj->phl, reg)); \
} while (0)
#define SHOW_REG16_MSG(adapter, reg, msg) \
do { \
printk("\t%04X = %04X - %s\n", \
(reg), rtw_phl_read16(adapter->dvobj->phl, reg), msg); \
} while (0)
static inline void _show_RX_counter(_adapter *adapter)
{
/* Show RX PPDU counters */
int i;
u32 reg32 = rtw_phl_read32(adapter->dvobj->phl, R_AX_RX_DBG_CNT_SEL);
static const char *cnt_name[] = {"Invalid packet",
"RE-CCA",
"RX FIFO overflow",
"RX packet full drop",
"RX packet dma OK",
"UD 0",
"UD 1",
"UD 2",
"UD 3",
"continuous FCS error",
"RX packet filter drop",
"CSI packet DMA OK",
"CSI packet DMA drop",
"RX MAC stop"
};
printk("CMAC0 RX PPDU Counters @%04X:\n", R_AX_RX_DBG_CNT_SEL);
reg32 &= ~(B_AX_RX_CNT_IDX_MSK << B_AX_RX_CNT_IDX_SH);
for (i = 30; i < 44; i++) {
rtw_phl_write32(adapter->dvobj->phl, R_AX_RX_DBG_CNT_SEL,
reg32 | (i << B_AX_RX_CNT_IDX_SH));
printk(" %02X: %d - %s\n", i,
(
( rtw_phl_read32(adapter->dvobj->phl, R_AX_RX_DBG_CNT_SEL)
>> B_AX_RX_DBG_CNT_SH)
& B_AX_RX_DBG_CNT_MSK),
cnt_name[i - 30]);
}
reg32 = rtw_phl_read32(adapter->dvobj->phl, R_AX_RX_DBG_CNT_SEL_C1);
printk("CMAC1 RX PPDU Counters @%04X:\n", R_AX_RX_DBG_CNT_SEL_C1);
reg32 &= ~(B_AX_RX_CNT_IDX_MSK << B_AX_RX_CNT_IDX_SH);
for (i = 30; i < 44; i++) {
rtw_phl_write32(adapter->dvobj->phl, R_AX_RX_DBG_CNT_SEL_C1,
reg32 | (i << B_AX_RX_CNT_IDX_SH));
printk(" %02X: %d - %s\n", i,
(
( rtw_phl_read32(adapter->dvobj->phl, R_AX_RX_DBG_CNT_SEL_C1)
>> B_AX_RX_DBG_CNT_SH)
& B_AX_RX_DBG_CNT_MSK),
cnt_name[i - 30]);
}
} /* _show_RX_counter */
void _show_TX_dbg_status(_adapter *adapter)
{
u32 reg32 = rtw_phl_read32(adapter->dvobj->phl, 0x9F1C);
printk("TX Debug: 0x%08X\n", reg32);
}
void _show_BCN_dbg_status(_adapter *adapter)
{
SHOW_REG32_MSG(adapter, R_AX_PORT_CFG_P0, "PORT_CFG_P0");
SHOW_REG32_MSG(adapter, R_AX_TBTT_PROHIB_P0, "TBTT_PROHIB_P0");
SHOW_REG32_MSG(adapter, R_AX_EN_HGQ_NOLIMIT, "EN_HGQ_NOLIMIT");
SHOW_REG32_MSG(adapter, R_AX_TBTT_AGG_P0, "TBTT_AGG_P0");
SHOW_REG32_MSG(adapter, R_AX_PORT_CFG_P0_C1, "PORT_CFG_P0_C1");
SHOW_REG32_MSG(adapter, R_AX_TBTT_PROHIB_P0_C1, "TBTT_PROHIB_P0_C1");
SHOW_REG32_MSG(adapter, R_AX_EN_HGQ_NOLIMIT_C1, "EN_HGQ_NOLIMIT_C1");
SHOW_REG32_MSG(adapter, R_AX_TBTT_AGG_P0_C1, "TBTT_AGG_P0_C1");
SHOW_REG32_MSG(adapter, R_AX_WCPU_FW_CTRL, "R_AX_WCPU_FW_CTRL");
}
void core_cmd_dump_debug(_adapter *adapter, void *cmd_para, u32 para_num)
{
printk("TX path registers: \n");
SHOW_REG32_MSG(adapter, R_AX_RXQ_RXBD_IDX, "RX_BD_IDX");
SHOW_REG32_MSG(adapter, R_AX_RPQ_RXBD_IDX, "RP_BD_IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH0_TXBD_IDX, "ACH0 IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH1_TXBD_IDX, "ACH1 IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH2_TXBD_IDX, "ACH2 IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH3_TXBD_IDX, "ACH3 IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH4_TXBD_IDX, "ACH4 IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH5_TXBD_IDX, "ACH5 IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH6_TXBD_IDX, "ACH6 IDX");
SHOW_REG32_MSG(adapter, R_AX_ACH7_TXBD_IDX, "ACH7 IDX");
SHOW_REG32_MSG(adapter, R_AX_CH8_TXBD_IDX, "CH8 IDX");
SHOW_REG32_MSG(adapter, R_AX_CH9_TXBD_IDX, "CH9 IDX");
SHOW_REG32_MSG(adapter, R_AX_CH10_TXBD_IDX, "CH10 IDX");
SHOW_REG32_MSG(adapter, R_AX_CH11_TXBD_IDX, "CH11 IDX");
SHOW_REG32_MSG(adapter, R_AX_CH12_TXBD_IDX, "CH12 IDX");
#ifdef R_AX_PCIE_DBG_CTRL
SHOW_REG32_MSG(adapter, R_AX_PCIE_DBG_CTRL, "DBG_CTRL");
#else
SHOW_REG32_MSG(adapter, 0x11C0, "DBG_CTRL");
#endif
SHOW_REG32_MSG(adapter, R_AX_DBG_ERR_FLAG, "DBG_ERR");
SHOW_REG32_MSG(adapter, R_AX_PCIE_HIMR00, "IMR0");
SHOW_REG32_MSG(adapter, R_AX_PCIE_HISR00, "ISR0");
SHOW_REG32_MSG(adapter, R_AX_PCIE_HIMR10, "IMR1");
SHOW_REG32_MSG(adapter, R_AX_PCIE_HISR10, "IMR1");
SHOW_REG16_MSG(adapter, R_AX_ACH0_BDRAM_RWPTR, "CH0");
SHOW_REG16_MSG(adapter, R_AX_ACH1_BDRAM_RWPTR, "CH1");
SHOW_REG16_MSG(adapter, R_AX_ACH2_BDRAM_RWPTR, "CH2");
SHOW_REG16_MSG(adapter, R_AX_ACH3_BDRAM_RWPTR, "CH3");
SHOW_REG16_MSG(adapter, R_AX_ACH4_BDRAM_RWPTR, "CH4");
SHOW_REG16_MSG(adapter, R_AX_ACH5_BDRAM_RWPTR, "CH5");
SHOW_REG16_MSG(adapter, R_AX_ACH6_BDRAM_RWPTR, "CH6");
SHOW_REG16_MSG(adapter, R_AX_ACH7_BDRAM_RWPTR, "CH7");
SHOW_REG16_MSG(adapter, R_AX_CH8_BDRAM_RWPTR, "CH8");
SHOW_REG16_MSG(adapter, R_AX_CH9_BDRAM_RWPTR, "CH9");
SHOW_REG16_MSG(adapter, R_AX_CH10_BDRAM_RWPTR, "CH10");
SHOW_REG16_MSG(adapter, R_AX_CH11_BDRAM_RWPTR, "CH11");
SHOW_REG16_MSG(adapter, R_AX_CH12_BDRAM_RWPTR, "CH12");
SHOW_REG32_MSG(adapter, R_AX_PCIE_DMA_STOP1, "DMA_STOP1");
SHOW_REG32_MSG(adapter, R_AX_PCIE_DMA_BUSY1, "DMA_BUSY1");
SHOW_REG32_MSG(adapter, R_AX_PCIE_DMA_STOP2, "DMA_STOP2");
SHOW_REG32_MSG(adapter, R_AX_PCIE_DMA_BUSY2, "DMA_BUSY2");
SHOW_REG32(adapter, 0x8840);
SHOW_REG32(adapter, 0x8844);
SHOW_REG32(adapter, 0x8854);
SHOW_REG16(adapter, 0xCA22);
SHOW_REG32(adapter, 0x8AA8);
/* Show TX PPDU counters */
do {
int i;
u32 reg32 = rtw_phl_read32(adapter->dvobj->phl, R_AX_TX_PPDU_CNT);
printk("CMAC0 TX PPDU Counters @%04X:\n", R_AX_TX_PPDU_CNT);
reg32 &= ~(B_AX_PPDU_CNT_IDX_MSK << B_AX_PPDU_CNT_IDX_SH);
for (i = 0; i < 11; i++) {
rtw_phl_write32(adapter->dvobj->phl, R_AX_TX_PPDU_CNT,
reg32 | (i << B_AX_PPDU_CNT_IDX_SH));
printk(" %02X: %d\n", i,
(
( rtw_phl_read32(adapter->dvobj->phl, R_AX_TX_PPDU_CNT)
>> B_AX_TX_PPDU_CNT_SH)
& B_AX_TX_PPDU_CNT_MSK));
}
reg32 = rtw_phl_read32(adapter->dvobj->phl, R_AX_TX_PPDU_CNT_C1);
printk("CMAC1 TX PPDU Counters @%04X:\n", R_AX_TX_PPDU_CNT_C1);
reg32 &= ~(B_AX_PPDU_CNT_IDX_MSK << B_AX_PPDU_CNT_IDX_SH);
for (i = 0; i < 11; i++) {
rtw_phl_write32(adapter->dvobj->phl, R_AX_TX_PPDU_CNT_C1,
reg32 | (i << B_AX_PPDU_CNT_IDX_SH));
printk(" %02X: %d\n", i,
(
( rtw_phl_read32(adapter->dvobj->phl, R_AX_TX_PPDU_CNT_C1)
>> B_AX_TX_PPDU_CNT_SH)
& B_AX_TX_PPDU_CNT_MSK));
}
} while (0);
/* Show RX PPDU counters */
_show_RX_counter(adapter);
_show_TX_dbg_status(adapter);
_show_BCN_dbg_status(adapter);
}
void core_cmd_dump_reg(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 *para = (u32 *)cmd_para;
void *phl = adapter->dvobj->phl;
u32 reg_start, reg_end;
u32 idx = 0;
reg_start = para[0];
reg_end = reg_start + para[1];
while(1) {
if((reg_start>=reg_end) || (reg_start >= 0xffff))
break;
printk("[%04x] %08x %08x %08x %08x \n",
reg_start,
rtw_phl_read32(phl, reg_start), rtw_phl_read32(phl, reg_start+4),
rtw_phl_read32(phl, reg_start+8), rtw_phl_read32(phl, reg_start+12));
reg_start+=16;
}
}
enum _CORE_CMD_PARA_TYPE {
CMD_PARA_DEC = 0,
CMD_PARA_HEX,
CMD_PARA_STR,
};
struct test_cmd_list {
const char *name;
void (*fun)(_adapter *, void *, u32);
enum _CORE_CMD_PARA_TYPE para_type;
};
void test_dump_dec(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 idx = 0;
u32 *para = (u32 *)cmd_para;
DBGP("para_num=%d\n", para_num);
for(idx=0; idx<para_num; idx++)
DBGP("para[%d]=%d\n", para_num, para[idx]);
}
void test_dump_hex(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 idx = 0;
u32 *para = (u32 *)cmd_para;
DBGP("para_num=%d\n", para_num);
for(idx=0; idx<para_num; idx++)
DBGP("para[%d]=0x%x\n", para_num, para[idx]);
}
void test_dump_str(_adapter *adapter, void *cmd_para, u32 para_num)
{
u32 idx = 0;
char *para = (char *)cmd_para;
DBGP("para_num=%d\n", para_num);
for(idx=0; idx<para_num; idx++, para+=MAX_PHL_CMD_STR_LEN)
DBGP("para[%d]=%s\n", para_num, para);
}
void get_all_cmd_para_value(_adapter *adapter, char *buf, u32 len, u32 *para, u8 type, u32 *num)
{
u8 *tmp = NULL;
if(!buf || !len)
return;
DBGP("type=%d buf=%s para=%p num=%d\n", type, buf, para, *num);
if(len > 0){
tmp = strsep(&buf, ",");
if(tmp){
if(type == CMD_PARA_HEX)
sscanf(tmp, "%x", para);
else if(type == CMD_PARA_DEC)
sscanf(tmp, "%d", para);
para += 1;
*num = *num+1;
}
else
return;
if(buf && (len>strlen(tmp)))
get_all_cmd_para_value(adapter, buf, strlen(buf), para, type, num);
else
return;
}
}
void get_all_cmd_para_str(_adapter *adapter, char *buf, u32 len, char *para, u8 type, u32* num)
{
u8 *tmp = NULL;
if(!buf || !len)
return;
DBGP("type=%d buf=%s para=%p num=%d\n", type, buf, para, *num);
if(len > 0){
tmp = strsep(&buf, ",");
if(tmp){
strcpy(para, tmp);
para += MAX_PHL_CMD_STR_LEN;
*num = *num+1;
}
else
return;
if(buf && (len>strlen(tmp)))
get_all_cmd_para_str(adapter, buf, strlen(buf), para, type, num);
else
return;
}
}
struct test_cmd_list core_test_cmd_list[] = {
{"dec", test_dump_dec, CMD_PARA_DEC},
{"hex", test_dump_hex, CMD_PARA_HEX},
{"str", test_dump_str, CMD_PARA_STR},
{"dump_reg", core_cmd_dump_reg, CMD_PARA_HEX},
{"dump_debug", core_cmd_dump_debug, CMD_PARA_DEC},
{"record", core_cmd_record_trx, CMD_PARA_STR},
{"txforce", core_cmd_txforce, CMD_PARA_STR},
{"sniffer", core_cmd_sniffer, CMD_PARA_STR},
#ifdef CONFIG_RTW_CORE_RXSC
{"rxsc", core_cmd_rxsc, CMD_PARA_STR},
#endif
};
void core_cmd_phl_handler(_adapter *adapter, char *extra)
{
u32 para[MAX_PHL_CMD_NUM]={0};
char para_str[MAX_PHL_CMD_NUM][MAX_PHL_CMD_STR_LEN]={0};
char *cmd_name, *cmd_para = NULL;
struct test_cmd_list *cmd = &core_test_cmd_list;
u32 array_size = ARRAY_SIZE(core_test_cmd_list);
u32 i = 0;
cmd_name = strsep(&extra, ",");
if(!cmd_name){
for(i = 0; i<array_size; i++, cmd++)
printk(" - %s\n", cmd->name);
return;
}
for(i = 0; i<array_size; i++, cmd++){
if(!strcmp(cmd->name, cmd_name)){
void *cmd_para = NULL;
u32 cmd_para_num = 0;
if(cmd->para_type == CMD_PARA_DEC || cmd->para_type == CMD_PARA_HEX){
cmd_para = para;
if(extra)
get_all_cmd_para_value(adapter, extra, strlen(extra), para, cmd->para_type, &cmd_para_num);
}
else{
cmd_para = para_str;
if(extra)
get_all_cmd_para_str(adapter, extra, strlen(extra), para_str, cmd->para_type, &cmd_para_num);
}
cmd->fun(adapter, cmd_para, cmd_para_num);
break;
}
}
}
#endif
u8 rtw_test_h2c_cmd(_adapter *adapter, u8 *buf, u8 len)
{
struct cmd_obj *pcmdobj;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
u8 *ph2c_content;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _SUCCESS;
pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmdobj == NULL) {
res = _FAIL;
goto exit;
}
pcmdobj->padapter = adapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((u8 *)pcmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
ph2c_content = rtw_zmalloc(len);
if (ph2c_content == NULL) {
rtw_mfree((u8 *)pcmdobj, sizeof(struct cmd_obj));
rtw_mfree((u8 *)pdrvextra_cmd_parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = TEST_H2C_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = len;
pdrvextra_cmd_parm->pbuf = ph2c_content;
_rtw_memcpy(ph2c_content, buf, len);
init_h2fwcmd_w_parm_no_rsp(pcmdobj, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
exit:
return res;
}
#ifdef CONFIG_MP_INCLUDED
static s32 rtw_mp_cmd_hdl(_adapter *padapter, u8 mp_cmd_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
int ret = H2C_SUCCESS;
uint status = _FALSE;
struct mp_priv *pmppriv = &padapter->mppriv;
struct rtw_test_module_info test_module_info;
struct rtw_mp_test_rpt my_mp_test_rpt;
if (mp_cmd_id == MP_START) {
if (padapter->registrypriv.mp_mode == 0) {
test_module_info.tm_mode = RTW_DRV_MODE_MP;
test_module_info.tm_type = RTW_TEST_SUB_MODULE_MP;
pmppriv->keep_ips_status = dvobj->phl_com->dev_sw_cap.ps_cap.ips_en;
pmppriv->keep_lps_status = dvobj->phl_com->dev_sw_cap.ps_cap.lps_en;
dvobj->phl_com->dev_sw_cap.ps_cap.ips_en = PS_OP_MODE_DISABLED;
dvobj->phl_com->dev_sw_cap.ps_cap.lps_en = PS_OP_MODE_DISABLED;
rtw_phl_test_submodule_init(dvobj->phl_com, &test_module_info);
#ifdef CONFIG_BTC
if (dvobj->phl_com->dev_cap.btc_mode == BTC_MODE_NORMAL ||\
dvobj->phl_com->dev_cap.btc_mode == BTC_MODE_BT) {
pmppriv->mp_keep_btc_mode = dvobj->phl_com->dev_cap.btc_mode;
rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_SWITCH_BT_PATH);
RTW_INFO("config BTC to WL Only\n");
}
#endif
rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_SET_PHY_INDEX);
status = rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_START_DUT);
if (status == _TRUE) {
padapter->registrypriv.mp_mode = 1;
MPT_InitializeAdapter(padapter, 1);
}
}
if (padapter->registrypriv.mp_mode == 0) {
ret = H2C_REJECTED;
goto exit;
}
if (padapter->mppriv.mode == MP_OFF) {
if (mp_start_test(padapter) == _FAIL) {
ret = H2C_REJECTED;
goto exit;
}
padapter->mppriv.mode = MP_ON;
}
padapter->mppriv.bmac_filter = _FALSE;
} else if (mp_cmd_id == MP_STOP) {
if (padapter->registrypriv.mp_mode == 1) {
status = rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_STOP_DUT);
RTW_INFO("RTW_MP_CONFIG_CMD_STOP_DUT %s\n", status == _TRUE ? "ok" : "fail");
rtw_phl_test_get_rpt(dvobj->phl_com, (u8*)&my_mp_test_rpt, sizeof(my_mp_test_rpt));
if (my_mp_test_rpt.status == _TRUE)
RTW_INFO("TM Sub finished OK!!!\n");
#ifdef CONFIG_BTC
if (pmppriv->mp_keep_btc_mode != BTC_MODE_MAX) {
pmppriv->btc_path = pmppriv->mp_keep_btc_mode;
rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_SWITCH_BT_PATH);
}
#endif
test_module_info.tm_mode = RTW_DRV_MODE_NORMAL;
test_module_info.tm_type = RTW_TEST_SUB_MODULE_MP;
dvobj->phl_com->dev_sw_cap.ps_cap.ips_en = pmppriv->keep_ips_status;
dvobj->phl_com->dev_sw_cap.ps_cap.lps_en = pmppriv->keep_lps_status;
rtw_phl_test_submodule_deinit(dvobj->phl_com, &test_module_info);
MPT_DeInitAdapter(padapter);
padapter->registrypriv.mp_mode = 0;
}
if (padapter->mppriv.mode != MP_OFF) {
mp_stop_test(padapter);
padapter->mppriv.mode = MP_OFF;
}
} else {
RTW_INFO(FUNC_ADPT_FMT"invalid id:%d\n", FUNC_ADPT_ARG(padapter), mp_cmd_id);
ret = H2C_PARAMETERS_ERROR;
rtw_warn_on(1);
}
exit:
return ret;
}
u8 rtw_mp_cmd(_adapter *adapter, u8 mp_cmd_id, u8 flags)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
parm->ec_id = MP_CMD_WK_CID;
parm->type = mp_cmd_id;
parm->size = 0;
parm->pbuf = NULL;
if (flags & RTW_CMDF_DIRECTLY) {
/* no need to enqueue, do the cmd hdl directly and free cmd parameter */
if (H2C_SUCCESS != rtw_mp_cmd_hdl(adapter, mp_cmd_id))
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
} else {
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
if (flags & RTW_CMDF_WAIT_ACK) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 10 * 1000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
}
exit:
return res;
}
#endif /*CONFIG_MP_INCLUDED*/
#ifdef CONFIG_RTW_CUSTOMER_STR
static s32 rtw_customer_str_cmd_hdl(_adapter *adapter, u8 write, const u8 *cstr)
{
int ret = H2C_SUCCESS;
if (write)
ret = rtw_hal_h2c_customer_str_write(adapter, cstr);
else
ret = rtw_hal_h2c_customer_str_req(adapter);
return ret == _SUCCESS ? H2C_SUCCESS : H2C_REJECTED;
}
static u8 rtw_customer_str_cmd(_adapter *adapter, u8 write, const u8 *cstr)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
u8 *str = NULL;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
if (write) {
str = rtw_zmalloc(RTW_CUSTOMER_STR_LEN);
if (str == NULL) {
rtw_mfree((u8 *)parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
}
parm->ec_id = CUSTOMER_STR_WK_CID;
parm->type = write;
parm->size = write ? RTW_CUSTOMER_STR_LEN : 0;
parm->pbuf = write ? str : NULL;
if (write)
_rtw_memcpy(str, cstr, RTW_CUSTOMER_STR_LEN);
/* need enqueue, prepare cmd_obj and enqueue */
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
if (write)
rtw_mfree(str, RTW_CUSTOMER_STR_LEN);
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, 2 * 1000);
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
if (res == _SUCCESS) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
exit:
return res;
}
inline u8 rtw_customer_str_req_cmd(_adapter *adapter)
{
return rtw_customer_str_cmd(adapter, 0, NULL);
}
inline u8 rtw_customer_str_write_cmd(_adapter *adapter, const u8 *cstr)
{
return rtw_customer_str_cmd(adapter, 1, cstr);
}
#endif /* CONFIG_RTW_CUSTOMER_STR */
u8 rtw_c2h_wk_cmd(_adapter *padapter, u8 *pbuf, u16 length, u8 type)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 *extra_cmd_buf;
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((u8 *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
extra_cmd_buf = rtw_zmalloc(length);
if (extra_cmd_buf == NULL) {
rtw_mfree((u8 *)cmd, sizeof(struct cmd_obj));
rtw_mfree((u8 *)pdrvextra_cmd_parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
_rtw_memcpy(extra_cmd_buf, pbuf, length);
pdrvextra_cmd_parm->ec_id = C2H_WK_CID;
pdrvextra_cmd_parm->type = type;
pdrvextra_cmd_parm->size = length;
pdrvextra_cmd_parm->pbuf = extra_cmd_buf;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
#define C2H_TYPE_PKT 1
inline u8 rtw_c2h_packet_wk_cmd(_adapter *adapter, u8 *c2h_evt, u16 length)
{
return rtw_c2h_wk_cmd(adapter, c2h_evt, length, C2H_TYPE_PKT);
}
static u8 _rtw_run_in_thread_cmd(_adapter *adapter, void (*func)(void *), void *context, s32 timeout_ms)
{
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct cmd_obj *cmdobj;
struct RunInThread_param *parm;
struct submit_ctx sctx;
s32 res = _SUCCESS;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (NULL == cmdobj) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
parm = (struct RunInThread_param *)rtw_zmalloc(sizeof(struct RunInThread_param));
if (NULL == parm) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
parm->func = func;
parm->context = context;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_RUN_INTHREAD);
if (timeout_ms >= 0) {
cmdobj->sctx = &sctx;
rtw_sctx_init(&sctx, timeout_ms);
}
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
if (res == _SUCCESS && timeout_ms >= 0) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&cmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmdobj->sctx = NULL;
_rtw_mutex_unlock(&cmdpriv->sctx_mutex);
if (sctx.status != RTW_SCTX_DONE_SUCCESS)
res = _FAIL;
}
exit:
return res;
}
u8 rtw_run_in_thread_cmd(_adapter *adapter, void (*func)(void *), void *context)
{
return _rtw_run_in_thread_cmd(adapter, func, context, -1);
}
u8 rtw_run_in_thread_cmd_wait(_adapter *adapter, void (*func)(void *), void *context, s32 timeout_ms)
{
return _rtw_run_in_thread_cmd(adapter, func, context, timeout_ms);
}
u8 session_tracker_cmd(_adapter *adapter, u8 cmd, struct sta_info *sta, u8 *local_naddr, u8 *local_port, u8 *remote_naddr, u8 *remote_port)
{
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *cmd_parm;
struct st_cmd_parm *st_parm;
u8 res = _SUCCESS;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (cmd_parm == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
st_parm = (struct st_cmd_parm *)rtw_zmalloc(sizeof(struct st_cmd_parm));
if (st_parm == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
rtw_mfree((u8 *)cmd_parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
st_parm->cmd = cmd;
st_parm->sta = sta;
if (cmd != ST_CMD_CHK) {
_rtw_memcpy(&st_parm->local_naddr, local_naddr, 4);
_rtw_memcpy(&st_parm->local_port, local_port, 2);
_rtw_memcpy(&st_parm->remote_naddr, remote_naddr, 4);
_rtw_memcpy(&st_parm->remote_port, remote_port, 2);
}
cmd_parm->ec_id = SESSION_TRACKER_WK_CID;
cmd_parm->type = 0;
cmd_parm->size = sizeof(struct st_cmd_parm);
cmd_parm->pbuf = (u8 *)st_parm;
init_h2fwcmd_w_parm_no_rsp(cmdobj, cmd_parm, CMD_SET_DRV_EXTRA);
cmdobj->no_io = 1;
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
exit:
return res;
}
inline u8 session_tracker_chk_cmd(_adapter *adapter, struct sta_info *sta)
{
return session_tracker_cmd(adapter, ST_CMD_CHK, sta, NULL, NULL, NULL, NULL);
}
inline u8 session_tracker_add_cmd(_adapter *adapter, struct sta_info *sta, u8 *local_naddr, u8 *local_port, u8 *remote_naddr, u8 *remote_port)
{
return session_tracker_cmd(adapter, ST_CMD_ADD, sta, local_naddr, local_port, remote_naddr, remote_port);
}
inline u8 session_tracker_del_cmd(_adapter *adapter, struct sta_info *sta, u8 *local_naddr, u8 *local_port, u8 *remote_naddr, u8 *remote_port)
{
return session_tracker_cmd(adapter, ST_CMD_DEL, sta, local_naddr, local_port, remote_naddr, remote_port);
}
void session_tracker_chk_for_sta(_adapter *adapter, struct sta_info *sta)
{
struct st_ctl_t *st_ctl = &sta->st_ctl;
int i;
_list *plist, *phead, *pnext;
_list dlist;
struct session_tracker *st = NULL;
u8 op_wfd_mode = MIRACAST_DISABLED;
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" sta:%p\n", FUNC_ADPT_ARG(adapter), sta);
if (!(sta->state & WIFI_ASOC_STATE))
goto exit;
for (i = 0; i < SESSION_TRACKER_REG_ID_NUM; i++) {
if (st_ctl->reg[i].s_proto != 0)
break;
}
if (i >= SESSION_TRACKER_REG_ID_NUM)
goto chk_sta;
_rtw_init_listhead(&dlist);
_rtw_spinlock_bh(&st_ctl->tracker_q.lock);
phead = &st_ctl->tracker_q.queue;
plist = get_next(phead);
pnext = get_next(plist);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
st = LIST_CONTAINOR(plist, struct session_tracker, list);
plist = pnext;
pnext = get_next(pnext);
if (st->status != ST_STATUS_ESTABLISH
&& rtw_get_passing_time_ms(st->set_time) > ST_EXPIRE_MS
) {
rtw_list_delete(&st->list);
rtw_list_insert_tail(&st->list, &dlist);
}
/* TODO: check OS for status update */
if (st->status == ST_STATUS_CHECK)
st->status = ST_STATUS_ESTABLISH;
if (st->status != ST_STATUS_ESTABLISH)
continue;
#ifdef CONFIG_WFD
if (0)
RTW_INFO(FUNC_ADPT_FMT" local:%u, remote:%u, rtsp:%u, %u, %u\n", FUNC_ADPT_ARG(adapter)
, ntohs(st->local_port), ntohs(st->remote_port), adapter->wfd_info.rtsp_ctrlport, adapter->wfd_info.tdls_rtsp_ctrlport
, adapter->wfd_info.peer_rtsp_ctrlport);
if (ntohs(st->local_port) == adapter->wfd_info.rtsp_ctrlport)
op_wfd_mode |= MIRACAST_SINK;
if (ntohs(st->local_port) == adapter->wfd_info.tdls_rtsp_ctrlport)
op_wfd_mode |= MIRACAST_SINK;
if (ntohs(st->remote_port) == adapter->wfd_info.peer_rtsp_ctrlport)
op_wfd_mode |= MIRACAST_SOURCE;
#endif
}
_rtw_spinunlock_bh(&st_ctl->tracker_q.lock);
plist = get_next(&dlist);
while (rtw_end_of_queue_search(&dlist, plist) == _FALSE) {
st = LIST_CONTAINOR(plist, struct session_tracker, list);
plist = get_next(plist);
rtw_mfree((u8 *)st, sizeof(struct session_tracker));
}
chk_sta:
if (STA_OP_WFD_MODE(sta) != op_wfd_mode) {
STA_SET_OP_WFD_MODE(sta, op_wfd_mode);
rtw_sta_media_status_rpt_cmd(adapter, sta, 1);
}
exit:
return;
}
void session_tracker_chk_for_adapter(_adapter *adapter)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct sta_info *sta;
int i;
_list *plist, *phead;
u8 op_wfd_mode = MIRACAST_DISABLED;
_rtw_spinlock_bh(&stapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(stapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
sta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
session_tracker_chk_for_sta(adapter, sta);
op_wfd_mode |= STA_OP_WFD_MODE(sta);
}
}
_rtw_spinunlock_bh(&stapriv->sta_hash_lock);
#ifdef CONFIG_WFD
adapter->wfd_info.op_wfd_mode = MIRACAST_MODE_REVERSE(op_wfd_mode);
#endif
}
void session_tracker_cmd_hdl(_adapter *adapter, struct st_cmd_parm *parm)
{
u8 cmd = parm->cmd;
struct sta_info *sta = parm->sta;
if (cmd == ST_CMD_CHK) {
if (sta)
session_tracker_chk_for_sta(adapter, sta);
else
session_tracker_chk_for_adapter(adapter);
goto exit;
} else if (cmd == ST_CMD_ADD || cmd == ST_CMD_DEL) {
struct st_ctl_t *st_ctl;
u32 local_naddr = parm->local_naddr;
u16 local_port = parm->local_port;
u32 remote_naddr = parm->remote_naddr;
u16 remote_port = parm->remote_port;
struct session_tracker *st = NULL;
_list *plist, *phead;
u8 free_st = 0;
u8 alloc_st = 0;
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" cmd:%u, sta:%p, local:"IP_FMT":"PORT_FMT", remote:"IP_FMT":"PORT_FMT"\n"
, FUNC_ADPT_ARG(adapter), cmd, sta
, IP_ARG(&local_naddr), PORT_ARG(&local_port)
, IP_ARG(&remote_naddr), PORT_ARG(&remote_port)
);
if (!(sta->state & WIFI_ASOC_STATE))
goto exit;
st_ctl = &sta->st_ctl;
_rtw_spinlock_bh(&st_ctl->tracker_q.lock);
phead = &st_ctl->tracker_q.queue;
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
st = LIST_CONTAINOR(plist, struct session_tracker, list);
if (st->local_naddr == local_naddr
&& st->local_port == local_port
&& st->remote_naddr == remote_naddr
&& st->remote_port == remote_port)
break;
plist = get_next(plist);
}
if (rtw_end_of_queue_search(phead, plist) == _TRUE)
st = NULL;
switch (cmd) {
case ST_CMD_DEL:
if (st) {
rtw_list_delete(plist);
free_st = 1;
}
goto unlock;
case ST_CMD_ADD:
if (!st)
alloc_st = 1;
}
unlock:
_rtw_spinunlock_bh(&st_ctl->tracker_q.lock);
if (free_st) {
rtw_mfree((u8 *)st, sizeof(struct session_tracker));
goto exit;
}
if (alloc_st) {
st = (struct session_tracker *)rtw_zmalloc(sizeof(struct session_tracker));
if (!st)
goto exit;
st->local_naddr = local_naddr;
st->local_port = local_port;
st->remote_naddr = remote_naddr;
st->remote_port = remote_port;
st->set_time = rtw_get_current_time();
st->status = ST_STATUS_CHECK;
_rtw_spinlock_bh(&st_ctl->tracker_q.lock);
rtw_list_insert_tail(&st->list, phead);
_rtw_spinunlock_bh(&st_ctl->tracker_q.lock);
}
}
exit:
return;
}
#if defined(CONFIG_RTW_MESH) && defined(RTW_PER_CMD_SUPPORT_FW)
static s32 rtw_req_per_cmd_hdl(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
struct macid_bmp req_macid_bmp, *macid_bmp;
u8 i, ret = _FAIL;
macid_bmp = &macid_ctl->if_g[adapter->iface_id];
_rtw_memcpy(&req_macid_bmp, macid_bmp, sizeof(struct macid_bmp));
/* Clear none mesh's macid */
for (i = 0; i < macid_ctl->num; i++) {
u8 role;
role = GET_H2CCMD_MSRRPT_PARM_ROLE(&macid_ctl->h2c_msr[i]);
if (role != H2C_MSR_ROLE_MESH)
rtw_macid_map_clr(&req_macid_bmp, i);
}
/* group_macid: always be 0 in NIC, so only pass macid_bitmap.m0
* rpt_type: 0 includes all info in 1, use 0 for now
* macid_bitmap: pass m0 only for NIC
*/
ret = rtw_hal_set_req_per_rpt_cmd(adapter, 0, 0, req_macid_bmp.m0);
return ret;
}
u8 rtw_req_per_cmd(_adapter *adapter)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct submit_ctx sctx;
u8 res = _SUCCESS;
parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (parm == NULL) {
res = _FAIL;
goto exit;
}
parm->ec_id = REQ_PER_CMD_WK_CID;
parm->type = 0;
parm->size = 0;
parm->pbuf = NULL;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
if (cmdobj == NULL) {
res = _FAIL;
rtw_mfree((u8 *)parm, sizeof(*parm));
goto exit;
}
cmdobj->padapter = adapter;
init_h2fwcmd_w_parm_no_rsp(cmdobj, parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
exit:
return res;
}
#endif
void rtw_ac_parm_cmd_hdl(_adapter *padapter, u8 *_ac_parm_buf, int ac_type)
{
u32 ac_parm_buf;
_rtw_memcpy(&ac_parm_buf, _ac_parm_buf, sizeof(ac_parm_buf));
switch (ac_type) {
case XMIT_VO_QUEUE:
RTW_INFO(FUNC_NDEV_FMT" AC_VO = 0x%08x\n", FUNC_ADPT_ARG(padapter), (unsigned int) ac_parm_buf);
rtw_ap_set_edca(padapter, 3, ac_parm_buf);
break;
case XMIT_VI_QUEUE:
RTW_INFO(FUNC_NDEV_FMT" AC_VI = 0x%08x\n", FUNC_ADPT_ARG(padapter), (unsigned int) ac_parm_buf);
rtw_ap_set_edca(padapter, 2, ac_parm_buf);
break;
case XMIT_BE_QUEUE:
RTW_INFO(FUNC_NDEV_FMT" AC_BE = 0x%08x\n", FUNC_ADPT_ARG(padapter), (unsigned int) ac_parm_buf);
rtw_ap_set_edca(padapter, 0, ac_parm_buf);
break;
case XMIT_BK_QUEUE:
RTW_INFO(FUNC_NDEV_FMT" AC_BK = 0x%08x\n", FUNC_ADPT_ARG(padapter), (unsigned int) ac_parm_buf);
rtw_ap_set_edca(padapter, 1, ac_parm_buf);
break;
default:
break;
}
}
u8 rtw_drvextra_cmd_hdl(_adapter *padapter, unsigned char *pbuf)
{
int ret = H2C_SUCCESS;
struct drvextra_cmd_parm *pdrvextra_cmd;
if (!pbuf)
return H2C_PARAMETERS_ERROR;
pdrvextra_cmd = (struct drvextra_cmd_parm *)pbuf;
switch (pdrvextra_cmd->ec_id) {
case STA_MSTATUS_RPT_WK_CID:
rtw_sta_media_status_rpt_cmd_hdl(padapter, (struct sta_media_status_rpt_cmd_parm *)pdrvextra_cmd->pbuf);
break;
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
case DYNAMIC_CHK_WK_CID:/*only primary padapter go to this cmd, but execute dynamic_chk_wk_hdl() for two interfaces */
rtw_dynamic_chk_wk_hdl(padapter);
break;
#endif
#ifdef CONFIG_POWER_SAVING
case POWER_SAVING_CTRL_WK_CID:
power_saving_wk_hdl(padapter);
break;
#endif
#ifdef CONFIG_LPS
case LPS_CTRL_WK_CID:
lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type, pdrvextra_cmd->pbuf);
break;
case DM_IN_LPS_WK_CID:
rtw_dm_in_lps_hdl(padapter);
break;
case LPS_CHANGE_DTIM_CID:
rtw_lps_change_dtim_hdl(padapter, (u8)pdrvextra_cmd->type);
break;
#endif
#ifdef CONFIG_ANTENNA_DIVERSITY
case ANT_SELECT_WK_CID:
antenna_select_wk_hdl(padapter, pdrvextra_cmd->type);
break;
#endif
#ifdef CONFIG_P2P_PS
case P2P_PS_WK_CID:
p2p_ps_wk_hdl(padapter, pdrvextra_cmd->type);
break;
#endif
#ifdef CONFIG_AP_MODE
case CHECK_HIQ_WK_CID:
rtw_chk_hi_queue_hdl(padapter);
break;
#endif
/* add for CONFIG_IEEE80211W, none 11w can use it */
case RESET_SECURITYPRIV:
reset_securitypriv_hdl(padapter);
break;
case FREE_ASSOC_RESOURCES:
free_assoc_resources_hdl(padapter, (u8)pdrvextra_cmd->type);
break;
case C2H_WK_CID:
switch (pdrvextra_cmd->type) {
case C2H_TYPE_PKT:
rtw_hal_c2h_pkt_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->size);
break;
default:
RTW_ERR("unknown C2H type:%d\n", pdrvextra_cmd->type);
rtw_warn_on(1);
break;
}
break;
#ifdef CONFIG_DFS_MASTER
case DFS_RADAR_DETECT_WK_CID:
rtw_dfs_rd_hdl(padapter);
break;
case DFS_RADAR_DETECT_EN_DEC_WK_CID:
rtw_dfs_rd_en_decision(padapter, MLME_ACTION_NONE, 0);
break;
#endif
case SESSION_TRACKER_WK_CID:
session_tracker_cmd_hdl(padapter, (struct st_cmd_parm *)pdrvextra_cmd->pbuf);
break;
case TEST_H2C_CID:
rtw_hal_fill_h2c_cmd(padapter, pdrvextra_cmd->pbuf[0], pdrvextra_cmd->size - 1, &pdrvextra_cmd->pbuf[1]);
break;
case MP_CMD_WK_CID:
#ifdef CONFIG_MP_INCLUDED
ret = rtw_mp_cmd_hdl(padapter, pdrvextra_cmd->type);
#endif
break;
#ifdef CONFIG_RTW_CUSTOMER_STR
case CUSTOMER_STR_WK_CID:
ret = rtw_customer_str_cmd_hdl(padapter, pdrvextra_cmd->type, pdrvextra_cmd->pbuf);
break;
#endif
#ifdef CONFIG_IOCTL_CFG80211
case MGNT_TX_WK_CID:
ret = rtw_mgnt_tx_handler(padapter, pdrvextra_cmd->pbuf);
break;
#endif /* CONFIG_IOCTL_CFG80211 */
#if defined(CONFIG_RTW_MESH) && defined(RTW_PER_CMD_SUPPORT_FW)
case REQ_PER_CMD_WK_CID:
ret = rtw_req_per_cmd_hdl(padapter);
break;
#endif
#ifdef CONFIG_SUPPORT_STATIC_SMPS
case SSMPS_WK_CID :
rtw_ssmps_wk_hdl(padapter, (struct ssmps_cmd_parm *)pdrvextra_cmd->pbuf);
break;
#endif
#ifdef CONFIG_CTRL_TXSS_BY_TP
case TXSS_WK_CID :
rtw_ctrl_txss_wk_hdl(padapter, (struct txss_cmd_parm *)pdrvextra_cmd->pbuf);
break;
#endif
case AC_PARM_CMD_WK_CID:
rtw_ac_parm_cmd_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type);
break;
#ifdef CONFIG_AP_MODE
case STOP_AP_WK_CID:
stop_ap_hdl(padapter);
break;
#endif
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
case TBTX_CONTROL_TX_WK_CID:
tx_control_hdl(padapter);
break;
#endif
#ifdef ROKU_PRIVATE
case FIND_REMOTE_WK_CID:
ret = issue_action_find_remote(padapter);
break;
#ifdef CONFIG_P2P
case HIDE_SSID_WK_CID:
issue_beacon(padapter, 0);
break;
#endif
#endif
default:
break;
}
if (pdrvextra_cmd->pbuf && pdrvextra_cmd->size > 0)
rtw_mfree(pdrvextra_cmd->pbuf, pdrvextra_cmd->size);
return ret;
}
void rtw_disassoc_cmd_callback(_adapter *padapter, struct cmd_obj *pcmd)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (pcmd->res != H2C_SUCCESS) {
_rtw_spinlock_bh(&pmlmepriv->lock);
set_fwstate(pmlmepriv, WIFI_ASOC_STATE);
_rtw_spinunlock_bh(&pmlmepriv->lock);
goto exit;
}
#ifdef CONFIG_BR_EXT
else /* clear bridge database */
nat25_db_cleanup(padapter);
#endif /* CONFIG_BR_EXT */
/* free cmd */
rtw_free_cmd_obj(pcmd);
exit:
return;
}
void rtw_joinbss_cmd_callback(_adapter *padapter, struct cmd_obj *pcmd)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (pcmd->res == H2C_DROPPED) {
/* TODO: cancel timer and do timeout handler directly... */
/* need to make timeout handlerOS independent */
set_assoc_timer(pmlmepriv, 1); /*_set_timer(&pmlmepriv->assoc_timer, 1);*/
} else if (pcmd->res != H2C_SUCCESS)
set_assoc_timer(pmlmepriv, 1); /*_set_timer(&pmlmepriv->assoc_timer, 1);*/
rtw_free_cmd_obj(pcmd);
}
void rtw_create_ibss_post_hdl(_adapter *padapter, int status)
{
struct wlan_network *pwlan = NULL;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
WLAN_BSSID_EX *pdev_network = &padapter->registrypriv.dev_network;
struct wlan_network *mlme_cur_network = &(pmlmepriv->cur_network);
if (status != H2C_SUCCESS)
set_assoc_timer(pmlmepriv, 1); /*_set_timer(&pmlmepriv->assoc_timer, 1);*/
/*_cancel_timer_ex(&pmlmepriv->assoc_timer);*/
cancel_assoc_timer(pmlmepriv);
_rtw_spinlock_bh(&pmlmepriv->lock);
{
pwlan = _rtw_alloc_network(pmlmepriv);
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
if (pwlan == NULL) {
pwlan = rtw_get_oldest_wlan_network(&pmlmepriv->scanned_queue);
if (pwlan == NULL) {
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
goto createbss_cmd_fail;
}
pwlan->last_scanned = rtw_get_current_time();
} else
rtw_list_insert_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue);
pdev_network->Length = get_WLAN_BSSID_EX_sz(pdev_network);
_rtw_memcpy(&(pwlan->network), pdev_network, pdev_network->Length);
/* pwlan->fixed = _TRUE; */
/* copy pdev_network information to pmlmepriv->cur_network */
_rtw_memcpy(&mlme_cur_network->network, pdev_network, (get_WLAN_BSSID_EX_sz(pdev_network)));
#if 0
/* reset DSConfig */
mlme_cur_network->network.Configuration.DSConfig = (u32)rtw_ch2freq(pdev_network->Configuration.DSConfig);
#endif
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
/* we will set WIFI_ASOC_STATE when there is one more sat to join us (rtw_stassoc_event_callback) */
}
createbss_cmd_fail:
_rtw_spinunlock_bh(&pmlmepriv->lock);
return;
}
void rtw_setstaKey_cmdrsp_callback(_adapter *padapter , struct cmd_obj *pcmd)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)(pcmd->rsp);
struct sta_info *psta = rtw_get_stainfo(pstapriv, psetstakey_rsp->addr);
if (psta == NULL) {
goto exit;
}
/* psta->phl_sta->aid = psta->phl_sta->macid = psetstakey_rsp->keyid; */ /* CAM_ID(CAM_ENTRY) */
exit:
rtw_free_cmd_obj(pcmd);
}
void rtw_getrttbl_cmd_cmdrsp_callback(_adapter *padapter, struct cmd_obj *pcmd)
{
rtw_free_cmd_obj(pcmd);
#ifdef CONFIG_MP_INCLUDED
if (padapter->registrypriv.mp_mode == 1)
padapter->mppriv.workparam.bcompleted = _TRUE;
#endif
}
u8 set_txq_params_cmd(_adapter *adapter, u32 ac_parm, u8 ac_type)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 *ac_parm_buf = NULL;
u8 sz;
u8 res = _SUCCESS;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
sz = sizeof(ac_parm);
ac_parm_buf = rtw_zmalloc(sz);
if (ac_parm_buf == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
rtw_mfree((u8 *)pdrvextra_cmd_parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = AC_PARM_CMD_WK_CID;
pdrvextra_cmd_parm->type = ac_type;
pdrvextra_cmd_parm->size = sz;
pdrvextra_cmd_parm->pbuf = ac_parm_buf;
_rtw_memcpy(ac_parm_buf, &ac_parm, sz);
init_h2fwcmd_w_parm_no_rsp(cmdobj, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
exit:
return res;
}
char UNKNOWN_CID[16] = "UNKNOWN_EXTRA";
char *rtw_extra_name(struct drvextra_cmd_parm *pdrvextra_cmd)
{
switch(pdrvextra_cmd->ec_id) {
case NONE_WK_CID:
return "NONE_WK_CID";
break;
case STA_MSTATUS_RPT_WK_CID:
return "STA_MSTATUS_RPT_WK_CID";
break;
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
case DYNAMIC_CHK_WK_CID:
return "DYNAMIC_CHK_WK_CID";
break;
#endif
case DM_CTRL_WK_CID:
return "DM_CTRL_WK_CID";
break;
case PBC_POLLING_WK_CID:
return "PBC_POLLING_WK_CID";
break;
#ifdef CONFIG_POWER_SAVING
case POWER_SAVING_CTRL_WK_CID:
return "POWER_SAVING_CTRL_WK_CID";
#endif
break;
case LPS_CTRL_WK_CID:
return "LPS_CTRL_WK_CID";
break;
case ANT_SELECT_WK_CID:
return "ANT_SELECT_WK_CID";
break;
case P2P_PS_WK_CID:
return "P2P_PS_WK_CID";
break;
case CHECK_HIQ_WK_CID:
return "CHECK_HIQ_WK_CID";
break;
case C2H_WK_CID:
return "C2H_WK_CID";
break;
case RESET_SECURITYPRIV:
return "RESET_SECURITYPRIV";
break;
case FREE_ASSOC_RESOURCES:
return "FREE_ASSOC_RESOURCES";
break;
case DM_IN_LPS_WK_CID:
return "DM_IN_LPS_WK_CID";
break;
case LPS_CHANGE_DTIM_CID:
return "LPS_CHANGE_DTIM_CID";
break;
case DFS_RADAR_DETECT_WK_CID:
return "DFS_RADAR_DETECT_WK_CID";
break;
case DFS_RADAR_DETECT_EN_DEC_WK_CID:
return "DFS_RADAR_DETECT_EN_DEC_WK_CID";
break;
case SESSION_TRACKER_WK_CID:
return "SESSION_TRACKER_WK_CID";
break;
case TEST_H2C_CID:
return "TEST_H2C_CID";
break;
case MP_CMD_WK_CID:
return "MP_CMD_WK_CID";
break;
case CUSTOMER_STR_WK_CID:
return "CUSTOMER_STR_WK_CID";
break;
case MGNT_TX_WK_CID:
return "MGNT_TX_WK_CID";
break;
case REQ_PER_CMD_WK_CID:
return "REQ_PER_CMD_WK_CID";
break;
case SSMPS_WK_CID:
return "SSMPS_WK_CID";
break;
#ifdef CONFIG_CTRL_TXSS_BY_TP
case TXSS_WK_CID:
return "TXSS_WK_CID";
break;
#endif
case AC_PARM_CMD_WK_CID:
return "AC_PARM_CMD_WK_CID";
break;
#ifdef CONFIG_AP_MODE
case STOP_AP_WK_CID:
return "STOP_AP_WK_CID";
break;
#endif
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
case TBTX_CONTROL_TX_WK_CID:
return "TBTX_CONTROL_TX_WK_CID";
break;
#endif
#ifdef ROKU_PRIVATE
case FIND_REMOTE_WK_CID:
return "FIND_REMOTE_WK_CID";
break;
#ifdef CONFIG_P2P
case HIDE_SSID_WK_CID:
return "HIDE_SSID_WK_CID";
break;
#endif
#endif
case MAX_WK_CID:
return "MAX_WK_CID";
break;
default:
return UNKNOWN_CID;
break;
}
return UNKNOWN_CID;
}
char UNKNOWN_CMD[16] = "UNKNOWN_CMD";
char *rtw_cmd_name(struct cmd_obj *pcmd)
{
struct rtw_evt_header *pev;
if (pcmd->cmdcode >= (sizeof(wlancmds) / sizeof(struct rtw_cmd)))
return UNKNOWN_CMD;
if (pcmd->cmdcode == CMD_SET_MLME_EVT)
return rtw_evt_name((struct rtw_evt_header*)pcmd->parmbuf);
if (pcmd->cmdcode == CMD_SET_DRV_EXTRA)
return rtw_extra_name((struct drvextra_cmd_parm*)pcmd->parmbuf);
return wlancmds[pcmd->cmdcode].name;
}
#ifdef ROKU_PRIVATE
u8 rtw_find_remote_wk_cmd(_adapter *adapter)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _SUCCESS;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = FIND_REMOTE_WK_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmdobj, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
exit:
return res;
}
#ifdef CONFIG_P2P
u8 rtw_hide_ssid_wk_cmd(_adapter *adapter)
{
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
u8 res = _SUCCESS;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = HIDE_SSID_WK_CID;
pdrvextra_cmd_parm->type = 0;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmdobj, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmdobj);
exit:
return res;
}
#endif
#endif
|
2301_81045437/rtl8852be
|
core/rtw_cmd.c
|
C
|
agpl-3.0
| 188,504
|
/******************************************************************************
*
* Copyright(c) 2019 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_CSA_C_
#include <drv_types.h>
#if CONFIG_DFS
void reset_csa_param(struct rf_ctl_t *rfctl)
{
rfctl->csa_mode = 0;
rfctl->csa_switch_cnt = 0;
rfctl->csa_ch_width = 0;
_rtw_memset(&(rfctl->csa_chandef), 0, sizeof(struct rtw_chan_def));
}
/* Get ch/bw/offset of CSA from rfctl, and check these parameters is valid or not */
bool rtw_get_csa_setting(struct dvobj_priv *d, s16 *req_ch, u8 *req_bw, u8 *req_offset)
{
struct rf_ctl_t *rfctl = dvobj_to_rfctl(d);
struct _ADAPTER *a = dvobj_get_primary_adapter(d);
u8 ifbmp_m = rtw_mi_get_ap_mesh_ifbmp(a);
bool valid = _TRUE;
*req_ch = REQ_CH_NONE;
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
if (rtw_chset_search_ch(rfctl->channel_set, rfctl->csa_chandef.chan) >= 0
&& !rtw_chset_is_ch_non_ocp(rfctl->channel_set, rfctl->csa_chandef.chan)
) {
/* CSA channel available and valid */
*req_ch = rfctl->csa_chandef.chan;
RTW_INFO("CSA : "FUNC_ADPT_FMT" valid CSA ch%u\n", FUNC_ADPT_ARG(a),
rfctl->csa_chandef.chan);
} else if (ifbmp_m) {
/* no available or valid CSA channel, having AP/MESH ifaces */
*req_ch = REQ_CH_NONE;
valid = _FALSE;
RTW_INFO("CSA : "FUNC_ADPT_FMT" ch sel by AP/MESH ifaces\n", FUNC_ADPT_ARG(a));
goto exit;
} else {
/* no available or valid CSA channel and no AP/MESH ifaces */
if (!is_supported_24g(dvobj_to_regsty(d)->band_type))
*req_ch = 36;
else
*req_ch = 1;
valid = _FALSE;
RTW_INFO("CSA : "FUNC_ADPT_FMT" switch to ch%d, then disconnect with AP\n",
FUNC_ADPT_ARG(a), *req_ch);
goto exit;
}
if (rfctl->csa_ch_width == 1) {
*req_bw = CHANNEL_WIDTH_80;
*req_offset = rfctl->csa_chandef.offset;
} else if (rfctl->csa_ch_width == 0 && rfctl->csa_chandef.offset != CHAN_OFFSET_NO_EXT) {
*req_bw = CHANNEL_WIDTH_40;
*req_offset = rfctl->csa_chandef.offset;
} else {
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
}
/* get correct offset and check ch/bw/offset is valid or not */
if (!rtw_get_offset_by_chbw(*req_ch, *req_bw, req_offset)) {
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
}
exit:
return valid;
}
#ifdef CONFIG_ECSA_PHL
static void reset_ecsa_param(struct _ADAPTER *a)
{
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
struct rtw_phl_ecsa_param *ecsa_param = &(ecsa_info->phl_ecsa_param);
SET_ECSA_STATE(a, ECSA_ST_NONE);
ecsa_info->ecsa_allow_case = 0;
ecsa_info->ecsa_delay_time = 0;
ecsa_info->channel_width = 0;
ecsa_info->bss_param = NULL;
_rtw_memset(ecsa_param, 0, sizeof(struct rtw_phl_ecsa_param));
}
bool rtw_mr_is_ecsa_running(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct _ADAPTER *iface;
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
u8 i;
for (i = 0; i < d->iface_nums; i++) {
iface = d->padapters[i];
if (!iface)
continue;
if (!CHK_ECSA_STATE(iface, ECSA_ST_NONE))
return _TRUE;
}
return _FALSE;
}
static void rtw_ecsa_update_sta_chan_info(struct _ADAPTER *a, struct rtw_chan_def new_chan_def)
{
struct mlme_ext_priv *pmlmeext = &a->mlmeextpriv;
struct mlme_priv *pmlmepriv = &a->mlmepriv;
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(d);
u8 new_ch = new_chan_def.chan;
u8 new_bw = (u8)new_chan_def.bw;
u8 new_offset = (u8)new_chan_def.offset;
bool is_chctx_add = _FALSE;
pmlmeext->chandef.chan= new_ch;
pmlmeext->chandef.bw = new_bw;
pmlmeext->chandef.offset = new_offset;
pmlmepriv->cur_network.network.Configuration.DSConfig = new_ch;
/* update wifi role chandef */
rtw_hw_update_chan_def(a);
/* update chanctx */
rtw_phl_chanctx_del(d->phl, a->phl_role, NULL);
is_chctx_add = rtw_phl_chanctx_add(d->phl, a->phl_role,
&new_chan_def.chan, &new_chan_def.bw, &new_chan_def.offset);
if (is_chctx_add == _FALSE)
RTW_ERR("CSA : "FUNC_ADPT_FMT" chan_ctx add fail!", FUNC_ADPT_ARG(a));
set_fwstate(pmlmepriv, WIFI_CSA_UPDATE_BEACON);
/* STA wait 70 seconds for receiving beacons in DFS channel */
if (rtw_chset_is_dfs_chbw(rfctl->channel_set, new_ch, new_bw, new_offset)) {
RTW_INFO("CSA : set csa_timer to 70 seconds\n");
_set_timer(&pmlmeext->csa_timer, CAC_TIME_MS + 10000);
}
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(a, MLME_OPCH_SWITCH, 0);
#endif
}
static void rtw_ecsa_update_ap_chan_info(struct _ADAPTER *a, struct rtw_chan_def new_chan_def)
{
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
struct createbss_parm *parm;
ecsa_info->bss_param = (struct createbss_parm *)rtw_zmalloc(sizeof(struct createbss_parm));
if (ecsa_info->bss_param) {
parm = ecsa_info->bss_param;
parm->adhoc = 0;
parm->ifbmp = BIT(a->iface_id);
parm->excl_ifbmp = 0;
parm->req_ch = new_chan_def.chan;
parm->req_bw = new_chan_def.bw;
parm->req_offset = new_chan_def.offset;
parm->ifbmp_ch_changed = 0;
parm->ch_to_set = 0;
parm->bw_to_set = 0;
parm->offset_to_set = 0;
parm->do_rfk = _FALSE;
start_bss_network(a, parm);
} else {
RTW_ERR("CSA : can't allocate memory for bss_param\n");
}
}
void rtw_ecsa_update_probe_resp(struct xmit_frame *xframe)
{
struct _ADAPTER *a = xframe->padapter;
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
struct rtw_phl_ecsa_param *ecsa_param = &(ecsa_info->phl_ecsa_param);
struct pkt_attrib *pattrib = &xframe->attrib;
u8 hdr_len = sizeof(struct rtw_ieee80211_hdr_3addr);
u8 *ies;
sint ies_len;
u8 *csa_ie;
sint csa_ie_len;
ies = xframe->buf_addr + TXDESC_OFFSET + hdr_len + _BEACON_IE_OFFSET_;
ies_len = pattrib->pktlen - hdr_len - _BEACON_IE_OFFSET_;
csa_ie = rtw_get_ie(ies, WLAN_EID_CHANNEL_SWITCH, &csa_ie_len, ies_len);
if (csa_ie == NULL)
return;
csa_ie[2 + CSA_SWITCH_COUNT] = ecsa_param->count;
#ifdef DBG_CSA
RTW_INFO("CSA : update csa count of probe response = %u\n", csa_ie[2 + CSA_SWITCH_COUNT]);
#endif
}
void rtw_ecsa_update_beacon(void *priv, struct rtw_wifi_role_t *role)
{
#ifdef CONFIG_AP_MODE
struct dvobj_priv *d = (struct dvobj_priv *)priv;
struct _ADAPTER *a = d->padapters[role->id];
_update_beacon(a, WLAN_EID_CHANNEL_SWITCH, NULL, _TRUE, 0, "update CSA count");
#endif
}
/* PHL MR module check core layer if AP mode can switch channel now */
bool rtw_ap_check_ecsa_allow(
void *priv,
struct rtw_wifi_role_t *role,
struct rtw_chan_def chan_def,
enum phl_ecsa_start_reason reason,
u32 *delay_start_ms
)
{
struct dvobj_priv *d = (struct dvobj_priv *)priv;
struct _ADAPTER *a = d->padapters[role->id];
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
bool ecsa_allow = _TRUE;
u8 i;
/* TODO : need to check MCC-ECSA case */
/* if (!(ecsa_info->ecsa_allow_case & BIT(reason))) { */
if (0) {
RTW_INFO("CSA : "FUNC_ADPT_FMT" : Case %u not support!\n", FUNC_ADPT_ARG(a), reason);
ecsa_allow = _FALSE;
goto exit;
}
/* Check DFS channel */
if (!rtw_phl_regulation_valid_channel(GET_PHL_INFO(d),
chan_def.band,
chan_def.chan,
(CH_PASSIVE | CH_DFS))) {
RTW_ERR("CSA : "FUNC_ADPT_FMT" : DFS channel (%u) not support!\n",
FUNC_ADPT_ARG(a), chan_def.chan);
ecsa_allow = _FALSE;
goto exit;
}
if (ecsa_info->ecsa_delay_time != 0)
*delay_start_ms = ecsa_info->ecsa_delay_time;
else if (reason <= ECSA_START_MCC_5G_TO_24G)
*delay_start_ms = MCC_ECSA_DELAY_START_TIME;
RTW_INFO("CSA : %s : ECSA will delay %u ms\n", __func__, *delay_start_ms);
SET_ECSA_STATE(a, ECSA_ST_SW_START);
exit:
return ecsa_allow;
}
void rtw_ecsa_mr_update_chan_info_by_role(
void *priv,
struct rtw_wifi_role_t *role,
struct rtw_chan_def new_chan_def
)
{
struct dvobj_priv *d = (struct dvobj_priv *)priv;
struct _ADAPTER *a = d->padapters[role->id];
struct mlme_ext_priv *pmlmeext = &a->mlmeextpriv;
struct mlme_priv *pmlmepriv = &a->mlmepriv;
RTW_INFO("CSA : "FUNC_ADPT_FMT", new ch/bw/offset = %u,%u,%u\n", FUNC_ADPT_ARG(a), \
new_chan_def.chan, new_chan_def.bw, new_chan_def.offset);
if (role->type == PHL_RTYPE_STATION || role->type == PHL_RTYPE_P2P_GC)
rtw_ecsa_update_sta_chan_info(a, new_chan_def);
else if (role->type == PHL_RTYPE_AP ||role->type == PHL_RTYPE_P2P_GO)
rtw_ecsa_update_ap_chan_info(a, new_chan_def);
}
bool rtw_ecsa_check_tx_resume_allow(void *priv, struct rtw_wifi_role_t *role)
{
/* TODO */
/* Is DFS slave still monitoring channel ?
If Yes, return False to PHL; If no, return True to PHL */
struct dvobj_priv *d = (struct dvobj_priv *)priv;
struct _ADAPTER *a = d->padapters[role->id];
RTW_INFO("CSA : "FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(a));
return 1;
}
void rtw_ecsa_complete(void *priv, struct rtw_wifi_role_t *role)
{
struct dvobj_priv *d = (struct dvobj_priv *)priv;
struct _ADAPTER *a = d->padapters[role->id];
struct rf_ctl_t *rfctl = dvobj_to_rfctl(d);
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
struct createbss_parm *parm = ecsa_info->bss_param;
u8 i, ht_option = 0;
RTW_INFO("CSA : "FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(a));
rtw_phl_mr_dump_cur_chandef(d->phl, role);
if (role->type == PHL_RTYPE_STATION || role->type == PHL_RTYPE_P2P_GC) {
/*
* TODO
* STA mode need to update RA if it receive CHANNEL_SWITCH_WRAPPER IE
* STA mode update its RA at rtw_check_bcn_info() now
*/
rtw_rfctl_update_op_mode(rfctl, 0, 0);
} else if (role->type == PHL_RTYPE_AP ||role->type == PHL_RTYPE_P2P_GO) {
#if defined(CONFIG_IOCTL_CFG80211) && (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
for (i = 0; i < d->iface_nums; i++) {
if (!(parm->ifbmp_ch_changed & BIT(i)) || !d->padapters[i])
continue;
#ifdef CONFIG_80211N_HT
ht_option = d->padapters[i]->mlmepriv.htpriv.ht_option;
#endif
rtw_cfg80211_ch_switch_notify(d->padapters[i]
, d->padapters[i]->mlmeextpriv.chandef.chan
, d->padapters[i]->mlmeextpriv.chandef.bw
, d->padapters[i]->mlmeextpriv.chandef.offset
, ht_option, 0);
}
#endif
rtw_rfctl_update_op_mode(adapter_to_rfctl(a), parm->ifbmp, 1);
rtw_core_ap_start(a, parm);
rtw_ap_update_clients_rainfo(a, PHL_CMD_DIRECTLY);
rtw_mfree((u8 *)parm, sizeof(struct createbss_parm));
}
rtw_mi_os_xmit_schedule(a);
reset_ecsa_param(a);
}
/* Get ch/bw/offset of CSA from adapter, and check these parameters is valid or not */
static bool rtw_sta_get_ecsa_setting(struct _ADAPTER *a, s16 *req_ch, u8 *req_bw, u8 *req_offset)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(a);
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
struct rtw_phl_ecsa_param *ecsa_param = &(ecsa_info->phl_ecsa_param);
u8 ifbmp_m = rtw_mi_get_ap_mesh_ifbmp(a);
u8 csa_chan = ecsa_param->new_chan_def.chan;
u8 csa_offset = ecsa_param->new_chan_def.offset;
bool valid = _TRUE;
*req_ch = REQ_CH_NONE;
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
if (rtw_chset_search_ch(rfctl->channel_set, csa_chan) >= 0
&& !rtw_chset_is_ch_non_ocp(rfctl->channel_set, csa_chan)
) {
/* CSA channel available and valid */
*req_ch = csa_chan;
RTW_INFO("CSA : "FUNC_ADPT_FMT" valid CSA ch%u\n", FUNC_ADPT_ARG(a), csa_chan);
} else if (ifbmp_m) {
/* no available or valid CSA channel, having AP/MESH ifaces */
*req_ch = REQ_CH_NONE;
valid = _FALSE;
RTW_INFO("CSA : "FUNC_ADPT_FMT" ch sel by AP/MESH ifaces\n", FUNC_ADPT_ARG(a));
goto exit;
} else {
/* no available or valid CSA channel and no AP/MESH ifaces */
/* TODO : DFS slave may need to switch channel as soon as possible before disconnect */
#if 0
if (!is_supported_24g(adapter_to_regsty(a)->band_type))
*req_ch = 36;
else
*req_ch = 1;
#endif
valid = _FALSE;
RTW_INFO("CSA : "FUNC_ADPT_FMT" switch to ch %d, then disconnect with AP\n",
FUNC_ADPT_ARG(a), *req_ch);
goto exit;
}
/* Transform channel_width to bandwidth 20/40/80M */
if (ecsa_info->channel_width == 1) {
*req_bw = CHANNEL_WIDTH_80;
*req_offset = csa_offset;
} else if (ecsa_info->channel_width == 0 && csa_offset != CHAN_OFFSET_NO_EXT) {
*req_bw = CHANNEL_WIDTH_40;
*req_offset = csa_offset;
} else {
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
}
/* Get correct offset and check ch/bw/offset is valid or not */
if (!rtw_get_offset_by_chbw(*req_ch, *req_bw, req_offset)) {
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
}
/* Update result to ecsa_param */
ecsa_param->new_chan_def.chan = *req_ch;
ecsa_param->new_chan_def.bw = *req_bw;
ecsa_param->new_chan_def.offset = *req_offset;
exit:
return valid;
}
static void rtw_sta_ecsa_invalid_hdl(struct _ADAPTER *a, s16 req_ch, u8 req_bw, u8 req_offset)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(d);
u8 ifbmp_s = rtw_mi_get_ld_sta_ifbmp(a);
struct rtw_chan_def mr_chdef = {0};
if (!ifbmp_s)
return;
set_fwstate(&a->mlmepriv, WIFI_OP_CH_SWITCHING);
issue_deauth(a, get_bssid(&a->mlmepriv), WLAN_REASON_DEAUTH_LEAVING);
/* Decide whether enable DFS slave radar detection or not */
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(a, MLME_OPCH_SWITCH, ifbmp_s);
#endif
/* TODO : DFS slave may need to switch channel as soon as possible before disconnect */
/* This context can't I/O, so use RTW_CMDF_DIRECTLY */
rtw_disassoc_cmd(a, 0, RTW_CMDF_DIRECTLY);
rtw_indicate_disconnect(a, 0, _FALSE);
#ifndef CONFIG_STA_CMD_DISPR
rtw_free_assoc_resources(a, _TRUE);
#endif
rtw_free_network_queue(a, _TRUE);
RTW_INFO("CSA : "FUNC_ADPT_FMT" disconnect with AP\n", FUNC_ADPT_ARG(a));
reset_ecsa_param(a);
rtw_mi_os_xmit_schedule(a);
}
void rtw_trigger_phl_ecsa_start(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
struct core_ecsa_info *ecsa_info = &(a->ecsa_info);
struct rtw_phl_ecsa_param *ecsa_param = &(ecsa_info->phl_ecsa_param);
/* STA need to check ecsa setting */
if (ecsa_param->ecsa_type == ECSA_TYPE_STA) {
s16 req_ch;
u8 req_bw, req_offset;
if (!rtw_sta_get_ecsa_setting(a, &req_ch, &req_bw, &req_offset)) {
/* we should handle error case by core layer self */
rtw_sta_ecsa_invalid_hdl(a, req_ch, req_bw, req_offset);
return;
}
}
if (rtw_phl_ecsa_start(GET_PHL_INFO(d), role, ecsa_param) != RTW_PHL_STATUS_SUCCESS)
RTW_ERR("CSA : Start PHL ECSA fail\n");
#if 0 /* TODO : ECSA */
if(0) {
if(!rtw_phl_get_chandef_from_operating_class(param.ch,
param.op_class,
&(param.new_chan_def))){
RTW_INFO("[CSA] Get chandef fail!Use 20 MHz to switch\n");
param.new_chan_def.band = rtw_phl_get_band_type(param.ch);
param.new_chan_def.chan = param.ch;
param.new_chan_def.bw = CHANNEL_WIDTH_20;
param.new_chan_def.offset = CHAN_OFFSET_NO_EXT;
}
}
#endif
}
#endif /* CONFIG_ECSA_PHL */
#endif /* CONFIG_DFS */
|
2301_81045437/rtl8852be
|
core/rtw_csa.c
|
C
|
agpl-3.0
| 15,190
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_DEBUG_C_
#include <drv_types.h>
#include "_hal_rate.h"
#ifdef CONFIG_RTW_DEBUG
const char *rtw_log_level_str[] = {
"_DRV_NONE_ = 0",
"_DRV_ALWAYS_ = 1",
"_DRV_ERR_ = 2",
"_DRV_WARNING_ = 3",
"_DRV_INFO_ = 4",
"_DRV_DEBUG_ = 5",
"_DRV_MAX_ = 6",
};
#endif
#ifdef CONFIG_DEBUG_RTL871X
u64 GlobalDebugComponents = 0;
#endif /* CONFIG_DEBUG_RTL871X */
#include <rtw_version.h>
#ifdef CONFIG_TDLS
#define TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE 41
#endif
void dump_drv_version(void *sel)
{
RTW_PRINT_SEL(sel, "%s %s\n", DRV_NAME, DRIVERVERSION);
RTW_PRINT_SEL(sel, "build time: %s %s\n", __DATE__, __TIME__);
}
void dump_drv_cfg(void *sel)
{
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
char *kernel_version = utsname()->release;
RTW_PRINT_SEL(sel, "\nKernel Version: %s\n", kernel_version);
#endif
#ifdef CONFIG_RTW_ANDROID
RTW_PRINT_SEL(sel, "Android Driver: %d\n", CONFIG_RTW_ANDROID);
#else
RTW_PRINT_SEL(sel, "Linux Driver: \n");
#endif /* CONFIG_RTW_ANDROID */
RTW_PRINT_SEL(sel, "Driver Version: %s\n", DRIVERVERSION);
RTW_PRINT_SEL(sel, "------------------------------------------------\n");
#ifdef CONFIG_IOCTL_CFG80211
RTW_PRINT_SEL(sel, "CFG80211\n");
#ifdef RTW_USE_CFG80211_STA_EVENT
RTW_PRINT_SEL(sel, "RTW_USE_CFG80211_STA_EVENT\n");
#endif
#ifdef CONFIG_RADIO_WORK
RTW_PRINT_SEL(sel, "CONFIG_RADIO_WORK\n");
#endif
#else
RTW_PRINT_SEL(sel, "WEXT\n");
#endif
RTW_PRINT_SEL(sel, "DBG:%d\n", DBG);
#ifdef CONFIG_RTW_DEBUG
RTW_PRINT_SEL(sel, "CONFIG_RTW_DEBUG\n");
#endif
#ifdef CONFIG_CONCURRENT_MODE
RTW_PRINT_SEL(sel, "CONFIG_CONCURRENT_MODE\n");
#ifdef CONFIG_RTW_STATIC_NDEV_NUM
RTW_PRINT_SEL(sel, "CONFIG_RTW_STATIC_NDEV_NUM = %d\n", CONFIG_RTW_STATIC_NDEV_NUM);
#endif
#if (RTW_P2P_GROUP_INTERFACE == 1)
RTW_PRINT_SEL(sel, "RTW_P2P_GROUP_INTERFACE\n");
#endif
#ifdef RTW_DEDICATED_P2P_DEVICE
RTW_PRINT_SEL(sel, "RTW_DEDICATED_P2P_DEVICE\n");
#endif
#if defined(CONFIG_P2P) && defined(CONFIG_SEL_P2P_IFACE)
RTW_PRINT_SEL(sel, "CONFIG_SEL_P2P_IFACE = %d\n", CONFIG_SEL_P2P_IFACE);
#endif
#endif
#ifdef CONFIG_POWER_SAVING
RTW_PRINT_SEL(sel, "CONFIG_POWER_SAVING\n");
#ifdef CONFIG_IPS
RTW_PRINT_SEL(sel, "CONFIG_IPS\n");
#endif
#ifdef CONFIG_LPS
RTW_PRINT_SEL(sel, "CONFIG_LPS\n");
#ifdef CONFIG_LPS_LCLK
RTW_PRINT_SEL(sel, "CONFIG_LPS_LCLK\n");
#ifdef CONFIG_DETECT_CPWM_BY_POLLING
RTW_PRINT_SEL(sel, "CONFIG_DETECT_CPWM_BY_POLLING\n");
#endif
#endif /*CONFIG_LPS_LCLK*/
#ifdef CONFIG_LPS_CHK_BY_TP
RTW_PRINT_SEL(sel, "CONFIG_LPS_CHK_BY_TP\n");
#endif
#ifdef CONFIG_LPS_ACK
RTW_PRINT_SEL(sel, "CONFIG_LPS_ACK\n");
#endif
#endif/*CONFIG_LPS*/
#endif
#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
RTW_PRINT_SEL(sel, "LOAD_PHY_PARA_FROM_FILE - REALTEK_CONFIG_PATH=%s\n", REALTEK_CONFIG_PATH);
#if defined(CONFIG_MULTIDRV) || defined(REALTEK_CONFIG_PATH_WITH_IC_NAME_FOLDER)
RTW_PRINT_SEL(sel, "LOAD_PHY_PARA_FROM_FILE - REALTEK_CONFIG_PATH_WITH_IC_NAME_FOLDER\n");
#endif
/* configurations about TX power */
#ifdef CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY
RTW_PRINT_SEL(sel, "CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY\n");
#endif
#ifdef CONFIG_CALIBRATE_TX_POWER_TO_MAX
RTW_PRINT_SEL(sel, "CONFIG_CALIBRATE_TX_POWER_TO_MAX\n");
#endif
#endif
RTW_PRINT_SEL(sel, "RTW_DEF_MODULE_REGULATORY_CERT=0x%02x\n", RTW_DEF_MODULE_REGULATORY_CERT);
RTW_PRINT_SEL(sel, "CONFIG_TXPWR_BY_RATE=%d\n", CONFIG_TXPWR_BY_RATE);
RTW_PRINT_SEL(sel, "CONFIG_TXPWR_BY_RATE_EN=%d\n", CONFIG_TXPWR_BY_RATE_EN);
RTW_PRINT_SEL(sel, "CONFIG_TXPWR_LIMIT=%d\n", CONFIG_TXPWR_LIMIT);
RTW_PRINT_SEL(sel, "CONFIG_TXPWR_LIMIT_EN=%d\n", CONFIG_TXPWR_LIMIT_EN);
#ifdef CONFIG_DISABLE_ODM
RTW_PRINT_SEL(sel, "CONFIG_DISABLE_ODM\n");
#endif
#ifdef CONFIG_MINIMAL_MEMORY_USAGE
RTW_PRINT_SEL(sel, "CONFIG_MINIMAL_MEMORY_USAGE\n");
#endif
RTW_PRINT_SEL(sel, "CONFIG_RTW_ADAPTIVITY_EN = %d\n", CONFIG_RTW_ADAPTIVITY_EN);
RTW_PRINT_SEL(sel, "CONFIG_RTW_ADAPTIVITY_MODE = %d\n", CONFIG_RTW_ADAPTIVITY_MODE);
#ifdef CONFIG_WOWLAN
RTW_PRINT_SEL(sel, "CONFIG_WOWLAN - ");
#ifdef CONFIG_GPIO_WAKEUP
RTW_PRINT_SEL(sel, "CONFIG_GPIO_WAKEUP - WAKEUP_GPIO_IDX:%d\n", WAKEUP_GPIO_IDX);
#endif
#endif
#ifdef CONFIG_TDLS
RTW_PRINT_SEL(sel, "CONFIG_TDLS\n");
#endif
#ifdef CONFIG_RTW_80211R
RTW_PRINT_SEL(sel, "CONFIG_RTW_80211R\n");
#endif
#ifdef CONFIG_RTW_NETIF_SG
RTW_PRINT_SEL(sel, "CONFIG_RTW_NETIF_SG\n");
#endif
#ifdef CONFIG_RTW_WIFI_HAL
RTW_PRINT_SEL(sel, "CONFIG_RTW_WIFI_HAL\n");
#endif
#ifdef RTW_BUSY_DENY_SCAN
RTW_PRINT_SEL(sel, "RTW_BUSY_DENY_SCAN\n");
RTW_PRINT_SEL(sel, "BUSY_TRAFFIC_SCAN_DENY_PERIOD = %u ms\n", \
BUSY_TRAFFIC_SCAN_DENY_PERIOD);
#endif
#ifdef CONFIG_USB_HCI
#ifdef CONFIG_SUPPORT_USB_INT
RTW_PRINT_SEL(sel, "CONFIG_SUPPORT_USB_INT\n");
#endif
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
RTW_PRINT_SEL(sel, "CONFIG_USB_INTERRUPT_IN_PIPE\n");
#endif
#ifdef CONFIG_USB_TX_AGGREGATION
RTW_PRINT_SEL(sel, "CONFIG_USB_TX_AGGREGATION\n");
#endif
#ifdef CONFIG_USB_RX_AGGREGATION
RTW_PRINT_SEL(sel, "CONFIG_USB_RX_AGGREGATION\n");
#endif
#ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX
RTW_PRINT_SEL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_TX\n");
#endif
#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
RTW_PRINT_SEL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_RX\n");
#endif
#ifdef CONFIG_FIX_NR_BULKIN_BUFFER
RTW_PRINT_SEL(sel, "CONFIG_FIX_NR_BULKIN_BUFFER\n");
#endif
#endif /*CONFIG_USB_HCI*/
#ifdef CONFIG_SDIO_HCI
#ifdef CONFIG_TX_AGGREGATION
RTW_PRINT_SEL(sel, "CONFIG_TX_AGGREGATION\n");
#endif
#ifdef CONFIG_RX_AGGREGATION
RTW_PRINT_SEL(sel, "CONFIG_RX_AGGREGATION\n");
#endif
#ifdef RTW_XMIT_THREAD_HIGH_PRIORITY
RTW_PRINT_SEL(sel, "RTW_XMIT_THREAD_HIGH_PRIORITY\n");
#endif
#ifdef RTW_XMIT_THREAD_HIGH_PRIORITY_AGG
RTW_PRINT_SEL(sel, "RTW_XMIT_THREAD_HIGH_PRIORITY_AGG\n");
#endif
#ifdef DBG_SDIO
RTW_PRINT_SEL(sel, "DBG_SDIO = %d\n", DBG_SDIO);
#endif
#endif /*CONFIG_SDIO_HCI*/
#ifdef CONFIG_PCI_HCI
#endif
RTW_PRINT_SEL(sel, "CONFIG_IFACE_NUMBER = %d\n", CONFIG_IFACE_NUMBER);
#ifdef CONFIG_PCI_TX_POLLING
RTW_PRINT_SEL(sel, "CONFIG_PCI_TX_POLLING\n");
#endif
RTW_PRINT_SEL(sel, "CONFIG_RTW_UP_MAPPING_RULE = %s\n", (CONFIG_RTW_UP_MAPPING_RULE == 1) ? "dscp" : "tos");
/*GEORGIA_TODO_TRX - need get trx buff accroding to IC spec*/
RTW_PRINT_SEL(sel, "\n=== XMIT-INFO ===\n");
RTW_PRINT_SEL(sel, "NR_XMITFRAME = %d\n", NR_XMITFRAME);
/*
RTW_PRINT_SEL(sel, "NR_XMITBUFF = %d\n", NR_XMITBUFF);
RTW_PRINT_SEL(sel, "MAX_XMITBUF_SZ = %d\n", MAX_XMITBUF_SZ);
RTW_PRINT_SEL(sel, "NR_XMIT_EXTBUFF = %d\n", NR_XMIT_EXTBUFF);
RTW_PRINT_SEL(sel, "MAX_XMIT_EXTBUF_SZ = %d\n", MAX_XMIT_EXTBUF_SZ);
RTW_PRINT_SEL(sel, "MAX_CMDBUF_SZ = %d\n", MAX_CMDBUF_SZ);
*/
RTW_PRINT_SEL(sel, "\n=== RECV-INFO ===\n");
RTW_PRINT_SEL(sel, "NR_RECVFRAME = %d\n", NR_RECVFRAME);
/*
RTW_PRINT_SEL(sel, "NR_RECVBUFF = %d\n", NR_RECVBUFF);
RTW_PRINT_SEL(sel, "MAX_RECVBUF_SZ = %d\n", MAX_RECVBUF_SZ);
*/
}
void dump_log_level(void *sel)
{
#ifdef CONFIG_RTW_DEBUG
int i;
RTW_PRINT_SEL(sel, "drv_log_level:%d\n", rtw_drv_log_level);
for (i = 0; i <= _DRV_MAX_; i++) {
if (rtw_log_level_str[i])
RTW_PRINT_SEL(sel, "%c %s = %d\n",
(rtw_drv_log_level == i) ? '+' : ' ', rtw_log_level_str[i], i);
}
#else
RTW_PRINT_SEL(sel, "CONFIG_RTW_DEBUG is disabled\n");
#endif
}
void rtw_sink_rtp_seq_dbg(_adapter *adapter, u8 *ehdr_pos)
{
struct recv_info *precvinfo = &(adapter->recvinfo);
if (precvinfo->sink_udpport > 0) {
if (*((u16 *)(ehdr_pos + 0x24)) == cpu_to_be16(precvinfo->sink_udpport)) {
precvinfo->pre_rtp_rxseq = precvinfo->cur_rtp_rxseq;
precvinfo->cur_rtp_rxseq = be16_to_cpu(*((u16 *)(ehdr_pos + 0x2C)));
if (precvinfo->pre_rtp_rxseq + 1 != precvinfo->cur_rtp_rxseq) {
if(precvinfo->pre_rtp_rxseq == 65535 ) {
if( precvinfo->cur_rtp_rxseq != 0) {
RTW_INFO("%s : RTP Seq num from %d to %d\n", __FUNCTION__, precvinfo->pre_rtp_rxseq, precvinfo->cur_rtp_rxseq);
}
} else {
RTW_INFO("%s : RTP Seq num from %d to %d\n", __FUNCTION__, precvinfo->pre_rtp_rxseq, precvinfo->cur_rtp_rxseq);
}
}
}
}
}
void sta_rx_reorder_ctl_dump(void *sel, struct sta_info *sta)
{
struct recv_reorder_ctrl *reorder_ctl;
int i;
for (i = 0; i < 16; i++) {
reorder_ctl = &sta->recvreorder_ctrl[i];
if (reorder_ctl->ampdu_size != RX_AMPDU_SIZE_INVALID || reorder_ctl->indicate_seq != 0xFFFF) {
RTW_PRINT_SEL(sel, "tid=%d, enable=%d, ampdu_size=%u, indicate_seq=%u\n"
, i, reorder_ctl->enable, reorder_ctl->ampdu_size, reorder_ctl->indicate_seq
);
}
}
}
void dump_tx_rate_bmp(void *sel, struct dvobj_priv *dvobj)
{
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
u8 bw;
RTW_PRINT_SEL(sel, "%-6s", "bw");
if (rtw_hw_chk_proto_cap(dvobj, PROTO_CAP_11AC))
_RTW_PRINT_SEL(sel, " %-15s", "vht");
_RTW_PRINT_SEL(sel, " %-11s %-4s %-3s\n", "ht", "ofdm", "cck");
for (bw = CHANNEL_WIDTH_20; bw <= CHANNEL_WIDTH_160; bw++) {
if (!rtw_hw_is_bw_support(adapter_to_dvobj(adapter), bw))
continue;
RTW_PRINT_SEL(sel, "%6s", ch_width_str(bw));
if (rtw_hw_chk_proto_cap(dvobj, PROTO_CAP_11AC)) {
_RTW_PRINT_SEL(sel, " %03x %03x %03x %03x"
, RATE_BMP_GET_VHT_4SS(rfctl->rate_bmp_vht_by_bw[bw])
, RATE_BMP_GET_VHT_3SS(rfctl->rate_bmp_vht_by_bw[bw])
, RATE_BMP_GET_VHT_2SS(rfctl->rate_bmp_vht_by_bw[bw])
, RATE_BMP_GET_VHT_1SS(rfctl->rate_bmp_vht_by_bw[bw])
);
}
_RTW_PRINT_SEL(sel, " %02x %02x %02x %02x"
, bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_4SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
, bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_3SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
, bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_2SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
, bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_1SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
);
_RTW_PRINT_SEL(sel, " %03x %01x\n"
, bw <= CHANNEL_WIDTH_20 ? RATE_BMP_GET_OFDM(rfctl->rate_bmp_cck_ofdm) : 0
, bw <= CHANNEL_WIDTH_20 ? RATE_BMP_GET_CCK(rfctl->rate_bmp_cck_ofdm) : 0
);
}
}
void dump_adapters_status(void *sel, struct dvobj_priv *dvobj)
{
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
int i;
_adapter *iface;
u8 u_ch, u_bw, u_offset;
dump_mi_status(sel, dvobj);
RTW_PRINT_SEL(sel, "dev status:%s%s\n\n"
, dev_is_surprise_removed(dvobj) ? " SR" : ""
, dev_is_drv_stopped(dvobj) ? " DS" : ""
);
#ifdef CONFIG_P2P
#define P2P_INFO_TITLE_FMT " %-3s %-4s"
#define P2P_INFO_TITLE_ARG , "lch", "p2ps"
#ifdef CONFIG_IOCTL_CFG80211
#define P2P_INFO_VALUE_FMT " %3u %c"
#define P2P_INFO_VALUE_ARG , iface->wdinfo.listen_channel, iface->wdev_data.p2p_enabled ? 'e' : ' '
#else
#define P2P_INFO_VALUE_FMT " %3u"
#define P2P_INFO_VALUE_ARG , iface->wdinfo.listen_channel
#endif
#define P2P_INFO_DASH "---------"
#else
#define P2P_INFO_TITLE_FMT ""
#define P2P_INFO_TITLE_ARG
#define P2P_INFO_VALUE_FMT ""
#define P2P_INFO_VALUE_ARG
#define P2P_INFO_DASH
#endif
#define INFO_FMT ""
#define INFO_ARG
#define INFO_CNT_FMT ""
#define INFO_CNT_ARG
RTW_PRINT_SEL(sel, "%-2s %-15s %c %-3s %-17s %-4s %-7s %-5s"
P2P_INFO_TITLE_FMT
" %s"INFO_FMT"\n"
, "id", "ifname", ' ', "netif_up", "macaddr", "port", "ch", "class"
P2P_INFO_TITLE_ARG
, "status"INFO_ARG);
RTW_PRINT_SEL(sel, "---------------------------------------------------------------"
P2P_INFO_DASH
"-------\n");
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (iface) {
RTW_PRINT_SEL(sel, "%2d %-15s %c %3u "MAC_FMT" %4hhu %3u,%u,%u %5u"
P2P_INFO_VALUE_FMT
" "MLME_STATE_FMT" " INFO_CNT_FMT"\n"
, i, iface->registered ? ADPT_ARG(iface) : NULL
, iface->registered ? 'R' : ' '
, iface->netif_up
, MAC_ARG(adapter_mac_addr(iface))
, rtw_hal_get_port(iface)
, iface->mlmeextpriv.chandef.chan
, iface->mlmeextpriv.chandef.bw
, iface->mlmeextpriv.chandef.offset
, rtw_get_op_class_by_chbw(iface->mlmeextpriv.chandef.chan
, iface->mlmeextpriv.chandef.bw
, iface->mlmeextpriv.chandef.offset)
P2P_INFO_VALUE_ARG
, MLME_STATE_ARG(iface)
INFO_CNT_ARG
);
}
}
RTW_PRINT_SEL(sel, "---------------------------------------------------------------"
P2P_INFO_DASH
"-------\n");
if (rtw_mi_get_ch_setting_union(dvobj_get_primary_adapter(dvobj), &u_ch, &u_bw, &u_offset))
RTW_PRINT_SEL(sel, "%55s %3u,%u,%u %5u\n"
, "union:"
, u_ch, u_bw, u_offset, rtw_get_op_class_by_chbw(u_ch, u_bw, u_offset));
#if 0
RTW_PRINT_SEL(sel, "%55s %3u,%u,%u offch_state:%d\n"
, "oper:"
, dvobj->chandef.chan
, dvobj->chandef.bw
, dvobj->chandef.offset
, rfctl->offch_state
);
#endif
#ifdef CONFIG_DFS_MASTER
if (rfctl->radar_detect_ch != 0) {
RTW_PRINT_SEL(sel, "%55s %3u,%u,%u"
, "radar_detect:"
, rfctl->radar_detect_ch
, rfctl->radar_detect_bw
, rfctl->radar_detect_offset
);
if (rfctl->radar_detect_by_others)
_RTW_PRINT_SEL(sel, ", by AP of STA link");
else {
u32 non_ocp_ms;
u32 cac_ms;
u8 dfs_domain = rtw_rfctl_get_dfs_domain(rfctl);
_RTW_PRINT_SEL(sel, ", domain:%s(%u)", rtw_dfs_regd_str(dfs_domain), dfs_domain);
rtw_get_ch_waiting_ms(rfctl
, rfctl->radar_detect_ch
, rfctl->radar_detect_bw
, rfctl->radar_detect_offset
, &non_ocp_ms
, &cac_ms
);
if (non_ocp_ms)
_RTW_PRINT_SEL(sel, ", non_ocp:%d", non_ocp_ms);
if (cac_ms)
_RTW_PRINT_SEL(sel, ", cac:%d", cac_ms);
}
_RTW_PRINT_SEL(sel, "\n");
}
#endif /* CONFIG_DFS_MASTER */
}
#define SEC_CAM_ENT_ID_TITLE_FMT "%-2s"
#define SEC_CAM_ENT_ID_TITLE_ARG "id"
#define SEC_CAM_ENT_ID_VALUE_FMT "%2u"
#define SEC_CAM_ENT_ID_VALUE_ARG(id) (id)
#define SEC_CAM_ENT_TITLE_FMT "%-6s %-17s %-32s %-3s %-8s %-2s %-2s %-5s"
#define SEC_CAM_ENT_TITLE_ARG "ctrl", "addr", "key", "kid", "type", "MK", "GK", "valid"
#define SEC_CAM_ENT_VALUE_FMT "0x%04x "MAC_FMT" "KEY_FMT" %3u %-8s %2u %2u %5u"
#define SEC_CAM_ENT_VALUE_ARG(ent) \
(ent)->ctrl \
, MAC_ARG((ent)->mac) \
, KEY_ARG((ent)->key) \
, ((ent)->ctrl) & 0x03 \
, (((ent)->ctrl) & 0x200) ? \
security_type_str((((ent)->ctrl) >> 2 & 0x7) | _SEC_TYPE_256_) : \
security_type_str(((ent)->ctrl) >> 2 & 0x7) \
, (((ent)->ctrl) >> 5) & 0x01 \
, (((ent)->ctrl) >> 6) & 0x01 \
, (((ent)->ctrl) >> 15) & 0x01
void dump_sec_cam_ent(void *sel, struct sec_cam_ent *ent, int id)
{
if (id >= 0) {
RTW_PRINT_SEL(sel, SEC_CAM_ENT_ID_VALUE_FMT " " SEC_CAM_ENT_VALUE_FMT"\n"
, SEC_CAM_ENT_ID_VALUE_ARG(id), SEC_CAM_ENT_VALUE_ARG(ent));
} else
RTW_PRINT_SEL(sel, SEC_CAM_ENT_VALUE_FMT"\n", SEC_CAM_ENT_VALUE_ARG(ent));
}
void dump_sec_cam_ent_title(void *sel, u8 has_id)
{
if (has_id) {
RTW_PRINT_SEL(sel, SEC_CAM_ENT_ID_TITLE_FMT " " SEC_CAM_ENT_TITLE_FMT"\n"
, SEC_CAM_ENT_ID_TITLE_ARG, SEC_CAM_ENT_TITLE_ARG);
} else
RTW_PRINT_SEL(sel, SEC_CAM_ENT_TITLE_FMT"\n", SEC_CAM_ENT_TITLE_ARG);
}
void dump_sec_cam(void *sel, _adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
struct sec_cam_ent ent;
int i;
RTW_PRINT_SEL(sel, "HW sec cam:\n");
dump_sec_cam_ent_title(sel, 1);
for (i = 0; i < cam_ctl->num; i++) {
rtw_hal_sec_read_cam_ent(adapter, i, (u8 *)(&ent.ctrl), ent.mac, ent.key);
dump_sec_cam_ent(sel , &ent, i);
}
}
void dump_sec_cam_cache(void *sel, _adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
int i;
RTW_PRINT_SEL(sel, "SW sec cam cache:\n");
dump_sec_cam_ent_title(sel, 1);
for (i = 0; i < cam_ctl->num; i++) {
if (dvobj->cam_cache[i].ctrl != 0)
dump_sec_cam_ent(sel, &dvobj->cam_cache[i], i);
}
}
static u8 del_rx_ampdu_test_no_tx_fail = 0;
bool rtw_del_rx_ampdu_test_trigger_no_tx_fail(void)
{
if (del_rx_ampdu_test_no_tx_fail) {
RTW_PRINT("del_rx_ampdu test case: trigger no_tx_fail\n");
del_rx_ampdu_test_no_tx_fail--;
return _TRUE;
}
return _FALSE;
}
static u32 g_wait_hiq_empty_ms = 0;
u32 rtw_get_wait_hiq_empty_ms(void)
{
return g_wait_hiq_empty_ms;
}
static systime sta_linking_test_start_time = 0;
static u32 sta_linking_test_wait_ms = 0;
static u8 sta_linking_test_force_fail = 0;
void rtw_sta_linking_test_set_start(void)
{
sta_linking_test_start_time = rtw_get_current_time();
}
bool rtw_sta_linking_test_wait_done(void)
{
return rtw_get_passing_time_ms(sta_linking_test_start_time) >= sta_linking_test_wait_ms;
}
bool rtw_sta_linking_test_force_fail(void)
{
return sta_linking_test_force_fail;
}
#ifdef CONFIG_AP_MODE
static u16 ap_linking_test_force_auth_fail = 0;
static u16 ap_linking_test_force_asoc_fail = 0;
u16 rtw_ap_linking_test_force_auth_fail(void)
{
return ap_linking_test_force_auth_fail;
}
u16 rtw_ap_linking_test_force_asoc_fail(void)
{
return ap_linking_test_force_asoc_fail;
}
#endif
int proc_get_defs_param(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *mlme = &adapter->mlmepriv;
RTW_PRINT_SEL(m, "%s %15s\n", "lmt_sta", "lmt_time");
RTW_PRINT_SEL(m, "%-15u %-15u\n"
, mlme->defs_lmt_sta
, mlme->defs_lmt_time
);
return 0;
}
ssize_t proc_set_defs_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *mlme = &adapter->mlmepriv;
char tmp[32];
u32 defs_lmt_sta;
u32 defs_lmt_time;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u %u", &defs_lmt_sta, &defs_lmt_time);
if (num >= 1)
mlme->defs_lmt_sta = defs_lmt_sta;
if (num >= 2)
mlme->defs_lmt_time = defs_lmt_time;
}
return count;
}
ssize_t proc_set_write_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
char tmp[32];
u32 addr, val, len;
if (count < 3) {
RTW_INFO("argument size is less than 3\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
if (num != 3) {
RTW_INFO("invalid write_reg parameter!\n");
return count;
}
switch (len) {
case 1:
rtw_phl_write8(dvobj->phl, addr, (u8)val);
break;
case 2:
rtw_phl_write16(dvobj->phl, addr, (u16)val);
break;
case 4:
rtw_phl_write32(dvobj->phl, addr, val);
break;
default:
RTW_INFO("error write length=%d", len);
break;
}
}
return count;
}
static u32 proc_get_read_addr = 0xeeeeeeee;
static u32 proc_get_read_len = 0x4;
int proc_get_read_reg(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
if (proc_get_read_addr == 0xeeeeeeee) {
RTW_PRINT_SEL(m, "address not initialized\n");
return 0;
}
switch (proc_get_read_len) {
case 1:
RTW_PRINT_SEL(m, "reg_read8(0x%x)=0x%x\n", proc_get_read_addr,
rtw_phl_read8(dvobj->phl, proc_get_read_addr));
break;
case 2:
RTW_PRINT_SEL(m, "reg_read16(0x%x)=0x%x\n", proc_get_read_addr,
rtw_phl_read16(dvobj->phl, proc_get_read_addr));
break;
case 4:
RTW_PRINT_SEL(m, "reg_read32(0x%x)=0x%x\n", proc_get_read_addr,
rtw_phl_read32(dvobj->phl, proc_get_read_addr));
break;
default:
RTW_PRINT_SEL(m, "error read length=%d\n", proc_get_read_len);
break;
}
return 0;
}
ssize_t proc_set_read_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[16];
u32 addr, len;
if (count < 2) {
RTW_INFO("argument size is less than 2\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%x %x", &addr, &len);
if (num != 2) {
RTW_INFO("invalid read_reg parameter!\n");
return count;
}
proc_get_read_addr = addr;
proc_get_read_len = len;
}
return count;
}
ssize_t proc_set_mac_dbg_status_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
char tmp[32] = {0};
u32 val[2] = {0};
u32 en;
u8 en_u8;
if (count < 1) {
RTW_INFO("argument size is less than 1\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%x", &en);
if (num != 1) {
RTW_INFO("invalid mac_dbg_status_dump parameter!\n");
return count;
}
en_u8 = (u8)en;
rtw_phl_mac_dbg_status_dump(dvobj->phl, val, &en_u8);
if (en & BIT0)
RTW_INFO_DUMP("ss_dbgpkg: ", (const u8 *)val, 8);
}
return count;
}
#ifdef CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST
int proc_get_ignore_go_and_low_rssi_in_scan(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
RTW_PRINT_SEL(m, "ignore_go_in_scan=%d, ignore_low_rssi_in_scan=%d\n",
pregpriv->ignore_go_in_scan, pregpriv->ignore_low_rssi_in_scan);
return 0;
}
ssize_t proc_set_ignore_go_and_low_rssi_in_scan(struct file *file,
const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32] = {0};
int enable = 0;
int num = 0, low_rssi=0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
num = sscanf(tmp, "%d %d", &enable, &low_rssi);
RTW_INFO("num=%d enable=%d low_rssi=%d\n", num, enable, low_rssi);
if (num != 2) {
RTW_INFO("argument number is wrong\n");
return -EFAULT;
}
pregpriv->ignore_go_in_scan = enable;
pregpriv->ignore_low_rssi_in_scan = low_rssi;
}
return count;
}
#endif /*CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST*/
#ifdef CONFIG_PROC_DEBUG
int proc_get_rx_stat(struct seq_file *m, void *v)
{
_list *plist, *phead;
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct sta_info *psta = NULL;
struct stainfo_stats *pstats = NULL;
struct sta_priv *pstapriv = &(adapter->stapriv);
u32 i, j;
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
pstats = &psta->sta_stats;
if (pstats == NULL)
continue;
if ((_rtw_memcmp(psta->phl_sta->mac_addr, bc_addr, ETH_ALEN) != _TRUE)
&& (_rtw_memcmp(psta->phl_sta->mac_addr, null_addr, ETH_ALEN) != _TRUE)
&& (_rtw_memcmp(psta->phl_sta->mac_addr, adapter_mac_addr(adapter), ETH_ALEN) != _TRUE)) {
RTW_PRINT_SEL(m, "MAC :\t\t"MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
RTW_PRINT_SEL(m, "data_rx_cnt :\t%llu\n", sta_rx_data_uc_pkts(psta) - pstats->last_rx_data_uc_pkts);
pstats->last_rx_data_uc_pkts = sta_rx_data_uc_pkts(psta);
RTW_PRINT_SEL(m, "duplicate_cnt :\t%u\n", pstats->duplicate_cnt);
pstats->duplicate_cnt = 0;
RTW_PRINT_SEL(m, "rx_per_rate_cnt :\n");
for (j = 0; j < 0x60; j++) {
RTW_PRINT_SEL(m, "%08u ", pstats->rxratecnt[j]);
pstats->rxratecnt[j] = 0;
if ((j%8) == 7)
RTW_PRINT_SEL(m, "\n");
}
RTW_PRINT_SEL(m, "\n");
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
return 0;
}
int proc_get_tx_stat(struct seq_file *m, void *v)
{
_list *plist, *phead;
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct sta_info *psta = NULL;
u8 sta_mac[NUM_STA][ETH_ALEN] = {{0}};
uint mac_id[NUM_STA];
struct stainfo_stats *pstats = NULL;
struct sta_priv *pstapriv = &(adapter->stapriv);
struct sta_priv *pstapriv_primary = &(GET_PRIMARY_ADAPTER(adapter))->stapriv;
u32 i, macid_rec_idx = 0;
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
struct submit_ctx gotc2h;
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
if ((_rtw_memcmp(psta->phl_sta->mac_addr, bc_addr, ETH_ALEN) != _TRUE)
&& (_rtw_memcmp(psta->phl_sta->mac_addr, null_addr, ETH_ALEN) != _TRUE)
&& (_rtw_memcmp(psta->phl_sta->mac_addr, adapter_mac_addr(adapter), ETH_ALEN) != _TRUE)) {
_rtw_memcpy(&sta_mac[macid_rec_idx][0], psta->phl_sta->mac_addr, ETH_ALEN);
mac_id[macid_rec_idx] = psta->phl_sta->macid;
macid_rec_idx++;
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < macid_rec_idx; i++) {
_rtw_memcpy(pstapriv_primary->c2h_sta_mac, &sta_mac[i][0], ETH_ALEN);
pstapriv_primary->c2h_adapter_id = adapter->iface_id;
rtw_sctx_init(&gotc2h, 60);
pstapriv_primary->gotc2h = &gotc2h;
rtw_hal_reqtxrpt(adapter, mac_id[i]);
if (rtw_sctx_wait(&gotc2h, __func__)) {
psta = rtw_get_stainfo(pstapriv, &sta_mac[i][0]);
if(psta) {
pstats = &psta->sta_stats;
#ifndef ROKU_PRIVATE
RTW_PRINT_SEL(m, "data_sent_cnt :\t%u\n", pstats->tx_ok_cnt + pstats->tx_fail_cnt);
RTW_PRINT_SEL(m, "success_cnt :\t%u\n", pstats->tx_ok_cnt);
RTW_PRINT_SEL(m, "failure_cnt :\t%u\n", pstats->tx_fail_cnt);
RTW_PRINT_SEL(m, "retry_cnt :\t%u\n\n", pstats->tx_retry_cnt);
#else
RTW_PRINT_SEL(m, "MAC: " MAC_FMT " sent: %u fail: %u retry: %u\n",
MAC_ARG(&sta_mac[i][0]), pstats->tx_ok_cnt, pstats->tx_fail_cnt, pstats->tx_retry_cnt);
#endif /* ROKU_PRIVATE */
} else
RTW_PRINT_SEL(m, "STA is gone\n");
} else {
//to avoid c2h modify counters
pstapriv_primary->gotc2h = NULL;
_rtw_memset(pstapriv_primary->c2h_sta_mac, 0, ETH_ALEN);
pstapriv_primary->c2h_adapter_id = CONFIG_IFACE_NUMBER;
RTW_PRINT_SEL(m, "Warming : Query timeout, operation abort!!\n");
break;
}
pstapriv_primary->gotc2h = NULL;
_rtw_memset(pstapriv_primary->c2h_sta_mac, 0, ETH_ALEN);
pstapriv_primary->c2h_adapter_id = CONFIG_IFACE_NUMBER;
}
return 0;
}
int proc_get_fwstate(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
RTW_PRINT_SEL(m, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
return 0;
}
int proc_get_sec_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct security_priv *sec = &padapter->securitypriv;
RTW_PRINT_SEL(m, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
sec->dot11AuthAlgrthm, sec->dot11PrivacyAlgrthm,
sec->ndisauthtype, sec->ndisencryptstatus);
RTW_PRINT_SEL(m, "hw_decrypted=%d\n", sec->hw_decrypted);
RTW_PRINT_SEL(m, "wpa_psk=");
if(sec->wpa_psk & BIT(0))
RTW_PRINT_SEL(m, "WPA ");
if(sec->wpa_psk & BIT(1))
RTW_PRINT_SEL(m, "WPA2 ");
RTW_PRINT_SEL(m, "\n");
RTW_PRINT_SEL(m, "wpa2_group_cipher=%d\n", sec->wpa2_group_cipher);
RTW_PRINT_SEL(m, "wpa2_pairwise_cipher=%d\n", sec->wpa2_pairwise_cipher);
RTW_PRINT_SEL(m, "wpa_group_cipher=%d\n", sec->wpa_group_cipher);
RTW_PRINT_SEL(m, "wpa_pairwise_cipher=%d\n", sec->wpa_pairwise_cipher);
RTW_PRINT_SEL(m, "80211W_enable=%d\n", sec->mfp_opt);
RTW_PRINT_SEL(m, "akm_suite_bitmap=0x%x\n", sec->akmp);
#ifdef DBG_SW_SEC_CNT
RTW_PRINT_SEL(m, "==sw counters(bc, mc, uc)==\n");
RTW_PRINT_SEL(m, "wep_sw_enc_cnt=%llu, %llu, %llu\n"
, sec->wep_sw_enc_cnt_bc , sec->wep_sw_enc_cnt_mc, sec->wep_sw_enc_cnt_uc);
RTW_PRINT_SEL(m, "wep_sw_dec_cnt=%llu, %llu, %llu\n"
, sec->wep_sw_dec_cnt_bc , sec->wep_sw_dec_cnt_mc, sec->wep_sw_dec_cnt_uc);
RTW_PRINT_SEL(m, "tkip_sw_enc_cnt=%llu, %llu, %llu\n"
, sec->tkip_sw_enc_cnt_bc , sec->tkip_sw_enc_cnt_mc, sec->tkip_sw_enc_cnt_uc);
RTW_PRINT_SEL(m, "tkip_sw_dec_cnt=%llu, %llu, %llu\n"
, sec->tkip_sw_dec_cnt_bc , sec->tkip_sw_dec_cnt_mc, sec->tkip_sw_dec_cnt_uc);
RTW_PRINT_SEL(m, "aes_sw_enc_cnt=%llu, %llu, %llu\n"
, sec->aes_sw_enc_cnt_bc , sec->aes_sw_enc_cnt_mc, sec->aes_sw_enc_cnt_uc);
RTW_PRINT_SEL(m, "aes_sw_dec_cnt=%llu, %llu, %llu\n"
, sec->aes_sw_dec_cnt_bc , sec->aes_sw_dec_cnt_mc, sec->aes_sw_dec_cnt_uc);
RTW_PRINT_SEL(m, "gcmp_sw_enc_cnt=%llu, %llu, %llu\n"
, sec->gcmp_sw_enc_cnt_bc , sec->gcmp_sw_enc_cnt_mc, sec->gcmp_sw_enc_cnt_uc);
RTW_PRINT_SEL(m, "gcmp_sw_dec_cnt=%llu, %llu, %llu\n"
, sec->gcmp_sw_dec_cnt_bc , sec->gcmp_sw_dec_cnt_mc, sec->gcmp_sw_dec_cnt_uc);
#endif /* DBG_SW_SEC_CNT */
return 0;
}
int proc_get_mlmext_state(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
RTW_PRINT_SEL(m, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
return 0;
}
#ifdef CONFIG_LAYER2_ROAMING
int proc_get_roam_flags(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "0x%02x\n", rtw_roam_flags(adapter));
return 0;
}
ssize_t proc_set_roam_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 flags;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx", &flags);
if (num == 1)
rtw_assign_roam_flags(adapter, flags);
}
return count;
}
int proc_get_roam_param(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *mlme = &adapter->mlmepriv;
RTW_PRINT_SEL(m, "%12s %15s %26s %16s\n", "rssi_diff_th", "scanr_exp_ms", "scan_interval(unit:2 sec)", "rssi_threshold");
RTW_PRINT_SEL(m, "%-15u %-13u %-27u %-11u\n"
, mlme->roam_rssi_diff_th
, mlme->roam_scanr_exp_ms
, mlme->roam_scan_int
, mlme->roam_rssi_threshold
);
return 0;
}
ssize_t proc_set_roam_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *mlme = &adapter->mlmepriv;
char tmp[32];
u8 rssi_diff_th;
u32 scanr_exp_ms;
u32 scan_int;
u8 rssi_threshold;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhu %u %u %hhu", &rssi_diff_th, &scanr_exp_ms, &scan_int, &rssi_threshold);
if (num >= 1)
mlme->roam_rssi_diff_th = rssi_diff_th;
if (num >= 2)
mlme->roam_scanr_exp_ms = scanr_exp_ms;
if (num >= 3)
mlme->roam_scan_int = scan_int;
if (num >= 4)
mlme->roam_rssi_threshold = rssi_threshold;
}
return count;
}
ssize_t proc_set_roam_tgt_addr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 addr[ETH_ALEN];
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", addr, addr + 1, addr + 2, addr + 3, addr + 4, addr + 5);
if (num == 6)
_rtw_memcpy(adapter->mlmepriv.roam_tgt_addr, addr, ETH_ALEN);
RTW_INFO("set roam_tgt_addr to "MAC_FMT"\n", MAC_ARG(adapter->mlmepriv.roam_tgt_addr));
}
return count;
}
#endif /* CONFIG_LAYER2_ROAMING */
int proc_get_qos_option(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
RTW_PRINT_SEL(m, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
return 0;
}
int proc_get_ht_option(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#ifdef CONFIG_80211N_HT
RTW_PRINT_SEL(m, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
#endif /* CONFIG_80211N_HT */
return 0;
}
int proc_get_rf_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
RTW_PRINT_SEL(m, "cur_ch=%d, cur_bw=%d, cur_ch_offet=%d\n",
pmlmeext->chandef.chan, pmlmeext->chandef.bw, pmlmeext->chandef.offset);
RTW_PRINT_SEL(m, "oper_ch=%d, oper_bw=%d, oper_ch_offet=%d\n",
rtw_get_oper_ch(padapter), rtw_get_oper_bw(padapter), rtw_get_oper_choffset(padapter));
return 0;
}
int proc_get_scan_param(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct ss_res *ss = &mlmeext->sitesurvey_res;
#define SCAN_PARAM_TITLE_FMT "%10s"
#define SCAN_PARAM_VALUE_FMT "%-10u"
#define SCAN_PARAM_TITLE_ARG , "scan_ch_ms"
#define SCAN_PARAM_VALUE_ARG , ss->scan_ch_ms
#ifdef CONFIG_80211N_HT
#define SCAN_PARAM_TITLE_FMT_HT " %15s %13s"
#define SCAN_PARAM_VALUE_FMT_HT " %-15u %-13u"
#define SCAN_PARAM_TITLE_ARG_HT , "rx_ampdu_accept", "rx_ampdu_size"
#define SCAN_PARAM_VALUE_ARG_HT , ss->rx_ampdu_accept, ss->rx_ampdu_size
#else
#define SCAN_PARAM_TITLE_FMT_HT ""
#define SCAN_PARAM_VALUE_FMT_HT ""
#define SCAN_PARAM_TITLE_ARG_HT
#define SCAN_PARAM_VALUE_ARG_HT
#endif
#ifdef CONFIG_SCAN_BACKOP
#define SCAN_PARAM_TITLE_FMT_BACKOP " %9s %12s"
#define SCAN_PARAM_VALUE_FMT_BACKOP " %-9u %-12u"
#define SCAN_PARAM_TITLE_ARG_BACKOP , "backop_ms", "scan_cnt_max"
#define SCAN_PARAM_VALUE_ARG_BACKOP , ss->backop_ms, ss->scan_cnt_max
#else
#define SCAN_PARAM_TITLE_FMT_BACKOP ""
#define SCAN_PARAM_VALUE_FMT_BACKOP ""
#define SCAN_PARAM_TITLE_ARG_BACKOP
#define SCAN_PARAM_VALUE_ARG_BACKOP
#endif
RTW_PRINT_SEL(m,
SCAN_PARAM_TITLE_FMT
SCAN_PARAM_TITLE_FMT_HT
SCAN_PARAM_TITLE_FMT_BACKOP
"\n"
SCAN_PARAM_TITLE_ARG
SCAN_PARAM_TITLE_ARG_HT
SCAN_PARAM_TITLE_ARG_BACKOP
);
RTW_PRINT_SEL(m,
SCAN_PARAM_VALUE_FMT
SCAN_PARAM_VALUE_FMT_HT
SCAN_PARAM_VALUE_FMT_BACKOP
"\n"
SCAN_PARAM_VALUE_ARG
SCAN_PARAM_VALUE_ARG_HT
SCAN_PARAM_VALUE_ARG_BACKOP
);
return 0;
}
ssize_t proc_set_scan_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct ss_res *ss = &mlmeext->sitesurvey_res;
char tmp[32] = {0};
u16 scan_ch_ms;
#define SCAN_PARAM_INPUT_FMT "%hu"
#define SCAN_PARAM_INPUT_ARG , &scan_ch_ms
#ifdef CONFIG_80211N_HT
u8 rx_ampdu_accept;
u8 rx_ampdu_size;
#define SCAN_PARAM_INPUT_FMT_HT " %hhu %hhu"
#define SCAN_PARAM_INPUT_ARG_HT , &rx_ampdu_accept, &rx_ampdu_size
#else
#define SCAN_PARAM_INPUT_FMT_HT ""
#define SCAN_PARAM_INPUT_ARG_HT
#endif
#ifdef CONFIG_SCAN_BACKOP
u16 backop_ms;
u8 scan_cnt_max;
#define SCAN_PARAM_INPUT_FMT_BACKOP " %hu %hhu"
#define SCAN_PARAM_INPUT_ARG_BACKOP , &backop_ms, &scan_cnt_max
#else
#define SCAN_PARAM_INPUT_FMT_BACKOP ""
#define SCAN_PARAM_INPUT_ARG_BACKOP
#endif
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp,
SCAN_PARAM_INPUT_FMT
SCAN_PARAM_INPUT_FMT_HT
SCAN_PARAM_INPUT_FMT_BACKOP
SCAN_PARAM_INPUT_ARG
SCAN_PARAM_INPUT_ARG_HT
SCAN_PARAM_INPUT_ARG_BACKOP
);
if (num-- > 0)
ss->scan_ch_ms = scan_ch_ms;
#ifdef CONFIG_80211N_HT
if (num-- > 0)
ss->rx_ampdu_accept = rx_ampdu_accept;
if (num-- > 0)
ss->rx_ampdu_size = rx_ampdu_size;
#endif
#ifdef CONFIG_SCAN_BACKOP
if (num-- > 0)
ss->backop_ms = backop_ms;
if (num-- > 0)
ss->scan_cnt_max = scan_cnt_max;
#endif
}
return count;
}
ssize_t proc_set_scan_abort(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
u32 timeout = 0;
if (count < 1) {
RTW_INFO("argument size is less than 1\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = 0;
num = sscanf(tmp, "%d", &timeout);
if (num != 1) {
RTW_INFO("invalid parameter!\n");
return count;
}
rtw_scan_abort(padapter, timeout);
}
return count;
}
int proc_get_scan_abort(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
return 0;
}
int proc_get_survey_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
_queue *queue = &(pmlmepriv->scanned_queue);
struct wlan_network *pnetwork = NULL;
_list *plist, *phead;
s32 notify_signal;
s16 notify_noise = 0;
u16 index = 0, ie_cap = 0;
unsigned char *ie_wpa = NULL, *ie_wpa2 = NULL, *ie_wps = NULL;
unsigned char *ie_p2p = NULL, *ssid = NULL;
char flag_str[64];
int ielen = 0;
u32 wpsielen = 0;
#ifdef CONFIG_RTW_MESH
const char *ssid_title_str = "ssid/mesh_id";
#else
const char *ssid_title_str = "ssid";
#endif
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
if (!phead)
goto _exit;
plist = get_next(phead);
if (!plist)
goto _exit;
RTW_PRINT_SEL(m, "%5s %-17s %3s %-3s %-4s %-4s %5s %32s %32s\n", "index", "bssid", "ch", "RSSI", "SdBm", "Noise", "age", "flag", ssid_title_str);
while (1) {
if (rtw_end_of_queue_search(phead, plist) == _TRUE)
break;
pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
if (!pnetwork)
break;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE &&
is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network)) {
notify_signal = rtw_phl_rssi_to_dbm(padapter->recvinfo.signal_strength);/* dbm */
} else {
notify_signal = rtw_phl_rssi_to_dbm(pnetwork->network.PhyInfo.SignalStrength);/* dbm */
}
#if 0 /*def CONFIG_BACKGROUND_NOISE_MONITOR*/
if (IS_NM_ENABLE(padapter))
notify_noise = rtw_noise_query_by_chan_num(padapter, pnetwork->network.Configuration.DSConfig);
#endif
ie_wpa = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength - 12);
ie_wpa2 = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength - 12);
ie_cap = rtw_get_capability(&pnetwork->network);
ie_wps = rtw_get_wps_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &wpsielen);
ie_p2p = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &ielen);
ssid = pnetwork->network.Ssid.Ssid;
sprintf(flag_str, "%s%s%s%s%s%s%s%s",
(ie_wpa) ? "[WPA]" : "",
(ie_wpa2) ? "[WPA2]" : "",
(!ie_wpa && !ie_wpa && ie_cap & BIT(4)) ? "[WEP]" : "",
(ie_wps) ? "[WPS]" : "",
(pnetwork->network.InfrastructureMode == Ndis802_11IBSS) ? "[IBSS]" :
(pnetwork->network.InfrastructureMode == Ndis802_11_mesh) ? "[MESH]" : "",
(ie_cap & BIT(0)) ? "[ESS]" : "",
(pnetwork->network.Reserved[0] == BSS_TYPE_BCN) ? "[B]" : \
(pnetwork->network.Reserved[0] == BSS_TYPE_PROB_RSP) ? "[P]" : "[U]",
(ie_p2p) ? "[P2P]" : "");
RTW_PRINT_SEL(m, "%5d "MAC_FMT" %3d %3d %4d %4d %5d %32s %32s\n",
++index,
MAC_ARG(pnetwork->network.MacAddress),
pnetwork->network.Configuration.DSConfig,
pnetwork->network.PhyInfo.rssi,
notify_signal,
notify_noise,
rtw_get_passing_time_ms(pnetwork->last_scanned),
flag_str,
pnetwork->network.InfrastructureMode == Ndis802_11_mesh ? pnetwork->network.mesh_id.Ssid : pnetwork->network.Ssid.Ssid
);
plist = get_next(plist);
}
_exit:
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
return 0;
}
ssize_t proc_set_survey_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
u8 _status = _FALSE;
u8 ssc_chk;
char tmp[32] = {0};
char cmd[8] = {0};
bool acs = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%s", cmd);
if (num < 1)
return count;
if (strcmp("acs", cmd) == 0)
acs = 1;
}
#if 1
ssc_chk = rtw_sitesurvey_condition_check(padapter, _FALSE);
if (ssc_chk != SS_ALLOW)
goto exit;
rtw_ps_deny(padapter, PS_DENY_SCAN);
if (_FAIL == rtw_pwr_wakeup(padapter))
goto cancel_ps_deny;
if (!rtw_is_adapter_up(padapter)) {
RTW_INFO("scan abort!! adapter cannot use\n");
goto cancel_ps_deny;
}
#else
#ifdef CONFIG_MP_INCLUDED
if (rtw_mp_mode_check(padapter)) {
RTW_INFO("MP mode block Scan request\n");
goto exit;
}
#endif
if (rtw_is_scan_deny(padapter)) {
RTW_INFO(FUNC_ADPT_FMT ": scan deny\n", FUNC_ADPT_ARG(padapter));
goto exit;
}
rtw_ps_deny(padapter, PS_DENY_SCAN);
if (_FAIL == rtw_pwr_wakeup(padapter))
goto cancel_ps_deny;
if (!rtw_is_adapter_up(padapter)) {
RTW_INFO("scan abort!! adapter cannot use\n");
goto cancel_ps_deny;
}
if (rtw_mi_busy_traffic_check(padapter)) {
RTW_INFO("scan abort!! BusyTraffic == _TRUE\n");
goto cancel_ps_deny;
}
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) && check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
RTW_INFO("scan abort!! AP mode process WPS\n");
goto cancel_ps_deny;
}
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING) == _TRUE) {
RTW_INFO("scan abort!! fwstate=0x%x\n", pmlmepriv->fw_state);
goto cancel_ps_deny;
}
#ifdef CONFIG_CONCURRENT_MODE
if (rtw_mi_buddy_check_fwstate(padapter,
WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING | WIFI_UNDER_WPS)) {
RTW_INFO("scan abort!! buddy_fwstate check failed\n");
goto cancel_ps_deny;
}
#endif
#endif
if (acs) {
#ifdef CONFIG_RTW_ACS
_status = rtw_set_acs_sitesurvey(padapter);
#endif
} else
_status = rtw_sitesurvey_cmd(padapter, NULL);
cancel_ps_deny:
rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
exit:
return count;
}
#ifdef ROKU_PRIVATE
int proc_get_infra_ap(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
struct sta_info *psta;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct ht_priv_infra_ap *phtpriv = &pmlmepriv->htpriv_infra_ap;
#ifdef CONFIG_80211AC_VHT
struct vht_priv_infra_ap *pvhtpriv = &pmlmepriv->vhtpriv_infra_ap;
#endif
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct sta_priv *pstapriv = &padapter->stapriv;
if (MLME_IS_STA(padapter)) {
psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
if (psta) {
unsigned int i, j;
unsigned int Rx_ss = 0, Tx_ss = 0;
RTW_PRINT_SEL(m, "SSID=%s\n", pmlmeinfo->network.Ssid.Ssid);
RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
RTW_PRINT_SEL(m, "Supported rate=");
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
if (pmlmeinfo->SupportedRates_infra_ap[i] == 0)
break;
RTW_PRINT_SEL(m, " 0x%x", pmlmeinfo->SupportedRates_infra_ap[i]);
}
RTW_PRINT_SEL(m, "\n");
#ifdef CONFIG_80211N_HT
if (pmlmeinfo->ht_vht_received & BIT(0)) {
RTW_PRINT_SEL(m, "Supported MCS set=");
for (i = 0; i < 16 ; i++)
RTW_PRINT_SEL(m, " 0x%02x", phtpriv->MCS_set_infra_ap[i]);
RTW_PRINT_SEL(m, "\n");
RTW_PRINT_SEL(m, "highest supported data rate=0x%x\n", phtpriv->rx_highest_data_rate_infra_ap);
RTW_PRINT_SEL(m, "HT_supported_channel_width_set=0x%x\n", phtpriv->channel_width_infra_ap);
RTW_PRINT_SEL(m, "sgi_20m=%d, sgi_40m=%d\n", phtpriv->sgi_20m_infra_ap, phtpriv->sgi_40m_infra_ap);
RTW_PRINT_SEL(m, "ldpc_cap=0x%x, stbc_cap=0x%x\n", phtpriv->ldpc_cap_infra_ap, phtpriv->stbc_cap_infra_ap);
RTW_PRINT_SEL(m, "HT_number_of_stream=%d\n", phtpriv->Rx_ss_infra_ap);
}
#endif
#ifdef CONFIG_80211AC_VHT
if (pmlmeinfo->ht_vht_received & BIT(1)) {
RTW_PRINT_SEL(m, "VHT_supported_channel_width_set=0x%x\n", pvhtpriv->channel_width_infra_ap);
RTW_PRINT_SEL(m, "vht_ldpc_cap=0x%x, vht_stbc_cap=0x%x, vht_beamform_cap=0x%x\n", pvhtpriv->ldpc_cap_infra_ap, pvhtpriv->stbc_cap_infra_ap, pvhtpriv->beamform_cap_infra_ap);
RTW_PRINT_SEL(m, "Rx_vht_mcs_map=0x%x, Tx_vht_mcs_map=0x%x\n", *(u16 *)pvhtpriv->vht_mcs_map_infra_ap, *(u16 *)pvhtpriv->vht_mcs_map_tx_infra_ap);
RTW_PRINT_SEL(m, "VHT_number_of_stream=%d\n", pvhtpriv->number_of_streams_infra_ap);
}
#endif
} else
RTW_PRINT_SEL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
} else
RTW_PRINT_SEL(m, "this only applies to STA mode\n");
return 0;
}
#endif /* ROKU_PRIVATE */
static int wireless_mode_to_str(u32 mode, char *str)
{
str[0]='\0';
if (mode & WLAN_MD_11A)
sprintf(str+strlen(str),"%s","A/");
if (mode & WLAN_MD_11B)
sprintf(str+strlen(str),"%s","B/");
if (mode & WLAN_MD_11G)
sprintf(str+strlen(str),"%s","G/");
#ifdef CONFIG_80211N_HT
if (mode & WLAN_MD_11N)
sprintf(str+strlen(str),"%s","N/");
#endif
#ifdef CONFIG_80211AC_VHT
if (mode & WLAN_MD_11AC)
sprintf(str+strlen(str),"%s","AC/");
#endif
#ifdef CONFIG_80211AX_HE
if (mode & WLAN_MD_11AX)
sprintf(str+strlen(str),"%s","AX/");
#endif
if (strlen(str)>1)
str[strlen(str)-1]='\0';
return strlen(str);
}
int proc_get_ap_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
struct sta_info *psta;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_priv *pstapriv = &padapter->stapriv;
char wl_mode[16];
/* ap vendor */
char vendor[VENDOR_NAME_LEN] = {0};
get_assoc_AP_Vendor(vendor,pmlmeinfo->assoc_AP_vendor);
RTW_PRINT_SEL(m,"AP Vendor %s\n", vendor);
psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
if (psta) {
wireless_mode_to_str(psta->phl_sta->wmode, wl_mode);
RTW_PRINT_SEL(m, "SSID=%s\n", cur_network->network.Ssid.Ssid);
RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
RTW_PRINT_SEL(m, "cur_channel=%d, cur_bwmode=%d(%s), cur_ch_offset=%d\n", pmlmeext->chandef.chan, pmlmeext->chandef.bw, ch_width_str(pmlmeext->chandef.bw), pmlmeext->chandef.offset);
RTW_PRINT_SEL(m, "wireless_mode=0x%x(%s), rtsen=%d, cts2slef=%d hw_rts_en=%d\n",
psta->phl_sta->wmode, wl_mode, psta->rtsen, psta->cts2self, psta->hw_rts_en);
/* ToDo: need API to query hal_sta->ra_info.rate_id */
/* RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n",
psta->state, psta->phl_sta->aid, psta->phl_sta->macid, psta->phl_sta->ra_info.rate_id); */
RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d\n",
psta->state, psta->phl_sta->aid, psta->phl_sta->macid);
#ifdef CONFIG_80211N_HT
RTW_PRINT_SEL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
RTW_PRINT_SEL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n"
, psta->phl_sta->chandef.bw, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
RTW_PRINT_SEL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
RTW_PRINT_SEL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
RTW_PRINT_SEL(m, "ldpc_cap=0x%x, stbc_cap=0x%x, beamform_cap=0x%x\n", psta->htpriv.ldpc_cap, psta->htpriv.stbc_cap, psta->htpriv.beamform_cap);
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
RTW_PRINT_SEL(m, "vht_en=%u, upper_layer_setting=%u, vht_sgi_80m=%u\n", psta->vhtpriv.vht_option, psta->vhtpriv.upper_layer_setting, psta->vhtpriv.sgi_80m);
RTW_PRINT_SEL(m, "vht_ldpc_cap=0x%x, vht_stbc_cap=0x%x, vht_beamform_cap=0x%x\n", psta->vhtpriv.ldpc_cap, psta->vhtpriv.stbc_cap, psta->vhtpriv.beamform_cap);
RTW_PRINT_SEL(m, "vht_mcs_map=0x%x, vht_highest_rate=0x%x, vht_ampdu_len=%d\n", *(u16 *)psta->vhtpriv.vht_mcs_map, psta->vhtpriv.vht_highest_rate, psta->vhtpriv.ampdu_len);
if (psta->vhtpriv.vht_option) {
RTW_MAP_DUMP_SEL_ALWAYS(m, "vht_cap=", psta->vhtpriv.vht_cap, 32);
} else {
RTW_PRINT_SEL(m, "vht_cap=N/A\n");
}
#endif
#ifdef CONFIG_80211AX_HE
RTW_PRINT_SEL(m, "he_en=%d\n", psta->hepriv.he_option);
if (psta->hepriv.he_option) {
RTW_MAP_DUMP_SEL_ALWAYS(m, "he_cap=", psta->hepriv.he_cap, HE_CAP_ELE_MAX_LEN);
} else {
RTW_PRINT_SEL(m, "he_cap=N/A\n");
}
#endif
#ifdef CONFIG_RECV_REORDERING_CTRL
sta_rx_reorder_ctl_dump(m, psta);
#endif
} else
RTW_PRINT_SEL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
return 0;
}
ssize_t proc_reset_trx_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct recv_info *precvinfo = &padapter->recvinfo;
char cmd[32] = {0};
u8 cnt = 0;
if (count > sizeof(cmd)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(cmd, buffer, count)) {
int num = sscanf(cmd, "%hhx", &cnt);
if (num == 1 && cnt == 0) {
precvinfo->dbg_rx_ampdu_drop_count = 0;
precvinfo->dbg_rx_ampdu_forced_indicate_count = 0;
precvinfo->dbg_rx_ampdu_loss_count = 0;
precvinfo->dbg_rx_dup_mgt_frame_drop_count = 0;
precvinfo->dbg_rx_ampdu_window_shift_cnt = 0;
precvinfo->dbg_rx_conflic_mac_addr_cnt = 0;
precvinfo->dbg_rx_drop_count = 0;
}
}
return count;
}
int proc_get_trx_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
int i;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct recv_info *precvinfo = &padapter->recvinfo;
struct recv_priv *precvpriv = &adapter_to_dvobj(padapter)->recvpriv;
struct hw_xmit *phwxmit;
struct trx_data_buf_q *litexmitbuf_q = &dvobj->litexmitbuf_q;
struct trx_data_buf_q *literecvbuf_q = &dvobj->literecvbuf_q;
#ifdef CONFIG_USB_HCI
struct trx_urb_buf_q *xmit_urb_q = &dvobj->xmit_urb_q;
struct trx_urb_buf_q *recv_urb_q = &dvobj->recv_urb_q;
#endif
u16 vo_params[4]={0}, vi_params[4]={0}, be_params[4]={0}, bk_params[4]={0};
rtw_hal_read_edca(padapter, vo_params, vi_params, be_params, bk_params);
RTW_PRINT_SEL(m, "wmm_edca_vo, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", vo_params[0], vo_params[1], vo_params[2], vo_params[3]);
RTW_PRINT_SEL(m, "wmm_edca_vi, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", vi_params[0], vi_params[1], vi_params[2], vi_params[3]);
RTW_PRINT_SEL(m, "wmm_edca_be, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", be_params[0], be_params[1], be_params[2], be_params[3]);
RTW_PRINT_SEL(m, "wmm_edca_bk, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", bk_params[0], bk_params[1], bk_params[2], bk_params[3]);
dump_os_queue(m, padapter);
#if 0 /*CONFIG_CORE_XMITBUF*/
RTW_PRINT_SEL(m, "free_xmitbuf_cnt=%d\n"
, pxmitpriv->free_xmitbuf_cnt);
RTW_PRINT_SEL(m, "free_ext_xmitbuf_cnt=%d\n"
, pxmitpriv->free_xmit_extbuf_cnt);
#endif
RTW_PRINT_SEL(m, "free_xmitframe_cnt=%d\n"
, pxmitpriv->free_xmitframe_cnt);
RTW_PRINT_SEL(m, "free_xframe_ext_cnt=%d\n"
, pxmitpriv->free_xframe_ext_cnt);
RTW_PRINT_SEL(m, "free_recvframe_cnt=%d\n"
, precvpriv->free_recvframe_cnt);
RTW_PRINT_SEL(m, "free_litexmitbuf_cnt=%d\n"
, litexmitbuf_q->free_data_buf_cnt);
RTW_PRINT_SEL(m, "free_recvbuf_cnt=%d\n"
, literecvbuf_q->free_data_buf_cnt);
for (i = 0; i < 4; i++) {
phwxmit = pxmitpriv->hwxmits + i;
RTW_PRINT_SEL(m, "%d, hwq.accnt=%d\n", i, phwxmit->accnt);
}
rtw_hal_get_hwreg(padapter, HW_VAR_DUMP_MAC_TXFIFO, (u8 *)m);
#ifdef CONFIG_USB_HCI
RTW_PRINT_SEL(m, "tx_urb_cnt=%d\n", xmit_urb_q->free_urb_buf_cnt);
RTW_PRINT_SEL(m, "rx_urb_cnt=%d\n", recv_urb_q->free_urb_buf_cnt);
RTW_PRINT_SEL(m, "rx_urb_pending_cn=%d\n", ATOMIC_READ(&(dvobj->rx_pending_cnt)));
#endif
/* Folowing are RX info */
RTW_PRINT_SEL(m, "RX: Count of Packets dropped by Driver: %llu\n", (unsigned long long)precvinfo->dbg_rx_drop_count);
/* Counts of packets whose seq_num is less than preorder_ctrl->indicate_seq, Ex delay, retransmission, redundant packets and so on */
RTW_PRINT_SEL(m, "Rx: Counts of Packets Whose Seq_Num Less Than Reorder Control Seq_Num: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_drop_count);
/* How many times the Rx Reorder Timer is triggered. */
RTW_PRINT_SEL(m, "Rx: Reorder Time-out Trigger Counts: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_forced_indicate_count);
/* Total counts of packets loss */
RTW_PRINT_SEL(m, "Rx: Packet Loss Counts: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_loss_count);
RTW_PRINT_SEL(m, "Rx: Duplicate Management Frame Drop Count: %llu\n", (unsigned long long)precvinfo->dbg_rx_dup_mgt_frame_drop_count);
RTW_PRINT_SEL(m, "Rx: AMPDU BA window shift Count: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_window_shift_cnt);
/*The same mac addr counts*/
RTW_PRINT_SEL(m, "Rx: Conflict MAC Address Frames Count: %llu\n", (unsigned long long)precvinfo->dbg_rx_conflic_mac_addr_cnt);
return 0;
}
static const char *rtw_data_rate_str(enum rtw_data_rate rate)
{
if (rate >= RTW_DATA_RATE_CCK1 && rate <= RTW_DATA_RATE_CCK11) {
switch (rate) {
#define CASE_CCK_RATE(cck) case RTW_DATA_RATE_CCK ## cck: return "CCK_" # cck "M"
CASE_CCK_RATE(1);
CASE_CCK_RATE(2);
CASE_CCK_RATE(5_5);
CASE_CCK_RATE(11);
#undef CASE_CCK_RATE
default:
return "CCK_UNKNOWN";
}
} else if (rate >= RTW_DATA_RATE_OFDM6 && rate <= RTW_DATA_RATE_OFDM54) {
switch (rate) {
#define CASE_OFDM_RATE(ofdm) case RTW_DATA_RATE_OFDM ## ofdm: return "OFDM_" # ofdm "M"
CASE_OFDM_RATE(6);
CASE_OFDM_RATE(9);
CASE_OFDM_RATE(12);
CASE_OFDM_RATE(18);
CASE_OFDM_RATE(24);
CASE_OFDM_RATE(36);
CASE_OFDM_RATE(48);
CASE_OFDM_RATE(54);
#undef CASE_OFDM_RATE
default:
return "OFDM_UNKNOWN";
}
} else if (rate >= RTW_DATA_RATE_MCS0 && rate <= RTW_DATA_RATE_MCS31) {
switch (rate) {
#define CASE_HT_RATE(mcs) case RTW_DATA_RATE_MCS ## mcs: return "MCS_" # mcs
CASE_HT_RATE(0);
CASE_HT_RATE(1);
CASE_HT_RATE(2);
CASE_HT_RATE(3);
CASE_HT_RATE(4);
CASE_HT_RATE(5);
CASE_HT_RATE(6);
CASE_HT_RATE(7);
CASE_HT_RATE(8);
CASE_HT_RATE(9);
CASE_HT_RATE(10);
CASE_HT_RATE(11);
CASE_HT_RATE(12);
CASE_HT_RATE(13);
CASE_HT_RATE(14);
CASE_HT_RATE(15);
CASE_HT_RATE(16);
CASE_HT_RATE(17);
CASE_HT_RATE(18);
CASE_HT_RATE(19);
CASE_HT_RATE(20);
CASE_HT_RATE(21);
CASE_HT_RATE(22);
CASE_HT_RATE(23);
CASE_HT_RATE(24);
CASE_HT_RATE(25);
CASE_HT_RATE(26);
CASE_HT_RATE(27);
CASE_HT_RATE(28);
CASE_HT_RATE(29);
CASE_HT_RATE(30);
CASE_HT_RATE(31);
#undef CASE_HT_RATE
default:
return "HT_UNKNOWN";
}
} else if (rate >= RTW_DATA_RATE_VHT_NSS1_MCS0 && rate <= RTW_DATA_RATE_VHT_NSS4_MCS9) {
switch (rate) {
#define CASE_VHT_RATE(ss, mcs) case RTW_DATA_RATE_VHT_NSS ## ss ##_MCS ##mcs: return "VHT_SS" #ss "MCS" #mcs
CASE_VHT_RATE(1, 0);
CASE_VHT_RATE(1, 1);
CASE_VHT_RATE(1, 2);
CASE_VHT_RATE(1, 3);
CASE_VHT_RATE(1, 4);
CASE_VHT_RATE(1, 5);
CASE_VHT_RATE(1, 6);
CASE_VHT_RATE(1, 7);
CASE_VHT_RATE(1, 8);
CASE_VHT_RATE(1, 9);
CASE_VHT_RATE(2, 0);
CASE_VHT_RATE(2, 1);
CASE_VHT_RATE(2, 2);
CASE_VHT_RATE(2, 3);
CASE_VHT_RATE(2, 4);
CASE_VHT_RATE(2, 5);
CASE_VHT_RATE(2, 6);
CASE_VHT_RATE(2, 7);
CASE_VHT_RATE(2, 8);
CASE_VHT_RATE(2, 9);
CASE_VHT_RATE(3, 0);
CASE_VHT_RATE(3, 1);
CASE_VHT_RATE(3, 2);
CASE_VHT_RATE(3, 3);
CASE_VHT_RATE(3, 4);
CASE_VHT_RATE(3, 5);
CASE_VHT_RATE(3, 6);
CASE_VHT_RATE(3, 7);
CASE_VHT_RATE(3, 8);
CASE_VHT_RATE(3, 9);
CASE_VHT_RATE(4, 0);
CASE_VHT_RATE(4, 1);
CASE_VHT_RATE(4, 2);
CASE_VHT_RATE(4, 3);
CASE_VHT_RATE(4, 4);
CASE_VHT_RATE(4, 5);
CASE_VHT_RATE(4, 6);
CASE_VHT_RATE(4, 7);
CASE_VHT_RATE(4, 8);
CASE_VHT_RATE(4, 9);
#undef CASE_VHT_RATE
default:
return "VHT_UNKNOWN";
}
} else if (rate >= RTW_DATA_RATE_HE_NSS1_MCS0 && rate <= RTW_DATA_RATE_HE_NSS4_MCS11) {
switch (rate) {
#define CASE_HE_RATE(ss, mcs) case RTW_DATA_RATE_HE_NSS ## ss ##_MCS ##mcs: return "HE_SS" #ss "MCS" #mcs
CASE_HE_RATE(1, 0);
CASE_HE_RATE(1, 1);
CASE_HE_RATE(1, 2);
CASE_HE_RATE(1, 3);
CASE_HE_RATE(1, 4);
CASE_HE_RATE(1, 5);
CASE_HE_RATE(1, 6);
CASE_HE_RATE(1, 7);
CASE_HE_RATE(1, 8);
CASE_HE_RATE(1, 9);
CASE_HE_RATE(1, 10);
CASE_HE_RATE(1, 11);
CASE_HE_RATE(2, 0);
CASE_HE_RATE(2, 1);
CASE_HE_RATE(2, 2);
CASE_HE_RATE(2, 3);
CASE_HE_RATE(2, 4);
CASE_HE_RATE(2, 5);
CASE_HE_RATE(2, 6);
CASE_HE_RATE(2, 7);
CASE_HE_RATE(2, 8);
CASE_HE_RATE(2, 9);
CASE_HE_RATE(2, 10);
CASE_HE_RATE(2, 11);
CASE_HE_RATE(3, 0);
CASE_HE_RATE(3, 1);
CASE_HE_RATE(3, 2);
CASE_HE_RATE(3, 3);
CASE_HE_RATE(3, 4);
CASE_HE_RATE(3, 5);
CASE_HE_RATE(3, 6);
CASE_HE_RATE(3, 7);
CASE_HE_RATE(3, 8);
CASE_HE_RATE(3, 9);
CASE_HE_RATE(3, 10);
CASE_HE_RATE(3, 11);
CASE_HE_RATE(4, 0);
CASE_HE_RATE(4, 1);
CASE_HE_RATE(4, 2);
CASE_HE_RATE(4, 3);
CASE_HE_RATE(4, 4);
CASE_HE_RATE(4, 5);
CASE_HE_RATE(4, 6);
CASE_HE_RATE(4, 7);
CASE_HE_RATE(4, 8);
CASE_HE_RATE(4, 9);
CASE_HE_RATE(4, 10);
CASE_HE_RATE(4, 11);
#undef CASE_HE_RATE
default:
return "HE_UNKNOWN";
}
}
return "ALL_UNKNOWN";
}
int proc_get_rate_ctl(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
u16 data_rate = 0;
u8 sgi = 0, data_fb = 0;
if (adapter->fix_rate != NO_FIX_RATE) {
data_rate = GET_FIX_RATE(adapter->fix_rate);
sgi = GET_FIX_RATE_SGI(adapter->fix_rate);
data_fb = adapter->data_fb ? 1 : 0;
RTW_PRINT_SEL(m, "FIXED %s%s%s\n"
, rtw_data_rate_str(data_rate)
, data_rate >= RTW_DATA_RATE_MCS0 ? (sgi ? " SGI" : " LGI") : ""
, data_fb ? " FB" : ""
);
RTW_PRINT_SEL(m, "0x%02x %u\n", adapter->fix_rate, adapter->data_fb);
} else
RTW_PRINT_SEL(m, "RA\n");
return 0;
}
ssize_t proc_set_rate_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u16 fix_rate = NO_FIX_RATE;
u8 data_fb = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hx %hhu", &fix_rate, &data_fb);
if (num >= 1) {
u16 fix_rate_ori = adapter->fix_rate;
adapter->fix_rate = fix_rate;
#if 0 /*GEORGIA_TODO_FIXIT*/
if (fix_rate == 0xFF)
hal_data->ForcedDataRate = 0;
else
hal_data->ForcedDataRate = hwrate_to_mrate(fix_rate & 0x7F);
#endif
if (adapter->fix_bw != NO_FIX_BW && fix_rate_ori != fix_rate)
rtw_run_in_thread_cmd(adapter, ((void *)(rtw_update_tx_rate_bmp)), adapter_to_dvobj(adapter));
}
if (num >= 2)
adapter->data_fb = data_fb ? 1 : 0;
}
return count;
}
#ifdef CONFIG_AP_MODE
int proc_get_bmc_tx_rate(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
if (!MLME_IS_AP(adapter) && !MLME_IS_MESH(adapter)) {
RTW_PRINT_SEL(m, "[ERROR] Not in SoftAP/Mesh mode !!\n");
return 0;
}
RTW_PRINT_SEL(m, " BMC Tx rate - %s\n", MGN_RATE_STR(adapter->bmc_tx_rate));
return 0;
}
ssize_t proc_set_bmc_tx_rate(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 bmc_tx_rate;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx", &bmc_tx_rate);
if (num >= 1)
/*adapter->bmc_tx_rate = hwrate_to_mrate(bmc_tx_rate);*/
adapter->bmc_tx_rate = bmc_tx_rate;
}
return count;
}
#endif /*CONFIG_AP_MODE*/
int proc_get_tx_power_offset(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "Tx power offset - %u\n", adapter->power_offset);
return 0;
}
ssize_t proc_set_tx_power_offset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 power_offset = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhu", &power_offset);
if (num >= 1) {
if (power_offset > 5)
power_offset = 0;
adapter->power_offset = power_offset;
}
}
return count;
}
int proc_get_bw_ctl(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
u8 data_bw = 0;
if (adapter->fix_bw != NO_FIX_BW) {
data_bw = adapter->fix_bw;
RTW_PRINT_SEL(m, "FIXED %s\n", ch_width_str(data_bw));
} else
RTW_PRINT_SEL(m, "Auto\n");
return 0;
}
ssize_t proc_set_bw_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 fix_bw;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhu", &fix_bw);
if (num >= 1) {
u8 fix_bw_ori = adapter->fix_bw;
adapter->fix_bw = fix_bw;
if (adapter->fix_rate != NO_FIX_RATE && fix_bw_ori != fix_bw)
rtw_run_in_thread_cmd(adapter, ((void *)(rtw_update_tx_rate_bmp)), adapter_to_dvobj(adapter));
}
}
return count;
}
#ifdef DBG_RX_COUNTER_DUMP
int proc_get_rx_cnt_dump(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
int i;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "BIT0- Dump RX counters of DRV\n");
RTW_PRINT_SEL(m, "BIT1- Dump RX counters of MAC\n");
RTW_PRINT_SEL(m, "BIT2- Dump RX counters of PHY\n");
RTW_PRINT_SEL(m, "BIT3- Dump TRX data frame of DRV\n");
RTW_PRINT_SEL(m, "dump_rx_cnt_mode = 0x%02x\n", adapter->dump_rx_cnt_mode);
return 0;
}
ssize_t proc_set_rx_cnt_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 dump_rx_cnt_mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx", &dump_rx_cnt_mode);
if (num == 1) {
rtw_dump_phy_rxcnts_preprocess(adapter, dump_rx_cnt_mode);
adapter->dump_rx_cnt_mode = dump_rx_cnt_mode;
}
}
return count;
}
#endif
ssize_t proc_set_del_rx_ampdu_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count))
sscanf(tmp, "%hhu", &del_rx_ampdu_test_no_tx_fail);
return count;
}
ssize_t proc_set_wait_hiq_empty(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count))
sscanf(tmp, "%u", &g_wait_hiq_empty_ms);
return count;
}
ssize_t proc_set_sta_linking_test(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
u32 wait_ms = 0;
u8 force_fail = 0;
int num = sscanf(tmp, "%u %hhu", &wait_ms, &force_fail);
if (num >= 1)
sta_linking_test_wait_ms = wait_ms;
if (num >= 2)
sta_linking_test_force_fail = force_fail;
}
return count;
}
#ifdef CONFIG_AP_MODE
ssize_t proc_set_ap_linking_test(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
u16 force_auth_fail = 0;
u16 force_asoc_fail = 0;
int num = sscanf(tmp, "%hu %hu", &force_auth_fail, &force_asoc_fail);
if (num >= 1)
ap_linking_test_force_auth_fail = force_auth_fail;
if (num >= 2)
ap_linking_test_force_asoc_fail = force_asoc_fail;
}
return count;
}
#endif /* CONFIG_AP_MODE */
int proc_get_ps_dbg_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = padapter->dvobj;
struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
RTW_PRINT_SEL(m, "dbg_sdio_alloc_irq_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_cnt);
RTW_PRINT_SEL(m, "dbg_sdio_free_irq_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_cnt);
RTW_PRINT_SEL(m, "dbg_sdio_alloc_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_error_cnt);
RTW_PRINT_SEL(m, "dbg_sdio_free_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_error_cnt);
RTW_PRINT_SEL(m, "dbg_sdio_init_error_cnt=%d\n", pdbgpriv->dbg_sdio_init_error_cnt);
RTW_PRINT_SEL(m, "dbg_sdio_deinit_error_cnt=%d\n", pdbgpriv->dbg_sdio_deinit_error_cnt);
RTW_PRINT_SEL(m, "dbg_suspend_error_cnt=%d\n", pdbgpriv->dbg_suspend_error_cnt);
RTW_PRINT_SEL(m, "dbg_suspend_cnt=%d\n", pdbgpriv->dbg_suspend_cnt);
RTW_PRINT_SEL(m, "dbg_resume_cnt=%d\n", pdbgpriv->dbg_resume_cnt);
RTW_PRINT_SEL(m, "dbg_resume_error_cnt=%d\n", pdbgpriv->dbg_resume_error_cnt);
RTW_PRINT_SEL(m, "dbg_deinit_fail_cnt=%d\n", pdbgpriv->dbg_deinit_fail_cnt);
RTW_PRINT_SEL(m, "dbg_carddisable_cnt=%d\n", pdbgpriv->dbg_carddisable_cnt);
RTW_PRINT_SEL(m, "dbg_ps_insuspend_cnt=%d\n", pdbgpriv->dbg_ps_insuspend_cnt);
RTW_PRINT_SEL(m, "dbg_dev_unload_inIPS_cnt=%d\n", pdbgpriv->dbg_dev_unload_inIPS_cnt);
RTW_PRINT_SEL(m, "dbg_scan_pwr_state_cnt=%d\n", pdbgpriv->dbg_scan_pwr_state_cnt);
RTW_PRINT_SEL(m, "dbg_downloadfw_pwr_state_cnt=%d\n", pdbgpriv->dbg_downloadfw_pwr_state_cnt);
RTW_PRINT_SEL(m, "dbg_carddisable_error_cnt=%d\n", pdbgpriv->dbg_carddisable_error_cnt);
RTW_PRINT_SEL(m, "dbg_fw_read_ps_state_fail_cnt=%d\n", pdbgpriv->dbg_fw_read_ps_state_fail_cnt);
RTW_PRINT_SEL(m, "dbg_leave_ips_fail_cnt=%d\n", pdbgpriv->dbg_leave_ips_fail_cnt);
RTW_PRINT_SEL(m, "dbg_leave_lps_fail_cnt=%d\n", pdbgpriv->dbg_leave_lps_fail_cnt);
RTW_PRINT_SEL(m, "dbg_h2c_leave32k_fail_cnt=%d\n", pdbgpriv->dbg_h2c_leave32k_fail_cnt);
RTW_PRINT_SEL(m, "dbg_diswow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_diswow_dload_fw_fail_cnt);
RTW_PRINT_SEL(m, "dbg_enwow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_enwow_dload_fw_fail_cnt);
RTW_PRINT_SEL(m, "dbg_ips_drvopen_fail_cnt=%d\n", pdbgpriv->dbg_ips_drvopen_fail_cnt);
RTW_PRINT_SEL(m, "dbg_poll_fail_cnt=%d\n", pdbgpriv->dbg_poll_fail_cnt);
RTW_PRINT_SEL(m, "dbg_rpwm_toogle_cnt=%d\n", pdbgpriv->dbg_rpwm_toogle_cnt);
RTW_PRINT_SEL(m, "dbg_rpwm_timeout_fail_cnt=%d\n", pdbgpriv->dbg_rpwm_timeout_fail_cnt);
RTW_PRINT_SEL(m, "dbg_sreset_cnt=%d\n", pdbgpriv->dbg_sreset_cnt);
RTW_PRINT_SEL(m, "dbg_fw_mem_dl_error_cnt=%d\n", pdbgpriv->dbg_fw_mem_dl_error_cnt);
return 0;
}
ssize_t proc_set_ps_dbg_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = adapter->dvobj;
struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
char tmp[32];
u8 ps_dbg_cmd_id;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx", &ps_dbg_cmd_id);
if (num == 1 && ps_dbg_cmd_id == 1) /*Clean all*/
_rtw_memset(pdbgpriv, 0, sizeof(struct debug_priv));
}
return count;
}
#ifdef CONFIG_DBG_COUNTER
int proc_get_rx_logs(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct rx_logs *rx_logs = &padapter->rx_logs;
RTW_PRINT_SEL(m,
"intf_rx=%d\n"
"intf_rx_err_recvframe=%d\n"
"intf_rx_err_skb=%d\n"
"intf_rx_report=%d\n"
"core_rx=%d\n"
"core_rx_pre=%d\n"
"core_rx_pre_ver_err=%d\n"
"core_rx_pre_mgmt=%d\n"
"core_rx_pre_mgmt_err_80211w=%d\n"
"core_rx_pre_mgmt_err=%d\n"
"core_rx_pre_ctrl=%d\n"
"core_rx_pre_ctrl_err=%d\n"
"core_rx_pre_data=%d\n"
"core_rx_pre_data_wapi_seq_err=%d\n"
"core_rx_pre_data_wapi_key_err=%d\n"
"core_rx_pre_data_handled=%d\n"
"core_rx_pre_data_err=%d\n"
"core_rx_pre_data_unknown=%d\n"
"core_rx_pre_unknown=%d\n"
"core_rx_enqueue=%d\n"
"core_rx_dequeue=%d\n"
"core_rx_post=%d\n"
"core_rx_post_decrypt=%d\n"
"core_rx_post_decrypt_wep=%d\n"
"core_rx_post_decrypt_tkip=%d\n"
"core_rx_post_decrypt_aes=%d\n"
"core_rx_post_decrypt_wapi=%d\n"
"core_rx_post_decrypt_hw=%d\n"
"core_rx_post_decrypt_unknown=%d\n"
"core_rx_post_decrypt_err=%d\n"
"core_rx_post_defrag_err=%d\n"
"core_rx_post_portctrl_err=%d\n"
"core_rx_post_indicate=%d\n"
"core_rx_post_indicate_in_oder=%d\n"
"core_rx_post_indicate_reoder=%d\n"
"core_rx_post_indicate_err=%d\n"
"os_indicate=%d\n"
"os_indicate_ap_mcast=%d\n"
"os_indicate_ap_forward=%d\n"
"os_indicate_ap_self=%d\n"
"os_indicate_err=%d\n"
"os_netif_ok=%d\n"
"os_netif_err=%d\n",
rx_logs->intf_rx,
rx_logs->intf_rx_err_recvframe,
rx_logs->intf_rx_err_skb,
rx_logs->intf_rx_report,
rx_logs->core_rx,
rx_logs->core_rx_pre,
rx_logs->core_rx_pre_ver_err,
rx_logs->core_rx_pre_mgmt,
rx_logs->core_rx_pre_mgmt_err_80211w,
rx_logs->core_rx_pre_mgmt_err,
rx_logs->core_rx_pre_ctrl,
rx_logs->core_rx_pre_ctrl_err,
rx_logs->core_rx_pre_data,
rx_logs->core_rx_pre_data_wapi_seq_err,
rx_logs->core_rx_pre_data_wapi_key_err,
rx_logs->core_rx_pre_data_handled,
rx_logs->core_rx_pre_data_err,
rx_logs->core_rx_pre_data_unknown,
rx_logs->core_rx_pre_unknown,
rx_logs->core_rx_enqueue,
rx_logs->core_rx_dequeue,
rx_logs->core_rx_post,
rx_logs->core_rx_post_decrypt,
rx_logs->core_rx_post_decrypt_wep,
rx_logs->core_rx_post_decrypt_tkip,
rx_logs->core_rx_post_decrypt_aes,
rx_logs->core_rx_post_decrypt_wapi,
rx_logs->core_rx_post_decrypt_hw,
rx_logs->core_rx_post_decrypt_unknown,
rx_logs->core_rx_post_decrypt_err,
rx_logs->core_rx_post_defrag_err,
rx_logs->core_rx_post_portctrl_err,
rx_logs->core_rx_post_indicate,
rx_logs->core_rx_post_indicate_in_oder,
rx_logs->core_rx_post_indicate_reoder,
rx_logs->core_rx_post_indicate_err,
rx_logs->os_indicate,
rx_logs->os_indicate_ap_mcast,
rx_logs->os_indicate_ap_forward,
rx_logs->os_indicate_ap_self,
rx_logs->os_indicate_err,
rx_logs->os_netif_ok,
rx_logs->os_netif_err
);
return 0;
}
int proc_get_tx_logs(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct tx_logs *tx_logs = &padapter->tx_logs;
RTW_PRINT_SEL(m,
"os_tx=%d\n"
"os_tx_err_up=%d\n"
"os_tx_err_xmit=%d\n"
"os_tx_m2u=%d\n"
"os_tx_m2u_ignore_fw_linked=%d\n"
"os_tx_m2u_ignore_self=%d\n"
"os_tx_m2u_entry=%d\n"
"os_tx_m2u_entry_err_xmit=%d\n"
"os_tx_m2u_entry_err_skb=%d\n"
"os_tx_m2u_stop=%d\n"
"core_tx=%d\n"
"core_tx_err_pxmitframe=%d\n"
"core_tx_err_brtx=%d\n"
"core_tx_upd_attrib=%d\n"
"core_tx_upd_attrib_adhoc=%d\n"
"core_tx_upd_attrib_sta=%d\n"
"core_tx_upd_attrib_ap=%d\n"
"core_tx_upd_attrib_unknown=%d\n"
"core_tx_upd_attrib_dhcp=%d\n"
"core_tx_upd_attrib_icmp=%d\n"
"core_tx_upd_attrib_active=%d\n"
"core_tx_upd_attrib_err_ucast_sta=%d\n"
"core_tx_upd_attrib_err_ucast_ap_link=%d\n"
"core_tx_upd_attrib_err_sta=%d\n"
"core_tx_upd_attrib_err_link=%d\n"
"core_tx_upd_attrib_err_sec=%d\n"
"core_tx_ap_enqueue_warn_fwstate=%d\n"
"core_tx_ap_enqueue_warn_sta=%d\n"
"core_tx_ap_enqueue_warn_nosta=%d\n"
"core_tx_ap_enqueue_warn_link=%d\n"
"core_tx_ap_enqueue_warn_trigger=%d\n"
"core_tx_ap_enqueue_mcast=%d\n"
"core_tx_ap_enqueue_ucast=%d\n"
"core_tx_ap_enqueue=%d\n"
"intf_tx=%d\n"
"intf_tx_pending_ac=%d\n"
"intf_tx_pending_fw_under_survey=%d\n"
"intf_tx_pending_fw_under_linking=%d\n"
"intf_tx_pending_xmitbuf=%d\n"
"intf_tx_enqueue=%d\n"
"core_tx_enqueue=%d\n"
"core_tx_enqueue_class=%d\n"
"core_tx_enqueue_class_err_sta=%d\n"
"core_tx_enqueue_class_err_nosta=%d\n"
"core_tx_enqueue_class_err_fwlink=%d\n"
"intf_tx_direct=%d\n"
"intf_tx_direct_err_coalesce=%d\n"
"intf_tx_dequeue=%d\n"
"intf_tx_dequeue_err_coalesce=%d\n"
"intf_tx_dump_xframe=%d\n"
"intf_tx_dump_xframe_err_txdesc=%d\n"
"intf_tx_dump_xframe_err_port=%d\n",
tx_logs->os_tx,
tx_logs->os_tx_err_up,
tx_logs->os_tx_err_xmit,
tx_logs->os_tx_m2u,
tx_logs->os_tx_m2u_ignore_fw_linked,
tx_logs->os_tx_m2u_ignore_self,
tx_logs->os_tx_m2u_entry,
tx_logs->os_tx_m2u_entry_err_xmit,
tx_logs->os_tx_m2u_entry_err_skb,
tx_logs->os_tx_m2u_stop,
tx_logs->core_tx,
tx_logs->core_tx_err_pxmitframe,
tx_logs->core_tx_err_brtx,
tx_logs->core_tx_upd_attrib,
tx_logs->core_tx_upd_attrib_adhoc,
tx_logs->core_tx_upd_attrib_sta,
tx_logs->core_tx_upd_attrib_ap,
tx_logs->core_tx_upd_attrib_unknown,
tx_logs->core_tx_upd_attrib_dhcp,
tx_logs->core_tx_upd_attrib_icmp,
tx_logs->core_tx_upd_attrib_active,
tx_logs->core_tx_upd_attrib_err_ucast_sta,
tx_logs->core_tx_upd_attrib_err_ucast_ap_link,
tx_logs->core_tx_upd_attrib_err_sta,
tx_logs->core_tx_upd_attrib_err_link,
tx_logs->core_tx_upd_attrib_err_sec,
tx_logs->core_tx_ap_enqueue_warn_fwstate,
tx_logs->core_tx_ap_enqueue_warn_sta,
tx_logs->core_tx_ap_enqueue_warn_nosta,
tx_logs->core_tx_ap_enqueue_warn_link,
tx_logs->core_tx_ap_enqueue_warn_trigger,
tx_logs->core_tx_ap_enqueue_mcast,
tx_logs->core_tx_ap_enqueue_ucast,
tx_logs->core_tx_ap_enqueue,
tx_logs->intf_tx,
tx_logs->intf_tx_pending_ac,
tx_logs->intf_tx_pending_fw_under_survey,
tx_logs->intf_tx_pending_fw_under_linking,
tx_logs->intf_tx_pending_xmitbuf,
tx_logs->intf_tx_enqueue,
tx_logs->core_tx_enqueue,
tx_logs->core_tx_enqueue_class,
tx_logs->core_tx_enqueue_class_err_sta,
tx_logs->core_tx_enqueue_class_err_nosta,
tx_logs->core_tx_enqueue_class_err_fwlink,
tx_logs->intf_tx_direct,
tx_logs->intf_tx_direct_err_coalesce,
tx_logs->intf_tx_dequeue,
tx_logs->intf_tx_dequeue_err_coalesce,
tx_logs->intf_tx_dump_xframe,
tx_logs->intf_tx_dump_xframe_err_txdesc,
tx_logs->intf_tx_dump_xframe_err_port
);
return 0;
}
int proc_get_int_logs(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m,
"all=%d\n"
"err=%d\n"
"tbdok=%d\n"
"tbder=%d\n"
"bcnderr=%d\n"
"bcndma=%d\n"
"bcndma_e=%d\n"
"rx=%d\n"
"rx_rdu=%d\n"
"rx_fovw=%d\n"
"txfovw=%d\n"
"mgntok=%d\n"
"highdok=%d\n"
"bkdok=%d\n"
"bedok=%d\n"
"vidok=%d\n"
"vodok=%d\n",
padapter->int_logs.all,
padapter->int_logs.err,
padapter->int_logs.tbdok,
padapter->int_logs.tbder,
padapter->int_logs.bcnderr,
padapter->int_logs.bcndma,
padapter->int_logs.bcndma_e,
padapter->int_logs.rx,
padapter->int_logs.rx_rdu,
padapter->int_logs.rx_fovw,
padapter->int_logs.txfovw,
padapter->int_logs.mgntok,
padapter->int_logs.highdok,
padapter->int_logs.bkdok,
padapter->int_logs.bedok,
padapter->int_logs.vidok,
padapter->int_logs.vodok
);
return 0;
}
#endif /* CONFIG_DBG_COUNTER */
int proc_get_hw_status(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = padapter->dvobj;
struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
struct registry_priv *regsty = dvobj_to_regsty(dvobj);
if (regsty->check_hw_status == 0)
RTW_PRINT_SEL(m, "RX FIFO full count: not check in watch dog\n");
else if (pdbgpriv->dbg_rx_fifo_last_overflow == 1
&& pdbgpriv->dbg_rx_fifo_curr_overflow == 1
&& pdbgpriv->dbg_rx_fifo_diff_overflow == 1
)
RTW_PRINT_SEL(m, "RX FIFO full count: no implementation\n");
else {
RTW_PRINT_SEL(m, "RX FIFO full count: last_time=%llu, current_time=%llu, differential=%llu\n"
, pdbgpriv->dbg_rx_fifo_last_overflow, pdbgpriv->dbg_rx_fifo_curr_overflow, pdbgpriv->dbg_rx_fifo_diff_overflow);
}
return 0;
}
ssize_t proc_set_hw_status(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = padapter->dvobj;
struct registry_priv *regsty = dvobj_to_regsty(dvobj);
char tmp[32];
u32 enable;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &enable);
if (num == 1 && regsty && enable <= 1) {
regsty->check_hw_status = enable;
RTW_INFO("check_hw_status=%d\n", regsty->check_hw_status);
}
}
return count;
}
int proc_get_trx_info_debug(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
/*============ tx info ============ */
rtw_hal_get_def_var(padapter, HW_DEF_RA_INFO_DUMP, m);
/*============ rx info ============ */
/*rtw_hal_set_phydm_var(padapter, HAL_PHYDM_RX_INFO_DUMP, m, _FALSE);*/
return 0;
}
int proc_get_rx_signal(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "rssi:%d\n", padapter->recvinfo.rssi);
#if 0//def CONFIG_MP_INCLUDED
if (padapter->registrypriv.mp_mode == 1) {
struct dm_struct *odm = adapter_to_phydm(padapter);
if (padapter->mppriv.antenna_rx == ANTENNA_A)
RTW_PRINT_SEL(m, "Antenna: A\n");
else if (padapter->mppriv.antenna_rx == ANTENNA_B)
RTW_PRINT_SEL(m, "Antenna: B\n");
else if (padapter->mppriv.antenna_rx == ANTENNA_C)
RTW_PRINT_SEL(m, "Antenna: C\n");
else if (padapter->mppriv.antenna_rx == ANTENNA_D)
RTW_PRINT_SEL(m, "Antenna: D\n");
else if (padapter->mppriv.antenna_rx == ANTENNA_AB)
RTW_PRINT_SEL(m, "Antenna: AB\n");
else if (padapter->mppriv.antenna_rx == ANTENNA_BC)
RTW_PRINT_SEL(m, "Antenna: BC\n");
else if (padapter->mppriv.antenna_rx == ANTENNA_CD)
RTW_PRINT_SEL(m, "Antenna: CD\n");
else
RTW_PRINT_SEL(m, "Antenna: __\n");
RTW_PRINT_SEL(m, "rx_rate = %s\n", HDATA_RATE(odm->rx_rate));
return 0;
} else
#endif
{
/* RTW_PRINT_SEL(m, "rxpwdb:%d\n", padapter->recvinfo.rxpwdb); */
RTW_PRINT_SEL(m, "signal_strength:%u\n", padapter->recvinfo.signal_strength);
RTW_PRINT_SEL(m, "signal_qual:%u\n", padapter->recvinfo.signal_qual);
}
return 0;
}
ssize_t proc_set_rx_signal(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 is_signal_dbg, signal_strength;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
if (num < 1)
return count;
is_signal_dbg = is_signal_dbg == 0 ? 0 : 1;
if (is_signal_dbg && num < 2)
return count;
signal_strength = signal_strength > PHL_MAX_RSSI ? PHL_MAX_RSSI : signal_strength;
padapter->recvinfo.is_signal_dbg = is_signal_dbg;
padapter->recvinfo.signal_strength_dbg = signal_strength;
if (is_signal_dbg)
RTW_INFO("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
else
RTW_INFO("set %s\n", "HW_SIGNAL_STRENGTH");
}
return count;
}
int proc_get_mac_rptbuf(struct seq_file *m, void *v)
{
return 0;
}
#ifdef CONFIG_80211N_HT
int proc_get_ht_enable(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "%d\n", pregpriv->ht_enable);
return 0;
}
ssize_t proc_set_ht_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &mode);
if ( num == 1 && pregpriv && mode < 2) {
pregpriv->ht_enable = mode;
RTW_INFO("ht_enable=%d\n", pregpriv->ht_enable);
}
}
return count;
}
int proc_get_bw_mode(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->bw_mode);
return 0;
}
ssize_t proc_set_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 mode;
u8 bw_2g;
u8 bw_5g;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%x ", &mode);
bw_5g = mode >> 4;
bw_2g = mode & 0x0f;
if (num == 1 && pregpriv && bw_2g <= 4 && bw_5g <= 4) {
pregpriv->bw_mode = mode;
printk("bw_mode=0x%x\n", mode);
}
}
return count;
}
int proc_get_ampdu_enable(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "%d\n", pregpriv->ampdu_enable);
return 0;
}
ssize_t proc_set_ampdu_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &mode);
if (num == 1 && pregpriv && mode < 2) {
pregpriv->ampdu_enable = mode;
printk("ampdu_enable=%d\n", mode);
}
}
return count;
}
void dump_regsty_rx_ampdu_size_limit(void *sel, _adapter *adapter)
{
struct registry_priv *regsty = adapter_to_regsty(adapter);
int i;
RTW_PRINT_SEL(sel, "%-3s %-3s %-3s %-3s %-4s\n"
, "", "20M", "40M", "80M", "160M");
for (i = 0; i < 4; i++)
RTW_PRINT_SEL(sel, "%dSS %3u %3u %3u %4u\n", i + 1
, regsty->rx_ampdu_sz_limit_by_nss_bw[i][0]
, regsty->rx_ampdu_sz_limit_by_nss_bw[i][1]
, regsty->rx_ampdu_sz_limit_by_nss_bw[i][2]
, regsty->rx_ampdu_sz_limit_by_nss_bw[i][3]);
}
int proc_get_rx_ampdu(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
_RTW_PRINT_SEL(m, "accept: ");
if (padapter->fix_rx_ampdu_accept == RX_AMPDU_ACCEPT_INVALID)
RTW_PRINT_SEL(m, "%u%s\n", rtw_rx_ampdu_is_accept(padapter), "(auto)");
else
RTW_PRINT_SEL(m, "%u%s\n", padapter->fix_rx_ampdu_accept, "(fixed)");
_RTW_PRINT_SEL(m, "size: ");
if (padapter->fix_rx_ampdu_size == RX_AMPDU_SIZE_INVALID) {
RTW_PRINT_SEL(m, "%u%s\n", rtw_rx_ampdu_size(padapter), "(auto) with conditional limit:");
dump_regsty_rx_ampdu_size_limit(m, padapter);
} else
RTW_PRINT_SEL(m, "%u%s\n", padapter->fix_rx_ampdu_size, "(fixed)");
RTW_PRINT_SEL(m, "\n");
RTW_PRINT_SEL(m, "%19s %17s\n", "fix_rx_ampdu_accept", "fix_rx_ampdu_size");
_RTW_PRINT_SEL(m, "%-19d %-17u\n"
, padapter->fix_rx_ampdu_accept
, padapter->fix_rx_ampdu_size);
return 0;
}
ssize_t proc_set_rx_ampdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 accept;
u8 size;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhu %hhu", &accept, &size);
if (num >= 1)
rtw_rx_ampdu_set_accept(padapter, accept, RX_AMPDU_DRV_FIXED);
if (num >= 2)
rtw_rx_ampdu_set_size(padapter, size, RX_AMPDU_DRV_FIXED);
rtw_rx_ampdu_apply(padapter);
}
return count;
}
int proc_get_rx_ampdu_factor(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
if (padapter)
RTW_PRINT_SEL(m, "rx ampdu factor = %x\n", padapter->driver_rx_ampdu_factor);
return 0;
}
ssize_t proc_set_rx_ampdu_factor(struct file *file, const char __user *buffer
, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 factor;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &factor);
if (padapter && (num == 1)) {
RTW_INFO("padapter->driver_rx_ampdu_factor = %x\n", factor);
if (factor > 0x03)
padapter->driver_rx_ampdu_factor = 0xFF;
else
padapter->driver_rx_ampdu_factor = factor;
}
}
return count;
}
int proc_get_tx_max_agg_num(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
if (padapter)
RTW_PRINT_SEL(m, "tx max AMPDU num = 0x%02x\n", padapter->driver_tx_max_agg_num);
return 0;
}
ssize_t proc_set_tx_max_agg_num(struct file *file, const char __user *buffer
, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 agg_num;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx ", &agg_num);
if (padapter && (num == 1)) {
RTW_INFO("padapter->driver_tx_max_agg_num = 0x%02x\n", agg_num);
padapter->driver_tx_max_agg_num = agg_num;
}
}
return count;
}
int proc_get_rx_ampdu_density(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
if (padapter)
RTW_PRINT_SEL(m, "rx ampdu densityg = %x\n", padapter->driver_rx_ampdu_spacing);
return 0;
}
ssize_t proc_set_rx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 density;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &density);
if (padapter && (num == 1)) {
RTW_INFO("padapter->driver_rx_ampdu_spacing = %x\n", density);
if (density > 0x07)
padapter->driver_rx_ampdu_spacing = 0xFF;
else
padapter->driver_rx_ampdu_spacing = density;
}
}
return count;
}
int proc_get_tx_ampdu_density(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
if (padapter)
RTW_PRINT_SEL(m, "tx ampdu density = %x\n", padapter->driver_ampdu_spacing);
return 0;
}
ssize_t proc_set_tx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 density;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &density);
if (padapter && (num == 1)) {
RTW_INFO("padapter->driver_ampdu_spacing = %x\n", density);
if (density > 0x07)
padapter->driver_ampdu_spacing = 0xFF;
else
padapter->driver_ampdu_spacing = density;
}
}
return count;
}
int proc_get_tx_quick_addba_req(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (padapter)
RTW_PRINT_SEL(m, "tx_quick_addba_req = %x\n", pregpriv->tx_quick_addba_req);
return 0;
}
ssize_t proc_set_tx_quick_addba_req(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 enable;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &enable);
if (padapter && (num == 1)) {
pregpriv->tx_quick_addba_req = enable;
RTW_INFO("tx_quick_addba_req = %d\n", pregpriv->tx_quick_addba_req);
}
}
return count;
}
#ifdef CONFIG_TX_AMSDU
int proc_get_tx_amsdu(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
int i;
if (padapter)
{
RTW_PRINT_SEL(m, "tx amsdu = %d\n", padapter->tx_amsdu);
RTW_PRINT_SEL(m, "amsdu set timer conut = %u\n", pxmitpriv->amsdu_debug_set_timer);
RTW_PRINT_SEL(m, "amsdu time out count = %u\n", pxmitpriv->amsdu_debug_timeout);
for (i = 0; i < (AMSDU_DEBUG_MAX_COUNT - 1); i++) {
RTW_PRINT_SEL(m, "amsdu coalesce %d count = %u\n",
i + 1, pxmitpriv->amsdu_debug_coalesce[i]);
}
RTW_PRINT_SEL(m, "amsdu coalesce >%d count = %u\n",
i, pxmitpriv->amsdu_debug_coalesce[i]);
RTW_PRINT_SEL(m, "amsdu tasklet count = %u\n", pxmitpriv->amsdu_debug_tasklet);
RTW_PRINT_SEL(m, "amsdu enqueue count = %u\n", pxmitpriv->amsdu_debug_enqueue);
RTW_PRINT_SEL(m, "amsdu dequeue count = %u\n", pxmitpriv->amsdu_debug_dequeue);
}
return 0;
}
ssize_t proc_set_tx_amsdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
char tmp[32];
u32 i, amsdu;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &amsdu);
if (padapter && (num == 1)) {
RTW_INFO("padapter->tx_amsdu = %x\n", amsdu);
if (amsdu == 255) {
pxmitpriv->amsdu_debug_set_timer = 0;
pxmitpriv->amsdu_debug_timeout = 0;
pxmitpriv->amsdu_debug_tasklet = 0;
pxmitpriv->amsdu_debug_enqueue = 0;
pxmitpriv->amsdu_debug_dequeue = 0;
for (i = 0; i < AMSDU_DEBUG_MAX_COUNT; i++)
pxmitpriv->amsdu_debug_coalesce[i] = 0;
} else {
padapter->tx_amsdu = amsdu;
}
}
}
return count;
}
int proc_get_tx_amsdu_rate(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
if (padapter)
RTW_PRINT_SEL(m, "tx amsdu rate = %d Mbps\n", padapter->tx_amsdu_rate);
return 0;
}
ssize_t proc_set_tx_amsdu_rate(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 amsdu_rate;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &amsdu_rate);
if (padapter && (num == 1)) {
RTW_INFO("padapter->tx_amsdu_rate = %x\n", amsdu_rate);
padapter->tx_amsdu_rate = amsdu_rate;
}
}
return count;
}
#endif /* CONFIG_TX_AMSDU */
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
int proc_get_vht_24g_enable(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
struct _ADAPTER *a = (struct _ADAPTER *)rtw_netdev_priv(dev);
struct registry_priv *regpriv = &a->registrypriv;
if (regpriv)
RTW_PRINT_SEL(m, "%d\n", regpriv->vht_24g_enable);
return 0;
}
ssize_t proc_set_vht_24g_enable(struct file *file, const char __user *buffer,
size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
struct _ADAPTER *a = (struct _ADAPTER *)rtw_netdev_priv(dev);
struct registry_priv *regpriv = &a->registrypriv;
char tmp[32];
u32 mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &mode);
if ((num == 1) && regpriv && (mode < 2)) {
regpriv->vht_24g_enable = mode;
RTW_INFO("vht_24g_enable = %d\n", regpriv->vht_24g_enable);
}
}
return count;
}
#endif /* CONFIG_80211AC_VHT */
ssize_t proc_set_dyn_rrsr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32] = {0};
u32 num = 0, enable = 0, rrsr_val = 0; /* gpio_mode:0 input 1:output; */
if (count < 2)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
num = sscanf(tmp, "%d 0x%x", &enable, &rrsr_val);
RTW_INFO("num=%u enable=%d rrsr_val=0x%x\n", num, enable, rrsr_val);
pregpriv->en_dyn_rrsr = enable;
pregpriv->set_rrsr_value = rrsr_val;
/*rtw_phydm_dyn_rrsr_en(padapter, enable);*/
/*rtw_phydm_set_rrsr(padapter, rrsr_val, _TRUE);*/
}
return count;
}
int proc_get_dyn_rrsr(struct seq_file *m, void *v) {
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
u32 init_rrsr =0xFFFFFFFF;
if (padapter)
RTW_PRINT_SEL(m, "en_dyn_rrsr = %d fixed_rrsr_value =0x%x %s\n"
, pregpriv->en_dyn_rrsr
, pregpriv->set_rrsr_value
, (pregpriv->set_rrsr_value == init_rrsr)?"(default)":"(fixed)"
);
return 0;
}
int proc_get_en_fwps(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "check_fw_ps = %d , 1:enable get FW PS state , 0: disable get FW PS state\n"
, pregpriv->check_fw_ps);
return 0;
}
ssize_t proc_set_en_fwps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &mode);
if (num == 1 && pregpriv && mode < 2) {
pregpriv->check_fw_ps = mode;
RTW_INFO("pregpriv->check_fw_ps=%d\n", pregpriv->check_fw_ps);
}
}
return count;
}
#ifdef CONFIG_80211N_HT
void rtw_dump_dft_phy_cap(void *sel, _adapter *adapter)
{
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
#ifdef CONFIG_80211AC_VHT
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
#endif
#ifdef CONFIG_80211AC_VHT
RTW_PRINT_SEL(sel, "[DFT CAP] VHT STBC Tx : %s\n", (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] VHT STBC Rx : %s\n", (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX)) ? "V" : "X");
#endif
RTW_PRINT_SEL(sel, "[DFT CAP] HT STBC Tx : %s\n", (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] HT STBC Rx : %s\n\n", (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX)) ? "V" : "X");
#ifdef CONFIG_80211AC_VHT
RTW_PRINT_SEL(sel, "[DFT CAP] VHT LDPC Tx : %s\n", (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] VHT LDPC Rx : %s\n", (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX)) ? "V" : "X");
#endif
RTW_PRINT_SEL(sel, "[DFT CAP] HT LDPC Tx : %s\n", (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] HT LDPC Rx : %s\n\n", (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX)) ? "V" : "X");
#ifdef CONFIG_BEAMFORMING
#ifdef CONFIG_80211AX_HE
RTW_PRINT_SEL(sel, "[DFT CAP] HE MU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_MU_MIMO_AP_ENABLE)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] HE MU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_MU_MIMO_STA_ENABLE)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] HE SU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_BEAMFORMER_ENABLE)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] HE SU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_BEAMFORMEE_ENABLE)) ? "V" : "X");
#endif
#ifdef CONFIG_80211AC_VHT
RTW_PRINT_SEL(sel, "[DFT CAP] VHT MU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] VHT MU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] VHT SU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] VHT SU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE)) ? "V" : "X");
#endif
RTW_PRINT_SEL(sel, "[DFT CAP] HT Bfer : %s\n", (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DFT CAP] HT Bfee : %s\n", (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE)) ? "V" : "X");
#endif
}
void rtw_get_dft_phy_cap(void *sel, _adapter *adapter)
{
RTW_PRINT_SEL(sel, "\n ======== PHY CAP protocol ========\n");
rtw_ht_use_default_setting(adapter);
#ifdef CONFIG_80211AC_VHT
rtw_vht_get_real_setting(adapter);
#endif
#ifdef CONFIG_80211N_HT
rtw_dump_dft_phy_cap(sel, adapter);
#endif
}
void rtw_dump_drv_phy_cap(void *sel, _adapter *adapter)
{
struct registry_priv *pregistry_priv = &adapter->registrypriv;
RTW_PRINT_SEL(sel, "\n ======== DRV's configuration ========\n");
#if 0
RTW_PRINT_SEL(sel, "[DRV CAP] TRx Capability : 0x%08x\n", phy_spec->trx_cap);
RTW_PRINT_SEL(sel, "[DRV CAP] Tx Stream Num Index : %d\n", (phy_spec->trx_cap >> 24) & 0xFF); /*Tx Stream Num Index [31:24]*/
RTW_PRINT_SEL(sel, "[DRV CAP] Rx Stream Num Index : %d\n", (phy_spec->trx_cap >> 16) & 0xFF); /*Rx Stream Num Index [23:16]*/
RTW_PRINT_SEL(sel, "[DRV CAP] Tx Path Num Index : %d\n", (phy_spec->trx_cap >> 8) & 0xFF);/*Tx Path Num Index [15:8]*/
RTW_PRINT_SEL(sel, "[DRV CAP] Rx Path Num Index : %d\n", (phy_spec->trx_cap & 0xFF));/*Rx Path Num Index [7:0]*/
#endif
#ifdef CONFIG_80211N_HT
RTW_PRINT_SEL(sel, "[DRV CAP] STBC Capability : 0x%04x\n", pregistry_priv->stbc_cap);
RTW_PRINT_SEL(sel, "[DRV CAP] HT STBC Tx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT5)) ? "V" : "X"); /*BIT5: Enable HT STBC Tx*/
RTW_PRINT_SEL(sel, "[DRV CAP] HT STBC Rx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT4)) ? "V" : "X"); /*BIT4: Enable HT STBC Rx*/
RTW_PRINT_SEL(sel, "[DRV CAP] VHT STBC Tx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT1)) ? "V" : "X"); /*BIT1: Enable VHT STBC Tx*/
RTW_PRINT_SEL(sel, "[DRV CAP] VHT STBC Rx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT0)) ? "V" : "X"); /*BIT0: Enable VHT STBC Rx*/
RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Tx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT10)) ? "V" : "X"); /*BIT10: Enable HE STBC Tx*/
RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Rx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT8)) ? "V" : "X"); /*BIT8: Enable HE STBC Rx*/
RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Tx(>80M) : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT11)) ? "V" : "X"); /*BIT11: Enable HE STBC Tx(>80M)*/
RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Rx(>80M) : %s\n\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT9)) ? "V" : "X"); /*BIT9: Enable HE STBC Rx(>80M)*/
RTW_PRINT_SEL(sel, "[DRV CAP] LDPC Capability : 0x%02x\n", pregistry_priv->ldpc_cap);
RTW_PRINT_SEL(sel, "[DRV CAP] VHT LDPC Tx : %s\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT1)) ? "V" : "X"); /*BIT1: Enable VHT LDPC Tx*/
RTW_PRINT_SEL(sel, "[DRV CAP] VHT LDPC Rx : %s\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT0)) ? "V" : "X"); /*BIT0: Enable VHT LDPC Rx*/
RTW_PRINT_SEL(sel, "[DRV CAP] HT LDPC Tx : %s\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT5)) ? "V" : "X"); /*BIT5: Enable HT LDPC Tx*/
RTW_PRINT_SEL(sel, "[DRV CAP] HT LDPC Rx : %s\n\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT4)) ? "V" : "X"); /*BIT4: Enable HT LDPC Rx*/
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_BEAMFORMING
#if 0
RTW_PRINT_SEL(sel, "[DRV CAP] TxBF parameter : 0x%08x\n", phy_spec->txbf_param);
RTW_PRINT_SEL(sel, "[DRV CAP] VHT Sounding Dim : %d\n", (phy_spec->txbf_param >> 24) & 0xFF); /*VHT Sounding Dim [31:24]*/
RTW_PRINT_SEL(sel, "[DRV CAP] VHT Steering Ant : %d\n", (phy_spec->txbf_param >> 16) & 0xFF); /*VHT Steering Ant [23:16]*/
RTW_PRINT_SEL(sel, "[DRV CAP] HT Sounding Dim : %d\n", (phy_spec->txbf_param >> 8) & 0xFF); /*HT Sounding Dim [15:8]*/
RTW_PRINT_SEL(sel, "[DRV CAP] HT Steering Ant : %d\n", phy_spec->txbf_param & 0xFF); /*HT Steering Ant [7:0]*/
#endif
/*
* BIT0: Enable VHT SU Beamformer
* BIT1: Enable VHT SU Beamformee
* BIT2: Enable VHT MU Beamformer, depend on VHT SU Beamformer
* BIT3: Enable VHT MU Beamformee, depend on VHT SU Beamformee
* BIT4: Enable HT Beamformer
* BIT5: Enable HT Beamformee
*/
RTW_PRINT_SEL(sel, "[DRV CAP] TxBF Capability : 0x%02x\n", pregistry_priv->beamform_cap);
RTW_PRINT_SEL(sel, "[DRV CAP] VHT MU Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT2)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DRV CAP] VHT MU Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT3)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DRV CAP] VHT SU Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT0)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DRV CAP] VHT SU Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT1)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DRV CAP] HT Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT4)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DRV CAP] HT Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT5)) ? "V" : "X");
RTW_PRINT_SEL(sel, "[DRV CAP] Tx Bfer rf_num : %d\n", pregistry_priv->beamformer_rf_num);
RTW_PRINT_SEL(sel, "[DRV CAP] Tx Bfee rf_num : %d\n", pregistry_priv->beamformee_rf_num);
#endif
}
int proc_get_stbc_cap(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "0x%04x\n", pregpriv->stbc_cap);
return 0;
}
ssize_t proc_set_stbc_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &mode);
if (num == 1 && pregpriv) {
pregpriv->stbc_cap = mode;
RTW_INFO("stbc_cap = 0x%02x\n", mode);
}
}
return count;
}
int proc_get_ldpc_cap(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->ldpc_cap);
return 0;
}
ssize_t proc_set_ldpc_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &mode);
if (num == 1 && pregpriv) {
pregpriv->ldpc_cap = mode;
RTW_INFO("ldpc_cap = 0x%02x\n", mode);
}
}
return count;
}
#ifdef CONFIG_BEAMFORMING
int proc_get_txbf_cap(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->beamform_cap);
return 0;
}
ssize_t proc_set_txbf_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 mode;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &mode);
if (num == 1 && pregpriv) {
pregpriv->beamform_cap = mode;
RTW_INFO("beamform_cap = 0x%02x\n", mode);
}
}
return count;
}
#endif
#endif /* CONFIG_80211N_HT */
/*int proc_get_rssi_disp(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
return 0;
}
*/
/*ssize_t proc_set_rssi_disp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 enable=0;
if (count < 1)
{
RTW_INFO("argument size is less than 1\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%x", &enable);
if (num != 1) {
RTW_INFO("invalid set_rssi_disp parameter!\n");
return count;
}
if(enable)
{
RTW_INFO("Linked info Function Enable\n");
padapter->bLinkInfoDump = enable ;
}
else
{
RTW_INFO("Linked info Function Disable\n");
padapter->bLinkInfoDump = 0 ;
}
}
return count;
}
*/
#ifdef CONFIG_AP_MODE
void dump_phl_tring_status(struct seq_file *m, _adapter *padapter, struct sta_info *psta)
{
int i = 0;
u16 tring_len = 0;
RTW_PRINT_SEL(m, "PHL_tring_len=");
for (i = 0; i < MAX_PHL_RING_CAT_NUM; i++) {
tring_len = rtw_phl_tring_rsc(padapter->dvobj->phl, psta->phl_sta->macid, i);
RTW_PRINT_SEL(m, "%d ", tring_len);
}
RTW_PRINT_SEL(m, "\n");
}
int proc_get_all_sta_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
struct sta_info *psta;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct sta_priv *pstapriv = &padapter->stapriv;
int i;
_list *plist, *phead;
RTW_MAP_DUMP_SEL_ALWAYS(m, "sta_dz_bitmap=", pstapriv->sta_dz_bitmap, pstapriv->aid_bmp_len);
RTW_MAP_DUMP_SEL_ALWAYS(m, "tim_bitmap=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len);
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
/* if(extra_arg == psta->phl_sta->aid) */
{
RTW_PRINT_SEL(m, "==============================\n");
RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
RTW_PRINT_SEL(m, "ieee8021x_blocked=%d\n", psta->ieee8021x_blocked);
RTW_PRINT_SEL(m, "rtsen=%d, cts2slef=%d, hw_rts_en=%d\n",
psta->rtsen, psta->cts2self, psta->hw_rts_en);
/* ToDo: need API to query hal_sta->ra_info.rate_id */
/* RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n",
psta->state, psta->phl_sta->aid, psta->phl_sta->macid, psta->phl_sta->hal_sta->ra_info.rate_id); */
RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d\n",
psta->state, psta->phl_sta->aid, psta->phl_sta->macid);
#ifdef CONFIG_RTS_FULL_BW
if(psta->vendor_8812)
RTW_PRINT_SEL(m,"Vendor Realtek 8812\n");
#endif/*CONFIG_RTS_FULL_BW*/
#ifdef CONFIG_80211N_HT
RTW_PRINT_SEL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
RTW_PRINT_SEL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n"
, psta->phl_sta->chandef.bw, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
RTW_PRINT_SEL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
RTW_PRINT_SEL(m, "tx_amsdu_enable = %d\n", psta->htpriv.tx_amsdu_enable);
RTW_PRINT_SEL(m, "Is_8K_AMSDU = %d\n", (psta->htpriv.ht_cap.cap_info & IEEE80211_HT_CAP_MAX_AMSDU)?1:0);
RTW_PRINT_SEL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
RTW_PRINT_SEL(m, "vht_en=%d, vht_sgi_80m=%d\n", psta->vhtpriv.vht_option, psta->vhtpriv.sgi_80m);
RTW_PRINT_SEL(m, "vht_ldpc_cap=0x%x, vht_stbc_cap=0x%x, vht_beamform_cap=0x%x\n", psta->vhtpriv.ldpc_cap, psta->vhtpriv.stbc_cap, psta->vhtpriv.beamform_cap);
RTW_PRINT_SEL(m, "vht_mcs_map=0x%x, vht_highest_rate=0x%x, vht_ampdu_len=%d\n", *(u16 *)psta->vhtpriv.vht_mcs_map, psta->vhtpriv.vht_highest_rate, psta->vhtpriv.ampdu_len);
if (psta->vhtpriv.vht_option) {
RTW_MAP_DUMP_SEL_ALWAYS(m, "vht_cap=", psta->vhtpriv.vht_cap, 32);
} else {
RTW_PRINT_SEL(m, "vht_cap=N/A\n");
}
#endif
#ifdef CONFIG_80211AX_HE
RTW_PRINT_SEL(m, "he_en=%d\n", psta->hepriv.he_option);
if (psta->hepriv.he_option) {
RTW_MAP_DUMP_SEL_ALWAYS(m, "he_cap=", psta->hepriv.he_cap, HE_CAP_ELE_MAX_LEN);
} else {
RTW_PRINT_SEL(m, "he_cap=N/A\n");
}
#endif
RTW_PRINT_SEL(m, "tx_nss=%d\n", rtw_get_sta_tx_nss(padapter, psta));
RTW_PRINT_SEL(m, "rx_nss=%d\n", rtw_get_sta_rx_nss(padapter, psta));
RTW_PRINT_SEL(m, "sleepq_len=%d\n", psta->sleepq_len);
RTW_PRINT_SEL(m, "sta_xmitpriv.vo_q_qcnt=%d\n", psta->sta_xmitpriv.vo_q.qcnt);
RTW_PRINT_SEL(m, "sta_xmitpriv.vi_q_qcnt=%d\n", psta->sta_xmitpriv.vi_q.qcnt);
RTW_PRINT_SEL(m, "sta_xmitpriv.be_q_qcnt=%d\n", psta->sta_xmitpriv.be_q.qcnt);
RTW_PRINT_SEL(m, "sta_xmitpriv.bk_q_qcnt=%d\n", psta->sta_xmitpriv.bk_q.qcnt);
RTW_PRINT_SEL(m, "capability=0x%x\n", psta->capability);
RTW_PRINT_SEL(m, "flags=0x%x\n", psta->flags);
RTW_PRINT_SEL(m, "isPMF=%d\n", (psta->flags & WLAN_STA_MFP)?1:0);
RTW_PRINT_SEL(m, "wpa_psk=0x%x\n", psta->wpa_psk);
RTW_PRINT_SEL(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
RTW_PRINT_SEL(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
RTW_PRINT_SEL(m, "qos_info=0x%x\n", psta->qos_info);
RTW_PRINT_SEL(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
RTW_PRINT_SEL(m, "AuthAlgrthm=0x%x\n", psta->authalg);
#ifdef CONFIG_RECV_REORDERING_CTRL
sta_rx_reorder_ctl_dump(m, psta);
#endif
#ifdef CONFIG_TDLS
RTW_PRINT_SEL(m, "tdls_sta_state=0x%08x\n", psta->tdls_sta_state);
RTW_PRINT_SEL(m, "PeerKey_Lifetime=%d\n", psta->TDLS_PeerKey_Lifetime);
#endif /* CONFIG_TDLS */
if(psta->bssratelen >= 0 && psta->bssratelen <= 16)
RTW_MAP_DUMP_SEL_ALWAYS(m, "bssrateset=", psta->bssrateset, psta->bssratelen);
RTW_PRINT_SEL(m, "rx_data_uc_pkts=%llu\n", sta_rx_data_uc_pkts(psta));
RTW_PRINT_SEL(m, "rx_data_mc_pkts=%llu\n", psta->sta_stats.rx_data_mc_pkts);
RTW_PRINT_SEL(m, "rx_data_bc_pkts=%llu\n", psta->sta_stats.rx_data_bc_pkts);
RTW_PRINT_SEL(m, "rx_uc_bytes=%llu\n", sta_rx_uc_bytes(psta));
RTW_PRINT_SEL(m, "rx_mc_bytes=%llu\n", psta->sta_stats.rx_mc_bytes);
RTW_PRINT_SEL(m, "rx_bc_bytes=%llu\n", psta->sta_stats.rx_bc_bytes);
if (psta->sta_stats.rx_tp_kbits >> 10)
RTW_PRINT_SEL(m, "rx_tp =%d (Mbps)\n", psta->sta_stats.rx_tp_kbits >> 10);
else
RTW_PRINT_SEL(m, "rx_tp =%d (Kbps)\n", psta->sta_stats.rx_tp_kbits);
RTW_PRINT_SEL(m, "tx_data_pkts=%llu\n", psta->sta_stats.tx_pkts);
RTW_PRINT_SEL(m, "tx_bytes=%llu\n", psta->sta_stats.tx_bytes);
if (psta->sta_stats.tx_tp_kbits >> 10)
RTW_PRINT_SEL(m, "tx_tp =%d (Mbps)\n", psta->sta_stats.tx_tp_kbits >> 10);
else
RTW_PRINT_SEL(m, "tx_tp =%d (Kbps)\n", psta->sta_stats.tx_tp_kbits);
#ifdef CONFIG_RTW_80211K
RTW_PRINT_SEL(m, "rm_en_cap="RM_CAP_FMT"\n", RM_CAP_ARG(psta->rm_en_cap));
#endif
dump_st_ctl(m, &psta->st_ctl);
if (STA_OP_WFD_MODE(psta))
RTW_PRINT_SEL(m, "op_wfd_mode:0x%02x\n", STA_OP_WFD_MODE(psta));
dump_phl_tring_status(m, padapter, psta);
RTW_PRINT_SEL(m, "==============================\n");
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
return 0;
}
#endif
#ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
int proc_get_rtkm_info(struct seq_file *m, void *v)
{
RTW_PRINT_SEL(m, "============[RTKM Info]============\n");
RTW_PRINT_SEL(m, "MAX_RTKM_NR_PREALLOC_RECV_SKB: %d\n", rtw_rtkm_get_nr_recv_skb());
RTW_PRINT_SEL(m, "MAX_RTKM_RECVBUF_SZ: %d\n", rtw_rtkm_get_buff_size());
RTW_PRINT_SEL(m, "============[Driver Info]============\n");
return 0;
}
#endif /* CONFIG_PREALLOC_RX_SKB_BUFFER */
#ifdef DBG_MEMORY_LEAK
#include <asm/atomic.h>
extern ATOMIC_T _malloc_cnt;
extern ATOMIC_T _malloc_size;
int proc_get_malloc_cnt(struct seq_file *m, void *v)
{
RTW_PRINT_SEL(m, "_malloc_cnt=%d\n", atomic_read(&_malloc_cnt));
RTW_PRINT_SEL(m, "_malloc_size=%d\n", atomic_read(&_malloc_size));
return 0;
}
#endif /* DBG_MEMORY_LEAK */
#ifdef CONFIG_FIND_BEST_CHANNEL
int proc_get_best_channel(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++) {
if (rfctl->channel_set[i].ChannelNum == 1)
index_24G = i;
if (rfctl->channel_set[i].ChannelNum == 36)
index_5G = i;
}
for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++) {
/* 2.4G */
if (rfctl->channel_set[i].ChannelNum == 6) {
if (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_24G].rx_count) {
index_24G = i;
best_channel_24G = rfctl->channel_set[i].ChannelNum;
}
}
/* 5G */
if (rfctl->channel_set[i].ChannelNum >= 36
&& rfctl->channel_set[i].ChannelNum < 140) {
/* Find primary channel */
if (((rfctl->channel_set[i].ChannelNum - 36) % 8 == 0)
&& (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_5G].rx_count)) {
index_5G = i;
best_channel_5G = rfctl->channel_set[i].ChannelNum;
}
}
if (rfctl->channel_set[i].ChannelNum >= 149
&& rfctl->channel_set[i].ChannelNum < 165) {
/* find primary channel */
if (((rfctl->channel_set[i].ChannelNum - 149) % 8 == 0)
&& (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_5G].rx_count)) {
index_5G = i;
best_channel_5G = rfctl->channel_set[i].ChannelNum;
}
}
#if 1 /* debug */
RTW_PRINT_SEL(m, "The rx cnt of channel %3d = %d\n",
rfctl->channel_set[i].ChannelNum, rfctl->channel_set[i].rx_count);
#endif
}
RTW_PRINT_SEL(m, "best_channel_5G = %d\n", best_channel_5G);
RTW_PRINT_SEL(m, "best_channel_24G = %d\n", best_channel_24G);
return 0;
}
ssize_t proc_set_best_channel(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
char tmp[32];
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int i;
for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++)
rfctl->channel_set[i].rx_count = 0;
RTW_INFO("set %s\n", "Clean Best Channel Count");
}
return count;
}
#endif /* CONFIG_FIND_BEST_CHANNEL */
#ifdef CONFIG_BTC
int proc_get_btc_dbg(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter;
char buf[512] = {0};
padapter = (_adapter *)rtw_netdev_priv(dev);
rtw_btc_get_dbg(padapter, buf, 512);
_RTW_PRINT_SEL(m, "%s", buf);
return 0;
}
ssize_t proc_set_btc_dbg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter;
u8 tmp[80] = {0};
u32 module[2] = {0};
u32 num;
padapter = (_adapter *)rtw_netdev_priv(dev);
/* RTW_INFO("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter)); */
if (NULL == buffer) {
RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n",
FUNC_ADPT_ARG(padapter));
return -EFAULT;
}
if (count < 1) {
RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n",
FUNC_ADPT_ARG(padapter));
return -EFAULT;
}
num = count;
if (num > (sizeof(tmp) - 1))
num = (sizeof(tmp) - 1);
if (copy_from_user(tmp, buffer, num)) {
RTW_INFO(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
FUNC_ADPT_ARG(padapter));
return -EFAULT;
}
num = sscanf(tmp, "%x %x", module, module + 1);
if (1 == num) {
if (0 == module[0])
_rtw_memset(module, 0, sizeof(module));
else
_rtw_memset(module, 0xFF, sizeof(module));
} else if (2 != num) {
RTW_INFO(FUNC_ADPT_FMT ": input(\"%s\") format incorrect!\n",
FUNC_ADPT_ARG(padapter), tmp);
if (0 == num)
return -EFAULT;
}
RTW_INFO(FUNC_ADPT_FMT ": input 0x%08X 0x%08X\n",
FUNC_ADPT_ARG(padapter), module[0], module[1]);
rtw_btc_set_dbg(padapter, module);
return count;
}
int proc_get_btc_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter;
padapter = (_adapter *)rtw_netdev_priv(dev);
rtw_btc_disp_btc_info(padapter, (void*)m, 0);
return 0;
}
#endif /* CONFIG_BTC */
#if defined(DBG_CONFIG_ERROR_DETECT)
int proc_get_sreset(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
HAL_DATA_TYPE *pHalData = GET_PHL_COM(psdpriv);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
if (psrtpriv->dbg_sreset_ctrl == _TRUE) {
RTW_PRINT_SEL(m, "self_dect_tx_cnt:%llu\n", psrtpriv->self_dect_tx_cnt);
RTW_PRINT_SEL(m, "self_dect_rx_cnt:%llu\n", psrtpriv->self_dect_rx_cnt);
RTW_PRINT_SEL(m, "self_dect_fw_cnt:%llu\n", psrtpriv->self_dect_fw_cnt);
RTW_PRINT_SEL(m, "tx_dma_status_cnt:%llu\n", psrtpriv->tx_dma_status_cnt);
RTW_PRINT_SEL(m, "rx_dma_status_cnt:%llu\n", psrtpriv->rx_dma_status_cnt);
RTW_PRINT_SEL(m, "self_dect_case:%d\n", psrtpriv->self_dect_case);
RTW_PRINT_SEL(m, "dbg_sreset_cnt:%d\n", pdbgpriv->dbg_sreset_cnt);
}
return 0;
}
ssize_t proc_set_sreset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(adapter_to_dvobj(padapter));
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
char tmp[32];
s32 trigger_point;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d", &trigger_point);
if (num < 1)
return count;
if (trigger_point == SRESET_TGP_NULL)
rtw_hal_sreset_reset(padapter);
else if (trigger_point == SRESET_TGP_INFO)
psrtpriv->dbg_sreset_ctrl = _TRUE;
else
sreset_set_trigger_point(padapter, trigger_point);
}
return count;
}
#endif /* DBG_CONFIG_ERROR_DETECT */
#ifdef CONFIG_PCI_HCI
ssize_t proc_set_pci_bridge_conf_space(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
struct pci_dev *pdev = pci_data->ppcidev;
struct pci_dev *bridge_pdev = pdev->bus->self;
char tmp[32] = { 0 };
int num;
u32 reg = 0, value = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
num = sscanf(tmp, "%x %x", ®, &value);
if (num != 2) {
RTW_INFO("invalid parameter!\n");
return count;
}
if (reg >= 0x1000) {
RTW_INFO("invalid register!\n");
return count;
}
if (value > 0xFF) {
RTW_INFO("invalid value! Only one byte\n");
return count;
}
RTW_INFO(FUNC_ADPT_FMT ": register 0x%x value 0x%x\n",
FUNC_ADPT_ARG(padapter), reg, value);
pci_write_config_byte(bridge_pdev, reg, value);
}
return count;
}
int proc_get_pci_bridge_conf_space(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
struct pci_dev *pdev = pci_data->ppcidev;
struct pci_dev *bridge_pdev = pdev->bus->self;
u32 tmp[4] = { 0 };
u32 i, j;
RTW_PRINT_SEL(m, "\n***** PCI Host Device Configuration Space*****\n\n");
for (i = 0; i < 0x1000; i += 0x10) {
for (j = 0 ; j < 4 ; j++)
pci_read_config_dword(bridge_pdev, i + j * 4, tmp+j);
RTW_PRINT_SEL(m, "%03x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
i, tmp[0] & 0xFF, (tmp[0] >> 8) & 0xFF, (tmp[0] >> 16) & 0xFF, (tmp[0] >> 24) & 0xFF,
tmp[1] & 0xFF, (tmp[1] >> 8) & 0xFF, (tmp[1] >> 16) & 0xFF, (tmp[1] >> 24) & 0xFF,
tmp[2] & 0xFF, (tmp[2] >> 8) & 0xFF, (tmp[2] >> 16) & 0xFF, (tmp[2] >> 24) & 0xFF,
tmp[3] & 0xFF, (tmp[3] >> 8) & 0xFF, (tmp[3] >> 16) & 0xFF, (tmp[3] >> 24) & 0xFF);
}
return 0;
}
ssize_t proc_set_pci_conf_space(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
struct pci_dev *pdev = pci_data->ppcidev;
char tmp[32] = { 0 };
int num;
u32 reg = 0, value = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
num = sscanf(tmp, "%x %x", ®, &value);
if (num != 2) {
RTW_INFO("invalid parameter!\n");
return count;
}
if (reg >= 0x1000) {
RTW_INFO("invalid register!\n");
return count;
}
if (value > 0xFF) {
RTW_INFO("invalid value! Only one byte\n");
return count;
}
RTW_INFO(FUNC_ADPT_FMT ": register 0x%x value 0x%x\n",
FUNC_ADPT_ARG(padapter), reg, value);
pci_write_config_byte(pdev, reg, value);
}
return count;
}
int proc_get_pci_conf_space(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
struct pci_dev *pdev = pci_data->ppcidev;
struct pci_dev *bridge_pdev = pdev->bus->self;
u32 tmp[4] = { 0 };
u32 i, j;
RTW_PRINT_SEL(m, "\n***** PCI Device Configuration Space *****\n\n");
for (i = 0; i < 0x1000; i += 0x10) {
for (j = 0 ; j < 4 ; j++)
pci_read_config_dword(pdev, i + j * 4, tmp+j);
RTW_PRINT_SEL(m, "%03x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
i, tmp[0] & 0xFF, (tmp[0] >> 8) & 0xFF, (tmp[0] >> 16) & 0xFF, (tmp[0] >> 24) & 0xFF,
tmp[1] & 0xFF, (tmp[1] >> 8) & 0xFF, (tmp[1] >> 16) & 0xFF, (tmp[1] >> 24) & 0xFF,
tmp[2] & 0xFF, (tmp[2] >> 8) & 0xFF, (tmp[2] >> 16) & 0xFF, (tmp[2] >> 24) & 0xFF,
tmp[3] & 0xFF, (tmp[3] >> 8) & 0xFF, (tmp[3] >> 16) & 0xFF, (tmp[3] >> 24) & 0xFF);
}
return 0;
}
int proc_get_pci_aspm(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
struct pci_priv *pcipriv = &(pci_data->pcipriv);
u8 tmp8 = 0;
u16 tmp16 = 0;
u32 tmp32 = 0;
u8 l1_idle = 0;
RTW_PRINT_SEL(m, "***** ASPM Capability *****\n");
pci_read_config_dword(pci_data->ppcidev, pcipriv->pciehdr_offset + PCI_EXP_LNKCAP, &tmp32);
RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp32&PCI_EXP_LNKCAP_CLKPM) ? "Enable" : "Disable");
RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp32&BIT10) ? "Enable" : "Disable");
RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp32&BIT11) ? "Enable" : "Disable");
tmp8 = rtw_hal_pci_l1off_capability(padapter);
RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", tmp8 ? "Enable" : "Disable");
RTW_PRINT_SEL(m, "***** ASPM CTRL Reg *****\n");
pci_read_config_word(pci_data->ppcidev, pcipriv->pciehdr_offset + PCI_EXP_LNKCTL, &tmp16);
RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp16&PCI_EXP_LNKCTL_CLKREQ_EN) ? "Enable" : "Disable");
RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp16&BIT0) ? "Enable" : "Disable");
RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp16&BIT1) ? "Enable" : "Disable");
tmp8 = rtw_hal_pci_l1off_nic_support(padapter);
RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", tmp8 ? "Enable" : "Disable");
RTW_PRINT_SEL(m, "***** ASPM Backdoor *****\n");
tmp8 = rtw_hal_pci_dbi_read(padapter, 0x719);
RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp8 & BIT4) ? "Enable" : "Disable");
tmp8 = rtw_hal_pci_dbi_read(padapter, 0x70f);
l1_idle = tmp8 & 0x38;
RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp8&BIT7) ? "Enable" : "Disable");
tmp8 = rtw_hal_pci_dbi_read(padapter, 0x719);
RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp8 & BIT3) ? "Enable" : "Disable");
tmp8 = rtw_hal_pci_dbi_read(padapter, 0x718);
RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", (tmp8 & BIT5) ? "Enable" : "Disable");
RTW_PRINT_SEL(m, "********* MISC **********\n");
RTW_PRINT_SEL(m, "ASPM L1 Idel Time: 0x%x\n", l1_idle>>3);
RTW_PRINT_SEL(m, "*************************\n");
#ifdef CONFIG_PCI_DYNAMIC_ASPM
RTW_PRINT_SEL(m, "Dynamic ASPM mode: %d (%s)\n", pcipriv->aspm_mode,
pcipriv->aspm_mode == ASPM_MODE_PERF ? "Perf" :
pcipriv->aspm_mode == ASPM_MODE_PS ? "PS" : "Und");
#endif
return 0;
}
int proc_get_rx_ring(struct seq_file *m, void *v)
{
return 0;
}
int proc_get_tx_ring(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
int i, j, k;
unsigned long sp_flags;
_rtw_spinlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
for (i = 0; i < PCI_MAX_TX_QUEUE_COUNT; i++) {
struct rtw_tx_ring *tx_ring = &pxmitpriv->tx_ring[i];
RTW_PRINT_SEL(m, "tx ring[%d] (%p)\n", i, tx_ring);
RTW_PRINT_SEL(m, " dma: 0x%08x\n", (int) tx_ring->dma);
RTW_PRINT_SEL(m, " idx: %d\n", tx_ring->idx);
RTW_PRINT_SEL(m, " entries: %d\n", tx_ring->entries);
/* RTW_PRINT_SEL(m, " queue: %d\n", tx_ring->queue); */
RTW_PRINT_SEL(m, " qlen: %d\n", tx_ring->qlen);
for (j = 0; j < pxmitpriv->txringcount[i]; j++) {
#ifdef CONFIG_TRX_BD_ARCH
struct tx_buf_desc *entry = &tx_ring->buf_desc[j];
RTW_PRINT_SEL(m, " buf_desc[%03d]: %p\n", j, entry);
#else
struct tx_desc *entry = &tx_ring->desc[j];
RTW_PRINT_SEL(m, " desc[%03d]: %p\n", j, entry);
#endif
for (k = 0; k < sizeof(*entry) / 4; k++) {
if ((k % 4) == 0)
RTW_PRINT_SEL(m, " 0x%03x", k);
RTW_PRINT_SEL(m, " 0x%08x ", ((int *) entry)[k]);
if ((k % 4) == 3)
RTW_PRINT_SEL(m, "\n");
}
}
}
_rtw_spinunlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
return 0;
}
#ifdef DBG_TXBD_DESC_DUMP
int proc_get_tx_ring_ext(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct rtw_tx_desc_backup *pbuf;
int i, j, k, idx;
unsigned long sp_flags;
RTW_PRINT_SEL(m, "<<<< tx ring ext dump settings >>>>\n");
RTW_PRINT_SEL(m, " - backup frame num: %d\n", TX_BAK_FRMAE_CNT);
RTW_PRINT_SEL(m, " - backup max. desc size: %d bytes\n", TX_BAK_DESC_LEN);
RTW_PRINT_SEL(m, " - backup data size: %d bytes\n\n", TX_BAK_DATA_LEN);
if (!pxmitpriv->dump_txbd_desc) {
RTW_PRINT_SEL(m, "Dump function is disabled.\n");
return 0;
}
_rtw_spinlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
for (i = 0; i < HW_QUEUE_ENTRY; i++) {
struct rtw_tx_ring *tx_ring = &pxmitpriv->tx_ring[i];
idx = rtw_get_tx_desc_backup(padapter, i, &pbuf);
RTW_PRINT_SEL(m, "Tx ring[%d]", i);
switch (i) {
case 0:
RTW_PRINT_SEL(m, " (VO)\n");
break;
case 1:
RTW_PRINT_SEL(m, " (VI)\n");
break;
case 2:
RTW_PRINT_SEL(m, " (BE)\n");
break;
case 3:
RTW_PRINT_SEL(m, " (BK)\n");
break;
case 4:
RTW_PRINT_SEL(m, " (BCN)\n");
break;
case 5:
RTW_PRINT_SEL(m, " (MGT)\n");
break;
case 6:
RTW_PRINT_SEL(m, " (HIGH)\n");
break;
case 7:
RTW_PRINT_SEL(m, " (TXCMD)\n");
break;
default:
RTW_PRINT_SEL(m, " (?)\n");
break;
}
RTW_PRINT_SEL(m, " Entries: %d\n", TX_BAK_FRMAE_CNT);
RTW_PRINT_SEL(m, " Last idx: %d\n", idx);
for (j = 0; j < TX_BAK_FRMAE_CNT; j++) {
RTW_PRINT_SEL(m, " desc[%03d]:\n", j);
for (k = 0; k < (pbuf->tx_desc_size) / 4; k++) {
if ((k % 4) == 0)
RTW_PRINT_SEL(m, " 0x%03x", k);
RTW_PRINT_SEL(m, " 0x%08x ", ((int *)pbuf->tx_bak_desc)[k]);
if ((k % 4) == 3)
RTW_PRINT_SEL(m, "\n");
}
#if 1 /* data dump */
if (pbuf->tx_desc_size) {
RTW_PRINT_SEL(m, " data[%03d]:\n", j);
for (k = 0; k < (TX_BAK_DATA_LEN) / 4; k++) {
if ((k % 4) == 0)
RTW_PRINT_SEL(m, " 0x%03x", k);
RTW_PRINT_SEL(m, " 0x%08x ", ((int *)pbuf->tx_bak_data_hdr)[k]);
if ((k % 4) == 3)
RTW_PRINT_SEL(m, "\n");
}
RTW_PRINT_SEL(m, "\n");
}
#endif
RTW_PRINT_SEL(m, " R/W pointer: %d/%d\n", pbuf->tx_bak_rp, pbuf->tx_bak_wp);
pbuf = pbuf + 1;
}
RTW_PRINT_SEL(m, "\n");
}
_rtw_spinunlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
return 0;
}
ssize_t proc_set_tx_ring_ext(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
char tmp[32];
u32 reset = 0;
u32 dump = 0;
unsigned long sp_flags;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u %u", &dump, &reset);
if (num != 2) {
RTW_INFO("invalid parameter!\n");
return count;
}
_rtw_spinlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
pxmitpriv->dump_txbd_desc = (BOOLEAN) dump;
if (reset == 1)
rtw_tx_desc_backup_reset();
_rtw_spinunlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
}
return count;
}
#endif
#endif
#ifdef CONFIG_WOWLAN
int proc_get_wow_enable(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *registry_pair = &padapter->registrypriv;
RTW_PRINT_SEL(m, "wow - %s\n", (registry_pair->wowlan_enable)? "enable" : "disable");
return 0;
}
ssize_t proc_set_wow_enable(struct file *file, const char __user *buffer,
size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *registry_pair = &padapter->registrypriv;
char tmp[8];
int num = 0;
int mode = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count))
num = sscanf(tmp, "%d", &mode);
else
return -EFAULT;
if (num != 1) {
RTW_ERR("%s: %s - invalid parameter!\n", __func__, tmp);
return -EINVAL;
}
if (mode == 1) {
RTW_PRINT("%s: wowlan - enable\n", __func__);
} else if (mode == 0) {
RTW_PRINT("%s: wowlan - disable\n", __func__);
} else {
RTW_ERR("%s: %s - invalid parameter!, mode=%d\n",
__func__, tmp, mode);
return -EINVAL;
}
registry_pair->wowlan_enable = mode;
return count;
}
int proc_get_pattern_info(struct seq_file *m, void *v)
{
// TODO(jw.hou): Get pattern info from PHL.
#if 0
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
u8 val8;
char str_1[128];
char *p_str;
int i = 0 , j = 0, k = 0;
int len = 0, max_len = 0, total = 0;
p_str = str_1;
max_len = sizeof(str_1);
total = pwrpriv->wowlan_pattern_idx;
rtw_set_default_pattern(padapter);
/*show pattern*/
RTW_PRINT_SEL(m, "\n======[Pattern Info.]======\n");
RTW_PRINT_SEL(m, "pattern number: %d\n", total);
RTW_PRINT_SEL(m, "support default patterns: %c\n",
(pwrpriv->default_patterns_en) ? 'Y' : 'N');
for (k = 0; k < total ; k++) {
RTW_PRINT_SEL(m, "\npattern idx: %d\n", k);
RTW_PRINT_SEL(m, "pattern content:\n");
p_str = str_1;
max_len = sizeof(str_1);
for (i = 0 ; i < MAX_WKFM_PATTERN_SIZE / 8 ; i++) {
_rtw_memset(p_str, 0, max_len);
len = 0;
for (j = 0 ; j < 8 ; j++) {
val8 = pwrpriv->patterns[k].content[i * 8 + j];
len += snprintf(p_str + len, max_len - len,
"%02x ", val8);
}
RTW_PRINT_SEL(m, "%s\n", p_str);
}
RTW_PRINT_SEL(m, "\npattern mask:\n");
for (i = 0 ; i < MAX_WKFM_SIZE / 8 ; i++) {
_rtw_memset(p_str, 0, max_len);
len = 0;
for (j = 0 ; j < 8 ; j++) {
val8 = pwrpriv->patterns[k].mask[i * 8 + j];
len += snprintf(p_str + len, max_len - len,
"%02x ", val8);
}
RTW_PRINT_SEL(m, "%s\n", p_str);
}
RTW_PRINT_SEL(m, "\npriv_pattern_len:\n");
RTW_PRINT_SEL(m, "pattern_len: %d\n", pwrpriv->patterns[k].len);
RTW_PRINT_SEL(m, "*****************\n");
}
#endif
return 0;
}
ssize_t proc_set_pattern_info(struct file *file, const char __user *buffer,
size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *registry_par = &adapter->registrypriv;
struct rtw_wowcam_upd_info wowcam_info = {0};
u8 tmp[MAX_WKFM_PATTERN_STR_LEN + 1] = {0};
if (!(registry_par->wakeup_event & BIT(3))) {
RTW_INFO("%s: customized pattern disabled, wakeup_event: %#2x\n",
__func__, registry_par->wakeup_event);
return -EOPNOTSUPP;
}
if (count < 1)
return -EINVAL;
if (count >= sizeof(tmp)) {
RTW_ERR("%s: pattern string is too long, count=%zu\n",
__func__, count);
return -EINVAL;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
if (strncmp(tmp, "clean", 5) == 0) {
rtw_wow_pattern_clean(adapter, RTW_CUSTOMIZED_PATTERN);
} else {
if (rtw_wowlan_parser_pattern_cmd(tmp,
wowcam_info.ptrn,
&wowcam_info.ptrn_len,
wowcam_info.mask)) {
if (_FAIL == rtw_wow_pattern_set(adapter,
&wowcam_info,
RTW_CUSTOMIZED_PATTERN))
return -EFAULT;
} else {
return -EINVAL;
}
}
} else {
rtw_warn_on(1);
return -EFAULT;
}
return count;
}
int proc_get_wakeup_event(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *registry_par = &padapter->registrypriv;
RTW_PRINT_SEL(m, "wakeup event: %#02x\n", registry_par->wakeup_event);
return 0;
}
ssize_t proc_set_wakeup_event(struct file *file, const char __user *buffer,
size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
struct registry_priv *registry_par = &padapter->registrypriv;
u32 wakeup_event = 0;
u8 tmp[8] = {0};
int num = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count))
num = sscanf(tmp, "%u", &wakeup_event);
else
return -EFAULT;
if (num == 1 && wakeup_event <= 0x1f) {
registry_par->wakeup_event = wakeup_event;
if (!(wakeup_event & BIT(1)))
rtw_wow_pattern_clean(padapter, RTW_DEFAULT_PATTERN);
if (!(wakeup_event & BIT(3)))
rtw_wow_pattern_clean(padapter, RTW_CUSTOMIZED_PATTERN);
RTW_INFO("%s: wakeup_event: %#2x\n",
__func__, registry_par->wakeup_event);
} else {
return -EINVAL;
}
return count;
}
int proc_get_wakeup_reason(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
u8 val = pwrpriv->wowlan_last_wake_reason;
RTW_PRINT_SEL(m, "last wake reason: %#02x\n", val);
return 0;
}
#endif /*CONFIG_WOWLAN*/
#ifdef CONFIG_GPIO_WAKEUP
int proc_get_wowlan_gpio_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct wow_priv *wowpriv = adapter_to_wowlan(padapter);
struct rtw_wow_gpio_info *wow_gpio = &wowpriv->wow_gpio;
RTW_PRINT_SEL(m, "wakeup_gpio_idx: %d\n", WAKEUP_GPIO_IDX);
RTW_PRINT_SEL(m, "high_active: %d\n", wow_gpio->gpio_active);
return 0;
}
ssize_t proc_set_wowlan_gpio_info(struct file *file, const char __user *buffer,
size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
void *phl = GET_PHL_INFO(dvobj);
enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
struct wow_priv *wowpriv = adapter_to_wowlan(padapter);
struct rtw_wow_gpio_info *wow_gpio = &wowpriv->wow_gpio;
char tmp[32] = {0};
int num = 0;
u32 is_high_active = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
num = sscanf(tmp, "%u", &is_high_active);
if (num != 1) {
RTW_INFO("Invalid format\n");
return count;
}
wow_gpio->dev2hst_high = is_high_active == 0 ? 1 : 0;
wow_gpio->gpio_active = is_high_active;
rtw_ps_deny(padapter, PS_DENY_IOCTL);
LeaveAllPowerSaveModeDirect(padapter);
status = rtw_phl_cfg_wow_sw_gpio_ctrl(phl, wow_gpio);
rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
RTW_INFO("set %s %d\n", "gpio_high_active",
wow_gpio->gpio_active);
RTW_INFO("%s: set GPIO_%d %d as default. status=%d\n",
__func__, WAKEUP_GPIO_IDX, wow_gpio->dev2hst_high, status);
}
return count;
}
#endif /* CONFIG_GPIO_WAKEUP */
#ifdef CONFIG_P2P_WOWLAN
int proc_get_p2p_wowlan_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
struct p2p_wowlan_info peerinfo = pwdinfo->p2p_wow_info;
if (_TRUE == peerinfo.is_trigger) {
RTW_PRINT_SEL(m, "is_trigger: TRUE\n");
switch (peerinfo.wowlan_recv_frame_type) {
case P2P_WOWLAN_RECV_NEGO_REQ:
RTW_PRINT_SEL(m, "Frame Type: Nego Request\n");
break;
case P2P_WOWLAN_RECV_INVITE_REQ:
RTW_PRINT_SEL(m, "Frame Type: Invitation Request\n");
break;
case P2P_WOWLAN_RECV_PROVISION_REQ:
RTW_PRINT_SEL(m, "Frame Type: Provision Request\n");
break;
default:
break;
}
RTW_PRINT_SEL(m, "Peer Addr: "MAC_FMT"\n", MAC_ARG(peerinfo.wowlan_peer_addr));
RTW_PRINT_SEL(m, "Peer WPS Config: %x\n", peerinfo.wowlan_peer_wpsconfig);
RTW_PRINT_SEL(m, "Persistent Group: %d\n", peerinfo.wowlan_peer_is_persistent);
RTW_PRINT_SEL(m, "Intivation Type: %d\n", peerinfo.wowlan_peer_invitation_type);
} else
RTW_PRINT_SEL(m, "is_trigger: False\n");
return 0;
}
#endif /* CONFIG_P2P_WOWLAN */
#ifdef CONFIG_POWER_SAVING
int proc_get_ps_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
u8 ips_mode = pwrpriv->ips_mode_req;
u8 lps_mode = pwrpriv->power_mgnt;
u8 lps_level = pwrpriv->lps_level;
#ifdef CONFIG_LPS_1T1R
u8 lps_1t1r = pwrpriv->lps_1t1r;
#endif
#ifdef CONFIG_WOWLAN
u8 wow_lps_mode = pwrpriv->wowlan_power_mgmt;
u8 wow_lps_level = pwrpriv->wowlan_lps_level;
#ifdef CONFIG_LPS_1T1R
u8 wow_lps_1t1r = pwrpriv->wowlan_lps_1t1r;
#endif
#endif /* CONFIG_WOWLAN */
char *str = "";
RTW_PRINT_SEL(m, "======Power Saving Info:======\n");
RTW_PRINT_SEL(m, "*IPS:\n");
if (ips_mode == IPS_NORMAL) {
#ifdef CONFIG_FWLPS_IN_IPS
str = "FW_LPS_IN_IPS";
#else
str = "Card Disable";
#endif
} else if (ips_mode == IPS_NONE)
str = "NO IPS";
else if (ips_mode == IPS_LEVEL_2)
str = "IPS_LEVEL_2";
else
str = "invalid ips_mode";
RTW_PRINT_SEL(m, " IPS mode: %s\n", str);
RTW_PRINT_SEL(m, " IPS enter count:%d, IPS leave count:%d\n",
pwrpriv->ips_enter_cnts, pwrpriv->ips_leave_cnts);
RTW_PRINT_SEL(m, "------------------------------\n");
RTW_PRINT_SEL(m, "*LPS:\n");
if (lps_mode == PM_PS_MODE_ACTIVE)
str = "NO LPS";
else if (lps_mode == PM_PS_MODE_MIN)
str = "MIN";
else if (lps_mode == PM_PS_MODE_MAX)
str = "MAX";
else if (lps_mode == PM_PS_MODE_DTIM)
str = "DTIM";
else
sprintf(str, "%d", lps_mode);
RTW_PRINT_SEL(m, " LPS mode: %s\n", str);
if (pwrpriv->dtim != 0)
RTW_PRINT_SEL(m, " DTIM: %d\n", pwrpriv->dtim);
RTW_PRINT_SEL(m, " LPS enter count:%d, LPS leave count:%d\n",
pwrpriv->lps_enter_cnts, pwrpriv->lps_leave_cnts);
if (lps_level == LPS_LCLK)
str = "LPS_LCLK";
else if (lps_level == LPS_PG)
str = "LPS_PG";
else
str = "LPS_NORMAL";
RTW_PRINT_SEL(m, " LPS level: %s\n", str);
#ifdef CONFIG_LPS_1T1R
RTW_PRINT_SEL(m, " LPS 1T1R: %d\n", lps_1t1r);
#endif
#ifdef CONFIG_WOWLAN
RTW_PRINT_SEL(m, "------------------------------\n");
RTW_PRINT_SEL(m, "*WOW LPS:\n");
if (wow_lps_mode == PM_PS_MODE_ACTIVE)
str = "NO LPS";
else if (wow_lps_mode == PM_PS_MODE_MIN)
str = "MIN";
else if (wow_lps_mode == PM_PS_MODE_MAX)
str = "MAX";
else if (wow_lps_mode == PM_PS_MODE_DTIM)
str = "DTIM";
else
sprintf(str, "%d", wow_lps_mode);
RTW_PRINT_SEL(m, " WOW LPS mode: %s\n", str);
if (wow_lps_level == LPS_LCLK)
str = "LPS_LCLK";
else if (wow_lps_level == LPS_PG)
str = "LPS_PG";
else
str = "LPS_NORMAL";
RTW_PRINT_SEL(m, " WOW LPS level: %s\n", str);
#ifdef CONFIG_LPS_1T1R
RTW_PRINT_SEL(m, " WOW LPS 1T1R: %d\n", wow_lps_1t1r);
#endif
#endif /* CONFIG_WOWLAN */
RTW_PRINT_SEL(m, "=============================\n");
return 0;
}
ssize_t proc_set_ps_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[8];
int num = 0;
int mode = 0;
int en = 0;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (!buffer || copy_from_user(tmp, buffer, count))
goto exit;
num = sscanf(tmp, "%d %d", &mode, &en);
if (num > 2) {
RTW_ERR("%s: invalid parameter!\n", __FUNCTION__);
goto exit;
}
if (num == 1 && mode == 0) {
/* back to original LPS/IPS Mode */
RTW_INFO("%s: back to original LPS/IPS Mode\n", __FUNCTION__);
rtw_pm_set_lps(adapter, adapter->registrypriv.power_mgnt);
rtw_pm_set_ips(adapter, adapter->registrypriv.ips_mode);
#ifdef CONFIG_WOWLAN
RTW_INFO("%s: back to original WOW LPS Mode\n", __FUNCTION__);
rtw_pm_set_wow_lps(adapter, adapter->registrypriv.wow_power_mgnt);
#endif /* CONFIG_WOWLAN */
goto exit;
}
if (mode == 1) {
/* LPS */
RTW_INFO("%s: LPS: %s, en=%d\n", __FUNCTION__, (en == 0) ? "disable":"enable", en);
if (rtw_pm_set_lps(adapter, en) != 0 )
RTW_ERR("%s: invalid parameter, mode=%d, level=%d\n", __FUNCTION__, mode, en);
} else if (mode == 2) {
/* IPS */
RTW_INFO("%s: IPS: %s, en=%d\n", __FUNCTION__, (en == 0) ? "disable":"enable", en);
if (rtw_pm_set_ips(adapter, en) != 0 )
RTW_ERR("%s: invalid parameter, mode=%d, level=%d\n", __FUNCTION__, mode, en);
}
#ifdef CONFIG_WOWLAN
else if (mode == 3) {
/* WOW LPS */
RTW_INFO("%s: WOW LPS: %s, en=%d\n", __FUNCTION__, (en == 0) ? "disable":"enable", en);
if (rtw_pm_set_wow_lps(adapter, en) != 0 )
RTW_ERR("%s: invalid parameter, mode=%d, level=%d\n", __FUNCTION__, mode, en);
}
#endif /* CONFIG_WOWLAN */
else
RTW_ERR("%s: invalid parameter, mode = %d!\n", __FUNCTION__, mode);
exit:
return count;
}
#ifdef CONFIG_WMMPS_STA
int proc_get_wmmps_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char *uapsd_max_sp_str="";
if (pregpriv){
switch(pregpriv->uapsd_max_sp_len) {
case 0:
uapsd_max_sp_str = "NO_LIMIT";
break;
case 1:
uapsd_max_sp_str = "TWO_MSDU";
break;
case 2:
uapsd_max_sp_str = "FOUR_MSDU";
break;
case 3:
uapsd_max_sp_str = "SIX_MSDU";
break;
default:
uapsd_max_sp_str = "UNSPECIFIED";
break;
}
RTW_PRINT_SEL(m, "====== WMMPS_STA Info:======\n");
RTW_PRINT_SEL(m, "uapsd_max_sp_len=0x%02x (%s)\n", pregpriv->uapsd_max_sp_len, uapsd_max_sp_str);
RTW_PRINT_SEL(m, "uapsd_ac_enable=0x%02x\n", pregpriv->uapsd_ac_enable);
RTW_PRINT_SEL(m, "BIT0 - AC_VO UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_VO) ? "Enabled" : "Disabled");
RTW_PRINT_SEL(m, "BIT1 - AC_VI UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_VI) ? "Enabled" : "Disabled");
RTW_PRINT_SEL(m, "BIT2 - AC_BK UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_BK) ? "Enabled" : "Disabled");
RTW_PRINT_SEL(m, "BIT3 - AC_BE UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_BE) ? "Enabled" : "Disabled");
RTW_PRINT_SEL(m, "============================\n");
}
return 0;
}
ssize_t proc_set_wmmps_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u8 uapsd_ac_setting;
u8 uapsd_max_sp_len_setting;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhu %hhx", &uapsd_max_sp_len_setting, &uapsd_ac_setting);
if (pregpriv) {
if (num >= 1) {
pregpriv->uapsd_max_sp_len = uapsd_max_sp_len_setting;
RTW_INFO("uapsd_max_sp_len = %d\n", pregpriv->uapsd_max_sp_len);
}
if (num >= 2) {
pregpriv->uapsd_ac_enable = uapsd_ac_setting;
RTW_INFO("uapsd_ac_enable = 0x%02x\n", pregpriv->uapsd_ac_enable);
}
}
}
return count;
}
#endif /* CONFIG_WMMPS_STA */
#endif /* CONFIG_POWER_SAVING */
#ifdef CONFIG_TDLS
int proc_get_tdls_enable(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
if (pregpriv)
RTW_PRINT_SEL(m, "TDLS is %s !\n", (rtw_is_tdls_enabled(padapter) == _TRUE) ? "enabled" : "disabled");
return 0;
}
ssize_t proc_set_tdls_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u32 en_tdls = 0;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d ", &en_tdls);
if (num == 1 && pregpriv) {
if (en_tdls > 0)
rtw_enable_tdls_func(padapter);
else
rtw_disable_tdls_func(padapter, _TRUE);
}
}
return count;
}
static int proc_tdls_display_tdls_function_info(struct seq_file *m)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
u8 SpaceBtwnItemAndValueTmp = 0;
BOOLEAN FirstMatchFound = _FALSE;
int j = 0;
RTW_PRINT_SEL(m, "============[TDLS Function Info]============\n");
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Enable", (rtw_is_tdls_enabled(padapter) == _TRUE) ? "_TRUE" : "_FALSE");
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Driver Setup", (ptdlsinfo->driver_setup == _TRUE) ? "_TRUE" : "_FALSE");
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Prohibited", (ptdlsinfo->ap_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Channel Switch Prohibited", (ptdlsinfo->ch_switch_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Link Established", (ptdlsinfo->link_established == _TRUE) ? "_TRUE" : "_FALSE");
RTW_PRINT_SEL(m, "%-*s = %d/%d\n", SpaceBtwnItemAndValue, "TDLS STA Num (Linked/Allowed)", ptdlsinfo->sta_cnt, MAX_ALLOWED_TDLS_STA_NUM);
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Allowed STA Num Reached", (ptdlsinfo->sta_maximum == _TRUE) ? "_TRUE" : "_FALSE");
#ifdef CONFIG_TDLS_CH_SW
RTW_PRINT_SEL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS CH SW State");
if (ptdlsinfo->chsw_info.ch_sw_state == TDLS_STATE_NONE)
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_STATE_NONE");
else {
for (j = 0; j < 32; j++) {
if (ptdlsinfo->chsw_info.ch_sw_state & BIT(j)) {
if (FirstMatchFound == _FALSE) {
SpaceBtwnItemAndValueTmp = 1;
FirstMatchFound = _TRUE;
} else
SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
switch (BIT(j)) {
case TDLS_INITIATOR_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
break;
case TDLS_RESPONDER_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
break;
case TDLS_LINKED_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
break;
case TDLS_WAIT_PTR_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
break;
case TDLS_ALIVE_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
break;
case TDLS_CH_SWITCH_ON_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
break;
case TDLS_PEER_AT_OFF_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
break;
case TDLS_CH_SW_INITIATOR_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
break;
case TDLS_WAIT_CH_RSP_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
break;
default:
RTW_PRINT_SEL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
break;
}
}
}
}
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW On", (ATOMIC_READ(&ptdlsinfo->chsw_info.chsw_on) == _TRUE) ? "_TRUE" : "_FALSE");
RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Off-Channel Num", ptdlsinfo->chsw_info.off_ch_num);
RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Channel Offset", ptdlsinfo->chsw_info.ch_offset);
RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Current Time", ptdlsinfo->chsw_info.cur_time);
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW Delay Switch Back", (ptdlsinfo->chsw_info.delay_switch_back == _TRUE) ? "_TRUE" : "_FALSE");
RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Dump Back", ptdlsinfo->chsw_info.dump_stack);
#endif
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Device Discovered", (ptdlsinfo->dev_discovered == _TRUE) ? "_TRUE" : "_FALSE");
return 0;
}
static int proc_tdls_display_network_info(struct seq_file *m)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
int i = 0;
u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
/* Display the linked AP/GO info */
RTW_PRINT_SEL(m, "============[Associated AP/GO Info]============\n");
if ((pmlmepriv->fw_state & WIFI_STATION_STATE) && (pmlmepriv->fw_state & WIFI_ASOC_STATE)) {
RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "BSSID", cur_network->network.Ssid.Ssid);
RTW_PRINT_SEL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(cur_network->network.MacAddress));
RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
for (i = 0; i < 8; i++) {
if (pmlmeext->cur_wireless_mode & BIT(i)) {
switch (BIT(i)) {
case WIRELESS_11B:
RTW_PRINT_SEL(m, "%4s", "11B ");
break;
case WIRELESS_11G:
RTW_PRINT_SEL(m, "%4s", "11G ");
break;
case WIRELESS_11A:
RTW_PRINT_SEL(m, "%4s", "11A ");
break;
case WIRELESS_11_24N:
RTW_PRINT_SEL(m, "%7s", "11_24N ");
break;
case WIRELESS_11_5N:
RTW_PRINT_SEL(m, "%6s", "11_5N ");
break;
case WIRELESS_AUTO:
RTW_PRINT_SEL(m, "%5s", "AUTO ");
break;
case WIRELESS_11AC:
RTW_PRINT_SEL(m, "%5s", "11AC ");
break;
}
}
}
RTW_PRINT_SEL(m, "\n");
RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
switch (padapter->securitypriv.dot11PrivacyAlgrthm) {
case _NO_PRIVACY_:
RTW_PRINT_SEL(m, "%s\n", "NO PRIVACY");
break;
case _WEP40_:
RTW_PRINT_SEL(m, "%s\n", "WEP 40");
break;
case _TKIP_:
RTW_PRINT_SEL(m, "%s\n", "TKIP");
break;
case _TKIP_WTMIC_:
RTW_PRINT_SEL(m, "%s\n", "TKIP WTMIC");
break;
case _AES_:
RTW_PRINT_SEL(m, "%s\n", "AES");
break;
case _WEP104_:
RTW_PRINT_SEL(m, "%s\n", "WEP 104");
break;
#if 0 /* no this setting */
case _WEP_WPA_MIXED_:
RTW_PRINT_SEL(m, "%s\n", "WEP/WPA Mixed");
break;
#endif
case _SMS4_:
RTW_PRINT_SEL(m, "%s\n", "SMS4");
break;
#ifdef CONFIG_IEEE80211W
case _BIP_CMAC_128_:
RTW_PRINT_SEL(m, "%s\n", "BIP");
break;
#endif /* CONFIG_IEEE80211W */
}
RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "Channel", pmlmeext->chandef.chan);
RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Channel Offset");
switch (pmlmeext->chandef.offset) {
case CHAN_OFFSET_NO_EXT:
RTW_PRINT_SEL(m, "%s\n", "SCN");
break;
case CHAN_OFFSET_UPPER:
RTW_PRINT_SEL(m, "%s\n", "SCA");
break;
case CHAN_OFFSET_LOWER:
RTW_PRINT_SEL(m, "%s\n", "SCB");
break;
}
RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
switch (pmlmeext->chandef.bw) {
case CHANNEL_WIDTH_20:
RTW_PRINT_SEL(m, "%s\n", "20MHz");
break;
case CHANNEL_WIDTH_40:
RTW_PRINT_SEL(m, "%s\n", "40MHz");
break;
case CHANNEL_WIDTH_80:
RTW_PRINT_SEL(m, "%s\n", "80MHz");
break;
case CHANNEL_WIDTH_160:
RTW_PRINT_SEL(m, "%s\n", "160MHz");
break;
case CHANNEL_WIDTH_80_80:
RTW_PRINT_SEL(m, "%s\n", "80MHz + 80MHz");
break;
}
} else
RTW_PRINT_SEL(m, "No association with AP/GO exists!\n");
return 0;
}
static int proc_tdls_display_tdls_sta_info(struct seq_file *m)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct sta_priv *pstapriv = &padapter->stapriv;
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct sta_info *psta;
int i = 0, j = 0;
_list *plist, *phead;
u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
u8 SpaceBtwnItemAndValueTmp = 0;
u8 NumOfTdlsStaToShow = 0;
BOOLEAN FirstMatchFound = _FALSE;
/* Search for TDLS sta info to display */
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
if (psta->tdls_sta_state != TDLS_STATE_NONE) {
/* We got one TDLS sta info to show */
RTW_PRINT_SEL(m, "============[TDLS Peer STA Info: STA %d]============\n", ++NumOfTdlsStaToShow);
RTW_PRINT_SEL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(psta->phl_sta->mac_addr));
RTW_PRINT_SEL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS STA State");
SpaceBtwnItemAndValueTmp = 0;
FirstMatchFound = _FALSE;
for (j = 0; j < 32; j++) {
if (psta->tdls_sta_state & BIT(j)) {
if (FirstMatchFound == _FALSE) {
SpaceBtwnItemAndValueTmp = 1;
FirstMatchFound = _TRUE;
} else
SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
switch (BIT(j)) {
case TDLS_INITIATOR_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
break;
case TDLS_RESPONDER_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
break;
case TDLS_LINKED_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
break;
case TDLS_WAIT_PTR_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
break;
case TDLS_ALIVE_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
break;
case TDLS_CH_SWITCH_ON_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
break;
case TDLS_PEER_AT_OFF_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
break;
case TDLS_CH_SW_INITIATOR_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
break;
case TDLS_WAIT_CH_RSP_STATE:
RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
break;
default:
RTW_PRINT_SEL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
break;
}
}
}
RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
for (j = 0; j < 8; j++) {
if (psta->phl_sta->wmode & BIT(j)) {
switch (BIT(j)) {
case WIRELESS_11B:
RTW_PRINT_SEL(m, "%4s", "11B ");
break;
case WIRELESS_11G:
RTW_PRINT_SEL(m, "%4s", "11G ");
break;
case WIRELESS_11A:
RTW_PRINT_SEL(m, "%4s", "11A ");
break;
case WIRELESS_11_24N:
RTW_PRINT_SEL(m, "%7s", "11_24N ");
break;
case WIRELESS_11_5N:
RTW_PRINT_SEL(m, "%6s", "11_5N ");
break;
case WIRELESS_AUTO:
RTW_PRINT_SEL(m, "%5s", "AUTO ");
break;
case WIRELESS_11AC:
RTW_PRINT_SEL(m, "%5s", "11AC ");
break;
}
}
}
RTW_PRINT_SEL(m, "\n");
RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
switch (psta->phl_sta->chandef.bw) {
case CHANNEL_WIDTH_20:
RTW_PRINT_SEL(m, "%s\n", "20MHz");
break;
case CHANNEL_WIDTH_40:
RTW_PRINT_SEL(m, "%s\n", "40MHz");
break;
case CHANNEL_WIDTH_80:
RTW_PRINT_SEL(m, "%s\n", "80MHz");
break;
case CHANNEL_WIDTH_160:
RTW_PRINT_SEL(m, "%s\n", "160MHz");
break;
case CHANNEL_WIDTH_80_80:
RTW_PRINT_SEL(m, "%s\n", "80MHz + 80MHz");
break;
case CHANNEL_WIDTH_5:
RTW_PRINT_SEL(m, "%s\n", "5MHz");
break;
case CHANNEL_WIDTH_10:
RTW_PRINT_SEL(m, "%s\n", "10MHz");
break;
default:
RTW_PRINT_SEL(m, "(%d)%s\n", psta->phl_sta->chandef.bw, "invalid");
break;
}
RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
switch (psta->dot118021XPrivacy) {
case _NO_PRIVACY_:
RTW_PRINT_SEL(m, "%s\n", "NO PRIVACY");
break;
case _WEP40_:
RTW_PRINT_SEL(m, "%s\n", "WEP 40");
break;
case _TKIP_:
RTW_PRINT_SEL(m, "%s\n", "TKIP");
break;
case _TKIP_WTMIC_:
RTW_PRINT_SEL(m, "%s\n", "TKIP WTMIC");
break;
case _AES_:
RTW_PRINT_SEL(m, "%s\n", "AES");
break;
case _WEP104_:
RTW_PRINT_SEL(m, "%s\n", "WEP 104");
break;
#if 0 /* no this setting */
case _WEP_WPA_MIXED_:
RTW_PRINT_SEL(m, "%s\n", "WEP/WPA Mixed");
break;
#endif
case _SMS4_:
RTW_PRINT_SEL(m, "%s\n", "SMS4");
break;
#ifdef CONFIG_IEEE80211W
case _BIP_CMAC_128_:
RTW_PRINT_SEL(m, "%s\n", "BIP");
break;
#endif /* CONFIG_IEEE80211W */
}
RTW_PRINT_SEL(m, "%-*s = %d sec/%d sec\n", SpaceBtwnItemAndValue, "TPK Lifetime (Current/Expire)", psta->TPK_count, psta->TDLS_PeerKey_Lifetime);
RTW_PRINT_SEL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Tx Packets Over Direct Link", psta->sta_stats.tx_pkts);
RTW_PRINT_SEL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Rx Packets Over Direct Link", psta->sta_stats.rx_data_pkts);
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
if (NumOfTdlsStaToShow == 0) {
RTW_PRINT_SEL(m, "============[TDLS Peer STA Info]============\n");
RTW_PRINT_SEL(m, "No TDLS direct link exists!\n");
}
return 0;
}
int proc_get_tdls_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct sta_priv *pstapriv = &padapter->stapriv;
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct sta_info *psta;
int i = 0, j = 0;
_list *plist, *phead;
u8 SpaceBtwnItemAndValue = 41;
u8 SpaceBtwnItemAndValueTmp = 0;
u8 NumOfTdlsStaToShow = 0;
BOOLEAN FirstMatchFound = _FALSE;
if (rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_TDLS) == _FALSE) {
RTW_PRINT_SEL(m, "No tdls info can be shown since hal doesn't support tdls\n");
return 0;
}
proc_tdls_display_tdls_function_info(m);
proc_tdls_display_network_info(m);
proc_tdls_display_tdls_sta_info(m);
return 0;
}
#endif
int proc_get_monitor(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
if (MLME_IS_MONITOR(padapter)) {
RTW_PRINT_SEL(m, "Monitor mode : Enable\n");
RTW_PRINT_SEL(m, "Device type : %u\n", dev->type);
RTW_PRINT_SEL(m, "ch=%d, ch_offset=%d, bw=%d\n",
rtw_get_oper_ch(padapter),
rtw_get_oper_choffset(padapter),
rtw_get_oper_bw(padapter));
} else
RTW_PRINT_SEL(m, "Monitor mode : Disable\n");
return 0;
}
ssize_t proc_set_monitor(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
u16 target_type;
u8 target_ch, target_offset, target_bw;
if (count < 3) {
RTW_INFO("argument size is less than 3\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = 0;
num = sscanf(tmp, "type %hu", &target_type);
if ((num == 1) &&
((target_type != ARPHRD_IEEE80211) &&
(target_type != ARPHRD_IEEE80211_RADIOTAP))) {
dev->type = ARPHRD_IEEE80211_RADIOTAP;
return count;
}
num = sscanf(tmp, "%hhu %hhu %hhu", &target_ch, &target_offset, &target_bw);
if (num != 3) {
RTW_INFO("invalid write_reg parameter!\n");
return count;
}
padapter->mlmeextpriv.chandef.chan = target_ch;
set_channel_bwmode(padapter, target_ch, target_offset, target_bw, _TRUE);
}
return count;
}
#ifdef DBG_XMIT_BLOCK
int proc_get_xmit_block(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
dump_xmit_block(m, padapter);
return 0;
}
ssize_t proc_set_xmit_block(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 xb_mode, xb_reason;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx %hhx", &xb_mode, &xb_reason);
if (num != 2) {
RTW_INFO("invalid parameter!\n");
return count;
}
if (xb_mode == 0)/*set*/
rtw_set_xmit_block(padapter, xb_reason);
else if (xb_mode == 1)/*clear*/
rtw_clr_xmit_block(padapter, xb_reason);
else
RTW_INFO("invalid parameter!\n");
}
return count;
}
#endif
int proc_get_efuse_map(struct seq_file *m, void *v)
{
#if 0
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(adapter_to_dvobj(padapter));
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
struct efuse_info *efuse = adapter_to_efuse(padapter);
int i, j;
u8 ips_mode = IPS_NUM;
u16 mapLen;
EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
if (mapLen > EFUSE_MAX_MAP_LEN)
mapLen = EFUSE_MAX_MAP_LEN;
ips_mode = pwrctrlpriv->ips_mode;
rtw_pm_set_ips(padapter, IPS_NONE);
if (efuse->file_status == EFUSE_FILE_LOADED) {
RTW_PRINT_SEL(m, "File eFuse Map loaded! file path:%s\nDriver eFuse Map From File\n", EFUSE_MAP_PATH);
if (efuse->is_autoload_fail)
RTW_PRINT_SEL(m, "File Autoload fail!!!\n");
} else if (efuse->file_status == EFUSE_FILE_FAILED) {
RTW_PRINT_SEL(m, "Open File eFuse Map Fail ! file path:%s\nDriver eFuse Map From Default\n", EFUSE_MAP_PATH);
if (efuse->is_autoload_fail)
RTW_PRINT_SEL(m, "HW Autoload fail!!!\n");
} else {
RTW_PRINT_SEL(m, "Driver eFuse Map From HW\n");
if (efuse->is_autoload_fail)
RTW_PRINT_SEL(m, "HW Autoload fail!!!\n");
}
for (i = 0; i < mapLen; i += 16) {
RTW_PRINT_SEL(m, "0x%02x\t", i);
for (j = 0; j < 8; j++)
RTW_PRINT_SEL(m, "%02X ", efuse->data[i + j]);
RTW_PRINT_SEL(m, "\t");
for (; j < 16; j++)
RTW_PRINT_SEL(m, "%02X ", efuse->data[i + j]);
RTW_PRINT_SEL(m, "\n");
}
if (rtw_efuse_map_read(padapter, 0, mapLen, pEfuseHal->fakeEfuseInitMap) == _FAIL) {
RTW_PRINT_SEL(m, "WARN - Read Realmap Failed\n");
return 0;
}
RTW_PRINT_SEL(m, "\n");
RTW_PRINT_SEL(m, "HW eFuse Map\n");
for (i = 0; i < mapLen; i += 16) {
RTW_PRINT_SEL(m, "0x%02x\t", i);
for (j = 0; j < 8; j++)
RTW_PRINT_SEL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i + j]);
RTW_PRINT_SEL(m, "\t");
for (; j < 16; j++)
RTW_PRINT_SEL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i + j]);
RTW_PRINT_SEL(m, "\n");
}
rtw_pm_set_ips(padapter, ips_mode);
#endif
return 0;
}
ssize_t proc_set_efuse_map(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
#if 0
char tmp[256] = {0};
u32 addr, cnts;
u8 efuse_data;
int jj, kk;
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
u8 ips_mode = IPS_NUM;
if (count < 3) {
RTW_INFO("argument size is less than 3\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%x %d %x", &addr, &cnts, &efuse_data);
if (num != 3) {
RTW_INFO("invalid write_reg parameter!\n");
return count;
}
}
ips_mode = pwrctrlpriv->ips_mode;
rtw_pm_set_ips(padapter, IPS_NONE);
if (rtw_efuse_map_write(padapter, addr, cnts, &efuse_data) == _FAIL)
RTW_INFO("WARN - rtw_efuse_map_write error!!\n");
rtw_pm_set_ips(padapter, ips_mode);
#endif
return count;
}
#ifdef CONFIG_IEEE80211W
ssize_t proc_set_tx_sa_query(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct sta_priv *pstapriv = &padapter->stapriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
/* macid_ctl move to phl */
/* struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj); */
struct sta_info *psta;
_list *plist, *phead;
char tmp[16];
u8 mac_addr[NUM_STA][ETH_ALEN];
u32 key_type;
u8 index;
void *phl = GET_PHL_INFO(dvobj);
u16 macid_num = rtw_phl_get_macid_max_num(phl);
if (count > 2) {
RTW_INFO("argument size is more than 2\n");
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
int num = sscanf(tmp, "%x", &key_type);
if (num != 1) {
RTW_INFO("invalid read_reg parameter!\n");
return count;
}
RTW_INFO("0: set sa query request , key_type=%d\n", key_type);
}
if (MLME_IS_STA(padapter)
&& (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) && SEC_IS_BIP_KEY_INSTALLED(&padapter->securitypriv) == _TRUE) {
RTW_INFO("STA:"MAC_FMT"\n", MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
/* TX unicast sa_query to AP */
issue_action_SA_Query(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, 0, (u8)key_type);
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && SEC_IS_BIP_KEY_INSTALLED(&padapter->securitypriv) == _TRUE) {
/* TX unicast sa_query to every client STA */
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < NUM_STA; index++) {
psta = NULL;
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
_rtw_memcpy(&mac_addr[psta->phl_sta->macid][0], psta->phl_sta->mac_addr, ETH_ALEN);
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < macid_num && index < NUM_STA; index++) {
if (rtw_phl_macid_is_used(phl, index) && !rtw_phl_macid_is_bmc(phl, index)) {
if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)
&& !IS_MCAST(&mac_addr[index][0])) {
issue_action_SA_Query(padapter, &mac_addr[index][0], 0, 0, (u8)key_type);
RTW_INFO("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
}
}
}
}
return count;
}
int proc_get_tx_sa_query(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "%s\n", __func__);
return 0;
}
ssize_t proc_set_tx_deauth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct sta_priv *pstapriv = &padapter->stapriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
/* macid_ctl move to phl */
/* struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj); */
struct sta_info *psta;
_list *plist, *phead;
char tmp[16];
u8 mac_addr[NUM_STA][ETH_ALEN];
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u32 key_type = 0;
u8 index;
void *phl = GET_PHL_INFO(dvobj);
u16 macid_num = rtw_phl_get_macid_max_num(phl);
if (count > 2) {
RTW_INFO("argument size is more than 2\n");
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
int num = sscanf(tmp, "%x", &key_type);
if (num != 1) {
RTW_INFO("invalid read_reg parameter!\n");
return count;
}
RTW_INFO("key_type=%d\n", key_type);
}
if (key_type > 4)
return count;
if (MLME_IS_STA(padapter)
&& (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
if (key_type == 3) /* key_type 3 only for AP mode */
return count;
/* TX unicast deauth to AP */
issue_deauth_11w(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, (u8)key_type);
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) {
u8 updated = _FALSE;
if (key_type == 3)
issue_deauth_11w(padapter, bc_addr, 0, IEEE80211W_RIGHT_KEY);
/* TX unicast deauth to every client STA */
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < NUM_STA; index++) {
psta = NULL;
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
_rtw_memcpy(&mac_addr[psta->phl_sta->macid][0], psta->phl_sta->mac_addr, ETH_ALEN);
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < macid_num && index < NUM_STA; index++) {
if (rtw_phl_macid_is_used(phl, index) && !rtw_phl_macid_is_bmc(phl, index)) {
if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)) {
if (key_type != 3)
issue_deauth_11w(padapter, &mac_addr[index][0], 0, (u8)key_type);
psta = rtw_get_stainfo(pstapriv, &mac_addr[index][0]);
if (psta && key_type != IEEE80211W_WRONG_KEY && key_type != IEEE80211W_NO_KEY) {
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
rtw_list_delete(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (psta->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt--;
#endif
updated |= ap_free_sta(padapter, psta, _FALSE, WLAN_REASON_PREV_AUTH_NOT_VALID, _TRUE, _FALSE);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
}
RTW_INFO("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
}
}
}
associated_clients_update(padapter, updated, STA_INFO_UPDATE_ALL);
}
return count;
}
int proc_get_tx_deauth(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "%s\n", __func__);
return 0;
}
ssize_t proc_set_tx_auth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct sta_priv *pstapriv = &padapter->stapriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
/* macid_ctl move to phl */
/*struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj); */
struct sta_info *psta;
_list *plist, *phead;
char tmp[16];
u8 mac_addr[NUM_STA][ETH_ALEN];
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u32 tx_auth;
u8 index;
if (count > 2) {
RTW_INFO("argument size is more than 2\n");
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
int num = sscanf(tmp, "%x", &tx_auth);
if (num != 1) {
RTW_INFO("invalid read_reg parameter!\n");
return count;
}
RTW_INFO("1: setnd auth, 2: send assoc request. tx_auth=%d\n", tx_auth);
}
if (MLME_IS_STA(padapter)
&& (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
if (tx_auth == 1) {
/* TX unicast auth to AP */
issue_auth(padapter, NULL, 0);
} else if (tx_auth == 2) {
/* TX unicast auth to AP */
issue_assocreq(padapter);
}
}
return count;
}
int proc_get_tx_auth(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "%s\n", __func__);
return 0;
}
#endif /* CONFIG_IEEE80211W */
int proc_get_ack_timeout(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
u8 ack_timeout_val = 0;
u8 ack_timeout_val_cck = 0;
rtw_hal_get_hwreg(padapter, HW_VAR_ACKTO, &ack_timeout_val);
rtw_hal_get_hwreg(padapter, HW_VAR_ACKTO_CCK, &ack_timeout_val_cck);
RTW_PRINT_SEL(m, "Current CCK packet ACK Timeout = %d us (0x%x).\n", ack_timeout_val_cck, ack_timeout_val_cck);
RTW_PRINT_SEL(m, "Current non-CCK packet ACK Timeout = %d us (0x%x).\n", ack_timeout_val, ack_timeout_val);
return 0;
}
ssize_t proc_set_ack_timeout(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 tmp_v1 = 0, tmp_v2 = 0;
u8 ack_to_ms = 0, ack_to_cck_ms = 0;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u %u", &tmp_v1, &tmp_v2);
if (num < 1) {
RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
return -EINVAL;
}
if (tmp_v1) {
ack_to_ms = (u8)tmp_v1;
rtw_hal_set_hwreg(padapter, HW_VAR_ACKTO, &ack_to_ms);
}
if (tmp_v2) {
ack_to_cck_ms = (u8)tmp_v2;
rtw_hal_set_hwreg(padapter, HW_VAR_ACKTO_CCK, &ack_to_cck_ms);
}
/* This register sets the Ack time out value after Tx unicast packet. It is in units of us. */
/* This register sets the Ack time out value after Tx unicast CCK packet. It is in units of us. */
RTW_INFO("Set CCK packet ACK Timeout to %d us.\n", ack_to_cck_ms);
RTW_INFO("Set non-CCK packet ACK Timeout to %d us.\n", ack_to_ms);
}
return count;
}
ssize_t proc_set_fw_offload(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
#if 0 /*GEORGIA_TODO_FIXIT*/
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
_adapter *pri_adapter = GET_PRIMARY_ADAPTER(adapter);
HAL_DATA_TYPE *hal = GET_PHL_COM(adapter_to_dvobj(adapter));
char tmp[32];
u32 iqk_offload_enable = 0, ch_switch_offload_enable = 0;
if (buffer == NULL) {
RTW_INFO("input buffer is NULL!\n");
return -EFAULT;
}
if (count < 1) {
RTW_INFO("input length is 0!\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
RTW_INFO("input length is too large\n");
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d %d", &iqk_offload_enable, &ch_switch_offload_enable);
if (num < 2) {
RTW_INFO("input parameters < 1\n");
return -EINVAL;
}
if (hal->RegIQKFWOffload != iqk_offload_enable) {
hal->RegIQKFWOffload = iqk_offload_enable;
rtw_run_in_thread_cmd(pri_adapter, ((void *)(rtw_hal_update_iqk_fw_offload_cap)), pri_adapter);
}
if (hal->ch_switch_offload != ch_switch_offload_enable)
hal->ch_switch_offload = ch_switch_offload_enable;
}
return count;
#endif
return 0;
}
int proc_get_fw_offload(struct seq_file *m, void *v)
{
#if 0 /*GEORGIA_TODO_FIXIT*/
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
HAL_DATA_TYPE *hal = GET_PHL_COM(adapter_to_dvobj(adapter));
RTW_PRINT_SEL(m, "IQK FW offload:%s\n", hal->RegIQKFWOffload?"enable":"disable");
RTW_PRINT_SEL(m, "Channel switch FW offload:%s\n", hal->ch_switch_offload?"enable":"disable");
#endif
return 0;
}
#ifdef CONFIG_CTRL_TXSS_BY_TP
ssize_t proc_set_txss_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
char tmp[32];
u32 enable = 0;
u32 txss_tx_tp = 0;
int txss_chk_cnt = 0;
if (buffer == NULL) {
RTW_INFO("input buffer is NULL!\n");
return -EFAULT;
}
if (count < 1) {
RTW_INFO("input length is 0!\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
RTW_INFO("input length is too large\n");
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u %u %d",
&enable, &txss_tx_tp, &txss_chk_cnt);
if (num < 1) {
RTW_INFO("input parameters < 1\n");
return -EINVAL;
}
pmlmeext->txss_ctrl_en = enable;
if (txss_tx_tp)
pmlmeext->txss_tp_th = txss_tx_tp;
if (txss_chk_cnt)
pmlmeext->txss_tp_chk_cnt = txss_chk_cnt;
RTW_INFO("%s txss_ctl_en :%s , txss_tp_th:%d, tp_chk_cnt:%d\n",
__func__, pmlmeext->txss_tp_th ? "Y" : "N",
pmlmeext->txss_tp_th, pmlmeext->txss_tp_chk_cnt);
}
return count;
}
int proc_get_txss_tp(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
RTW_PRINT_SEL(m, "TXSS Control - %s\n", pmlmeext->txss_ctrl_en ? "enable" : "disable");
RTW_PRINT_SEL(m, "TXSS Tx TP TH - %d\n", pmlmeext->txss_tp_th);
RTW_PRINT_SEL(m, "TXSS check cnt - %d\n", pmlmeext->txss_tp_chk_cnt);
return 0;
}
#ifdef DBG_CTRL_TXSS
ssize_t proc_set_txss_ctrl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
char tmp[32];
u32 tx_1ss = 0;
if (buffer == NULL) {
RTW_INFO("input buffer is NULL!\n");
return -EFAULT;
}
if (count < 1) {
RTW_INFO("input length is 0!\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
RTW_INFO("input length is too large\n");
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u", &tx_1ss);
if (num < 1) {
RTW_INFO("input parameters < 1\n");
return -EINVAL;
}
pmlmeext->txss_ctrl_en = _FALSE;
dbg_ctrl_txss(adapter, tx_1ss);
RTW_INFO("%s set tx to 1ss :%s\n", __func__, tx_1ss ? "Y" : "N");
}
return count;
}
int proc_get_txss_ctrl(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
RTW_PRINT_SEL(m, "TXSS 1ss - %s\n", pmlmeext->txss_1ss ? "Y" : "N");
return 0;
}
#endif
#endif
#ifdef CONFIG_DBG_RF_CAL
int proc_get_iqk_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
return 0;
}
ssize_t proc_set_iqk(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 recovery, clear, segment;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d %d %d", &recovery, &clear, &segment);
if (num != 3) {
RTW_INFO("Invalid format\n");
return count;
}
rtw_hal_iqk_test(padapter, recovery, clear, segment);
}
return count;
}
int proc_get_lck_info(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
return 0;
}
ssize_t proc_set_lck(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u32 trigger;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d", &trigger);
if (num != 1) {
RTW_INFO("Invalid format\n");
return count;
}
rtw_hal_lck_test(padapter);
}
return count;
}
#endif /* CONFIG_DBG_RF_CAL */
#ifdef CONFIG_LPS_CHK_BY_TP
ssize_t proc_set_lps_chk_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
char tmp[32];
u32 enable = 0;
u32 lps_tx_tp = 0, lps_rx_tp = 0, lps_bi_tp = 0;
int lps_chk_cnt_th = 0;
u32 lps_tx_pkts = 0, lps_rx_pkts = 0;
if (buffer == NULL) {
RTW_INFO("input buffer is NULL!\n");
return -EFAULT;
}
if (count < 1) {
RTW_INFO("input length is 0!\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
RTW_INFO("input length is too large\n");
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u %u %u %u %d %u %u",
&enable, &lps_tx_tp, &lps_rx_tp, &lps_bi_tp,
&lps_chk_cnt_th, &lps_tx_pkts, &lps_rx_pkts);
if (num < 1) {
RTW_INFO("input parameters < 1\n");
return -EINVAL;
}
pwrpriv->lps_chk_by_tp = enable;
if (lps_tx_tp) {
pwrpriv->lps_tx_tp_th = lps_tx_tp;
pwrpriv->lps_rx_tp_th = lps_tx_tp;
pwrpriv->lps_bi_tp_th = lps_tx_tp;
}
if (lps_rx_tp)
pwrpriv->lps_rx_tp_th = lps_rx_tp;
if (lps_bi_tp)
pwrpriv->lps_bi_tp_th = lps_bi_tp;
if (lps_chk_cnt_th)
pwrpriv->lps_chk_cnt_th = lps_chk_cnt_th;
if (lps_tx_pkts)
pwrpriv->lps_tx_pkts = lps_tx_pkts;
if (lps_rx_pkts)
pwrpriv->lps_rx_pkts = lps_rx_pkts;
RTW_INFO("%s lps_chk_by_tp:%s , lps_tx_tp_th:%d, lps_tx_tp_th:%d, lps_bi_tp:%d\n",
__func__, pwrpriv->lps_chk_by_tp ? "Y" : "N",
pwrpriv->lps_tx_tp_th, pwrpriv->lps_tx_tp_th, pwrpriv->lps_bi_tp_th);
RTW_INFO("%s lps_chk_cnt_th:%d , lps_tx_pkts:%d, lps_rx_pkts:%d\n",
__func__, pwrpriv->lps_chk_cnt_th, pwrpriv->lps_tx_pkts, pwrpriv->lps_rx_pkts);
}
return count;
}
int proc_get_lps_chk_tp(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
RTW_PRINT_SEL(m, "LPS chk by tp - %s\n", pwrpriv->lps_chk_by_tp ? "enable" : "disable");
RTW_PRINT_SEL(m, "LPS Tx TP TH - %d(Mbps)\n", pwrpriv->lps_tx_tp_th);
RTW_PRINT_SEL(m, "LPS Rx TP TH - %d(Mbps)\n", pwrpriv->lps_rx_tp_th);
RTW_PRINT_SEL(m, "LPS BI TP TH - %d(Mbps)\n", pwrpriv->lps_bi_tp_th);
RTW_PRINT_SEL(m, "LPS CHK CNT - %d\n", pwrpriv->lps_chk_cnt_th);
RTW_PRINT_SEL(m, "LPS Tx PKTs - %d\n", pwrpriv->lps_tx_pkts);
RTW_PRINT_SEL(m, "LPS Rx PKTs - %d\n", pwrpriv->lps_rx_pkts);
return 0;
}
#endif /*CONFIG_LPS_CHK_BY_TP*/
#ifdef CONFIG_SUPPORT_STATIC_SMPS
ssize_t proc_set_smps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
char tmp[32];
u32 enable = 0;
u32 smps_en, smps_tx_tp = 0, smps_rx_tp = 0;
u32 smps_test = 0, smps_test_en = 0;
if (buffer == NULL) {
RTW_INFO("input buffer is NULL!\n");
return -EFAULT;
}
if (count < 1) {
RTW_INFO("input length is 0!\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
RTW_INFO("input length is too large\n");
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%u %u %u %u %u", &smps_en, &smps_tx_tp, &smps_rx_tp,
&smps_test, &smps_test_en);
if (num < 1) {
RTW_INFO("input parameters < 1\n");
return -EINVAL;
}
pmlmeext->ssmps_en = smps_en;
if (smps_tx_tp) {
pmlmeext->ssmps_tx_tp_th= smps_tx_tp;
pmlmeext->ssmps_rx_tp_th= smps_tx_tp;
}
if (smps_rx_tp)
pmlmeext->ssmps_rx_tp_th = smps_rx_tp;
#ifdef DBG_STATIC_SMPS
if (num > 3) {
pmlmeext->ssmps_test = smps_test;
pmlmeext->ssmps_test_en = smps_test_en;
}
#endif
RTW_INFO("SM PS : %s tx_tp_th:%d, rx_tp_th:%d\n",
(smps_en) ? "Enable" : "Disable",
pmlmeext->ssmps_tx_tp_th,
pmlmeext->ssmps_rx_tp_th);
#ifdef DBG_STATIC_SMPS
RTW_INFO("SM PS : %s ssmps_test_en:%d\n",
(smps_test) ? "Enable" : "Disable",
pmlmeext->ssmps_test_en);
#endif
}
return count;
}
int proc_get_smps(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
RTW_PRINT_SEL(m, "Static SMPS %s\n", pmlmeext->ssmps_en ? "enable" : "disable");
RTW_PRINT_SEL(m, "Tx TP TH %d\n", pmlmeext->ssmps_tx_tp_th);
RTW_PRINT_SEL(m, "Rx TP TH %d\n", pmlmeext->ssmps_rx_tp_th);
#ifdef DBG_STATIC_SMPS
RTW_PRINT_SEL(m, "test %d, test_en:%d\n", pmlmeext->ssmps_test, pmlmeext->ssmps_test_en);
#endif
return 0;
}
#endif /*CONFIG_SUPPORT_STATIC_SMPS*/
int proc_get_chan(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "ch=%d, ch_offset=%d, bw=%d\n",
rtw_get_oper_ch(padapter),
rtw_get_oper_choffset(padapter),
rtw_get_oper_bw(padapter));
RTW_PRINT_SEL(m, "PHL ch=%d\n",
rtw_phl_get_cur_ch(padapter->phl_role));
return 0;
}
ssize_t proc_set_chan(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
u8 target_ch, target_offset, target_bw;
#ifdef DBG_CONFIG_CMD_DISP
u8 cmd_type = 0xFF;
u8 cmd_to = 0;
#endif
if (count < 3) {
RTW_INFO("argument size is less than 3\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = 0;
#ifdef DBG_CONFIG_CMD_DISP
num = sscanf(tmp, "%hhu %hhu %hhu %hhu %hhu",
&target_ch, &target_offset, &target_bw,
&cmd_type, &cmd_to);
if (num != 5) {
RTW_INFO("invalid write_reg parameter!\n");
return count;
}
padapter->cmd_type = cmd_type;
padapter->cmd_timeout = cmd_to;
#else
num = sscanf(tmp, "%hhu %hhu %hhu",
&target_ch, &target_offset, &target_bw);
if (num != 3) {
RTW_INFO("invalid write_reg parameter!\n");
return count;
}
#endif
set_channel_bwmode(padapter, target_ch, target_offset, target_bw, _FALSE);
}
return count;
}
int proc_get_mr_test(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
return 0;
}
ssize_t proc_set_mr_test(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
char tmp[32];
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 mode, param, param_1, param_2;
bool show_caller;
if (count < 2) {
RTW_INFO("argument size is less than 3\n");
return -EFAULT;
}
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = 0;
num = sscanf(tmp, "%hhu %hhu %hhu %hhu", &mode, ¶m, ¶m_1, ¶m_2);
if (num < 2) {
RTW_INFO("invalid write_reg parameter!\n");
return count;
}
#ifdef PHL_MR_PROC_CMD
if (mode == 1) {
show_caller = (param) ? _TRUE : _FALSE;
rtw_phl_mr_dump_info(dvobj->phl, show_caller);
}
else if (mode == 2) {
show_caller = (param) ? _TRUE : _FALSE;
rtw_phl_mr_dump_band_ctl(dvobj->phl, show_caller);
}
else if (mode == 3) {
if (param == 1)
rtw_phl_mr_dump_mac_addr(dvobj->phl, padapter->phl_role);
else if (param == 2)
rtw_phl_mr_buddy_dump_mac_addr(dvobj->phl, padapter->phl_role);
}
else if (mode == 4 || mode == 5) {
u8 chan;
enum channel_width bw;
enum chan_offset offset;
bool rst, is_add;
is_add = (mode == 4) ? _TRUE : _FALSE;
chan = param;
bw = param_1;
offset = param_2;
rst = rtw_phl_chanctx_test(dvobj->phl, padapter->phl_role, is_add, &chan, &bw, &offset);
RTW_INFO("%s s_ch:%d,s_bw:%d,s_offset:%d, r_ch:%d, r_bw:%d, r_offset:%d\n",
__func__, param, param_1, param_2, chan, bw, offset);
}
else if (mode == 6) {
show_caller = (param) ? _TRUE : _FALSE;
rtw_phl_sta_dump_info(dvobj->phl, show_caller, padapter->phl_role, param_1);
}
#endif
}
return count;
}
int proc_get_deny_legacy(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
if (pregpriv)
RTW_PRINT_SEL(m, "deny_legacy = 0x%x\n", pregpriv->deny_legacy);
if (pmlmeext)
RTW_PRINT_SEL(m, "cur_wireless_mode = 0x%x\n", pmlmeext->cur_wireless_mode);
return 0;
}
ssize_t proc_set_deny_legacy(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct registry_priv *pregpriv = &padapter->registrypriv;
char tmp[32];
u8 legacy;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhu ", &legacy);
if (num == 1 && pregpriv) {
pregpriv->deny_legacy = legacy;
RTW_INFO("deny_legacy=%d\n", legacy);
}
}
return count;
}
#ifdef CONFIG_80211AX_HE
int proc_get_tx_ul_mu_disable(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct rtw_he_actrl_om *cur_om_info = &(pmlmepriv->hepriv.om_info);
RTW_PRINT_SEL(m, "OM ul_mu_disable = %s\n", cur_om_info->om_actrl_ele.ul_mu_disable ? "True" : "False");
return 0;
}
ssize_t proc_set_tx_ul_mu_disable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct rtw_he_actrl_om om_info;
u8 om_mask = 0;
char tmp[32];
u8 ul_mu_disable;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhu ", &ul_mu_disable);
if (num == 1) {
om_mask = om_mask | OM_UL_MU_DIS;
/*om_info.actrl_om_normal_tx = _TRUE;*/
/*om_info.actrl_om_normal_tx_cnt = 8;*/
if (ul_mu_disable == _TRUE)
om_info.om_actrl_ele.ul_mu_disable = _TRUE;
else
om_info.om_actrl_ele.ul_mu_disable = _FALSE;
#if 0
/*om others control setting*/
om_mask = om_mask | OM_RX_NSS;
om_info.om_actrl_ele.rx_nss = 1;
om_mask = om_mask | OM_CH_BW;
om_info.om_actrl_ele.channel_width= 2;
om_mask = om_mask | OM_TX_NSTS;
om_info.om_actrl_ele.tx_nsts= 2;
om_mask = om_mask | OM_ER_SU_DIS;
om_info.om_actrl_ele.er_su_disable = _TRUE;
om_mask = om_mask | OM_DL_MU_RR;
om_info.om_actrl_ele.dl_mu_mimo_rr= _TRUE;
om_mask = om_mask | OM_UL_MU_DATA_DIS;
om_info.om_actrl_ele.ul_mu_data_disable= _TRUE;
#endif
rtw_he_set_om_info(padapter, om_mask, &om_info);
issue_qos_nulldata(padapter, NULL, 0, 0, 3, 10, _TRUE);
}
}
return count;
}
#endif
#endif /* CONFIG_PROC_DEBUG */
#define RTW_BUFDUMP_BSIZE 16
#if 1
inline void RTW_BUF_DUMP_SEL(uint _loglevel, void *sel, u8 *_titlestring,
bool _idx_show, const u8 *_hexdata, int _hexdatalen)
{
#ifdef CONFIG_RTW_DEBUG
int __i;
u8 *ptr = (u8 *)_hexdata;
if (_loglevel <= rtw_drv_log_level) {
if (_titlestring) {
if (sel == RTW_DBGDUMP)
RTW_PRINT("");
_RTW_PRINT_SEL(sel, "%s", _titlestring);
if (_hexdatalen >= RTW_BUFDUMP_BSIZE)
_RTW_PRINT_SEL(sel, "\n");
}
for (__i = 0; __i < _hexdatalen; __i++) {
if (((__i % RTW_BUFDUMP_BSIZE) == 0) && (_hexdatalen >= RTW_BUFDUMP_BSIZE)) {
if (sel == RTW_DBGDUMP)
RTW_PRINT("");
if (_idx_show)
_RTW_PRINT_SEL(sel, "0x%03X: ", __i);
}
_RTW_PRINT_SEL(sel, "%02X%s", ptr[__i], (((__i + 1) % 4) == 0) ? " " : " ");
if ((__i + 1 < _hexdatalen) && ((__i + 1) % RTW_BUFDUMP_BSIZE) == 0)
_RTW_PRINT_SEL(sel, "\n");
}
_RTW_PRINT_SEL(sel, "\n");
}
#endif
}
inline void RTW_BUF_DUMP_SEL_ALWAYS(void *sel, u8 *_titlestring,
bool _idx_show, const u8 *_hexdata, int _hexdatalen)
{
int __i;
u8 *ptr = (u8 *)_hexdata;
if (_titlestring) {
if (sel == RTW_DBGDUMP)
RTW_PRINT("");
_RTW_PRINT_SEL(sel, "%s", _titlestring);
if (_hexdatalen >= RTW_BUFDUMP_BSIZE)
_RTW_PRINT_SEL(sel, "\n");
}
for (__i = 0; __i < _hexdatalen; __i++) {
if (((__i % RTW_BUFDUMP_BSIZE) == 0) && (_hexdatalen >= RTW_BUFDUMP_BSIZE)) {
if (sel == RTW_DBGDUMP)
RTW_PRINT("");
if (_idx_show)
_RTW_PRINT_SEL(sel, "0x%03X: ", __i);
}
_RTW_PRINT_SEL(sel, "%02X%s", ptr[__i], (((__i + 1) % 4) == 0) ? " " : " ");
if ((__i + 1 < _hexdatalen) && ((__i + 1) % RTW_BUFDUMP_BSIZE) == 0)
_RTW_PRINT_SEL(sel, "\n");
}
_RTW_PRINT_SEL(sel, "\n");
}
#else
inline void _RTW_STR_DUMP_SEL(void *sel, char *str_out)
{
if (sel == RTW_DBGDUMP)
_dbgdump("%s\n", str_out);
#if defined(_seqdump)
else
_seqdump(sel, "%s\n", str_out);
#endif /*_seqdump*/
}
inline void RTW_BUF_DUMP_SEL(uint _loglevel, void *sel, u8 *_titlestring,
bool _idx_show, u8 *_hexdata, int _hexdatalen)
{
int __i, len;
int __j, idx;
int block_num, remain_byte;
char str_out[128] = {'\0'};
char str_val[32] = {'\0'};
char *p = NULL;
u8 *ptr = (u8 *)_hexdata;
if (_loglevel <= rtw_drv_log_level) {
/*dump title*/
p = &str_out[0];
if (_titlestring) {
if (sel == RTW_DBGDUMP) {
len = snprintf(str_val, sizeof(str_val), "%s", DRIVER_PREFIX);
strncpy(p, str_val, len);
p += len;
}
len = snprintf(str_val, sizeof(str_val), "%s", _titlestring);
strncpy(p, str_val, len);
p += len;
}
if (p != &str_out[0]) {
_RTW_STR_DUMP_SEL(sel, str_out);
_rtw_memset(&str_out, '\0', sizeof(str_out));
}
/*dump buffer*/
block_num = _hexdatalen / RTW_BUFDUMP_BSIZE;
remain_byte = _hexdatalen % RTW_BUFDUMP_BSIZE;
for (__i = 0; __i < block_num; __i++) {
p = &str_out[0];
if (sel == RTW_DBGDUMP) {
len = snprintf(str_val, sizeof(str_val), "%s", DRIVER_PREFIX);
strncpy(p, str_val, len);
p += len;
}
if (_idx_show) {
len = snprintf(str_val, sizeof(str_val), "0x%03X: ", __i * RTW_BUFDUMP_BSIZE);
strncpy(p, str_val, len);
p += len;
}
for (__j =0; __j < RTW_BUFDUMP_BSIZE; __j++) {
idx = __i * RTW_BUFDUMP_BSIZE + __j;
len = snprintf(str_val, sizeof(str_val), "%02X%s", ptr[idx], (((__j + 1) % 4) == 0) ? " " : " ");
strncpy(p, str_val, len);
p += len;
}
_RTW_STR_DUMP_SEL(sel, str_out);
_rtw_memset(&str_out, '\0', sizeof(str_out));
}
p = &str_out[0];
if ((sel == RTW_DBGDUMP) && remain_byte) {
len = snprintf(str_val, sizeof(str_val), "%s", DRIVER_PREFIX);
strncpy(p, str_val, len);
p += len;
}
if (_idx_show && remain_byte) {
len = snprintf(str_val, sizeof(str_val), "0x%03X: ", block_num * RTW_BUFDUMP_BSIZE);
strncpy(p, str_val, len);
p += len;
}
for (__i = 0; __i < remain_byte; __i++) {
idx = block_num * RTW_BUFDUMP_BSIZE + __i;
len = snprintf(str_val, sizeof(str_val), "%02X%s", ptr[idx], (((__i + 1) % 4) == 0) ? " " : " ");
strncpy(p, str_val, len);
p += len;
}
_RTW_STR_DUMP_SEL(sel, str_out);
}
}
#endif
|
2301_81045437/rtl8852be
|
core/rtw_debug.c
|
C
|
agpl-3.0
| 204,636
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
static const u8 bcast_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#ifdef RTW_PHL_TEST_FPGA
static const u8 ap_addr[ETH_ALEN] = {0x00, 0xe0, 0x4c, 0x88, 0x52, 0xa0};
u8 ap_ssid[] = {'p','h','l','-','5','g'};
#else
static const u8 ap_addr[ETH_ALEN] = {0x00, 0xe0, 0x4c, 0x12, 0x34, 0x56};
u8 ap_ssid[] = {'f','a','k','e','a','p'};
#endif
u8 ap_ch = 1;
u16 ap_beacon_interval = 100; /* unit: ms */
u16 ap_capability_info = 0x0001;
u8 ap_datarate[] = {0x82, 0x84, 0x8b, 0x96, 0xc, 0x12, 0x18, 0x24};
int rtw_fakeap_tx(struct _ADAPTER *a, struct xmit_frame *frame)
{
u8 *data = frame->buf_addr + TXDESC_OFFSET;
u32 data_len = frame->attrib.last_txcmdsz;
struct sk_buff *skb;
u8 *buf;
if (GetFrameType(data) != WIFI_MGT_TYPE)
return _FAIL;
switch (get_frame_sub_type(data)) {
case WIFI_AUTH:
case WIFI_ASSOCREQ:
case WIFI_REASSOCREQ:
case WIFI_PROBEREQ:
break;
default:
return _FAIL;
}
skb = rtw_skb_alloc(data_len);
buf = skb_put(skb, data_len);
_rtw_memcpy(buf, data, data_len);
rtw_free_xmitbuf(&a->xmitpriv, frame->pxmitbuf);
rtw_free_xmitframe(&a->xmitpriv, frame);
skb_queue_tail(&adapter_to_dvobj(a)->fakeap.rxq, skb);
_set_workitem(&adapter_to_dvobj(a)->fakeap.work);
return _SUCCESS;
}
static void add_ie(struct sk_buff *skb, u8 index, u8 len, const u8 *source)
{
u8 *buf;
buf = skb_put(skb, 2 + len);
*buf = index;
*(buf + 1) = len;
if (len > 0)
_rtw_memcpy(buf + 2, source, len);
}
void rtw_fakeap_bcn_timer_hdl(void *p)
{
struct dvobj_priv *d;
struct sk_buff *skb;
struct rtw_ieee80211_hdr *wlanhdr;
int len;
u8 *buf;
u8 hdrlen;
d = (struct dvobj_priv*)p;
hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
len = hdrlen + _FIXED_IE_LENGTH_
+ 2 + sizeof(ap_ssid)
+ 2 + sizeof(ap_datarate)
+ 2 + 1;
skb = rtw_skb_alloc(len);
_rtw_memset(skb->data, 0, len);
buf = skb_put(skb, hdrlen);
wlanhdr = (struct rtw_ieee80211_hdr*)buf;
set_frame_sub_type(&wlanhdr->frame_ctl, WIFI_BEACON);
_rtw_memcpy(wlanhdr->addr1, bcast_addr, ETH_ALEN);
_rtw_memcpy(wlanhdr->addr2, ap_addr, ETH_ALEN);
_rtw_memcpy(wlanhdr->addr3, ap_addr, ETH_ALEN);
buf = skb_put(skb, _FIXED_IE_LENGTH_);
/* timestamp: 8 bytes */
/* beacon interval: 2 bytes */
*(u16*)(buf + 8) = ap_beacon_interval;
/* capability info: 2 bytes */
*(u16*)(buf + 10) = ap_capability_info;
/* SSID */
add_ie(skb, _SSID_IE_, sizeof(ap_ssid), ap_ssid);
/* supported rates... */
add_ie(skb, _SUPPORTEDRATES_IE_, sizeof(ap_datarate), ap_datarate);
/* DS parameter set */
add_ie(skb, _DSSET_IE_, 1, &ap_ch);
skb_queue_tail(&d->fakeap.rxq, skb);
_set_workitem(&d->fakeap.work);
}
static void rx_prepare(struct _ADAPTER *adapter, union recv_frame *r)
{
struct rx_pkt_attrib *a;
/* init recv_frame */
_rtw_init_listhead(&r->u.hdr.list);
r->u.hdr.len = 0;
a = &r->u.hdr.attrib;
_rtw_memset(a, 0, sizeof(*a));
/* fill sec related attrib, iv_len and icv_len will be filled by
* validate_recv_data_frame() */
a->crc_err = 0;
a->icv_err = 0;
a->encrypt = 0;
/* fill rx pkt attrib */
a->hdrlen = 0;
a->bw = CHANNEL_WIDTH_MAX;
a->pkt_len = 0;
a->pkt_rpt_type = NORMAL_RX;
a->drvinfo_sz = 0;
a->bdecrypted = 0;
a->qos = 0;
a->priority = 0;
a->amsdu = 0;
a->mdata = 0;
a->mfrag = 0;
a->seq_num = 0;
a->frag_num = 0;
a->data_rate = DESC_RATE6M;
a->ppdu_cnt = 1;
a->free_cnt = 0;
}
static union recv_frame* gen_probersp(struct _ADAPTER *a)
{
union recv_frame *r;
u32 len;
struct sk_buff *skb;
struct rtw_ieee80211_hdr *wlanhdr;
u8 *buf;
u8 hdrlen;
u8 ielen;
r = rtw_alloc_recvframe(&a->recvpriv.free_recv_queue);
if (!r) {
RTW_ERR("%s: alloc recvframe failed!\n", __func__);
return NULL;
}
rtw_init_recvframe(r, &a->recvpriv);
rx_prepare(a, r);
hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
len = RXDESC_OFFSET + hdrlen + _CAPABILITY_ + _STATUS_CODE_ + _ASOC_ID_
+ 2 + sizeof(ap_ssid)
+ 2 + sizeof(ap_datarate)
+ 2 + 1;
skb = rtw_skb_alloc(len);
_rtw_memset(skb->data, 0, len);
skb->dev = a->pnetdev;
skb_reserve(skb, RXDESC_OFFSET);
r->u.hdr.pkt = skb;
buf = skb_put(skb, hdrlen);
wlanhdr = (struct rtw_ieee80211_hdr*)buf;
set_frame_sub_type(&wlanhdr->frame_ctl, WIFI_PROBERSP);
_rtw_memcpy(wlanhdr->addr1, adapter_mac_addr(a), ETH_ALEN);
_rtw_memcpy(wlanhdr->addr2, ap_addr, ETH_ALEN);
_rtw_memcpy(wlanhdr->addr3, ap_addr, ETH_ALEN);
buf = skb_put(skb, _FIXED_IE_LENGTH_);
/* timestamp: 8 bytes */
/* beacon interval: 2 bytes */
*(u16*)(buf + 8) = ap_beacon_interval;
/* capability info: 2 bytes */
*(u16*)(buf + 10) = ap_capability_info;
/* SSID */
add_ie(skb, _SSID_IE_, sizeof(ap_ssid), ap_ssid);
/* supported rates... */
add_ie(skb, _SUPPORTEDRATES_IE_, sizeof(ap_datarate), ap_datarate);
/* DS parameter set */
add_ie(skb, _DSSET_IE_, 1, &ap_ch);
/* handle r->u.hdr.attrib */
/* handle recv_frame pointer */
r->u.hdr.len = skb->len;
r->u.hdr.rx_head = skb->head;
r->u.hdr.rx_data = skb->data;
r->u.hdr.rx_tail = skb_tail_pointer(skb);
r->u.hdr.rx_end = skb_end_pointer(skb);
return r;
}
static union recv_frame* gen_beacon(struct _ADAPTER *a, struct sk_buff *beacon)
{
union recv_frame *r;
u32 len;
struct sk_buff *skb;
struct rtw_ieee80211_hdr *wlanhdr;
u8 *buf;
u8 hdrlen;
r = rtw_alloc_recvframe(&a->recvpriv.free_recv_queue);
if (!r) {
RTW_ERR("%s: alloc recvframe failed!\n", __func__);
return NULL;
}
rtw_init_recvframe(r, &a->recvpriv);
rx_prepare(a, r);
hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
len = RXDESC_OFFSET + beacon->len;
skb = rtw_skb_alloc(len);
_rtw_memset(skb->data, 0, len);
skb->dev = a->pnetdev;
skb_reserve(skb, RXDESC_OFFSET);
r->u.hdr.pkt = skb;
buf = skb_put(skb, beacon->len);
_rtw_memcpy(buf, beacon->data, beacon->len);
/* handle r->u.hdr.attrib */
/* handle recv_frame pointer */
r->u.hdr.len = skb->len;
r->u.hdr.rx_head = skb->head;
r->u.hdr.rx_data = skb->data;
r->u.hdr.rx_tail = skb_tail_pointer(skb);
r->u.hdr.rx_end = skb_end_pointer(skb);
return r;
}
static union recv_frame *gen_auth(struct _ADAPTER *a, u8 *bssid)
{
union recv_frame *r;
u32 len;
struct sk_buff *skb;
struct rtw_ieee80211_hdr *wlanhdr;
u8 *buf;
u8 hdrlen;
r = rtw_alloc_recvframe(&a->recvpriv.free_recv_queue);
if (!r) {
RTW_ERR("%s: alloc recvframe failed!\n", __func__);
return NULL;
}
rtw_init_recvframe(r, &a->recvpriv);
rx_prepare(a, r);
hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
len = RXDESC_OFFSET + hdrlen
+ _AUTH_ALGM_NUM_ + _AUTH_SEQ_NUM_ + _STATUS_CODE_;
skb = rtw_skb_alloc(len);
_rtw_memset(skb->data, 0, len);
skb->dev = a->pnetdev;
skb_reserve(skb, RXDESC_OFFSET);
r->u.hdr.pkt = skb;
buf = skb_put(skb, hdrlen);
wlanhdr = (struct rtw_ieee80211_hdr*)buf;
set_frame_sub_type(&wlanhdr->frame_ctl, WIFI_AUTH);
_rtw_memcpy(wlanhdr->addr1, adapter_mac_addr(a), ETH_ALEN);
_rtw_memcpy(wlanhdr->addr2, bssid, ETH_ALEN);
_rtw_memcpy(wlanhdr->addr3, bssid, ETH_ALEN);
/* setting auth algo number */
buf = skb_put(skb, _AUTH_ALGM_NUM_);
*(u16*)buf = cpu_to_le16(0);;
/* setting auth seq number */
buf = skb_put(skb, _AUTH_SEQ_NUM_);
*(u16*)buf = cpu_to_le16(2);
/* setting status code... */
buf = skb_put(skb, _STATUS_CODE_);
*(u16*)buf = cpu_to_le16(0);
/* handle r->u.hdr.attrib */
/* handle recv_frame pointer */
r->u.hdr.len = skb->len;
r->u.hdr.rx_head = skb->head;
r->u.hdr.rx_data = skb->data;
r->u.hdr.rx_tail = skb_tail_pointer(skb);
r->u.hdr.rx_end = skb_end_pointer(skb);
return r;
}
static union recv_frame *gen_assocrsp(struct _ADAPTER *a, u8 *bssid)
{
union recv_frame *r;
u32 len;
struct sk_buff *skb;
struct rtw_ieee80211_hdr *wlanhdr;
u8 *buf;
u8 hdrlen;
r = rtw_alloc_recvframe(&a->recvpriv.free_recv_queue);
if (!r) {
RTW_ERR("%s: alloc recvframe failed!\n", __func__);
return NULL;
}
rtw_init_recvframe(r, &a->recvpriv);
rx_prepare(a, r);
hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
len = RXDESC_OFFSET + hdrlen
+ _CAPABILITY_ + _STATUS_CODE_ + _ASOC_ID_
+ 2 + sizeof(ap_datarate);
skb = rtw_skb_alloc(len);
_rtw_memset(skb->data, 0, len);
skb->dev = a->pnetdev;
skb_reserve(skb, RXDESC_OFFSET);
r->u.hdr.pkt = skb;
buf = skb_put(skb, hdrlen);
wlanhdr = (struct rtw_ieee80211_hdr*)buf;
set_frame_sub_type(&wlanhdr->frame_ctl, WIFI_ASSOCRSP);
_rtw_memcpy(wlanhdr->addr1, adapter_mac_addr(a), ETH_ALEN);
_rtw_memcpy(wlanhdr->addr2, bssid, ETH_ALEN);
_rtw_memcpy(wlanhdr->addr3, bssid, ETH_ALEN);
/* capability info: 2 bytes */
buf = skb_put(skb, _CAPABILITY_);
*(u16*)buf = ap_capability_info;
/* status code: 2 bytes */
buf = skb_put(skb, _STATUS_CODE_);
*(u16*)buf = 0;
/* AID: 2 bytes */
buf = skb_put(skb, _ASOC_ID_);
*(u16*)buf = 100;
/* supported rates... */
add_ie(skb, _SUPPORTEDRATES_IE_, sizeof(ap_datarate), ap_datarate);
/* handle r->u.hdr.attrib */
/* handle recv_frame pointer */
r->u.hdr.len = skb->len;
r->u.hdr.rx_head = skb->head;
r->u.hdr.rx_data = skb->data;
r->u.hdr.rx_tail = skb_tail_pointer(skb);
r->u.hdr.rx_end = skb_end_pointer(skb);
// recvframe_put(r, buflen);
// pre_recv_entry(r, NULL);
return r;
}
static union recv_frame* fakeap_dispatcher(struct _ADAPTER *a,
struct sk_buff *skb)
{
u8 *pframe;
union recv_frame *rframe = NULL;
pframe = skb->data;
RTW_INFO("A1-" MAC_FMT "\n", MAC_ARG(GetAddr1Ptr(pframe)));
RTW_INFO("A2-" MAC_FMT "\n", MAC_ARG(get_addr2_ptr(pframe)));
RTW_INFO("A3-" MAC_FMT "\n", MAC_ARG(GetAddr3Ptr(pframe)));
if (GetFrameType(pframe) != WIFI_MGT_TYPE)
return NULL;
switch (get_frame_sub_type(pframe)) {
case WIFI_AUTH:
{
u16 algo, seq;
algo = le16_to_cpu(*(u16 *)(pframe + WLAN_HDR_A3_LEN));
seq = le16_to_cpu(*(u16 *)(pframe + WLAN_HDR_A3_LEN + 2));
if ((algo == 0) && (seq == 1))
rframe = gen_auth(a, GetAddr1Ptr(pframe));
}
break;
case WIFI_ASSOCREQ:
case WIFI_REASSOCREQ:
rframe = gen_assocrsp(a, GetAddr1Ptr(pframe));
break;
case WIFI_PROBEREQ:
rframe = gen_probersp(a);
break;
case WIFI_BEACON:
rframe = gen_beacon(a, skb);
default:
break;
}
return rframe;
}
extern sint validate_recv_frame(struct _ADAPTER*, union recv_frame*);
void rtw_fakeap_work(struct work_struct *work)
{
struct dvobj_priv *d;
struct _ADAPTER *a;
struct sk_buff_head *pktq;
struct sk_buff *skb, *tmp;
u8 *ta, *ra;
union recv_frame *rframe;
int i;
d = container_of(work, struct dvobj_priv, fakeap.work);
pktq = &d->fakeap.rxq;
skb_queue_walk_safe(pktq, skb, tmp) {
__skb_unlink(skb, pktq);
ta = get_addr2_ptr(skb->data);
ra = GetAddr1Ptr(skb->data);
if (is_broadcast_mac_addr(ra)
&& (_rtw_memcmp(ta, ap_addr, ETH_ALEN)==_TRUE)
&& (get_frame_sub_type(skb->data) == WIFI_BEACON)) {
for (i = 0; i < d->iface_nums; i++) {
a = d->padapters[i];
if (a) {
rframe = fakeap_dispatcher(a, skb);
if (rframe) {
validate_recv_frame(a, rframe);
rframe = NULL;
}
}
}
} else {
a = rtw_get_iface_by_macddr(dvobj_get_primary_adapter(d),
ta);
if (a)
rframe = fakeap_dispatcher(a, skb);
}
rtw_skb_free(skb);
if (rframe) {
validate_recv_frame(a, rframe);
rframe = NULL;
}
}
}
|
2301_81045437/rtl8852be
|
core/rtw_fake_ap.c
|
C
|
agpl-3.0
| 11,840
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#ifdef CONFIG_RTW_80211R
#ifndef RTW_FT_DBG
#define RTW_FT_DBG 0
#endif
#if RTW_FT_DBG
#define RTW_FT_INFO(fmt, arg...) \
RTW_INFO(fmt, arg)
#define RTW_FT_DUMP(str, data, len) \
RTW_INFO_DUMP(str, data, len)
#else
#define RTW_FT_INFO(fmt, arg...) do {} while (0)
#define RTW_FT_DUMP(str, data, len) do {} while (0)
#endif
void rtw_ft_info_init(struct ft_roam_info *pft)
{
_rtw_memset(pft, 0, sizeof(struct ft_roam_info));
pft->ft_flags = 0
| RTW_FT_EN
| RTW_FT_OTD_EN
#ifdef CONFIG_RTW_BTM_ROAM
| RTW_FT_BTM_ROAM
#endif
;
pft->ft_updated_bcn = _FALSE;
RTW_FT_INFO("%s : ft_flags=0x%02x\n", __func__, pft->ft_flags);
}
ssize_t rtw_ft_proc_flags_set(struct file *file,
const char __user *buffer, size_t count, loff_t *pos, void *data)
{
struct net_device *dev = data;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
char tmp[32];
u8 flags;
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%hhx", &flags);
if (num == 1)
adapter->mlmepriv.ft_roam.ft_flags = flags;
}
return count;
}
int rtw_ft_proc_flags_get(struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
RTW_PRINT_SEL(m, "0x%02x\n", adapter->mlmepriv.ft_roam.ft_flags);
return 0;
}
u8 rtw_ft_chk_roaming_candidate(
_adapter *padapter, struct wlan_network *competitor)
{
u8 *pmdie;
u32 mdie_len = 0;
struct ft_roam_info *pft_roam = &(padapter->mlmepriv.ft_roam);
if (!(pmdie = rtw_get_ie(&competitor->network.IEs[12], _MDIE_,
&mdie_len, competitor->network.IELength-12))) {
RTW_INFO("FT : MDIE not foud in competitor!\n");
return _FALSE;
}
if (!_rtw_memcmp(&pft_roam->mdid, (pmdie+2), 2)) {
RTW_INFO("FT : unmatched MDIE!\n");
return _FALSE;
}
/*The candidate don't support over-the-DS*/
if (rtw_ft_valid_otd_candidate(padapter, pmdie)) {
RTW_INFO("FT: ignore the candidate("
MAC_FMT ") for over-the-DS\n",
MAC_ARG(competitor->network.MacAddress));
/* rtw_ft_clr_flags(padapter, RTW_FT_PEER_OTD_EN); */
return _FALSE;
}
if (rtw_ft_chk_flags(padapter, RTW_FT_TEST_RSSI_ROAM)) {
if (!_rtw_memcmp(
padapter->mlmepriv.cur_network.network.MacAddress,
competitor->network.MacAddress, ETH_ALEN)) {
competitor->network.PhyInfo.rssi +=20;
RTW_FT_INFO("%s : update "MAC_FMT
" RSSI to %d for RTW_FT_TEST_RSSI_ROAM\n",
__func__, MAC_ARG(competitor->network.MacAddress),
(int)competitor->network.PhyInfo.rssi);
rtw_ft_clr_flags(padapter, RTW_FT_TEST_RSSI_ROAM);
}
}
return _TRUE;
}
void rtw_ft_update_stainfo(_adapter *padapter, WLAN_BSSID_EX *pnetwork)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta = NULL;
psta = rtw_get_stainfo(pstapriv, pnetwork->MacAddress);
if (psta == NULL)
psta = rtw_alloc_stainfo(pstapriv, pnetwork->MacAddress);
if (padapter->securitypriv.dot11AuthAlgrthm ==
dot11AuthAlgrthm_8021X) {
padapter->securitypriv.binstallGrpkey = _FALSE;
padapter->securitypriv.busetkipkey = _FALSE;
padapter->securitypriv.bgrpkey_handshake = _FALSE;
psta->ieee8021x_blocked = _TRUE;
psta->dot118021XPrivacy = \
padapter->securitypriv.dot11PrivacyAlgrthm;
_rtw_memset((u8 *)&psta->dot118021x_UncstKey,
0, sizeof(union Keytype));
_rtw_memset((u8 *)&psta->dot11tkiprxmickey,
0, sizeof(union Keytype));
_rtw_memset((u8 *)&psta->dot11tkiptxmickey,
0, sizeof(union Keytype));
}
}
void rtw_ft_reassoc_event_callback(_adapter *padapter, u8 *pbuf)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
struct ft_roam_info *pft_roam = &(pmlmepriv->ft_roam);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)&(pmlmeinfo->network);
struct cfg80211_ft_event_params ft_evt_parms;
_rtw_memset(&ft_evt_parms, 0, sizeof(ft_evt_parms));
rtw_ft_update_stainfo(padapter, pnetwork);
ft_evt_parms.ies_len = pft_roam->ft_event.ies_len;
ft_evt_parms.ies = rtw_zmalloc(ft_evt_parms.ies_len);
if (ft_evt_parms.ies) {
_rtw_memcpy((void *)ft_evt_parms.ies,
pft_roam->ft_event.ies, ft_evt_parms.ies_len);
} else
goto err_2;
ft_evt_parms.target_ap = rtw_zmalloc(ETH_ALEN);
if (ft_evt_parms.target_ap) {
_rtw_memcpy((void *)ft_evt_parms.target_ap,
pstassoc->macaddr, ETH_ALEN);
} else
goto err_1;
ft_evt_parms.ric_ies = pft_roam->ft_event.ric_ies;
ft_evt_parms.ric_ies_len = pft_roam->ft_event.ric_ies_len;
/* It's a KERNEL issue between v4.11 ~ v4.16,
* <= v4.10, NLMSG_DEFAULT_SIZE is used for nlmsg_new().
* v4.11 ~ v4.16, only used "100 + >ric_ies_len" for nlmsg_new()
* even then DRIVER don't support RIC.
* >= v4.17, issue should correct as "100 + ies_len + ric_ies_len".
*/
#if ((LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)) && \
(LINUX_VERSION_CODE < KERNEL_VERSION(4, 17, 0)))
if (!ft_evt_parms.ric_ies_len)
ft_evt_parms.ric_ies_len = ft_evt_parms.ies_len;
else
ft_evt_parms.ric_ies_len += ft_evt_parms.ies_len;
#endif
rtw_ft_lock_set_status(padapter, RTW_FT_AUTHENTICATED_STA);
rtw_cfg80211_ft_event(padapter, &ft_evt_parms);
RTW_INFO("%s: to "MAC_FMT"\n", __func__,
MAC_ARG(ft_evt_parms.target_ap));
rtw_mfree((u8 *)pft_roam->ft_event.target_ap, ETH_ALEN);
err_1:
rtw_mfree((u8 *)ft_evt_parms.ies, ft_evt_parms.ies_len);
err_2:
return;
}
void rtw_ft_validate_akm_type(_adapter *padapter,
struct wlan_network *pnetwork)
{
struct security_priv *psecuritypriv = &(padapter->securitypriv);
struct ft_roam_info *pft_roam = &(padapter->mlmepriv.ft_roam);
u32 tmp_len;
u8 *ptmp;
/*IEEE802.11-2012 Std. Table 8-101-AKM suite selectors*/
if (rtw_ft_valid_akm(padapter, psecuritypriv->rsn_akm_suite_type)) {
ptmp = rtw_get_ie(&pnetwork->network.IEs[12],
_MDIE_, &tmp_len,
(pnetwork->network.IELength-12));
if (ptmp) {
pft_roam->mdid = *(u16 *)(ptmp+2);
pft_roam->ft_cap = *(ptmp+4);
RTW_INFO("FT: target "MAC_FMT
" mdid=(0x%2x), capacity=(0x%2x)\n",
MAC_ARG(pnetwork->network.MacAddress),
pft_roam->mdid, pft_roam->ft_cap);
rtw_ft_set_flags(padapter, RTW_FT_PEER_EN);
RTW_FT_INFO("%s : peer support FTOTA(0x%02x),"
" ft_roam_on_expired=0x%02x\n",
__func__, pft_roam->ft_flags,
pft_roam->ft_roam_on_expired);
if (rtw_ft_otd_roam_en(padapter)) {
rtw_ft_set_flags(padapter, RTW_FT_PEER_OTD_EN);
RTW_FT_INFO("%s : peer support FTOTD(0x%02x)\n",
__func__, pft_roam->ft_flags);
} else {
pft_roam->ft_cap &= ~BIT(0);
rtw_ft_clr_flags(padapter, RTW_FT_PEER_OTD_EN);
RTW_FT_INFO("%s : update mdid=0x%02x, "
"cap=0x%02x, flag=0x%02x\n",
__func__, pft_roam->mdid,
pft_roam->ft_cap,
pft_roam->ft_flags);
}
} else {
/* Don't use FT roaming if target AP cannot support FT */
rtw_ft_clr_flags(padapter,
(RTW_FT_PEER_EN|RTW_FT_PEER_OTD_EN));
rtw_ft_reset_status(padapter);
}
} else {
/* It could be a non-FT connection */
rtw_ft_clr_flags(padapter,
(RTW_FT_PEER_EN|RTW_FT_PEER_OTD_EN));
rtw_ft_reset_status(padapter);
}
RTW_FT_INFO("%s : ft_flags=0x%02x\n", __func__, pft_roam->ft_flags);
}
void rtw_ft_update_bcn(_adapter *padapter, union recv_frame *precv_frame)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
u8 *pframe = precv_frame->u.hdr.rx_data;
uint len = precv_frame->u.hdr.len;
WLAN_BSSID_EX *pbss;
if (rtw_ft_chk_status(padapter,RTW_FT_ASSOCIATED_STA)
&& (pmlmepriv->ft_roam.ft_updated_bcn == _FALSE)) {
pbss = (WLAN_BSSID_EX*)rtw_malloc(sizeof(WLAN_BSSID_EX));
if (pbss) {
if (collect_bss_info(
padapter, precv_frame, pbss) == _SUCCESS) {
struct beacon_keys recv_beacon;
rtw_update_network(
&(pmlmepriv->cur_network.network),
pbss, padapter, _TRUE);
/* Move into rtw_get_bcn_keys */
/* rtw_get_bcn_info(&(pmlmepriv->cur_network)); */
/* update bcn keys */
if (rtw_get_bcn_keys(padapter, pframe, len,
&recv_beacon) == _TRUE) {
RTW_FT_INFO("%s: beacon keys ready\n",
__func__);
_rtw_memcpy(
&pmlmepriv->cur_beacon_keys,
&recv_beacon,
sizeof(recv_beacon));
if (is_hidden_ssid(
recv_beacon.ssid,
recv_beacon.ssid_len)) {
_rtw_memcpy(
pmlmepriv->cur_beacon_keys.ssid,
pmlmeinfo->network.Ssid.Ssid,
IW_ESSID_MAX_SIZE);
pmlmepriv->cur_beacon_keys.ssid_len = \
pmlmeinfo->network.Ssid.SsidLength;
}
} else {
RTW_ERR("%s: get beacon keys failed\n",
__func__);
_rtw_memset(
&pmlmepriv->cur_beacon_keys,
0, sizeof(recv_beacon));
}
#ifdef CONFIG_BCN_CNT_CONFIRM_HDL
pmlmepriv->new_beacon_cnts = 0;
#endif
}
rtw_mfree((u8*)pbss, sizeof(WLAN_BSSID_EX));
}
/* check the vendor of the assoc AP */
pmlmeinfo->assoc_AP_vendor =
check_assoc_AP(
pframe + sizeof(struct rtw_ieee80211_hdr_3addr),
(len - sizeof(struct rtw_ieee80211_hdr_3addr))
);
/* update TSF Value */
update_TSF(pmlmeext, pframe, len);
pmlmeext->bcn_cnt = 0;
pmlmeext->last_bcn_cnt = 0;
pmlmepriv->ft_roam.ft_updated_bcn = _TRUE;
}
}
void rtw_ft_start_clnt_join(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct ft_roam_info *pft_roam = &(pmlmepriv->ft_roam);
if (rtw_ft_otd_roam(padapter)) {
pmlmeinfo->state = WIFI_FW_AUTH_SUCCESS | WIFI_FW_STATION_STATE;
pft_roam->ft_event.ies =
(pft_roam->ft_action + \
sizeof(struct rtw_ieee80211_hdr_3addr) + 16);
pft_roam->ft_event.ies_len =
(pft_roam->ft_action_len - \
sizeof(struct rtw_ieee80211_hdr_3addr));
/*Not support RIC*/
pft_roam->ft_event.ric_ies = NULL;
pft_roam->ft_event.ric_ies_len = 0;
rtw_ft_report_evt(padapter);
return;
}
pmlmeinfo->state = WIFI_FW_AUTH_NULL | WIFI_FW_STATION_STATE;
start_clnt_auth(padapter);
}
u8 rtw_ft_update_rsnie(
_adapter *padapter, u8 bwrite,
struct pkt_attrib *pattrib, u8 **pframe)
{
struct ft_roam_info *pft_roam = &(padapter->mlmepriv.ft_roam);
u8 *pie;
u32 len;
pie = rtw_get_ie(pft_roam->updated_ft_ies, EID_WPA2, &len,
pft_roam->updated_ft_ies_len);
if (!bwrite)
return (pie)?_SUCCESS:_FAIL;
if (pie) {
*pframe = rtw_set_ie(((u8 *)*pframe), EID_WPA2, len,
pie+2, &(pattrib->pktlen));
} else
return _FAIL;
return _SUCCESS;
}
static u8 rtw_ft_update_mdie(
_adapter *padapter, struct pkt_attrib *pattrib, u8 **pframe)
{
struct ft_roam_info *pft_roam = &(padapter->mlmepriv.ft_roam);
u8 *pie, mdie[3];
u32 len = 3;
if (rtw_ft_roam(padapter)) {
if ((pie = rtw_get_ie(pft_roam->updated_ft_ies, _MDIE_,
&len, pft_roam->updated_ft_ies_len))) {
pie = (pie + 2); /* ignore md-id & length */
} else
return _FAIL;
} else {
*((u16 *)&mdie[0]) = pft_roam->mdid;
mdie[2] = pft_roam->ft_cap;
pie = &mdie[0];
}
*pframe = rtw_set_ie(((u8 *)*pframe), _MDIE_,
len, pie, &(pattrib->pktlen));
return _SUCCESS;
}
static u8 rtw_ft_update_ftie(
_adapter *padapter, struct pkt_attrib *pattrib, u8 **pframe)
{
struct ft_roam_info *pft_roam = &(padapter->mlmepriv.ft_roam);
u8 *pie;
u32 len;
if ((pie = rtw_get_ie(pft_roam->updated_ft_ies, _FTIE_, &len,
pft_roam->updated_ft_ies_len)) != NULL) {
*pframe = rtw_set_ie(*pframe, _FTIE_, len,
(pie+2), &(pattrib->pktlen));
} else
return _FAIL;
return _SUCCESS;
}
void rtw_ft_build_auth_req_ies(_adapter *padapter,
struct pkt_attrib *pattrib, u8 **pframe)
{
u8 ftie_append = _TRUE;
if (!pattrib || !(*pframe))
return;
if (!rtw_ft_roam(padapter))
return;
ftie_append = rtw_ft_update_rsnie(padapter, _TRUE, pattrib, pframe);
rtw_ft_update_mdie(padapter, pattrib, pframe);
if (ftie_append)
rtw_ft_update_ftie(padapter, pattrib, pframe);
}
void rtw_ft_build_assoc_req_ies(_adapter *padapter,
u8 is_reassoc, struct pkt_attrib *pattrib, u8 **pframe)
{
if (!pattrib || !(*pframe))
return;
if (rtw_ft_chk_flags(padapter, RTW_FT_PEER_EN))
rtw_ft_update_mdie(padapter, pattrib, pframe);
if ((!is_reassoc) || (!rtw_ft_roam(padapter)))
return;
if (rtw_ft_update_rsnie(padapter, _FALSE, pattrib, pframe))
rtw_ft_update_ftie(padapter, pattrib, pframe);
}
u8 rtw_ft_update_auth_rsp_ies(_adapter *padapter, u8 *pframe, u32 len)
{
u8 ret = _SUCCESS;
u8 target_ap_addr[ETH_ALEN] = {0};
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct ft_roam_info *pft_roam = &(pmlmepriv->ft_roam);
if (!rtw_ft_roam(padapter))
return _FAIL;
/*rtw_ft_report_reassoc_evt already,
* and waiting for cfg80211_rtw_update_ft_ies */
if (rtw_ft_authed_sta(padapter))
return ret;
if (!pframe || !len)
return _FAIL;
rtw_buf_update(&pmlmepriv->auth_rsp,
&pmlmepriv->auth_rsp_len, pframe, len);
pft_roam->ft_event.ies =
(pmlmepriv->auth_rsp + \
sizeof(struct rtw_ieee80211_hdr_3addr) + 6);
pft_roam->ft_event.ies_len =
(pmlmepriv->auth_rsp_len - \
sizeof(struct rtw_ieee80211_hdr_3addr) - 6);
/*Not support RIC*/
pft_roam->ft_event.ric_ies = NULL;
pft_roam->ft_event.ric_ies_len = 0;
_rtw_memcpy(target_ap_addr, pmlmepriv->assoc_bssid, ETH_ALEN);
rtw_ft_report_reassoc_evt(padapter, target_ap_addr);
return ret;
}
static void rtw_ft_start_clnt_action(_adapter *padapter, u8 *pTargetAddr)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
rtw_ft_set_status(padapter, RTW_FT_REQUESTING_STA);
rtw_ft_issue_action_req(padapter, pTargetAddr);
_set_timer(&pmlmeext->ft_link_timer, REASSOC_TO);
}
void rtw_ft_start_roam(_adapter *padapter, u8 *pTargetAddr)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
if (rtw_ft_otd_roam(padapter)) {
RTW_FT_INFO("%s : try OTD roaming\n", __func__);
rtw_ft_start_clnt_action(padapter, pTargetAddr);
} else {
/* wait a little time to retrieve packets buffered
in the current ap while scan*/
RTW_FT_INFO("%s : start roaming timer\n", __func__);
_set_timer(&pmlmeext->ft_roam_timer, 30);
}
}
void rtw_ft_issue_action_req(_adapter *padapter, u8 *pTargetAddr)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct xmit_frame *pmgntframe;
struct rtw_ieee80211_hdr *pwlanhdr;
struct pkt_attrib *pattrib;
u8 *pframe;
u8 category = RTW_WLAN_CATEGORY_FT;
u8 action = RTW_WLAN_ACTION_FT_REQ;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
pwlanhdr->frame_ctl = 0;
_rtw_memcpy(pwlanhdr->addr1,
get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3,
get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
_rtw_memcpy(pframe, adapter_mac_addr(padapter), ETH_ALEN);
pframe += ETH_ALEN;
pattrib->pktlen += ETH_ALEN;
_rtw_memcpy(pframe, pTargetAddr, ETH_ALEN);
pframe += ETH_ALEN;
pattrib->pktlen += ETH_ALEN;
rtw_ft_update_mdie(padapter, pattrib, &pframe);
if (rtw_ft_update_rsnie(padapter, _TRUE, pattrib, &pframe))
rtw_ft_update_ftie(padapter, pattrib, &pframe);
RTW_INFO("FT : issue RTW_WLAN_ACTION_FT_REQ\n");
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
void rtw_ft_report_evt(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct ft_roam_info *pft_roam = &(pmlmepriv->ft_roam);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)&(pmlmeinfo->network);
struct cfg80211_ft_event_params ft_evt_parms;
_rtw_memset(&ft_evt_parms, 0, sizeof(ft_evt_parms));
rtw_ft_update_stainfo(padapter, pnetwork);
if (!pnetwork)
goto err_2;
ft_evt_parms.ies_len = pft_roam->ft_event.ies_len;
ft_evt_parms.ies = rtw_zmalloc(ft_evt_parms.ies_len);
if (ft_evt_parms.ies) {
_rtw_memcpy((void *)ft_evt_parms.ies,
pft_roam->ft_event.ies, ft_evt_parms.ies_len);
} else
goto err_2;
ft_evt_parms.target_ap = rtw_zmalloc(ETH_ALEN);
if (ft_evt_parms.target_ap) {
_rtw_memcpy((void *)ft_evt_parms.target_ap,
pnetwork->MacAddress, ETH_ALEN);
} else
goto err_1;
ft_evt_parms.ric_ies = pft_roam->ft_event.ric_ies;
ft_evt_parms.ric_ies_len = pft_roam->ft_event.ric_ies_len;
/* It's a KERNEL issue between v4.11 ~ v4.16,
* <= v4.10, NLMSG_DEFAULT_SIZE is used for nlmsg_new().
* v4.11 ~ v4.16, only used "100 + >ric_ies_len" for nlmsg_new()
* even then DRIVER don't support RIC.
* >= v4.17, issue should correct as "100 + ies_len + ric_ies_len".
*/
#if ((LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)) && \
(LINUX_VERSION_CODE < KERNEL_VERSION(4, 17, 0)))
ft_evt_parms.ric_ies_len = (ft_evt_parms.ies_len <= 100 )?
(0):(ft_evt_parms.ies_len - 100);
#endif
rtw_ft_lock_set_status(padapter, RTW_FT_AUTHENTICATED_STA);
rtw_cfg80211_ft_event(padapter, &ft_evt_parms);
RTW_INFO("FT: rtw_ft_report_evt\n");
rtw_mfree((u8 *)pft_roam->ft_event.target_ap, ETH_ALEN);
err_1:
rtw_mfree((u8 *)ft_evt_parms.ies, ft_evt_parms.ies_len);
err_2:
return;
}
void rtw_ft_report_reassoc_evt(_adapter *padapter, u8 *pMacAddr)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(padapter)->cmdpriv);
struct cmd_obj *pcmd_obj = NULL;
struct stassoc_event *passoc_sta_evt = NULL;
struct rtw_evt_header *evt_hdr = NULL;
u8 *pevtcmd = NULL;
u32 cmdsz = 0;
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL)
return;
cmdsz = (sizeof(struct stassoc_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
return;
}
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->padapter = padapter;
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct stassoc_event);
evt_hdr->id = EVT_FT_REASSOC;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
passoc_sta_evt = \
(struct stassoc_event *)(pevtcmd + \
sizeof(struct rtw_evt_header));
_rtw_memcpy((unsigned char *)(&(passoc_sta_evt->macaddr)),
pMacAddr, ETH_ALEN);
rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
}
void rtw_ft_link_timer_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct ft_roam_info *pft_roam = &(pmlmepriv->ft_roam);
if (rtw_ft_chk_status(padapter, RTW_FT_REQUESTING_STA)) {
if (pft_roam->ft_req_retry_cnt < RTW_FT_ACTION_REQ_LMT) {
pft_roam->ft_req_retry_cnt++;
rtw_ft_issue_action_req(padapter,
(u8 *)pmlmepriv->roam_network->network.MacAddress);
_set_timer(&pmlmeext->ft_link_timer, REASSOC_TO);
} else {
pft_roam->ft_req_retry_cnt = 0;
if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) {
rtw_ft_set_status(padapter,
RTW_FT_ASSOCIATED_STA);
} else
rtw_ft_reset_status(padapter);
}
}
}
void rtw_ft_roam_timer_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
RTW_FT_INFO("%s : try roaming\n", __func__);
receive_disconnect(padapter,
pmlmepriv->cur_network.network.MacAddress,
WLAN_REASON_ACTIVE_ROAM, _FALSE);
}
void rtw_ft_roam_status_reset(_adapter *padapter)
{
struct ft_roam_info *pft_roam = &(padapter->mlmepriv.ft_roam);
if ((rtw_to_roam(padapter) > 0) &&
(!rtw_ft_chk_status(padapter, RTW_FT_REQUESTED_STA))) {
rtw_ft_reset_status(padapter);
}
padapter->mlmepriv.ft_roam.ft_updated_bcn = _FALSE;
}
void rtw_ft_peer_info_init(struct sta_info *psta)
{
struct rtw_sta_ft_info_t *peer = &(psta->ft_peer);
_rtw_memset(peer, 0, sizeof(struct rtw_sta_ft_info_t));
}
void rtw_ft_peer_info_free(struct sta_info *psta)
{
struct rtw_sta_ft_info_t *peer = &(psta->ft_peer);
rtw_buf_free(&peer->md_ie, &peer->md_len);
rtw_buf_free(&peer->rsn_ie, &peer->rsn_len);
rtw_buf_free(&peer->ft_ie, &peer->ft_len);
}
int rtw_ft_update_sta_ies(_adapter *padapter,
struct cfg80211_update_ft_ies_params *ie)
{
struct security_priv *psecuritypriv = &(padapter->securitypriv);
struct sta_priv *pstapriv = &(padapter->stapriv);
struct sta_info *psta;
struct rtw_sta_ft_info_t *peer_info;
u8 *ptr, *paddr;
u32 len;
int ret = 0;
if (!CHECK_BIT(WLAN_AKM_TYPE_FT_PSK, psecuritypriv->akmp)
&& !CHECK_BIT(WLAN_AKM_TYPE_FT_8021X, psecuritypriv->akmp)
&& !CHECK_BIT(WLAN_AKM_TYPE_FT_OVER_SAE, psecuritypriv->akmp)) {
RTW_FT_INFO("%s : AKM=0x%x\n", __func__, psecuritypriv->akmp);
goto exit;
}
if ((ie->ie_len == 0) ||
(ie->ie_len >= RTW_FT_MAX_IE_SZ)) {
ret = - EINVAL;
goto exit;
}
if ((ptr = rtw_get_ie(ie->ie, WLAN_EID_VENDOR_SPECIFIC,
&len , ie->ie_len)) == NULL) {
RTW_ERR("FT : no station mac address found in ies\n");
ret = -EINVAL;
goto exit;
}
if (len != ETH_ALEN) {
RTW_ERR("FT : invalid station mac length(%u)\n", len);
ret = -EINVAL;
goto exit;
}
paddr = ptr + 2;
if ((psta = rtw_get_stainfo(pstapriv, paddr)) == NULL) {
RTW_ERR("FT : sta "MAC_FMT" not found!\n", MAC_ARG(paddr));
ret = -EINVAL;
goto exit;
}
RTW_FT_INFO("%s : update sta "MAC_FMT" ie, len=%lu\n",
__func__, MAC_ARG(paddr), ie->ie_len);
RTW_FT_DUMP("ie = ", ie->ie, ie->ie_len);
peer_info = &(psta->ft_peer);
if ((ptr = rtw_get_ie(ie->ie, EID_WPA2, &len , ie->ie_len)) != NULL) {
rtw_buf_update(&peer_info->rsn_ie,
&peer_info->rsn_len, ptr + 2, len);
RTW_FT_DUMP("rsn_ie = ", peer_info->rsn_ie,
peer_info->rsn_len);
}
if ((ptr = rtw_get_ie(ie->ie, _MDIE_, &len , ie->ie_len)) != NULL) {
rtw_buf_update(&peer_info->md_ie,
&peer_info->md_len, ptr + 2, len);
RTW_FT_DUMP("md_ie = ",
peer_info->md_ie, peer_info->md_len);
}
if ((ptr = rtw_get_ie(ie->ie, _FTIE_, &len , ie->ie_len)) != NULL) {
rtw_buf_update(&peer_info->ft_ie,
&peer_info->ft_len, ptr + 2, len);
RTW_FT_DUMP("ft_ie = ",
peer_info->ft_ie, peer_info->ft_len);
}
if (psta->authalg == WLAN_AUTH_FT)
issue_asocrsp(padapter, 0, psta, WIFI_REASSOCRSP);
exit:
return ret;
}
void rtw_ft_update_assocresp_ies(struct net_device *net,
struct cfg80211_ap_settings *settings)
{
_adapter *padapter = (_adapter *)rtw_netdev_priv(net);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct ft_roam_info *pinfo = &(pmlmepriv->ft_roam);
u8 *ie, *bcn_tail_ies, *assocrsp_ies;
int ielen, bcn_tail_len, assocrsp_ies_len, ret = 0;
bcn_tail_ies = (u8 *)settings->beacon.tail;
bcn_tail_len = (u32)settings->beacon.tail_len;
assocrsp_ies = (u8 *)settings->beacon.assocresp_ies;
assocrsp_ies_len = (u32)settings->beacon.assocresp_ies_len;
if ((bcn_tail_len > 0) &&
((ie = rtw_get_ie(bcn_tail_ies, _MDIE_,
&ielen , bcn_tail_len)) != NULL)) {
pinfo->mdid = *(u16 *)(ie + 2);
pinfo->ft_cap = *(ie + 4);
RTW_FT_INFO("%s : mdid = 0x%04x, cap=0x%02x\n",
__func__, pinfo->mdid, pinfo->ft_cap);
}
if ((assocrsp_ies_len > 0) &&
((ie = rtw_get_ie(assocrsp_ies, _FTIE_,
&ielen , assocrsp_ies_len)) != NULL)) {
_rtw_memset(pinfo->updated_ft_ies, 0, RTW_FT_MAX_IE_SZ);
_rtw_memcpy(pinfo->updated_ft_ies, ie + 2, ielen);
pinfo->updated_ft_ies_len = ielen;
RTW_FT_DUMP("FT : ft ie = ", ie + 2, ielen);
}
}
void rtw_ft_process_ft_auth_rsp(_adapter *padapter, u8 *pframe, u32 len)
{
struct sta_priv *pstapriv = &(padapter->stapriv);
struct sta_info *psta = NULL;
u8 *ptr;
u32 plen;
ptr = pframe + IEEE80211_3ADDR_LEN + _AUTH_IE_OFFSET_;
plen = len - IEEE80211_3ADDR_LEN - _AUTH_IE_OFFSET_;
psta = rtw_get_stainfo(pstapriv, GetAddr1Ptr(pframe));
if (psta) {
_rtw_spinlock_bh(&psta->lock);
psta->state &= ~WIFI_FW_AUTH_NULL;
psta->state |= WIFI_FW_AUTH_SUCCESS;
psta->expire_to = pstapriv->assoc_to;
_rtw_spinunlock_bh(&psta->lock);
}
}
void rtw_ft_build_assoc_rsp_ies(_adapter *padapter,
struct sta_info *psta, struct pkt_attrib *pattrib, u8 **pframe)
{
struct ft_roam_info *prinfo = &(padapter->mlmepriv.ft_roam);
struct rtw_sta_ft_info_t *peer_info;
u8 *pie, mdie[3] = {0};
u32 ielen;
if (psta == NULL)
return;
if (psta->authalg != WLAN_AUTH_FT) {
*((u16 *)&mdie[0]) = prinfo->mdid;
mdie[2] = prinfo->ft_cap;
pie = mdie;
ielen = 3;
if (prinfo->mdid > 0) {
*pframe = rtw_set_ie(((u8 *)*pframe),
_MDIE_, ielen , pie, &(pattrib->pktlen));
}
if (prinfo->updated_ft_ies_len > 0) {
*pframe = rtw_set_ie(((u8 *)*pframe),
_FTIE_, prinfo->updated_ft_ies_len,
prinfo->updated_ft_ies, &(pattrib->pktlen));
}
} else {
peer_info = &(psta->ft_peer);
if (peer_info->rsn_len > 0) {
*pframe = rtw_set_ie(((u8 *)*pframe), EID_WPA2,
peer_info->rsn_len, peer_info->rsn_ie,
&(pattrib->pktlen));
}
if (peer_info->md_len > 0) {
*pframe = rtw_set_ie(((u8 *)*pframe), _MDIE_,
peer_info->md_len, peer_info->md_ie,
&(pattrib->pktlen));
}
if (peer_info->ft_len > 0) {
*pframe = rtw_set_ie(((u8 *)*pframe), _FTIE_,
peer_info->ft_len, peer_info->ft_ie,
&(pattrib->pktlen));
}
}
}
#endif /* CONFIG_RTW_80211R */
|
2301_81045437/rtl8852be
|
core/rtw_ft.c
|
C
|
agpl-3.0
| 26,834
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_HE_C
#include <drv_types.h>
#ifdef CONFIG_80211AX_HE
/* for now cover BW 20/40/80 bounded in 2SS */
const u16 HE_MCS_DATA_RATE[3][MAX_HE_GI_TYPE][MAX_HE_MCS_INDEX] = {
{ /* 20M */
{ /* 3.2us */
14, 29, 43, 58, 87, 117, 131, 146, 175, 195, 219, 243,
29, 58, 87, 117, 175, 234, 263, 292, 351, 390, 438, 487,
},
{ /* 1.6us */
16, 32, 48, 65, 97, 130, 146, 162, 195, 216, 243, 270,
32, 65, 97, 130, 195, 260, 292, 325, 390, 433, 487, 541,
},
{ /* 0.8us */
17, 34, 51, 68, 103, 137, 154, 172, 206, 229, 258, 286,
34, 68, 103, 137, 206, 275, 309, 344, 413, 458, 516, 573,
}
},
{ /* 40M */
{ /* 3.2us */
29, 58, 87, 117, 175, 234, 263, 292, 351, 390, 438, 487,
58, 117, 175, 234, 351, 468, 526, 585, 702, 780, 877, 975,
},
{ /* 1.6us */
32, 65, 97, 130, 195, 260, 292, 325, 390, 433, 487, 541,
65, 130, 195, 260, 390, 520, 585, 650, 780, 866, 975, 1083,
},
{ /* 0.8us */
34, 68, 103, 138, 206, 275, 309, 344, 413, 458, 516, 573,
68, 137, 206, 275, 413, 550, 619, 688, 825, 917, 1032, 1147,
}
},
{ /* 80M */
{ /* 3.2us */
61, 122, 183, 245, 367, 490, 551, 612, 735, 816, 918, 1020,
122, 245, 367, 490, 735, 980, 1102, 1225, 1470, 1633, 1839, 2041,
},
{ /* 1.6us */
68, 136, 204, 272, 408, 544, 612, 680, 816, 907, 1020, 1134,
136, 272, 408, 544, 816, 1088, 1225, 1361, 1633, 1814, 2041, 2268,
},
{ /* 0.8us */
72, 144, 216, 288, 432, 576, 648, 720, 864, 960, 1080, 1200,
144, 288, 432, 576, 864, 1153, 1297, 1441, 1729, 1921, 2161, 2402,
}
}
};
u16 rtw_he_mcs_to_data_rate(u8 bw, u8 guard_int, u8 he_mcs_rate)
{
u8 gi = 2; /* use 0.8us GI since 2XLTF_0.8us GI is mandatory in HE */
u8 mcs_idx = he_mcs_rate - MGN_HE1SS_MCS0;
return HE_MCS_DATA_RATE[bw][gi][mcs_idx];
}
static u8 rtw_he_get_highest_rate(u8 *he_mcs_map)
{
u8 i, j;
u8 bit_map;
u8 he_mcs_rate = 0;
/* currently only consider the BW 80M */
for (i = 0; i < 2; i++) {
if (he_mcs_map[i] != 0xff) {
/* max to 4SS, each SS contains 2 bit */
for (j = 0; j < 8; j += 2) {
bit_map = (he_mcs_map[i] >> j) & 3;
if (bit_map != 3)
he_mcs_rate = MGN_HE1SS_MCS7 + 12 * j / 2 + i * 48 + 2 * bit_map;
}
}
}
/*RTW_INFO("####### HighestHEMCSRate is %x\n", he_mcs_rate);*/
return he_mcs_rate;
}
void rtw_he_use_default_setting(_adapter *padapter)
{
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *role_cap = &(wrole->proto_role_cap);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
phepriv->he_highest_rate = rtw_he_get_highest_rate(role_cap->he_rx_mcs);
}
static void rtw_he_set_asoc_cap_supp_mcs(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start, u8 supp_mcs_len)
{
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *role_cap = &(wrole->proto_role_cap);
int nss = 0, nss_tx = 0, nss_rx = 0;
u8 mcs_from_role = HE_MSC_NOT_SUPP;
u8 mcs_from_ie = HE_MSC_NOT_SUPP;
u8 mcs_val_rx = HE_MSC_NOT_SUPP;
u8 mcs_val_tx = HE_MSC_NOT_SUPP;
_rtw_memset(phl_sta->asoc_cap.he_rx_mcs, HE_MSC_NOT_SUPP_BYTE, HE_CAP_ELE_SUPP_MCS_LEN_RX_80M);
_rtw_memset(phl_sta->asoc_cap.he_tx_mcs, HE_MSC_NOT_SUPP_BYTE, HE_CAP_ELE_SUPP_MCS_LEN_TX_80M);
/* only deal with <= 80MHz now */
for (nss = 1; nss <= 8; nss++) {
mcs_val_rx = HE_MSC_NOT_SUPP;
mcs_val_tx = HE_MSC_NOT_SUPP;
switch (nss) {
case 1:
mcs_from_role = GET_HE_CAP_MCS_1SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_1SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_1SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_1SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_1SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_1SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
case 2:
mcs_from_role = GET_HE_CAP_MCS_2SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_2SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_2SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_2SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_2SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_2SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
case 3:
mcs_from_role = GET_HE_CAP_MCS_3SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_3SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_3SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_3SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_3SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_3SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
case 4:
mcs_from_role = GET_HE_CAP_MCS_4SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_4SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_4SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_4SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_4SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_4SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
case 5:
mcs_from_role = GET_HE_CAP_MCS_5SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_5SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_5SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_5SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_5SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_5SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
case 6:
mcs_from_role = GET_HE_CAP_MCS_6SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_6SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_6SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_6SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_6SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_6SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
case 7:
mcs_from_role = GET_HE_CAP_MCS_7SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_7SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_7SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_7SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_7SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_7SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
case 8:
mcs_from_role = GET_HE_CAP_MCS_8SS(role_cap->he_tx_mcs);
mcs_from_ie = GET_HE_CAP_RX_MCS_LESS_THAN_80MHZ_8SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_rx = (mcs_from_role < mcs_from_ie) ? mcs_from_role : mcs_from_ie;
mcs_from_role = GET_HE_CAP_MCS_8SS(role_cap->he_rx_mcs);
mcs_from_ie = GET_HE_CAP_TX_MCS_LESS_THAN_80MHZ_8SS(ele_start);
if ((mcs_from_role != HE_MSC_NOT_SUPP) && (mcs_from_ie != HE_MSC_NOT_SUPP))
mcs_val_tx = mcs_from_ie;
SET_HE_CAP_MCS_8SS(phl_sta->asoc_cap.he_rx_mcs, mcs_val_rx);
SET_HE_CAP_MCS_8SS(phl_sta->asoc_cap.he_tx_mcs, mcs_val_tx);
break;
}
if (mcs_val_rx != HE_MSC_NOT_SUPP)
nss_rx++;
if (mcs_val_tx != HE_MSC_NOT_SUPP)
nss_tx++;
}
phl_sta->asoc_cap.nss_rx = nss_rx;
phl_sta->asoc_cap.nss_tx = nss_tx;
}
static void rtw_he_set_asoc_cap_ppe_thre(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start)
{
u8 nsts, rumsk, i, j, offset, shift;
u16 ppe8, ppe16;
if (phl_sta->asoc_cap.pkt_padding != 3)
return;
nsts = GET_HE_CAP_PPE_NSTS(ele_start);
rumsk = GET_HE_CAP_PPE_PU_IDX_BITMASK(ele_start);
shift = 7;
for (i = 0; i <= nsts; i ++) {
for (j = 0; j < 4; j++) {
if (rumsk & (BIT(0) << j)) {
offset = shift / 8;
ppe16 = LE_BITS_TO_2BYTE(ele_start + offset, shift % 8, 3);
shift += 3;
offset = shift / 8;
ppe8 = LE_BITS_TO_2BYTE(ele_start + offset, shift % 8, 3);
shift += 3;
phl_sta->asoc_cap.ppe_thr[i][j] = ((ppe16 & 0x07) | ((ppe8 & 0x07) << 3));
} else {
phl_sta->asoc_cap.ppe_thr[i][j] = 0;
}
}
}
}
static void update_sta_he_mac_cap_apmode(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start)
{
/* CONFIG_80211AX_HE_TODO - we may need to refer to role_cap when setting some of asoc_cap */
#if 0
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *role_cap = &(wrole->proto_role_cap);
#endif
phl_sta->asoc_cap.htc_rx = GET_HE_MAC_CAP_HTC_HE_SUPPORT(ele_start);
phl_sta->asoc_cap.twt = GET_HE_MAC_CAP_TWT_REQUESTER_SUPPORT(ele_start);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_TWT_RESPONDER_SUPPORT(ele_start)) << 1);
phl_sta->asoc_cap.trig_padding = GET_HE_MAC_CAP_TRI_FRAME_PADDING_DUR(ele_start);
phl_sta->asoc_cap.all_ack = GET_HE_MAC_CAP_ALL_ACK_SUPPORT(ele_start);
phl_sta->asoc_cap.a_ctrl = GET_HE_MAC_CAP_TRS_SUPPORT(ele_start);
phl_sta->asoc_cap.a_ctrl |= ((GET_HE_MAC_CAP_BRS_SUPPORT(ele_start)) << 1);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_BC_TWT_SUPPORT(ele_start)) << 2);
phl_sta->asoc_cap.a_ctrl |= ((GET_HE_MAC_CAP_OM_CTRL_SUPPORT(ele_start)) << 2);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_FLEX_TWT_SCHED_SUPPORT(ele_start)) << 3);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_PSR_RESPONDER(ele_start)) << 4);
phl_sta->asoc_cap.ops = GET_HE_MAC_CAP_OPS_SUPPORT(ele_start);
phl_sta->asoc_cap.amsdu_in_ampdu =
GET_HE_MAC_CAP_AMSDU_NOT_UNDER_BA_IN_ACK_EN_AMPDU(ele_start);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_HE_SUB_CH_SELECTIVE_TX(ele_start)) << 5);
phl_sta->asoc_cap.ht_vht_trig_rx =
GET_HE_MAC_CAP_HT_VHT_TRIG_FRAME_RX(ele_start);
}
static void update_sta_he_phy_cap_apmode(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start, u8 *supp_mcs_len)
{
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *role_cap = &(wrole->proto_role_cap);
struct role_cap_t *cap = &(wrole->cap);
if (phl_sta->chandef.band == BAND_ON_24G) {
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(0))
phl_sta->chandef.bw = (wrole->chandef.bw < CHANNEL_WIDTH_40) ?
wrole->chandef.bw : CHANNEL_WIDTH_40;
} else if (phl_sta->chandef.band == BAND_ON_5G) {
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(1))
phl_sta->chandef.bw = (wrole->chandef.bw < CHANNEL_WIDTH_80) ?
wrole->chandef.bw : CHANNEL_WIDTH_80;
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(2))
*supp_mcs_len += 4;
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(3))
*supp_mcs_len += 4;
}
phl_sta->asoc_cap.he_ldpc = (GET_HE_PHY_CAP_LDPC_IN_PAYLOAD(ele_start) & role_cap->he_ldpc);
if (phl_sta->asoc_cap.er_su) {
phl_sta->asoc_cap.ltf_gi = (BIT(RTW_GILTF_2XHE16) |
BIT(RTW_GILTF_2XHE08) | BIT(RTW_GILTF_1XHE16) |
(GET_HE_PHY_CAP_NDP_4X_LTF_3_POINT_2_GI(ele_start) ?
BIT(RTW_GILTF_LGI_4XHE32) : 0) |
(GET_HE_PHY_CAP_ERSU_PPDU_4X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_SGI_4XHE08) : 0) |
(GET_HE_PHY_CAP_ERSU_PPDU_1X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_1XHE08) : 0));
} else {
phl_sta->asoc_cap.ltf_gi = (BIT(RTW_GILTF_2XHE16) |
BIT(RTW_GILTF_2XHE08) | BIT(RTW_GILTF_1XHE16) |
(GET_HE_PHY_CAP_NDP_4X_LTF_3_POINT_2_GI(ele_start) ?
BIT(RTW_GILTF_LGI_4XHE32) : 0) |
(GET_HE_PHY_CAP_SU_MU_PPDU_4X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_SGI_4XHE08) : 0) |
(GET_HE_PHY_CAP_SU_PPDU_1X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_1XHE08) : 0));
}
phl_sta->asoc_cap.stbc_he_tx = GET_HE_PHY_CAP_STBC_TX_LESS_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.stbc_he_rx = (GET_HE_PHY_CAP_STBC_RX_LESS_THAN_80MHZ(ele_start) & role_cap->stbc_he_tx);
phl_sta->asoc_cap.doppler_tx = GET_HE_PHY_CAP_DOPPLER_TX(ele_start);
phl_sta->asoc_cap.doppler_rx = (GET_HE_PHY_CAP_DOPPLER_RX(ele_start) & role_cap->doppler_tx);
phl_sta->asoc_cap.dcm_max_const_tx =
GET_HE_PHY_CAP_DCM_MAX_CONSTELLATION_TX(ele_start);
if (phl_sta->asoc_cap.dcm_max_const_tx > role_cap->dcm_max_const_rx)
phl_sta->asoc_cap.dcm_max_const_tx = role_cap->dcm_max_const_rx;
phl_sta->asoc_cap.dcm_max_nss_tx = (GET_HE_PHY_CAP_DCM_MAX_NSS_TX(ele_start) & role_cap->dcm_max_nss_rx);
phl_sta->asoc_cap.dcm_max_const_rx =
GET_HE_PHY_CAP_DCM_MAX_CONSTELLATION_RX(ele_start);
if (phl_sta->asoc_cap.dcm_max_const_rx > role_cap->dcm_max_const_tx)
phl_sta->asoc_cap.dcm_max_const_rx = role_cap->dcm_max_const_tx;
phl_sta->asoc_cap.dcm_max_nss_rx = (GET_HE_PHY_CAP_DCM_MAX_NSS_RX(ele_start) & role_cap->dcm_max_nss_tx);
phl_sta->asoc_cap.partial_bw_su_er =
GET_HE_PHY_CAP_RX_PARTIAL_BW_SU_IN_20MHZ_MUPPDU(ele_start);
phl_sta->asoc_cap.he_su_bfmr = GET_HE_PHY_CAP_SU_BFER(ele_start);
phl_sta->asoc_cap.he_su_bfme = GET_HE_PHY_CAP_SU_BFEE(ele_start);
phl_sta->asoc_cap.he_mu_bfmr = GET_HE_PHY_CAP_MU_BFER(ele_start);
phl_sta->asoc_cap.bfme_sts =
GET_HE_PHY_CAP_BFEE_STS_LESS_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.bfme_sts_greater_80mhz =
GET_HE_PHY_CAP_BFEE_STS_GREATER_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.num_snd_dim =
GET_HE_PHY_CAP_NUM_SND_DIMEN_LESS_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.num_snd_dim_greater_80mhz =
GET_HE_PHY_CAP_NUM_SND_DIMEN_GREATER_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.ng_16_su_fb = GET_HE_PHY_CAP_NG_16_SU_FEEDBACK(ele_start);
phl_sta->asoc_cap.ng_16_mu_fb = GET_HE_PHY_CAP_NG_16_MU_FEEDBACK(ele_start);
phl_sta->asoc_cap.cb_sz_su_fb =
GET_HE_PHY_CAP_CODEBOOK_4_2_SU_FEEDBACK(ele_start);
phl_sta->asoc_cap.cb_sz_mu_fb =
GET_HE_PHY_CAP_CODEBOOK_7_5_MU_FEEDBACK(ele_start);
phl_sta->asoc_cap.trig_su_bfm_fb =
GET_HE_PHY_CAP_TRIG_SUBF_FEEDBACK(ele_start);
phl_sta->asoc_cap.trig_mu_bfm_fb =
GET_HE_PHY_CAP_TRIG_MUBF_PARTIAL_BW_FEEDBACK(ele_start);
phl_sta->asoc_cap.trig_cqi_fb = GET_HE_PHY_CAP_TRIG_CQI_FEEDBACK(ele_start);
phl_sta->asoc_cap.partial_bw_su_er =
GET_HE_PHY_CAP_PARTIAL_BW_EXT_RANGE(ele_start);
phl_sta->asoc_cap.pwr_bst_factor =
GET_HE_PHY_CAP_PWR_BOOST_FACTOR_SUPPORT(ele_start);
phl_sta->asoc_cap.max_nc = GET_HE_PHY_CAP_MAX_NC(ele_start);
phl_sta->asoc_cap.stbc_tx_greater_80mhz =
(GET_HE_PHY_CAP_STBC_TX_GREATER_THAN_80MHZ(ele_start) & role_cap->stbc_rx_greater_80mhz);
phl_sta->asoc_cap.stbc_rx_greater_80mhz =
(GET_HE_PHY_CAP_STBC_RX_GREATER_THAN_80MHZ(ele_start) & role_cap->stbc_tx_greater_80mhz);
phl_sta->asoc_cap.dcm_max_ru = GET_HE_PHY_CAP_DCM_MAX_RU(ele_start);
phl_sta->asoc_cap.long_sigb_symbol =
GET_HE_PHY_CAP_LONGER_THAN_16_HESIGB_OFDM_SYM(ele_start);
phl_sta->asoc_cap.non_trig_cqi_fb =
GET_HE_PHY_CAP_NON_TRIGGER_CQI_FEEDBACK(ele_start);
phl_sta->asoc_cap.tx_1024q_ru =
(GET_HE_PHY_CAP_TX_1024_QAM_LESS_THAN_242_TONE_RU(ele_start) & role_cap->rx_1024q_ru);
phl_sta->asoc_cap.rx_1024q_ru =
(GET_HE_PHY_CAP_RX_1024_QAM_LESS_THAN_242_TONE_RU(ele_start) & role_cap->tx_1024q_ru);
phl_sta->asoc_cap.fbw_su_using_mu_cmprs_sigb =
GET_HE_PHY_CAP_RX_FULLBW_SU_USE_MUPPDU_CMP_SIGB(ele_start);
phl_sta->asoc_cap.fbw_su_using_mu_non_cmprs_sigb =
GET_HE_PHY_CAP_RX_FULLBW_SU_USE_MUPPDU_NONCMP_SIGB(ele_start);
if (GET_HE_PHY_CAP_PPE_THRESHOLD_PRESENT(ele_start))
phl_sta->asoc_cap.pkt_padding = 3;
else
phl_sta->asoc_cap.pkt_padding = GET_HE_PHY_CAP_NOMINAL_PACKET_PADDING(ele_start);
}
static void update_sta_he_supp_mcs_apmode(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start, u8 supp_mcs_len)
{
rtw_he_set_asoc_cap_supp_mcs(padapter, phl_sta, ele_start, supp_mcs_len);
}
static void update_sta_he_ppe_thre_apmode(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start)
{
rtw_he_set_asoc_cap_ppe_thre(padapter, phl_sta, ele_start);
}
void update_sta_he_info_apmode(_adapter *padapter, void *sta)
{
struct sta_info *psta = (struct sta_info *)sta;
struct rtw_phl_stainfo_t *phl_sta = psta->phl_sta;
struct he_priv *phepriv_sta = &psta->hepriv;
u8 *ele_start = NULL;
u8 supp_mcs_len = 4;
if (phepriv_sta->he_option == _FALSE)
return;
ele_start = &(phepriv_sta->he_cap[1]);
update_sta_he_mac_cap_apmode(padapter, phl_sta, ele_start);
ele_start += HE_CAP_ELE_MAC_CAP_LEN;
update_sta_he_phy_cap_apmode(padapter, phl_sta, ele_start, &supp_mcs_len);
ele_start += HE_CAP_ELE_PHY_CAP_LEN;
update_sta_he_supp_mcs_apmode(padapter, phl_sta, ele_start, supp_mcs_len);
ele_start += supp_mcs_len;
update_sta_he_ppe_thre_apmode(padapter, phl_sta, ele_start);
}
void update_hw_he_param(_adapter *padapter)
{
/* CONFIG_80211AX_HE_TODO */
}
static void HE_mac_caps_handler(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start)
{
phl_sta->asoc_cap.htc_rx = GET_HE_MAC_CAP_HTC_HE_SUPPORT(ele_start);
phl_sta->asoc_cap.twt = GET_HE_MAC_CAP_TWT_REQUESTER_SUPPORT(ele_start);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_TWT_RESPONDER_SUPPORT(ele_start)) << 1);
phl_sta->asoc_cap.trig_padding = GET_HE_MAC_CAP_TRI_FRAME_PADDING_DUR(ele_start);
phl_sta->asoc_cap.all_ack = GET_HE_MAC_CAP_ALL_ACK_SUPPORT(ele_start);
phl_sta->asoc_cap.a_ctrl = GET_HE_MAC_CAP_TRS_SUPPORT(ele_start);
phl_sta->asoc_cap.a_ctrl |= ((GET_HE_MAC_CAP_BRS_SUPPORT(ele_start)) << 1);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_BC_TWT_SUPPORT(ele_start)) << 2);
phl_sta->asoc_cap.a_ctrl |= ((GET_HE_MAC_CAP_OM_CTRL_SUPPORT(ele_start)) << 2);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_FLEX_TWT_SCHED_SUPPORT(ele_start)) << 3);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_PSR_RESPONDER(ele_start)) << 4);
phl_sta->asoc_cap.ops = GET_HE_MAC_CAP_OPS_SUPPORT(ele_start);
phl_sta->asoc_cap.amsdu_in_ampdu =
GET_HE_MAC_CAP_AMSDU_NOT_UNDER_BA_IN_ACK_EN_AMPDU(ele_start);
phl_sta->asoc_cap.twt |= ((GET_HE_MAC_CAP_HE_SUB_CH_SELECTIVE_TX(ele_start)) << 5);
phl_sta->asoc_cap.ht_vht_trig_rx =
GET_HE_MAC_CAP_HT_VHT_TRIG_FRAME_RX(ele_start);
}
static void HE_phy_caps_handler(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start, u8 *supp_mcs_len)
{
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *role_cap = &(wrole->proto_role_cap);
if (phl_sta->chandef.band == BAND_ON_24G) {
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(0))
phl_sta->chandef.bw = (wrole->chandef.bw < CHANNEL_WIDTH_40) ?
wrole->chandef.bw : CHANNEL_WIDTH_40;
} else if (phl_sta->chandef.band == BAND_ON_5G) {
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(1))
phl_sta->chandef.bw = (wrole->chandef.bw < CHANNEL_WIDTH_80) ?
wrole->chandef.bw : CHANNEL_WIDTH_80;
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(2))
*supp_mcs_len += 4;
if (GET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(ele_start) & BIT(3))
*supp_mcs_len += 4;
}
phl_sta->asoc_cap.he_ldpc = GET_HE_PHY_CAP_LDPC_IN_PAYLOAD(ele_start);
if (phl_sta->asoc_cap.er_su) {
phl_sta->asoc_cap.ltf_gi = (BIT(RTW_GILTF_2XHE16) |
BIT(RTW_GILTF_2XHE08) | BIT(RTW_GILTF_1XHE16) |
(GET_HE_PHY_CAP_NDP_4X_LTF_3_POINT_2_GI(ele_start) ?
BIT(RTW_GILTF_LGI_4XHE32) : 0) |
(GET_HE_PHY_CAP_ERSU_PPDU_4X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_SGI_4XHE08) : 0) |
(GET_HE_PHY_CAP_ERSU_PPDU_1X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_1XHE08) : 0));
} else {
phl_sta->asoc_cap.ltf_gi = (BIT(RTW_GILTF_2XHE16) |
BIT(RTW_GILTF_2XHE08) | BIT(RTW_GILTF_1XHE16) |
(GET_HE_PHY_CAP_NDP_4X_LTF_3_POINT_2_GI(ele_start) ?
BIT(RTW_GILTF_LGI_4XHE32) : 0) |
(GET_HE_PHY_CAP_SU_MU_PPDU_4X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_SGI_4XHE08) : 0) |
(GET_HE_PHY_CAP_SU_PPDU_1X_LTF_0_POINT_8_GI(ele_start) ?
BIT(RTW_GILTF_1XHE08) : 0));
}
phl_sta->asoc_cap.stbc_he_tx = GET_HE_PHY_CAP_STBC_TX_LESS_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.stbc_he_rx = (GET_HE_PHY_CAP_STBC_RX_LESS_THAN_80MHZ(ele_start) & role_cap->stbc_he_tx);
phl_sta->asoc_cap.doppler_tx = GET_HE_PHY_CAP_DOPPLER_TX(ele_start);
phl_sta->asoc_cap.doppler_rx = (GET_HE_PHY_CAP_DOPPLER_RX(ele_start) & role_cap->doppler_tx);
phl_sta->asoc_cap.dcm_max_const_tx =
GET_HE_PHY_CAP_DCM_MAX_CONSTELLATION_TX(ele_start);
phl_sta->asoc_cap.dcm_max_nss_tx = GET_HE_PHY_CAP_DCM_MAX_NSS_TX(ele_start);
phl_sta->asoc_cap.dcm_max_const_rx =
GET_HE_PHY_CAP_DCM_MAX_CONSTELLATION_RX(ele_start);
phl_sta->asoc_cap.dcm_max_nss_rx = GET_HE_PHY_CAP_DCM_MAX_NSS_RX(ele_start);
phl_sta->asoc_cap.partial_bw_su_er =
GET_HE_PHY_CAP_RX_PARTIAL_BW_SU_IN_20MHZ_MUPPDU(ele_start);
phl_sta->asoc_cap.he_su_bfmr = GET_HE_PHY_CAP_SU_BFER(ele_start);
phl_sta->asoc_cap.he_su_bfme = GET_HE_PHY_CAP_SU_BFEE(ele_start);
phl_sta->asoc_cap.he_mu_bfmr = GET_HE_PHY_CAP_MU_BFER(ele_start);
phl_sta->asoc_cap.bfme_sts =
GET_HE_PHY_CAP_BFEE_STS_LESS_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.bfme_sts_greater_80mhz =
GET_HE_PHY_CAP_BFEE_STS_GREATER_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.num_snd_dim =
GET_HE_PHY_CAP_NUM_SND_DIMEN_LESS_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.num_snd_dim_greater_80mhz =
GET_HE_PHY_CAP_NUM_SND_DIMEN_GREATER_THAN_80MHZ(ele_start);
RTW_INFO("%s: HE STA assoc_cap:\n", __func__);
RTW_INFO("- SU BFer: %d\n", phl_sta->asoc_cap.he_su_bfmr);
RTW_INFO("- SU BFee: %d\n", phl_sta->asoc_cap.he_su_bfme);
RTW_INFO("- MU BFer: %d\n", phl_sta->asoc_cap.he_mu_bfmr);
RTW_INFO("- BFee STS: %d\n", phl_sta->asoc_cap.bfme_sts);
RTW_INFO("- BFee STS(>80MHz): %d\n", phl_sta->asoc_cap.bfme_sts_greater_80mhz);
RTW_INFO("- BFer SND DIM number: %d\n", phl_sta->asoc_cap.num_snd_dim);
RTW_INFO("- BFer SND DIM number(>80MHz): %d\n", phl_sta->asoc_cap.num_snd_dim_greater_80mhz);
phl_sta->asoc_cap.ng_16_su_fb = GET_HE_PHY_CAP_NG_16_SU_FEEDBACK(ele_start);
phl_sta->asoc_cap.ng_16_mu_fb = GET_HE_PHY_CAP_NG_16_MU_FEEDBACK(ele_start);
phl_sta->asoc_cap.cb_sz_su_fb =
GET_HE_PHY_CAP_CODEBOOK_4_2_SU_FEEDBACK(ele_start);
phl_sta->asoc_cap.cb_sz_mu_fb =
GET_HE_PHY_CAP_CODEBOOK_7_5_MU_FEEDBACK(ele_start);
phl_sta->asoc_cap.trig_su_bfm_fb =
GET_HE_PHY_CAP_TRIG_SUBF_FEEDBACK(ele_start);
phl_sta->asoc_cap.trig_mu_bfm_fb =
GET_HE_PHY_CAP_TRIG_MUBF_PARTIAL_BW_FEEDBACK(ele_start);
phl_sta->asoc_cap.trig_cqi_fb = GET_HE_PHY_CAP_TRIG_CQI_FEEDBACK(ele_start);
phl_sta->asoc_cap.partial_bw_su_er =
GET_HE_PHY_CAP_PARTIAL_BW_EXT_RANGE(ele_start);
phl_sta->asoc_cap.pwr_bst_factor =
GET_HE_PHY_CAP_PWR_BOOST_FACTOR_SUPPORT(ele_start);
phl_sta->asoc_cap.max_nc = GET_HE_PHY_CAP_MAX_NC(ele_start);
phl_sta->asoc_cap.stbc_tx_greater_80mhz =
GET_HE_PHY_CAP_STBC_TX_GREATER_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.stbc_rx_greater_80mhz =
GET_HE_PHY_CAP_STBC_RX_GREATER_THAN_80MHZ(ele_start);
phl_sta->asoc_cap.dcm_max_ru = GET_HE_PHY_CAP_DCM_MAX_RU(ele_start);
phl_sta->asoc_cap.long_sigb_symbol =
GET_HE_PHY_CAP_LONGER_THAN_16_HESIGB_OFDM_SYM(ele_start);
phl_sta->asoc_cap.non_trig_cqi_fb =
GET_HE_PHY_CAP_NON_TRIGGER_CQI_FEEDBACK(ele_start);
phl_sta->asoc_cap.tx_1024q_ru =
GET_HE_PHY_CAP_TX_1024_QAM_LESS_THAN_242_TONE_RU(ele_start);
phl_sta->asoc_cap.rx_1024q_ru =
GET_HE_PHY_CAP_RX_1024_QAM_LESS_THAN_242_TONE_RU(ele_start);
phl_sta->asoc_cap.fbw_su_using_mu_cmprs_sigb =
GET_HE_PHY_CAP_RX_FULLBW_SU_USE_MUPPDU_CMP_SIGB(ele_start);
phl_sta->asoc_cap.fbw_su_using_mu_non_cmprs_sigb =
GET_HE_PHY_CAP_RX_FULLBW_SU_USE_MUPPDU_NONCMP_SIGB(ele_start);
if (GET_HE_PHY_CAP_PPE_THRESHOLD_PRESENT(ele_start))
phl_sta->asoc_cap.pkt_padding = 3;
else
phl_sta->asoc_cap.pkt_padding = GET_HE_PHY_CAP_NOMINAL_PACKET_PADDING(ele_start);
}
static void HE_supp_mcs_handler(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start, u8 supp_mcs_len)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
rtw_he_set_asoc_cap_supp_mcs(padapter, phl_sta, ele_start, supp_mcs_len);
phepriv->he_highest_rate = rtw_he_get_highest_rate(phl_sta->asoc_cap.he_rx_mcs);
}
static void HE_ppe_thre_handler(_adapter *padapter, struct rtw_phl_stainfo_t *phl_sta, u8 *ele_start)
{
rtw_he_set_asoc_cap_ppe_thre(padapter, phl_sta, ele_start);
}
void HE_caps_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct sta_info *psta = NULL;
struct rtw_phl_stainfo_t *phl_sta = NULL;
u8 *ele_start = (&(pIE->data[0]) + 1);
u8 supp_mcs_len = 4;
if (pIE == NULL)
return;
if (phepriv->he_option == _FALSE)
return;
psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
if (psta == NULL)
return;
if (psta->phl_sta == NULL)
return;
phl_sta = psta->phl_sta;
/* HE MAC Caps */
HE_mac_caps_handler(padapter, phl_sta, ele_start);
ele_start += HE_CAP_ELE_MAC_CAP_LEN;
/* HE PHY Caps */
HE_phy_caps_handler(padapter, phl_sta, ele_start, &supp_mcs_len);
ele_start += HE_CAP_ELE_PHY_CAP_LEN;
/* HE Supp MCS Set */
HE_supp_mcs_handler(padapter, phl_sta, ele_start, supp_mcs_len);
ele_start += supp_mcs_len;
/* HE PPE Thresholds */
HE_ppe_thre_handler(padapter, phl_sta, ele_start);
pmlmeinfo->HE_enable = 1;
}
void HE_operation_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct sta_info *psta = NULL;
struct rtw_phl_stainfo_t *phl_sta = NULL;
u8 *ele_start = (&(pIE->data[0]) + 1);
struct dvobj_priv *d;
void *phl;
u8 pre_bsscolor = 0;
u16 pre_rts_th = 0;
if (pIE == NULL)
return;
if (phepriv->he_option == _FALSE)
return;
d = adapter_to_dvobj(padapter);
phl = GET_PHL_INFO(d);
psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
if (psta == NULL)
return;
if (psta->phl_sta == NULL)
return;
phl_sta = psta->phl_sta;
phl_sta->tf_trs = _TRUE;
phl_sta->asoc_cap.er_su = !GET_HE_OP_PARA_ER_SU_DISABLE(ele_start);
if (!GET_HE_OP_BSS_COLOR_INFO_BSS_COLOR_DISABLE(ele_start)) {
pre_bsscolor = phl_sta->asoc_cap.bsscolor;
phl_sta->asoc_cap.bsscolor = GET_HE_OP_BSS_COLOR_INFO_BSS_COLOR(ele_start);
/* rx thread & assoc timer callback, use cmd no_wait */
if (pre_bsscolor != phl_sta->asoc_cap.bsscolor) {
RTW_INFO("%s, Update BSS Color = %d\n", __func__, phl_sta->asoc_cap.bsscolor);
#ifdef CONFIG_CMD_DISP
rtw_phl_cmd_wrole_change(phl,
padapter->phl_role,
WR_CHG_BSS_COLOR,
(u8 *)&phl_sta->asoc_cap.bsscolor,
sizeof(phl_sta->asoc_cap.bsscolor),
PHL_CMD_NO_WAIT,
0);
#else
/* role change here, but no implementation for not CMD_DISP case */
#endif
}
}
pre_rts_th = phl_sta->asoc_cap.rts_th;
phl_sta->asoc_cap.rts_th =
GET_HE_OP_PARA_TXOP_DUR_RTS_THRESHOLD(ele_start);
if ((phl_sta->asoc_cap.rts_th > 0) &&
(phl_sta->asoc_cap.rts_th != TXOP_DUR_RTS_TH_DISABLED)) {
struct rtw_rts_threshold val = {0};
/* time preference */
val.rts_len_th = 0xffff;
/* IE field unit 32us, parameter unit 1us */
val.rts_time_th = phl_sta->asoc_cap.rts_th * 32;
/* rx thread & assoc timer callback, use cmd no_wait */
if (pre_rts_th != phl_sta->asoc_cap.rts_th) {
RTW_INFO("%s, Update TXOP Duration RTS Threshold =%d\n", __func__, phl_sta->asoc_cap.rts_th);
#ifdef CONFIG_CMD_DISP
rtw_phl_cmd_wrole_change(phl,
padapter->phl_role,
WR_CHG_RTS_TH,
(u8 *)&val,
sizeof(struct rtw_rts_threshold),
PHL_CMD_NO_WAIT,
0);
#else
/* role change here, but no implementation for not CMD_DISP case */
#endif
}
}
}
void HE_mu_edca_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE, u8 first)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct sta_info *psta = NULL;
struct rtw_phl_stainfo_t *phl_sta = NULL;
u8 *ele_start = (&(pIE->data[0]) + 1);
struct dvobj_priv *d;
void *phl;
struct rtw_mu_edca_param edca = {0};
u8 pre_cnt = 0, cur_cnt = 0;
u8 i = 0;
if (pIE == NULL)
return;
if (phepriv->he_option == _FALSE)
return;
d = adapter_to_dvobj(padapter);
phl = GET_PHL_INFO(d);
if (!phl)
return;
psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
if (psta == NULL)
return;
if (psta->phl_sta == NULL)
return;
phl_sta = psta->phl_sta;
pre_cnt = phepriv->pre_he_muedca_cnt;
cur_cnt = GET_HE_MU_EDCA_QOS_INFO_UPDATE_CNT(ele_start);
if (cur_cnt != pre_cnt || first == _TRUE) {
phepriv->pre_he_muedca_cnt = cur_cnt;
phl_sta->asoc_cap.mu_edca[0].ac =
GET_HE_MU_EDCA_BE_ACI(ele_start);
phl_sta->asoc_cap.mu_edca[0].aifsn =
GET_HE_MU_EDCA_BE_AIFSN(ele_start);
phl_sta->asoc_cap.mu_edca[0].cw =
GET_HE_MU_EDCA_BE_ECW_MIN_MAX(ele_start);
phl_sta->asoc_cap.mu_edca[0].timer =
GET_HE_MU_EDCA_BE_TIMER(ele_start);
phl_sta->asoc_cap.mu_edca[1].ac =
GET_HE_MU_EDCA_BK_ACI(ele_start);
phl_sta->asoc_cap.mu_edca[1].aifsn =
GET_HE_MU_EDCA_BK_AIFSN(ele_start);
phl_sta->asoc_cap.mu_edca[1].cw =
GET_HE_MU_EDCA_BK_ECW_MIN_MAX(ele_start);
phl_sta->asoc_cap.mu_edca[1].timer =
GET_HE_MU_EDCA_BK_TIMER(ele_start);
phl_sta->asoc_cap.mu_edca[2].ac =
GET_HE_MU_EDCA_VI_ACI(ele_start);
phl_sta->asoc_cap.mu_edca[2].aifsn =
GET_HE_MU_EDCA_VI_AIFSN(ele_start);
phl_sta->asoc_cap.mu_edca[2].cw =
GET_HE_MU_EDCA_VI_ECW_MIN_MAX(ele_start);
phl_sta->asoc_cap.mu_edca[2].timer =
GET_HE_MU_EDCA_VI_TIMER(ele_start);
phl_sta->asoc_cap.mu_edca[3].ac =
GET_HE_MU_EDCA_VO_ACI(ele_start);
phl_sta->asoc_cap.mu_edca[3].aifsn =
GET_HE_MU_EDCA_VO_AIFSN(ele_start);
phl_sta->asoc_cap.mu_edca[3].cw =
GET_HE_MU_EDCA_VO_ECW_MIN_MAX(ele_start);
phl_sta->asoc_cap.mu_edca[3].timer =
GET_HE_MU_EDCA_VO_TIMER(ele_start);
for (i = 0; i < 4; i++) {
#ifdef CONFIG_CMD_DISP
rtw_phl_cmd_wrole_change(phl,
padapter->phl_role,
WR_CHG_MU_EDCA_PARAM,
(u8 *)&phl_sta->asoc_cap.mu_edca[i],
sizeof(struct rtw_mu_edca_param),
PHL_CMD_NO_WAIT,
0);
#endif
RTW_INFO("%s, Update HE MU EDCA AC(%d) aifsn(%d) cw(0x%x) timer(0x%x)\n",
__func__,
phl_sta->asoc_cap.mu_edca[i].ac,
phl_sta->asoc_cap.mu_edca[i].aifsn,
phl_sta->asoc_cap.mu_edca[i].cw,
phl_sta->asoc_cap.mu_edca[i].timer);
}
if (first) {
#ifdef CONFIG_CMD_DISP
rtw_phl_cmd_wrole_change(phl,
padapter->phl_role,
WR_CHG_MU_EDCA_CFG,
(u8 *)&first,
sizeof(first),
PHL_CMD_NO_WAIT,
0);
#else
/* role change here, but no implementation for not CMD_DISP case */
#endif
}
}
}
static int rtw_build_he_mac_caps(struct protocol_cap_t *proto_cap, u8 *pbuf)
{
/* Set HE MAC Capabilities Information */
int info_len = HE_CAP_ELE_MAC_CAP_LEN;
if (proto_cap->htc_rx)
SET_HE_MAC_CAP_HTC_HE_SUPPORT(pbuf, 1);
if (proto_cap->twt & BIT(0))
SET_HE_MAC_CAP_TWT_REQUESTER_SUPPORT(pbuf, 1);
if (proto_cap->twt & BIT(1))
SET_HE_MAC_CAP_TWT_RESPONDER_SUPPORT(pbuf, 1);
if (proto_cap->trig_padding)
SET_HE_MAC_CAP_TRI_FRAME_PADDING_DUR(pbuf,
proto_cap->trig_padding);
if (proto_cap->all_ack)
SET_HE_MAC_CAP_ALL_ACK_SUPPORT(pbuf, 1);
if (proto_cap->htc_rx && (proto_cap->a_ctrl & BIT(0)))
SET_HE_MAC_CAP_TRS_SUPPORT(pbuf, 1);
if (proto_cap->a_ctrl & BIT(1))
SET_HE_MAC_CAP_BRS_SUPPORT(pbuf, 1);
if (proto_cap->twt & BIT(2))
SET_HE_MAC_CAP_BC_TWT_SUPPORT(pbuf, 1);
if (proto_cap->htc_rx && (proto_cap->a_ctrl & BIT(2)))
SET_HE_MAC_CAP_OM_CTRL_SUPPORT(pbuf, 1);
SET_HE_MAC_CAP_MAX_AMPDU_LEN_EXP_EXT(pbuf, 2);
if (proto_cap->twt & BIT(3))
SET_HE_MAC_CAP_FLEX_TWT_SCHED_SUPPORT(pbuf, 1);
if (proto_cap->twt & BIT(4))
SET_HE_MAC_CAP_PSR_RESPONDER(pbuf, 1);
if (proto_cap->ops)
SET_HE_MAC_CAP_OPS_SUPPORT(pbuf, 1);
if (proto_cap->amsdu_in_ampdu)
SET_HE_MAC_CAP_AMSDU_NOT_UNDER_BA_IN_ACK_EN_AMPDU(pbuf, 1);
if (proto_cap->twt & BIT(5))
SET_HE_MAC_CAP_HE_SUB_CH_SELECTIVE_TX(pbuf, 1);
if (proto_cap->ht_vht_trig_rx)
SET_HE_MAC_CAP_HT_VHT_TRIG_FRAME_RX(pbuf, 1);
return info_len;
}
static int rtw_build_he_phy_caps(struct protocol_cap_t *proto_cap, u8 *pbuf)
{
/* struct rtw_chan_def *chan_def = &(wrole->chandef); */
/* Set HE PHY Capabilities Information */
int info_len = HE_CAP_ELE_PHY_CAP_LEN;
#if 1
SET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(pbuf, (BIT(0) | BIT(1)));
#else
u8 bw_cap = 0;
if (phy_cap->bw_sup & BW_CAP_40M)
bw_cap |= BIT(0);
if (phy_cap->bw_sup & BW_CAP_80M)
bw_cap |= BIT(1);
if (chan_def->band == BAND_ON_24G) {
if (chan_def->bw == CHANNEL_WIDTH_40)
SET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(pbuf, BIT(0));
} else if (chan_def->band == BAND_ON_5G) {
if (chan_def->bw == CHANNEL_WIDTH_80)
SET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(pbuf, BIT(1));
else if (chan_def->bw == CHANNEL_WIDTH_160)
SET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(pbuf, (BIT(1) | BIT(2)));
else if (chan_def->bw == CHANNEL_WIDTH_80_80)
SET_HE_PHY_CAP_SUPPORT_CHAN_WIDTH_SET(pbuf, (BIT(1) | BIT(3)));
}
#endif
SET_HE_PHY_CAP_DEVICE_CLASS(pbuf, HE_DEV_CLASS_A);
if (proto_cap->he_ldpc)
SET_HE_PHY_CAP_LDPC_IN_PAYLOAD(pbuf, 1);
SET_HE_PHY_CAP_SU_PPDU_1X_LTF_0_POINT_8_GI(pbuf, 1);
if (proto_cap->he_rx_ndp_4x32) {
SET_HE_PHY_CAP_NDP_4X_LTF_3_POINT_2_GI(pbuf, 1);
RTW_INFO("NDP_4x32 is set.\n");;
}
if (proto_cap->stbc_he_tx)
SET_HE_PHY_CAP_STBC_TX_LESS_THAN_80MHZ(pbuf, 1);
if (proto_cap->stbc_he_rx)
SET_HE_PHY_CAP_STBC_RX_LESS_THAN_80MHZ(pbuf, 1);
if (proto_cap->doppler_tx)
SET_HE_PHY_CAP_DOPPLER_TX(pbuf, 1);
if (proto_cap->doppler_rx)
SET_HE_PHY_CAP_DOPPLER_RX(pbuf, 1);
if (proto_cap->dcm_max_const_tx)
SET_HE_PHY_CAP_DCM_MAX_CONSTELLATION_TX(pbuf,
proto_cap->dcm_max_const_tx);
if (proto_cap->dcm_max_nss_tx)
SET_HE_PHY_CAP_DCM_MAX_NSS_TX(pbuf, 1);
if (proto_cap->dcm_max_const_rx)
SET_HE_PHY_CAP_DCM_MAX_CONSTELLATION_RX(pbuf,
proto_cap->dcm_max_const_rx);
if (proto_cap->dcm_max_nss_rx)
SET_HE_PHY_CAP_DCM_MAX_NSS_RX(pbuf, 1);
if (proto_cap->partial_bw_su_in_mu)
SET_HE_PHY_CAP_RX_PARTIAL_BW_SU_IN_20MHZ_MUPPDU(pbuf, 1);
if (proto_cap->he_su_bfmr)
SET_HE_PHY_CAP_SU_BFER(pbuf, 1);
if (proto_cap->he_su_bfme)
SET_HE_PHY_CAP_SU_BFEE(pbuf, 1);
if (proto_cap->he_mu_bfmr)
SET_HE_PHY_CAP_MU_BFER(pbuf, 1);
if (proto_cap->bfme_sts)
SET_HE_PHY_CAP_BFEE_STS_LESS_THAN_80MHZ(pbuf,
proto_cap->bfme_sts);
if (proto_cap->bfme_sts_greater_80mhz)
SET_HE_PHY_CAP_BFEE_STS_GREATER_THAN_80MHZ(pbuf,
proto_cap->bfme_sts_greater_80mhz);
if (proto_cap->num_snd_dim)
SET_HE_PHY_CAP_NUM_SND_DIMEN_LESS_THAN_80MHZ(pbuf,
proto_cap->num_snd_dim);
if (proto_cap->num_snd_dim_greater_80mhz)
SET_HE_PHY_CAP_NUM_SND_DIMEN_GREATER_THAN_80MHZ(pbuf,
proto_cap->num_snd_dim_greater_80mhz);
if (proto_cap->ng_16_su_fb)
SET_HE_PHY_CAP_NG_16_SU_FEEDBACK(pbuf, 1);
if (proto_cap->ng_16_mu_fb)
SET_HE_PHY_CAP_NG_16_MU_FEEDBACK(pbuf, 1);
if (proto_cap->cb_sz_su_fb)
SET_HE_PHY_CAP_CODEBOOK_4_2_SU_FEEDBACK(pbuf, 1);
if (proto_cap->cb_sz_mu_fb)
SET_HE_PHY_CAP_CODEBOOK_7_5_MU_FEEDBACK(pbuf, 1);
if (proto_cap->trig_su_bfm_fb)
SET_HE_PHY_CAP_TRIG_SUBF_FEEDBACK(pbuf, 1);
if (proto_cap->trig_mu_bfm_fb)
SET_HE_PHY_CAP_TRIG_MUBF_PARTIAL_BW_FEEDBACK(pbuf, 1);
if (proto_cap->trig_cqi_fb)
SET_HE_PHY_CAP_TRIG_CQI_FEEDBACK(pbuf, 1);
if (proto_cap->partial_bw_su_er)
SET_HE_PHY_CAP_PARTIAL_BW_EXT_RANGE(pbuf, 1);
if (proto_cap->pwr_bst_factor)
SET_HE_PHY_CAP_PWR_BOOST_FACTOR_SUPPORT(pbuf, 1);
SET_HE_PHY_CAP_SU_MU_PPDU_4X_LTF_0_POINT_8_GI(pbuf, 1);
if (proto_cap->max_nc)
SET_HE_PHY_CAP_MAX_NC(pbuf, proto_cap->max_nc);
if (proto_cap->stbc_tx_greater_80mhz)
SET_HE_PHY_CAP_STBC_TX_GREATER_THAN_80MHZ(pbuf, 1);
if (proto_cap->stbc_rx_greater_80mhz)
SET_HE_PHY_CAP_STBC_RX_GREATER_THAN_80MHZ(pbuf, 1);
SET_HE_PHY_CAP_ERSU_PPDU_4X_LTF_0_POINT_8_GI(pbuf, 1);
SET_HE_PHY_CAP_ERSU_PPDU_1X_LTF_0_POINT_8_GI(pbuf, 1);
if (proto_cap->dcm_max_ru)
SET_HE_PHY_CAP_DCM_MAX_RU(pbuf, proto_cap->dcm_max_ru);
if (proto_cap->long_sigb_symbol)
SET_HE_PHY_CAP_LONGER_THAN_16_HESIGB_OFDM_SYM(pbuf, 1);
if (proto_cap->non_trig_cqi_fb)
SET_HE_PHY_CAP_NON_TRIGGER_CQI_FEEDBACK(pbuf, 1);
if (proto_cap->tx_1024q_ru)
SET_HE_PHY_CAP_TX_1024_QAM_LESS_THAN_242_TONE_RU(pbuf, 1);
if (proto_cap->rx_1024q_ru)
SET_HE_PHY_CAP_RX_1024_QAM_LESS_THAN_242_TONE_RU(pbuf, 1);
if (proto_cap->fbw_su_using_mu_cmprs_sigb)
SET_HE_PHY_CAP_RX_FULLBW_SU_USE_MUPPDU_CMP_SIGB(pbuf, 1);
if (proto_cap->fbw_su_using_mu_non_cmprs_sigb)
SET_HE_PHY_CAP_RX_FULLBW_SU_USE_MUPPDU_NONCMP_SIGB(pbuf, 1);
if (proto_cap->pkt_padding)
SET_HE_PHY_CAP_NOMINAL_PACKET_PADDING(pbuf,
proto_cap->pkt_padding);
return info_len;
}
static int rtw_build_he_supp_mcs(struct protocol_cap_t *proto_cap, u8 *pbuf)
{
/* struct rtw_chan_def *chan_def = &(wrole->chandef); */
/* Set HE Supported MCS and NSS Set */
int info_len = 4;
_rtw_memset(pbuf, HE_MSC_NOT_SUPP_BYTE, info_len);
_rtw_memcpy(pbuf, proto_cap->he_rx_mcs, HE_CAP_ELE_SUPP_MCS_LEN_RX_80M);
_rtw_memcpy(pbuf + 2, proto_cap->he_tx_mcs, HE_CAP_ELE_SUPP_MCS_LEN_TX_80M);
return info_len;
}
static int rtw_build_he_ppe_thre(struct protocol_cap_t *proto_cap, u8 *pbuf)
{
/* Set HE PPE Thresholds (optional) */
int info_len = 0;
return info_len;
}
u32 rtw_get_dft_he_cap_ie(_adapter *padapter, struct phy_cap_t *phy_cap,
struct protocol_cap_t *proto_cap, u8 *pbuf)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
u32 he_cap_total_len = 0, len = 0;
u8* pcap_start = phepriv->he_cap;
u8* pcap = pcap_start;
_rtw_memset(pcap, 0, HE_CAP_ELE_MAX_LEN);
/* Ele ID Extension */
*pcap++ = WLAN_EID_EXTENSION_HE_CAPABILITY;
/* HE MAC Caps */
pcap += rtw_build_he_mac_caps(proto_cap, pcap);
/* HE PHY Caps */
pcap += rtw_build_he_phy_caps(proto_cap, pcap);
/* HE Supported MCS and NSS Set */
pcap += rtw_build_he_supp_mcs(proto_cap, pcap);
/* HE PPE Thresholds (optional) */
pcap += rtw_build_he_ppe_thre(proto_cap, pcap);
he_cap_total_len = (pcap - pcap_start);
pbuf = rtw_set_ie(pbuf, WLAN_EID_EXTENSION, he_cap_total_len, pcap_start, &len);
return len;
}
u32 rtw_build_he_cap_ie(_adapter *padapter, u8 *pbuf)
{
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *proto_cap = &(wrole->proto_role_cap);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
u32 he_cap_total_len = 0, len = 0;
u8* pcap_start = phepriv->he_cap;
u8* pcap = pcap_start;
_rtw_memset(pcap, 0, HE_CAP_ELE_MAX_LEN);
/* Ele ID Extension */
*pcap++ = WLAN_EID_EXTENSION_HE_CAPABILITY;
/* HE MAC Caps */
pcap += rtw_build_he_mac_caps(proto_cap, pcap);
/* HE PHY Caps */
pcap += rtw_build_he_phy_caps(proto_cap, pcap);
/* HE Supported MCS and NSS Set */
pcap += rtw_build_he_supp_mcs(proto_cap, pcap);
/* HE PPE Thresholds (optional) */
pcap += rtw_build_he_ppe_thre(proto_cap, pcap);
he_cap_total_len = (pcap - pcap_start);
pbuf = rtw_set_ie(pbuf, WLAN_EID_EXTENSION, he_cap_total_len, pcap_start, &len);
return len;
}
u32 rtw_restructure_he_ie(_adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, struct country_chplan *req_chplan)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
u32 ielen;
u8 *out_he_op_ie, *he_cap_ie, *he_op_ie;
u8 he_cap_eid_ext = WLAN_EID_EXTENSION_HE_CAPABILITY;
u8 he_op_eid_ext = WLAN_EID_EXTENSION_HE_OPERATION;
rtw_he_use_default_setting(padapter);
he_cap_ie = rtw_get_ie_ex(in_ie + 12, in_len - 12, WLAN_EID_EXTENSION, &he_cap_eid_ext, 1, NULL, &ielen);
if (!he_cap_ie || (ielen > (HE_CAP_ELE_MAX_LEN + 2)))
goto exit;
he_op_ie = rtw_get_ie_ex(in_ie + 12, in_len - 12, WLAN_EID_EXTENSION, &he_op_eid_ext, 1, NULL, &ielen);
if (!he_op_ie || (ielen > (HE_OPER_ELE_MAX_LEN + 2)))
goto exit;
/* TODO: channel width adjustment according to current chan plan or request chan plan */
*pout_len += rtw_build_he_cap_ie(padapter, out_ie + *pout_len);
phepriv->he_option = _TRUE;
exit:
return phepriv->he_option;
}
static int rtw_build_he_oper_params(_adapter *padapter, u8 *pbuf)
{
/* Set HE Operation Parameters */
int info_len = HE_OPER_PARAMS_LEN;
SET_HE_OP_PARA_DEFAULT_PE_DUR(pbuf, 0x4);
return info_len;
}
static int rtw_build_he_oper_bss_color_info(_adapter *padapter, u8 *pbuf)
{
/* Set BSS Color Information */
int info_len = HE_OPER_BSS_COLOR_INFO_LEN;
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *proto_cap = &(wrole->proto_role_cap);
SET_HE_OP_BSS_COLOR_INFO_BSS_COLOR(pbuf, proto_cap->bsscolor);
return info_len;
}
static int rtw_build_he_oper_basic_mcs_set(_adapter *padapter, u8 *pbuf)
{
/* Set Basic HE-MCS and NSS Set */
int info_len = HE_OPER_BASIC_MCS_LEN;
_rtw_memset(pbuf, HE_MSC_NOT_SUPP_BYTE, info_len);
SET_HE_OP_BASIC_MCS_1SS(pbuf, HE_MCS_SUPP_MSC0_TO_MSC11);
SET_HE_OP_BASIC_MCS_2SS(pbuf, HE_MCS_SUPP_MSC0_TO_MSC11);
return info_len;
}
static int rtw_build_vht_oper_info(_adapter *padapter, u8 *pbuf)
{
/* Set VHT Operation Information (optional) */
int info_len = 0;
return info_len;
}
static int rtw_build_max_cohost_bssid_ind(_adapter *padapter, u8 *pbuf)
{
/* Set Max Co-Hosted BSSID Indicator (optional) */
int info_len = 0;
return info_len;
}
static int rtw_build_6g_oper_info(_adapter *padapter, u8 *pbuf)
{
/* Set 6GHz Operation Information (optional) */
int info_len = 0;
return info_len;
}
u32 rtw_build_he_operation_ie(_adapter *padapter, u8 *pbuf)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct he_priv *phepriv = &pmlmepriv->hepriv;
u32 he_oper_total_len = 0, len = 0;
u8* poper_start = phepriv->he_op;
u8* poper = poper_start;
_rtw_memset(poper, 0, HE_OPER_ELE_MAX_LEN);
/* Ele ID Extension */
*poper++ = WLAN_EID_EXTENSION_HE_OPERATION;
/* HE Oper Params */
poper += rtw_build_he_oper_params(padapter, poper);
/* BSS Color Info */
poper += rtw_build_he_oper_bss_color_info(padapter, poper);
/* Basic MCS and NSS Set */
poper += rtw_build_he_oper_basic_mcs_set(padapter, poper);
/* VHT Oper Info */
poper += rtw_build_vht_oper_info(padapter, poper);
/* Max Co-Hosted BSSID Indicator */
poper += rtw_build_max_cohost_bssid_ind(padapter, poper);
/* 6G Oper Info */
poper += rtw_build_6g_oper_info(padapter, poper);
he_oper_total_len = (poper - poper_start);
pbuf = rtw_set_ie(pbuf, WLAN_EID_EXTENSION, he_oper_total_len, poper_start, &len);
return len;
}
void HEOnAssocRsp(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 ht_AMPDU_len;
if (!pmlmeinfo->VHT_enable)
return;
if (!pmlmeinfo->HE_enable)
return;
RTW_INFO("%s\n", __FUNCTION__);
/* AMPDU related settings here ? */
}
void rtw_he_ies_attach(_adapter *padapter, WLAN_BSSID_EX *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 he_cap_eid_ext = WLAN_EID_EXTENSION_HE_CAPABILITY;
u8 cap_len, operation_len;
uint len = 0;
sint ie_len = 0;
u8 *p = NULL;
p = rtw_get_ie_ex(pnetwork->IEs + _BEACON_IE_OFFSET_, pnetwork->IELength - _BEACON_IE_OFFSET_,
WLAN_EID_EXTENSION, &he_cap_eid_ext, 1, NULL, &ie_len);
if (p && ie_len > 0)
return;
rtw_he_use_default_setting(padapter);
cap_len = rtw_build_he_cap_ie(padapter, pnetwork->IEs + pnetwork->IELength);
pnetwork->IELength += cap_len;
operation_len = rtw_build_he_operation_ie(padapter, pnetwork->IEs + pnetwork->IELength);
pnetwork->IELength += operation_len;
pmlmepriv->hepriv.he_option = _TRUE;
}
void rtw_he_ies_detach(_adapter *padapter, WLAN_BSSID_EX *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 he_cap_eid_ext = WLAN_EID_EXTENSION_HE_CAPABILITY;
u8 he_op_eid_ext = WLAN_EID_EXTENSION_HE_OPERATION;
rtw_remove_bcn_ie_ex(padapter, pnetwork, WLAN_EID_EXTENSION, &he_cap_eid_ext, 1);
rtw_remove_bcn_ie_ex(padapter, pnetwork, WLAN_EID_EXTENSION, &he_op_eid_ext, 1);
pmlmepriv->hepriv.he_option = _FALSE;
}
u8 rtw_he_htc_en(_adapter *padapter, struct sta_info *psta)
{
return 1;
}
void rtw_he_fill_htc(_adapter *padapter, struct pkt_attrib *pattrib, u32 *phtc_buf)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct rtw_he_actrl_om *cur_om_info = &(pmlmepriv->hepriv.om_info);
SET_HE_VAR_HTC(phtc_buf);
SET_HE_VAR_HTC_CID_CAS(phtc_buf);
/* CONFIG_80211AX_HE_TODO */
if ((pattrib->type == WIFI_DATA_TYPE &&
cur_om_info->actrl_om_normal_tx &&
cur_om_info->actrl_om_normal_tx_cnt != 0) ||
pattrib->type == WIFI_MGT_TYPE) {
SET_HE_VAR_HTC_CID_OM(phtc_buf);
SET_HE_VAR_HTC_OM_RX_NSS(phtc_buf, cur_om_info->om_actrl_ele.rx_nss);
SET_HE_VAR_HTC_OM_CH_WIDTH(phtc_buf, cur_om_info->om_actrl_ele.channel_width);
SET_HE_VAR_HTC_OM_UL_MU_DIS(phtc_buf, cur_om_info->om_actrl_ele.ul_mu_disable);
SET_HE_VAR_HTC_OM_TX_NSTS(phtc_buf, cur_om_info->om_actrl_ele.tx_nsts);
SET_HE_VAR_HTC_OM_ER_SU_DIS(phtc_buf, cur_om_info->om_actrl_ele.er_su_disable);
SET_HE_VAR_HTC_OM_DL_MU_MIMO_RR(phtc_buf, cur_om_info->om_actrl_ele.dl_mu_mimo_rr);
SET_HE_VAR_HTC_OM_UL_MU_DATA_DIS(phtc_buf, cur_om_info->om_actrl_ele.ul_mu_data_disable);
if (cur_om_info->actrl_om_normal_tx_cnt) {
/*RTW_INFO("%s, cur_om_info->actrl_om_normal_tx_cnt=%d\n", __func__, cur_om_info->actrl_om_normal_tx_cnt);*/
cur_om_info->actrl_om_normal_tx_cnt --;
}
}
}
void rtw_he_set_om_info(_adapter *padapter, u8 om_mask, struct rtw_he_actrl_om *om_info)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct rtw_he_actrl_om *cur_om_info = &(pmlmepriv->hepriv.om_info);
if (om_mask & OM_RX_NSS)
cur_om_info->om_actrl_ele.rx_nss = om_info->om_actrl_ele.rx_nss;
if (om_mask & OM_CH_BW)
cur_om_info->om_actrl_ele.channel_width= om_info->om_actrl_ele.channel_width;
if (om_mask & OM_UL_MU_DIS)
cur_om_info->om_actrl_ele.ul_mu_disable= om_info->om_actrl_ele.ul_mu_disable;
if (om_mask & OM_TX_NSTS)
cur_om_info->om_actrl_ele.tx_nsts= om_info->om_actrl_ele.tx_nsts;
if (om_mask & OM_ER_SU_DIS)
cur_om_info->om_actrl_ele.er_su_disable= om_info->om_actrl_ele.er_su_disable;
if (om_mask & OM_DL_MU_RR)
cur_om_info->om_actrl_ele.dl_mu_mimo_rr= om_info->om_actrl_ele.dl_mu_mimo_rr;
if (om_mask & OM_UL_MU_DATA_DIS)
cur_om_info->om_actrl_ele.ul_mu_data_disable= om_info->om_actrl_ele.ul_mu_data_disable;
cur_om_info->actrl_om_normal_tx = om_info->actrl_om_normal_tx;
cur_om_info->actrl_om_normal_tx_cnt = om_info->actrl_om_normal_tx_cnt;
#if 0
RTW_INFO("%s, cur_om_info->om_actrl_ele.rx_nss = %d\n", __func__, cur_om_info->om_actrl_ele.rx_nss);
RTW_INFO("%s, cur_om_info->om_actrl_ele.channel_width = %d\n", __func__, cur_om_info->om_actrl_ele.channel_width);
RTW_INFO("%s, cur_om_info->om_actrl_ele.ul_mu_disable = %d\n", __func__, cur_om_info->om_actrl_ele.ul_mu_disable);
RTW_INFO("%s, cur_om_info->om_actrl_ele.tx_nsts = %d\n", __func__, cur_om_info->om_actrl_ele.tx_nsts);
RTW_INFO("%s, cur_om_info->om_actrl_ele.er_su_disable = %d\n", __func__, cur_om_info->om_actrl_ele.er_su_disable);
RTW_INFO("%s, cur_om_info->om_actrl_ele.dl_mu_mimo_rr = %d\n", __func__, cur_om_info->om_actrl_ele.dl_mu_mimo_rr);
RTW_INFO("%s, cur_om_info->om_actrl_ele.ul_mu_data_disable = %d\n", __func__, cur_om_info->om_actrl_ele.ul_mu_data_disable);
#endif
}
void rtw_he_init_om_info(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct rtw_he_actrl_om *cur_om_info = &(pmlmepriv->hepriv.om_info);
struct rtw_wifi_role_t *wrole = padapter->phl_role;
cur_om_info->om_actrl_ele.rx_nss = wrole->proto_role_cap.nss_rx - 1;
switch (wrole->chandef.bw) {
case CHANNEL_WIDTH_20:
cur_om_info->om_actrl_ele.channel_width = 0;
break;
case CHANNEL_WIDTH_40:
cur_om_info->om_actrl_ele.channel_width = 1;
break;
case CHANNEL_WIDTH_80:
cur_om_info->om_actrl_ele.channel_width = 2;
break;
case CHANNEL_WIDTH_160:
case CHANNEL_WIDTH_80_80:
cur_om_info->om_actrl_ele.channel_width = 3;
break;
default:
RTW_WARN("%s, HE OM control not support CH BW (%d), set to 0 (20M)\n", __func__, wrole->chandef.bw);
cur_om_info->om_actrl_ele.channel_width = 0;
break;
}
cur_om_info->om_actrl_ele.ul_mu_disable = _FALSE;
cur_om_info->om_actrl_ele.tx_nsts = wrole->proto_role_cap.nss_tx - 1;
cur_om_info->om_actrl_ele.er_su_disable = _FALSE;
cur_om_info->om_actrl_ele.dl_mu_mimo_rr = _FALSE;
cur_om_info->om_actrl_ele.ul_mu_data_disable = _FALSE;
cur_om_info->actrl_om_normal_tx = _FALSE;
cur_om_info->actrl_om_normal_tx_cnt = 0;
}
#endif /* CONFIG_80211AX_HE */
|
2301_81045437/rtl8852be
|
core/rtw_he.c
|
C
|
agpl-3.0
| 51,445
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _IEEE80211_C
#include <drv_types.h>
u8 RTW_WPA_OUI_TYPE[] = { 0x00, 0x50, 0xf2, 1 };
u16 RTW_WPA_VERSION = 1;
u8 WPA_AUTH_KEY_MGMT_NONE[] = { 0x00, 0x50, 0xf2, 0 };
u8 WPA_AUTH_KEY_MGMT_UNSPEC_802_1X[] = { 0x00, 0x50, 0xf2, 1 };
u8 WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X[] = { 0x00, 0x50, 0xf2, 2 };
u8 WPA_CIPHER_SUITE_NONE[] = { 0x00, 0x50, 0xf2, 0 };
u8 WPA_CIPHER_SUITE_WEP40[] = { 0x00, 0x50, 0xf2, 1 };
u8 WPA_CIPHER_SUITE_TKIP[] = { 0x00, 0x50, 0xf2, 2 };
u8 WPA_CIPHER_SUITE_WRAP[] = { 0x00, 0x50, 0xf2, 3 };
u8 WPA_CIPHER_SUITE_CCMP[] = { 0x00, 0x50, 0xf2, 4 };
u8 WPA_CIPHER_SUITE_WEP104[] = { 0x00, 0x50, 0xf2, 5 };
u8 WPA_CIPHER_SUITE_AES_CMAC[] = { 0x00, 0x50, 0xf2, 6 };
u8 WPA_CIPHER_SUITE_GCMP[] = { 0x00, 0x50, 0xf2, 8 };
u8 WPA_CIPHER_SUITE_GCMP_256[] = { 0x00, 0x50, 0xf2, 9 };
u8 WPA_CIPHER_SUITE_CCMP_256[] = { 0x00, 0x50, 0xf2, 10 };
u16 RSN_VERSION_BSD = 1;
u8 RSN_CIPHER_SUITE_NONE[] = { 0x00, 0x0f, 0xac, 0 };
u8 RSN_CIPHER_SUITE_WEP40[] = { 0x00, 0x0f, 0xac, 1 };
u8 RSN_CIPHER_SUITE_TKIP[] = { 0x00, 0x0f, 0xac, 2 };
/*u8 RSN_CIPHER_SUITE_WRAP[] = { 0x00, 0x0f, 0xac, 3 };*/
u8 RSN_CIPHER_SUITE_CCMP[] = { 0x00, 0x0f, 0xac, 4 };
u8 RSN_CIPHER_SUITE_AES_128_CMAC[] = { 0x00, 0x0f, 0xac, 6 };
u8 RSN_CIPHER_SUITE_GCMP[] = { 0x00, 0x0f, 0xac, 8 };
u8 RSN_CIPHER_SUITE_GCMP_256[] = { 0x00, 0x0f, 0xac, 9 };
u8 RSN_CIPHER_SUITE_CCMP_256[] = { 0x00, 0x0f, 0xac, 10 };
u8 RSN_CIPHER_SUITE_BIP_GMAC_128[] = { 0x00, 0x0f, 0xac, 11 };
u8 RSN_CIPHER_SUITE_BIP_GMAC_256[] = { 0x00, 0x0f, 0xac, 12 };
u8 RSN_CIPHER_SUITE_BIP_CMAC_256[] = { 0x00, 0x0f, 0xac, 13 };
u8 RSN_CIPHER_SUITE_WEP104[] = { 0x00, 0x0f, 0xac, 5 };
u8 WLAN_AKM_8021X[] = {0x00, 0x0f, 0xac, 1};
u8 WLAN_AKM_PSK[] = {0x00, 0x0f, 0xac, 2};
u8 WLAN_AKM_FT_8021X[] = {0x00, 0x0f, 0xac, 3};
u8 WLAN_AKM_FT_PSK[] = {0x00, 0x0f, 0xac, 4};
u8 WLAN_AKM_8021X_SHA256[] = {0x00, 0x0f, 0xac, 5};
u8 WLAN_AKM_PSK_SHA256[] = {0x00, 0x0f, 0xac, 6};
u8 WLAN_AKM_TDLS[] = {0x00, 0x0f, 0xac, 7};
u8 WLAN_AKM_SAE[] = {0x00, 0x0f, 0xac, 8};
u8 WLAN_AKM_FT_OVER_SAE[] = {0x00, 0x0f, 0xac, 9};
u8 WLAN_AKM_8021X_SUITE_B[] = {0x00, 0x0f, 0xac, 11};
u8 WLAN_AKM_8021X_SUITE_B_192[] = {0x00, 0x0f, 0xac, 12};
u8 WLAN_AKM_FILS_SHA256[] = {0x00, 0x0f, 0xac, 14};
u8 WLAN_AKM_FILS_SHA384[] = {0x00, 0x0f, 0xac, 15};
u8 WLAN_AKM_FT_FILS_SHA256[] = {0x00, 0x0f, 0xac, 16};
u8 WLAN_AKM_FT_FILS_SHA384[] = {0x00, 0x0f, 0xac, 17};
/* -----------------------------------------------------------
* for adhoc-master to generate ie and provide supported-rate to fw
* ----------------------------------------------------------- */
u8 WIFI_CCKRATES[] = {
(IEEE80211_CCK_RATE_1MB | IEEE80211_BASIC_RATE_MASK),
(IEEE80211_CCK_RATE_2MB | IEEE80211_BASIC_RATE_MASK),
(IEEE80211_CCK_RATE_5MB | IEEE80211_BASIC_RATE_MASK),
(IEEE80211_CCK_RATE_11MB | IEEE80211_BASIC_RATE_MASK)
};
u8 WIFI_OFDMRATES[] = {
(IEEE80211_OFDM_RATE_6MB),
(IEEE80211_OFDM_RATE_9MB),
(IEEE80211_OFDM_RATE_12MB),
(IEEE80211_OFDM_RATE_18MB),
(IEEE80211_OFDM_RATE_24MB),
IEEE80211_OFDM_RATE_36MB,
IEEE80211_OFDM_RATE_48MB,
IEEE80211_OFDM_RATE_54MB
};
u8 mgn_rates_cck[4] = {MGN_1M, MGN_2M, MGN_5_5M, MGN_11M};
u8 mgn_rates_ofdm[8] = {MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M};
u8 mgn_rates_mcs0_7[8] = {MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7};
u8 mgn_rates_mcs8_15[8] = {MGN_MCS8, MGN_MCS9, MGN_MCS10, MGN_MCS11, MGN_MCS12, MGN_MCS13, MGN_MCS14, MGN_MCS15};
u8 mgn_rates_mcs16_23[8] = {MGN_MCS16, MGN_MCS17, MGN_MCS18, MGN_MCS19, MGN_MCS20, MGN_MCS21, MGN_MCS22, MGN_MCS23};
u8 mgn_rates_mcs24_31[8] = {MGN_MCS24, MGN_MCS25, MGN_MCS26, MGN_MCS27, MGN_MCS28, MGN_MCS29, MGN_MCS30, MGN_MCS31};
u8 mgn_rates_vht1ss[10] = {MGN_VHT1SS_MCS0, MGN_VHT1SS_MCS1, MGN_VHT1SS_MCS2, MGN_VHT1SS_MCS3, MGN_VHT1SS_MCS4
, MGN_VHT1SS_MCS5, MGN_VHT1SS_MCS6, MGN_VHT1SS_MCS7, MGN_VHT1SS_MCS8, MGN_VHT1SS_MCS9
};
u8 mgn_rates_vht2ss[10] = {MGN_VHT2SS_MCS0, MGN_VHT2SS_MCS1, MGN_VHT2SS_MCS2, MGN_VHT2SS_MCS3, MGN_VHT2SS_MCS4
, MGN_VHT2SS_MCS5, MGN_VHT2SS_MCS6, MGN_VHT2SS_MCS7, MGN_VHT2SS_MCS8, MGN_VHT2SS_MCS9
};
u8 mgn_rates_vht3ss[10] = {MGN_VHT3SS_MCS0, MGN_VHT3SS_MCS1, MGN_VHT3SS_MCS2, MGN_VHT3SS_MCS3, MGN_VHT3SS_MCS4
, MGN_VHT3SS_MCS5, MGN_VHT3SS_MCS6, MGN_VHT3SS_MCS7, MGN_VHT3SS_MCS8, MGN_VHT3SS_MCS9
};
u8 mgn_rates_vht4ss[10] = {MGN_VHT4SS_MCS0, MGN_VHT4SS_MCS1, MGN_VHT4SS_MCS2, MGN_VHT4SS_MCS3, MGN_VHT4SS_MCS4
, MGN_VHT4SS_MCS5, MGN_VHT4SS_MCS6, MGN_VHT4SS_MCS7, MGN_VHT4SS_MCS8, MGN_VHT4SS_MCS9
};
RATE_SECTION mgn_rate_to_rs(enum MGN_RATE rate)
{
RATE_SECTION rs = RATE_SECTION_NUM;
if (IS_CCK_RATE(rate))
rs = CCK;
else if (IS_OFDM_RATE(rate))
rs = OFDM;
else if (IS_HT1SS_RATE(rate))
rs = HT_1SS;
else if (IS_HT2SS_RATE(rate))
rs = HT_2SS;
else if (IS_HT3SS_RATE(rate))
rs = HT_3SS;
else if (IS_HT4SS_RATE(rate))
rs = HT_4SS;
else if (IS_VHT1SS_RATE(rate))
rs = VHT_1SS;
else if (IS_VHT2SS_RATE(rate))
rs = VHT_2SS;
else if (IS_VHT3SS_RATE(rate))
rs = VHT_3SS;
else if (IS_VHT4SS_RATE(rate))
rs = VHT_4SS;
return rs;
}
static const char *const _rate_section_str[] = {
"CCK",
"OFDM",
"HT_1SS",
"HT_2SS",
"HT_3SS",
"HT_4SS",
"VHT_1SS",
"VHT_2SS",
"VHT_3SS",
"VHT_4SS",
"RATE_SECTION_UNKNOWN",
};
const char *rate_section_str(u8 section)
{
section = (section >= RATE_SECTION_NUM) ? RATE_SECTION_NUM : section;
return _rate_section_str[section];
}
struct rate_section_ent rates_by_sections[RATE_SECTION_NUM] = {
{RF_1TX, 4, mgn_rates_cck},
{RF_1TX, 8, mgn_rates_ofdm},
{RF_1TX, 8, mgn_rates_mcs0_7},
{RF_2TX, 8, mgn_rates_mcs8_15},
{RF_3TX, 8, mgn_rates_mcs16_23},
{RF_4TX, 8, mgn_rates_mcs24_31},
{RF_1TX, 10, mgn_rates_vht1ss},
{RF_2TX, 10, mgn_rates_vht2ss},
{RF_3TX, 10, mgn_rates_vht3ss},
{RF_4TX, 10, mgn_rates_vht4ss},
};
int rtw_get_bit_value_from_ieee_value(u8 val)
{
unsigned char dot11_rate_table[] = {2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108, 0}; /* last element must be zero!! */
int i = 0;
while (dot11_rate_table[i] != 0) {
if (dot11_rate_table[i] == val)
return BIT(i);
i++;
}
return 0;
}
uint rtw_get_cckrate_size(u8 *rate, u32 rate_length)
{
int i = 0;
while(i < rate_length){
RTW_DBG("%s, rate[%d]=%u\n", __FUNCTION__, i, rate[i]);
if (((rate[i] & 0x7f) == 2) || ((rate[i] & 0x7f) == 4) ||
((rate[i] & 0x7f) == 11) || ((rate[i] & 0x7f) == 22))
i++;
else
break;
}
return i;
}
uint rtw_is_cckrates_included(u8 *rate)
{
u32 i = 0;
while (rate[i] != 0) {
if ((((rate[i]) & 0x7f) == 2) || (((rate[i]) & 0x7f) == 4) ||
(((rate[i]) & 0x7f) == 11) || (((rate[i]) & 0x7f) == 22))
return _TRUE;
i++;
}
return _FALSE;
}
uint rtw_is_cckratesonly_included(u8 *rate)
{
u32 i = 0;
while (rate[i] != 0) {
if ((((rate[i]) & 0x7f) != 2) && (((rate[i]) & 0x7f) != 4) &&
(((rate[i]) & 0x7f) != 11) && (((rate[i]) & 0x7f) != 22))
return _FALSE;
i++;
}
return _TRUE;
}
int rtw_check_network_type(unsigned char *rate, int ratelen, int channel)
{
if (channel > 14) {
if ((rtw_is_cckrates_included(rate)) == _TRUE)
return WLAN_MD_INVALID;
else
return WLAN_MD_11A;
} else { /* could be pure B, pure G, or B/G */
if ((rtw_is_cckratesonly_included(rate)) == _TRUE)
return WLAN_MD_11B;
else if ((rtw_is_cckrates_included(rate)) == _TRUE)
return WLAN_MD_11BG;
else
return WLAN_MD_11G;
}
}
u8 *rtw_set_fixed_ie(unsigned char *pbuf, unsigned int len, unsigned char *source,
unsigned int *frlen)
{
_rtw_memcpy((void *)pbuf, (void *)source, len);
*frlen = *frlen + len;
return pbuf + len;
}
/* rtw_set_ie will update frame length */
u8 *rtw_set_ie
(
u8 *pbuf,
sint index,
uint len, /* IE content length, not entire IE length */
const u8 *source,
uint *frlen /* frame length */
)
{
*pbuf = (u8)index;
*(pbuf + 1) = (u8)len;
if (len > 0)
_rtw_memcpy((void *)(pbuf + 2), (void *)source, len);
if (frlen)
*frlen = *frlen + (len + 2);
return pbuf + len + 2;
}
inline u8 *rtw_set_ie_ch_switch(u8 *buf, u32 *buf_len, u8 ch_switch_mode,
u8 new_ch, u8 ch_switch_cnt)
{
u8 ie_data[3];
ie_data[0] = ch_switch_mode;
ie_data[1] = new_ch;
ie_data[2] = ch_switch_cnt;
return rtw_set_ie(buf, WLAN_EID_CHANNEL_SWITCH, 3, ie_data, buf_len);
}
inline u8 secondary_ch_offset_to_hal_ch_offset(u8 ch_offset)
{
if (ch_offset == IEEE80211_SCN)
return CHAN_OFFSET_NO_EXT;
else if (ch_offset == IEEE80211_SCA)
return CHAN_OFFSET_UPPER;
else if (ch_offset == IEEE80211_SCB)
return CHAN_OFFSET_LOWER;
return CHAN_OFFSET_NO_EXT;
}
inline u8 hal_ch_offset_to_secondary_ch_offset(u8 ch_offset)
{
if (ch_offset == CHAN_OFFSET_NO_EXT)
return IEEE80211_SCN;
else if (ch_offset == CHAN_OFFSET_UPPER)
return IEEE80211_SCA;
else if (ch_offset == CHAN_OFFSET_LOWER)
return IEEE80211_SCB;
return IEEE80211_SCN;
}
inline u8 *rtw_set_ie_secondary_ch_offset(u8 *buf, u32 *buf_len, u8 secondary_ch_offset)
{
return rtw_set_ie(buf, WLAN_EID_SECONDARY_CHANNEL_OFFSET, 1, &secondary_ch_offset, buf_len);
}
inline u8 *rtw_set_ie_mesh_ch_switch_parm(u8 *buf, u32 *buf_len, u8 ttl,
u8 flags, u16 reason, u16 precedence)
{
u8 ie_data[6];
ie_data[0] = ttl;
ie_data[1] = flags;
RTW_PUT_LE16((u8 *)&ie_data[2], reason);
RTW_PUT_LE16((u8 *)&ie_data[4], precedence);
return rtw_set_ie(buf, 0x118, 6, ie_data, buf_len);
}
/*----------------------------------------------------------------------------
index: the information element id index, limit is the limit for search
-----------------------------------------------------------------------------*/
u8 *rtw_get_ie(const u8 *pbuf, sint index, sint *len, sint limit)
{
sint tmp, i;
const u8 *p;
if (limit < 1) {
return NULL;
}
p = pbuf;
i = 0;
*len = 0;
while (1) {
if (*p == index) {
*len = *(p + 1);
return (u8 *)p;
} else {
tmp = *(p + 1);
p += (tmp + 2);
i += (tmp + 2);
}
if (i >= limit)
break;
}
return NULL;
}
/**
* rtw_get_ie_ex - Search specific IE from a series of IEs
* @in_ie: Address of IEs to search
* @in_len: Length limit from in_ie
* @eid: Element ID to match
* @oui: OUI to match
* @oui_len: OUI length
* @ie: If not NULL and the specific IE is found, the IE will be copied to the buf starting from the specific IE
* @ielen: If not NULL and the specific IE is found, will set to the length of the entire IE
*
* Returns: The address of the specific IE found, or NULL
*/
u8 *rtw_get_ie_ex(const u8 *in_ie, uint in_len, u8 eid, const u8 *oui, u8 oui_len, u8 *ie, uint *ielen)
{
uint cnt;
const u8 *target_ie = NULL;
if (ielen)
*ielen = 0;
if (!in_ie || in_len <= 0)
return (u8 *)target_ie;
cnt = 0;
while (cnt < in_len) {
if (eid == in_ie[cnt]
&& (!oui || _rtw_memcmp(&in_ie[cnt + 2], oui, oui_len) == _TRUE)) {
target_ie = &in_ie[cnt];
if (ie)
_rtw_memcpy(ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
if (ielen)
*ielen = in_ie[cnt + 1] + 2;
break;
} else {
cnt += in_ie[cnt + 1] + 2; /* goto next */
}
}
return (u8 *)target_ie;
}
/**
* rtw_ies_update_ie - Find matching IEs and update it
*
* @ies: address of IEs to search
* @ies_len: address of length of ies, will update to new length
* @offset: the offset to start scarch
* @eid: element ID to match
* @content: new content will update to matching element
* @content_len: length of new content
* Returns: _SUCCESS: ies is updated, _FAIL: not updated
*/
u8 rtw_ies_update_ie(u8 *ies, uint *ies_len, uint ies_offset, u8 eid, const u8 *content, u8 content_len)
{
u8 ret = _FAIL;
u8 *target_ie;
u32 target_ielen;
u8 *start, *remain_ies = NULL, *backup_ies = NULL;
uint search_len, remain_len = 0;
sint offset;
if (ies == NULL || *ies_len == 0 || *ies_len <= ies_offset)
goto exit;
start = ies + ies_offset;
search_len = *ies_len - ies_offset;
target_ie = rtw_get_ie(start, eid, &target_ielen, search_len);
if (target_ie && target_ielen) {
if (target_ielen != content_len) {
remain_ies = target_ie + 2 + target_ielen;
remain_len = search_len - (remain_ies - start);
backup_ies = rtw_malloc(remain_len);
if (!backup_ies)
goto exit;
_rtw_memcpy(backup_ies, remain_ies, remain_len);
}
_rtw_memcpy(target_ie + 2, content, content_len);
*(target_ie + 1) = content_len;
ret = _SUCCESS;
if (target_ielen != content_len) {
remain_ies = target_ie + 2 + content_len;
_rtw_memcpy(remain_ies, backup_ies, remain_len);
offset = content_len - target_ielen;
*ies_len = *ies_len + offset;
}
}
exit:
return ret;
}
/**
* rtw_ies_remove_ie - Find matching IEs and remove
* @ies: Address of IEs to search
* @ies_len: Pointer of length of ies, will update to new length
* @offset: The offset to start scarch
* @eid: Element ID to match
* @oui: OUI to match
* @oui_len: OUI length
*
* Returns: _SUCCESS: ies is updated, _FAIL: not updated
*/
int rtw_ies_remove_ie(u8 *ies, uint *ies_len, uint offset, u8 eid, u8 *oui, u8 oui_len)
{
int ret = _FAIL;
u8 *target_ie;
u32 target_ielen;
u8 *start;
uint search_len;
if (!ies || !ies_len || *ies_len <= offset)
goto exit;
start = ies + offset;
search_len = *ies_len - offset;
while (1) {
target_ie = rtw_get_ie_ex(start, search_len, eid, oui, oui_len, NULL, &target_ielen);
if (target_ie && target_ielen) {
u8 *remain_ies = target_ie + target_ielen;
uint remain_len = search_len - (remain_ies - start);
_rtw_memmove(target_ie, remain_ies, remain_len);
*ies_len = *ies_len - target_ielen;
ret = _SUCCESS;
start = target_ie;
search_len = remain_len;
} else
break;
}
exit:
return ret;
}
void rtw_set_supported_rate(u8 *SupportedRates, uint mode, u8 ch)
{
int is_2G_band = 1;
if (ch > 14)
is_2G_band = 0;
_rtw_memset(SupportedRates, 0, NDIS_802_11_LENGTH_RATES_EX);
if (is_2G_band) {
if (mode & WLAN_MD_11B)
_rtw_memcpy(SupportedRates, WIFI_CCKRATES, IEEE80211_CCK_RATE_LEN);
if (mode & ~WLAN_MD_11B) /* NOT B only */
_rtw_memcpy(SupportedRates + IEEE80211_CCK_RATE_LEN,
WIFI_OFDMRATES, IEEE80211_NUM_OFDM_RATESLEN);
} else {/* 5G and 6G */
_rtw_memcpy(SupportedRates, WIFI_OFDMRATES, IEEE80211_NUM_OFDM_RATESLEN);
}
}
void rtw_filter_suppport_rateie(WLAN_BSSID_EX *pbss_network, u8 keep)
{
u8 i, idx = 0, new_rate[NDIS_802_11_LENGTH_RATES_EX], *p;
uint iscck, isofdm, ie_orilen = 0, remain_len;
u8 *remain_ies;
p = rtw_get_ie(pbss_network->IEs + _BEACON_IE_OFFSET_, _SUPPORTEDRATES_IE_, &ie_orilen, (pbss_network->IELength - _BEACON_IE_OFFSET_));
if (!p)
return;
_rtw_memset(new_rate, 0, NDIS_802_11_LENGTH_RATES_EX);
for (i=0; i < ie_orilen; i++) {
iscck = rtw_is_cck_rate(p[i+2]);
isofdm= rtw_is_ofdm_rate(p[i+2]);
if (((keep == CCK) && iscck)
|| ((keep == OFDM) && isofdm))
new_rate[idx++]= rtw_is_basic_rate_ofdm(p[i+2]) ? p[i+2]|IEEE80211_BASIC_RATE_MASK : p[i+2];
}
/* update rate ie */
p[1] = idx;
_rtw_memcpy(p+2, new_rate, idx);
/* update remain ie & IELength*/
remain_ies = p + 2 + ie_orilen;
remain_len = pbss_network->IELength - (remain_ies - pbss_network->IEs);
_rtw_memmove(p+2+idx, remain_ies, remain_len);
pbss_network->IELength -= (ie_orilen - idx);
}
/*
Adjust those items by given wireless_mode
1. pbss_network->IELength
2. pbss_network->IE (SUPPORTRATE & EXT_SUPPORTRATE)
3. pbss_network->SupportedRates
*/
u8 rtw_update_rate_bymode(WLAN_BSSID_EX *pbss_network, u32 mode)
{
u8 network_type, *p, *ie = pbss_network->IEs;
sint ie_len;
uint network_ielen = pbss_network->IELength;
if (mode == WLAN_MD_11B) {
/*only keep CCK in support_rate IE and remove whole ext_support_rate IE*/
rtw_filter_suppport_rateie(pbss_network, CCK);
p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _EXT_SUPPORTEDRATES_IE_, &ie_len, pbss_network->IELength - _BEACON_IE_OFFSET_);
if (p) {
rtw_ies_remove_ie(ie , &network_ielen, _BEACON_IE_OFFSET_, _EXT_SUPPORTEDRATES_IE_, NULL, 0);
pbss_network->IELength -= ie_len;
}
network_type = WLAN_MD_11B;
} else {
if (pbss_network->Configuration.DSConfig > 14) {
/* Remove CCK in support_rate IE */
rtw_filter_suppport_rateie(pbss_network, OFDM);
network_type = WLAN_MD_11A;
} else {
if ((mode & WLAN_MD_11B) == 0) {
/* Remove CCK in support_rate IE */
rtw_filter_suppport_rateie(pbss_network, OFDM);
network_type = WLAN_MD_11G;
} else {
network_type = WLAN_MD_11BG;
}
}
}
rtw_set_supported_rate(pbss_network->SupportedRates, network_type, pbss_network->Configuration.DSConfig);
return network_type;
}
uint rtw_get_rateset_len(u8 *rateset)
{
uint i = 0;
while (1) {
if ((rateset[i]) == 0)
break;
if (i > 12)
break;
i++;
}
return i;
}
int rtw_generate_ie(struct registry_priv *pregistrypriv)
{
u8 wireless_mode;
int sz = 0, rateLen;
WLAN_BSSID_EX *pdev_network = &pregistrypriv->dev_network;
u8 *ie = pdev_network->IEs;
/* timestamp will be inserted by hardware */
sz += 8;
ie += sz;
/* beacon interval : 2bytes */
*(u16 *)ie = cpu_to_le16((u16)pdev_network->Configuration.BeaconPeriod); /* BCN_INTERVAL; */
sz += 2;
ie += 2;
/* capability info */
*(u16 *)ie = 0;
*(u16 *)ie |= cpu_to_le16(cap_IBSS);
if (pregistrypriv->preamble == PREAMBLE_SHORT)
*(u16 *)ie |= cpu_to_le16(cap_ShortPremble);
if (pdev_network->Privacy)
*(u16 *)ie |= cpu_to_le16(cap_Privacy);
sz += 2;
ie += 2;
/* SSID */
ie = rtw_set_ie(ie, _SSID_IE_, pdev_network->Ssid.SsidLength, pdev_network->Ssid.Ssid, &sz);
/* supported rates */
if (pregistrypriv->wireless_mode == WLAN_MD_11ABGN) {
if (pdev_network->Configuration.DSConfig > 14)
wireless_mode = WLAN_MD_11AN;
else
wireless_mode = WLAN_MD_11BGN;
} else if (pregistrypriv->wireless_mode == WLAN_MD_MAX) { /* WIRELESS_11ABGN | WIRELESS_11AC */
if (pdev_network->Configuration.DSConfig > 14)
wireless_mode = WLAN_MD_5G_MIX;
else
wireless_mode = WLAN_MD_24G_MIX;
} else
wireless_mode = pregistrypriv->wireless_mode;
rtw_set_supported_rate(pdev_network->SupportedRates, wireless_mode, pdev_network->Configuration.DSConfig) ;
rateLen = rtw_get_rateset_len(pdev_network->SupportedRates);
if (rateLen > 8) {
ie = rtw_set_ie(ie, _SUPPORTEDRATES_IE_, 8, pdev_network->SupportedRates, &sz);
/* ie = rtw_set_ie(ie, _EXT_SUPPORTEDRATES_IE_, (rateLen - 8), (pdev_network->SupportedRates + 8), &sz); */
} else
ie = rtw_set_ie(ie, _SUPPORTEDRATES_IE_, rateLen, pdev_network->SupportedRates, &sz);
/* DS parameter set */
ie = rtw_set_ie(ie, _DSSET_IE_, 1, (u8 *)&(pdev_network->Configuration.DSConfig), &sz);
/* IBSS Parameter Set */
ie = rtw_set_ie(ie, _IBSS_PARA_IE_, 2, (u8 *)&(pdev_network->Configuration.ATIMWindow), &sz);
if (rateLen > 8)
ie = rtw_set_ie(ie, _EXT_SUPPORTEDRATES_IE_, (rateLen - 8), (pdev_network->SupportedRates + 8), &sz);
#ifdef CONFIG_80211N_HT
/* HT Cap. */
if (is_supported_ht(pregistrypriv->wireless_mode)
&& (pregistrypriv->ht_enable == _TRUE)) {
/* todo: */
}
#endif /* CONFIG_80211N_HT */
/* pdev_network->IELength = sz; */ /* update IELength */
/* return _SUCCESS; */
return sz;
}
unsigned char *rtw_get_wpa_ie(unsigned char *pie, int *wpa_ie_len, int limit)
{
int len;
u16 val16;
unsigned char wpa_oui_type[] = {0x00, 0x50, 0xf2, 0x01};
u8 *pbuf = pie;
int limit_new = limit;
while (1) {
pbuf = rtw_get_ie(pbuf, _WPA_IE_ID_, &len, limit_new);
if (pbuf) {
/* check if oui matches... */
if (_rtw_memcmp((pbuf + 2), wpa_oui_type, sizeof(wpa_oui_type)) == _FALSE)
goto check_next_ie;
/* check version... */
_rtw_memcpy((u8 *)&val16, (pbuf + 6), sizeof(val16));
val16 = le16_to_cpu(val16);
if (val16 != 0x0001)
goto check_next_ie;
*wpa_ie_len = *(pbuf + 1);
return pbuf;
} else {
*wpa_ie_len = 0;
return NULL;
}
check_next_ie:
limit_new = limit - (pbuf - pie) - 2 - len;
if (limit_new <= 0)
break;
pbuf += (2 + len);
}
*wpa_ie_len = 0;
return NULL;
}
unsigned char *rtw_get_wpa2_ie(unsigned char *pie, int *rsn_ie_len, int limit)
{
return rtw_get_ie(pie, _WPA2_IE_ID_, rsn_ie_len, limit);
}
int rtw_get_wpa_cipher_suite(u8 *s)
{
if (_rtw_memcmp(s, WPA_CIPHER_SUITE_NONE, WPA_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_NONE;
if (_rtw_memcmp(s, WPA_CIPHER_SUITE_WEP40, WPA_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_WEP40;
if (_rtw_memcmp(s, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_TKIP;
if (_rtw_memcmp(s, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_CCMP;
if (_rtw_memcmp(s, WPA_CIPHER_SUITE_WEP104, WPA_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_WEP104;
return 0;
}
int rtw_get_rsn_cipher_suite(u8 *s)
{
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_NONE, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_NONE;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_WEP40, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_WEP40;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_TKIP;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_CCMP;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_GCMP, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_GCMP;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_GCMP_256, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_GCMP_256;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_CCMP_256, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_CCMP_256;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_WEP104, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_WEP104;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_AES_128_CMAC, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_BIP_CMAC_128;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_BIP_GMAC_128, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_BIP_GMAC_128;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_BIP_GMAC_256, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_BIP_GMAC_256;
if (_rtw_memcmp(s, RSN_CIPHER_SUITE_BIP_CMAC_256, RSN_SELECTOR_LEN) == _TRUE)
return WPA_CIPHER_BIP_CMAC_256;
return 0;
}
u32 rtw_get_akm_suite_bitmap(u8 *s)
{
if (_rtw_memcmp(s, WLAN_AKM_8021X, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_8021X;
if (_rtw_memcmp(s, WLAN_AKM_PSK, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_PSK;
if (_rtw_memcmp(s, WLAN_AKM_FT_8021X, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_FT_8021X;
if (_rtw_memcmp(s, WLAN_AKM_FT_PSK, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_FT_PSK;
if (_rtw_memcmp(s, WLAN_AKM_8021X_SHA256, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_8021X_SHA256;
if (_rtw_memcmp(s, WLAN_AKM_PSK_SHA256, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_PSK_SHA256;
if (_rtw_memcmp(s, WLAN_AKM_TDLS, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_TDLS;
if (_rtw_memcmp(s, WLAN_AKM_SAE, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_SAE;
if (_rtw_memcmp(s, WLAN_AKM_FT_OVER_SAE, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_FT_OVER_SAE;
if (_rtw_memcmp(s, WLAN_AKM_8021X_SUITE_B, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_8021X_SUITE_B;
if (_rtw_memcmp(s, WLAN_AKM_8021X_SUITE_B_192, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_8021X_SUITE_B_192;
if (_rtw_memcmp(s, WLAN_AKM_FILS_SHA256, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_FILS_SHA256;
if (_rtw_memcmp(s, WLAN_AKM_FILS_SHA384, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_FILS_SHA384;
if (_rtw_memcmp(s, WLAN_AKM_FT_FILS_SHA256, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_FT_FILS_SHA256;
if (_rtw_memcmp(s, WLAN_AKM_FT_FILS_SHA384, RSN_SELECTOR_LEN) == _TRUE)
return WLAN_AKM_TYPE_FT_FILS_SHA384;
return 0;
}
int rtw_parse_wpa_ie(u8 *wpa_ie, int wpa_ie_len, int *group_cipher,
int *pairwise_cipher, u32 *akm)
{
int i, ret = _SUCCESS;
int left, count;
u8 *pos;
u8 SUITE_1X[4] = {0x00, 0x50, 0xf2, 1};
if (wpa_ie_len <= 0) {
/* No WPA IE - fail silently */
return _FAIL;
}
if ((*wpa_ie != _WPA_IE_ID_) || (*(wpa_ie + 1) != (u8)(wpa_ie_len - 2)) ||
(_rtw_memcmp(wpa_ie + 2, RTW_WPA_OUI_TYPE, WPA_SELECTOR_LEN) != _TRUE))
return _FAIL;
pos = wpa_ie;
pos += 8;
left = wpa_ie_len - 8;
/* group_cipher */
if (left >= WPA_SELECTOR_LEN) {
*group_cipher = rtw_get_wpa_cipher_suite(pos);
pos += WPA_SELECTOR_LEN;
left -= WPA_SELECTOR_LEN;
} else if (left > 0) {
return _FAIL;
}
/* pairwise_cipher */
if (left >= 2) {
/* count = le16_to_cpu(*(u16*)pos); */
count = RTW_GET_LE16(pos);
pos += 2;
left -= 2;
if (count == 0 || left < count * WPA_SELECTOR_LEN) {
return _FAIL;
}
for (i = 0; i < count; i++) {
*pairwise_cipher |= rtw_get_wpa_cipher_suite(pos);
pos += WPA_SELECTOR_LEN;
left -= WPA_SELECTOR_LEN;
}
} else if (left == 1) {
return _FAIL;
}
if (akm) {
if (left >= 6) {
pos += 2;
if (_rtw_memcmp(pos, SUITE_1X, 4) == 1) {
*akm = WLAN_AKM_TYPE_8021X;
}
}
}
return ret;
}
int rtw_rsne_info_parse(const u8 *ie, uint ie_len, struct rsne_info *info)
{
const u8 *pos = ie;
u16 cnt;
_rtw_memset(info, 0, sizeof(struct rsne_info));
/* wpa2-imp 4.2.2 F */
if (ie + ie_len < pos + RSN_HEADER_LEN) {
RTW_INFO("%s: Invalid RSN IE length\n", __func__);
goto err;
}
if (*ie != WLAN_EID_RSN || *(ie + 1) != ie_len - 2)
goto err;
/* wpa2-imp 4.2.2 A */
if ((u16)(*(ie + 2)) != RSN_VERSION_BSD) {
RTW_INFO("%s: Invalid RSN version\n", __func__);
goto err;
}
pos += RSN_HEADER_LEN;
/* ------------------- */
/* Group CS processing */
/* ------------------- */
/* wpa2-imp 4.2.2 G */
if (ie + ie_len < pos + RSN_SELECTOR_LEN) {
if (ie + ie_len != pos) {
RTW_INFO("%s: Group Cipher Suite truncated\n", __func__);
goto err;
}
goto exit;
}
info->gcs = (u8 *)pos;
pos += RSN_SELECTOR_LEN;
/* ---------------------- */
/* Pairwise CS processing */
/* ---------------------- */
if (ie + ie_len < pos + 2) {
if (ie + ie_len != pos)
goto err;
goto exit;
}
cnt = RTW_GET_LE16(pos);
pos += 2;
/* wpa-imp 4.2.2 B D */
if (cnt == 0) {
RTW_INFO("%s: Pairwise Suite Count Invalid\n", __func__);
goto err;
}
/* wpa2-imp 4.2.2 H L */
if (ie + ie_len < pos + RSN_SELECTOR_LEN * cnt) {
if (ie + ie_len != pos) {
RTW_INFO("%s: Pairwise Suite truncated\n", __func__);
goto err;
}
goto exit;
}
info->pcs_cnt = cnt;
info->pcs_list = (u8 *)pos;
pos += RSN_SELECTOR_LEN * cnt;
/* -------------- */
/* AKM processing */
/* -------------- */
if (ie + ie_len < pos + 2) {
if (ie + ie_len != pos)
goto err;
goto exit;
}
cnt = RTW_GET_LE16(pos);
pos += 2;
/* wpa-imp 4.2.2 C D */
if (cnt == 0) {
RTW_INFO("%s: AKM Count Invalid\n", __func__);
goto err;
}
/* wpa2-imp 4.2.2 I M */
if (ie + ie_len < pos + RSN_SELECTOR_LEN * cnt) {
if (ie + ie_len != pos) {
RTW_INFO("%s: AKM truncated\n", __func__);
goto err;
}
goto exit;
}
info->akm_cnt = cnt;
info->akm_list = (u8 *)pos;
pos += RSN_SELECTOR_LEN * cnt;
/* ------------------------- */
/* RSN Capability processing */
/* ------------------------- */
/* wpa2-imp 4.2.2 J */
if (ie + ie_len < pos + 2) {
if (ie + ie_len != pos) {
RTW_INFO("%s: RSN Capability truncated\n", __func__);
goto err;
}
goto exit;
}
info->cap = (u8 *)pos;
pos += 2;
/* ---------------- */
/* PMKID processing */
/* ---------------- */
/* wpa2-imp 4.2.2 K */
if (ie + ie_len < pos + 2) {
if (ie + ie_len != pos) {
RTW_INFO("%s: PMKID count truncated\n", __func__);
goto err;
}
goto exit;
}
cnt = RTW_GET_LE16(pos);
pos += 2;
/* wpa2-imp 4.2.2 N */
if (ie + ie_len < pos + RSN_PMKID_LEN * cnt) {
if (ie + ie_len != pos || cnt) {
RTW_INFO("%s: PMKID list truncated\n", __func__);
goto err;
}
goto exit;
}
info->pmkid_cnt = cnt;
info->pmkid_list = (u8 *)pos;
pos += RSN_PMKID_LEN * cnt;
/* --------------------------------------- */
/* Group Management Cipher Suit processing */
/* --------------------------------------- */
if (ie + ie_len < pos + RSN_SELECTOR_LEN) {
if (ie + ie_len != pos)
goto err;
goto exit;
}
info->gmcs = (u8 *)pos;
exit:
return _SUCCESS;
err:
info->err = 1;
return _FAIL;
}
int rtw_parse_wpa2_ie(u8 *rsn_ie, int rsn_ie_len, int *group_cipher,
int *pairwise_cipher, int *gmcs, u32 *akm, u8 *mfp_opt, u8 *spp_opt)
{
struct rsne_info info;
int i, ret = _SUCCESS;
ret = rtw_rsne_info_parse(rsn_ie, rsn_ie_len, &info);
if (ret != _SUCCESS)
goto exit;
if (group_cipher) {
if (info.gcs)
*group_cipher = rtw_get_rsn_cipher_suite(info.gcs);
else
*group_cipher = 0;
}
if (pairwise_cipher) {
*pairwise_cipher = 0;
for (i = 0; i < info.pcs_cnt; i++)
*pairwise_cipher |= rtw_get_rsn_cipher_suite(info.pcs_list + 4 * i);
}
if (gmcs) {
if (info.gmcs)
*gmcs = rtw_get_rsn_cipher_suite(info.gmcs);
else
*gmcs = WPA_CIPHER_BIP_CMAC_128; /* default value when absent */
}
if (akm) {
*akm = 0;
for (i = 0; i < info.akm_cnt; i++)
*akm |= rtw_get_akm_suite_bitmap(info.akm_list + 4 * i);
}
if (mfp_opt) {
*mfp_opt = MFP_NO;
if (info.cap)
*mfp_opt = GET_RSN_CAP_MFP_OPTION(info.cap);
}
if (spp_opt) {
*spp_opt = 0;
if (info.cap)
*spp_opt = GET_RSN_CAP_SPP_OPT(info.cap);
}
exit:
return ret;
}
/* #ifdef CONFIG_WAPI_SUPPORT */
int rtw_get_wapi_ie(u8 *in_ie, uint in_len, u8 *wapi_ie, u16 *wapi_len)
{
int len = 0;
u8 authmode;
uint cnt;
u8 wapi_oui1[4] = {0x0, 0x14, 0x72, 0x01};
u8 wapi_oui2[4] = {0x0, 0x14, 0x72, 0x02};
if (wapi_len)
*wapi_len = 0;
if (!in_ie || in_len <= 0)
return len;
cnt = (_TIMESTAMP_ + _BEACON_ITERVAL_ + _CAPABILITY_);
while (cnt < in_len) {
authmode = in_ie[cnt];
/* if(authmode==_WAPI_IE_) */
if (authmode == _WAPI_IE_ && (_rtw_memcmp(&in_ie[cnt + 6], wapi_oui1, 4) == _TRUE ||
_rtw_memcmp(&in_ie[cnt + 6], wapi_oui2, 4) == _TRUE)) {
if (wapi_ie)
_rtw_memcpy(wapi_ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
if (wapi_len)
*wapi_len = in_ie[cnt + 1] + 2;
cnt += in_ie[cnt + 1] + 2; /* get next */
} else {
cnt += in_ie[cnt + 1] + 2; /* get next */
}
}
if (wapi_len)
len = *wapi_len;
return len;
}
/* #endif */
int rtw_get_sec_ie(u8 *in_ie, uint in_len, u8 *rsn_ie, u16 *rsn_len, u8 *wpa_ie, u16 *wpa_len)
{
u8 authmode, sec_idx;
u8 wpa_oui[4] = {0x0, 0x50, 0xf2, 0x01};
uint cnt;
/* Search required WPA or WPA2 IE and copy to sec_ie[ ] */
cnt = (_TIMESTAMP_ + _BEACON_ITERVAL_ + _CAPABILITY_);
sec_idx = 0;
while (cnt < in_len) {
authmode = in_ie[cnt];
if ((authmode == _WPA_IE_ID_) && (_rtw_memcmp(&in_ie[cnt + 2], &wpa_oui[0], 4) == _TRUE)) {
if (wpa_ie)
_rtw_memcpy(wpa_ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
*wpa_len = in_ie[cnt + 1] + 2;
cnt += in_ie[cnt + 1] + 2; /* get next */
} else {
if (authmode == _WPA2_IE_ID_) {
if (rsn_ie)
_rtw_memcpy(rsn_ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
*rsn_len = in_ie[cnt + 1] + 2;
cnt += in_ie[cnt + 1] + 2; /* get next */
} else {
cnt += in_ie[cnt + 1] + 2; /* get next */
}
}
}
return *rsn_len + *wpa_len;
}
u8 rtw_is_wps_ie(u8 *ie_ptr, uint *wps_ielen)
{
u8 match = _FALSE;
u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
if (ie_ptr == NULL)
return match;
eid = ie_ptr[0];
if ((eid == _WPA_IE_ID_) && (_rtw_memcmp(&ie_ptr[2], wps_oui, 4) == _TRUE)) {
/* RTW_INFO("==> found WPS_IE.....\n"); */
*wps_ielen = ie_ptr[1] + 2;
match = _TRUE;
}
return match;
}
u8 *rtw_get_wps_ie_from_scan_queue(u8 *in_ie, uint in_len, u8 *wps_ie, uint *wps_ielen, enum bss_type frame_type)
{
u8 *wps = NULL;
RTW_INFO("[%s] frame_type = %d\n", __FUNCTION__, frame_type);
switch (frame_type) {
case BSS_TYPE_BCN:
case BSS_TYPE_PROB_RSP: {
/* Beacon or Probe Response */
wps = rtw_get_wps_ie(in_ie + _PROBERSP_IE_OFFSET_, in_len - _PROBERSP_IE_OFFSET_, wps_ie, wps_ielen);
break;
}
case BSS_TYPE_PROB_REQ: {
/* Probe Request */
wps = rtw_get_wps_ie(in_ie + _PROBEREQ_IE_OFFSET_ , in_len - _PROBEREQ_IE_OFFSET_ , wps_ie, wps_ielen);
break;
}
default:
case BSS_TYPE_UNDEF:
break;
}
return wps;
}
/**
* rtw_get_wps_ie - Search WPS IE from a series of IEs
* @in_ie: Address of IEs to search
* @in_len: Length limit from in_ie
* @wps_ie: If not NULL and WPS IE is found, WPS IE will be copied to the buf starting from wps_ie
* @wps_ielen: If not NULL and WPS IE is found, will set to the length of the entire WPS IE
*
* Returns: The address of the WPS IE found, or NULL
*/
u8 *rtw_get_wps_ie(const u8 *in_ie, uint in_len, u8 *wps_ie, uint *wps_ielen)
{
uint cnt;
const u8 *wpsie_ptr = NULL;
u8 eid, wps_oui[4] = {0x00, 0x50, 0xf2, 0x04};
if (wps_ielen)
*wps_ielen = 0;
if (!in_ie) {
rtw_warn_on(1);
return (u8 *)wpsie_ptr;
}
if (in_len <= 0)
return (u8 *)wpsie_ptr;
cnt = 0;
while (cnt + 1 + 4 < in_len) {
eid = in_ie[cnt];
if (cnt + 1 + 4 >= MAX_IE_SZ) {
rtw_warn_on(1);
return NULL;
}
if (eid == WLAN_EID_VENDOR_SPECIFIC && _rtw_memcmp(&in_ie[cnt + 2], wps_oui, 4) == _TRUE) {
wpsie_ptr = in_ie + cnt;
if (wps_ie)
_rtw_memcpy(wps_ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
if (wps_ielen)
*wps_ielen = in_ie[cnt + 1] + 2;
break;
} else
cnt += in_ie[cnt + 1] + 2;
}
return (u8 *)wpsie_ptr;
}
/**
* rtw_get_wps_attr - Search a specific WPS attribute from a given WPS IE
* @wps_ie: Address of WPS IE to search
* @wps_ielen: Length limit from wps_ie
* @target_attr_id: The attribute ID of WPS attribute to search
* @buf_attr: If not NULL and the WPS attribute is found, WPS attribute will be copied to the buf starting from buf_attr
* @len_attr: If not NULL and the WPS attribute is found, will set to the length of the entire WPS attribute
*
* Returns: the address of the specific WPS attribute found, or NULL
*/
u8 *rtw_get_wps_attr(u8 *wps_ie, uint wps_ielen, u16 target_attr_id , u8 *buf_attr, u32 *len_attr)
{
u8 *attr_ptr = NULL;
u8 *target_attr_ptr = NULL;
u8 wps_oui[4] = {0x00, 0x50, 0xF2, 0x04};
if (len_attr)
*len_attr = 0;
if ((wps_ie[0] != _VENDOR_SPECIFIC_IE_) ||
(_rtw_memcmp(wps_ie + 2, wps_oui , 4) != _TRUE))
return attr_ptr;
/* 6 = 1(Element ID) + 1(Length) + 4(WPS OUI) */
attr_ptr = wps_ie + 6; /* goto first attr */
while (attr_ptr - wps_ie < wps_ielen) {
/* 4 = 2(Attribute ID) + 2(Length) */
u16 attr_id = RTW_GET_BE16(attr_ptr);
u16 attr_data_len = RTW_GET_BE16(attr_ptr + 2);
u16 attr_len = attr_data_len + 4;
/* RTW_INFO("%s attr_ptr:%p, id:%u, length:%u\n", __FUNCTION__, attr_ptr, attr_id, attr_data_len); */
if (attr_id == target_attr_id) {
target_attr_ptr = attr_ptr;
if (buf_attr)
_rtw_memcpy(buf_attr, attr_ptr, attr_len);
if (len_attr)
*len_attr = attr_len;
break;
} else {
attr_ptr += attr_len; /* goto next */
}
}
return target_attr_ptr;
}
/**
* rtw_get_wps_attr_content - Search a specific WPS attribute content from a given WPS IE
* @wps_ie: Address of WPS IE to search
* @wps_ielen: Length limit from wps_ie
* @target_attr_id: The attribute ID of WPS attribute to search
* @buf_content: If not NULL and the WPS attribute is found, WPS attribute content will be copied to the buf starting from buf_content
* @len_content: If not NULL and the WPS attribute is found, will set to the length of the WPS attribute content
*
* Returns: the address of the specific WPS attribute content found, or NULL
*/
u8 *rtw_get_wps_attr_content(u8 *wps_ie, uint wps_ielen, u16 target_attr_id , u8 *buf_content, uint *len_content)
{
u8 *attr_ptr;
u32 attr_len;
if (len_content)
*len_content = 0;
attr_ptr = rtw_get_wps_attr(wps_ie, wps_ielen, target_attr_id, NULL, &attr_len);
if (attr_ptr && attr_len) {
if (buf_content)
_rtw_memcpy(buf_content, attr_ptr + 4, attr_len - 4);
if (len_content)
*len_content = attr_len - 4;
return attr_ptr + 4;
}
return NULL;
}
/* OWE */
/**
* rtw_get_OWE_ie - Search OWE IE from a series of IEs
* @in_ie: Address of IEs to search
* @in_len: Length limit from in_ie
* @wps_ie: If not NULL and OWE IE is found, OWE IE will be copied to the buf starting from owe_ie
* @wps_ielen: If not NULL and OWE IE is found, will set to the length of the entire OWE IE
*
* Returns: The address of the OWE IE found, or NULL
*/
u8 *rtw_get_owe_ie(const u8 *in_ie, uint in_len, u8 *owe_ie, uint *owe_ielen)
{
uint cnt;
const u8 *oweie_ptr = NULL;
u8 eid;
if (owe_ielen)
*owe_ielen = 0;
if (!in_ie) {
rtw_warn_on(1);
return (u8 *)oweie_ptr;
}
if (in_len <= 0)
return (u8 *)oweie_ptr;
cnt = 0;
while (cnt + 1 + 4 < in_len) {
eid = in_ie[cnt];
if (cnt + 1 + 4 >= MAX_IE_SZ) {
rtw_warn_on(1);
return NULL;
}
if ((eid == WLAN_EID_EXTENSION) && (in_ie[cnt + 2] == WLAN_EID_EXT_OWE_DH_PARAM)) {
oweie_ptr = in_ie + cnt;
if (owe_ie)
_rtw_memcpy(owe_ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
if (owe_ielen)
*owe_ielen = in_ie[cnt + 1] + 2;
break;
} else
cnt += in_ie[cnt + 1] + 2;
}
return (u8 *)oweie_ptr;
}
/* Add extended capabilities element infomation into ext_cap_data of driver */
void rtw_add_ext_cap_info(u8 *ext_cap_data, u8 *ext_cap_data_len, u8 cap_info)
{
u8 byte_offset = cap_info >> 3;
u8 bit_offset = cap_info % 8;
ext_cap_data[byte_offset] |= BIT(bit_offset);
/* Enlarge the length of EXT_CAP_IE */
if (byte_offset + 1 > *ext_cap_data_len)
*ext_cap_data_len = byte_offset + 1;
#ifdef DBG_EXT_CAP_IE
RTW_INFO("%s : cap_info = %u, byte_offset = %u, bit_offset = %u, ext_cap_data_len = %u\n", \
__func__, cap_info, byte_offset, bit_offset, *ext_cap_data_len);
#endif
}
/* Remvoe extended capabilities element infomation from ext_cap_data of driver */
void rtw_remove_ext_cap_info(u8 *ext_cap_data, u8 *ext_cap_data_len, u8 cap_info)
{
u8 byte_offset = cap_info >> 3;
u8 bit_offset = cap_info % 8;
u8 i, max_len = 0;
ext_cap_data[byte_offset] &= (~BIT(bit_offset));
/* Reduce the length of EXT_CAP_IE */
for (i = 0; i < WLAN_EID_EXT_CAP_MAX_LEN; i++) {
if (ext_cap_data[i] != 0x0)
max_len = i + 1;
}
*ext_cap_data_len = max_len;
#ifdef DBG_EXT_CAP_IE
RTW_INFO("%s : cap_info = %u, byte_offset = %u, bit_offset = %u, ext_cap_data_len = %u\n", \
__func__, cap_info, byte_offset, bit_offset, *ext_cap_data_len);
#endif
}
/**
* rtw_update_ext_cap_ie - add/update/remove the extended capabilities element of frame
*
* @ext_cap_data: from &(mlme_priv->ext_capab_ie_data)
* @ext_cap_data_len: length of ext_cap_data
* @ies: address of ies, e.g. pnetwork->IEs
* @ies_len: address of length of ies, e.g. &(pnetwork->IELength)
* @ies_offset: offset of ies, e.g. _BEACON_IE_OFFSET_
*/
u8 rtw_update_ext_cap_ie(u8 *ext_cap_data, u8 ext_cap_data_len, u8 *ies, u32 *ies_len, u8 ies_offset)
{
u8 *extcap_ie;
uint extcap_len_field = 0;
uint ie_len = 0;
if (ext_cap_data_len != 0) {
extcap_ie = rtw_get_ie(ies + ies_offset, WLAN_EID_EXT_CAP, &extcap_len_field, *ies_len - ies_offset);
if (extcap_ie == NULL) {
rtw_set_ie(ies + *ies_len, WLAN_EID_EXT_CAP, ext_cap_data_len, ext_cap_data, &ie_len);
*ies_len += ie_len;
} else {
rtw_ies_update_ie(ies, ies_len, ies_offset, WLAN_EID_EXT_CAP, ext_cap_data, ext_cap_data_len);
}
} else {
rtw_ies_remove_ie(ies, ies_len, ies_offset, WLAN_EID_EXT_CAP, NULL, 0);
}
return _SUCCESS;
}
void rtw_parse_ext_cap_ie(u8 *ext_cap_data, u8 *ext_cap_data_len, u8 *ies, u32 ies_len, u8 ies_offset)
{
u8 *extcap_ie;
uint extcap_len_field = 0;
u8 i;
extcap_ie = rtw_get_ie(ies + ies_offset, WLAN_EID_EXT_CAP, &extcap_len_field, ies_len - ies_offset);
if (extcap_ie != NULL) {
extcap_ie = extcap_ie + 2; /* element id and length filed */
if (*ext_cap_data_len == 0) {
_rtw_memcpy(ext_cap_data, extcap_ie, extcap_len_field);
*ext_cap_data_len = extcap_len_field;
} else {
for (i = 0; i < extcap_len_field; i++)
ext_cap_data[i] |= extcap_ie[i];
}
#ifdef DBG_EXT_CAP_IE
for (i = 0; i < extcap_len_field; i++)
RTW_INFO("%s : Parse extended capabilties[%u] = 0x%x\n", __func__, i, extcap_ie[i]);
#endif
}
}
static int rtw_ieee802_11_parse_vendor_specific(u8 *pos, uint elen,
struct rtw_ieee802_11_elems *elems,
int show_errors)
{
unsigned int oui;
/* first 3 bytes in vendor specific information element are the IEEE
* OUI of the vendor. The following byte is used a vendor specific
* sub-type. */
if (elen < 4) {
if (show_errors) {
RTW_INFO("short vendor specific "
"information element ignored (len=%lu)\n",
(unsigned long) elen);
}
return -1;
}
oui = RTW_GET_BE24(pos);
switch (oui) {
case OUI_MICROSOFT:
/* Microsoft/Wi-Fi information elements are further typed and
* subtyped */
switch (pos[3]) {
case 1:
/* Microsoft OUI (00:50:F2) with OUI Type 1:
* real WPA information element */
elems->wpa_ie = pos;
elems->wpa_ie_len = elen;
break;
case WME_OUI_TYPE: /* this is a Wi-Fi WME info. element */
if (elen < 5) {
RTW_DBG("short WME "
"information element ignored "
"(len=%lu)\n",
(unsigned long) elen);
return -1;
}
switch (pos[4]) {
case WME_OUI_SUBTYPE_INFORMATION_ELEMENT:
case WME_OUI_SUBTYPE_PARAMETER_ELEMENT:
elems->wme = pos;
elems->wme_len = elen;
break;
case WME_OUI_SUBTYPE_TSPEC_ELEMENT:
elems->wme_tspec = pos;
elems->wme_tspec_len = elen;
break;
default:
RTW_DBG("unknown WME "
"information element ignored "
"(subtype=%d len=%lu)\n",
pos[4], (unsigned long) elen);
return -1;
}
break;
case 4:
/* Wi-Fi Protected Setup (WPS) IE */
elems->wps_ie = pos;
elems->wps_ie_len = elen;
break;
default:
RTW_DBG("Unknown Microsoft "
"information element ignored "
"(type=%d len=%lu)\n",
pos[3], (unsigned long) elen);
return -1;
}
break;
case OUI_BROADCOM:
switch (pos[3]) {
case VENDOR_HT_CAPAB_OUI_TYPE:
elems->vendor_ht_cap = pos;
elems->vendor_ht_cap_len = elen;
break;
default:
RTW_DBG("Unknown Broadcom "
"information element ignored "
"(type=%d len=%lu)\n",
pos[3], (unsigned long) elen);
return -1;
}
break;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
case OUI_REALTEK:
if (elen == 8) { // TBTX capable IE length is 8
elems->tbtx_cap = pos;
elems->tbtx_cap_len = elen;
}
break;
#endif
default:
RTW_DBG("unknown vendor specific information "
"element ignored (vendor OUI %02x:%02x:%02x "
"len=%lu)\n",
pos[0], pos[1], pos[2], (unsigned long) elen);
return -1;
}
return 0;
}
static int rtw_ieee802_11_parse_ext_elems(u8 *start, uint elen, struct rtw_ieee802_11_elems *elems)
{
u8 *pos = start;
u8 id = *pos;
switch (id) {
case WLAN_EID_EXTENSION_HE_CAPABILITY:
elems->he_capabilities = pos;
elems->he_capabilities_len = elen;
return 0;
case WLAN_EID_EXTENSION_HE_OPERATION:
elems->he_operation = pos;
elems->he_operation_len = elen;
return 0;
default:
return -1;
}
}
/**
* ieee802_11_parse_elems - Parse information elements in management frames
* @start: Pointer to the start of IEs
* @len: Length of IE buffer in octets
* @elems: Data structure for parsed elements
* @show_errors: Whether to show parsing errors in debug log
* Returns: Parsing result
*/
ParseRes rtw_ieee802_11_parse_elems(u8 *start, uint len,
struct rtw_ieee802_11_elems *elems,
int show_errors)
{
uint left = len;
u8 *pos = start;
int unknown = 0;
_rtw_memset(elems, 0, sizeof(*elems));
while (left >= 2) {
u8 id, elen;
id = *pos++;
elen = *pos++;
left -= 2;
if (elen > left) {
if (show_errors) {
RTW_INFO("IEEE 802.11 element "
"parse failed (id=%d elen=%d "
"left=%lu)\n",
id, elen, (unsigned long) left);
}
return ParseFailed;
}
switch (id) {
case WLAN_EID_SSID:
elems->ssid = pos;
elems->ssid_len = elen;
break;
case WLAN_EID_SUPP_RATES:
elems->supp_rates = pos;
elems->supp_rates_len = elen;
break;
case WLAN_EID_FH_PARAMS:
elems->fh_params = pos;
elems->fh_params_len = elen;
break;
case WLAN_EID_DS_PARAMS:
elems->ds_params = pos;
elems->ds_params_len = elen;
break;
case WLAN_EID_CF_PARAMS:
elems->cf_params = pos;
elems->cf_params_len = elen;
break;
case WLAN_EID_TIM:
elems->tim = pos;
elems->tim_len = elen;
break;
case WLAN_EID_IBSS_PARAMS:
elems->ibss_params = pos;
elems->ibss_params_len = elen;
break;
case WLAN_EID_CHALLENGE:
elems->challenge = pos;
elems->challenge_len = elen;
break;
case WLAN_EID_ERP_INFO:
elems->erp_info = pos;
elems->erp_info_len = elen;
break;
case WLAN_EID_EXT_SUPP_RATES:
elems->ext_supp_rates = pos;
elems->ext_supp_rates_len = elen;
break;
case WLAN_EID_VENDOR_SPECIFIC:
if (rtw_ieee802_11_parse_vendor_specific(pos, elen,
elems,
show_errors))
unknown++;
break;
case WLAN_EID_RSN:
elems->rsn_ie = pos;
elems->rsn_ie_len = elen;
break;
case WLAN_EID_PWR_CAPABILITY:
elems->power_cap = pos;
elems->power_cap_len = elen;
break;
case WLAN_EID_SUPPORTED_CHANNELS:
elems->supp_channels = pos;
elems->supp_channels_len = elen;
break;
case WLAN_EID_MOBILITY_DOMAIN:
elems->mdie = pos;
elems->mdie_len = elen;
break;
case WLAN_EID_FAST_BSS_TRANSITION:
elems->ftie = pos;
elems->ftie_len = elen;
break;
case WLAN_EID_TIMEOUT_INTERVAL:
elems->timeout_int = pos;
elems->timeout_int_len = elen;
break;
case WLAN_EID_HT_CAP:
elems->ht_capabilities = pos;
elems->ht_capabilities_len = elen;
break;
case WLAN_EID_HT_OPERATION:
elems->ht_operation = pos;
elems->ht_operation_len = elen;
break;
case WLAN_EID_VHT_CAPABILITY:
elems->vht_capabilities = pos;
elems->vht_capabilities_len = elen;
break;
case WLAN_EID_VHT_OPERATION:
elems->vht_operation = pos;
elems->vht_operation_len = elen;
break;
case WLAN_EID_VHT_OP_MODE_NOTIFY:
elems->vht_op_mode_notify = pos;
elems->vht_op_mode_notify_len = elen;
break;
case _EID_RRM_EN_CAP_IE_:
elems->rm_en_cap = pos;
elems->rm_en_cap_len = elen;
break;
#ifdef CONFIG_RTW_MESH
case WLAN_EID_PREQ:
elems->preq = pos;
elems->preq_len = elen;
break;
case WLAN_EID_PREP:
elems->prep = pos;
elems->prep_len = elen;
break;
case WLAN_EID_PERR:
elems->perr = pos;
elems->perr_len = elen;
break;
case WLAN_EID_RANN:
elems->rann = pos;
elems->rann_len = elen;
break;
#endif
case WLAN_EID_EXTENSION:
rtw_ieee802_11_parse_ext_elems(pos, elen, elems);
break;
default:
unknown++;
if (!show_errors)
break;
RTW_DBG("IEEE 802.11 element parse "
"ignored unknown element (id=%d elen=%d)\n",
id, elen);
break;
}
left -= elen;
pos += elen;
}
if (left)
return ParseFailed;
return unknown ? ParseUnknown : ParseOK;
}
static u8 key_char2num(u8 ch);
static u8 key_char2num(u8 ch)
{
if ((ch >= '0') && (ch <= '9'))
return ch - '0';
else if ((ch >= 'a') && (ch <= 'f'))
return ch - 'a' + 10;
else if ((ch >= 'A') && (ch <= 'F'))
return ch - 'A' + 10;
else
return 0xff;
}
u8 str_2char2num(u8 hch, u8 lch);
u8 str_2char2num(u8 hch, u8 lch)
{
return (key_char2num(hch) * 10) + key_char2num(lch);
}
u8 key_2char2num(u8 hch, u8 lch);
u8 key_2char2num(u8 hch, u8 lch)
{
return (key_char2num(hch) << 4) | key_char2num(lch);
}
void macstr2num(u8 *dst, u8 *src);
void macstr2num(u8 *dst, u8 *src)
{
int jj, kk;
for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3)
dst[jj] = key_2char2num(src[kk], src[kk + 1]);
}
u8 convert_ip_addr(u8 hch, u8 mch, u8 lch)
{
return (key_char2num(hch) * 100) + (key_char2num(mch) * 10) + key_char2num(lch);
}
/*
* Description:
* rtw_check_invalid_mac_address:
* This is only used for checking mac address valid or not.
*
* Input:
* adapter: mac_address pointer.
* check_local_bit: check locally bit or not.
*
* Output:
* _TRUE: The mac address is invalid.
* _FALSE: The mac address is valid.
*
* Auther: Isaac.Li
*/
u8 rtw_check_invalid_mac_address(u8 *mac_addr, u8 check_local_bit)
{
u8 null_mac_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
u8 multi_mac_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 res = _FALSE;
if (_rtw_memcmp(mac_addr, null_mac_addr, ETH_ALEN)) {
res = _TRUE;
goto func_exit;
}
if (_rtw_memcmp(mac_addr, multi_mac_addr, ETH_ALEN)) {
res = _TRUE;
goto func_exit;
}
if (mac_addr[0] & BIT0) {
res = _TRUE;
goto func_exit;
}
if (check_local_bit == _TRUE) {
if (mac_addr[0] & BIT1) {
res = _TRUE;
goto func_exit;
}
}
func_exit:
return res;
}
extern char *rtw_initmac;
/**
* rtw_macaddr_cfg - Decide the mac address used
* @out: buf to store mac address decided
* @hw_mac_addr: mac address from efuse/epprom
*/
void rtw_macaddr_cfg(u8 *out, const u8 *hw_mac_addr)
{
#define DEFAULT_RANDOM_MACADDR 1
u8 mac[ETH_ALEN];
if (out == NULL) {
rtw_warn_on(1);
return;
}
/* Users specify the mac address */
if (rtw_initmac) {
int jj, kk;
for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3)
mac[jj] = key_2char2num(rtw_initmac[kk], rtw_initmac[kk + 1]);
goto err_chk;
}
/* Use the mac address stored in the Efuse */
if (hw_mac_addr) {
_rtw_memcpy(mac, hw_mac_addr, ETH_ALEN);
goto err_chk;
}
err_chk:
if (rtw_check_invalid_mac_address(mac, _TRUE) == _TRUE) {
#if DEFAULT_RANDOM_MACADDR
RTW_ERR("invalid mac addr:"MAC_FMT", assign random MAC\n", MAC_ARG(mac));
*((u32 *)(&mac[2])) = rtw_random32();
mac[0] = 0x00;
mac[1] = 0xe0;
mac[2] = 0x4c;
#else
RTW_ERR("invalid mac addr:"MAC_FMT", assign default one\n", MAC_ARG(mac));
mac[0] = 0x00;
mac[1] = 0xe0;
mac[2] = 0x4c;
mac[3] = 0x87;
mac[4] = 0x00;
mac[5] = 0x00;
#endif
}
_rtw_memcpy(out, mac, ETH_ALEN);
RTW_INFO("%s mac addr:"MAC_FMT"\n", __func__, MAC_ARG(out));
}
#ifdef CONFIG_80211N_HT
void dump_ht_cap_ie_content(void *sel, const u8 *buf, u32 buf_len)
{
if (buf_len != HT_CAP_IE_LEN) {
RTW_PRINT_SEL(sel, "Invalid HT capability IE len:%d != %d\n", buf_len, HT_CAP_IE_LEN);
return;
}
RTW_PRINT_SEL(sel, "cap_info:%02x%02x:%s\n", *(buf), *(buf + 1)
, GET_HT_CAP_ELE_CHL_WIDTH(buf) ? " 40MHz" : " 20MHz");
RTW_PRINT_SEL(sel, "A-MPDU Parameters:"HT_AMPDU_PARA_FMT"\n"
, HT_AMPDU_PARA_ARG(HT_CAP_ELE_AMPDU_PARA(buf)));
RTW_PRINT_SEL(sel, "Supported MCS Set:"HT_SUP_MCS_SET_FMT"\n"
, HT_SUP_MCS_SET_ARG(HT_CAP_ELE_SUP_MCS_SET(buf)));
}
void dump_ht_cap_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *ht_cap_ie;
sint ht_cap_ielen;
ht_cap_ie = rtw_get_ie(ie, WLAN_EID_HT_CAP, &ht_cap_ielen, ie_len);
if (!ie || ht_cap_ie != ie)
return;
dump_ht_cap_ie_content(sel, ht_cap_ie + 2, ht_cap_ielen);
}
const char *const _ht_sc_offset_str[] = {
"SCN",
"SCA",
"SC-RSVD",
"SCB",
};
void dump_ht_op_ie_content(void *sel, const u8 *buf, u32 buf_len)
{
if (buf_len != HT_OP_IE_LEN) {
RTW_PRINT_SEL(sel, "Invalid HT operation IE len:%d != %d\n", buf_len, HT_OP_IE_LEN);
return;
}
RTW_PRINT_SEL(sel, "ch:%u%s %s\n"
, GET_HT_OP_ELE_PRI_CHL(buf)
, GET_HT_OP_ELE_STA_CHL_WIDTH(buf) ? "" : " 20MHz only"
, ht_sc_offset_str(GET_HT_OP_ELE_2ND_CHL_OFFSET(buf))
);
}
void dump_ht_op_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *ht_op_ie;
sint ht_op_ielen;
ht_op_ie = rtw_get_ie(ie, WLAN_EID_HT_OPERATION, &ht_op_ielen, ie_len);
if (!ie || ht_op_ie != ie)
return;
dump_ht_op_ie_content(sel, ht_op_ie + 2, ht_op_ielen);
}
#endif /* CONFIG_80211N_HT */
void dump_ies(void *sel, const u8 *buf, u32 buf_len)
{
const u8 *pos = buf;
u8 id, len;
while (pos - buf + 1 < buf_len) {
id = *pos;
len = *(pos + 1);
RTW_PRINT_SEL(sel, "%s ID:%u, LEN:%u\n", __FUNCTION__, id, len);
#ifdef CONFIG_80211N_HT
dump_ht_cap_ie(sel, pos, len + 2);
dump_ht_op_ie(sel, pos, len + 2);
#endif
#ifdef CONFIG_80211AC_VHT
dump_vht_cap_ie(sel, pos, len + 2);
dump_vht_op_ie(sel, pos, len + 2);
#endif
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif
dump_wps_ie(sel, pos, len + 2);
#ifdef CONFIG_P2P
dump_p2p_ie(sel, pos, len + 2);
#ifdef CONFIG_WFD
dump_wfd_ie(sel, pos, len + 2);
#endif
#endif
#ifdef CONFIG_RTW_MULTI_AP
dump_multi_ap_ie(sel, pos, len + 2);
#endif
pos += (2 + len);
}
}
void dump_wps_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *pos = ie;
u16 id;
u16 len;
const u8 *wps_ie;
uint wps_ielen;
wps_ie = rtw_get_wps_ie(ie, ie_len, NULL, &wps_ielen);
if (wps_ie != ie || wps_ielen == 0)
return;
pos += 6;
while (pos - ie + 4 <= ie_len) {
id = RTW_GET_BE16(pos);
len = RTW_GET_BE16(pos + 2);
RTW_PRINT_SEL(sel, "%s ID:0x%04x, LEN:%u%s\n", __func__, id, len
, ((pos - ie + 4 + len) <= ie_len) ? "" : "(exceed ie_len)");
pos += (4 + len);
}
}
/**
* rtw_ies_get_chbw - get operation ch, bw, offset from IEs of BSS.
* @ies: pointer of the first tlv IE
* @ies_len: length of @ies
* @ch: pointer of ch, used as output
* @bw: pointer of bw, used as output
* @offset: pointer of offset, used as output
* @ht: check HT IEs
* @vht: check VHT IEs, if true imply ht is true
*/
void rtw_ies_get_chbw(u8 *ies, int ies_len, u8 *ch, u8 *bw, u8 *offset, u8 ht, u8 vht)
{
u8 *p;
int ie_len;
*ch = 0;
*bw = CHANNEL_WIDTH_20;
*offset = CHAN_OFFSET_NO_EXT;
p = rtw_get_ie(ies, _DSSET_IE_, &ie_len, ies_len);
if (p && ie_len > 0)
*ch = *(p + 2);
#ifdef CONFIG_80211N_HT
if (ht || vht) {
u8 *ht_cap_ie, *ht_op_ie;
int ht_cap_ielen, ht_op_ielen;
ht_cap_ie = rtw_get_ie(ies, EID_HTCapability, &ht_cap_ielen, ies_len);
if (ht_cap_ie && ht_cap_ielen) {
if (GET_HT_CAP_ELE_CHL_WIDTH(ht_cap_ie + 2))
*bw = CHANNEL_WIDTH_40;
}
ht_op_ie = rtw_get_ie(ies, EID_HTInfo, &ht_op_ielen, ies_len);
if (ht_op_ie && ht_op_ielen) {
if (*ch == 0)
*ch = GET_HT_OP_ELE_PRI_CHL(ht_op_ie + 2);
else if (*ch != 0 && *ch != GET_HT_OP_ELE_PRI_CHL(ht_op_ie + 2)) {
RTW_INFO("%s ch inconsistent, DSSS:%u, HT primary:%u\n"
, __func__, *ch, GET_HT_OP_ELE_PRI_CHL(ht_op_ie + 2));
}
if (!GET_HT_OP_ELE_STA_CHL_WIDTH(ht_op_ie + 2))
*bw = CHANNEL_WIDTH_20;
if (*bw == CHANNEL_WIDTH_40) {
switch (GET_HT_OP_ELE_2ND_CHL_OFFSET(ht_op_ie + 2)) {
case IEEE80211_SCA:
*offset = CHAN_OFFSET_UPPER;
break;
case IEEE80211_SCB:
*offset = CHAN_OFFSET_LOWER;
break;
}
}
}
#ifdef CONFIG_80211AC_VHT
if (vht) {
u8 *vht_op_ie;
int vht_op_ielen;
vht_op_ie = rtw_get_ie(ies, EID_VHTOperation, &vht_op_ielen, ies_len);
if (vht_op_ie && vht_op_ielen) {
if (GET_VHT_OPERATION_ELE_CHL_WIDTH(vht_op_ie + 2) >= 1)
*bw = CHANNEL_WIDTH_80;
}
}
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif /* CONFIG_80211AX_HE */
#endif /* CONFIG_80211AC_VHT */
}
#endif /* CONFIG_80211N_HT */
}
void rtw_bss_get_chbw(WLAN_BSSID_EX *bss, u8 *ch, u8 *bw, u8 *offset, u8 ht, u8 vht)
{
rtw_ies_get_chbw(bss->IEs + sizeof(NDIS_802_11_FIXED_IEs)
, bss->IELength - sizeof(NDIS_802_11_FIXED_IEs)
, ch, bw, offset, ht, vht);
if (*ch == 0)
*ch = bss->Configuration.DSConfig;
else if (*ch != bss->Configuration.DSConfig) {
RTW_INFO("inconsistent ch - ies:%u bss->Configuration.DSConfig:%u\n"
, *ch, bss->Configuration.DSConfig);
*ch = bss->Configuration.DSConfig;
rtw_warn_on(1);
}
}
/**
* rtw_is_chbw_grouped - test if the two ch settings can be grouped together
* @ch_a: ch of set a
* @bw_a: bw of set a
* @offset_a: offset of set a
* @ch_b: ch of set b
* @bw_b: bw of set b
* @offset_b: offset of set b
*/
bool rtw_is_chbw_grouped(u8 ch_a, u8 bw_a, u8 offset_a
, u8 ch_b, u8 bw_b, u8 offset_b)
{
bool is_grouped = _FALSE;
if (ch_a != ch_b) {
/* ch is different */
goto exit;
} else if ((bw_a == CHANNEL_WIDTH_40 || bw_a == CHANNEL_WIDTH_80)
&& (bw_b == CHANNEL_WIDTH_40 || bw_b == CHANNEL_WIDTH_80)
) {
if (offset_a != offset_b)
goto exit;
}
is_grouped = _TRUE;
exit:
return is_grouped;
}
/**
* rtw_sync_chbw - obey g_ch, adjust g_bw, g_offset, bw, offset
* @req_ch: pointer of the request ch, may be modified further
* @req_bw: pointer of the request bw, may be modified further
* @req_offset: pointer of the request offset, may be modified further
* @g_ch: pointer of the ongoing group ch
* @g_bw: pointer of the ongoing group bw, may be modified further
* @g_offset: pointer of the ongoing group offset, may be modified further
*/
void rtw_sync_chbw(u8 *req_ch, u8 *req_bw, u8 *req_offset
, u8 *g_ch, u8 *g_bw, u8 *g_offset)
{
*req_ch = *g_ch;
if (*req_bw == CHANNEL_WIDTH_80 && *g_ch <= 14) {
/*2.4G ch, downgrade to 40Mhz */
*req_bw = CHANNEL_WIDTH_40;
}
switch (*req_bw) {
case CHANNEL_WIDTH_80:
if (*g_bw == CHANNEL_WIDTH_40 || *g_bw == CHANNEL_WIDTH_80)
*req_offset = *g_offset;
else if (*g_bw == CHANNEL_WIDTH_20)
rtw_get_offset_by_chbw(*req_ch, *req_bw, req_offset);
if (*req_offset == CHAN_OFFSET_NO_EXT) {
RTW_ERR("%s req 80MHz BW without offset, down to 20MHz\n", __func__);
rtw_warn_on(1);
*req_bw = CHANNEL_WIDTH_20;
}
break;
case CHANNEL_WIDTH_40:
if (*g_bw == CHANNEL_WIDTH_40 || *g_bw == CHANNEL_WIDTH_80)
*req_offset = *g_offset;
else if (*g_bw == CHANNEL_WIDTH_20)
rtw_get_offset_by_chbw(*req_ch, *req_bw, req_offset);
if (*req_offset == CHAN_OFFSET_NO_EXT) {
RTW_ERR("%s req 40MHz BW without offset, down to 20MHz\n", __func__);
rtw_warn_on(1);
*req_bw = CHANNEL_WIDTH_20;
}
break;
case CHANNEL_WIDTH_20:
*req_offset = CHAN_OFFSET_NO_EXT;
break;
default:
RTW_ERR("%s req unsupported BW:%u\n", __func__, *req_bw);
rtw_warn_on(1);
}
if (*req_bw > *g_bw) {
*g_bw = *req_bw;
*g_offset = *req_offset;
}
}
/**
* rtw_get_p2p_merged_len - Get merged ie length from muitiple p2p ies.
* @in_ie: Pointer of the first p2p ie
* @in_len: Total len of muiltiple p2p ies
* Returns: Length of merged p2p ie length
*/
u32 rtw_get_p2p_merged_ies_len(u8 *in_ie, u32 in_len)
{
PNDIS_802_11_VARIABLE_IEs pIE;
u8 OUI[4] = { 0x50, 0x6f, 0x9a, 0x09 };
int i = 0;
int len = 0;
while (i < in_len) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(in_ie + i);
if (pIE->ElementID == _VENDOR_SPECIFIC_IE_ && _rtw_memcmp(pIE->data, OUI, 4)) {
len += pIE->Length - 4; /* 4 is P2P OUI length, don't count it in this loop */
}
i += (pIE->Length + 2);
}
return len + 4; /* Append P2P OUI length at last. */
}
/**
* rtw_p2p_merge_ies - Merge muitiple p2p ies into one
* @in_ie: Pointer of the first p2p ie
* @in_len: Total len of muiltiple p2p ies
* @merge_ie: Pointer of merged ie
* Returns: Length of merged p2p ie
*/
int rtw_p2p_merge_ies(u8 *in_ie, u32 in_len, u8 *merge_ie)
{
PNDIS_802_11_VARIABLE_IEs pIE;
u8 len = 0;
u8 OUI[4] = { 0x50, 0x6f, 0x9a, 0x09 };
u8 ELOUI[6] = { 0xDD, 0x00, 0x50, 0x6f, 0x9a, 0x09 }; /* EID;Len;OUI, Len would copy at the end of function */
int i = 0;
if (merge_ie != NULL) {
/* Set first P2P OUI */
_rtw_memcpy(merge_ie, ELOUI, 6);
merge_ie += 6;
while (i < in_len) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(in_ie + i);
/* Take out the rest of P2P OUIs */
if (pIE->ElementID == _VENDOR_SPECIFIC_IE_ && _rtw_memcmp(pIE->data, OUI, 4)) {
_rtw_memcpy(merge_ie, pIE->data + 4, pIE->Length - 4);
len += pIE->Length - 4;
merge_ie += pIE->Length - 4;
}
i += (pIE->Length + 2);
}
return len + 4; /* 4 is for P2P OUI */
}
return 0;
}
void dump_p2p_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *pos = ie;
u8 id;
u16 len;
const u8 *p2p_ie;
uint p2p_ielen;
p2p_ie = rtw_get_p2p_ie(ie, ie_len, NULL, &p2p_ielen);
if (p2p_ie != ie || p2p_ielen == 0)
return;
pos += 6;
while (pos - ie + 3 <= ie_len) {
id = *pos;
len = RTW_GET_LE16(pos + 1);
RTW_PRINT_SEL(sel, "%s ID:%u, LEN:%u%s\n", __func__, id, len
, ((pos - ie + 3 + len) <= ie_len) ? "" : "(exceed ie_len)");
pos += (3 + len);
}
}
/**
* rtw_get_p2p_ie - Search P2P IE from a series of IEs
* @in_ie: Address of IEs to search
* @in_len: Length limit from in_ie
* @p2p_ie: If not NULL and P2P IE is found, P2P IE will be copied to the buf starting from p2p_ie
* @p2p_ielen: If not NULL and P2P IE is found, will set to the length of the entire P2P IE
*
* Returns: The address of the P2P IE found, or NULL
*/
u8 *rtw_get_p2p_ie(const u8 *in_ie, int in_len, u8 *p2p_ie, uint *p2p_ielen)
{
uint cnt;
const u8 *p2p_ie_ptr = NULL;
u8 eid, p2p_oui[4] = {0x50, 0x6F, 0x9A, 0x09};
if (p2p_ielen)
*p2p_ielen = 0;
if (!in_ie || in_len < 0) {
rtw_warn_on(1);
return (u8 *)p2p_ie_ptr;
}
if (in_len <= 0)
return (u8 *)p2p_ie_ptr;
cnt = 0;
while (cnt + 1 + 4 < in_len) {
eid = in_ie[cnt];
if (cnt + 1 + 4 >= MAX_IE_SZ) {
rtw_warn_on(1);
return NULL;
}
if (eid == WLAN_EID_VENDOR_SPECIFIC && _rtw_memcmp(&in_ie[cnt + 2], p2p_oui, 4) == _TRUE) {
p2p_ie_ptr = in_ie + cnt;
if (p2p_ie)
_rtw_memcpy(p2p_ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
if (p2p_ielen)
*p2p_ielen = in_ie[cnt + 1] + 2;
break;
} else
cnt += in_ie[cnt + 1] + 2;
}
return (u8 *)p2p_ie_ptr;
}
/**
* rtw_get_p2p_attr - Search a specific P2P attribute from a given P2P IE
* @p2p_ie: Address of P2P IE to search
* @p2p_ielen: Length limit from p2p_ie
* @target_attr_id: The attribute ID of P2P attribute to search
* @buf_attr: If not NULL and the P2P attribute is found, P2P attribute will be copied to the buf starting from buf_attr
* @len_attr: If not NULL and the P2P attribute is found, will set to the length of the entire P2P attribute
*
* Returns: the address of the specific WPS attribute found, or NULL
*/
u8 *rtw_get_p2p_attr(u8 *p2p_ie, uint p2p_ielen, u8 target_attr_id , u8 *buf_attr, u32 *len_attr)
{
u8 *attr_ptr = NULL;
u8 *target_attr_ptr = NULL;
u8 p2p_oui[4] = {0x50, 0x6F, 0x9A, 0x09};
if (len_attr)
*len_attr = 0;
if (!p2p_ie
|| p2p_ielen <= 6
|| (p2p_ie[0] != WLAN_EID_VENDOR_SPECIFIC)
|| (_rtw_memcmp(p2p_ie + 2, p2p_oui, 4) != _TRUE))
return attr_ptr;
/* 6 = 1(Element ID) + 1(Length) + 3 (OUI) + 1(OUI Type) */
attr_ptr = p2p_ie + 6; /* goto first attr */
while ((attr_ptr - p2p_ie + 3) <= p2p_ielen) {
/* 3 = 1(Attribute ID) + 2(Length) */
u8 attr_id = *attr_ptr;
u16 attr_data_len = RTW_GET_LE16(attr_ptr + 1);
u16 attr_len = attr_data_len + 3;
if (0)
RTW_INFO("%s attr_ptr:%p, id:%u, length:%u\n", __func__, attr_ptr, attr_id, attr_data_len);
if ((attr_ptr - p2p_ie + attr_len) > p2p_ielen)
break;
if (attr_id == target_attr_id) {
target_attr_ptr = attr_ptr;
if (buf_attr)
_rtw_memcpy(buf_attr, attr_ptr, attr_len);
if (len_attr)
*len_attr = attr_len;
break;
} else
attr_ptr += attr_len;
}
return target_attr_ptr;
}
/**
* rtw_get_p2p_attr_content - Search a specific P2P attribute content from a given P2P IE
* @p2p_ie: Address of P2P IE to search
* @p2p_ielen: Length limit from p2p_ie
* @target_attr_id: The attribute ID of P2P attribute to search
* @buf_content: If not NULL and the P2P attribute is found, P2P attribute content will be copied to the buf starting from buf_content
* @len_content: If not NULL and the P2P attribute is found, will set to the length of the P2P attribute content
*
* Returns: the address of the specific P2P attribute content found, or NULL
*/
u8 *rtw_get_p2p_attr_content(u8 *p2p_ie, uint p2p_ielen, u8 target_attr_id , u8 *buf_content, uint *len_content)
{
u8 *attr_ptr;
u32 attr_len;
if (len_content)
*len_content = 0;
attr_ptr = rtw_get_p2p_attr(p2p_ie, p2p_ielen, target_attr_id, NULL, &attr_len);
if (attr_ptr && attr_len) {
if (buf_content)
_rtw_memcpy(buf_content, attr_ptr + 3, attr_len - 3);
if (len_content)
*len_content = attr_len - 3;
return attr_ptr + 3;
}
return NULL;
}
u32 rtw_set_p2p_attr_content(u8 *pbuf, u8 attr_id, u16 attr_len, u8 *pdata_attr)
{
u32 a_len;
*pbuf = attr_id;
/* *(u16*)(pbuf + 1) = cpu_to_le16(attr_len); */
RTW_PUT_LE16(pbuf + 1, attr_len);
if (pdata_attr)
_rtw_memcpy(pbuf + 3, pdata_attr, attr_len);
a_len = attr_len + 3;
return a_len;
}
uint rtw_del_p2p_ie(u8 *ies, uint ies_len_ori, const char *msg)
{
#define DBG_DEL_P2P_IE 0
u8 *target_ie;
u32 target_ie_len;
uint ies_len = ies_len_ori;
int index = 0;
while (1) {
target_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &target_ie_len);
if (target_ie && target_ie_len) {
u8 *next_ie = target_ie + target_ie_len;
uint remain_len = ies_len - (next_ie - ies);
if (DBG_DEL_P2P_IE && msg) {
RTW_INFO("%s %d before\n", __func__, index);
dump_ies(RTW_DBGDUMP, ies, ies_len);
RTW_INFO("ies:%p, ies_len:%u\n", ies, ies_len);
RTW_INFO("target_ie:%p, target_ie_len:%u\n", target_ie, target_ie_len);
RTW_INFO("next_ie:%p, remain_len:%u\n", next_ie, remain_len);
}
_rtw_memmove(target_ie, next_ie, remain_len);
_rtw_memset(target_ie + remain_len, 0, target_ie_len);
ies_len -= target_ie_len;
if (DBG_DEL_P2P_IE && msg) {
RTW_INFO("%s %d after\n", __func__, index);
dump_ies(RTW_DBGDUMP, ies, ies_len);
}
index++;
} else
break;
}
return ies_len;
}
uint rtw_del_p2p_attr(u8 *ie, uint ielen_ori, u8 attr_id)
{
#define DBG_DEL_P2P_ATTR 0
u8 *target_attr;
u32 target_attr_len;
uint ielen = ielen_ori;
int index = 0;
while (1) {
target_attr = rtw_get_p2p_attr(ie, ielen, attr_id, NULL, &target_attr_len);
if (target_attr && target_attr_len) {
u8 *next_attr = target_attr + target_attr_len;
uint remain_len = ielen - (next_attr - ie);
if (DBG_DEL_P2P_ATTR) {
RTW_INFO("%s %d before\n", __func__, index);
dump_ies(RTW_DBGDUMP, ie, ielen);
RTW_INFO("ie:%p, ielen:%u\n", ie, ielen);
RTW_INFO("target_attr:%p, target_attr_len:%u\n", target_attr, target_attr_len);
RTW_INFO("next_attr:%p, remain_len:%u\n", next_attr, remain_len);
}
_rtw_memmove(target_attr, next_attr, remain_len);
_rtw_memset(target_attr + remain_len, 0, target_attr_len);
*(ie + 1) -= target_attr_len;
ielen -= target_attr_len;
if (DBG_DEL_P2P_ATTR) {
RTW_INFO("%s %d after\n", __func__, index);
dump_ies(RTW_DBGDUMP, ie, ielen);
}
index++;
} else
break;
}
return ielen;
}
inline u8 *rtw_bss_ex_get_p2p_ie(WLAN_BSSID_EX *bss_ex, u8 *p2p_ie, uint *p2p_ielen)
{
return rtw_get_p2p_ie(BSS_EX_TLV_IES(bss_ex), BSS_EX_TLV_IES_LEN(bss_ex), p2p_ie, p2p_ielen);
}
void rtw_bss_ex_del_p2p_ie(WLAN_BSSID_EX *bss_ex)
{
#define DBG_BSS_EX_DEL_P2P_IE 0
u8 *ies = BSS_EX_TLV_IES(bss_ex);
uint ies_len_ori = BSS_EX_TLV_IES_LEN(bss_ex);
uint ies_len;
ies_len = rtw_del_p2p_ie(ies, ies_len_ori, DBG_BSS_EX_DEL_P2P_IE ? __func__ : NULL);
bss_ex->IELength -= ies_len_ori - ies_len;
}
void rtw_bss_ex_del_p2p_attr(WLAN_BSSID_EX *bss_ex, u8 attr_id)
{
#define DBG_BSS_EX_DEL_P2P_ATTR 0
u8 *ies = BSS_EX_TLV_IES(bss_ex);
uint ies_len = BSS_EX_TLV_IES_LEN(bss_ex);
u8 *ie;
uint ie_len, ie_len_ori;
int index = 0;
while (1) {
ie = rtw_get_p2p_ie(ies, ies_len, NULL, &ie_len_ori);
if (ie) {
u8 *next_ie_ori = ie + ie_len_ori;
uint remain_len = bss_ex->IELength - (next_ie_ori - bss_ex->IEs);
u8 has_target_attr = 0;
if (DBG_BSS_EX_DEL_P2P_ATTR) {
if (rtw_get_p2p_attr(ie, ie_len_ori, attr_id, NULL, NULL)) {
RTW_INFO("%s %d before\n", __func__, index);
dump_ies(RTW_DBGDUMP, BSS_EX_TLV_IES(bss_ex), BSS_EX_TLV_IES_LEN(bss_ex));
RTW_INFO("ies:%p, ies_len:%u\n", ies, ies_len);
RTW_INFO("ie:%p, ie_len_ori:%u\n", ie, ie_len_ori);
RTW_INFO("next_ie_ori:%p, remain_len:%u\n", next_ie_ori, remain_len);
has_target_attr = 1;
}
}
ie_len = rtw_del_p2p_attr(ie, ie_len_ori, attr_id);
if (ie_len != ie_len_ori) {
u8 *next_ie = ie + ie_len;
_rtw_memmove(next_ie, next_ie_ori, remain_len);
_rtw_memset(next_ie + remain_len, 0, ie_len_ori - ie_len);
bss_ex->IELength -= ie_len_ori - ie_len;
ies = next_ie;
} else
ies = next_ie_ori;
if (DBG_BSS_EX_DEL_P2P_ATTR) {
if (has_target_attr) {
RTW_INFO("%s %d after\n", __func__, index);
dump_ies(RTW_DBGDUMP, BSS_EX_TLV_IES(bss_ex), BSS_EX_TLV_IES_LEN(bss_ex));
}
}
ies_len = remain_len;
index++;
} else
break;
}
}
#ifdef CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST
int rtw_chk_p2p_wildcard_ssid(WLAN_BSSID_EX *bss_ex)
{
if (_rtw_memcmp(bss_ex->Ssid.Ssid, "DIRECT-", P2P_WILDCARD_SSID_LEN))
return _SUCCESS;
else
return _FAIL;
}
int rtw_chk_p2p_ie(WLAN_BSSID_EX *bss_ex)
{
u8 *ies = BSS_EX_TLV_IES(bss_ex);
uint ies_len = BSS_EX_TLV_IES_LEN(bss_ex);
u8 *ie;
uint ie_len_ori;
ie = rtw_get_p2p_ie(ies, ies_len, NULL, &ie_len_ori);
if(ie)
return _SUCCESS;
else
return _FAIL;
}
#endif /*CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST*/
void dump_wfd_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *pos = ie;
u8 id;
u16 len;
const u8 *wfd_ie;
uint wfd_ielen;
wfd_ie = rtw_get_wfd_ie(ie, ie_len, NULL, &wfd_ielen);
if (wfd_ie != ie || wfd_ielen == 0)
return;
pos += 6;
while (pos - ie + 3 <= ie_len) {
id = *pos;
len = RTW_GET_BE16(pos + 1);
RTW_PRINT_SEL(sel, "%s ID:%u, LEN:%u%s\n", __func__, id, len
, ((pos - ie + 3 + len) <= ie_len) ? "" : "(exceed ie_len)");
pos += (3 + len);
}
}
/**
* rtw_get_wfd_ie - Search WFD IE from a series of IEs
* @in_ie: Address of IEs to search
* @in_len: Length limit from in_ie
* @wfd_ie: If not NULL and WFD IE is found, WFD IE will be copied to the buf starting from wfd_ie
* @wfd_ielen: If not NULL and WFD IE is found, will set to the length of the entire WFD IE
*
* Returns: The address of the P2P IE found, or NULL
*/
u8 *rtw_get_wfd_ie(const u8 *in_ie, int in_len, u8 *wfd_ie, uint *wfd_ielen)
{
uint cnt;
const u8 *wfd_ie_ptr = NULL;
u8 eid, wfd_oui[4] = {0x50, 0x6F, 0x9A, 0x0A};
if (wfd_ielen)
*wfd_ielen = 0;
if (!in_ie || in_len < 0) {
rtw_warn_on(1);
return (u8 *)wfd_ie_ptr;
}
if (in_len <= 0)
return (u8 *)wfd_ie_ptr;
cnt = 0;
while (cnt + 1 + 4 < in_len) {
eid = in_ie[cnt];
if (cnt + 1 + 4 >= MAX_IE_SZ) {
rtw_warn_on(1);
return NULL;
}
if (eid == WLAN_EID_VENDOR_SPECIFIC && _rtw_memcmp(&in_ie[cnt + 2], wfd_oui, 4) == _TRUE) {
wfd_ie_ptr = in_ie + cnt;
if (wfd_ie)
_rtw_memcpy(wfd_ie, &in_ie[cnt], in_ie[cnt + 1] + 2);
if (wfd_ielen)
*wfd_ielen = in_ie[cnt + 1] + 2;
break;
} else
cnt += in_ie[cnt + 1] + 2;
}
return (u8 *)wfd_ie_ptr;
}
/**
* rtw_get_wfd_attr - Search a specific WFD attribute from a given WFD IE
* @wfd_ie: Address of WFD IE to search
* @wfd_ielen: Length limit from wfd_ie
* @target_attr_id: The attribute ID of WFD attribute to search
* @buf_attr: If not NULL and the WFD attribute is found, WFD attribute will be copied to the buf starting from buf_attr
* @len_attr: If not NULL and the WFD attribute is found, will set to the length of the entire WFD attribute
*
* Returns: the address of the specific WPS attribute found, or NULL
*/
u8 *rtw_get_wfd_attr(u8 *wfd_ie, uint wfd_ielen, u8 target_attr_id, u8 *buf_attr, u32 *len_attr)
{
u8 *attr_ptr = NULL;
u8 *target_attr_ptr = NULL;
u8 wfd_oui[4] = {0x50, 0x6F, 0x9A, 0x0A};
if (len_attr)
*len_attr = 0;
if (!wfd_ie
|| wfd_ielen <= 6
|| (wfd_ie[0] != WLAN_EID_VENDOR_SPECIFIC)
|| (_rtw_memcmp(wfd_ie + 2, wfd_oui, 4) != _TRUE))
return attr_ptr;
/* 6 = 1(Element ID) + 1(Length) + 3 (OUI) + 1(OUI Type) */
attr_ptr = wfd_ie + 6; /* goto first attr */
while ((attr_ptr - wfd_ie + 3) <= wfd_ielen) {
/* 3 = 1(Attribute ID) + 2(Length) */
u8 attr_id = *attr_ptr;
u16 attr_data_len = RTW_GET_BE16(attr_ptr + 1);
u16 attr_len = attr_data_len + 3;
if (0)
RTW_INFO("%s attr_ptr:%p, id:%u, length:%u\n", __func__, attr_ptr, attr_id, attr_data_len);
if ((attr_ptr - wfd_ie + attr_len) > wfd_ielen)
break;
if (attr_id == target_attr_id) {
target_attr_ptr = attr_ptr;
if (buf_attr)
_rtw_memcpy(buf_attr, attr_ptr, attr_len);
if (len_attr)
*len_attr = attr_len;
break;
} else
attr_ptr += attr_len;
}
return target_attr_ptr;
}
/**
* rtw_get_wfd_attr_content - Search a specific WFD attribute content from a given WFD IE
* @wfd_ie: Address of WFD IE to search
* @wfd_ielen: Length limit from wfd_ie
* @target_attr_id: The attribute ID of WFD attribute to search
* @buf_content: If not NULL and the WFD attribute is found, WFD attribute content will be copied to the buf starting from buf_content
* @len_content: If not NULL and the WFD attribute is found, will set to the length of the WFD attribute content
*
* Returns: the address of the specific WFD attribute content found, or NULL
*/
u8 *rtw_get_wfd_attr_content(u8 *wfd_ie, uint wfd_ielen, u8 target_attr_id, u8 *buf_content, uint *len_content)
{
u8 *attr_ptr;
u32 attr_len;
if (len_content)
*len_content = 0;
attr_ptr = rtw_get_wfd_attr(wfd_ie, wfd_ielen, target_attr_id, NULL, &attr_len);
if (attr_ptr && attr_len) {
if (buf_content)
_rtw_memcpy(buf_content, attr_ptr + 3, attr_len - 3);
if (len_content)
*len_content = attr_len - 3;
return attr_ptr + 3;
}
return NULL;
}
uint rtw_del_wfd_ie(u8 *ies, uint ies_len_ori, const char *msg)
{
#define DBG_DEL_WFD_IE 0
u8 *target_ie;
u32 target_ie_len;
uint ies_len = ies_len_ori;
int index = 0;
while (1) {
target_ie = rtw_get_wfd_ie(ies, ies_len, NULL, &target_ie_len);
if (target_ie && target_ie_len) {
u8 *next_ie = target_ie + target_ie_len;
uint remain_len = ies_len - (next_ie - ies);
if (DBG_DEL_WFD_IE && msg) {
RTW_INFO("%s %d before\n", __func__, index);
dump_ies(RTW_DBGDUMP, ies, ies_len);
RTW_INFO("ies:%p, ies_len:%u\n", ies, ies_len);
RTW_INFO("target_ie:%p, target_ie_len:%u\n", target_ie, target_ie_len);
RTW_INFO("next_ie:%p, remain_len:%u\n", next_ie, remain_len);
}
_rtw_memmove(target_ie, next_ie, remain_len);
_rtw_memset(target_ie + remain_len, 0, target_ie_len);
ies_len -= target_ie_len;
if (DBG_DEL_WFD_IE && msg) {
RTW_INFO("%s %d after\n", __func__, index);
dump_ies(RTW_DBGDUMP, ies, ies_len);
}
index++;
} else
break;
}
return ies_len;
}
uint rtw_del_wfd_attr(u8 *ie, uint ielen_ori, u8 attr_id)
{
#define DBG_DEL_WFD_ATTR 0
u8 *target_attr;
u32 target_attr_len;
uint ielen = ielen_ori;
int index = 0;
while (1) {
target_attr = rtw_get_wfd_attr(ie, ielen, attr_id, NULL, &target_attr_len);
if (target_attr && target_attr_len) {
u8 *next_attr = target_attr + target_attr_len;
uint remain_len = ielen - (next_attr - ie);
if (DBG_DEL_WFD_ATTR) {
RTW_INFO("%s %d before\n", __func__, index);
dump_ies(RTW_DBGDUMP, ie, ielen);
RTW_INFO("ie:%p, ielen:%u\n", ie, ielen);
RTW_INFO("target_attr:%p, target_attr_len:%u\n", target_attr, target_attr_len);
RTW_INFO("next_attr:%p, remain_len:%u\n", next_attr, remain_len);
}
_rtw_memmove(target_attr, next_attr, remain_len);
_rtw_memset(target_attr + remain_len, 0, target_attr_len);
*(ie + 1) -= target_attr_len;
ielen -= target_attr_len;
if (DBG_DEL_WFD_ATTR) {
RTW_INFO("%s %d after\n", __func__, index);
dump_ies(RTW_DBGDUMP, ie, ielen);
}
index++;
} else
break;
}
return ielen;
}
inline u8 *rtw_bss_ex_get_wfd_ie(WLAN_BSSID_EX *bss_ex, u8 *wfd_ie, uint *wfd_ielen)
{
return rtw_get_wfd_ie(BSS_EX_TLV_IES(bss_ex), BSS_EX_TLV_IES_LEN(bss_ex), wfd_ie, wfd_ielen);
}
void rtw_bss_ex_del_wfd_ie(WLAN_BSSID_EX *bss_ex)
{
#define DBG_BSS_EX_DEL_WFD_IE 0
u8 *ies = BSS_EX_TLV_IES(bss_ex);
uint ies_len_ori = BSS_EX_TLV_IES_LEN(bss_ex);
uint ies_len;
ies_len = rtw_del_wfd_ie(ies, ies_len_ori, DBG_BSS_EX_DEL_WFD_IE ? __func__ : NULL);
bss_ex->IELength -= ies_len_ori - ies_len;
}
void rtw_bss_ex_del_wfd_attr(WLAN_BSSID_EX *bss_ex, u8 attr_id)
{
#define DBG_BSS_EX_DEL_WFD_ATTR 0
u8 *ies = BSS_EX_TLV_IES(bss_ex);
uint ies_len = BSS_EX_TLV_IES_LEN(bss_ex);
u8 *ie;
uint ie_len, ie_len_ori;
int index = 0;
while (1) {
ie = rtw_get_wfd_ie(ies, ies_len, NULL, &ie_len_ori);
if (ie) {
u8 *next_ie_ori = ie + ie_len_ori;
uint remain_len = bss_ex->IELength - (next_ie_ori - bss_ex->IEs);
u8 has_target_attr = 0;
if (DBG_BSS_EX_DEL_WFD_ATTR) {
if (rtw_get_wfd_attr(ie, ie_len_ori, attr_id, NULL, NULL)) {
RTW_INFO("%s %d before\n", __func__, index);
dump_ies(RTW_DBGDUMP, BSS_EX_TLV_IES(bss_ex), BSS_EX_TLV_IES_LEN(bss_ex));
RTW_INFO("ies:%p, ies_len:%u\n", ies, ies_len);
RTW_INFO("ie:%p, ie_len_ori:%u\n", ie, ie_len_ori);
RTW_INFO("next_ie_ori:%p, remain_len:%u\n", next_ie_ori, remain_len);
has_target_attr = 1;
}
}
ie_len = rtw_del_wfd_attr(ie, ie_len_ori, attr_id);
if (ie_len != ie_len_ori) {
u8 *next_ie = ie + ie_len;
_rtw_memmove(next_ie, next_ie_ori, remain_len);
_rtw_memset(next_ie + remain_len, 0, ie_len_ori - ie_len);
bss_ex->IELength -= ie_len_ori - ie_len;
ies = next_ie;
} else
ies = next_ie_ori;
if (DBG_BSS_EX_DEL_WFD_ATTR) {
if (has_target_attr) {
RTW_INFO("%s %d after\n", __func__, index);
dump_ies(RTW_DBGDUMP, BSS_EX_TLV_IES(bss_ex), BSS_EX_TLV_IES_LEN(bss_ex));
}
}
ies_len = remain_len;
index++;
} else
break;
}
}
#ifdef CONFIG_RTW_MULTI_AP
void dump_multi_ap_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *pos = ie;
u8 id;
u8 len;
const u8 *multi_ap_ie;
uint multi_ap_ielen;
multi_ap_ie = rtw_get_ie_ex(ie, ie_len, WLAN_EID_VENDOR_SPECIFIC, MULTI_AP_OUI, 4, NULL, &multi_ap_ielen);
if (multi_ap_ie != ie || multi_ap_ielen == 0)
return;
pos += 6;
while (pos - ie + 2 <= ie_len) {
id = *pos;
len = *(pos + 1);
RTW_PRINT_SEL(sel, "%s ID:%u, LEN:%u%s\n", __func__, id, len
, ((pos - ie + 2 + len) <= ie_len) ? "" : "(exceed ie_len)");
RTW_DUMP_SEL(sel, pos + 2, len);
pos += (2 + len);
}
}
/**
* rtw_get_multi_ap_ext - Search Multi-AP IE from a series of IEs and return extension subelement value
* @ies: Address of IEs to search
* @ies_len: Length limit from in_ie
*
* Returns: The address of the target IE found, or NULL
*/
u8 rtw_get_multi_ap_ie_ext(const u8 *ies, int ies_len)
{
u8 *ie;
uint ielen;
u8 val = 0;
ie = rtw_get_ie_ex(ies, ies_len, WLAN_EID_VENDOR_SPECIFIC, MULTI_AP_OUI, 4, NULL, &ielen);
if (ielen < 9)
goto exit;
if (ie[6] != MULTI_AP_SUB_ELEM_TYPE)
goto exit;
val = ie[8];
exit:
return val;
}
u8 *rtw_set_multi_ap_ie_ext(u8 *pbuf, uint *frlen, u8 val)
{
u8 cont_len = 7;
*pbuf++ = WLAN_EID_VENDOR_SPECIFIC;
*pbuf++ = cont_len;
_rtw_memcpy(pbuf, MULTI_AP_OUI, 4);
pbuf += 4;
*pbuf++ = MULTI_AP_SUB_ELEM_TYPE;
*pbuf++ = 1; /* len */
*pbuf++ = val;
if (frlen)
*frlen = *frlen + (cont_len + 2);
return pbuf;
}
#endif /* CONFIG_RTW_MULTI_AP */
/* Baron adds to avoid FreeBSD warning */
int ieee80211_is_empty_essid(const char *essid, int essid_len)
{
/* Single white space is for Linksys APs */
if (essid_len == 1 && essid[0] == ' ')
return 1;
/* Otherwise, if the entire essid is 0, we assume it is hidden */
while (essid_len) {
essid_len--;
if (essid[essid_len] != '\0')
return 0;
}
return 1;
}
int ieee80211_get_hdrlen(u16 fc)
{
int hdrlen = 24;
switch (WLAN_FC_GET_TYPE(fc)) {
case RTW_IEEE80211_FTYPE_DATA:
if (fc & RTW_IEEE80211_STYPE_QOS_DATA)
hdrlen += 2;
if ((fc & RTW_IEEE80211_FCTL_FROMDS) && (fc & RTW_IEEE80211_FCTL_TODS))
hdrlen += 6; /* Addr4 */
break;
case RTW_IEEE80211_FTYPE_CTL:
switch (WLAN_FC_GET_STYPE(fc)) {
case RTW_IEEE80211_STYPE_CTS:
case RTW_IEEE80211_STYPE_ACK:
hdrlen = 10;
break;
default:
hdrlen = 16;
break;
}
break;
}
return hdrlen;
}
u8 rtw_ht_mcsset_to_nss(u8 *supp_mcs_set)
{
u8 nss = 1;
if (supp_mcs_set[3])
nss = 4;
else if (supp_mcs_set[2])
nss = 3;
else if (supp_mcs_set[1])
nss = 2;
else if (supp_mcs_set[0])
nss = 1;
else
RTW_INFO("%s,%d, warning! supp_mcs_set is zero\n", __func__, __LINE__);
/* RTW_INFO("%s HT: %dSS\n", __FUNCTION__, nss); */
return nss;
}
u32 rtw_ht_mcs_set_to_bitmap(u8 *mcs_set, u8 nss)
{
u8 i;
u32 bitmap = 0;
for (i = 0; i < nss; i++)
bitmap |= mcs_set[i] << (i * 8);
RTW_INFO("ht_mcs_set=%02x %02x %02x %02x, nss=%u, bitmap=%08x\n"
, mcs_set[0], mcs_set[1], mcs_set[2], mcs_set[3], nss, bitmap);
return bitmap;
}
/* show MCS rate, unit: 100Kbps */
u16 rtw_ht_mcs_rate(u8 bw_40MHz, u8 short_GI, unsigned char *MCS_rate)
{
u16 max_rate = 0;
if (MCS_rate[3]) {
if (MCS_rate[3] & BIT(7))
max_rate = (bw_40MHz) ? ((short_GI) ? 6000 : 5400) : ((short_GI) ? 2889 : 2600);
else if (MCS_rate[3] & BIT(6))
max_rate = (bw_40MHz) ? ((short_GI) ? 5400 : 4860) : ((short_GI) ? 2600 : 2340);
else if (MCS_rate[3] & BIT(5))
max_rate = (bw_40MHz) ? ((short_GI) ? 4800 : 4320) : ((short_GI) ? 2311 : 2080);
else if (MCS_rate[3] & BIT(4))
max_rate = (bw_40MHz) ? ((short_GI) ? 3600 : 3240) : ((short_GI) ? 1733 : 1560);
else if (MCS_rate[3] & BIT(3))
max_rate = (bw_40MHz) ? ((short_GI) ? 2400 : 2160) : ((short_GI) ? 1156 : 1040);
else if (MCS_rate[3] & BIT(2))
max_rate = (bw_40MHz) ? ((short_GI) ? 1800 : 1620) : ((short_GI) ? 867 : 780);
else if (MCS_rate[3] & BIT(1))
max_rate = (bw_40MHz) ? ((short_GI) ? 1200 : 1080) : ((short_GI) ? 578 : 520);
else if (MCS_rate[3] & BIT(0))
max_rate = (bw_40MHz) ? ((short_GI) ? 600 : 540) : ((short_GI) ? 289 : 260);
} else if (MCS_rate[2]) {
if (MCS_rate[2] & BIT(7))
max_rate = (bw_40MHz) ? ((short_GI) ? 4500 : 4050) : ((short_GI) ? 2167 : 1950);
else if (MCS_rate[2] & BIT(6))
max_rate = (bw_40MHz) ? ((short_GI) ? 4050 : 3645) : ((short_GI) ? 1950 : 1750);
else if (MCS_rate[2] & BIT(5))
max_rate = (bw_40MHz) ? ((short_GI) ? 3600 : 3240) : ((short_GI) ? 1733 : 1560);
else if (MCS_rate[2] & BIT(4))
max_rate = (bw_40MHz) ? ((short_GI) ? 2700 : 2430) : ((short_GI) ? 1300 : 1170);
else if (MCS_rate[2] & BIT(3))
max_rate = (bw_40MHz) ? ((short_GI) ? 1800 : 1620) : ((short_GI) ? 867 : 780);
else if (MCS_rate[2] & BIT(2))
max_rate = (bw_40MHz) ? ((short_GI) ? 1350 : 1215) : ((short_GI) ? 650 : 585);
else if (MCS_rate[2] & BIT(1))
max_rate = (bw_40MHz) ? ((short_GI) ? 900 : 810) : ((short_GI) ? 433 : 390);
else if (MCS_rate[2] & BIT(0))
max_rate = (bw_40MHz) ? ((short_GI) ? 450 : 405) : ((short_GI) ? 217 : 195);
} else if (MCS_rate[1]) {
if (MCS_rate[1] & BIT(7))
max_rate = (bw_40MHz) ? ((short_GI) ? 3000 : 2700) : ((short_GI) ? 1444 : 1300);
else if (MCS_rate[1] & BIT(6))
max_rate = (bw_40MHz) ? ((short_GI) ? 2700 : 2430) : ((short_GI) ? 1300 : 1170);
else if (MCS_rate[1] & BIT(5))
max_rate = (bw_40MHz) ? ((short_GI) ? 2400 : 2160) : ((short_GI) ? 1156 : 1040);
else if (MCS_rate[1] & BIT(4))
max_rate = (bw_40MHz) ? ((short_GI) ? 1800 : 1620) : ((short_GI) ? 867 : 780);
else if (MCS_rate[1] & BIT(3))
max_rate = (bw_40MHz) ? ((short_GI) ? 1200 : 1080) : ((short_GI) ? 578 : 520);
else if (MCS_rate[1] & BIT(2))
max_rate = (bw_40MHz) ? ((short_GI) ? 900 : 810) : ((short_GI) ? 433 : 390);
else if (MCS_rate[1] & BIT(1))
max_rate = (bw_40MHz) ? ((short_GI) ? 600 : 540) : ((short_GI) ? 289 : 260);
else if (MCS_rate[1] & BIT(0))
max_rate = (bw_40MHz) ? ((short_GI) ? 300 : 270) : ((short_GI) ? 144 : 130);
} else {
if (MCS_rate[0] & BIT(7))
max_rate = (bw_40MHz) ? ((short_GI) ? 1500 : 1350) : ((short_GI) ? 722 : 650);
else if (MCS_rate[0] & BIT(6))
max_rate = (bw_40MHz) ? ((short_GI) ? 1350 : 1215) : ((short_GI) ? 650 : 585);
else if (MCS_rate[0] & BIT(5))
max_rate = (bw_40MHz) ? ((short_GI) ? 1200 : 1080) : ((short_GI) ? 578 : 520);
else if (MCS_rate[0] & BIT(4))
max_rate = (bw_40MHz) ? ((short_GI) ? 900 : 810) : ((short_GI) ? 433 : 390);
else if (MCS_rate[0] & BIT(3))
max_rate = (bw_40MHz) ? ((short_GI) ? 600 : 540) : ((short_GI) ? 289 : 260);
else if (MCS_rate[0] & BIT(2))
max_rate = (bw_40MHz) ? ((short_GI) ? 450 : 405) : ((short_GI) ? 217 : 195);
else if (MCS_rate[0] & BIT(1))
max_rate = (bw_40MHz) ? ((short_GI) ? 300 : 270) : ((short_GI) ? 144 : 130);
else if (MCS_rate[0] & BIT(0))
max_rate = (bw_40MHz) ? ((short_GI) ? 150 : 135) : ((short_GI) ? 72 : 65);
}
return max_rate;
}
int rtw_action_frame_parse(const u8 *frame, u32 frame_len, u8 *category, u8 *action)
{
const u8 *frame_body = frame + sizeof(struct rtw_ieee80211_hdr_3addr);
u16 fc;
u8 c;
u8 a = ACT_PUBLIC_MAX;
fc = le16_to_cpu(((struct rtw_ieee80211_hdr_3addr *)frame)->frame_ctl);
if ((fc & (RTW_IEEE80211_FCTL_FTYPE | RTW_IEEE80211_FCTL_STYPE))
!= (RTW_IEEE80211_FTYPE_MGMT | RTW_IEEE80211_STYPE_ACTION)
)
return _FALSE;
c = frame_body[0];
switch (c) {
case RTW_WLAN_CATEGORY_P2P: /* vendor-specific */
break;
default:
a = frame_body[1];
}
if (category)
*category = c;
if (action)
*action = a;
return _TRUE;
}
static const char *_action_public_str[] = {
"ACT_PUB_BSSCOEXIST",
"ACT_PUB_DSE_ENABLE",
"ACT_PUB_DSE_DEENABLE",
"ACT_PUB_DSE_REG_LOCATION",
"ACT_PUB_EXT_CHL_SWITCH",
"ACT_PUB_DSE_MSR_REQ",
"ACT_PUB_DSE_MSR_RPRT",
"ACT_PUB_MP",
"ACT_PUB_DSE_PWR_CONSTRAINT",
"ACT_PUB_VENDOR",
"ACT_PUB_GAS_INITIAL_REQ",
"ACT_PUB_GAS_INITIAL_RSP",
"ACT_PUB_GAS_COMEBACK_REQ",
"ACT_PUB_GAS_COMEBACK_RSP",
"ACT_PUB_TDLS_DISCOVERY_RSP",
"ACT_PUB_LOCATION_TRACK",
"ACT_PUB_RSVD",
};
const char *action_public_str(u8 action)
{
action = (action >= ACT_PUBLIC_MAX) ? ACT_PUBLIC_MAX : action;
return _action_public_str[action];
}
#if 0
/*tmp for sta mode, root cause have to wait supplicant's update.*/
void rtw_set_spp_amsdu_mode(u8 mode, u8 *rsn_ie, int rsn_ie_len)
{
struct rsne_info info;
int i, ret = _SUCCESS;
u8 spp_req_cap = 0;
ret = rtw_rsne_info_parse(rsn_ie, rsn_ie_len, &info);
if (ret != _SUCCESS)
return;
if (mode == RTW_AMSDU_MODE_NON_SPP ) {
spp_req_cap = 0;
} else if (mode == RTW_AMSDU_MODE_SPP) {
spp_req_cap = SPP_CAP|SPP_REQ;
} else if (mode == RTW_AMSDU_MODE_ALL_DROP) {
spp_req_cap = SPP_REQ;
} else {
RTW_INFO("%s unexpected mode = %d, please check the config\n", __func__, mode);
return;
}
SET_RSN_CAP_SPP(info.cap, spp_req_cap);
RTW_INFO("%s set spp opt = %d\n", __func__, GET_RSN_CAP_SPP_OPT(info.cap));
}
#endif
/* Returns:
_TRUE -- Disable AMSDU
_FALSE -- Enable AMSDU
*/
u8 rtw_check_amsdu_disable(u8 mode, u8 spp_opt)
{
u8 ret = _FALSE;
/* pp amsdu: peer's required has to be 0, or disable */
if ((mode == RTW_AMSDU_MODE_NON_SPP) && (spp_opt & SPP_REQ))
ret = _TRUE;
/* spp amsdu: peer's cap has to be 1, or disable */
else if ((mode == RTW_AMSDU_MODE_SPP) && (!(spp_opt & SPP_CAP)))
ret = _TRUE;
/* mode = all drop */
else if (mode == RTW_AMSDU_MODE_ALL_DROP)
ret = _TRUE;
else
ret = _FALSE;
return ret;
}
|
2301_81045437/rtl8852be
|
core/rtw_ieee80211.c
|
C
|
agpl-3.0
| 86,817
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
/*
The purpose of rtw_io.c
a. provides the API
b. provides the protocol engine
c. provides the software interface between caller and the hardware interface
Compiler Flag Option:
1. CONFIG_SDIO_HCI:
a. USE_SYNC_IRP: Only sync operations are provided.
b. USE_ASYNC_IRP:Both sync/async operations are provided.
2. CONFIG_USB_HCI:
a. USE_ASYNC_IRP: Both sync/async operations are provided.
3. CONFIG_CFIO_HCI:
b. USE_SYNC_IRP: Only sync operations are provided.
Only sync read/rtw_write_mem operations are provided.
jackson@realtek.com.tw
*/
#define _RTW_IO_C_
#include <drv_types.h>
/*
* Increase and check if the continual_io_error of this @param dvobjprive is larger than MAX_CONTINUAL_IO_ERR
* @return _TRUE:
* @return _FALSE:
*/
int rtw_inc_and_chk_continual_io_error(struct dvobj_priv *dvobj)
{
int ret = _FALSE;
int value;
value = ATOMIC_INC_RETURN(&dvobj->continual_io_error);
if (value > MAX_CONTINUAL_IO_ERR) {
RTW_INFO("[dvobj:%p][ERROR] continual_io_error:%d > %d\n", dvobj, value, MAX_CONTINUAL_IO_ERR);
ret = _TRUE;
} else {
/* RTW_INFO("[dvobj:%p] continual_io_error:%d\n", dvobj, value); */
}
return ret;
}
/*
* Set the continual_io_error of this @param dvobjprive to 0
*/
void rtw_reset_continual_io_error(struct dvobj_priv *dvobj)
{
ATOMIC_SET(&dvobj->continual_io_error, 0);
}
|
2301_81045437/rtl8852be
|
core/rtw_io.c
|
C
|
agpl-3.0
| 1,995
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_IOCTL_QUERY_C_
#include <drv_types.h>
|
2301_81045437/rtl8852be
|
core/rtw_ioctl_query.c
|
C
|
agpl-3.0
| 710
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_IOCTL_SET_C_
#include <drv_types.h>
extern void indicate_wx_scan_complete_event(_adapter *padapter);
#define IS_MAC_ADDRESS_BROADCAST(addr) \
(\
((addr[0] == 0xff) && (addr[1] == 0xff) && \
(addr[2] == 0xff) && (addr[3] == 0xff) && \
(addr[4] == 0xff) && (addr[5] == 0xff)) ? _TRUE : _FALSE \
)
u8 rtw_validate_bssid(u8 *bssid)
{
u8 ret = _TRUE;
if (is_zero_mac_addr(bssid)
|| is_broadcast_mac_addr(bssid)
|| is_multicast_mac_addr(bssid)
)
ret = _FALSE;
return ret;
}
u8 rtw_validate_ssid(NDIS_802_11_SSID *ssid)
{
#ifdef CONFIG_VALIDATE_SSID
u8 i;
#endif
u8 ret = _TRUE;
if (ssid->SsidLength > 32) {
ret = _FALSE;
goto exit;
}
#ifdef CONFIG_VALIDATE_SSID
for (i = 0; i < ssid->SsidLength; i++) {
/* wifi, printable ascii code must be supported */
if (!((ssid->Ssid[i] >= 0x20) && (ssid->Ssid[i] <= 0x7e))) {
ret = _FALSE;
break;
}
}
#endif /* CONFIG_VALIDATE_SSID */
exit:
return ret;
}
u8 rtw_do_join(_adapter *padapter)
{
_list *plist, *phead;
u8 *pibss = NULL;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct sitesurvey_parm parm;
_queue *queue = &(pmlmepriv->scanned_queue);
u8 ret = _SUCCESS;
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
plist = get_next(phead);
pmlmepriv->cur_network.join_res = -2;
set_fwstate(pmlmepriv, WIFI_UNDER_LINKING);
pmlmepriv->pscanned = plist;
pmlmepriv->to_join = _TRUE;
rtw_init_sitesurvey_parm(padapter, &parm);
_rtw_memcpy(&parm.ssid[0], &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
parm.ssid_num = 1;
if (pmlmepriv->assoc_ch) {
parm.ch_num = 1;
parm.ch[0].hw_value = pmlmepriv->assoc_ch;
parm.ch[0].flags = 0;
}
if (_rtw_queue_empty(queue) == _TRUE) {
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
/* when set_ssid/set_bssid for rtw_do_join(), but scanning queue is empty */
/* we try to issue sitesurvey firstly */
if (pmlmepriv->LinkDetectInfo.bBusyTraffic == _FALSE
|| rtw_to_roam(padapter) > 0
) {
u8 ssc_chk = rtw_sitesurvey_condition_check(padapter, _FALSE);
if ((ssc_chk == SS_ALLOW) || (ssc_chk == SS_DENY_BUSY_TRAFFIC) ){
/* submit site_survey_cmd */
ret = rtw_sitesurvey_cmd(padapter, &parm);
if (_SUCCESS != ret)
pmlmepriv->to_join = _FALSE;
} else {
/*if (ssc_chk == SS_DENY_BUDDY_UNDER_SURVEY)*/
pmlmepriv->to_join = _FALSE;
ret = _FAIL;
}
} else {
pmlmepriv->to_join = _FALSE;
ret = _FAIL;
}
goto exit;
} else {
int select_ret;
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
select_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);
if (select_ret == _SUCCESS) {
pmlmepriv->to_join = _FALSE;
set_assoc_timer(pmlmepriv, MAX_JOIN_TIMEOUT); /*_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);*/
} else {
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) {
/* submit createbss_cmd to change to a ADHOC_MASTER */
/* pmlmepriv->lock has been acquired by caller... */
WLAN_BSSID_EX *pdev_network = &(padapter->registrypriv.dev_network);
/*pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;*/
init_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
pibss = padapter->registrypriv.dev_network.MacAddress;
_rtw_memset(&pdev_network->Ssid, 0, sizeof(NDIS_802_11_SSID));
_rtw_memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
rtw_update_registrypriv_dev_network(padapter);
rtw_generate_random_ibss(pibss);
if (rtw_create_ibss_cmd(padapter, 0) != _SUCCESS) {
ret = _FALSE;
goto exit;
}
pmlmepriv->to_join = _FALSE;
} else {
/* can't associate ; reset under-linking */
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
/* when set_ssid/set_bssid for rtw_do_join(), but there are no desired bss in scanning queue */
/* we try to issue sitesurvey firstly */
if (pmlmepriv->LinkDetectInfo.bBusyTraffic == _FALSE
|| rtw_to_roam(padapter) > 0
) {
u8 ssc_chk = rtw_sitesurvey_condition_check(padapter, _FALSE);
if ((ssc_chk == SS_ALLOW) || (ssc_chk == SS_DENY_BUSY_TRAFFIC)){
/* RTW_INFO(("rtw_do_join() when no desired bss in scanning queue\n"); */
ret = rtw_sitesurvey_cmd(padapter, &parm);
if (_SUCCESS != ret)
pmlmepriv->to_join = _FALSE;
} else {
/*if (ssc_chk == SS_DENY_BUDDY_UNDER_SURVEY) {
} else {*/
ret = _FAIL;
pmlmepriv->to_join = _FALSE;
}
} else {
ret = _FAIL;
pmlmepriv->to_join = _FALSE;
}
}
}
}
exit:
return ret;
}
u8 rtw_set_802_11_bssid(_adapter *padapter, u8 *bssid)
{
u8 status = _SUCCESS;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
RTW_PRINT("set bssid:%pM\n", bssid);
if ((bssid[0] == 0x00 && bssid[1] == 0x00 && bssid[2] == 0x00 && bssid[3] == 0x00 && bssid[4] == 0x00 && bssid[5] == 0x00) ||
(bssid[0] == 0xFF && bssid[1] == 0xFF && bssid[2] == 0xFF && bssid[3] == 0xFF && bssid[4] == 0xFF && bssid[5] == 0xFF)) {
status = _FAIL;
goto exit;
}
_rtw_spinlock_bh(&pmlmepriv->lock);
RTW_INFO("Set BSSID under fw_state=0x%08x\n", get_fwstate(pmlmepriv));
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE)
goto handle_tkip_countermeasure;
else if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE)
goto release_mlme_lock;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE | WIFI_ADHOC_MASTER_STATE) == _TRUE) {
if (_rtw_memcmp(&pmlmepriv->cur_network.network.MacAddress, bssid, ETH_ALEN) == _TRUE) {
if (!MLME_IS_STA(padapter))
goto release_mlme_lock;/* it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again. */
} else {
rtw_disassoc_cmd(padapter, 0, 0);
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
#ifdef CONFIG_STA_CMD_DISPR
if (MLME_IS_STA(padapter) == _FALSE)
#endif /* CONFIG_STA_CMD_DISPR */
rtw_free_assoc_resources_cmd(padapter, _TRUE, 0);
rtw_indicate_disconnect(padapter, 0, _FALSE);
}
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
_clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
}
}
}
handle_tkip_countermeasure:
if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
status = _FAIL;
goto release_mlme_lock;
}
_rtw_memset(&pmlmepriv->assoc_ssid, 0, sizeof(NDIS_802_11_SSID));
_rtw_memcpy(&pmlmepriv->assoc_bssid, bssid, ETH_ALEN);
pmlmepriv->assoc_ch = 0;
pmlmepriv->assoc_by_bssid = _TRUE;
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE)
pmlmepriv->to_join = _TRUE;
else
status = rtw_do_join(padapter);
release_mlme_lock:
_rtw_spinunlock_bh(&pmlmepriv->lock);
exit:
return status;
}
u8 rtw_set_802_11_ssid(_adapter *padapter, NDIS_802_11_SSID *ssid)
{
u8 status = _SUCCESS;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *pnetwork = &pmlmepriv->cur_network;
RTW_PRINT("set ssid [%s] fw_state=0x%08x\n",
ssid->Ssid, get_fwstate(pmlmepriv));
if (!rtw_hw_is_init_completed(adapter_to_dvobj(padapter))) {
status = _FAIL;
goto exit;
}
_rtw_spinlock_bh(&pmlmepriv->lock);
RTW_INFO("Set SSID under fw_state=0x%08x\n", get_fwstate(pmlmepriv));
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE)
goto handle_tkip_countermeasure;
else if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE)
goto release_mlme_lock;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE | WIFI_ADHOC_MASTER_STATE) == _TRUE) {
if ((pmlmepriv->assoc_ssid.SsidLength == ssid->SsidLength) &&
(_rtw_memcmp(&pmlmepriv->assoc_ssid.Ssid, ssid->Ssid, ssid->SsidLength) == _TRUE)) {
if (!MLME_IS_STA(padapter)) {
if (rtw_is_same_ibss(padapter, pnetwork) == _FALSE) {
/* if in WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE, create bss or rejoin again */
rtw_disassoc_cmd(padapter, 0, 0);
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
rtw_free_assoc_resources_cmd(padapter, _TRUE, 0);
rtw_indicate_disconnect(padapter, 0, _FALSE);
}
if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) {
_clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
}
} else {
goto release_mlme_lock;/* it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again. */
}
}
#ifdef CONFIG_LPS
else
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_JOINBSS, 0);
#endif
} else {
rtw_disassoc_cmd(padapter, 0, 0);
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE){
#ifdef CONFIG_STA_CMD_DISPR
if (MLME_IS_STA(padapter) == _FALSE)
#endif /* CONFIG_STA_CMD_DISPR */
rtw_free_assoc_resources_cmd(padapter, _TRUE, 0);
rtw_indicate_disconnect(padapter, 0, _FALSE);
}
if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) {
_clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
}
}
}
handle_tkip_countermeasure:
if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
status = _FAIL;
goto release_mlme_lock;
}
if (rtw_validate_ssid(ssid) == _FALSE) {
status = _FAIL;
goto release_mlme_lock;
}
_rtw_memcpy(&pmlmepriv->assoc_ssid, ssid, sizeof(NDIS_802_11_SSID));
pmlmepriv->assoc_ch = 0;
pmlmepriv->assoc_by_bssid = _FALSE;
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE)
pmlmepriv->to_join = _TRUE;
else
status = rtw_do_join(padapter);
release_mlme_lock:
_rtw_spinunlock_bh(&pmlmepriv->lock);
exit:
return status;
}
u8 rtw_set_802_11_connect(_adapter *padapter,
u8 *bssid, NDIS_802_11_SSID *ssid, u16 ch)
{
u8 status = _SUCCESS;
bool bssid_valid = _TRUE;
bool ssid_valid = _TRUE;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (!ssid || rtw_validate_ssid(ssid) == _FALSE)
ssid_valid = _FALSE;
if (!bssid || rtw_validate_bssid(bssid) == _FALSE)
bssid_valid = _FALSE;
if (ssid_valid == _FALSE && bssid_valid == _FALSE) {
RTW_INFO(FUNC_ADPT_FMT" ssid:%p, ssid_valid:%d, bssid:%p, bssid_valid:%d\n",
FUNC_ADPT_ARG(padapter), ssid, ssid_valid, bssid, bssid_valid);
status = _FAIL;
goto exit;
}
_rtw_spinlock_bh(&pmlmepriv->lock);
RTW_PRINT(FUNC_ADPT_FMT" fw_state=0x%08x\n",
FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE)
goto handle_tkip_countermeasure;
else if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE)
goto release_mlme_lock;
handle_tkip_countermeasure:
if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
status = _FAIL;
goto release_mlme_lock;
}
if (ssid && ssid_valid)
_rtw_memcpy(&pmlmepriv->assoc_ssid, ssid, sizeof(NDIS_802_11_SSID));
else
_rtw_memset(&pmlmepriv->assoc_ssid, 0, sizeof(NDIS_802_11_SSID));
if (bssid && bssid_valid) {
_rtw_memcpy(&pmlmepriv->assoc_bssid, bssid, ETH_ALEN);
pmlmepriv->assoc_by_bssid = _TRUE;
} else
pmlmepriv->assoc_by_bssid = _FALSE;
pmlmepriv->assoc_ch = ch;
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE)
pmlmepriv->to_join = _TRUE;
else
status = rtw_do_join(padapter);
release_mlme_lock:
_rtw_spinunlock_bh(&pmlmepriv->lock);
exit:
return status;
}
u8 rtw_set_802_11_infrastructure_mode(_adapter *padapter,
NDIS_802_11_NETWORK_INFRASTRUCTURE networktype, u8 flags)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *cur_network = &pmlmepriv->cur_network;
NDIS_802_11_NETWORK_INFRASTRUCTURE *pold_state = &(cur_network->network.InfrastructureMode);
u8 ap2sta_mode = _FALSE;
u8 ret = _TRUE;
u8 is_linked = _FALSE, is_adhoc_master = _FALSE;
if (*pold_state != networktype) {
/* RTW_INFO("change mode, old_mode=%d, new_mode=%d, fw_state=0x%x\n", *pold_state, networktype, get_fwstate(pmlmepriv)); */
if (*pold_state == Ndis802_11APMode
|| *pold_state == Ndis802_11_mesh
) {
/* change to other mode from Ndis802_11APMode/Ndis802_11_mesh */
cur_network->join_res = -1;
ap2sta_mode = _TRUE;
#ifdef CONFIG_NATIVEAP_MLME
stop_ap_mode(padapter);
#endif
}
_rtw_spinlock_bh(&pmlmepriv->lock);
is_linked = check_fwstate(pmlmepriv, WIFI_ASOC_STATE);
is_adhoc_master = check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
/* flags = 0, means enqueue cmd and no wait */
if (flags != 0)
_rtw_spinunlock_bh(&pmlmepriv->lock);
if ((is_linked == _TRUE) || (*pold_state == Ndis802_11IBSS))
rtw_disassoc_cmd(padapter, 0, flags);
if ((is_adhoc_master == _TRUE)
|| ((is_linked == _TRUE)
#ifdef CONFIG_STA_CMD_DISPR
&& (MLME_IS_STA(padapter) == _FALSE)
#endif /* CONFIG_STA_CMD_DISPR */
)
)
rtw_free_assoc_resources_cmd(padapter, _TRUE, flags);
if ((*pold_state == Ndis802_11Infrastructure) || (*pold_state == Ndis802_11IBSS)) {
if (is_linked == _TRUE) {
rtw_indicate_disconnect(padapter, 0, _FALSE); /*will clr Linked_state; before this function, we must have checked whether issue dis-assoc_cmd or not*/
}
}
/* flags = 0, means enqueue cmd and no wait */
if (flags != 0)
_rtw_spinlock_bh(&pmlmepriv->lock);
*pold_state = networktype;
_clr_fwstate_(pmlmepriv, ~WIFI_NULL_STATE);
switch (networktype) {
case Ndis802_11IBSS:
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
break;
case Ndis802_11Infrastructure:
set_fwstate(pmlmepriv, WIFI_STATION_STATE);
break;
case Ndis802_11APMode:
set_fwstate(pmlmepriv, WIFI_AP_STATE);
#ifdef CONFIG_NATIVEAP_MLME
start_ap_mode(padapter);
/* rtw_indicate_connect(padapter); */
#endif
break;
#ifdef CONFIG_RTW_MESH
case Ndis802_11_mesh:
set_fwstate(pmlmepriv, WIFI_MESH_STATE);
start_ap_mode(padapter);
break;
#endif
case Ndis802_11AutoUnknown:
case Ndis802_11InfrastructureMax:
break;
#ifdef CONFIG_WIFI_MONITOR
case Ndis802_11Monitor:
set_fwstate(pmlmepriv, WIFI_MONITOR_STATE);
break;
#endif /* CONFIG_WIFI_MONITOR */
default:
ret = _FALSE;
rtw_warn_on(1);
}
/* SecClearAllKeys(adapter); */
_rtw_spinunlock_bh(&pmlmepriv->lock);
}
return ret;
}
u8 rtw_set_802_11_disassociate(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
_rtw_spinlock_bh(&pmlmepriv->lock);
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
rtw_disassoc_cmd(padapter, 0, 0);
/* modify for CONFIG_IEEE80211W, none 11w can use it */
if (1
#ifdef CONFIG_STA_CMD_DISPR
&& (MLME_IS_STA(padapter) == _FALSE)
#endif /* CONFIG_STA_CMD_DISPR */
)
rtw_free_assoc_resources_cmd(padapter, _TRUE, 0);
rtw_indicate_disconnect(padapter, 0, _FALSE);
if (_FAIL == rtw_pwr_wakeup(padapter))
RTW_INFO("%s(): rtw_pwr_wakeup fail !!!\n", __FUNCTION__);
}
_rtw_spinunlock_bh(&pmlmepriv->lock);
return _TRUE;
}
u8 rtw_set_802_11_authentication_mode(_adapter *padapter, NDIS_802_11_AUTHENTICATION_MODE authmode)
{
struct security_priv *psecuritypriv = &padapter->securitypriv;
int res;
u8 ret;
psecuritypriv->ndisauthtype = authmode;
if (psecuritypriv->ndisauthtype > 3)
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
#ifdef CONFIG_WAPI_SUPPORT
if (psecuritypriv->ndisauthtype == 6)
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_WAPI;
#endif
res = rtw_set_auth(padapter, psecuritypriv);
if (res == _SUCCESS)
ret = _TRUE;
else
ret = _FALSE;
return ret;
}
u8 rtw_set_802_11_add_wep(_adapter *padapter, NDIS_802_11_WEP *wep)
{
u8 bdefaultkey;
u8 btransmitkey;
sint keyid, res;
struct security_priv *psecuritypriv = &(padapter->securitypriv);
u8 ret = _SUCCESS;
bdefaultkey = (wep->KeyIndex & 0x40000000) > 0 ? _FALSE : _TRUE; /* for ??? */
btransmitkey = (wep->KeyIndex & 0x80000000) > 0 ? _TRUE : _FALSE; /* for ??? */
keyid = wep->KeyIndex & 0x3fffffff;
if (keyid >= 4) {
ret = _FALSE;
goto exit;
}
switch (wep->KeyLength) {
case 5:
psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
break;
case 13:
psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
break;
default:
psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
break;
}
_rtw_memcpy(&(psecuritypriv->dot11DefKey[keyid].skey[0]), &(wep->KeyMaterial), wep->KeyLength);
psecuritypriv->dot11DefKeylen[keyid] = wep->KeyLength;
psecuritypriv->dot11PrivacyKeyIndex = keyid;
res = rtw_set_key(padapter, psecuritypriv, keyid, 1, _TRUE);
if (res == _FAIL)
ret = _FALSE;
exit:
return ret;
}
/*
* rtw_get_cur_max_rate -
* @adapter: pointer to _adapter structure
*
* Return 0 or 100Kbps
*/
u16 rtw_get_cur_max_rate(_adapter *adapter)
{
int j;
int i = 0;
u16 rate = 0, max_rate = 0;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
WLAN_BSSID_EX *pcur_bss = &pmlmepriv->cur_network.network;
int sta_bssrate_len = 0;
unsigned char sta_bssrate[NumRates];
struct sta_info *psta = NULL;
u8 short_GI = 0;
#ifdef CONFIG_MP_INCLUDED
if (adapter->registrypriv.mp_mode == 1) {
if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE)
return 0;
}
#endif
if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) != _TRUE)
&& (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) != _TRUE))
return 0;
psta = rtw_get_stainfo(&adapter->stapriv, get_bssid(pmlmepriv));
if (psta == NULL)
return 0;
short_GI = query_ra_short_GI(psta, rtw_get_tx_bw_mode(adapter, psta));
#ifdef CONFIG_80211N_HT
if (is_supported_ht(psta->phl_sta->wmode)) {
max_rate = rtw_ht_mcs_rate((psta->phl_sta->chandef.bw == CHANNEL_WIDTH_40) ? 1 : 0
, short_GI
, psta->htpriv.ht_cap.supp_mcs_set
);
}
#ifdef CONFIG_80211AC_VHT
else if (is_supported_vht(psta->phl_sta->wmode))
max_rate = ((rtw_vht_mcs_to_data_rate(psta->phl_sta->chandef.bw, short_GI, pmlmepriv->vhtpriv.vht_highest_rate) + 1) >> 1) * 10;
#ifdef CONFIG_80211AX_HE
else if (is_supported_he(psta->phl_sta->wmode))
max_rate =
((rtw_he_mcs_to_data_rate(psta->phl_sta->chandef.bw,
psta->phl_sta->asoc_cap.ltf_gi,
pmlmepriv->hepriv.he_highest_rate) + 1) >> 1) * 10;
#endif /* CONFIG_80211AX_HE */
#endif /* CONFIG_80211AC_VHT */
else
#endif /* CONFIG_80211N_HT */
{
/*station mode show :station && ap support rate; softap :show ap support rate*/
if (MLME_IS_STA(adapter))
get_rate_set(adapter, sta_bssrate, &sta_bssrate_len);/*get sta rate and length*/
while ((pcur_bss->SupportedRates[i] != 0) && (pcur_bss->SupportedRates[i] != 0xFF)) {
rate = pcur_bss->SupportedRates[i] & 0x7F;/*AP support rates*/
/*RTW_INFO("%s rate=%02X \n", __func__, rate);*/
/*check STA support rate or not */
if (MLME_IS_STA(adapter)) {
for (j = 0; j < sta_bssrate_len; j++) {
/* Avoid the proprietary data rate (22Mbps) of Handlink WSG-4000 AP */
if ((rate | IEEE80211_BASIC_RATE_MASK)
== (sta_bssrate[j] | IEEE80211_BASIC_RATE_MASK)) {
if (rate > max_rate) {
max_rate = rate;
}
break;
}
}
} else {
if (rate > max_rate)
max_rate = rate;
}
i++;
}
max_rate = max_rate * 10 / 2;
}
return max_rate;
}
/*
* rtw_set_scan_mode -
* @adapter: pointer to _adapter structure
* @scan_mode:
*
* Return _SUCCESS or _FAIL
*/
int rtw_set_scan_mode(_adapter *adapter, enum rtw_phl_scan_type scan_mode)
{
if (scan_mode != RTW_PHL_SCAN_ACTIVE &&
scan_mode != RTW_PHL_SCAN_PASSIVE)
return _FAIL;
adapter->mlmepriv.scan_mode = scan_mode;
return _SUCCESS;
}
/*
* rtw_set_channel_plan -
* @adapter: pointer to _adapter structure
* @channel_plan:
*
* Return _SUCCESS or _FAIL
*/
int rtw_set_channel_plan(_adapter *adapter, u8 channel_plan, u8 chplan_6g, enum rtw_regd_inr inr)
{
struct registry_priv *regsty = adapter_to_regsty(adapter);
if (!REGSTY_REGD_SRC_FROM_OS(regsty))
return rtw_set_chplan_cmd(adapter, RTW_CMDF_WAIT_ACK, channel_plan, chplan_6g, inr);
RTW_WARN("%s(): not applied\n", __func__);
return _SUCCESS;
}
/*
* rtw_set_country -
* @adapter: pointer to _adapter structure
* @country_code: string of country code
*
* Return _SUCCESS or _FAIL
*/
int rtw_set_country(_adapter *adapter, const char *country_code, enum rtw_regd_inr inr)
{
#ifdef CONFIG_RTW_IOCTL_SET_COUNTRY
struct registry_priv *regsty = adapter_to_regsty(adapter);
if (!REGSTY_REGD_SRC_FROM_OS(regsty))
return rtw_set_country_cmd(adapter, RTW_CMDF_WAIT_ACK, country_code, inr);
#endif
RTW_WARN("%s(): not applied\n", __func__);
return _SUCCESS;
}
/*
* rtw_set_band -
* @adapter: pointer to _adapter structure
* @band: band to set
*
* Return _SUCCESS or _FAIL
*/
int rtw_set_band(_adapter *adapter, u8 band)
{
if (rtw_band_valid(band)) {
RTW_INFO(FUNC_ADPT_FMT" band:%d\n", FUNC_ADPT_ARG(adapter), band);
adapter->setband = band;
return _SUCCESS;
}
RTW_PRINT(FUNC_ADPT_FMT" band:%d fail\n", FUNC_ADPT_ARG(adapter), band);
return _FAIL;
}
|
2301_81045437/rtl8852be
|
core/rtw_ioctl_set.c
|
C
|
agpl-3.0
| 21,375
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_MBO_C
#include <drv_types.h>
#ifdef CONFIG_RTW_MBO
#ifndef RTW_MBO_DBG
#define RTW_MBO_DBG 0
#endif
#if RTW_MBO_DBG
#define RTW_MBO_INFO(fmt, arg...) \
RTW_INFO(fmt, arg)
#define RTW_MBO_DUMP(str, data, len) \
RTW_INFO_DUMP(str, data, len)
#else
#define RTW_MBO_INFO(fmt, arg...) do {} while (0)
#define RTW_MBO_DUMP(str, data, len) do {} while (0)
#endif
/* Cellular Data Connectivity field
* 1 : Cellular data connection available
* 2 : Cellular data connection not available
* 3 : Not Cellular data capable
* otherwise : Reserved
*/
int rtw_mbo_cell_data_conn = 2;
module_param(rtw_mbo_cell_data_conn, int, 0644);
static u8 wfa_mbo_oui[] = {0x50, 0x6F, 0x9A, 0x16};
#define rtw_mbo_get_oui(p) ((u8 *)(p) + 2)
#define rtw_mbo_get_attr_id(p) ((u8 *)(p))
#define rtw_mbo_get_disallow_res(p) ((u8 *)(p) + 3)
#define rtw_mbo_set_1byte_ie(p, v, l) \
rtw_set_fixed_ie((p), 1, (v), (l))
#define rtw_mbo_set_2byte_ie(p, v, l) \
rtw_set_fixed_ie((p), 2, (v), (l))
#define rtw_mbo_set_4byte_ie(p, v, l) \
rtw_set_fixed_ie((p), 4, (v), (l))
#define rtw_mbo_set_nbyte_ie(p, sz, v, l) \
rtw_set_fixed_ie((p), (sz), (v), (l))
#define rtw_mbo_subfield_set(p, offset, val) (*(p + offset) = val)
#define rtw_mbo_subfields_set(p, offset, buf, len) \
do { \
u32 _offset = 0; \
u8 *_p = p + offset; \
while(_offset < len) { \
*(_p + _offset) = *(buf + _offset); \
_offset++; \
} \
} while(0)
void rtw_mbo_ie_init(_adapter *padapter, struct mbo_priv *mbopriv)
{
if(!mbopriv)
return;
mbopriv->assoc_disallow = 0;
mbopriv->cellular_aware = 0;
mbopriv->ch_list_num = 0;
mbopriv->mbo_oce_element_len = 6;
mbopriv->mbo_oce_element[0] = 0xdd;
mbopriv->mbo_oce_element[1] = mbopriv->mbo_oce_element_len;
mbopriv->mbo_oce_element[2] = 0x50;
mbopriv->mbo_oce_element[3] = 0x6f;
mbopriv->mbo_oce_element[4] = 0x9a;
mbopriv->mbo_oce_element[5] = 0x16;
}
void rtw_mbo_fill_non_prefer_channel_list(_adapter *padapter, struct mbo_priv *mbopriv,
const u8 *pbuf, u8 len)
{
u8 op_class = 0;
u8 preference = 0;
int i;
/* invalid length */
if(len != 0 && len < 3)
return;
/* reset non-prefer channel list */
mbopriv->ch_list_num = 0;
op_class = *pbuf;
preference = *(pbuf + len - 2);
if (len == 3 && mbopriv->ch_list_num < MBO_CH_LIST_MAX_NUM) {
mbopriv->ch_list[mbopriv->ch_list_num].op_class = op_class;
mbopriv->ch_list[mbopriv->ch_list_num].preference = preference;
mbopriv->ch_list[mbopriv->ch_list_num].channel = 0;
mbopriv->ch_list_num += 1;
RTW_INFO("[%s:%d]channel = %d, preference = %d\n", __func__, __LINE__, 0, preference);
} else {
for (i = 0; i < len - 3; i++) {
if(mbopriv->ch_list_num >= MBO_CH_LIST_MAX_NUM)
break;
mbopriv->ch_list[mbopriv->ch_list_num].op_class = op_class;
mbopriv->ch_list[mbopriv->ch_list_num].preference = preference;
mbopriv->ch_list[mbopriv->ch_list_num].channel = *(pbuf + 1 + i);
mbopriv->ch_list_num += 1;
RTW_INFO("[%s:%d]channel = %d, preference = %d\n", __func__, __LINE__,
*(pbuf + 1 + i), preference);
}
}
}
void rtw_mbo_ie_handler(_adapter *padapter, struct mbo_priv *mbopriv, const u8 *pbuf, uint limit_len)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
uint total_len = 0;
u8 attribute_id = 0;
u8 attribute_len = 0;
const u8 *p = pbuf;
if(!mbopriv)
return;
rtw_mbo_ie_init(padapter, mbopriv);
_rtw_memcpy(mbopriv->mbo_oce_element + 6, pbuf, limit_len);
mbopriv->mbo_oce_element[1] = limit_len + 4;
while (total_len <= limit_len) {
attribute_id = *p;
attribute_len = *(p + 1);
total_len += attribute_len;
if(total_len > limit_len)
break;
switch (attribute_id) {
case MBO_AP_CAPABILITY:
if(attribute_len == 1){
RTW_INFO("[%s]Find attribute MBO_AP_CAPABILITY\n", __func__);
if(*(p+2) & 0x40)
mbopriv->cellular_aware = 1;
}
break;
case ASSOCIATION_DISALLOW:
if(attribute_len == 1){
RTW_INFO("[%s]Find attribute ASSOCIATION_DISALLOW\n", __func__);
mbopriv->assoc_disallow = *(p+2);
}
break;
case NON_PREFER_CHANNEL_RPT:
RTW_INFO("[%s]Find attribute NON_PREFER_CHANNEL_RPT\n", __func__);
rtw_mbo_fill_non_prefer_channel_list(padapter, mbopriv, p + 2, attribute_len);
break;
case CELLULAR_DATA_CAPABILITY:
case CELLULAR_DATA_CONNECT_PREFER:
case TRANS_REASON_CODE:
case TRANS_REJECT_REASON_CODE:
case ASSOCIATION_RETRY_DELAY:
break;
default:
RTW_ERR("[%s]Unknown MBO attribute %d\n", __func__, attribute_id);
}
p += (attribute_len + 2);
}
}
void rtw_ap_parse_sta_mbo_element(_adapter *padapter,
struct sta_info *psta, u8 *ies_buf, u16 ies_len)
{
uint ie_len = 0;
u8 *p;
u8 WIFI_ALLIANCE_OUI[] = {0x50, 0x6f, 0x9a};
ie_len = 0;
for (p = ies_buf; ; p += (ie_len + 2)) {
p = rtw_get_ie(p, _SSN_IE_1_, &ie_len, (ies_len - (ie_len + 2)));
if ((p) && (_rtw_memcmp(p + 2, WIFI_ALLIANCE_OUI, 3)) && (*(p+5) == MBO_OUI_TYPE)) {
/* find MBO-OCE information element */
psta->mbopriv.enable = _TRUE;
rtw_mbo_ie_handler(padapter, &psta->mbopriv, p + 6, ie_len - 4);
break;
}
if ((p == NULL) || (ie_len == 0))
break;
}
}
static u8 *rtw_mbo_ie_get(u8 *pie, u32 *plen, u32 limit)
{
const u8 *p = pie;
u32 tmp, i;
if (limit <= 1)
return NULL;
i = 0;
*plen = 0;
while (1) {
if ((*p == _VENDOR_SPECIFIC_IE_) &&
(_rtw_memcmp(rtw_mbo_get_oui(p), wfa_mbo_oui, 4))) {
*plen = *(p + 1);
/* RTW_MBO_DUMP("VENDOR_SPECIFIC_IE MBO: ", p, *(p + 1)); */
return (u8 *)p;
} else {
tmp = *(p + 1);
p += (tmp + 2);
i += (tmp + 2);
}
if (i >= limit)
break;
}
return NULL;
}
static u8 *rtw_mbo_attrs_get(u8 *pie,
u32 limit, u8 attr_id,u32 *attr_len, u8 dbg)
{
u8 *p = NULL;
u32 offset, plen = 0;
if ((pie == NULL) || (limit <= 1))
goto exit;
if ((p = rtw_mbo_ie_get(pie, &plen, limit)) == NULL)
goto exit;
/* shift 2 + OUI size and move to attributes content */
p = p + 2 + sizeof(wfa_mbo_oui);
plen = plen - 4;
if (dbg)
RTW_MBO_DUMP("Attributes contents: ", p, plen);
if ((p = rtw_get_ie(p, attr_id, attr_len, plen)) == NULL)
goto exit;
if (dbg) {
RTW_MBO_INFO("%s : id=%u(len=%u)\n",
__func__, attr_id, *attr_len);
RTW_MBO_DUMP("contents : ", (p + 2), *attr_len);
}
exit:
return p;
}
static u32 rtw_mbo_attr_sz_get(
_adapter *padapter, u8 id)
{
u32 len = 0;
switch (id) {
case RTW_MBO_ATTR_NPREF_CH_RPT_ID:
{
struct rf_ctl_t *prfctl = \
adapter_to_rfctl(padapter);
struct npref_ch_rtp *prpt = \
&(prfctl->ch_rtp);
struct npref_ch* pch;
u32 i, attr_len, offset;
for (i=0; i < prpt->nm_of_rpt; i++) {
pch = &prpt->ch_rpt[i];
/*attr_len = ch list + op class
+ preference + reason */
attr_len = pch->nm_of_ch + 3;
/* offset = id + len field
+ attr_len */
offset = attr_len + 2;
len += offset;
}
}
break;
case RTW_MBO_ATTR_ASSOC_RETRY_DELAY_ID:
len = 4;
break;
case RTW_MBO_ATTR_AP_CAP_ID:
case RTW_MBO_ATTR_CELL_DATA_CAP_ID:
case RTW_MBO_ATTR_ASSOC_DISABLED_ID:
case RTW_MBO_ATTR_TRANS_RES_ID:
case RTW_MBO_ATTR_TRANS_REJ_ID:
len = 3;
break;
default:
break;
}
return len;
}
static void rtw_mbo_build_mbo_ie_hdr(
u8 **pframe, struct pkt_attrib *pattrib, u8 payload_len)
{
u8 eid = RTW_MBO_EID;
u8 len = payload_len + 4;
*pframe = rtw_mbo_set_1byte_ie(*pframe, &eid, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe, &len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_4byte_ie(*pframe,
wfa_mbo_oui, &(pattrib->pktlen));
}
void rtw_mbo_build_cell_data_cap_attr(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 attr_id = RTW_MBO_ATTR_CELL_DATA_CAP_ID;
u8 attr_len = 1;
u8 cell_data_con = rtw_mbo_cell_data_conn;
/* used Cellular Data Capabilities from supplicant */
if (!rtw_mbo_wifi_logo_test(padapter) &&
pmlmepriv->pcell_data_cap_ie &&
pmlmepriv->cell_data_cap_len == 1) {
cell_data_con = *pmlmepriv->pcell_data_cap_ie;
}
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&cell_data_con, &(pattrib->pktlen));
}
static void rtw_mbo_build_ap_cap_Indication_attr(
_adapter *padapter, u8 **pframe,
struct pkt_attrib *pattrib, u8 cap_ind)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 attr_id = RTW_MBO_ATTR_AP_CAP_ID;
u8 attr_len = 1;
u8 ap_cap_ind = cap_ind;
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&ap_cap_ind, &(pattrib->pktlen));
}
static void rtw_mbo_build_ap_disallowed_attr(
_adapter *padapter, u8 **pframe,
struct pkt_attrib *pattrib, u8 code)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 attr_id = RTW_MBO_ATTR_ASSOC_DISABLED_ID;
u8 attr_len = 1;
u8 reason = 0;
if (code > 0) {
reason = code;
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&attr_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&attr_len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&reason, &(pattrib->pktlen));
}
}
static void rtw_mbo_build_ap_trans_reason_attr(
_adapter *padapter, u8 **pframe,
struct pkt_attrib *pattrib, u8 code)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 attr_id = RTW_MBO_ATTR_TRANS_RES_ID;
u8 attr_len = 1;
u8 reason = 0;
reason = code;
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&attr_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&attr_len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&reason, &(pattrib->pktlen));
}
static void rtw_mbo_build_ap_assoc_retry_delay_attr(
_adapter *padapter, u8 **pframe,
struct pkt_attrib *pattrib, u16 code)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 attr_id = RTW_MBO_ATTR_ASSOC_RETRY_DELAY_ID;
u8 attr_len = 2;
u16 delay = 0;
delay = code;
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_2byte_ie(*pframe,
(u8 *)&delay, &(pattrib->pktlen));
}
static void rtw_mbo_update_cell_data_cap(
_adapter *padapter, u8 *pie, u32 ie_len)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 *mbo_attr;
u32 mbo_attrlen;
if ((pie == NULL) || (ie_len == 0))
return;
mbo_attr = rtw_mbo_attrs_get(pie, ie_len,
RTW_MBO_ATTR_CELL_DATA_CAP_ID, &mbo_attrlen, 0);
if ((mbo_attr == NULL) || (mbo_attrlen == 0) ) {
RTW_INFO("MBO : Cellular Data Capabilities not found!\n");
return;
}
rtw_buf_update(&pmlmepriv->pcell_data_cap_ie,
&pmlmepriv->cell_data_cap_len, (mbo_attr + 2), mbo_attrlen);
RTW_MBO_DUMP("rtw_mbo_update_cell_data_cap : ",
pmlmepriv->pcell_data_cap_ie, pmlmepriv->cell_data_cap_len);
}
void rtw_mbo_update_ie_data(
_adapter *padapter, u8 *pie, u32 ie_len)
{
rtw_mbo_update_cell_data_cap(padapter, pie, ie_len);
}
static u8 rtw_mbo_current_op_class_get(_adapter *padapter)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct p2p_channels *pch_list = &(prfctl->channel_list);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct p2p_reg_class *preg_class;
int class_idx, ch_idx;
u8 cur_op_class = 0;
for(class_idx =0; class_idx < pch_list->reg_classes; class_idx++) {
preg_class = &pch_list->reg_class[class_idx];
for (ch_idx = 0; ch_idx <= preg_class->channels; ch_idx++) {
if (pmlmeext->chandef.chan == \
preg_class->channel[ch_idx]) {
cur_op_class = preg_class->reg_class;
RTW_MBO_INFO("%s : current ch : %d,"
" op class : %d\n",
__func__, pmlmeext->chandef.chan,
cur_op_class);
break;
}
}
}
return cur_op_class;
}
static void rtw_mbo_supp_op_classes_get(_adapter *padapter, u8 *pclasses)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct p2p_channels *pch_list = &(prfctl->channel_list);
int class_idx;
if (pclasses == NULL)
return;
RTW_MBO_INFO("%s : support op class \n", __func__);
for(class_idx = 0; class_idx < pch_list->reg_classes; class_idx++) {
*(pclasses + class_idx) = \
pch_list->reg_class[class_idx].reg_class;
RTW_MBO_INFO("%u ,", *(pclasses + class_idx));
}
RTW_MBO_INFO("%s : \n", __func__);
}
void rtw_mbo_build_supp_op_class_elem(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
u8 payload[32] = {0};
u8 delimiter_130 = 130; /*0x82*/
u8 reg_class_nm, len;
if ((reg_class_nm = prfctl->channel_list.reg_classes) == 0)
return;
payload[0] = rtw_mbo_current_op_class_get(padapter);
rtw_mbo_supp_op_classes_get(padapter, &payload[1]);
/* IEEE 802.11 Std Current Operating Class Extension Sequence */
payload[reg_class_nm + 1] = delimiter_130;
payload[reg_class_nm + 2] = 0x00;
RTW_MBO_DUMP("op class :", payload, reg_class_nm);
/* Current Operating Class field + Operating Class field
+ OneHundredAndThirty Delimiter field */
len = reg_class_nm + 3;
*pframe = rtw_set_ie(*pframe, EID_SupRegulatory, len ,
payload, &(pattrib->pktlen));
}
static u8 rtw_mbo_construct_npref_ch_rpt_attr(
_adapter *padapter, u8 *pbuf, u32 buf_len, u32 *plen)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct npref_ch_rtp *prpt = &(prfctl->ch_rtp);
struct npref_ch* pch;
u32 attr_len, offset;
int i;
u8 *p = pbuf;
if (prpt->nm_of_rpt == 0) {
*plen = 0;
return _FALSE;
}
for (i=0; i < prpt->nm_of_rpt; i++) {
pch = &prpt->ch_rpt[i];
/* attr_len = ch list + op class + preference + reason */
attr_len = pch->nm_of_ch + 3;
/* offset = id + len field + attr_len */
offset = attr_len + 2;
rtw_mbo_subfield_set(p, 0, RTW_MBO_ATTR_NPREF_CH_RPT_ID);
rtw_mbo_subfield_set(p, 1, attr_len);
rtw_mbo_subfield_set(p, 2, pch->op_class);
rtw_mbo_subfields_set(p, 3, pch->chs, pch->nm_of_ch);
rtw_mbo_subfield_set(p, (offset - 2), pch->preference);
rtw_mbo_subfield_set(p, (offset - 1), pch->reason);
p += offset;
*plen += offset;
if (*plen >= buf_len) {
RTW_ERR("MBO : construct non-preferred-ch rpt fail!\n");
return _FALSE;
}
}
return _TRUE;
}
void rtw_mbo_build_npref_ch_rpt_attr(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct npref_ch_rtp *prpt = &(prfctl->ch_rtp);
u32 tmp_sz = 0, body_len = 0;
u8 *ptmp;
tmp_sz = prpt->nm_of_rpt * sizeof(struct npref_ch);
ptmp = rtw_zmalloc(tmp_sz);
if (ptmp == NULL)
return;
if (rtw_mbo_construct_npref_ch_rpt_attr(
padapter, ptmp, tmp_sz, &body_len) == _FALSE) {
rtw_mfree(ptmp, tmp_sz);
return;
}
RTW_MBO_DUMP("Non-preferred Channel Report :", ptmp, body_len);
*pframe = rtw_mbo_set_nbyte_ie(*pframe, body_len,
ptmp, &(pattrib->pktlen));
rtw_mfree(ptmp, tmp_sz);
}
void rtw_mbo_build_trans_reject_reason_attr(
_adapter *padapter, u8 **pframe,
struct pkt_attrib *pattrib, u8 *pres)
{
u8 attr_id = RTW_MBO_ATTR_TRANS_REJ_ID;
u8 attr_len = 1;
u32 len = 0;
len = rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_TRANS_REJ_ID);
if ((len == 0) || (len > 3)) {
RTW_ERR("MBO : build Transition Rejection Reason"
" attribute fail(len=%u)\n", len);
return;
}
rtw_mbo_build_mbo_ie_hdr(pframe, pattrib, len);
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe, &attr_len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe, pres, &(pattrib->pktlen));
}
u8 rtw_mbo_disallowed_network(struct wlan_network *pnetwork)
{
u8 *p, *attr_id, *res;
u32 attr_len = 0;
u8 disallow = _FALSE;
if ((pnetwork == NULL) || \
((p = rtw_mbo_attrs_get(
pnetwork->network.IEs,
pnetwork->network.IELength,
RTW_MBO_ATTR_ASSOC_DISABLED_ID,
&attr_len, 0)) == NULL)) {
goto exit;
}
RTW_MBO_DUMP("Association Disallowed attribute :",p , attr_len + 2);
RTW_INFO("MBO : block "MAC_FMT" assoc disallowed reason %d\n",
MAC_ARG(pnetwork->network.MacAddress),
*(rtw_mbo_get_disallow_res(p)));
disallow = _TRUE;
exit:
return disallow;
}
void rtw_mbo_build_extended_cap(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
if (!rtw_mbo_wifi_logo_test(padapter))
return;
rtw_wnm_add_btm_ext_cap(pmlmepriv->ext_capab_ie_data,
&(pmlmepriv->ext_capab_ie_len));
rtw_mbo_add_internw_ext_cap(pmlmepriv->ext_capab_ie_data,
&(pmlmepriv->ext_capab_ie_len));
*pframe = rtw_set_ie(*pframe,
WLAN_EID_EXT_CAP,
pmlmepriv->ext_capab_ie_len,
pmlmepriv->ext_capab_ie_data,
&(pattrib->pktlen));
}
static void rtw_mbo_non_pref_chans_dump(struct npref_ch* pch)
{
int i;
u8 buf[128] = {0};
for (i=0; i < pch->nm_of_ch; i++)
rtw_sprintf(buf, 128, "%s,%d", buf, pch->chs[i]);
RTW_MBO_INFO("%s : op_class=%01x, ch=%s, preference=%d, reason=%d\n",
__func__, pch->op_class, buf, pch->preference, pch->reason);
}
static u8 rtw_mbo_non_pref_chan_exist(struct npref_ch* pch, u8 ch)
{
u32 i;
u8 found = _FALSE;
for (i=0; i < pch->nm_of_ch; i++) {
if (pch->chs[i] == ch) {
found = _TRUE;
break;
}
}
return found;
}
static struct npref_ch* rtw_mbo_non_pref_chan_get(
_adapter *padapter, u8 op_class, u8 prefe, u8 res)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct npref_ch_rtp *prpt = &(prfctl->ch_rtp);
struct npref_ch* pch = NULL;
int i;
if (prpt->nm_of_rpt == 0)
return pch;
for (i=0; i < prpt->nm_of_rpt; i++) {
if ((prpt->ch_rpt[i].op_class == op_class) &&
(prpt->ch_rpt[i].preference == prefe) &&
(prpt->ch_rpt[i].reason == res)) {
pch = &prpt->ch_rpt[i];
break;
}
}
return pch;
}
static void rtw_mbo_non_pref_chan_set(
struct npref_ch* pch, u8 op_class,
u8 ch, u8 prefe, u8 res, u8 update)
{
u32 offset = pch->nm_of_ch;
if (update) {
if (rtw_mbo_non_pref_chan_exist(pch, ch) == _FALSE) {
pch->chs[offset] = ch;
pch->nm_of_ch++;
}
} else {
pch->op_class = op_class;
pch->chs[0] = ch;
pch->preference = prefe;
pch->reason = res;
pch->nm_of_ch = 1;
}
}
static void rtw_mbo_non_pref_chans_update(
_adapter *padapter, u8 op_class, u8 ch, u8 prefe, u8 res)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct npref_ch_rtp *pch_rpt = &(prfctl->ch_rtp);
struct npref_ch* pch;
if (pch_rpt->nm_of_rpt >= RTW_MBO_MAX_CH_RPT_NUM) {
RTW_ERR("MBO : %d non_pref_chan entries supported!",
RTW_MBO_MAX_CH_RPT_NUM);
return;
}
if (pch_rpt->nm_of_rpt == 0) {
pch = &pch_rpt->ch_rpt[0];
rtw_mbo_non_pref_chan_set(pch, op_class,
ch, prefe, res, _FALSE);
pch_rpt->nm_of_rpt = 1;
return;
}
pch = rtw_mbo_non_pref_chan_get(padapter, op_class, prefe, res);
if (pch == NULL) {
pch = &pch_rpt->ch_rpt[pch_rpt->nm_of_rpt];
rtw_mbo_non_pref_chan_set(pch, op_class,
ch, prefe, res, _FALSE);
pch_rpt->nm_of_rpt++;
} else {
rtw_mbo_non_pref_chan_set(pch, op_class,
ch, prefe, res, _TRUE);
}
rtw_mbo_non_pref_chans_dump(pch);
}
static void rtw_mbo_non_pref_chans_set(
_adapter *padapter, char *param, ssize_t sz)
{
char *pnext;
u32 op_class, ch, prefe, res;
int i = 0;
do {
pnext = strsep(¶m, " ");
if (pnext == NULL)
break;
sscanf(pnext, "%d:%d:%d:%d", &op_class, &ch, &prefe, &res);
rtw_mbo_non_pref_chans_update(padapter, op_class,
ch, prefe, res);
if ((i++) > 10) {
RTW_ERR("MBO : overflow %d \n", i);
break;
}
} while (param != (char*)'\0');
}
static void rtw_mbo_non_pref_chans_del(
_adapter *padapter, char *param, ssize_t sz)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct npref_ch_rtp *prpt = &(prfctl->ch_rtp);
RTW_INFO("%s : delete non_pref_chan %s\n", __func__, param);
_rtw_memset(prpt, 0, sizeof(struct npref_ch_rtp));
}
ssize_t rtw_mbo_proc_non_pref_chans_set(
struct file *pfile, const char __user *buffer,
size_t count, loff_t *pos, void *pdata)
{
struct net_device *dev = pdata;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
u8 tmp[128] = {0};
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp)) {
rtw_warn_on(1);
return -EFAULT;
}
if (buffer && !copy_from_user(tmp, buffer, count)) {
if (strncmp(tmp, "add", 3) == 0) {
rtw_mbo_non_pref_chans_set(padapter,
&tmp[4], (count - 4));
} else if (strncmp(tmp, "delete", 6) == 0) {
rtw_mbo_non_pref_chans_del(padapter,
&tmp[7], (count - 7));
} else {
RTW_ERR("MBO : Invalid format : echo [add|delete]"
" <oper_class>:<chan>:<preference>:<reason>\n");
return -EFAULT;
}
}
#ifdef CONFIG_RTW_WNM
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) &&
check_fwstate(pmlmepriv, WIFI_STATION_STATE))
rtw_wnm_issue_action(padapter,
RTW_WLAN_ACTION_WNM_NOTIF_REQ, 0, 0);
#endif
return count;
}
int rtw_mbo_proc_non_pref_chans_get(
struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct npref_ch_rtp *prpt = &(prfctl->ch_rtp);
struct npref_ch* pch;
int i,j;
u8 buf[32] = {0};
RTW_PRINT_SEL(m, "op_class ch preference reason \n");
RTW_PRINT_SEL(m, "=======================================================\n");
if (prpt->nm_of_rpt == 0) {
RTW_PRINT_SEL(m, " empty table \n");
return 0;
}
for (i=0; i < prpt->nm_of_rpt; i++) {
pch = &prpt->ch_rpt[i];
buf[0]='\0';
for (j=0; j < pch->nm_of_ch; j++) {
if (j == 0)
rtw_sprintf(buf, 32, "%02u", pch->chs[j]);
else
rtw_sprintf(buf, 32, "%s,%02u", buf, pch->chs[j]);
}
RTW_PRINT_SEL(m, " %04u %20s %02u %02u\n",
pch->op_class, buf, pch->preference, pch->reason);
}
return 0;
}
ssize_t rtw_mbo_proc_cell_data_set(
struct file *pfile, const char __user *buffer,
size_t count, loff_t *pos, void *pdata)
{
struct net_device *dev = pdata;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int mbo_cell_data = 0;
u8 tmp[8] = {0};
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp))
return -EFAULT;
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d", &mbo_cell_data);
if (num == 1) {
rtw_mbo_cell_data_conn = mbo_cell_data;
#ifdef CONFIG_RTW_WNM
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) &&
check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
rtw_wnm_issue_action(padapter,
RTW_WLAN_ACTION_WNM_NOTIF_REQ, 0, 0);
}
#endif
}
}
return count;
}
int rtw_mbo_proc_cell_data_get(
struct seq_file *m, void *v)
{
#if 0
struct net_device *dev = m->private;
_adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
#endif
RTW_PRINT_SEL(m, "Cellular Data Connectivity : %d\n",
rtw_mbo_cell_data_conn);
return 0;
}
static void rtw_mbo_disassoc(_adapter *padapter, u8 *da,
u8 reason, u8 wait_ack)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct rtw_ieee80211_hdr *pwlanhdr;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 *pframe;
u16 *fctrl;
int ret = _FAIL;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->retry_ctrl = _FALSE;
pattrib->key_type = IEEE80211W_RIGHT_KEY;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3,
get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_DISASSOC);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
reason = cpu_to_le16(reason);
pframe = rtw_set_fixed_ie(pframe, _RSON_CODE_ ,
(unsigned char *)&reason, &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else
dump_mgntframe(padapter, pmgntframe);
RTW_MBO_INFO("%s : reason %u\n", __func__, reason);
}
static void rtw_mbo_construct_user_btm_req(
_adapter *padapter, struct btm_req_hdr *phdr,
u8 *purl, u32 url_len, struct wnm_btm_cant *pbtm_cant)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
struct mbo_user_btm_req_pkt *puser = &(pmbo_attr->user_raw);
struct wnm_btm_cant *puser_cant = NULL;
if (phdr) {
puser->hdr.req_mode = phdr->req_mode;
puser->hdr.disassoc_timer = phdr->disassoc_timer;
puser->hdr.validity_interval = phdr->validity_interval;
puser->hdr.term_duration.tsf = phdr->term_duration.tsf;
puser->hdr.term_duration.duration = \
phdr->term_duration.duration;
puser->hdr.term_duration.id = 0x4;
puser->hdr.term_duration.len = 0xa;
RTW_MBO_INFO("%s : req-mode=0x%x, disassoc_timer=%u, "
"validity_interval=%u, tsf=%llu, "
"duration=%u\n", __func__,
puser->hdr.req_mode, puser->hdr.disassoc_timer,
puser->hdr.validity_interval,
puser->hdr.term_duration.tsf,
puser->hdr.term_duration.duration);
}
if (purl && url_len) {
/* TODO */
}
if (pbtm_cant) {
struct wnm_btm_cant *pbtm_tb = NULL;
u8 i, idx, found = _FALSE;
for (i = 0; i < RTW_MAX_NB_RPT_NUM; i++) {
puser_cant = &puser->btm_cants[i];
if (_rtw_memcmp(pbtm_cant->nb_rpt.bssid,
puser_cant->nb_rpt.bssid, ETH_ALEN)) {
puser_cant->nb_rpt.bss_info = \
pbtm_cant->nb_rpt.bss_info;
puser_cant->nb_rpt.reg_class = \
pbtm_cant->nb_rpt.reg_class;
puser_cant->nb_rpt.ch_num = \
pbtm_cant->nb_rpt.ch_num;
puser_cant->nb_rpt.phy_type = \
pbtm_cant->nb_rpt.phy_type;
puser_cant->preference = \
pbtm_cant->preference;
idx = i;
found = _TRUE;
break;
}
}
if (!found) {
if (puser->candidate_cnt >= RTW_MAX_NB_RPT_NUM)
puser->candidate_cnt = 0;
puser_cant = &puser->btm_cants[puser->candidate_cnt];
puser_cant->nb_rpt.id = \
RTW_WLAN_ACTION_WNM_NB_RPT_ELEM;
puser_cant->nb_rpt.len = 0x10;
_rtw_memcpy(puser_cant->nb_rpt.bssid,
pbtm_cant->nb_rpt.bssid, ETH_ALEN);
puser_cant->nb_rpt.bss_info = \
pbtm_cant->nb_rpt.bss_info;
puser_cant->nb_rpt.reg_class = \
pbtm_cant->nb_rpt.reg_class;
puser_cant->nb_rpt.ch_num = \
pbtm_cant->nb_rpt.ch_num;
puser_cant->nb_rpt.phy_type = \
pbtm_cant->nb_rpt.phy_type;
puser_cant->preference = \
pbtm_cant->preference;
idx = puser->candidate_cnt;
puser->candidate_cnt++;
}
RTW_MBO_INFO("%s:%s idx=%u, bssid("MAC_FMT"),"
" bss_info(0x%04X), reg_class(0x%02X),"
" ch(%d), phy_type(0x%02X), preference(0x%02X)\n",
__func__, (found)?"update":"new", idx,
MAC_ARG(puser_cant->nb_rpt.bssid),
puser_cant->nb_rpt.bss_info,
puser_cant->nb_rpt.reg_class,
puser_cant->nb_rpt.ch_num,
puser_cant->nb_rpt.phy_type,
puser_cant->preference);
} /* end of if (pbtm_cant) */
}
static void rtw_mbo_reset_user_btm_req_preference(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
struct mbo_user_btm_req_pkt *puser = &(pmbo_attr->user_raw);
struct wnm_btm_cant *puser_cant = NULL;
u8 i;
for (i = 0; i < RTW_MAX_NB_RPT_NUM; i++) {
puser_cant = &puser->btm_cants[i];
if (_rtw_memcmp(adapter_mac_addr(padapter),
puser_cant->nb_rpt.bssid, ETH_ALEN)) {
puser_cant->preference = 0;
RTW_MBO_INFO("%s : reset "MAC_FMT" BTM preference\n",
__func__, MAC_ARG(puser_cant->nb_rpt.bssid));
break;
}
}
}
ssize_t rtw_mbo_proc_attr_set(
struct file *pfile, const char __user *buffer,
size_t count, loff_t *pos, void *pdata)
{
struct net_device *dev = pdata;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
struct mbo_user_btm_req_pkt *puser = &(pmbo_attr->user_raw);
u32 id, val;
u8 tmp[64] = {0};
if (count < 1)
return -EFAULT;
if (count > sizeof(tmp))
return -EFAULT;
if (buffer && !copy_from_user(tmp, buffer, count)) {
int num = sscanf(tmp, "%d %d", &id, &val);
switch (id) {
case RTW_MBO_ATTR_AP_CAP_ID:
pmbo_attr->ap_cap_ind = val;
break;
case RTW_MBO_ATTR_CELL_DATA_CAP_ID:
pmbo_attr->cell_data_cap = val;
break;
case RTW_MBO_ATTR_ASSOC_DISABLED_ID:
pmbo_attr->assoc_disallow = val;
break;
case RTW_MBO_ATTR_TRANS_RES_ID:
pmbo_attr->reason = val;
break;
case RTW_MBO_ATTR_ASSOC_RETRY_DELAY_ID:
pmbo_attr->delay = val;
break;
case RTW_MBO_TEST_CMD_REST:
RTW_INFO("%s : RTW_MBO_TEST_CMD_REST\n",
__func__);
_rtw_memset(pmbo_attr, 0,
sizeof(struct mbo_attr_info));
pmbo_attr->mbo_spec_test = 1;
break;
case RTW_MBO_TEST_CMD_BTM_REQ_SET:
if (count >= 10) {
struct btm_req_hdr btm_hdr;
u32 disassoc_imnt, term_bit;
u32 term_tsf, term_duration;
_rtw_memset(&btm_hdr, 0,
sizeof(btm_hdr));
num = sscanf(tmp, "%d %u %u %u %u",
&id, &disassoc_imnt,
&term_bit, &term_tsf,
&term_duration);
if (num < 5)
break;
if (disassoc_imnt > 0)
btm_hdr.req_mode |= \
DISASSOC_IMMINENT;
if (term_bit > 0)
btm_hdr.req_mode |= \
BSS_TERMINATION_INCLUDED;
btm_hdr.term_duration.tsf = term_tsf;
btm_hdr.term_duration.duration = \
term_duration;
rtw_mbo_construct_user_btm_req(
padapter, &btm_hdr, NULL, 0,
NULL);
}
break;
case RTW_MBO_TEST_CMD_BTM_REQ_SEND:
if (count >= 12) {
u8 mac_str[18] = {0};
u8 dst_mac[ETH_ALEN] = {0};
u32 cand_list = 0, disassoc_timer = 0;
num = sscanf(tmp, "%d %s %u %u",
&id, mac_str, &cand_list,
&disassoc_timer);
if (num < 4)
break;
if (sscanf(mac_str, MAC_SFMT,
MAC_SARG(
dst_mac)) != 6) {
break;
}
puser->append_mbo_ie = _TRUE;
puser->hdr.dialog_token++;
puser->hdr.validity_interval = 0xf;
if (cand_list > 0)
puser->hdr.req_mode |= \
PREFERRED_CANDIDATE_LIST_INCLUDED;
puser->hdr.disassoc_timer = \
disassoc_timer;
if ((puser->hdr.req_mode & \
DISASSOC_IMMINENT) == \
DISASSOC_IMMINENT) {
rtw_mbo_reset_user_btm_req_preference(padapter);
if (pmbo_attr->delay == 0)
pmbo_attr->delay = 1;
if (puser->hdr.disassoc_timer == 0)
puser->hdr.disassoc_timer = 1000;
}
if ((puser->hdr.req_mode & \
BSS_TERMINATION_INCLUDED) == \
BSS_TERMINATION_INCLUDED) {
puser->append_mbo_ie = _FALSE;
}
if (!puser->candidate_cnt) {
struct wnm_btm_cant cant;
_rtw_memset(&cant, 0,
sizeof(cant));
_rtw_memcpy(cant.nb_rpt.bssid,
adapter_mac_addr(padapter),
ETH_ALEN);
cant.nb_rpt.reg_class = 115;
cant.nb_rpt.ch_num = 36;
cant.preference = 0;
rtw_mbo_construct_user_btm_req(
padapter, NULL,
NULL, 0, &cant);
}
rtw_wnm_issue_btm_req(padapter, dst_mac,
&puser->hdr, NULL, 0,
(u8 *)&puser->btm_cants,
puser->candidate_cnt);
if ((puser->hdr.term_duration.duration)
&& (puser->hdr.req_mode & \
BSS_TERMINATION_INCLUDED) == \
BSS_TERMINATION_INCLUDED) {
rtw_mbo_disassoc(padapter,
dst_mac, 3, _TRUE);
}
if ((puser->hdr.req_mode & \
DISASSOC_IMMINENT) == \
DISASSOC_IMMINENT) {
rtw_mbo_disassoc(padapter,
dst_mac, 3, _TRUE);
}
} /* end of if (count >= 12) */
break;
case RTW_MBO_TEST_CMD_NB_BSS_ADD:
if (count >= 12) {
u8 bss_str[18];
struct wnm_btm_cant cant;
u32 op, op_ch, perf;
num = sscanf(tmp, "%d %s %u %u %u",
&id, bss_str, &op, &op_ch,
&perf);
if (num < 5)
break;
_rtw_memset(&cant, 0, sizeof(cant));
if (sscanf(bss_str, MAC_SFMT,
MAC_SARG(
cant.nb_rpt.bssid)) != 6) {
break;
}
cant.nb_rpt.reg_class = op;
cant.nb_rpt.ch_num = op_ch;
cant.preference = perf;
rtw_mbo_construct_user_btm_req(
padapter, NULL, NULL, 0,
&cant);
} /* end of if (count >= 12) */
break;
default:
break;
}
}
return count;
}
int rtw_mbo_proc_attr_get(
struct seq_file *m, void *v)
{
struct net_device *dev = m->private;
_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
RTW_PRINT_SEL(m, "AP Capability Indication : %d\n",
pmbo_attr->ap_cap_ind);
RTW_PRINT_SEL(m, "Cellular Data Capabilities : %d\n",
pmbo_attr->cell_data_cap);
RTW_PRINT_SEL(m, "Association Disallowed : %d\n",
pmbo_attr->assoc_disallow);
return 0;
}
static void rtw_mbo_non_pref_chan_subelem_parsing(
_adapter *padapter, u8 *subelem, size_t subelem_len)
{
u8 *pnon_pref_chans;
u32 non_pref_chan_offset, op_subelem_len;
u32 oui_offset = 3;
/* wpa_supplicant don't apped OUI Type */
u32 oui_type_offset = 0;
RTW_MBO_DUMP("Non-preferred Channel subelem : ",
subelem , subelem_len);
/* Subelem :
Vendor Specific | Length | WFA OUI | OUI Type | MBO Attributes */
non_pref_chan_offset = 2 + oui_offset + oui_type_offset;
pnon_pref_chans = subelem + non_pref_chan_offset;
op_subelem_len = subelem_len - non_pref_chan_offset;
/* wpa_supplicant don't indicate non_pref_chan length,
so we cannot get how many non_pref_chan in a wnm notification */
RTW_MBO_DUMP("Non-preferred Channel : ",
pnon_pref_chans, op_subelem_len);
}
void rtw_mbo_wnm_notification_parsing(
_adapter *padapter, const u8 *pdata, size_t data_len)
{
u8 *paction;
u8 category, action, dialog, type;
u32 len;
if ((pdata == NULL) || (data_len == 0))
return;
RTW_MBO_DUMP("WNM notification data : ", pdata, data_len);
paction = (u8 *)pdata + sizeof(struct rtw_ieee80211_hdr_3addr);
category = paction[0];
action = paction[1];
dialog = paction[2];
type = paction[3];
if ((action == RTW_WLAN_ACTION_WNM_NOTIF_REQ) &&
(type == WLAN_EID_VENDOR_SPECIFIC)) {
rtw_mbo_non_pref_chan_subelem_parsing(padapter, &paction[4],
(data_len - sizeof(struct rtw_ieee80211_hdr_3addr)));
}
}
void rtw_mbo_build_wnm_notification(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
struct rf_ctl_t *prfctl = adapter_to_rfctl(padapter);
struct npref_ch_rtp *prpt = &(prfctl->ch_rtp);
struct npref_ch* pch;
u8 subelem_id = WLAN_EID_VENDOR_SPECIFIC;
u8 non_pref_ch_oui[] = {0x50, 0x6F, 0x9A, 0x2};
u8 cell_data_cap_oui[] = {0x50, 0x6F, 0x9A, 0x3};
u8 cell_data_con = rtw_mbo_cell_data_conn;
u8 len, cell_data_con_len = 0, *pcont = *pframe;
int i;
if (rtw_mbo_cell_data_conn > 0) {
len = 0x5;
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&subelem_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_4byte_ie(*pframe,
cell_data_cap_oui, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&cell_data_con, &(pattrib->pktlen));
RTW_MBO_INFO("%s : Cellular Data Capabilities subelemen\n",
__func__);
RTW_MBO_DUMP(":", pcont, len + 2);
pcont += len + 2 ;
}
if (prpt->nm_of_rpt == 0) {
len = 0x4;
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&subelem_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_4byte_ie(*pframe,
non_pref_ch_oui, &(pattrib->pktlen));
RTW_MBO_INFO("%s :Non-preferred Channel Report subelement"
" without data\n", __func__);
return;
}
for (i=0; i < prpt->nm_of_rpt; i++) {
pch = &prpt->ch_rpt[i];
/* OUI(3B) + OUT-type(1B) + op-class(1B) + ch list(nB)
+ Preference(1B) + reason(1B) */
len = pch->nm_of_ch + 7;
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&subelem_id, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&len, &(pattrib->pktlen));
*pframe = rtw_mbo_set_4byte_ie(*pframe,
non_pref_ch_oui, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&pch->op_class, &(pattrib->pktlen));
*pframe = rtw_mbo_set_nbyte_ie(*pframe,
pch->nm_of_ch, pch->chs, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&pch->preference, &(pattrib->pktlen));
*pframe = rtw_mbo_set_1byte_ie(*pframe,
&pch->reason, &(pattrib->pktlen));
RTW_MBO_INFO("%s :Non-preferred Channel Report"
" subelement\n", __func__);
RTW_MBO_DUMP(":", pcont, len);
pcont = *pframe;
}
}
void rtw_mbo_build_probe_req_ies(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
u32 len =0;
rtw_mbo_build_extended_cap(padapter, pframe, pattrib);
len = rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_CELL_DATA_CAP_ID);
if ((len == 0) || (len > 3)) {
RTW_ERR("MBO : build Cellular Data Capabilities"
" attribute fail(len=%u)\n", len);
return;
}
rtw_mbo_build_mbo_ie_hdr(pframe, pattrib, len);
rtw_mbo_build_cell_data_cap_attr(padapter, pframe, pattrib);
}
void rtw_mbo_build_assoc_req_ies(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
u32 len = 0;
rtw_mbo_build_supp_op_class_elem(padapter, pframe, pattrib);
len += rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_CELL_DATA_CAP_ID);
len += rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_NPREF_CH_RPT_ID);
if ((len == 0)|| (len < 3)) {
RTW_ERR("MBO : build assoc MBO IE fail(len=%u)\n", len);
return;
}
rtw_mbo_build_mbo_ie_hdr(pframe, pattrib, len);
rtw_mbo_build_cell_data_cap_attr(padapter, pframe, pattrib);
rtw_mbo_build_npref_ch_rpt_attr(padapter, pframe, pattrib);
}
static void rtw_mbo_build_ap_capability(
_adapter *padapter, u8 **pframe,
struct pkt_attrib *pattrib)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
u8 *pcap = NULL;
u32 cap_len = 0, flen = 0;
if ((pcap = rtw_mbo_attrs_get(
(cur_network->IEs + _FIXED_IE_LENGTH_),
(cur_network->IELength - _FIXED_IE_LENGTH_),
RTW_MBO_ATTR_AP_CAP_ID, &cap_len, 0)) != NULL)
return;
flen += rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_AP_CAP_ID);
if (pmbo_attr->assoc_disallow > 0)
flen += rtw_mbo_attr_sz_get(padapter,
RTW_MBO_ATTR_ASSOC_DISABLED_ID);
if (flen > 0) {
rtw_mbo_build_mbo_ie_hdr(pframe, pattrib, flen);
rtw_mbo_build_ap_cap_Indication_attr(padapter, pframe,
pattrib, pmbo_attr->ap_cap_ind);
if (pmbo_attr->assoc_disallow > 0) {
rtw_mbo_build_ap_disallowed_attr(padapter, pframe,
pattrib, pmbo_attr->assoc_disallow);
}
} /* end of if (flen > 0) */
}
void rtw_mbo_attr_info_init(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
_rtw_memset(pmbo_attr, 0, sizeof(struct mbo_attr_info));
}
void rtw_mbo_process_assoc_req(
_adapter *padapter, u8 *pie, int ie_len)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
u8 non_pref_ch = 0, ch_op_pref = 1;
u8 *pattr = NULL, *ptr = NULL;
u32 attr_len = 0, ch_nums = 0;
int i, j;
if (!pie || !ie_len)
return;
if ((pattr = rtw_mbo_attrs_get(pie, ie_len,
RTW_MBO_ATTR_NPREF_CH_RPT_ID, &attr_len, 1)) == NULL)
return;
if (attr_len < 3)
return;
ch_nums = (attr_len - 3);
/* shfit to non-preferred ch rpt field */
ptr = pattr + 3;
RTW_MBO_DUMP("non-preferred ch rpt :", ptr, ch_nums);
ch_op_pref = *(ptr + ch_nums);
RTW_MBO_INFO("%s : ch_op_pref=0x%02x\n", __func__, ch_op_pref);
if (ch_op_pref >= 2) {
RTW_MBO_INFO("%s : unknow ch operating preference(0x%02x)\n",
__func__, ch_op_pref);
return;
}
for (i = 0; i < ch_nums; i++) {
if (i >= RTW_MBO_MAX_CH_LIST_NUM)
break;
non_pref_ch = *(ptr + i);
RTW_MBO_INFO("%s : non-pref ch %u found in assoc-req\n",
__func__, non_pref_ch);
if (rtw_mbo_wifi_spec_test(padapter)) {
struct mbo_user_btm_req_pkt *puser_raw = \
&(pmbo_attr->user_raw);
struct wnm_btm_cant *pcant = NULL;
for (j = 0; j < RTW_MAX_NB_RPT_NUM; j++) {
pcant = &puser_raw->btm_cants[j];
if ((pcant->nb_rpt.ch_num == non_pref_ch) && \
(ch_op_pref == 0)) {
RTW_MBO_INFO("%s : reset "
"preference(%u) for non-preference ch\n",
__func__, pcant->preference);
pcant->preference = 0;
}
}
}
} /* end of for-loop ch_nums */
}
void rtw_mbo_build_beacon_ies(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
rtw_mbo_build_ap_capability(padapter, pframe, pattrib);
}
void rtw_mbo_build_probe_rsp_ies(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
rtw_mbo_build_ap_capability(padapter, pframe, pattrib);
}
void rtw_mbo_build_assoc_rsp_ies(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
u8 *pcap = NULL;
u32 len = 0, cap_len = 0 ;
/* driver would't reload all assoc-rsp ie from hostapd */
#if 0
if ((pcap = rtw_mbo_attrs_get(
(cur_network->IEs + _FIXED_IE_LENGTH_),
(cur_network->IELength - _FIXED_IE_LENGTH_),
RTW_MBO_ATTR_AP_CAP_ID, &cap_len, 0)) != NULL)
return;
#endif
len += rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_AP_CAP_ID);
if (pmbo_attr->assoc_disallow > 0)
len += rtw_mbo_attr_sz_get(padapter,
RTW_MBO_ATTR_ASSOC_DISABLED_ID);
if (len > 0) {
rtw_mbo_build_mbo_ie_hdr(pframe, pattrib, len);
rtw_mbo_build_ap_cap_Indication_attr(
padapter, pframe, pattrib, pmbo_attr->ap_cap_ind);
if (pmbo_attr->assoc_disallow > 0) {
rtw_mbo_build_ap_disallowed_attr(padapter, pframe,
pattrib, pmbo_attr->assoc_disallow);
}
}
}
void rtw_mbo_build_wnm_btmreq_reason_ies(
_adapter *padapter, u8 **pframe, struct pkt_attrib *pattrib)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
struct mbo_user_btm_req_pkt *puser = &(pmbo_attr->user_raw);
u8 *pcap = NULL;
u32 len = 0, cap_len = 0 ;
if (!puser->append_mbo_ie)
return;
len += rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_AP_CAP_ID);
len += rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_TRANS_RES_ID);
len += rtw_mbo_attr_sz_get(padapter, RTW_MBO_ATTR_ASSOC_RETRY_DELAY_ID);
rtw_mbo_build_mbo_ie_hdr(pframe, pattrib, len);
rtw_mbo_build_ap_cap_Indication_attr(
padapter, pframe, pattrib, pmbo_attr->ap_cap_ind);
rtw_mbo_build_ap_trans_reason_attr(padapter, pframe,
pattrib, pmbo_attr->reason);
rtw_mbo_build_ap_assoc_retry_delay_attr(padapter, pframe,
pattrib, pmbo_attr->delay);
}
#endif /* CONFIG_RTW_MBO */
|
2301_81045437/rtl8852be
|
core/rtw_mbo.c
|
C
|
agpl-3.0
| 44,349
|
/******************************************************************************
*
* Copyright(c) 2016 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#include <rtw_mem.h>
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
MODULE_AUTHOR("Realtek Semiconductor Corp.");
MODULE_VERSION("DRIVERVERSION");
struct sk_buff_head rtk_skb_mem_q;
struct u8 *rtk_buf_mem[NR_RECVBUFF];
struct u8 *rtw_get_buf_premem(int index)
{
printk("%s, rtk_buf_mem index : %d\n", __func__, index);
return rtk_buf_mem[index];
}
u16 rtw_rtkm_get_buff_size(void)
{
return MAX_RTKM_RECVBUF_SZ;
}
EXPORT_SYMBOL(rtw_rtkm_get_buff_size);
u8 rtw_rtkm_get_nr_recv_skb(void)
{
return MAX_RTKM_NR_PREALLOC_RECV_SKB;
}
EXPORT_SYMBOL(rtw_rtkm_get_nr_recv_skb);
struct sk_buff *rtw_alloc_skb_premem(u16 in_size)
{
struct sk_buff *skb = NULL;
if (in_size > MAX_RTKM_RECVBUF_SZ) {
pr_info("warning %s: driver buffer size(%d) > rtkm buffer size(%d)\n", __func__, in_size, MAX_RTKM_RECVBUF_SZ);
WARN_ON(1);
return skb;
}
skb = skb_dequeue(&rtk_skb_mem_q);
printk("%s, rtk_skb_mem_q len : %d\n", __func__, skb_queue_len(&rtk_skb_mem_q));
return skb;
}
EXPORT_SYMBOL(rtw_alloc_skb_premem);
int rtw_free_skb_premem(struct sk_buff *pskb)
{
if (!pskb)
return -1;
if (skb_queue_len(&rtk_skb_mem_q) >= MAX_RTKM_NR_PREALLOC_RECV_SKB)
return -1;
skb_queue_tail(&rtk_skb_mem_q, pskb);
printk("%s, rtk_skb_mem_q len : %d\n", __func__, skb_queue_len(&rtk_skb_mem_q));
return 0;
}
EXPORT_SYMBOL(rtw_free_skb_premem);
static int __init rtw_mem_init(void)
{
int i;
SIZE_PTR tmpaddr = 0;
SIZE_PTR alignment = 0;
struct sk_buff *pskb = NULL;
printk("%s\n", __func__);
pr_info("MAX_RTKM_NR_PREALLOC_RECV_SKB: %d\n", MAX_RTKM_NR_PREALLOC_RECV_SKB);
pr_info("MAX_RTKM_RECVBUF_SZ: %d\n", MAX_RTKM_RECVBUF_SZ);
#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
for (i = 0; i < NR_RECVBUFF; i++)
rtk_buf_mem[i] = usb_buffer_alloc(dev, size, (in_interrupt() ? GFP_ATOMIC : GFP_KERNEL), dma);
#endif /* CONFIG_USE_USB_BUFFER_ALLOC_RX */
skb_queue_head_init(&rtk_skb_mem_q);
for (i = 0; i < MAX_RTKM_NR_PREALLOC_RECV_SKB; i++) {
pskb = __dev_alloc_skb(MAX_RTKM_RECVBUF_SZ + RECVBUFF_ALIGN_SZ, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
if (pskb) {
tmpaddr = (SIZE_PTR)pskb->data;
alignment = tmpaddr & (RECVBUFF_ALIGN_SZ - 1);
skb_reserve(pskb, (RECVBUFF_ALIGN_SZ - alignment));
skb_queue_tail(&rtk_skb_mem_q, pskb);
} else
printk("%s, alloc skb memory fail!\n", __func__);
pskb = NULL;
}
printk("%s, rtk_skb_mem_q len : %d\n", __func__, skb_queue_len(&rtk_skb_mem_q));
return 0;
}
static void __exit rtw_mem_exit(void)
{
if (skb_queue_len(&rtk_skb_mem_q))
printk("%s, rtk_skb_mem_q len : %d\n", __func__, skb_queue_len(&rtk_skb_mem_q));
skb_queue_purge(&rtk_skb_mem_q);
printk("%s\n", __func__);
}
module_init(rtw_mem_init);
module_exit(rtw_mem_exit);
|
2301_81045437/rtl8852be
|
core/rtw_mem.c
|
C
|
agpl-3.0
| 3,422
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_MI_C_
#include <drv_types.h>
void rtw_mi_update_union_chan_inf(_adapter *adapter, u8 ch, u8 offset , u8 bw)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct mi_state *iface_state = &dvobj->iface_state;
iface_state->union_ch = ch;
iface_state->union_bw = bw;
iface_state->union_offset = offset;
}
u8 rtw_mi_stayin_union_ch_chk(_adapter *adapter)
{
u8 rst = _TRUE;
u8 u_ch, u_bw, u_offset;
u8 o_ch, o_bw, o_offset;
u_ch = rtw_mi_get_union_chan(adapter);
u_bw = rtw_mi_get_union_bw(adapter);
u_offset = rtw_mi_get_union_offset(adapter);
o_ch = rtw_get_oper_ch(adapter);
o_bw = rtw_get_oper_bw(adapter);
o_offset = rtw_get_oper_choffset(adapter);
if ((u_ch != o_ch) || (u_bw != o_bw) || (u_offset != o_offset))
rst = _FALSE;
#ifdef DBG_IFACE_STATUS
if (rst == _FALSE) {
RTW_ERR("%s Not stay in union channel\n", __func__);
if (GET_PHL_COM(adapter_to_dvobj(adapter))->bScanInProcess == _TRUE)
RTW_ERR("ScanInProcess\n");
#ifdef CONFIG_IOCTL_CFG80211
if (rtw_cfg80211_get_is_roch(adapter))
RTW_ERR("Doing remain on channel\n");
#endif
RTW_ERR("union ch, bw, offset: %u,%u,%u\n", u_ch, u_bw, u_offset);
RTW_ERR("oper ch, bw, offset: %u,%u,%u\n", o_ch, o_bw, o_offset);
RTW_ERR("=========================\n");
}
#endif
return rst;
}
u8 rtw_mi_stayin_union_band_chk(_adapter *adapter)
{
u8 rst = _TRUE;
u8 u_ch, o_ch;
u8 u_band, o_band;
u_ch = rtw_mi_get_union_chan(adapter);
o_ch = rtw_get_oper_ch(adapter);
u_band = (u_ch > 14) ? BAND_ON_5G : BAND_ON_24G;
o_band = (o_ch > 14) ? BAND_ON_5G : BAND_ON_24G;
if (u_ch != o_ch)
if(u_band != o_band)
rst = _FALSE;
#ifdef DBG_IFACE_STATUS
if (rst == _FALSE)
RTW_ERR("%s Not stay in union band\n", __func__);
#endif
return rst;
}
/* Find union about ch, bw, ch_offset of all linked/linking interfaces */
int rtw_mi_get_ch_setting_union_by_ifbmp(struct dvobj_priv *dvobj, u8 ifbmp, u8 *ch, u8 *bw, u8 *offset)
{
_adapter *iface;
struct mlme_ext_priv *mlmeext;
int i;
u8 ch_ret = 0;
u8 bw_ret = CHANNEL_WIDTH_20;
u8 offset_ret = CHAN_OFFSET_NO_EXT;
int num = 0;
if (ch)
*ch = 0;
if (bw)
*bw = CHANNEL_WIDTH_20;
if (offset)
*offset = CHAN_OFFSET_NO_EXT;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface || !(ifbmp & BIT(iface->iface_id)))
continue;
mlmeext = &iface->mlmeextpriv;
if (!check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE | WIFI_UNDER_LINKING))
continue;
if (check_fwstate(&iface->mlmepriv, WIFI_OP_CH_SWITCHING))
continue;
if (num == 0) {
ch_ret = mlmeext->chandef.chan;
bw_ret = mlmeext->chandef.bw;
offset_ret = mlmeext->chandef.offset;
num++;
continue;
}
if (ch_ret != mlmeext->chandef.chan) {
num = 0;
break;
}
if (bw_ret < mlmeext->chandef.bw) {
bw_ret = mlmeext->chandef.bw;
offset_ret = mlmeext->chandef.offset;
} else if (bw_ret == mlmeext->chandef.bw && offset_ret != mlmeext->chandef.offset) {
num = 0;
break;
}
num++;
}
if (num) {
if (ch)
*ch = ch_ret;
if (bw)
*bw = bw_ret;
if (offset)
*offset = offset_ret;
}
return num;
}
inline int rtw_mi_get_ch_setting_union(_adapter *adapter, u8 *ch, u8 *bw, u8 *offset)
{
return rtw_mi_get_ch_setting_union_by_ifbmp(adapter_to_dvobj(adapter), 0xFF, ch, bw, offset);
}
inline int rtw_mi_get_ch_setting_union_no_self(_adapter *adapter, u8 *ch, u8 *bw, u8 *offset)
{
return rtw_mi_get_ch_setting_union_by_ifbmp(adapter_to_dvobj(adapter), 0xFF & ~BIT(adapter->iface_id), ch, bw, offset);
}
/* For now, not return union_ch/bw/offset */
void rtw_mi_status_by_ifbmp(struct dvobj_priv *dvobj, u8 ifbmp, struct mi_state *mstate)
{
_adapter *iface;
int i;
_rtw_memset(mstate, 0, sizeof(struct mi_state));
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface || !(ifbmp & BIT(iface->iface_id)))
continue;
if (MLME_IS_STA(iface)) {
MSTATE_STA_NUM(mstate)++;
if (check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE) {
MSTATE_STA_LD_NUM(mstate)++;
#ifdef CONFIG_TDLS
if (iface->tdlsinfo.link_established == _TRUE)
MSTATE_TDLS_LD_NUM(mstate)++;
#endif
#ifdef CONFIG_P2P
if (MLME_IS_GC(iface))
MSTATE_P2P_GC_NUM(mstate)++;
#endif
}
if (check_fwstate(&iface->mlmepriv, WIFI_UNDER_LINKING) == _TRUE)
MSTATE_STA_LG_NUM(mstate)++;
#ifdef CONFIG_AP_MODE
} else if (check_fwstate(&iface->mlmepriv, WIFI_AP_STATE) == _TRUE ) {
if (check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE) {
MSTATE_AP_NUM(mstate)++;
if (iface->stapriv.asoc_sta_count > 2)
MSTATE_AP_LD_NUM(mstate)++;
#ifdef CONFIG_P2P
if (MLME_IS_GO(iface))
MSTATE_P2P_GO_NUM(mstate)++;
#endif
} else
MSTATE_AP_STARTING_NUM(mstate)++;
#endif
} else if (check_fwstate(&iface->mlmepriv, WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE) == _TRUE
&& check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE
) {
MSTATE_ADHOC_NUM(mstate)++;
if (iface->stapriv.asoc_sta_count > 2)
MSTATE_ADHOC_LD_NUM(mstate)++;
#ifdef CONFIG_RTW_MESH
} else if (check_fwstate(&iface->mlmepriv, WIFI_MESH_STATE) == _TRUE
&& check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE
) {
MSTATE_MESH_NUM(mstate)++;
if (iface->stapriv.asoc_sta_count > 2)
MSTATE_MESH_LD_NUM(mstate)++;
#endif
}
if (check_fwstate(&iface->mlmepriv, WIFI_UNDER_WPS) == _TRUE)
MSTATE_WPS_NUM(mstate)++;
if (check_fwstate(&iface->mlmepriv, WIFI_UNDER_SURVEY) == _TRUE) {
MSTATE_SCAN_NUM(mstate)++;
if (mlmeext_scan_state(&iface->mlmeextpriv) != SCAN_DISABLE
&& mlmeext_scan_state(&iface->mlmeextpriv) != SCAN_BACK_OP)
MSTATE_SCAN_ENTER_NUM(mstate)++;
}
#ifdef CONFIG_IOCTL_CFG80211
if (rtw_cfg80211_get_is_mgmt_tx(iface))
MSTATE_MGMT_TX_NUM(mstate)++;
#ifdef CONFIG_P2P
if (rtw_cfg80211_get_is_roch(iface) == _TRUE)
MSTATE_ROCH_NUM(mstate)++;
#endif
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_P2P
if (MLME_IS_PD(iface))
MSTATE_P2P_DV_NUM(mstate)++;
#endif
}
}
inline void rtw_mi_status(_adapter *adapter, struct mi_state *mstate)
{
return rtw_mi_status_by_ifbmp(adapter_to_dvobj(adapter), 0xFF, mstate);
}
inline void rtw_mi_status_no_self(_adapter *adapter, struct mi_state *mstate)
{
return rtw_mi_status_by_ifbmp(adapter_to_dvobj(adapter), 0xFF & ~BIT(adapter->iface_id), mstate);
}
inline void rtw_mi_status_no_others(_adapter *adapter, struct mi_state *mstate)
{
return rtw_mi_status_by_ifbmp(adapter_to_dvobj(adapter), BIT(adapter->iface_id), mstate);
}
/* For now, not handle union_ch/bw/offset */
inline void rtw_mi_status_merge(struct mi_state *d, struct mi_state *a)
{
d->sta_num += a->sta_num;
d->ld_sta_num += a->ld_sta_num;
d->lg_sta_num += a->lg_sta_num;
#ifdef CONFIG_TDLS
d->ld_tdls_num += a->ld_tdls_num;
#endif
#ifdef CONFIG_AP_MODE
d->ap_num += a->ap_num;
d->ld_ap_num += a->ld_ap_num;
#endif
d->adhoc_num += a->adhoc_num;
d->ld_adhoc_num += a->ld_adhoc_num;
#ifdef CONFIG_RTW_MESH
d->mesh_num += a->mesh_num;
d->ld_mesh_num += a->ld_mesh_num;
#endif
d->scan_num += a->scan_num;
d->scan_enter_num += a->scan_enter_num;
d->uwps_num += a->uwps_num;
#ifdef CONFIG_IOCTL_CFG80211
#ifdef CONFIG_P2P
d->roch_num += a->roch_num;
#endif
d->mgmt_tx_num += a->mgmt_tx_num;
#endif
}
void dump_mi_status(void *sel, struct dvobj_priv *dvobj)
{
RTW_PRINT_SEL(sel, "== dvobj-iface_state ==\n");
RTW_PRINT_SEL(sel, "sta_num:%d\n", DEV_STA_NUM(dvobj));
RTW_PRINT_SEL(sel, "linking_sta_num:%d\n", DEV_STA_LG_NUM(dvobj));
RTW_PRINT_SEL(sel, "linked_sta_num:%d\n", DEV_STA_LD_NUM(dvobj));
#ifdef CONFIG_TDLS
RTW_PRINT_SEL(sel, "linked_tdls_num:%d\n", DEV_TDLS_LD_NUM(dvobj));
#endif
#ifdef CONFIG_AP_MODE
RTW_PRINT_SEL(sel, "ap_num:%d\n", DEV_AP_NUM(dvobj));
RTW_PRINT_SEL(sel, "starting_ap_num:%d\n", DEV_AP_STARTING_NUM(dvobj));
RTW_PRINT_SEL(sel, "linked_ap_num:%d\n", DEV_AP_LD_NUM(dvobj));
#endif
RTW_PRINT_SEL(sel, "adhoc_num:%d\n", DEV_ADHOC_NUM(dvobj));
RTW_PRINT_SEL(sel, "linked_adhoc_num:%d\n", DEV_ADHOC_LD_NUM(dvobj));
#ifdef CONFIG_RTW_MESH
RTW_PRINT_SEL(sel, "mesh_num:%d\n", DEV_MESH_NUM(dvobj));
RTW_PRINT_SEL(sel, "linked_mesh_num:%d\n", DEV_MESH_LD_NUM(dvobj));
#endif
#ifdef CONFIG_P2P
RTW_PRINT_SEL(sel, "p2p_device_num:%d\n", DEV_P2P_DV_NUM(dvobj));
RTW_PRINT_SEL(sel, "p2p_gc_num:%d\n", DEV_P2P_GC_NUM(dvobj));
RTW_PRINT_SEL(sel, "p2p_go_num:%d\n", DEV_P2P_GO_NUM(dvobj));
#endif
RTW_PRINT_SEL(sel, "scan_num:%d\n", DEV_SCAN_NUM(dvobj));
RTW_PRINT_SEL(sel, "under_wps_num:%d\n", DEV_WPS_NUM(dvobj));
#if defined(CONFIG_IOCTL_CFG80211)
#if defined(CONFIG_P2P)
RTW_PRINT_SEL(sel, "roch_num:%d\n", DEV_ROCH_NUM(dvobj));
#endif
RTW_PRINT_SEL(sel, "mgmt_tx_num:%d\n", DEV_MGMT_TX_NUM(dvobj));
#endif
RTW_PRINT_SEL(sel, "union_ch:%d\n", DEV_U_CH(dvobj));
RTW_PRINT_SEL(sel, "union_bw:%d\n", DEV_U_BW(dvobj));
RTW_PRINT_SEL(sel, "union_offset:%d\n", DEV_U_OFFSET(dvobj));
RTW_PRINT_SEL(sel, "================\n\n");
}
void dump_dvobj_mi_status(void *sel, const char *fun_name, _adapter *adapter)
{
RTW_INFO("\n[ %s ] call %s\n", fun_name, __func__);
dump_mi_status(sel, adapter_to_dvobj(adapter));
}
inline void rtw_mi_update_iface_status(struct mlme_priv *pmlmepriv, sint state)
{
_adapter *adapter = container_of(pmlmepriv, _adapter, mlmepriv);
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct mi_state *iface_state = &dvobj->iface_state;
struct mi_state tmp_mstate;
u8 u_ch, u_offset, u_bw;
if (state == WIFI_MONITOR_STATE
|| state == 0xFFFFFFFF
)
return;
if (0)
RTW_INFO("%s => will change or clean state to 0x%08x\n", __func__, state);
rtw_mi_status(adapter, &tmp_mstate);
_rtw_memcpy(iface_state, &tmp_mstate, sizeof(struct mi_state));
if (rtw_mi_get_ch_setting_union(adapter, &u_ch, &u_bw, &u_offset))
rtw_mi_update_union_chan_inf(adapter , u_ch, u_offset , u_bw);
else {
if (0) {
dump_adapters_status(RTW_DBGDUMP , dvobj);
RTW_INFO("%s-[ERROR] cannot get union channel\n", __func__);
rtw_warn_on(1);
}
}
#ifdef DBG_IFACE_STATUS
DBG_IFACE_STATUS_DUMP(adapter);
#endif
}
u8 rtw_mi_check_status(_adapter *adapter, u8 type)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct mi_state *iface_state = &dvobj->iface_state;
u8 ret = _FALSE;
#ifdef DBG_IFACE_STATUS
DBG_IFACE_STATUS_DUMP(adapter);
RTW_INFO("%s-"ADPT_FMT" check type:%d\n", __func__, ADPT_ARG(adapter), type);
#endif
switch (type) {
case MI_LINKED:
if (MSTATE_STA_LD_NUM(iface_state) || MSTATE_AP_NUM(iface_state) || MSTATE_ADHOC_NUM(iface_state) || MSTATE_MESH_NUM(iface_state)) /*check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE)*/
ret = _TRUE;
break;
case MI_ASSOC:
if (MSTATE_STA_LD_NUM(iface_state) || MSTATE_AP_LD_NUM(iface_state) || MSTATE_ADHOC_LD_NUM(iface_state) || MSTATE_MESH_LD_NUM(iface_state))
ret = _TRUE;
break;
case MI_UNDER_WPS:
if (MSTATE_WPS_NUM(iface_state))
ret = _TRUE;
break;
case MI_AP_MODE:
if (MSTATE_AP_NUM(iface_state))
ret = _TRUE;
break;
case MI_AP_ASSOC:
if (MSTATE_AP_LD_NUM(iface_state))
ret = _TRUE;
break;
case MI_ADHOC:
if (MSTATE_ADHOC_NUM(iface_state))
ret = _TRUE;
break;
case MI_ADHOC_ASSOC:
if (MSTATE_ADHOC_LD_NUM(iface_state))
ret = _TRUE;
break;
#ifdef CONFIG_RTW_MESH
case MI_MESH:
if (MSTATE_MESH_NUM(iface_state))
ret = _TRUE;
break;
case MI_MESH_ASSOC:
if (MSTATE_MESH_LD_NUM(iface_state))
ret = _TRUE;
break;
#endif
case MI_STA_NOLINK: /* this is misleading, but not used now */
if (MSTATE_STA_NUM(iface_state) && (!(MSTATE_STA_LD_NUM(iface_state) || MSTATE_STA_LG_NUM(iface_state))))
ret = _TRUE;
break;
case MI_STA_LINKED:
if (MSTATE_STA_LD_NUM(iface_state))
ret = _TRUE;
break;
case MI_STA_LINKING:
if (MSTATE_STA_LG_NUM(iface_state))
ret = _TRUE;
break;
default:
break;
}
return ret;
}
/*
* return value : 0 is failed or have not interface meet condition
* return value : !0 is success or interface numbers which meet condition
* return value of ops_func must be _TRUE or _FALSE
*/
static u8 _rtw_mi_process(_adapter *padapter, bool exclude_self,
void *data, u8(*ops_func)(_adapter *padapter, void *data))
{
int i;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 ret = 0;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
if ((exclude_self) && (iface == padapter))
continue;
if (ops_func)
if (_TRUE == ops_func(iface, data))
ret++;
}
}
return ret;
}
static u8 _rtw_mi_process_without_schk(_adapter *padapter, bool exclude_self,
void *data, u8(*ops_func)(_adapter *padapter, void *data))
{
int i;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 ret = 0;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (iface) {
if ((exclude_self) && (iface == padapter))
continue;
if (ops_func)
if (ops_func(iface, data) == _TRUE)
ret++;
}
}
return ret;
}
static u8 _rtw_mi_netif_caroff_qstop(_adapter *padapter, void *data)
{
struct net_device *pnetdev = padapter->pnetdev;
rtw_netif_carrier_off(pnetdev);
rtw_netif_stop_queue(pnetdev);
return _TRUE;
}
u8 rtw_mi_netif_caroff_qstop(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_caroff_qstop);
}
u8 rtw_mi_buddy_netif_caroff_qstop(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_caroff_qstop);
}
static u8 _rtw_mi_disconnect(_adapter *adapter, void *data)
{
struct mlme_priv *mlme = &adapter->mlmepriv;
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
if ((MLME_IS_AP(adapter) || MLME_IS_MESH(adapter))
&& check_fwstate(mlme, WIFI_ASOC_STATE)) {
#ifdef CONFIG_SPCT_CH_SWITCH
if (1)
rtw_ap_inform_ch_switch(adapter, mlmeext->chandef.chan, mlmeext->chandef.offset);
else
#endif
#ifdef CONFIG_STA_CMD_DISPR
rtw_phl_cmd_stop_beacon(adapter_to_dvobj(adapter)->phl, adapter->phl_role, _TRUE, PHL_CMD_NO_WAIT, 0);
#else
rtw_phl_cmd_stop_beacon(adapter_to_dvobj(adapter)->phl, adapter->phl_role, _TRUE, PHL_CMD_DIRECTLY, 0);
#endif
rtw_sta_flush(adapter, _FALSE);
rtw_hal_set_hwreg(adapter, HW_VAR_CHECK_TXBUF, 0);
set_fwstate(mlme, WIFI_OP_CH_SWITCHING);
rtw_phl_chanctx_del(adapter_to_dvobj(adapter)->phl, adapter->phl_role, NULL);
} else if (MLME_IS_STA(adapter)
&& check_fwstate(mlme, WIFI_ASOC_STATE)) {
rtw_disassoc_cmd(adapter, 500, RTW_CMDF_DIRECTLY);
#ifndef CONFIG_STA_CMD_DISPR
rtw_free_assoc_resources(adapter, _TRUE);
#endif /* !CONFIG_STA_CMD_DISPR */
rtw_indicate_disconnect(adapter, 0, _FALSE);
}
return _TRUE;
}
u8 rtw_mi_disconnect(_adapter *adapter)
{
return _rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_disconnect);
}
u8 rtw_mi_buddy_disconnect(_adapter *adapter)
{
return _rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_disconnect);
}
static u8 _rtw_mi_netif_caron_qstart(_adapter *padapter, void *data)
{
struct net_device *pnetdev = padapter->pnetdev;
rtw_netif_carrier_on(pnetdev);
rtw_netif_start_queue(pnetdev);
return _TRUE;
}
u8 rtw_mi_netif_caron_qstart(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_caron_qstart);
}
u8 rtw_mi_buddy_netif_caron_qstart(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_caron_qstart);
}
static u8 _rtw_mi_netif_stop_queue(_adapter *padapter, void *data)
{
struct net_device *pnetdev = padapter->pnetdev;
rtw_netif_stop_queue(pnetdev);
return _TRUE;
}
u8 rtw_mi_netif_stop_queue(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_stop_queue);
}
u8 rtw_mi_buddy_netif_stop_queue(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_stop_queue);
}
static u8 _rtw_mi_netif_wake_queue(_adapter *padapter, void *data)
{
struct net_device *pnetdev = padapter->pnetdev;
if (pnetdev)
rtw_netif_wake_queue(pnetdev);
return _TRUE;
}
u8 rtw_mi_netif_wake_queue(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_wake_queue);
}
u8 rtw_mi_buddy_netif_wake_queue(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_wake_queue);
}
static u8 _rtw_mi_netif_carrier_on(_adapter *padapter, void *data)
{
struct net_device *pnetdev = padapter->pnetdev;
if (pnetdev)
rtw_netif_carrier_on(pnetdev);
return _TRUE;
}
u8 rtw_mi_netif_carrier_on(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_carrier_on);
}
u8 rtw_mi_buddy_netif_carrier_on(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_carrier_on);
}
static u8 _rtw_mi_netif_carrier_off(_adapter *padapter, void *data)
{
struct net_device *pnetdev = padapter->pnetdev;
if (pnetdev)
rtw_netif_carrier_off(pnetdev);
return _TRUE;
}
u8 rtw_mi_netif_carrier_off(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_netif_carrier_off);
}
u8 rtw_mi_buddy_netif_carrier_off(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_netif_carrier_off);
}
static u8 _rtw_mi_scan_abort(_adapter *adapter, void *data)
{
bool bwait = *(bool *)data;
if (bwait)
rtw_scan_abort(adapter, 0);
else
rtw_scan_abort_no_wait(adapter);
return _TRUE;
}
void rtw_mi_scan_abort(_adapter *adapter, bool bwait)
{
bool in_data = bwait;
_rtw_mi_process(adapter, _FALSE, &in_data, _rtw_mi_scan_abort);
}
void rtw_mi_buddy_scan_abort(_adapter *adapter, bool bwait)
{
bool in_data = bwait;
_rtw_mi_process(adapter, _TRUE, &in_data, _rtw_mi_scan_abort);
}
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
static u32 _rtw_mi_start_drv_threads(_adapter *adapter, bool exclude_self)
{
int i;
_adapter *iface = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
u32 _status = _SUCCESS;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (iface) {
if ((exclude_self) && (iface == adapter))
continue;
if (rtw_start_drv_threads(iface) == _FAIL) {
_status = _FAIL;
break;
}
}
}
return _status;
}
u32 rtw_mi_start_drv_threads(_adapter *adapter)
{
return _rtw_mi_start_drv_threads(adapter, _FALSE);
}
u32 rtw_mi_buddy_start_drv_threads(_adapter *adapter)
{
return _rtw_mi_start_drv_threads(adapter, _TRUE);
}
static void _rtw_mi_stop_drv_threads(_adapter *adapter, bool exclude_self)
{
int i;
_adapter *iface = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (iface) {
if ((exclude_self) && (iface == adapter))
continue;
rtw_stop_drv_threads(iface);
}
}
}
void rtw_mi_stop_drv_threads(_adapter *adapter)
{
_rtw_mi_stop_drv_threads(adapter, _FALSE);
}
void rtw_mi_buddy_stop_drv_threads(_adapter *adapter)
{
_rtw_mi_stop_drv_threads(adapter, _TRUE);
}
#endif
static u8 _rtw_mi_cancel_all_timer(_adapter *adapter, void *data)
{
rtw_cancel_all_timer(adapter);
return _TRUE;
}
void rtw_mi_cancel_all_timer(_adapter *adapter)
{
_rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_cancel_all_timer);
}
void rtw_mi_buddy_cancel_all_timer(_adapter *adapter)
{
_rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_cancel_all_timer);
}
static u8 _rtw_mi_reset_drv_sw(_adapter *adapter, void *data)
{
rtw_reset_drv_sw(adapter);
return _TRUE;
}
void rtw_mi_reset_drv_sw(_adapter *adapter)
{
_rtw_mi_process_without_schk(adapter, _FALSE, NULL, _rtw_mi_reset_drv_sw);
}
void rtw_mi_buddy_reset_drv_sw(_adapter *adapter)
{
_rtw_mi_process_without_schk(adapter, _TRUE, NULL, _rtw_mi_reset_drv_sw);
}
u8 rtw_mi_hal_iface_init(_adapter *padapter)
{
int i;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 ret = _SUCCESS;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (iface && iface->netif_up) {
ret = rtw_hw_iface_init(iface);
if (ret == _FAIL)
break;
}
}
return ret;
}
static u8 _rtw_mi_suspend_free_assoc_resource(_adapter *padapter, void *data)
{
return rtw_suspend_free_assoc_resource(padapter);
}
void rtw_mi_suspend_free_assoc_resource(_adapter *adapter)
{
_rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_suspend_free_assoc_resource);
}
void rtw_mi_buddy_suspend_free_assoc_resource(_adapter *adapter)
{
_rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_suspend_free_assoc_resource);
}
static u8 _rtw_mi_is_scan_deny(_adapter *adapter, void *data)
{
return rtw_is_scan_deny(adapter);
}
u8 rtw_mi_is_scan_deny(_adapter *adapter)
{
return _rtw_mi_process(adapter, _FALSE, NULL, _rtw_mi_is_scan_deny);
}
u8 rtw_mi_buddy_is_scan_deny(_adapter *adapter)
{
return _rtw_mi_process(adapter, _TRUE, NULL, _rtw_mi_is_scan_deny);
}
#ifdef CONFIG_SET_SCAN_DENY_TIMER
static u8 _rtw_mi_set_scan_deny(_adapter *adapter, void *data)
{
u32 ms = *(u32 *)data;
rtw_set_scan_deny(adapter, ms);
return _TRUE;
}
void rtw_mi_set_scan_deny(_adapter *adapter, u32 ms)
{
u32 in_data = ms;
_rtw_mi_process(adapter, _FALSE, &in_data, _rtw_mi_set_scan_deny);
}
void rtw_mi_buddy_set_scan_deny(_adapter *adapter, u32 ms)
{
u32 in_data = ms;
_rtw_mi_process(adapter, _TRUE, &in_data, _rtw_mi_set_scan_deny);
}
#endif /*CONFIG_SET_SCAN_DENY_TIMER*/
static u8 _rtw_mi_beacon_update(_adapter *padapter, void *data)
{
if (!MLME_IS_STA(padapter)
&& check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE) {
RTW_INFO(ADPT_FMT" - update_beacon\n", ADPT_ARG(padapter));
rtw_update_beacon(padapter, 0xFF, NULL, _TRUE, 0);
}
return _TRUE;
}
void rtw_mi_beacon_update(_adapter *padapter)
{
_rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_beacon_update);
}
void rtw_mi_buddy_beacon_update(_adapter *padapter)
{
_rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_beacon_update);
}
u8 _rtw_mi_busy_traffic_check(_adapter *padapter, void *data)
{
return padapter->mlmepriv.LinkDetectInfo.bBusyTraffic;
}
u8 rtw_mi_busy_traffic_check(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_busy_traffic_check);
}
u8 rtw_mi_buddy_busy_traffic_check(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_busy_traffic_check);
}
static u8 _rtw_mi_check_mlmeinfo_state(_adapter *padapter, void *data)
{
u32 state = *(u32 *)data;
struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
/*if (mlmeext_msr(mlmeext) == state)*/
if (check_mlmeinfo_state(mlmeext, state))
return _TRUE;
else
return _FALSE;
}
u8 rtw_mi_check_mlmeinfo_state(_adapter *padapter, u32 state)
{
u32 in_data = state;
return _rtw_mi_process(padapter, _FALSE, &in_data, _rtw_mi_check_mlmeinfo_state);
}
u8 rtw_mi_buddy_check_mlmeinfo_state(_adapter *padapter, u32 state)
{
u32 in_data = state;
return _rtw_mi_process(padapter, _TRUE, &in_data, _rtw_mi_check_mlmeinfo_state);
}
/*#define DBG_DUMP_FW_STATE*/
#ifdef DBG_DUMP_FW_STATE
static void rtw_dbg_dump_fwstate(_adapter *padapter, sint state)
{
u8 buf[32] = {0};
if (state & WIFI_FW_NULL_STATE) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "WIFI_FW_NULL_STATE");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
if (state & WIFI_ASOC_STATE) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "WIFI_ASOC_STATE");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
if (state & WIFI_UNDER_LINKING) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "WIFI_UNDER_LINKING");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
if (state & WIFI_UNDER_SURVEY) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "WIFI_UNDER_SURVEY");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
}
#endif
static u8 _rtw_mi_check_fwstate(_adapter *padapter, void *data)
{
u8 ret = _FALSE;
sint state = *(sint *)data;
if ((state == WIFI_FW_NULL_STATE) &&
(padapter->mlmepriv.fw_state == WIFI_FW_NULL_STATE))
ret = _TRUE;
else if (_TRUE == check_fwstate(&padapter->mlmepriv, state))
ret = _TRUE;
#ifdef DBG_DUMP_FW_STATE
if (ret)
rtw_dbg_dump_fwstate(padapter, state);
#endif
return ret;
}
u8 rtw_mi_check_fwstate(_adapter *padapter, sint state)
{
sint in_data = state;
return _rtw_mi_process(padapter, _FALSE, &in_data, _rtw_mi_check_fwstate);
}
u8 rtw_mi_buddy_check_fwstate(_adapter *padapter, sint state)
{
sint in_data = state;
return _rtw_mi_process(padapter, _TRUE, &in_data, _rtw_mi_check_fwstate);
}
static u8 _rtw_mi_traffic_statistics(_adapter *padapter , void *data)
{
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
/* Tx */
pdvobjpriv->traffic_stat.tx_bytes += padapter->xmitpriv.tx_bytes;
pdvobjpriv->traffic_stat.tx_pkts += padapter->xmitpriv.tx_pkts;
pdvobjpriv->traffic_stat.tx_drop += padapter->xmitpriv.tx_drop;
/* Rx */
pdvobjpriv->traffic_stat.rx_bytes += padapter->recvinfo.rx_bytes;
pdvobjpriv->traffic_stat.rx_pkts += padapter->recvinfo.rx_pkts;
pdvobjpriv->traffic_stat.rx_drop += padapter->recvinfo.rx_drop;
return _TRUE;
}
u8 rtw_mi_traffic_statistics(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_traffic_statistics);
}
static u8 _rtw_mi_check_miracast_enabled(_adapter *padapter , void *data)
{
return is_miracast_enabled(padapter);
}
u8 rtw_mi_check_miracast_enabled(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_check_miracast_enabled);
}
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
static u8 _rtw_mi_check_pending_xmitbuf(_adapter *padapter , void *data)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
return check_pending_xmitbuf(pxmitpriv);
}
u8 rtw_mi_check_pending_xmitbuf(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_check_pending_xmitbuf);
}
u8 rtw_mi_buddy_check_pending_xmitbuf(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_check_pending_xmitbuf);
}
#endif
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
#include <rtw_trx_sdio.h>
static u8 _rtw_mi_dequeue_xmit(_adapter *padapter , bool exclude_self)
{
int i;
u8 queue_empty = _TRUE;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
if ((exclude_self) && (iface == padapter))
continue;
queue_empty &= sdio_dequeue_xmit(iface);
}
}
return queue_empty;
}
u8 rtw_mi_sdio_dequeue_xmit(_adapter *padapter)
{
return _rtw_mi_dequeue_xmit(padapter, _FALSE);
}
u8 rtw_mi_sdio_buddy_dequeue_xmit(_adapter *padapter)
{
return _rtw_mi_dequeue_xmit(padapter, _TRUE);
}
#endif
static void _rtw_mi_adapter_reset(_adapter *padapter , u8 exclude_self)
{
int i;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
for (i = 0; i < dvobj->iface_nums; i++) {
if (dvobj->padapters[i]) {
if ((exclude_self) && (dvobj->padapters[i] == padapter))
continue;
dvobj->padapters[i] = NULL;
}
}
}
void rtw_mi_adapter_reset(_adapter *padapter)
{
_rtw_mi_adapter_reset(padapter, _FALSE);
}
void rtw_mi_buddy_adapter_reset(_adapter *padapter)
{
_rtw_mi_adapter_reset(padapter, _TRUE);
}
static u8 _rtw_mi_dynamic_check_handlder(struct _ADAPTER *a, void *data)
{
rtw_iface_dynamic_check_handlder(a);
return _TRUE;
}
u8 rtw_mi_dynamic_check_handlder(struct _ADAPTER *a)
{
return _rtw_mi_process(a, _FALSE, NULL, _rtw_mi_dynamic_check_handlder);
}
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
static u8 _rtw_mi_dynamic_check_timer_handlder(_adapter *adapter, void *data)
{
rtw_iface_dynamic_check_timer_handlder(adapter);
return _TRUE;
}
u8 rtw_mi_dynamic_check_timer_handlder(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_dynamic_check_timer_handlder);
}
u8 rtw_mi_buddy_dynamic_check_timer_handlder(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_dynamic_check_timer_handlder);
}
#endif
static u8 _rtw_mi_dynamic_chk_wk_hdl(_adapter *adapter, void *data)
{
rtw_iface_dynamic_chk_wk_hdl(adapter);
return _TRUE;
}
u8 rtw_mi_dynamic_chk_wk_hdl(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_dynamic_chk_wk_hdl);
}
u8 rtw_mi_buddy_dynamic_chk_wk_hdl(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_dynamic_chk_wk_hdl);
}
static u8 _rtw_mi_os_xmit_schedule(_adapter *adapter, void *data)
{
rtw_os_xmit_schedule(adapter);
return _TRUE;
}
u8 rtw_mi_os_xmit_schedule(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_os_xmit_schedule);
}
u8 rtw_mi_buddy_os_xmit_schedule(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_os_xmit_schedule);
}
static u8 _rtw_mi_report_survey_event(_adapter *adapter, void *data)
{
union recv_frame *precv_frame = (union recv_frame *)data;
report_survey_event(adapter, precv_frame);
return _TRUE;
}
u8 rtw_mi_report_survey_event(_adapter *padapter, union recv_frame *precv_frame)
{
return _rtw_mi_process(padapter, _FALSE, precv_frame, _rtw_mi_report_survey_event);
}
u8 rtw_mi_buddy_report_survey_event(_adapter *padapter, union recv_frame *precv_frame)
{
return _rtw_mi_process(padapter, _TRUE, precv_frame, _rtw_mi_report_survey_event);
}
static u8 _rtw_mi_sreset_adapter_hdl(_adapter *adapter, void *data)
{
u8 bstart = *(u8 *)data;
if (bstart)
sreset_start_adapter(adapter);
else
sreset_stop_adapter(adapter);
return _TRUE;
}
u8 rtw_mi_sreset_adapter_hdl(_adapter *padapter, u8 bstart)
{
u8 in_data = bstart;
return _rtw_mi_process(padapter, _FALSE, &in_data, _rtw_mi_sreset_adapter_hdl);
}
#if defined(DBG_CONFIG_ERROR_RESET) && defined(CONFIG_CONCURRENT_MODE)
void rtw_mi_ap_info_restore(_adapter *adapter)
{
int i;
_adapter *iface;
struct mlme_priv *pmlmepriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (iface) {
pmlmepriv = &iface->mlmepriv;
if (MLME_IS_AP(iface) || MLME_IS_MESH(iface)) {
RTW_INFO(FUNC_ADPT_FMT" %s\n", FUNC_ADPT_ARG(iface), MLME_IS_AP(iface) ? "AP" : "MESH");
rtw_iface_bcmc_sec_cam_map_restore(iface);
}
}
}
}
#endif /*#if defined(DBG_CONFIG_ERROR_RESET) && defined(CONFIG_CONCURRENT_MODE)*/
u8 rtw_mi_buddy_sreset_adapter_hdl(_adapter *padapter, u8 bstart)
{
u8 in_data = bstart;
return _rtw_mi_process(padapter, _TRUE, &in_data, _rtw_mi_sreset_adapter_hdl);
}
static u8 _rtw_mi_tx_beacon_hdl(_adapter *adapter, void *data)
{
if ((MLME_IS_AP(adapter) || MLME_IS_MESH(adapter))
&& check_fwstate(&adapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE
) {
adapter->mlmepriv.update_bcn = _TRUE;
#ifndef CONFIG_INTERRUPT_BASED_TXBCN
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI) || defined(CONFIG_PCI_BCN_POLLING)
tx_beacon_hdl(adapter, NULL);
#endif
#endif
}
return _TRUE;
}
u8 rtw_mi_tx_beacon_hdl(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_tx_beacon_hdl);
}
u8 rtw_mi_buddy_tx_beacon_hdl(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_sreset_adapter_hdl);
}
static u8 _rtw_mi_set_tx_beacon_cmd(_adapter *adapter, void *data)
{
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
if (MLME_IS_AP(adapter) || MLME_IS_MESH(adapter)) {
if (pmlmepriv->update_bcn == _TRUE)
set_tx_beacon_cmd(adapter, 0);
}
return _TRUE;
}
u8 rtw_mi_set_tx_beacon_cmd(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_set_tx_beacon_cmd);
}
u8 rtw_mi_buddy_set_tx_beacon_cmd(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_set_tx_beacon_cmd);
}
#ifdef CONFIG_P2P
static u8 _rtw_mi_stay_in_p2p_mode(_adapter *adapter, void *data)
{
struct wifidirect_info *pwdinfo = &(adapter->wdinfo);
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT) ||
rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
return _TRUE;
return _FALSE;
}
u8 rtw_mi_stay_in_p2p_mode(_adapter *padapter)
{
return _rtw_mi_process(padapter, _FALSE, NULL, _rtw_mi_stay_in_p2p_mode);
}
u8 rtw_mi_buddy_stay_in_p2p_mode(_adapter *padapter)
{
return _rtw_mi_process(padapter, _TRUE, NULL, _rtw_mi_stay_in_p2p_mode);
}
#endif /*CONFIG_P2P*/
_adapter *rtw_get_iface_by_id(_adapter *padapter, u8 iface_id)
{
_adapter *iface = NULL;
struct dvobj_priv *dvobj;
if ((padapter == NULL) || (iface_id >= CONFIG_IFACE_NUMBER)) {
rtw_warn_on(1);
return iface;
}
dvobj = adapter_to_dvobj(padapter);
dvobj = adapter_to_dvobj(padapter);
return dvobj->padapters[iface_id];
}
_adapter *rtw_get_iface_by_macddr(_adapter *padapter, const u8 *mac_addr)
{
int i;
_adapter *iface = NULL;
u8 bmatch = _FALSE;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
#ifdef RTW_PHL_TEST_FPGA
return dvobj->padapters[0];
#endif
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && (_rtw_memcmp(mac_addr, adapter_mac_addr(iface), ETH_ALEN))) {
bmatch = _TRUE;
break;
}
}
if (bmatch)
return iface;
else
return NULL;
}
_adapter *rtw_get_iface_by_hwport(_adapter *padapter, u8 hw_port)
{
int i;
_adapter *iface = NULL;
u8 bmatch = _FALSE;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && (hw_port == iface->hw_port)) {
bmatch = _TRUE;
break;
}
}
if (bmatch)
return iface;
else
return NULL;
}
/*#define CONFIG_SKB_ALLOCATED*/
#define DBG_SKB_PROCESS
#ifdef DBG_SKB_PROCESS
void rtw_dbg_skb_process(_adapter *padapter, union recv_frame *precvframe, union recv_frame *pcloneframe)
{
struct sk_buff *pkt_copy, *pkt_org;
pkt_org = precvframe->u.hdr.pkt;
pkt_copy = pcloneframe->u.hdr.pkt;
/*
RTW_INFO("%s ===== ORG SKB =====\n", __func__);
RTW_INFO(" SKB head(%p)\n", pkt_org->head);
RTW_INFO(" SKB data(%p)\n", pkt_org->data);
RTW_INFO(" SKB tail(%p)\n", pkt_org->tail);
RTW_INFO(" SKB end(%p)\n", pkt_org->end);
RTW_INFO(" recv frame head(%p)\n", precvframe->u.hdr.rx_head);
RTW_INFO(" recv frame data(%p)\n", precvframe->u.hdr.rx_data);
RTW_INFO(" recv frame tail(%p)\n", precvframe->u.hdr.rx_tail);
RTW_INFO(" recv frame end(%p)\n", precvframe->u.hdr.rx_end);
RTW_INFO("%s ===== COPY SKB =====\n", __func__);
RTW_INFO(" SKB head(%p)\n", pkt_copy->head);
RTW_INFO(" SKB data(%p)\n", pkt_copy->data);
RTW_INFO(" SKB tail(%p)\n", pkt_copy->tail);
RTW_INFO(" SKB end(%p)\n", pkt_copy->end);
RTW_INFO(" recv frame head(%p)\n", pcloneframe->u.hdr.rx_head);
RTW_INFO(" recv frame data(%p)\n", pcloneframe->u.hdr.rx_data);
RTW_INFO(" recv frame tail(%p)\n", pcloneframe->u.hdr.rx_tail);
RTW_INFO(" recv frame end(%p)\n", pcloneframe->u.hdr.rx_end);
*/
/*
RTW_INFO("%s => recv_frame adapter(%p,%p)\n", __func__, precvframe->u.hdr.adapter, pcloneframe->u.hdr.adapter);
RTW_INFO("%s => recv_frame dev(%p,%p)\n", __func__, pkt_org->dev , pkt_copy->dev);
RTW_INFO("%s => recv_frame len(%d,%d)\n", __func__, precvframe->u.hdr.len, pcloneframe->u.hdr.len);
*/
if (precvframe->u.hdr.len != pcloneframe->u.hdr.len)
RTW_INFO("%s [WARN] recv_frame length(%d:%d) compare failed\n", __func__, precvframe->u.hdr.len, pcloneframe->u.hdr.len);
if (_rtw_memcmp(&precvframe->u.hdr.attrib, &pcloneframe->u.hdr.attrib, sizeof(struct rx_pkt_attrib)) == _FALSE)
RTW_INFO("%s [WARN] recv_frame attrib compare failed\n", __func__);
if (_rtw_memcmp(precvframe->u.hdr.rx_data, pcloneframe->u.hdr.rx_data, precvframe->u.hdr.len) == _FALSE)
RTW_INFO("%s [WARN] recv_frame rx_data compare failed\n", __func__);
}
#endif
static s32 _rtw_mi_buddy_clone_bcmc_packet(_adapter *adapter,
union recv_frame *precvframe, union recv_frame *pcloneframe)
{
s32 ret = _SUCCESS;
#ifdef CONFIG_SKB_ALLOCATED
u8 *pbuf = precvframe->u.hdr.rx_data;
#endif
struct rx_pkt_attrib *pattrib = NULL;
if (pcloneframe) {
pcloneframe->u.hdr.adapter = adapter;
_rtw_init_listhead(&pcloneframe->u.hdr.list);
pcloneframe->u.hdr.precvbuf = NULL; /*can't access the precvbuf for new arch.*/
pcloneframe->u.hdr.len = 0;
_rtw_memcpy(&pcloneframe->u.hdr.attrib, &precvframe->u.hdr.attrib, sizeof(struct rx_pkt_attrib));
pattrib = &pcloneframe->u.hdr.attrib;
#ifdef CONFIG_SKB_ALLOCATED
if (rtw_os_alloc_recvframe(adapter, pcloneframe, pbuf, NULL) == _SUCCESS)
#else
if (rtw_os_recvframe_duplicate_skb(adapter, pcloneframe, precvframe->u.hdr.pkt) == _SUCCESS)
#endif
{
#ifdef CONFIG_SKB_ALLOCATED
recvframe_put(pcloneframe, pattrib->pkt_len);
#endif
#ifdef DBG_SKB_PROCESS
rtw_dbg_skb_process(adapter, precvframe, pcloneframe);
#endif
validate_recv_frame(adapter, pcloneframe);
} else {
ret = _FAIL;
RTW_ERR("%s()-%d: rtw_os_alloc_recvframe() failed!\n", __func__, __LINE__);
}
}
return ret;
}
void rtw_mi_buddy_clone_bcmc_packet(_adapter *padapter,
union recv_frame *precvframe)
{
int i;
s32 ret = _SUCCESS;
_adapter *iface = NULL;
union recv_frame *pcloneframe = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct recv_priv *precvpriv = &dvobj->recvpriv;
_queue *pfree_recv_queue = &precvpriv->free_recv_queue;
u8 *fhead = get_recvframe_data(precvframe);
u8 type = GetFrameType(fhead);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface || iface == padapter)
continue;
if (rtw_is_adapter_up(iface) == _FALSE || iface->registered == 0)
continue;
if (type == WIFI_DATA_TYPE && !adapter_allow_bmc_data_rx(iface))
continue;
pcloneframe = rtw_alloc_recvframe(pfree_recv_queue);
if (pcloneframe) {
ret = _rtw_mi_buddy_clone_bcmc_packet(iface, precvframe, pcloneframe);
if (ret == _FAIL)
RTW_ERR("_rtw_mi_buddy_clone_bcmc_packet failed!\n");
rtw_free_recvframe(pcloneframe);
} else {
RTW_ERR("%s rtw_alloc_recvframe failed\n", __func__);
rtw_warn_on(1);
}
}
}
#ifdef CONFIG_PCI_HCI
/*API be created temporary for MI, caller is interrupt-handler, PCIE's interrupt handler cannot apply to multi-AP*/
_adapter *rtw_mi_get_ap_adapter(_adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
int i;
_adapter *iface = NULL;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface)
continue;
if (check_fwstate(&iface->mlmepriv, WIFI_AP_STATE) == _TRUE
&& check_fwstate(&iface->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
break;
}
return iface;
}
#endif
u8 rtw_mi_get_ld_sta_ifbmp(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
int i;
_adapter *iface = NULL;
u8 ifbmp = 0;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface)
continue;
if (MLME_IS_STA(iface) && MLME_IS_ASOC(iface))
ifbmp |= BIT(i);
}
return ifbmp;
}
u8 rtw_mi_get_ap_mesh_ifbmp(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
int i;
_adapter *iface = NULL;
u8 ifbmp = 0;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface)
continue;
if (CHK_MLME_STATE(iface, WIFI_AP_STATE | WIFI_MESH_STATE)
&& MLME_IS_ASOC(iface))
ifbmp |= BIT(i);
}
return ifbmp;
}
u8 rtw_mi_get_assoc_if_num(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
u8 n_assoc_iface = 0;
#if 1
u8 i;
for (i = 0; i < dvobj->iface_nums; i++) {
if (check_fwstate(&(dvobj->padapters[i]->mlmepriv), WIFI_ASOC_STATE))
n_assoc_iface++;
}
#else
n_assoc_iface = DEV_STA_LD_NUM(dvobj) + DEV_AP_NUM(dvobj) + DEV_ADHOC_NUM(dvobj) + DEV_MESH_NUM(dvobj);
#endif
return n_assoc_iface;
}
|
2301_81045437/rtl8852be
|
core/rtw_mi.c
|
C
|
agpl-3.0
| 40,080
|
/******************************************************************************
*
* Copyright(c) 2007 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_MLME_C_
#include <drv_types.h>
extern u8 rtw_do_join(_adapter *padapter);
void rtw_init_mlme_timer(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
rtw_init_timer(&(pmlmepriv->assoc_timer), rtw_join_timeout_handler, padapter);
rtw_init_timer(&(pmlmepriv->scan_to_timer), rtw_scan_timeout_handler, padapter);
#ifdef CONFIG_SET_SCAN_DENY_TIMER
rtw_init_timer(&(pmlmepriv->set_scan_deny_timer), rtw_set_scan_deny_timer_hdl, padapter);
#endif
#ifdef RTK_DMP_PLATFORM
_init_workitem(&(pmlmepriv->Linkup_workitem), Linkup_workitem_callback, padapter);
_init_workitem(&(pmlmepriv->Linkdown_workitem), Linkdown_workitem_callback, padapter);
#endif
}
sint _rtw_init_mlme_priv(_adapter *padapter)
{
sint i;
u8 *pbuf;
struct wlan_network *pnetwork;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
sint res = _SUCCESS;
#ifdef CONFIG_RTW_MULTI_AP
struct unassoc_sta_info *unassoc_sta;
#endif
/* We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc(). */
/* _rtw_memset((u8 *)pmlmepriv, 0, sizeof(struct mlme_priv)); */
/*qos_priv*/
/*pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable;*/
/*ht_priv*/
#ifdef CONFIG_80211N_HT
pmlmepriv->htpriv.ampdu_enable = _FALSE;/*set to disabled*/
#endif
pmlmepriv->nic_hdl = (u8 *)padapter;
pmlmepriv->pscanned = NULL;
init_fwstate(pmlmepriv, WIFI_STATION_STATE);
pmlmepriv->cur_network.network.InfrastructureMode = Ndis802_11AutoUnknown;
pmlmepriv->scan_mode = RTW_PHL_SCAN_ACTIVE; /* 1: active, 0: pasive. Maybe someday we should rename this varable to "active_mode" (Jeff) */
_rtw_spinlock_init(&(pmlmepriv->lock));
_rtw_init_queue(&(pmlmepriv->free_bss_pool));
_rtw_init_queue(&(pmlmepriv->scanned_queue));
set_scanned_network_val(pmlmepriv, 0);
_rtw_memset(&pmlmepriv->assoc_ssid, 0, sizeof(NDIS_802_11_SSID));
if (padapter->registrypriv.max_bss_cnt != 0)
pmlmepriv->max_bss_cnt = padapter->registrypriv.max_bss_cnt;
else if (rfctl->max_chan_nums <= MAX_CHANNEL_NUM_2G)
pmlmepriv->max_bss_cnt = MAX_BSS_CNT;
else
pmlmepriv->max_bss_cnt = MAX_BSS_CNT + MAX_BSS_CNT;
pbuf = rtw_zvmalloc(pmlmepriv->max_bss_cnt * (sizeof(struct wlan_network)));
if (pbuf == NULL) {
res = _FAIL;
goto exit;
}
pmlmepriv->free_bss_buf = pbuf;
pnetwork = (struct wlan_network *)pbuf;
for (i = 0; i < pmlmepriv->max_bss_cnt; i++) {
_rtw_init_listhead(&(pnetwork->list));
rtw_list_insert_tail(&(pnetwork->list), &(pmlmepriv->free_bss_pool.queue));
pnetwork++;
}
#ifdef CONFIG_RTW_MULTI_AP
if (is_primary_adapter(padapter)) {
_rtw_init_queue(&(pmlmepriv->free_unassoc_sta_queue));
_rtw_init_queue(&(pmlmepriv->unassoc_sta_queue));
for (i = 0; i < UNASOC_STA_SRC_NUM; i++)
pmlmepriv->unassoc_sta_mode_of_stype[i] = padapter->registrypriv.unassoc_sta_mode_of_stype[i];
if (padapter->registrypriv.max_unassoc_sta_cnt != 0)
pmlmepriv->max_unassoc_sta_cnt = padapter->registrypriv.max_unassoc_sta_cnt;
else if (rfctl->max_chan_nums <= MAX_CHANNEL_NUM_2G)
pmlmepriv->max_unassoc_sta_cnt = MAX_UNASSOC_STA_CNT;
else
pmlmepriv->max_unassoc_sta_cnt = MAX_UNASSOC_STA_CNT * 2;
pbuf = rtw_zvmalloc(pmlmepriv->max_unassoc_sta_cnt * (sizeof(struct unassoc_sta_info)));
if (pbuf == NULL) {
res = _FAIL;
goto exit;
}
pmlmepriv->free_unassoc_sta_buf = pbuf;
unassoc_sta = (struct unassoc_sta_info *) pbuf;
for (i = 0; i < pmlmepriv->max_unassoc_sta_cnt; i++) {
_rtw_init_listhead(&(unassoc_sta->list));
rtw_list_insert_tail(&(unassoc_sta->list), &(pmlmepriv->free_unassoc_sta_queue.queue));
unassoc_sta++;
}
}
#endif
/* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
rtw_clear_scan_deny(padapter);
#ifdef CONFIG_ARP_KEEP_ALIVE
pmlmepriv->bGetGateway = 0;
pmlmepriv->GetGatewayTryCnt = 0;
#endif
#ifdef CONFIG_LAYER2_ROAMING
#define RTW_ROAM_SCAN_RESULT_EXP_MS (5*1000)
#define RTW_ROAM_RSSI_DIFF_TH 10
#define RTW_ROAM_SCAN_INTERVAL (5) /* 5*(2 second)*/
#define RTW_ROAM_RSSI_THRESHOLD 70
pmlmepriv->roam_flags = CONFIG_ROAMING_FLAG;
pmlmepriv->roam_scanr_exp_ms = RTW_ROAM_SCAN_RESULT_EXP_MS;
pmlmepriv->roam_rssi_diff_th = RTW_ROAM_RSSI_DIFF_TH;
pmlmepriv->roam_scan_int = RTW_ROAM_SCAN_INTERVAL;
pmlmepriv->roam_rssi_threshold = RTW_ROAM_RSSI_THRESHOLD;
pmlmepriv->need_to_roam = _FALSE;
pmlmepriv->last_roaming = rtw_get_current_time();
#endif /* CONFIG_LAYER2_ROAMING */
#ifdef CONFIG_RTW_80211R
rtw_ft_info_init(&pmlmepriv->ft_roam);
#endif
#ifdef CONFIG_RTW_MBO
#ifdef CONFIG_LAYER2_ROAMING
#if defined(CONFIG_RTW_WNM) || defined(CONFIG_RTW_80211K)
rtw_roam_nb_info_init(padapter);
pmlmepriv->ch_cnt = 0;
#endif
#endif
#endif
#ifdef CONFIG_RTW_MBO
rtw_mbo_attr_info_init(padapter);
#endif
pmlmepriv->defs_lmt_sta = 2;
pmlmepriv->defs_lmt_time = 5;
rtw_init_mlme_timer(padapter);
exit:
return res;
}
void rtw_mfree_mlme_priv_lock(struct mlme_priv *pmlmepriv)
{
_rtw_spinlock_free(&pmlmepriv->lock);
_rtw_spinlock_free(&(pmlmepriv->free_bss_pool.lock));
_rtw_spinlock_free(&(pmlmepriv->scanned_queue.lock));
#ifdef CONFIG_RTW_MULTI_AP
if (is_primary_adapter(mlme_to_adapter(pmlmepriv))) {
_rtw_spinlock_free(&(pmlmepriv->unassoc_sta_queue.lock));
_rtw_spinlock_free(&(pmlmepriv->free_unassoc_sta_queue.lock));
}
#endif
}
static void rtw_free_mlme_ie_data(u8 **ppie, u32 *plen)
{
if (*ppie) {
rtw_mfree(*ppie, *plen);
*plen = 0;
*ppie = NULL;
}
}
void rtw_free_mlme_priv_ie_data(struct mlme_priv *pmlmepriv)
{
#ifdef CONFIG_80211D
rtw_buf_free(&pmlmepriv->recv_country_ie, &pmlmepriv->recv_country_ie_len);
#endif
#if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
rtw_buf_free(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len);
rtw_buf_free(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_beacon_ie, &pmlmepriv->wps_beacon_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_req_ie, &pmlmepriv->wps_probe_req_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_resp_ie, &pmlmepriv->wps_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_assoc_resp_ie, &pmlmepriv->wps_assoc_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_beacon_ie, &pmlmepriv->p2p_beacon_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_req_ie, &pmlmepriv->p2p_probe_req_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_resp_ie, &pmlmepriv->p2p_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_go_probe_resp_ie, &pmlmepriv->p2p_go_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_assoc_req_ie, &pmlmepriv->p2p_assoc_req_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_assoc_resp_ie, &pmlmepriv->p2p_assoc_resp_ie_len);
#endif
#if defined(CONFIG_WFD) && defined(CONFIG_IOCTL_CFG80211)
rtw_free_mlme_ie_data(&pmlmepriv->wfd_beacon_ie, &pmlmepriv->wfd_beacon_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wfd_probe_req_ie, &pmlmepriv->wfd_probe_req_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wfd_probe_resp_ie, &pmlmepriv->wfd_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wfd_go_probe_resp_ie, &pmlmepriv->wfd_go_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wfd_assoc_req_ie, &pmlmepriv->wfd_assoc_req_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wfd_assoc_resp_ie, &pmlmepriv->wfd_assoc_resp_ie_len);
#endif
#ifdef CONFIG_RTW_80211R
rtw_free_mlme_ie_data(&pmlmepriv->auth_rsp, &pmlmepriv->auth_rsp_len);
#endif
#ifdef CONFIG_RTW_MBO
rtw_buf_free(&pmlmepriv->pcell_data_cap_ie, &pmlmepriv->cell_data_cap_len);
#endif
}
#if defined(CONFIG_WFD) && defined(CONFIG_IOCTL_CFG80211)
int rtw_mlme_update_wfd_ie_data(struct mlme_priv *mlme, u8 type, u8 *ie, u32 ie_len)
{
_adapter *adapter = mlme_to_adapter(mlme);
struct wifi_display_info *wfd_info = &adapter->wfd_info;
u8 clear = 0;
u8 **t_ie = NULL;
u32 *t_ie_len = NULL;
int ret = _FAIL;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
goto success;
if (wfd_info->wfd_enable == _TRUE)
goto success; /* WFD IE is build by self */
if (!ie && !ie_len)
clear = 1;
else if (!ie || !ie_len) {
RTW_PRINT(FUNC_ADPT_FMT" type:%u, ie:%p, ie_len:%u"
, FUNC_ADPT_ARG(adapter), type, ie, ie_len);
rtw_warn_on(1);
goto exit;
}
switch (type) {
case MLME_BEACON_IE:
t_ie = &mlme->wfd_beacon_ie;
t_ie_len = &mlme->wfd_beacon_ie_len;
break;
case MLME_PROBE_REQ_IE:
t_ie = &mlme->wfd_probe_req_ie;
t_ie_len = &mlme->wfd_probe_req_ie_len;
break;
case MLME_PROBE_RESP_IE:
t_ie = &mlme->wfd_probe_resp_ie;
t_ie_len = &mlme->wfd_probe_resp_ie_len;
break;
case MLME_GO_PROBE_RESP_IE:
t_ie = &mlme->wfd_go_probe_resp_ie;
t_ie_len = &mlme->wfd_go_probe_resp_ie_len;
break;
case MLME_ASSOC_REQ_IE:
t_ie = &mlme->wfd_assoc_req_ie;
t_ie_len = &mlme->wfd_assoc_req_ie_len;
break;
case MLME_ASSOC_RESP_IE:
t_ie = &mlme->wfd_assoc_resp_ie;
t_ie_len = &mlme->wfd_assoc_resp_ie_len;
break;
default:
RTW_PRINT(FUNC_ADPT_FMT" unsupported type:%u"
, FUNC_ADPT_ARG(adapter), type);
rtw_warn_on(1);
goto exit;
}
if (*t_ie) {
u32 free_len = *t_ie_len;
*t_ie_len = 0;
rtw_mfree(*t_ie, free_len);
*t_ie = NULL;
}
if (!clear) {
*t_ie = rtw_malloc(ie_len);
if (*t_ie == NULL) {
RTW_ERR(FUNC_ADPT_FMT" type:%u, rtw_malloc() fail\n"
, FUNC_ADPT_ARG(adapter), type);
goto exit;
}
_rtw_memcpy(*t_ie, ie, ie_len);
*t_ie_len = ie_len;
}
if (*t_ie && *t_ie_len) {
u8 *attr_content;
u32 attr_contentlen = 0;
attr_content = rtw_get_wfd_attr_content(*t_ie, *t_ie_len, WFD_ATTR_DEVICE_INFO, NULL, &attr_contentlen);
if (attr_content && attr_contentlen) {
if (RTW_GET_BE16(attr_content + 2) != wfd_info->rtsp_ctrlport) {
wfd_info->rtsp_ctrlport = RTW_GET_BE16(attr_content + 2);
RTW_INFO(FUNC_ADPT_FMT" type:%u, RTSP CTRL port = %u\n"
, FUNC_ADPT_ARG(adapter), type, wfd_info->rtsp_ctrlport);
}
}
}
success:
ret = _SUCCESS;
exit:
return ret;
}
#endif /* defined(CONFIG_WFD) && defined(CONFIG_IOCTL_CFG80211) */
void _rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)
{
_adapter *adapter = mlme_to_adapter(pmlmepriv);
if (NULL == pmlmepriv) {
rtw_warn_on(1);
goto exit;
}
rtw_free_mlme_priv_ie_data(pmlmepriv);
if (pmlmepriv) {
rtw_mfree_mlme_priv_lock(pmlmepriv);
if (pmlmepriv->free_bss_buf)
rtw_vmfree(pmlmepriv->free_bss_buf, pmlmepriv->max_bss_cnt * sizeof(struct wlan_network));
#ifdef CONFIG_RTW_MULTI_AP
if (is_primary_adapter(adapter)) {
if (pmlmepriv->free_unassoc_sta_buf)
rtw_vmfree(pmlmepriv->free_unassoc_sta_buf, pmlmepriv->max_unassoc_sta_cnt * sizeof(struct unassoc_sta_info));
}
#endif
}
exit:
return;
}
sint _rtw_enqueue_network(_queue *queue, struct wlan_network *pnetwork)
{
if (pnetwork == NULL)
goto exit;
_rtw_spinlock_bh(&queue->lock);
rtw_list_insert_tail(&pnetwork->list, &queue->queue);
_rtw_spinunlock_bh(&queue->lock);
exit:
return _SUCCESS;
}
/*
struct wlan_network *_rtw_dequeue_network(_queue *queue)
{
struct wlan_network *pnetwork;
_rtw_spinlock_bh(&queue->lock);
if (_rtw_queue_empty(queue) == _TRUE)
pnetwork = NULL;
else
{
pnetwork = LIST_CONTAINOR(get_next(&queue->queue), struct wlan_network, list);
rtw_list_delete(&(pnetwork->list));
}
_rtw_spinunlock_bh(&queue->lock);
return pnetwork;
}
*/
struct wlan_network *_rtw_alloc_network(struct mlme_priv *pmlmepriv) /* (_queue *free_queue) */
{
struct wlan_network *pnetwork;
_queue *free_queue = &pmlmepriv->free_bss_pool;
_list *plist = NULL;
_rtw_spinlock_bh(&free_queue->lock);
if (_rtw_queue_empty(free_queue) == _TRUE) {
pnetwork = NULL;
goto exit;
}
plist = get_next(&(free_queue->queue));
pnetwork = LIST_CONTAINOR(plist , struct wlan_network, list);
rtw_list_delete(&pnetwork->list);
pnetwork->network_type = 0;
pnetwork->fixed = _FALSE;
pnetwork->last_scanned = rtw_get_current_time();
#if defined(CONFIG_RTW_MESH) && CONFIG_RTW_MESH_ACNODE_PREVENT
pnetwork->acnode_stime = 0;
pnetwork->acnode_notify_etime = 0;
#endif
pnetwork->aid = 0;
pnetwork->join_res = 0;
pmlmepriv->num_of_scanned++;
exit:
_rtw_spinunlock_bh(&free_queue->lock);
return pnetwork;
}
void _rtw_free_network(struct mlme_priv *pmlmepriv , struct wlan_network *pnetwork, u8 isfreeall)
{
u32 delta_time;
u32 lifetime = SCANQUEUE_LIFETIME;
_queue *free_queue = &(pmlmepriv->free_bss_pool);
if (pnetwork == NULL)
goto exit;
if (pnetwork->fixed == _TRUE)
goto exit;
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE))
lifetime = 1;
if (!isfreeall) {
delta_time = (u32) rtw_get_passing_time_ms(pnetwork->last_scanned);
if (delta_time < lifetime) /* unit:msec */
goto exit;
}
_rtw_spinlock_bh(&free_queue->lock);
rtw_list_delete(&(pnetwork->list));
rtw_list_insert_tail(&(pnetwork->list), &(free_queue->queue));
pmlmepriv->num_of_scanned--;
/* RTW_INFO("_rtw_free_network:SSID=%s\n", pnetwork->network.Ssid.Ssid); */
_rtw_spinunlock_bh(&free_queue->lock);
exit:
return;
}
void _rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork)
{
_queue *free_queue = &(pmlmepriv->free_bss_pool);
if (pnetwork == NULL)
goto exit;
if (pnetwork->fixed == _TRUE)
goto exit;
/* _rtw_spinlock_irq(&free_queue->lock, &sp_flags); */
rtw_list_delete(&(pnetwork->list));
rtw_list_insert_tail(&(pnetwork->list), get_list_head(free_queue));
pmlmepriv->num_of_scanned--;
/* _rtw_spinunlock_irq(&free_queue->lock, &sp_flags); */
exit:
return;
}
void _rtw_free_network_queue(_adapter *padapter, u8 isfreeall)
{
_list *phead, *plist;
struct wlan_network *pnetwork;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
_queue *scanned_queue = &pmlmepriv->scanned_queue;
_rtw_spinlock_bh(&scanned_queue->lock);
phead = get_list_head(scanned_queue);
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
plist = get_next(plist);
_rtw_free_network(pmlmepriv, pnetwork, isfreeall);
}
_rtw_spinunlock_bh(&scanned_queue->lock);
}
sint rtw_if_up(_adapter *padapter)
{
sint res;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)) ||
(check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _FALSE)) {
res = _FALSE;
} else
res = _TRUE;
return res;
}
void rtw_generate_random_ibss(u8 *pibss)
{
*((u32 *)(&pibss[2])) = rtw_random32();
pibss[0] = 0x02; /* in ad-hoc mode local bit must set to 1 */
pibss[1] = 0x11;
pibss[2] = 0x87;
}
u8 *rtw_get_capability_from_ie(u8 *ie)
{
return ie + 8 + 2;
}
u16 rtw_get_capability(WLAN_BSSID_EX *bss)
{
u16 val;
_rtw_memcpy((u8 *)&val, rtw_get_capability_from_ie(bss->IEs), 2);
return le16_to_cpu(val);
}
u8 *rtw_get_timestampe_from_ie(u8 *ie)
{
return ie + 0;
}
u8 *rtw_get_beacon_interval_from_ie(u8 *ie)
{
return ie + 8;
}
int rtw_init_mlme_priv(_adapter *padapter) /* (struct mlme_priv *pmlmepriv) */
{
int res;
res = _rtw_init_mlme_priv(padapter);/* (pmlmepriv); */
return res;
}
void rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)
{
_rtw_free_mlme_priv(pmlmepriv);
}
int rtw_enqueue_network(_queue *queue, struct wlan_network *pnetwork)
{
int res;
res = _rtw_enqueue_network(queue, pnetwork);
return res;
}
void rtw_free_network(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork, u8 is_freeall)/* (struct wlan_network *pnetwork, _queue *free_queue) */
{
_rtw_free_network(pmlmepriv, pnetwork, is_freeall);
}
void rtw_free_network_nolock(_adapter *padapter, struct wlan_network *pnetwork)
{
_rtw_free_network_nolock(&(padapter->mlmepriv), pnetwork);
#ifdef CONFIG_IOCTL_CFG80211
rtw_cfg80211_unlink_bss(padapter, pnetwork);
#endif /* CONFIG_IOCTL_CFG80211 */
}
void rtw_free_network_queue(_adapter *dev, u8 isfreeall)
{
_rtw_free_network_queue(dev, isfreeall);
}
struct wlan_network *_rtw_find_network(_queue *scanned_queue, const u8 *addr)
{
_list *phead, *plist;
struct wlan_network *pnetwork = NULL;
u8 zero_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
if (_rtw_memcmp(zero_addr, addr, ETH_ALEN)) {
pnetwork = NULL;
goto exit;
}
phead = get_list_head(scanned_queue);
plist = get_next(phead);
while (plist != phead) {
pnetwork = LIST_CONTAINOR(plist, struct wlan_network , list);
if (_rtw_memcmp(addr, pnetwork->network.MacAddress, ETH_ALEN) == _TRUE)
break;
plist = get_next(plist);
}
if (plist == phead)
pnetwork = NULL;
exit:
return pnetwork;
}
struct wlan_network *rtw_find_network(_queue *scanned_queue, const u8 *addr)
{
struct wlan_network *pnetwork;
_rtw_spinlock_bh(&scanned_queue->lock);
pnetwork = _rtw_find_network(scanned_queue, addr);
_rtw_spinunlock_bh(&scanned_queue->lock);
return pnetwork;
}
int rtw_is_same_ibss(_adapter *adapter, struct wlan_network *pnetwork)
{
int ret = _TRUE;
struct security_priv *psecuritypriv = &adapter->securitypriv;
if ((psecuritypriv->dot11PrivacyAlgrthm != _NO_PRIVACY_) &&
(pnetwork->network.Privacy == 0))
ret = _FALSE;
else if ((psecuritypriv->dot11PrivacyAlgrthm == _NO_PRIVACY_) &&
(pnetwork->network.Privacy == 1))
ret = _FALSE;
else
ret = _TRUE;
return ret;
}
inline int is_same_ess(WLAN_BSSID_EX *a, WLAN_BSSID_EX *b)
{
return (a->Ssid.SsidLength == b->Ssid.SsidLength)
&& _rtw_memcmp(a->Ssid.Ssid, b->Ssid.Ssid, a->Ssid.SsidLength) == _TRUE;
}
int is_same_network(WLAN_BSSID_EX *src, WLAN_BSSID_EX *dst)
{
u16 s_cap, d_cap;
_rtw_memcpy((u8 *)&s_cap, rtw_get_capability_from_ie(src->IEs), 2);
_rtw_memcpy((u8 *)&d_cap, rtw_get_capability_from_ie(dst->IEs), 2);
s_cap = le16_to_cpu(s_cap);
d_cap = le16_to_cpu(d_cap);
/* Wi-Fi driver doesn't consider the situation of BCN and ProbRsp sent from the same hidden AP,
* it considers these two packets are sent from different AP.
* Therefore, the scan queue may store two scan results of the same hidden AP, likes below.
*
* index bssid ch RSSI SdBm Noise age flag ssid
* 1 00:e0:4c:55:50:01 153 -73 -73 0 7044 [WPS][ESS] RTK5G
* 3 00:e0:4c:55:50:01 153 -73 -73 0 7044 [WPS][ESS]
*
* Original rules will compare Ssid, SsidLength, MacAddress, s_cap, d_cap at the same time.
* Wi-Fi driver will assume that the BCN and ProbRsp sent from the same hidden AP are the same network
* after we add an additional rule to compare SsidLength and Ssid.
* It means the scan queue will not store two scan results of the same hidden AP, it only store ProbRsp.
* For customer request.
*/
if (((_rtw_memcmp(src->MacAddress, dst->MacAddress, ETH_ALEN)) == _TRUE) &&
((s_cap & WLAN_CAPABILITY_IBSS) == (d_cap & WLAN_CAPABILITY_IBSS)) &&
((s_cap & WLAN_CAPABILITY_BSS) == (d_cap & WLAN_CAPABILITY_BSS))) {
if ((src->Ssid.SsidLength == dst->Ssid.SsidLength) &&
(((_rtw_memcmp(src->Ssid.Ssid, dst->Ssid.Ssid, src->Ssid.SsidLength)) == _TRUE) || //Case of normal AP
(is_all_null(src->Ssid.Ssid, src->Ssid.SsidLength) == _TRUE || is_all_null(dst->Ssid.Ssid, dst->Ssid.SsidLength) == _TRUE))) //Case of hidden AP
return _TRUE;
else if ((src->Ssid.SsidLength == 0 || dst->Ssid.SsidLength == 0)) //Case of hidden AP
return _TRUE;
else
return _FALSE;
} else {
return _FALSE;
}
}
struct wlan_network *_rtw_find_same_network(_queue *scanned_queue, struct wlan_network *network)
{
_list *phead, *plist;
struct wlan_network *found = NULL;
phead = get_list_head(scanned_queue);
plist = get_next(phead);
while (plist != phead) {
found = LIST_CONTAINOR(plist, struct wlan_network , list);
if (is_same_network(&network->network, &found->network))
break;
plist = get_next(plist);
}
if (plist == phead)
found = NULL;
return found;
}
struct wlan_network *rtw_find_same_network(_queue *scanned_queue, struct wlan_network *network)
{
struct wlan_network *found = NULL;
if (scanned_queue == NULL || network == NULL)
goto exit;
_rtw_spinlock_bh(&scanned_queue->lock);
found = _rtw_find_same_network(scanned_queue, network);
_rtw_spinunlock_bh(&scanned_queue->lock);
exit:
return found;
}
struct wlan_network *rtw_get_oldest_wlan_network(_queue *scanned_queue)
{
_list *plist, *phead;
struct wlan_network *pwlan = NULL;
struct wlan_network *oldest = NULL;
phead = get_list_head(scanned_queue);
plist = get_next(phead);
while (1) {
if (rtw_end_of_queue_search(phead, plist) == _TRUE)
break;
pwlan = LIST_CONTAINOR(plist, struct wlan_network, list);
if (pwlan->fixed != _TRUE) {
if (oldest == NULL || rtw_time_after(oldest->last_scanned, pwlan->last_scanned))
oldest = pwlan;
}
plist = get_next(plist);
}
return oldest;
}
void rtw_update_network(WLAN_BSSID_EX *dst, WLAN_BSSID_EX *src,
_adapter *padapter, bool update_ie)
{
#if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
u8 ss_ori = dst->PhyInfo.SignalStrength;
u8 sq_ori = dst->PhyInfo.SignalQuality;
u8 ss_smp = src->PhyInfo.SignalStrength;
s8 rssi_smp = src->PhyInfo.rssi;
#endif
s8 rssi_ori = dst->PhyInfo.rssi;
u8 sq_smp = src->PhyInfo.SignalQuality;
u8 ss_final;
u8 sq_final;
s8 rssi_final;
#ifdef CONFIG_ANTENNA_DIVERSITY
rtw_hal_antdiv_rssi_compared(padapter, dst, src); /* this will update src->PhyInfo.rssi, need consider again */
#endif
#if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
if (strcmp(dst->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
RTW_INFO(FUNC_ADPT_FMT" %s("MAC_FMT", ch%u) ss_ori:%3u, sq_ori:%3u, rssi_ori:%d, ss_smp:%3u, sq_smp:%3u, rssi_smp:%d\n"
, FUNC_ADPT_ARG(padapter)
, src->Ssid.Ssid, MAC_ARG(src->MacAddress), src->Configuration.DSConfig
, ss_ori, sq_ori, rssi_ori
, ss_smp, sq_smp, rssi_smp
);
}
#endif
/* The rule below is 1/5 for sample value, 4/5 for history value */
if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) && is_same_network(&(padapter->mlmepriv.cur_network.network), src)) {
/* Take the recvpriv's value for the connected AP*/
ss_final = padapter->recvinfo.signal_strength;
sq_final = padapter->recvinfo.signal_qual;
/* the rssi value here is undecorated, and will be used for antenna diversity */
if (sq_smp != 101) /* from the right channel */
rssi_final = (src->PhyInfo.rssi + dst->PhyInfo.rssi * 4) / 5;
else
rssi_final = rssi_ori;
} else {
if (sq_smp != 101) { /* from the right channel */
ss_final = ((u32)(src->PhyInfo.SignalStrength) + (u32)(dst->PhyInfo.SignalStrength) * 4) / 5;
sq_final = ((u32)(src->PhyInfo.SignalQuality) + (u32)(dst->PhyInfo.SignalQuality) * 4) / 5;
rssi_final = (src->PhyInfo.rssi + dst->PhyInfo.rssi * 4) / 5;
} else {
/* bss info not receving from the right channel, use the original RX signal infos */
ss_final = dst->PhyInfo.SignalStrength;
sq_final = dst->PhyInfo.SignalQuality;
rssi_final = dst->PhyInfo.rssi;
}
}
if (update_ie) {
dst->Reserved[0] = src->Reserved[0];
dst->Reserved[1] = src->Reserved[1];
_rtw_memcpy((u8 *)dst, (u8 *)src, get_WLAN_BSSID_EX_sz(src));
}
dst->PhyInfo.SignalStrength = ss_final;
dst->PhyInfo.SignalQuality = sq_final;
dst->PhyInfo.rssi = rssi_final;
#if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) && 1
if (strcmp(dst->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
RTW_INFO(FUNC_ADPT_FMT" %s("MAC_FMT"), SignalStrength:%u, SignalQuality:%u, RawRSSI:%d\n"
, FUNC_ADPT_ARG(padapter)
, dst->Ssid.Ssid, MAC_ARG(dst->MacAddress),
dst->PhyInfo.SignalStrength, dst->PhyInfo.SignalQuality, dst->PhyInfo.rssi);
}
#endif
}
#ifdef CONFIG_RTW_MULTI_AP
void rtw_map_config_monitor_act_non(_adapter *adapter)
{
rtw_map_config_monitor(adapter, MLME_ACTION_NONE);
}
void rtw_map_config_monitor(_adapter *adapter, u8 self_act)
{
struct mi_state mstate, mstate_s;
void *phl = GET_PHL_INFO(adapter_to_dvobj(adapter));
rtw_mi_status_no_self(adapter, &mstate);
rtw_mi_status_no_others(adapter, &mstate_s);
switch (self_act) {
case MLME_AP_STARTED:
mstate_s.ap_num = 1;
break;
case MLME_AP_STOPPED:
mstate_s.ap_num = 0;
break;
case MLME_ACTION_NONE:
break;
default:
break;
}
rtw_mi_status_merge(&mstate, &mstate_s);
if (MSTATE_AP_NUM(&mstate) &&
rtw_unassoc_sta_src_chk(adapter, UNASOC_STA_SRC_RX_NMY_UC))
rtw_phl_enter_mon_mode(phl, adapter->phl_role);
else
rtw_phl_leave_mon_mode(phl, adapter->phl_role);
}
void rtw_unassoc_sta_set_mode(_adapter *adapter, u8 stype, u8 mode)
{
if (stype >= UNASOC_STA_SRC_NUM || mode >= UNASOC_STA_MODE_NUM)
return;
adapter = GET_PRIMARY_ADAPTER(adapter);
if (adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] == mode)
return;
adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] = mode;
rtw_run_in_thread_cmd_wait(adapter, ((void *)(rtw_map_config_monitor_act_non)), adapter, 2000);
}
bool rtw_unassoc_sta_src_chk(_adapter *adapter, u8 stype)
{
if (stype >= UNASOC_STA_SRC_NUM)
return 0;
adapter = GET_PRIMARY_ADAPTER(adapter);
return adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] == UNASOC_STA_MODE_ALL
|| (adapter->mlmepriv.unassoc_sta_mode_of_stype[stype] == UNASOC_STA_MODE_INTERESTED
&& adapter->mlmepriv.interested_unassoc_sta_cnt);
}
const char *unasoc_sta_src_str[] = {
"BMC",
"NMY_UC",
};
const char *unasoc_sta_mode_str[] = {
"DISABLED",
"INTERESTED",
"ALL",
};
void dump_unassoc_sta(void *sel, _adapter *adapter)
{
struct mlme_priv *mlmepriv;
_queue *queue;
_list *list, *head;
struct unassoc_sta_info **unassoc_sta_arr;
struct unassoc_sta_info *unassoc_sta;
u16 i, unassoc_sta_cnt = 0;
adapter = GET_PRIMARY_ADAPTER(adapter);
mlmepriv = &(adapter->mlmepriv);
queue = &(mlmepriv->unassoc_sta_queue);
for (i = 0; i < UNASOC_STA_SRC_NUM; i++) {
RTW_PRINT_SEL(sel, "[%u]%-6s:%u(%s)\n", i, unasoc_sta_src_str[i],
mlmepriv->unassoc_sta_mode_of_stype[i],
unasoc_sta_mode_str[mlmepriv->unassoc_sta_mode_of_stype[i]]);
}
RTW_PRINT_SEL(sel, "interested_unassoc_sta_cnt:%u\n",
mlmepriv->interested_unassoc_sta_cnt);
unassoc_sta_arr = rtw_zvmalloc(mlmepriv->max_unassoc_sta_cnt * sizeof(struct unassoc_sta_info *));
if (!unassoc_sta_arr)
return;
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
unassoc_sta = LIST_CONTAINOR(list, struct unassoc_sta_info, list);
list = get_next(list);
unassoc_sta_arr[unassoc_sta_cnt++] = unassoc_sta;
}
_rtw_spinunlock_bh(&queue->lock);
RTW_PRINT_SEL(sel, " %17s %18s %6s\n", "mac_addr", "measure_delta_time", "rssi");
for (i = 0; i < unassoc_sta_cnt; i++) {
u8 rcpi;
s8 rx_power;
u32 measure_delta_time;
unassoc_sta = unassoc_sta_arr[i];
measure_delta_time = rtw_systime_to_ms(rtw_get_current_time() - unassoc_sta->time);
RTW_PRINT_SEL(sel, "%c "MAC_FMT" %18u %6d\n"
, unassoc_sta->interested ? '*' : ' '
, MAC_ARG(unassoc_sta->addr), measure_delta_time,
unassoc_sta->recv_signal_power);
}
rtw_vmfree(unassoc_sta_arr, mlmepriv->max_unassoc_sta_cnt * sizeof(struct unassoc_sta_info *));
}
static void del_unassoc_sta(struct mlme_priv *mlmepriv, struct unassoc_sta_info *unassoc_sta)
{
_queue *free_queue = &(mlmepriv->free_unassoc_sta_queue);
if (unassoc_sta->interested)
mlmepriv->interested_unassoc_sta_cnt--;
if (mlmepriv->interested_unassoc_sta_cnt == 0) {
rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
, ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
}
_rtw_spinlock_bh(&free_queue->lock);
rtw_list_delete(&(unassoc_sta->list));
rtw_list_insert_tail(&(unassoc_sta->list), &(free_queue->queue));
_rtw_spinunlock_bh(&free_queue->lock);
}
static u8 del_unassoc_sta_chk(struct mlme_priv *mlmepriv, struct unassoc_sta_info *unassoc_sta)
{
systime cur, lifetime;
if (unassoc_sta == NULL)
return UNASOC_STA_DEL_CHK_SKIP;
if (unassoc_sta->interested)
return UNASOC_STA_DEL_CHK_SKIP;
cur = rtw_get_current_time();
lifetime = unassoc_sta->time + rtw_ms_to_systime(UNASSOC_STA_LIFETIME_MS);
if (rtw_time_before(cur, lifetime))
return UNASOC_STA_DEL_CHK_ALIVE;
del_unassoc_sta(mlmepriv, unassoc_sta);
return UNASOC_STA_DEL_CHK_DELETED;
}
static struct unassoc_sta_info *alloc_unassoc_sta(struct mlme_priv *mlmepriv)
{
struct unassoc_sta_info *unassoc_sta;
_queue *free_queue = &mlmepriv->free_unassoc_sta_queue;
_list *list = NULL;
_rtw_spinlock_bh(&free_queue->lock);
if (_rtw_queue_empty(free_queue) == _TRUE) {
unassoc_sta = NULL;
goto exit;
}
list = get_next(&(free_queue->queue));
unassoc_sta = LIST_CONTAINOR(list, struct unassoc_sta_info, list);
rtw_list_delete(&unassoc_sta->list);
_rtw_memset(unassoc_sta->addr, 0, ETH_ALEN);
unassoc_sta->recv_signal_power = 0;
unassoc_sta->time = 0;
unassoc_sta->interested = 0;
exit:
_rtw_spinunlock_bh(&free_queue->lock);
return unassoc_sta;
}
void rtw_del_unassoc_sta_queue(_adapter *adapter)
{
struct unassoc_sta_info *unassoc_sta;
struct mlme_priv *mlmepriv;
_queue *queue;
_list *head, *list;
adapter = GET_PRIMARY_ADAPTER(adapter);
mlmepriv = &(adapter->mlmepriv);
queue = &(mlmepriv->unassoc_sta_queue);
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
list = get_next(list);
del_unassoc_sta(mlmepriv, unassoc_sta);
}
_rtw_spinunlock_bh(&queue->lock);
}
void rtw_del_unassoc_sta(_adapter *adapter, u8 *addr)
{
struct unassoc_sta_info *unassoc_sta;
struct mlme_priv *mlmepriv;
_queue *queue;
_list *head, *list;
adapter = GET_PRIMARY_ADAPTER(adapter);
mlmepriv = &(adapter->mlmepriv);
queue = &(mlmepriv->unassoc_sta_queue);
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
list = get_next(list);
if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
del_unassoc_sta(mlmepriv, unassoc_sta);
goto unlock_unassoc_sta_queue;
}
}
unlock_unassoc_sta_queue:
_rtw_spinunlock_bh(&queue->lock);
}
void rtw_rx_add_unassoc_sta(_adapter *adapter, u8 stype, u8 *addr, s8 recv_signal_power)
{
struct unassoc_sta_info *unassoc_sta;
struct unassoc_sta_info *oldest_unassoc_sta = NULL;
struct mlme_priv *mlmepriv;
_queue *queue;
_list *head, *list;
adapter = GET_PRIMARY_ADAPTER(adapter);
mlmepriv = &(adapter->mlmepriv);
queue = &(mlmepriv->unassoc_sta_queue);
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
list = get_next(list);
if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
if (unassoc_sta->interested ||
mlmepriv->unassoc_sta_mode_of_stype[stype] >=
UNASOC_STA_MODE_ALL) {
unassoc_sta->recv_signal_power = recv_signal_power;
unassoc_sta->time = rtw_get_current_time();
goto unlock_unassoc_sta_queue;
}
}
if (del_unassoc_sta_chk(mlmepriv, unassoc_sta) == UNASOC_STA_DEL_CHK_ALIVE) {
if (oldest_unassoc_sta == NULL)
oldest_unassoc_sta = unassoc_sta;
else if (rtw_time_before(unassoc_sta->time, oldest_unassoc_sta->time))
oldest_unassoc_sta = unassoc_sta;
}
}
if (mlmepriv->unassoc_sta_mode_of_stype[stype] <= UNASOC_STA_MODE_INTERESTED)
goto unlock_unassoc_sta_queue;
unassoc_sta = alloc_unassoc_sta(mlmepriv);
if (unassoc_sta == NULL) {
if (oldest_unassoc_sta) {
del_unassoc_sta(mlmepriv, oldest_unassoc_sta);
unassoc_sta = alloc_unassoc_sta(mlmepriv);
} else
goto unlock_unassoc_sta_queue;
}
_rtw_memcpy(unassoc_sta->addr, addr, ETH_ALEN);
unassoc_sta->recv_signal_power = recv_signal_power;
unassoc_sta->time = rtw_get_current_time();
rtw_list_insert_tail(&(unassoc_sta->list), &(queue->queue));
unlock_unassoc_sta_queue:
_rtw_spinunlock_bh(&queue->lock);
}
void rtw_add_interested_unassoc_sta(_adapter *adapter, u8 *addr)
{
struct unassoc_sta_info *unassoc_sta;
struct unassoc_sta_info *oldest_unassoc_sta = NULL;
struct mlme_priv *mlmepriv;
_queue *queue;
_list *head, *list;
adapter = GET_PRIMARY_ADAPTER(adapter);
mlmepriv = &(adapter->mlmepriv);
queue = &(mlmepriv->unassoc_sta_queue);
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
list = get_next(list);
if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
if (!unassoc_sta->interested) {
unassoc_sta->interested = 1;
mlmepriv->interested_unassoc_sta_cnt++;
if (mlmepriv->interested_unassoc_sta_cnt == 1) {
rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
, ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
}
}
goto unlock_unassoc_sta_queue;
}
if (del_unassoc_sta_chk(mlmepriv, unassoc_sta) == UNASOC_STA_DEL_CHK_ALIVE) {
if (oldest_unassoc_sta == NULL)
oldest_unassoc_sta = unassoc_sta;
else if (rtw_time_after(unassoc_sta->time, oldest_unassoc_sta->time))
oldest_unassoc_sta = unassoc_sta;
}
}
unassoc_sta = alloc_unassoc_sta(mlmepriv);
if (unassoc_sta == NULL) {
RTW_INFO(FUNC_ADPT_FMT": Allocate fail\n", FUNC_ADPT_ARG(adapter));
if (oldest_unassoc_sta) {
RTW_INFO(FUNC_ADPT_FMT": Delete oldest entry and try again.\n", FUNC_ADPT_ARG(adapter));
del_unassoc_sta(mlmepriv, oldest_unassoc_sta);
unassoc_sta = alloc_unassoc_sta(mlmepriv);
} else
goto unlock_unassoc_sta_queue;
}
_rtw_memcpy(unassoc_sta->addr, addr, ETH_ALEN);
unassoc_sta->interested = 1;
unassoc_sta->recv_signal_power = 0;
unassoc_sta->time = rtw_get_current_time() - rtw_ms_to_systime(UNASSOC_STA_LIFETIME_MS);
rtw_list_insert_tail(&(unassoc_sta->list), &(queue->queue));
mlmepriv->interested_unassoc_sta_cnt++;
if (mlmepriv->interested_unassoc_sta_cnt == 1) {
rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
, ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
}
unlock_unassoc_sta_queue:
_rtw_spinunlock_bh(&queue->lock);
}
void rtw_undo_interested_unassoc_sta(_adapter *adapter, u8 *addr)
{
struct unassoc_sta_info *unassoc_sta;
struct mlme_priv *mlmepriv;
_queue *queue;
_list *head, *list;
adapter = GET_PRIMARY_ADAPTER(adapter);
mlmepriv = &(adapter->mlmepriv);
queue = &(mlmepriv->unassoc_sta_queue);
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
list = get_next(list);
if (_rtw_memcmp(addr, unassoc_sta->addr, ETH_ALEN) == _TRUE) {
if (unassoc_sta->interested) {
unassoc_sta->interested = 0;
mlmepriv->interested_unassoc_sta_cnt--;
if (mlmepriv->interested_unassoc_sta_cnt == 0) {
rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
, ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
}
}
goto unlock_unassoc_sta_queue;
}
}
unlock_unassoc_sta_queue:
_rtw_spinunlock_bh(&queue->lock);
}
void rtw_undo_all_interested_unassoc_sta(_adapter *adapter)
{
struct unassoc_sta_info *unassoc_sta;
struct mlme_priv *mlmepriv;
_queue *queue;
_list *head, *list;
adapter = GET_PRIMARY_ADAPTER(adapter);
mlmepriv = &(adapter->mlmepriv);
queue = &(mlmepriv->unassoc_sta_queue);
_rtw_spinlock_bh(&queue->lock);
head = get_list_head(queue);
list = get_next(head);
while ((rtw_end_of_queue_search(head, list)) == _FALSE) {
unassoc_sta = LIST_CONTAINOR(list , struct unassoc_sta_info, list);
list = get_next(list);
if (unassoc_sta->interested) {
unassoc_sta->interested = 0;
mlmepriv->interested_unassoc_sta_cnt--;
if (mlmepriv->interested_unassoc_sta_cnt == 0) {
rtw_run_in_thread_cmd(mlme_to_adapter(mlmepriv)
, ((void *)(rtw_map_config_monitor_act_non)), mlme_to_adapter(mlmepriv));
goto unlock_unassoc_sta_queue;
}
}
}
unlock_unassoc_sta_queue:
_rtw_spinunlock_bh(&queue->lock);
}
#endif /* CONFIG_RTW_MULTI_AP */
/* select the desired network based on the capability of the (i)bss.
* check items: (1) security
* (2) network_type
* (3) WMM
* (4) HT
* (5) others */
int rtw_is_desired_network(_adapter *adapter, struct wlan_network *pnetwork)
{
struct security_priv *psecuritypriv = &adapter->securitypriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u32 desired_encmode;
u32 privacy;
/* u8 wps_ie[512]; */
uint wps_ielen;
int bselected = _TRUE;
desired_encmode = psecuritypriv->ndisencryptstatus;
privacy = pnetwork->network.Privacy;
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
if (rtw_get_wps_ie(pnetwork->network.IEs + _FIXED_IE_LENGTH_, pnetwork->network.IELength - _FIXED_IE_LENGTH_, NULL, &wps_ielen) != NULL)
return _TRUE;
else
return _FALSE;
}
if (adapter->registrypriv.wifi_spec == 1) { /* for correct flow of 8021X to do.... */
u8 *p = NULL;
uint ie_len = 0;
if ((desired_encmode == Ndis802_11EncryptionDisabled) && (privacy != 0))
bselected = _FALSE;
if (psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPA2PSK) {
p = rtw_get_ie(pnetwork->network.IEs + _BEACON_IE_OFFSET_, _RSN_IE_2_, &ie_len, (pnetwork->network.IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0)
bselected = _TRUE;
else
bselected = _FALSE;
}
}
if ((desired_encmode != Ndis802_11EncryptionDisabled) && (privacy == 0)) {
RTW_INFO("desired_encmode: %d, privacy: %d\n", desired_encmode, privacy);
bselected = _FALSE;
}
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) {
if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
bselected = _FALSE;
}
#ifdef CONFIG_RTW_MBO
if (rtw_mbo_disallowed_network(pnetwork) == _TRUE)
bselected = _FALSE;
#endif
return bselected;
}
static void free_scanqueue(struct mlme_priv *pmlmepriv)
{
_queue *free_queue = &pmlmepriv->free_bss_pool;
_queue *scan_queue = &pmlmepriv->scanned_queue;
_list *plist, *phead, *ptemp;
_rtw_spinlock_bh(&scan_queue->lock);
_rtw_spinlock_bh(&free_queue->lock);
phead = get_list_head(scan_queue);
plist = get_next(phead);
while (plist != phead) {
ptemp = get_next(plist);
rtw_list_delete(plist);
rtw_list_insert_tail(plist, &free_queue->queue);
plist = ptemp;
pmlmepriv->num_of_scanned--;
}
_rtw_spinunlock_bh(&free_queue->lock);
_rtw_spinunlock_bh(&scan_queue->lock);
}
void rtw_reset_rx_info(_adapter *adapter)
{
struct recv_info *precvinfo = &adapter->recvinfo;
precvinfo->dbg_rx_ampdu_drop_count = 0;
precvinfo->dbg_rx_ampdu_forced_indicate_count = 0;
precvinfo->dbg_rx_ampdu_loss_count = 0;
precvinfo->dbg_rx_dup_mgt_frame_drop_count = 0;
precvinfo->dbg_rx_ampdu_window_shift_cnt = 0;
precvinfo->dbg_rx_drop_count = 0;
precvinfo->dbg_rx_conflic_mac_addr_cnt = 0;
}
/*
* Note: There may be I/O in following functions:
* rtw_free_stainfo()
* rtw_init_self_stainfo()
*/
void rtw_free_assoc_resources(_adapter *adapter, u8 lock_scanned_queue)
{
struct wlan_network *pwlan = NULL;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct wlan_network *tgt_network = &pmlmepriv->cur_network;
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &adapter->tdlsinfo;
#endif /* CONFIG_TDLS */
RTW_INFO("%s-"ADPT_FMT" tgt_network MacAddress=" MAC_FMT" ssid=%s\n",
__func__, ADPT_ARG(adapter), MAC_ARG(tgt_network->network.MacAddress), tgt_network->network.Ssid.Ssid);
if (MLME_IS_STA(adapter)) {
struct sta_info *psta;
psta = rtw_get_stainfo(&adapter->stapriv, tgt_network->network.MacAddress);
if (!psta) {
RTW_WARN("[TODO]" FUNC_ADPT_FMT ": fail to find stainfo"
"(" MAC_FMT ")\n",
FUNC_ADPT_ARG(adapter),
MAC_ARG(tgt_network->network.MacAddress));
}
#ifdef CONFIG_TDLS
rtw_free_all_tdls_sta(adapter, _TRUE);
rtw_reset_tdls_info(adapter);
if (ptdlsinfo->link_established == _TRUE)
rtw_tdls_cmd(adapter, NULL, TDLS_RS_RCR);
#endif /* CONFIG_TDLS */
/* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
rtw_free_stainfo(adapter, psta);
rtw_init_self_stainfo(adapter);
/* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
}
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE)) {
struct sta_info *psta;
rtw_free_all_stainfo(adapter);
}
if (lock_scanned_queue)
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS) || (pmlmepriv->wpa_phase == _TRUE)){
RTW_INFO("Dont free disconnecting network of scanned_queue due to uner %s %s phase\n\n",
check_fwstate(pmlmepriv, WIFI_UNDER_WPS) ? "WPS" : "",
(pmlmepriv->wpa_phase == _TRUE) ? "WPA" : "");
} else {
pwlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, tgt_network);
if (pwlan) {
pwlan->fixed = _FALSE;
RTW_INFO("Free disconnecting network of scanned_queue\n");
rtw_free_network_nolock(adapter, pwlan);
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(&adapter->wdinfo, P2P_ROLE_CLIENT) ||
rtw_p2p_chk_role(&adapter->wdinfo, P2P_ROLE_GO)) {
rtw_set_scan_deny(adapter, 2000);
/* rtw_clear_scan_deny(adapter); */
}
#endif /* CONFIG_P2P */
} else
RTW_ERR("Free disconnecting network of scanned_queue failed due to pwlan == NULL\n\n");
}
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) && (adapter->stapriv.asoc_sta_count == 1))
/*||MLME_IS_STA(adapter)*/) {
if (pwlan)
rtw_free_network_nolock(adapter, pwlan);
}
if (lock_scanned_queue)
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
adapter->securitypriv.key_mask = 0;
rtw_reset_rx_info(adapter);
}
/*
*rtw_indicate_connect: the caller has to lock pmlmepriv->lock
*/
void rtw_indicate_connect(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
pmlmepriv->to_join = _FALSE;
if (!check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)) {
set_fwstate(pmlmepriv, WIFI_ASOC_STATE);
rtw_led_control(padapter, LED_CTL_LINK);
rtw_os_indicate_connect(padapter);
#ifdef CONFIG_RTW_WDS
if (MLME_IS_STA(padapter))
rtw_wds_gptr_tbl_init(padapter);
#endif
}
rtw_set_to_roam(padapter, 0);
if (!MLME_IS_AP(padapter) && !MLME_IS_MESH(padapter))
rtw_mi_set_scan_deny(padapter, 3000);
}
/*
*rtw_indicate_disconnect: the caller has to lock pmlmepriv->lock
*/
void rtw_indicate_disconnect(_adapter *padapter, u16 reason, u8 locally_generated)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
u8 *wps_ie = NULL;
uint wpsie_len = 0;
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS))
pmlmepriv->wpa_phase = _TRUE;
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING | WIFI_UNDER_WPS | WIFI_OP_CH_SWITCHING | WIFI_UNDER_KEY_HANDSHAKE);
/* force to clear cur_network_scanned's SELECTED REGISTRAR */
if (pmlmepriv->cur_network_scanned) {
WLAN_BSSID_EX *current_joined_bss = &(pmlmepriv->cur_network_scanned->network);
if (current_joined_bss) {
wps_ie = rtw_get_wps_ie(current_joined_bss->IEs + _FIXED_IE_LENGTH_,
current_joined_bss->IELength - _FIXED_IE_LENGTH_, NULL, &wpsie_len);
if (wps_ie && wpsie_len > 0) {
u8 *attr = NULL;
u32 attr_len;
attr = rtw_get_wps_attr(wps_ie, wpsie_len, WPS_ATTR_SELECTED_REGISTRAR,
NULL, &attr_len);
if (attr)
*(attr + 4) = 0;
}
}
}
/* RTW_INFO("clear wps when %s\n", __func__); */
if (rtw_to_roam(padapter) > 0)
_clr_fwstate_(pmlmepriv, WIFI_ASOC_STATE);
#ifdef CONFIG_WAPI_SUPPORT
if (MLME_IS_STA(padapter))
rtw_wapi_return_one_sta_info(padapter, NULL);
else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) ||
check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))
rtw_wapi_return_all_sta_info(padapter);
#endif
if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)
|| (rtw_to_roam(padapter) <= 0)
) {
#ifdef CONFIG_RTW_WDS
adapter_set_use_wds(padapter, 0);
rtw_wds_gptr_tbl_unregister(padapter);
#endif
#ifdef CONFIG_RTW_MULTI_AP
padapter->multi_ap = 0;
#endif
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (ATOMIC_READ(&padapter->tbtx_tx_pause) == _TRUE) {
ATOMIC_SET(&padapter->tbtx_tx_pause, _FALSE);
rtw_tx_control_cmd(padapter);
}
#endif
/* rtw_phl_chanctx_del(adapter_to_dvobj(padapter)->phl, padapter->phl_role, NULL); */
rtw_os_indicate_disconnect(padapter, reason, locally_generated);
/* set ips_deny_time to avoid enter IPS before LPS leave */
rtw_set_ips_deny(padapter, 3000);
_clr_fwstate_(pmlmepriv, WIFI_ASOC_STATE);
rtw_led_control(padapter, LED_CTL_NO_LINK);
rtw_clear_scan_deny(padapter);
}
#ifdef CONFIG_P2P_PS
p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
#endif /* CONFIG_P2P_PS */
#ifdef CONFIG_LPS
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 0);
#endif
}
inline void rtw_indicate_scan_done(_adapter *padapter, bool aborted)
{
RTW_INFO(FUNC_ADPT_FMT" aborted=%d\n", FUNC_ADPT_ARG(padapter), aborted);
rtw_os_indicate_scan_done(padapter, aborted);
#ifdef CONFIG_IPS
if (is_primary_adapter(padapter)
&& (_FALSE == adapter_to_pwrctl(padapter)->bInSuspend)
&& (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE | WIFI_UNDER_LINKING) == _FALSE)) {
struct pwrctrl_priv *pwrpriv;
pwrpriv = adapter_to_pwrctl(padapter);
rtw_set_ips_deny(padapter, 0);
#ifdef CONFIG_IPS_CHECK_IN_WD
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
_set_timer(&adapter_to_dvobj(padapter)->dynamic_chk_timer, 1);
#endif
#else /* !CONFIG_IPS_CHECK_IN_WD */
_rtw_set_pwr_state_check_timer(pwrpriv, 1);
#endif /* !CONFIG_IPS_CHECK_IN_WD */
}
#endif /* CONFIG_IPS */
}
static u32 _rtw_wait_join_done(_adapter *adapter, u8 abort, u32 timeout_ms)
{
systime start;
u32 pass_ms;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
start = rtw_get_current_time();
pmlmeext->join_abort = abort;
if (abort)
set_link_timer(pmlmeext, 1);
while (rtw_get_passing_time_ms(start) <= timeout_ms
&& (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)
#ifdef CONFIG_IOCTL_CFG80211
|| rtw_cfg80211_is_connect_requested(adapter)
#endif
)
) {
if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
break;
RTW_INFO(FUNC_ADPT_FMT" linking...\n", FUNC_ADPT_ARG(adapter));
rtw_msleep_os(20);
}
if (abort) {
if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)
#ifdef CONFIG_IOCTL_CFG80211
|| rtw_cfg80211_is_connect_requested(adapter)
#endif
) {
if (!RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
RTW_INFO(FUNC_ADPT_FMT" waiting for join_abort time out!\n", FUNC_ADPT_ARG(adapter));
}
}
pmlmeext->join_abort = 0;
pass_ms = rtw_get_passing_time_ms(start);
return pass_ms;
}
u32 rtw_join_abort_timeout(_adapter *adapter, u32 timeout_ms)
{
return _rtw_wait_join_done(adapter, _TRUE, timeout_ms);
}
static struct sta_info *rtw_joinbss_update_stainfo(_adapter *padapter, struct wlan_network *pnetwork)
{
int i;
struct sta_info *psta = NULL;
struct recv_reorder_ctrl *preorder_ctrl;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
#if defined(CONFIG_RTW_MULTI_AP) || defined(CONFIG_RTS_FULL_BW)
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#endif
#ifdef CONFIG_RTS_FULL_BW
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
#endif/*CONFIG_RTS_FULL_BW*/
psta = rtw_get_stainfo(pstapriv, pnetwork->network.MacAddress);
if (psta == NULL) {
RTW_ERR("%s: can not find "MAC_FMT"\n", __func__, MAC_ARG(pnetwork->network.MacAddress));
psta = rtw_alloc_stainfo(pstapriv, pnetwork->network.MacAddress);
}
if (psta) { /* update ptarget_sta */
RTW_INFO("%s\n", __FUNCTION__);
/* assign aid */
psta->phl_sta->aid = pnetwork->join_res;
update_sta_info(padapter, psta);
/* update station supportRate */
psta->bssratelen = rtw_get_rateset_len(pnetwork->network.SupportedRates);
_rtw_memcpy(psta->bssrateset, pnetwork->network.SupportedRates, psta->bssratelen);
update_sta_ra_info(padapter, psta);
psta->phl_sta->wmode = pmlmeext->cur_wireless_mode;
/* security related */
#ifdef CONFIG_RTW_80211R
if ((padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
&& (psta->ft_pairwise_key_installed == _FALSE))
#else
if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
#endif
{
u8 *ie;
sint ie_len;
u8 mfp_opt = MFP_NO;
u8 spp_opt = 0;
padapter->securitypriv.binstallGrpkey = _FALSE;
padapter->securitypriv.busetkipkey = _FALSE;
padapter->securitypriv.bgrpkey_handshake = _FALSE;
ie = rtw_get_ie(pnetwork->network.IEs + _BEACON_IE_OFFSET_, WLAN_EID_RSN
, &ie_len, (pnetwork->network.IELength - _BEACON_IE_OFFSET_));
if (ie && ie_len > 0
&& rtw_parse_wpa2_ie(ie, ie_len + 2, NULL, NULL, NULL, NULL, &mfp_opt, &spp_opt) == _SUCCESS
) {
if (padapter->securitypriv.mfp_opt >= MFP_OPTIONAL && mfp_opt >= MFP_OPTIONAL)
psta->flags |= WLAN_STA_MFP;
}
if (padapter->securitypriv.dot11PrivacyAlgrthm != _NO_PRIVACY_ ) {
/*check if amsdu is allowed */
if (rtw_check_amsdu_disable(padapter->registrypriv.amsdu_mode, spp_opt) == _TRUE)
psta->flags |= WLAN_STA_AMSDU_DISABLE;
}
psta->ieee8021x_blocked = _TRUE;
psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
_rtw_memset((u8 *)&psta->dot118021x_UncstKey, 0, sizeof(union Keytype));
_rtw_memset((u8 *)&psta->dot11tkiprxmickey, 0, sizeof(union Keytype));
_rtw_memset((u8 *)&psta->dot11tkiptxmickey, 0, sizeof(union Keytype));
}
/* Commented by Albert 2012/07/21 */
/* When doing the WPS, the wps_ie_len won't equal to 0 */
/* And the Wi-Fi driver shouldn't allow the data packet to be tramsmitted. */
if (padapter->securitypriv.wps_ie_len != 0) {
psta->ieee8021x_blocked = _TRUE;
padapter->securitypriv.wps_ie_len = 0;
}
/* for A-MPDU Rx reordering buffer control for sta_info */
/* if A-MPDU Rx is enabled, reseting rx_ordering_ctrl wstart_b(indicate_seq) to default value=0xffff */
/* todo: check if AP can send A-MPDU packets */
for (i = 0; i < 16 ; i++) {
preorder_ctrl = &psta->recvreorder_ctrl[i];
preorder_ctrl->enable = _FALSE;
preorder_ctrl->indicate_seq = 0xffff;
rtw_clear_bit(RTW_RECV_ACK_OR_TIMEOUT, &preorder_ctrl->rec_abba_rsp_ack);
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_CLEAR indicate_seq:%u preorder_ctrl->rec_abba_rsp_ack:%lu\n"
, FUNC_ADPT_ARG(padapter)
, i
, preorder_ctrl->indicate_seq
,preorder_ctrl->rec_abba_rsp_ack
);
#endif
#ifdef CONFIG_RECV_REORDERING_CTRL
preorder_ctrl->wsize_b = 64;/* max_ampdu_sz; */ /* ex. 32(kbytes) -> wsize_b=32 */
#endif
preorder_ctrl->ampdu_size = RX_AMPDU_SIZE_INVALID;
}
#ifdef CONFIG_RTW_80211K
_rtw_memcpy(&psta->rm_en_cap, pnetwork->network.PhyInfo.rm_en_cap, 5);
#endif
#ifdef CONFIG_RTW_MULTI_AP
if (padapter->multi_ap & MULTI_AP_BACKHAUL_STA) {
u8 multi_ap = rtw_get_multi_ap_ie_ext(pmlmepriv->assoc_rsp + sizeof(struct rtw_ieee80211_hdr_3addr) + 6
, pmlmepriv->assoc_rsp_len - sizeof(struct rtw_ieee80211_hdr_3addr) - 6);
if (multi_ap & MULTI_AP_BACKHAUL_BSS) /* backhaul bss, enable WDS */
psta->flags |= WLAN_STA_MULTI_AP | WLAN_STA_WDS;
else if (multi_ap & MULTI_AP_FRONTHAUL_BSS) /* fronthaul bss only */
psta->flags |= WLAN_STA_MULTI_AP;
}
#endif
#ifdef CONFIG_RTS_FULL_BW
rtw_parse_sta_vendor_ie_8812(padapter, psta, BSS_EX_TLV_IES(&cur_network->network), BSS_EX_TLV_IES_LEN(&cur_network->network));
#endif
}
return psta;
}
/* pnetwork : returns from rtw_joinbss_event_callback
* ptarget_wlan: found from scanned_queue */
static void rtw_joinbss_update_network(_adapter *padapter, struct wlan_network *ptarget_wlan, struct wlan_network *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
sint tmp_fw_state = 0x0;
RTW_INFO("%s\n", __FUNCTION__);
/* why not use ptarget_wlan?? */
_rtw_memcpy(&cur_network->network, &pnetwork->network, pnetwork->network.Length);
/* some IEs in pnetwork is wrong, so we should use ptarget_wlan IEs */
cur_network->network.IELength = ptarget_wlan->network.IELength;
_rtw_memcpy(&cur_network->network.IEs[0], &ptarget_wlan->network.IEs[0], MAX_IE_SZ);
cur_network->aid = pnetwork->join_res;
#ifdef CONFIG_SIGNAL_STAT_PROCESS
rtw_set_signal_stat_timer(&padapter->recvinfo);
#endif
/*RTW_WKARD_CORE_RSSI_V1 - GEORGIA MUST REFINE*/
padapter->recvinfo.signal_strength = ptarget_wlan->network.PhyInfo.SignalStrength;
padapter->recvinfo.signal_qual = ptarget_wlan->network.PhyInfo.SignalQuality;
/* the ptarget_wlan->network.PhyInfo.rssi is raw data, we use ptarget_wlan->network.PhyInfo.SignalStrength instead (has scaled) */
padapter->recvinfo.rssi = ptarget_wlan->network.PhyInfo.rssi;
#if defined(DBG_RX_SIGNAL_DISPLAY_PROCESSING) && 1
RTW_INFO(FUNC_ADPT_FMT" signal_strength:%3u, rssi:%3d, signal_qual:%3u"
"\n"
, FUNC_ADPT_ARG(padapter)
, padapter->recvinfo.signal_strength
, padapter->recvinfo.rssi
, padapter->recvinfo.signal_qual
);
#endif
#ifdef CONFIG_SIGNAL_STAT_PROCESS
rtw_set_signal_stat_timer(&padapter->recvinfo);
#endif
/* update fw_state */ /* will clr WIFI_UNDER_LINKING here indirectly */
switch (pnetwork->network.InfrastructureMode) {
case Ndis802_11Infrastructure:
/* Check encryption */
if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
tmp_fw_state = tmp_fw_state | WIFI_UNDER_KEY_HANDSHAKE;
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS))
tmp_fw_state = tmp_fw_state | WIFI_UNDER_WPS;
init_fwstate(pmlmepriv, WIFI_STATION_STATE | tmp_fw_state);
break;
case Ndis802_11IBSS:
/*pmlmepriv->fw_state = WIFI_ADHOC_STATE;*/
init_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
break;
default:
/*pmlmepriv->fw_state = WIFI_NULL_STATE;*/
init_fwstate(pmlmepriv, WIFI_NULL_STATE);
break;
}
rtw_update_protection(padapter, (cur_network->network.IEs) + sizeof(NDIS_802_11_FIXED_IEs),
(cur_network->network.IELength));
#ifdef CONFIG_80211N_HT
rtw_update_ht_cap(padapter, cur_network->network.IEs, cur_network->network.IELength, (u8) cur_network->network.Configuration.DSConfig);
#endif
}
/* Notes: the fucntion could be > passive_level (the same context as Rx tasklet)
* pnetwork : returns from rtw_joinbss_event_callback
* ptarget_wlan: found from scanned_queue
* if join_res > 0, for (fw_state==WIFI_STATION_STATE), we check if "ptarget_sta" & "ptarget_wlan" exist.
* if join_res > 0, for (fw_state==WIFI_ADHOC_STATE), we only check if "ptarget_wlan" exist.
* if join_res > 0, update "cur_network->network" from "pnetwork->network" if (ptarget_wlan !=NULL).
*/
/* #define REJOIN */
void rtw_joinbss_event_prehandle(_adapter *adapter, u8 *pbuf, u16 status)
{
static u8 retry = 0;
struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL;
unsigned int the_same_macaddr = _FALSE;
rtw_get_encrypt_decrypt_from_registrypriv(adapter);
the_same_macaddr = _rtw_memcmp(pnetwork->network.MacAddress, cur_network->network.MacAddress, ETH_ALEN);
pnetwork->network.Length = get_WLAN_BSSID_EX_sz(&pnetwork->network);
if (pnetwork->network.Length > sizeof(WLAN_BSSID_EX))
goto exit;
_rtw_spinlock_bh(&pmlmepriv->lock);
pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
if (pnetwork->join_res > 0) {
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
retry = 0;
if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) {
/* s1. find ptarget_wlan */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) {
if (the_same_macaddr == _TRUE)
ptarget_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
else {
pcur_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
if (pcur_wlan)
pcur_wlan->fixed = _FALSE;
pcur_sta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
if (pcur_sta) {
/* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
rtw_free_stainfo(adapter, pcur_sta);
/* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
}
ptarget_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->network.MacAddress);
if (MLME_IS_STA(adapter)) {
if (ptarget_wlan)
ptarget_wlan->fixed = _TRUE;
}
}
} else {
ptarget_wlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, pnetwork);
if (MLME_IS_STA(adapter)) {
if (ptarget_wlan)
ptarget_wlan->fixed = _TRUE;
}
}
/* s2. update cur_network */
if (ptarget_wlan)
rtw_joinbss_update_network(adapter, ptarget_wlan, pnetwork);
else {
RTW_PRINT("Can't find ptarget_wlan when joinbss_event callback\n");
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
goto ignore_joinbss_callback;
}
/* s3. find ptarget_sta & update ptarget_sta after update cur_network only for station mode */
if (MLME_IS_STA(adapter)) {
ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork);
if (ptarget_sta == NULL) {
RTW_ERR("Can't update stainfo when joinbss_event callback\n");
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
goto ignore_joinbss_callback;
}
/* Queue TX packets before FW/HW ready */
/* clear in mlmeext_joinbss_event_callback() */
rtw_xmit_queue_set(ptarget_sta);
}
/* s4. indicate connect */
if (MLME_IS_STA(adapter) || MLME_IS_ADHOC(adapter)) {
pmlmepriv->cur_network_scanned = ptarget_wlan;
rtw_indicate_connect(adapter);
}
/* s5. Cancle assoc_timer */
/*_cancel_timer_ex(&pmlmepriv->assoc_timer);*/
cancel_assoc_timer(pmlmepriv);
} else {
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
goto ignore_joinbss_callback;
}
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
} else if (pnetwork->join_res == -4) {
rtw_reset_securitypriv(adapter);
pmlmepriv->join_status = status;
/*_set_timer(&pmlmepriv->assoc_timer, 1);*/
set_assoc_timer(pmlmepriv, 1);
/* rtw_free_assoc_resources(adapter, _TRUE); */
if ((check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) == _TRUE) {
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
}
} else { /* if join_res < 0 (join fails), then try again */
#ifdef REJOIN
res = _FAIL;
if (retry < 2) {
res = rtw_select_and_join_from_scanned_queue(pmlmepriv);
}
if (res == _SUCCESS) {
/* extend time of assoc_timer */
/*_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);*/
set_assoc_timer(pmlmepriv, MAX_JOIN_TIMEOUT);
retry++;
} else if (res == 2) { /* there is no need to wait for join */
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
rtw_indicate_connect(adapter);
} else {
#endif
pmlmepriv->join_status = status;
/*_set_timer(&pmlmepriv->assoc_timer, 1);*/
set_assoc_timer(pmlmepriv, 1);
/* rtw_free_assoc_resources(adapter, _TRUE); */
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
#ifdef REJOIN
retry = 0;
}
#endif
}
ignore_joinbss_callback:
_rtw_spinunlock_bh(&pmlmepriv->lock);
exit:
return;
}
void rtw_joinbss_event_callback(_adapter *adapter, u8 *pbuf)
{
struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
rtw_set_hw_after_join(adapter, pnetwork->join_res);
rtw_mi_os_xmit_schedule(adapter);
}
void rtw_sta_media_status_rpt(_adapter *adapter, struct sta_info *sta, bool connected)
{
/* ToDo H2C */
#if 0
struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
bool miracast_enabled = 0;
bool miracast_sink = 0;
u8 role = H2C_MSR_ROLE_RSVD;
if (sta == NULL) {
RTW_PRINT(FUNC_ADPT_FMT" sta is NULL\n"
, FUNC_ADPT_ARG(adapter));
rtw_warn_on(1);
return;
}
if (sta->phl_sta->macid >= macid_ctl->num) {
RTW_PRINT(FUNC_ADPT_FMT" invalid macid:%u\n"
, FUNC_ADPT_ARG(adapter), sta->phl_sta->macid);
rtw_warn_on(1);
return;
}
if (!rtw_macid_is_used(macid_ctl, sta->phl_sta->macid)) {
RTW_PRINT(FUNC_ADPT_FMT" macid:%u not is used, set connected to 0\n"
, FUNC_ADPT_ARG(adapter), sta->phl_sta->macid);
connected = 0;
rtw_warn_on(1);
}
if (connected && !rtw_macid_is_bmc(macid_ctl, sta->phl_sta->macid)) {
miracast_enabled = STA_OP_WFD_MODE(sta) != 0 && is_miracast_enabled(adapter);
miracast_sink = miracast_enabled && (STA_OP_WFD_MODE(sta) & MIRACAST_SINK);
#ifdef CONFIG_TDLS
if (sta->tdls_sta_state & TDLS_LINKED_STATE)
role = H2C_MSR_ROLE_TDLS;
else
#endif
if (MLME_IS_STA(adapter)) {
if (MLME_IS_GC(adapter))
role = H2C_MSR_ROLE_GO;
else
role = H2C_MSR_ROLE_AP;
} else if (MLME_IS_AP(adapter)) {
if (MLME_IS_GO(adapter))
role = H2C_MSR_ROLE_GC;
else
role = H2C_MSR_ROLE_STA;
} else if (MLME_IS_ADHOC(adapter) || MLME_IS_ADHOC_MASTER(adapter))
role = H2C_MSR_ROLE_ADHOC;
else if (MLME_IS_MESH(adapter))
role = H2C_MSR_ROLE_MESH;
#ifdef CONFIG_WFD
if (role == H2C_MSR_ROLE_GC
|| role == H2C_MSR_ROLE_GO
|| role == H2C_MSR_ROLE_TDLS
) {
if (adapter->wfd_info.rtsp_ctrlport
|| adapter->wfd_info.tdls_rtsp_ctrlport
|| adapter->wfd_info.peer_rtsp_ctrlport)
rtw_wfd_st_switch(sta, 1);
}
#endif
}
rtw_hal_set_FwMediaStatusRpt_single_cmd(adapter
, connected
, miracast_enabled
, miracast_sink
, role
, sta->phl_sta->macid
);
#endif
}
u8 rtw_sta_media_status_rpt_cmd(_adapter *adapter, struct sta_info *sta, bool connected)
{
struct cmd_priv *cmdpriv = &adapter_to_dvobj(adapter)->cmdpriv;
struct cmd_obj *cmdobj;
struct drvextra_cmd_parm *cmd_parm;
struct sta_media_status_rpt_cmd_parm *rpt_parm;
u8 res = _SUCCESS;
cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmdobj == NULL) {
res = _FAIL;
goto exit;
}
cmdobj->padapter = adapter;
cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (cmd_parm == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
rpt_parm = (struct sta_media_status_rpt_cmd_parm *)rtw_zmalloc(sizeof(struct sta_media_status_rpt_cmd_parm));
if (rpt_parm == NULL) {
rtw_mfree((u8 *)cmdobj, sizeof(struct cmd_obj));
rtw_mfree((u8 *)cmd_parm, sizeof(struct drvextra_cmd_parm));
res = _FAIL;
goto exit;
}
rpt_parm->sta = sta;
rpt_parm->connected = connected;
cmd_parm->ec_id = STA_MSTATUS_RPT_WK_CID;
cmd_parm->type = 0;
cmd_parm->size = sizeof(struct sta_media_status_rpt_cmd_parm);
cmd_parm->pbuf = (u8 *)rpt_parm;
init_h2fwcmd_w_parm_no_rsp(cmdobj, cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(cmdpriv, cmdobj);
exit:
return res;
}
inline void rtw_sta_media_status_rpt_cmd_hdl(_adapter *adapter, struct sta_media_status_rpt_cmd_parm *parm)
{
rtw_sta_media_status_rpt(adapter, parm->sta, parm->connected);
}
void rtw_stassoc_event_callback(_adapter *adapter, u8 *pbuf)
{
struct sta_info *psta;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct wlan_network *ptarget_wlan = NULL;
#if CONFIG_RTW_MACADDR_ACL
if (rtw_access_ctrl(adapter, pstassoc->macaddr) == _FALSE)
return;
#endif
#if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
if (MLME_IS_AP(adapter) || MLME_IS_MESH(adapter)) {
psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
if (psta) {
u8 *passoc_req = NULL;
u32 assoc_req_len = 0;
rtw_alloc_stainfo_hw(&adapter->stapriv, psta);
#if 0
rtw_sta_media_status_rpt(adapter, psta, 1);
#else
rtw_hw_connected_apmode(adapter, psta);
#endif
#ifndef CONFIG_AUTO_AP_MODE
if (!MLME_IS_MESH(adapter)) {
/* report to upper layer */
RTW_INFO("indicate_sta_assoc_event to upper layer - hostapd\n");
#ifdef CONFIG_IOCTL_CFG80211
_rtw_spinlock_bh(&psta->lock);
if (psta->passoc_req && psta->assoc_req_len > 0) {
passoc_req = rtw_zmalloc(psta->assoc_req_len);
if (passoc_req) {
assoc_req_len = psta->assoc_req_len;
_rtw_memcpy(passoc_req, psta->passoc_req, assoc_req_len);
}
}
_rtw_spinunlock_bh(&psta->lock);
if (passoc_req && assoc_req_len > 0) {
rtw_cfg80211_indicate_sta_assoc(adapter, passoc_req, assoc_req_len);
rtw_mfree(passoc_req, assoc_req_len);
}
#else /* !CONFIG_IOCTL_CFG80211 */
rtw_indicate_sta_assoc_event(adapter, psta);
#endif /* !CONFIG_IOCTL_CFG80211 */
}
#endif /* !CONFIG_AUTO_AP_MODE */
if (is_wep_enc(adapter->securitypriv.dot11PrivacyAlgrthm))
rtw_ap_wep_pk_setting(adapter, psta);
}
goto exit;
}
#endif /* defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME) */
/* for AD-HOC mode */
psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
if (psta == NULL) {
RTW_ERR(FUNC_ADPT_FMT" get no sta_info with "MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(pstassoc->macaddr));
rtw_warn_on(1);
goto exit;
}
rtw_sta_media_status_rpt(adapter, psta, 1);
if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
psta->dot118021XPrivacy = adapter->securitypriv.dot11PrivacyAlgrthm;
psta->ieee8021x_blocked = _FALSE;
_rtw_spinlock_bh(&pmlmepriv->lock);
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE)) {
if (adapter->stapriv.asoc_sta_count == 2) {
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
ptarget_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
pmlmepriv->cur_network_scanned = ptarget_wlan;
if (ptarget_wlan)
ptarget_wlan->fixed = _TRUE;
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
/* a sta + bc/mc_stainfo (not Ibss_stainfo) */
rtw_indicate_connect(adapter);
}
}
_rtw_spinunlock_bh(&pmlmepriv->lock);
mlmeext_sta_add_event_callback(adapter, psta);
#ifdef CONFIG_RTL8711
/* submit SetStaKey_cmd to tell fw, fw will allocate an CAM entry for this sta */
rtw_setstakey_cmd(adapter, psta, GROUP_KEY, _TRUE);
#endif
exit:
#ifdef CONFIG_RTS_FULL_BW
rtw_set_rts_bw(adapter);
#endif/*CONFIG_RTS_FULL_BW*/
return;
}
#ifdef CONFIG_IEEE80211W
void rtw_sta_timeout_event_callback(_adapter *adapter, u8 *pbuf)
{
struct sta_info *psta;
struct stadel_event *pstadel = (struct stadel_event *)pbuf;
struct sta_priv *pstapriv = &adapter->stapriv;
psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr);
if (psta) {
u8 updated = _FALSE;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
rtw_list_delete(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (psta->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt--;
#endif
updated = ap_free_sta(adapter, psta, _TRUE, WLAN_REASON_PREV_AUTH_NOT_VALID, _TRUE, _FALSE);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
associated_clients_update(adapter, updated, STA_INFO_UPDATE_ALL);
}
}
#endif /* CONFIG_IEEE80211W */
/* Note: the caller should already have lock of a->mlmepriv.lock */
/* Note2: There may be I/O in rtw_free_assoc_resources() */
static void _stadel_posthandle_sta(struct _ADAPTER *a,
struct stadel_event *stadel)
{
struct mlme_priv *mlme = &a->mlmepriv;
u16 reason = *((unsigned short *)stadel->rsvd);
bool roam = _FALSE;
struct wlan_network *roam_target = NULL;
#ifdef CONFIG_LAYER2_ROAMING
#ifdef CONFIG_RTW_80211R
if (rtw_ft_roam_expired(a, reason))
mlme->ft_roam.ft_roam_on_expired = _TRUE;
else
mlme->ft_roam.ft_roam_on_expired = _FALSE;
#endif
if (a->registrypriv.wifi_spec == 1) {
roam = _FALSE;
} else if ((reason == WLAN_REASON_EXPIRATION_CHK)
&& rtw_chk_roam_flags(a, RTW_ROAM_ON_EXPIRED)) {
roam = _TRUE;
} else if ((reason == WLAN_REASON_ACTIVE_ROAM)
&& rtw_chk_roam_flags(a, RTW_ROAM_ACTIVE)) {
roam = _TRUE;
roam_target = mlme->roam_network;
}
#ifdef CONFIG_RTW_80211R
if ((reason == WLAN_REASON_ACTIVE_ROAM)
&& rtw_ft_chk_flags(a, RTW_FT_BTM_ROAM)) {
roam = _TRUE;
roam_target = mlme->roam_network;
}
#endif
if (roam == _TRUE) {
if (rtw_to_roam(a) > 0)
rtw_dec_to_roam(a); /* this stadel_event is caused by roaming, decrease to_roam */
else if (rtw_to_roam(a) == 0)
rtw_set_to_roam(a, a->registrypriv.max_roaming_times);
} else {
rtw_set_to_roam(a, 0);
}
#endif /* CONFIG_LAYER2_ROAMING */
#if 0
rtw_free_uc_swdec_pending_queue(adapter_to_dvobj(a));
#endif
if (MLME_IS_ASOC(a))
rtw_free_assoc_resources(a, _TRUE);
rtw_free_mlme_priv_ie_data(mlme);
rtw_indicate_disconnect(a, *(u16 *)stadel->rsvd, stadel->locally_generated);
_rtw_roaming(a, roam_target);
}
void rtw_stadel_event_callback(_adapter *adapter, u8 *pbuf)
{
struct sta_info *psta;
struct wlan_network *pwlan = NULL;
WLAN_BSSID_EX *pdev_network = NULL;
u8 *pibss = NULL;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct stadel_event *pstadel = (struct stadel_event *)pbuf;
struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
RTW_INFO("%s(mac_id=%d)=" MAC_FMT "\n", __func__, pstadel->mac_id, MAC_ARG(pstadel->macaddr));
psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr);
if (psta == NULL) {
RTW_INFO("%s(mac_id=%d)=" MAC_FMT " psta == NULL\n", __func__, pstadel->mac_id, MAC_ARG(pstadel->macaddr));
/*rtw_warn_on(1);*/
}
if (psta) {
rtw_wfd_st_switch(psta, 0);
psta->hw_decrypted = _FALSE;
}
if (MLME_IS_MESH(adapter)) {
rtw_free_stainfo(adapter, psta);
goto exit;
}
if (MLME_IS_AP(adapter)) {
#ifdef CONFIG_IOCTL_CFG80211
#ifdef COMPAT_KERNEL_RELEASE
#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37)) || defined(CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER)
rtw_cfg80211_indicate_sta_disassoc(adapter, pstadel->macaddr, *(u16 *)pstadel->rsvd);
#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37)) || defined(CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER) */
#endif /* CONFIG_IOCTL_CFG80211 */
rtw_hw_disconnect(adapter, psta);
rtw_free_stainfo(adapter, psta);
goto exit;
}
mlmeext_sta_del_event_callback(adapter);
_rtw_spinlock_bh(&pmlmepriv->lock);
if (MLME_IS_STA(adapter))
_stadel_posthandle_sta(adapter, pstadel);
if (MLME_IS_ADHOC_MASTER(adapter) ||
MLME_IS_ADHOC(adapter)) {
/* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
rtw_free_stainfo(adapter, psta);
/* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
if (adapter->stapriv.asoc_sta_count == 1) { /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
/* rtw_indicate_disconnect(adapter); */ /* removed@20091105 */
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
/* free old ibss network */
/* pwlan = _rtw_find_network(&pmlmepriv->scanned_queue, pstadel->macaddr); */
pwlan = _rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.MacAddress);
if (pwlan) {
pwlan->fixed = _FALSE;
rtw_free_network_nolock(adapter, pwlan);
}
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
/* re-create ibss */
pdev_network = &(adapter->registrypriv.dev_network);
pibss = adapter->registrypriv.dev_network.MacAddress;
_rtw_memcpy(pdev_network, &tgt_network->network, get_WLAN_BSSID_EX_sz(&tgt_network->network));
_rtw_memset(&pdev_network->Ssid, 0, sizeof(NDIS_802_11_SSID));
_rtw_memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
rtw_update_registrypriv_dev_network(adapter);
rtw_generate_random_ibss(pibss);
if (MLME_IS_ADHOC(adapter)) {
set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
_clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE);
}
if (rtw_create_ibss_cmd(adapter, 0) != _SUCCESS)
RTW_ERR("rtw_create_ibss_cmd FAIL\n");
}
}
_rtw_spinunlock_bh(&pmlmepriv->lock);
exit:
#ifdef CONFIG_RTS_FULL_BW
rtw_set_rts_bw(adapter);
#endif/*CONFIG_RTS_FULL_BW*/
return;
}
void rtw_wmm_event_callback(_adapter *padapter, u8 *pbuf)
{
WMMOnAssocRsp(padapter);
}
/*
* rtw_join_timeout_handler - Timeout/failure handler for CMD JoinBss
*/
void rtw_join_timeout_handler(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
#if 0
if (dev_is_drv_stopped(adapter_to_dvobj(adapter))) {
_rtw_up_sema(&pmlmepriv->assoc_terminate);
return;
}
#endif
RTW_INFO("%s, fw_state=%x\n", __FUNCTION__, get_fwstate(pmlmepriv));
if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
return;
_rtw_spinlock_bh(&pmlmepriv->lock);
#ifdef CONFIG_LAYER2_ROAMING
if (rtw_to_roam(adapter) > 0) { /* join timeout caused by roaming */
while (1) {
rtw_dec_to_roam(adapter);
if (rtw_to_roam(adapter) != 0) { /* try another */
int do_join_r;
RTW_INFO("%s try another roaming\n", __FUNCTION__);
do_join_r = rtw_do_join(adapter);
if (_SUCCESS != do_join_r) {
RTW_INFO("%s roaming do_join return %d\n", __FUNCTION__ , do_join_r);
continue;
}
break;
} else {
RTW_INFO("%s We've try roaming but fail\n", __FUNCTION__);
#ifdef CONFIG_RTW_80211R
/* rtw_ft_clr_flags(adapter, RTW_FT_PEER_EN|RTW_FT_PEER_OTD_EN); */
rtw_ft_reset_status(adapter);
#endif
rtw_indicate_disconnect(adapter, pmlmepriv->join_status, _FALSE);
#ifdef CONFIG_STA_CMD_DISPR
rtw_connect_abort(adapter);
#endif
break;
}
}
} else
#endif
{
#ifdef CONFIG_STA_CMD_DISPR
if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE)
rtw_connect_abort(adapter);
#endif /* CONFIG_STA_CMD_DISPR */
rtw_indicate_disconnect(adapter, pmlmepriv->join_status, _FALSE);
free_scanqueue(pmlmepriv);/* ??? */
#ifdef CONFIG_IOCTL_CFG80211
/* indicate disconnect for the case that join_timeout and check_fwstate != FW_LINKED */
rtw_cfg80211_indicate_disconnect(adapter, pmlmepriv->join_status, _FALSE);
#endif /* CONFIG_IOCTL_CFG80211 */
}
pmlmepriv->join_status = 0; /* reset */
_rtw_spinunlock_bh(&pmlmepriv->lock);
#ifdef CONFIG_DRVEXT_MODULE_WSC
drvext_assoc_fail_indicate(&adapter->drvextpriv);
#endif
}
void rtw_mlme_reset_auto_scan_int(_adapter *adapter, u8 *reason)
{
#if defined(CONFIG_RTW_MESH) && defined(CONFIG_DFS_MASTER)
#if CONFIG_RTW_MESH_OFFCH_CAND
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
#endif
#endif
u8 u_ch;
u32 interval_ms = 0xffffffff; /* 0xffffffff: special value to make min() works well, also means no auto scan */
*reason = RTW_AUTO_SCAN_REASON_UNSPECIFIED;
rtw_mi_get_ch_setting_union(adapter, &u_ch, NULL, NULL);
if (rtw_hw_chk_bw_cap(adapter_to_dvobj(adapter), BW_CAP_40M)
&& is_client_associated_to_ap(adapter) == _TRUE
&& u_ch >= 1 && u_ch <= 14
&& adapter->registrypriv.wifi_spec
/* TODO: AP Connected is 40MHz capability? */
) {
interval_ms = rtw_min(interval_ms, 60 * 1000);
*reason |= RTW_AUTO_SCAN_REASON_2040_BSS;
}
#ifdef CONFIG_RTW_MESH
#if CONFIG_RTW_MESH_OFFCH_CAND
if (adapter->mesh_cfg.peer_sel_policy.offch_find_int_ms
&& rtw_mesh_offch_candidate_accepted(adapter)
#ifdef CONFIG_DFS_MASTER
&& (!rfctl->radar_detect_ch || (IS_CH_WAITING(rfctl) && !IS_UNDER_CAC(rfctl)))
#endif
) {
interval_ms = rtw_min(interval_ms, adapter->mesh_cfg.peer_sel_policy.offch_find_int_ms);
*reason |= RTW_AUTO_SCAN_REASON_MESH_OFFCH_CAND;
}
#endif
#endif /* CONFIG_RTW_MESH */
if (interval_ms == 0xffffffff)
interval_ms = 0;
rtw_mlme_set_auto_scan_int(adapter, interval_ms);
return;
}
static void rtw_auto_scan_handler(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
u8 reason = RTW_AUTO_SCAN_REASON_UNSPECIFIED;
rtw_mlme_reset_auto_scan_int(padapter, &reason);
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_CLIENT) ||
rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_GO))
goto exit;
#endif
#ifdef CONFIG_TDLS
if (padapter->tdlsinfo.link_established == _TRUE)
goto exit;
#endif
if (pmlmepriv->auto_scan_int_ms == 0
|| rtw_get_passing_time_ms(pmlmepriv->scan_start_time) < pmlmepriv->auto_scan_int_ms)
goto exit;
rtw_drv_scan_by_self(padapter, reason);
exit:
return;
}
static u8 is_drv_in_lps(_adapter *adapter)
{
u8 is_in_lps = _FALSE;
#ifdef CONFIG_LPS_LCLK_WD_TIMER /* to avoid leaving lps 32k frequently*/
if ((adapter_to_pwrctl(adapter)->bFwCurrentInPSMode == _TRUE)
)
is_in_lps = _TRUE;
#endif /* CONFIG_LPS_LCLK_WD_TIMER*/
return is_in_lps;
}
void rtw_iface_dynamic_check_handlder(struct _ADAPTER *a)
{
if (!a->netif_up)
return;
/* auto site survey */
rtw_auto_scan_handler(a);
#ifdef CONFIG_BR_EXT
if (!adapter_use_wds(a)) {
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
rcu_read_lock();
#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) */
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
if (a->pnetdev->br_port
#else /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) */
if (rcu_dereference(a->pnetdev->rx_handler_data)
#endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) */
&& (MLME_IS_STA(a) || MLME_IS_ADHOC(a))) {
/* expire NAT2.5 entry */
void nat25_db_expire(_adapter *priv);
nat25_db_expire(a);
if (a->pppoe_connection_in_progress > 0)
a->pppoe_connection_in_progress--;
if (a->pppoe_connection_in_progress > 0)
a->pppoe_connection_in_progress--;
}
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
rcu_read_unlock();
#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) */
}
#endif /* CONFIG_BR_EXT */
}
void rtw_iface_dynamic_check_timer_handlder(_adapter *adapter)
{
#ifdef CONFIG_AP_MODE
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
#endif /* CONFIG_AP_MODE */
if (!adapter->netif_up)
return;
#ifdef CONFIG_LPS_LCLK_WD_TIMER /* to avoid leaving lps 32k frequently*/
if (is_drv_in_lps(adapter)) {
u8 bEnterPS;
linked_status_chk(adapter, 1);
bEnterPS = traffic_status_watchdog(adapter, 1);
#if 0 /*PS TODO ...*/
if (bEnterPS) {
/* rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_ENTER, 0); */
rtw_hal_dm_watchdog_in_lps(adapter);
} else {
/* call rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 0) in traffic_status_watchdog() */
}
#endif
}
#endif /* CONFIG_LPS_LCLK_WD_TIMER */
#ifdef CONFIG_AP_MODE
if (MLME_IS_AP(adapter)|| MLME_IS_MESH(adapter)) {
#ifndef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
expire_timeout_chk(adapter);
#endif /* !CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
#ifdef CONFIG_BMC_TX_RATE_SELECT
rtw_update_bmc_sta_tx_rate(adapter);
#endif /*CONFIG_BMC_TX_RATE_SELECT*/
}
#endif /*CONFIG_AP_MODE*/
rtw_iface_dynamic_check_handlder(adapter);
}
/*TP_avg(t) = (1/10) * TP_avg(t-1) + (9/10) * TP(t) MBps*/
static void collect_sta_traffic_statistics(_adapter *adapter)
{
/* ToDo */
#if 0
struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
struct sta_info *sta;
u64 curr_tx_bytes = 0, curr_rx_bytes = 0;
u32 curr_tx_mbytes = 0, curr_rx_mbytes = 0;
int i;
for (i = 0; i < MACID_NUM_SW_LIMIT; i++) {
sta = macid_ctl->sta[i];
if (sta && !is_broadcast_mac_addr(sta->phl_sta->mac_addr)) {
if (sta->sta_stats.last_tx_bytes > sta->sta_stats.tx_bytes)
sta->sta_stats.last_tx_bytes = sta->sta_stats.tx_bytes;
if (sta->sta_stats.last_rx_bytes > sta->sta_stats.rx_bytes)
sta->sta_stats.last_rx_bytes = sta->sta_stats.rx_bytes;
if (sta->sta_stats.last_rx_bc_bytes > sta->sta_stats.rx_bc_bytes)
sta->sta_stats.last_rx_bc_bytes = sta->sta_stats.rx_bc_bytes;
if (sta->sta_stats.last_rx_mc_bytes > sta->sta_stats.rx_mc_bytes)
sta->sta_stats.last_rx_mc_bytes = sta->sta_stats.rx_mc_bytes;
curr_tx_bytes = sta->sta_stats.tx_bytes - sta->sta_stats.last_tx_bytes;
curr_rx_bytes = sta->sta_stats.rx_bytes - sta->sta_stats.last_rx_bytes;
sta->sta_stats.tx_tp_kbits = (curr_tx_bytes * 8 / 2) >> 10;/*Kbps*/
sta->sta_stats.rx_tp_kbits = (curr_rx_bytes * 8 / 2) >> 10;/*Kbps*/
sta->sta_stats.smooth_tx_tp_kbits = (sta->sta_stats.smooth_tx_tp_kbits * 6 / 10) + (sta->sta_stats.tx_tp_kbits * 4 / 10);/*Kbps*/
sta->sta_stats.smooth_rx_tp_kbits = (sta->sta_stats.smooth_rx_tp_kbits * 6 / 10) + (sta->sta_stats.rx_tp_kbits * 4 / 10);/*Kbps*/
curr_tx_mbytes = (curr_tx_bytes / 2) >> 20;/*MBps*/
curr_rx_mbytes = (curr_rx_bytes / 2) >> 20;/*MBps*/
sta->phl_sta->tx_moving_average_tp =
(sta->phl_sta->tx_moving_average_tp / 10) + (curr_tx_mbytes * 9 / 10); /*MBps*/
sta->phl_sta->rx_moving_average_tp =
(sta->phl_sta->rx_moving_average_tp / 10) + (curr_rx_mbytes * 9 /10); /*MBps*/
rtw_collect_bcn_info(sta->padapter);
if (adapter->bsta_tp_dump)
rtw_hal_dump_sta_traffic(RTW_DBGDUMP, adapter, sta);
sta->sta_stats.last_tx_bytes = sta->sta_stats.tx_bytes;
sta->sta_stats.last_rx_bytes = sta->sta_stats.rx_bytes;
sta->sta_stats.last_rx_bc_bytes = sta->sta_stats.rx_bc_bytes;
sta->sta_stats.last_rx_mc_bytes = sta->sta_stats.rx_mc_bytes;
}
}
#endif
}
void rtw_sta_traffic_info(void *sel, _adapter *adapter)
{
/* ToDo */
#if 0
struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
struct sta_info *sta;
int i;
for (i = 0; i < MACID_NUM_SW_LIMIT; i++) {
sta = macid_ctl->sta[i];
if (sta && !is_broadcast_mac_addr(sta->phl_sta->mac_addr))
rtw_hal_dump_sta_traffic(sel, adapter, sta);
}
#endif
}
/*#define DBG_TRAFFIC_STATISTIC*/
static void collect_traffic_statistics(_adapter *padapter)
{
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
/*_rtw_memset(&pdvobjpriv->traffic_stat, 0, sizeof(struct rtw_traffic_statistics));*/
/* Tx bytes reset*/
pdvobjpriv->traffic_stat.tx_bytes = 0;
pdvobjpriv->traffic_stat.tx_pkts = 0;
pdvobjpriv->traffic_stat.tx_drop = 0;
/* Rx bytes reset*/
pdvobjpriv->traffic_stat.rx_bytes = 0;
pdvobjpriv->traffic_stat.rx_pkts = 0;
pdvobjpriv->traffic_stat.rx_drop = 0;
rtw_mi_traffic_statistics(padapter);
/* Calculate throughput in last interval */
pdvobjpriv->traffic_stat.cur_tx_bytes = pdvobjpriv->traffic_stat.tx_bytes - pdvobjpriv->traffic_stat.last_tx_bytes;
pdvobjpriv->traffic_stat.cur_rx_bytes = pdvobjpriv->traffic_stat.rx_bytes - pdvobjpriv->traffic_stat.last_rx_bytes;
pdvobjpriv->traffic_stat.last_tx_bytes = pdvobjpriv->traffic_stat.tx_bytes;
pdvobjpriv->traffic_stat.last_rx_bytes = pdvobjpriv->traffic_stat.rx_bytes;
pdvobjpriv->traffic_stat.cur_tx_tp = (u32)(pdvobjpriv->traffic_stat.cur_tx_bytes * 8 / 2 / 1024 / 1024);/*Mbps*/
pdvobjpriv->traffic_stat.cur_rx_tp = (u32)(pdvobjpriv->traffic_stat.cur_rx_bytes * 8 / 2 / 1024 / 1024);/*Mbps*/
#ifdef DBG_TRAFFIC_STATISTIC
RTW_INFO("\n========================\n");
RTW_INFO("cur_tx_bytes:%lld\n", pdvobjpriv->traffic_stat.cur_tx_bytes);
RTW_INFO("cur_rx_bytes:%lld\n", pdvobjpriv->traffic_stat.cur_rx_bytes);
RTW_INFO("last_tx_bytes:%lld\n", pdvobjpriv->traffic_stat.last_tx_bytes);
RTW_INFO("last_rx_bytes:%lld\n", pdvobjpriv->traffic_stat.last_rx_bytes);
RTW_INFO("cur_tx_tp:%d (Mbps)\n", pdvobjpriv->traffic_stat.cur_tx_tp);
RTW_INFO("cur_rx_tp:%d (Mbps)\n", pdvobjpriv->traffic_stat.cur_rx_tp);
#endif
#ifdef CONFIG_RTW_NAPI
#ifdef CONFIG_RTW_NAPI_DYNAMIC
dynamic_napi_th_chk (padapter);
#endif /* CONFIG_RTW_NAPI_DYNAMIC */
#endif
}
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
void rtw_dynamic_check_timer_handlder(void *ctx)
{
struct dvobj_priv *pdvobj = (struct dvobj_priv *)ctx;
_adapter *adapter = dvobj_get_primary_adapter(pdvobj);
if (!adapter)
goto exit;
#if (MP_DRIVER == 1)
if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) { /* for MP ODM dynamic Tx power tracking */
/* RTW_INFO("%s mp_dm =0 return\n", __func__); */
goto exit;
}
#endif
if (!rtw_hw_is_init_completed(pdvobj))
goto exit;
if (RTW_CANNOT_RUN(pdvobj))
goto exit;
collect_traffic_statistics(adapter);
collect_sta_traffic_statistics(adapter);
rtw_mi_dynamic_check_timer_handlder(adapter);
if (!is_drv_in_lps(adapter))
rtw_dynamic_chk_wk_cmd(adapter);
exit:
_set_timer(&pdvobj->dynamic_chk_timer, 2000);
}
#endif
#ifdef CONFIG_CMD_GENERAL
void rtw_core_watchdog_sw_hdlr(void *drv_priv)
{
struct dvobj_priv *pdvobj = (struct dvobj_priv *)drv_priv;
struct _ADAPTER *adapter = dvobj_get_primary_adapter(pdvobj);
if (!adapter)
goto exit;
#if (MP_DRIVER == 1)
/* for MP ODM dynamic Tx power tracking */
if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) {
/* RTW_INFO("%s mp_dm =0 return\n", __func__); */
goto exit;
}
#endif
if (!rtw_hw_is_init_completed(pdvobj))
goto exit;
collect_traffic_statistics(adapter);
collect_sta_traffic_statistics(adapter);
rtw_mi_dynamic_check_handlder(adapter);
rtw_dynamic_chk_wk_sw_hdl(adapter);
exit:
return;
}
void rtw_core_watchdog_hw_hdlr(void *drv_priv)
{
struct dvobj_priv *pdvobj = (struct dvobj_priv *)drv_priv;
struct _ADAPTER *adapter = dvobj_get_primary_adapter(pdvobj);
if (!adapter)
goto exit;
#if (MP_DRIVER == 1)
/* for MP ODM dynamic Tx power tracking */
if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) {
/* RTW_INFO("%s mp_dm =0 return\n", __func__); */
goto exit;
}
#endif
if (!rtw_hw_is_init_completed(pdvobj))
goto exit;
if (RTW_CANNOT_RUN(pdvobj))
goto exit;
rtw_dynamic_chk_wk_hw_hdl(adapter);
exit:
return;
}
#else
int rtw_dynamic_check_handlder(void *ctx, void *parm, bool discard)
{
struct dvobj_priv *pdvobj = (struct dvobj_priv *)ctx;
struct _ADAPTER *adapter = dvobj_get_primary_adapter(pdvobj);
if (!adapter)
goto exit;
#if (MP_DRIVER == 1)
/* for MP ODM dynamic Tx power tracking */
if (adapter->registrypriv.mp_mode == 1 && adapter->mppriv.mp_dm == 0) {
/* RTW_INFO("%s mp_dm =0 return\n", __func__); */
goto exit;
}
#endif
if (!rtw_hw_is_init_completed(pdvobj))
goto exit;
if (RTW_CANNOT_RUN(pdvobj))
goto exit;
collect_traffic_statistics(adapter);
collect_sta_traffic_statistics(adapter);
rtw_mi_dynamic_check_handlder(adapter);
rtw_dynamic_chk_wk_hdl(adapter);
exit:
return 0;
}
#endif
#ifdef CONFIG_LAYER2_ROAMING
/*
* Select a new roaming candidate from the original @param candidate and @param competitor
* @return _TRUE: candidate is updated
* @return _FALSE: candidate is not updated
*/
static int rtw_check_roaming_candidate(struct mlme_priv *mlme
, struct wlan_network **candidate, struct wlan_network *competitor)
{
int updated = _FALSE;
_adapter *adapter = container_of(mlme, _adapter, mlmepriv);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
RT_CHANNEL_INFO *chset = rfctl->channel_set;
u8 ch = competitor->network.Configuration.DSConfig;
if (rtw_chset_search_ch(chset, ch) < 0)
goto exit;
if (IS_DFS_SLAVE_WITH_RD(rfctl)
&& !rtw_rfctl_dfs_domain_unknown(rfctl)
&& rtw_chset_is_ch_non_ocp(chset, ch))
goto exit;
if (is_same_ess(&competitor->network, &mlme->cur_network.network) == _FALSE)
goto exit;
if (rtw_is_desired_network(adapter, competitor) == _FALSE)
goto exit;
#ifdef CONFIG_LAYER2_ROAMING
if (mlme->need_to_roam == _FALSE)
goto exit;
#endif
RTW_INFO("roam candidate:%s %s("MAC_FMT", ch%3u) rssi:%d, age:%5d\n",
(competitor == mlme->cur_network_scanned) ? "*" : " " ,
competitor->network.Ssid.Ssid,
MAC_ARG(competitor->network.MacAddress),
competitor->network.Configuration.DSConfig,
(int)competitor->network.PhyInfo.rssi,
rtw_get_passing_time_ms(competitor->last_scanned)
);
/* got specific addr to roam */
if (!is_zero_mac_addr(mlme->roam_tgt_addr)) {
if (_rtw_memcmp(mlme->roam_tgt_addr, competitor->network.MacAddress, ETH_ALEN) == _TRUE)
goto update;
else
goto exit;
}
#ifdef CONFIG_RTW_80211R
if (rtw_ft_chk_flags(adapter, RTW_FT_PEER_EN)) {
if (rtw_ft_chk_roaming_candidate(adapter, competitor) == _FALSE)
goto exit;
}
#ifdef CONFIG_RTW_WNM
if (rtw_wnm_btm_diff_bss(adapter) &&
rtw_wnm_btm_roam_candidate(adapter, competitor)) {
goto update;
}
#endif
#endif
#if 1
if (rtw_get_passing_time_ms(competitor->last_scanned) >= mlme->roam_scanr_exp_ms)
goto exit;
if (competitor->network.PhyInfo.rssi - mlme->cur_network_scanned->network.PhyInfo.rssi < mlme->roam_rssi_diff_th)
goto exit;
if (*candidate != NULL && (*candidate)->network.PhyInfo.rssi >= competitor->network.PhyInfo.rssi)
goto exit;
#else
goto exit;
#endif
update:
*candidate = competitor;
updated = _TRUE;
exit:
return updated;
}
int rtw_select_roaming_candidate(struct mlme_priv *mlme)
{
int ret = _FAIL;
_list *phead;
_adapter *adapter;
_queue *queue = &(mlme->scanned_queue);
struct wlan_network *pnetwork = NULL;
struct wlan_network *candidate = NULL;
if (mlme->cur_network_scanned == NULL) {
rtw_warn_on(1);
goto exit;
}
_rtw_spinlock_bh(&(mlme->scanned_queue.lock));
phead = get_list_head(queue);
adapter = (_adapter *)mlme->nic_hdl;
mlme->pscanned = get_next(phead);
while (!rtw_end_of_queue_search(phead, mlme->pscanned)) {
pnetwork = LIST_CONTAINOR(mlme->pscanned, struct wlan_network, list);
if (pnetwork == NULL) {
ret = _FAIL;
goto exit;
}
mlme->pscanned = get_next(mlme->pscanned);
if (0)
RTW_INFO("%s("MAC_FMT", ch%u) rssi:%d\n"
, pnetwork->network.Ssid.Ssid
, MAC_ARG(pnetwork->network.MacAddress)
, pnetwork->network.Configuration.DSConfig
, (int)pnetwork->network.PhyInfo.rssi);
rtw_check_roaming_candidate(mlme, &candidate, pnetwork);
}
if (candidate == NULL) {
/* if parent note lost the path to root and there is no other cadidate, report disconnection */
RTW_INFO("%s: return _FAIL(candidate == NULL)\n", __FUNCTION__);
ret = _FAIL;
goto exit;
} else {
RTW_INFO("%s: candidate: %s("MAC_FMT", ch:%u)\n", __FUNCTION__,
candidate->network.Ssid.Ssid, MAC_ARG(candidate->network.MacAddress),
candidate->network.Configuration.DSConfig);
mlme->roam_network = candidate;
if (_rtw_memcmp(candidate->network.MacAddress, mlme->roam_tgt_addr, ETH_ALEN) == _TRUE)
_rtw_memset(mlme->roam_tgt_addr, 0, ETH_ALEN);
}
ret = _SUCCESS;
exit:
_rtw_spinunlock_bh(&(mlme->scanned_queue.lock));
return ret;
}
#endif /* CONFIG_LAYER2_ROAMING */
/*
* Select a new join candidate from the original @param candidate and @param competitor
* @return _TRUE: candidate is updated
* @return _FALSE: candidate is not updated
*/
static int rtw_check_join_candidate(struct mlme_priv *mlme
, struct wlan_network **candidate, struct wlan_network *competitor)
{
int updated = _FALSE;
_adapter *adapter = container_of(mlme, _adapter, mlmepriv);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
RT_CHANNEL_INFO *chset = rfctl->channel_set;
u8 ch = competitor->network.Configuration.DSConfig;
if (rtw_chset_search_ch(chset, ch) < 0)
goto exit;
if (IS_DFS_SLAVE_WITH_RD(rfctl)
&& !rtw_rfctl_dfs_domain_unknown(rfctl)
&& rtw_chset_is_ch_non_ocp(chset, ch))
goto exit;
/* check bssid, if needed */
if (mlme->assoc_by_bssid == _TRUE) {
if (_rtw_memcmp(competitor->network.MacAddress, mlme->assoc_bssid, ETH_ALEN) == _FALSE)
goto exit;
}
/* check ssid, if needed */
if (mlme->assoc_ssid.Ssid[0] && mlme->assoc_ssid.SsidLength) {
if (competitor->network.Ssid.SsidLength != mlme->assoc_ssid.SsidLength
|| _rtw_memcmp(competitor->network.Ssid.Ssid, mlme->assoc_ssid.Ssid, mlme->assoc_ssid.SsidLength) == _FALSE
)
goto exit;
}
if (rtw_is_desired_network(adapter, competitor) == _FALSE)
goto exit;
#ifdef CONFIG_LAYER2_ROAMING
if (rtw_to_roam(adapter) > 0) {
if (rtw_get_passing_time_ms(competitor->last_scanned) >= mlme->roam_scanr_exp_ms
|| is_same_ess(&competitor->network, &mlme->cur_network.network) == _FALSE
)
goto exit;
}
#endif
if (*candidate == NULL || (*candidate)->network.PhyInfo.rssi < competitor->network.PhyInfo.rssi) {
*candidate = competitor;
updated = _TRUE;
}
if (updated) {
RTW_INFO("[by_bssid:%u][assoc_ssid:%s][to_roam:%u] "
"new candidate: %s("MAC_FMT", ch%u) rssi:%d\n",
mlme->assoc_by_bssid,
mlme->assoc_ssid.Ssid,
rtw_to_roam(adapter),
(*candidate)->network.Ssid.Ssid,
MAC_ARG((*candidate)->network.MacAddress),
(*candidate)->network.Configuration.DSConfig,
(int)(*candidate)->network.PhyInfo.rssi
);
}
exit:
return updated;
}
/*
Calling context:
The caller of the sub-routine will be in critical section...
The caller must hold the following spinlock
pmlmepriv->lock
*/
int rtw_select_and_join_from_scanned_queue(struct mlme_priv *pmlmepriv)
{
int ret;
_list *phead;
_adapter *adapter;
_queue *queue = &(pmlmepriv->scanned_queue);
struct wlan_network *pnetwork = NULL;
struct wlan_network *candidate = NULL;
#ifdef CONFIG_ANTENNA_DIVERSITY
u8 bSupportAntDiv = _FALSE;
#endif
adapter = (_adapter *)pmlmepriv->nic_hdl;
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
#ifdef CONFIG_LAYER2_ROAMING
if (pmlmepriv->roam_network) {
candidate = pmlmepriv->roam_network;
goto candidate_exist;
}
#endif
phead = get_list_head(queue);
pmlmepriv->pscanned = get_next(phead);
while (!rtw_end_of_queue_search(phead, pmlmepriv->pscanned)) {
pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list);
if (pnetwork == NULL) {
ret = _FAIL;
goto exit;
}
pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
if (0)
RTW_INFO("%s("MAC_FMT", ch%u) rssi:%d\n"
, pnetwork->network.Ssid.Ssid
, MAC_ARG(pnetwork->network.MacAddress)
, pnetwork->network.Configuration.DSConfig
, (int)pnetwork->network.PhyInfo.rssi);
rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork);
}
if (candidate == NULL) {
RTW_INFO("%s: return _FAIL(candidate == NULL)\n", __FUNCTION__);
#ifdef CONFIG_WOWLAN
_clr_fwstate_(pmlmepriv, WIFI_ASOC_STATE | WIFI_UNDER_LINKING);
#endif
ret = _FAIL;
goto exit;
} else {
RTW_INFO("%s: candidate: %s("MAC_FMT", ch:%u)\n", __FUNCTION__,
candidate->network.Ssid.Ssid, MAC_ARG(candidate->network.MacAddress),
candidate->network.Configuration.DSConfig);
goto candidate_exist;
}
candidate_exist:
/* check for situation of WIFI_ASOC_STATE */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
RTW_INFO("%s: WIFI_ASOC_STATE while ask_for_joinbss!!!\n", __FUNCTION__);
#if 0 /* for WPA/WPA2 authentication, wpa_supplicant will expect authentication from AP, it is needed to reconnect AP... */
if (is_same_network(&pmlmepriv->cur_network.network, &candidate->network)) {
RTW_INFO("%s: WIFI_ASOC_STATE and is same network, it needn't join again\n", __FUNCTION__);
rtw_indicate_connect(adapter);/* rtw_indicate_connect again */
ret = 2;
goto exit;
} else
#endif
{
rtw_disassoc_cmd(adapter, 0, 0);
if (1
#ifdef CONFIG_STA_CMD_DISPR
&& (MLME_IS_STA(adapter) == _FALSE)
#endif /* CONFIG_STA_CMD_DISPR */
)
rtw_free_assoc_resources_cmd(adapter, _TRUE, 0);
rtw_indicate_disconnect(adapter, 0, _FALSE);
}
}
set_fwstate(pmlmepriv, WIFI_UNDER_LINKING);
ret = rtw_joinbss_cmd(adapter, candidate);
exit:
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
return ret;
}
sint rtw_set_auth(_adapter *adapter, struct security_priv *psecuritypriv)
{
struct cmd_obj *pcmd;
struct setauth_parm *psetauthparm;
struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(adapter)->cmdpriv);
sint res = _SUCCESS;
pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd == NULL) {
res = _FAIL; /* try again */
goto exit;
}
pcmd->padapter = adapter;
psetauthparm = (struct setauth_parm *)rtw_zmalloc(sizeof(struct setauth_parm));
if (psetauthparm == NULL) {
rtw_mfree((unsigned char *)pcmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
_rtw_memset(psetauthparm, 0, sizeof(struct setauth_parm));
psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm;
pcmd->cmdcode = CMD_SET_AUTH; /* _SetAuth_CMD_;*/
pcmd->parmbuf = (unsigned char *)psetauthparm;
pcmd->cmdsz = (sizeof(struct setauth_parm));
pcmd->rsp = NULL;
pcmd->rspsz = 0;
_rtw_init_listhead(&pcmd->list);
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
exit:
return res;
}
#ifdef CONFIG_CMD_DISP
sint rtw_set_key(_adapter *adapter, struct security_priv *psecuritypriv, sint keyid, u8 set_tx, bool enqueue)
{
u8 keylen;
struct setkey_parm setkeyparm;
sint res = _SUCCESS;
_rtw_memset(&setkeyparm, 0, sizeof(struct setkey_parm));
if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
/* BIP use keyid 4 or 5 */
if (keyid >= 4)
setkeyparm.algorithm = (unsigned char)psecuritypriv->dot11wCipher;
else
setkeyparm.algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy;
} else {
setkeyparm.algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
}
setkeyparm.keyid = (u8)keyid;/* 0~3 */
setkeyparm.set_tx = set_tx;
if (is_wep_enc(setkeyparm.algorithm))
adapter->securitypriv.key_mask |= BIT(setkeyparm.keyid);
RTW_INFO("==> rtw_set_key algorithm(%x),keyid(%x),key_mask(%x)\n", setkeyparm.algorithm, setkeyparm.keyid, adapter->securitypriv.key_mask);
switch (setkeyparm.algorithm) {
case _WEP40_:
keylen = 5;
_rtw_memcpy(&(setkeyparm.key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
break;
case _WEP104_:
keylen = 13;
_rtw_memcpy(&(setkeyparm.key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
break;
case _TKIP_:
keylen = 16;
_rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
break;
case _AES_:
case _GCMP_:
keylen = 16;
_rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
break;
case _GCMP_256_:
case _CCMP_256_:
keylen = 32;
_rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
break;
#ifdef CONFIG_IEEE80211W
case _BIP_CMAC_128_:
keylen = 16;
_rtw_memcpy(&setkeyparm.key, &psecuritypriv->dot11wBIPKey[keyid], keylen);
break;
#endif /* CONFIG_IEEE80211W */
default:
res = _FAIL;
goto exit;
}
if (enqueue)
setkey_hdl(adapter, &setkeyparm, PHL_CMD_NO_WAIT, 0);
else
setkey_hdl(adapter, &setkeyparm, PHL_CMD_DIRECTLY, 0);
exit:
return res;
}
#else /* CONFIG_FSM */
sint rtw_set_key(_adapter *adapter, struct security_priv *psecuritypriv, sint keyid, u8 set_tx, bool enqueue)
{
u8 keylen;
struct cmd_obj *pcmd;
struct setkey_parm *psetkeyparm;
struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(adapter)->cmdpriv);
sint res = _SUCCESS;
psetkeyparm = (struct setkey_parm *)rtw_zmalloc(sizeof(struct setkey_parm));
if (psetkeyparm == NULL) {
res = _FAIL;
goto exit;
}
_rtw_memset(psetkeyparm, 0, sizeof(struct setkey_parm));
if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
/* BIP use keyid 4 or 5 */
if (keyid >= 4)
psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot11wCipher;
else
psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy;
} else {
psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
}
psetkeyparm->keyid = (u8)keyid;/* 0~3 */
psetkeyparm->set_tx = set_tx;
if (is_wep_enc(psetkeyparm->algorithm))
adapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
RTW_INFO("==> rtw_set_key algorithm(%x),keyid(%x),key_mask(%x)\n", psetkeyparm->algorithm, psetkeyparm->keyid, adapter->securitypriv.key_mask);
switch (psetkeyparm->algorithm) {
case _WEP40_:
keylen = 5;
_rtw_memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
break;
case _WEP104_:
keylen = 13;
_rtw_memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
break;
case _TKIP_:
keylen = 16;
_rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
break;
case _AES_:
case _GCMP_:
keylen = 16;
_rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
break;
case _GCMP_256_:
case _CCMP_256_:
keylen = 32;
_rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
break;
#ifdef CONFIG_IEEE80211W
case _BIP_CMAC_128_:
keylen = 16;
_rtw_memcpy(&psetkeyparm->key, &psecuritypriv->dot11wBIPKey[keyid], keylen);
break;
#endif /* CONFIG_IEEE80211W */
default:
res = _FAIL;
rtw_mfree((unsigned char *)psetkeyparm, sizeof(struct setkey_parm));
goto exit;
}
if (enqueue) {
pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd == NULL) {
rtw_mfree((unsigned char *)psetkeyparm, sizeof(struct setkey_parm));
res = _FAIL; /* try again */
goto exit;
}
pcmd->padapter = adapter;
pcmd->cmdcode = CMD_SET_KEY; /*_SetKey_CMD_*/
pcmd->parmbuf = (u8 *)psetkeyparm;
pcmd->cmdsz = (sizeof(struct setkey_parm));
pcmd->rsp = NULL;
pcmd->rspsz = 0;
_rtw_init_listhead(&pcmd->list);
/* _rtw_init_sema(&(pcmd->cmd_sem), 0); */
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
} else {
setkey_hdl(adapter, (u8 *)psetkeyparm);
rtw_mfree((u8 *) psetkeyparm, sizeof(struct setkey_parm));
}
exit:
return res;
}
#endif
#ifdef CONFIG_WMMPS_STA
/*
* rtw_uapsd_use_default_setting
* This function is used for setting default uapsd max sp length to uapsd_max_sp_len
* in qos_priv data structure from registry. In additional, it will also map default uapsd
* ac to each uapsd TID, delivery-enabled and trigger-enabled of corresponding TID.
*
* Arguments:
* @padapter: _adapter pointer.
*
* Auther: Arvin Liu
* Date: 2017/05/03
*/
void rtw_uapsd_use_default_setting(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
if (pregistrypriv->uapsd_ac_enable != 0) {
pqospriv->uapsd_max_sp_len = pregistrypriv->uapsd_max_sp_len;
CLEAR_FLAGS(pqospriv->uapsd_tid);
CLEAR_FLAGS(pqospriv->uapsd_tid_delivery_enabled);
CLEAR_FLAGS(pqospriv->uapsd_tid_trigger_enabled);
/* check the uapsd setting of AC_VO from registry then map these setting to each TID if necessary */
if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_VO)) {
SET_FLAG(pqospriv->uapsd_tid, WMM_TID7);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID7);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID7);
SET_FLAG(pqospriv->uapsd_tid, WMM_TID6);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID6);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID6);
}
/* check the uapsd setting of AC_VI from registry then map these setting to each TID if necessary */
if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_VI)) {
SET_FLAG(pqospriv->uapsd_tid, WMM_TID5);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID5);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID5);
SET_FLAG(pqospriv->uapsd_tid, WMM_TID4);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID4);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID4);
}
/* check the uapsd setting of AC_BK from registry then map these setting to each TID if necessary */
if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_BK)) {
SET_FLAG(pqospriv->uapsd_tid, WMM_TID2);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID2);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID2);
SET_FLAG(pqospriv->uapsd_tid, WMM_TID1);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID1);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID1);
}
/* check the uapsd setting of AC_BE from registry then map these setting to each TID if necessary */
if(TEST_FLAG(pregistrypriv->uapsd_ac_enable, DRV_CFG_UAPSD_BE)) {
SET_FLAG(pqospriv->uapsd_tid, WMM_TID3);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID3);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID3);
SET_FLAG(pqospriv->uapsd_tid, WMM_TID0);
SET_FLAG(pqospriv->uapsd_tid_delivery_enabled, WMM_TID0);
SET_FLAG(pqospriv->uapsd_tid_trigger_enabled, WMM_TID0);
}
RTW_INFO("[WMMPS] UAPSD MAX SP Len = 0x%02x, UAPSD TID enabled = 0x%02x\n",
pqospriv->uapsd_max_sp_len, (u8)pqospriv->uapsd_tid);
}
}
/*
* rtw_is_wmmps_mode
* This function is used for checking whether Driver and an AP support uapsd function or not.
* If both of them support uapsd function, it will return true. Otherwise returns false.
*
* Arguments:
* @padapter: _adapter pointer.
*
* Auther: Arvin Liu
* Date: 2017/06/12
*/
bool rtw_is_wmmps_mode(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
if ((pqospriv->uapsd_ap_supported) && ((pqospriv->uapsd_tid & BIT_MASK_TID_TC) != 0))
return _TRUE;
return _FALSE;
}
#endif /* CONFIG_WMMPS_STA */
/* adjust IEs for rtw_joinbss_cmd in WMM */
int rtw_restruct_wmm_ie(_adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len, uint initial_out_len)
{
#ifdef CONFIG_WMMPS_STA
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
#endif /* CONFIG_WMMPS_STA */
unsigned int ielength = 0;
unsigned int i, j;
u8 qos_info = 0;
i = 12; /* after the fixed IE */
while (i < in_len) {
ielength = initial_out_len;
if (in_ie[i] == 0xDD && in_ie[i + 2] == 0x00 && in_ie[i + 3] == 0x50 && in_ie[i + 4] == 0xF2 && in_ie[i + 5] == 0x02 && i + 5 < in_len) { /* WMM element ID and OUI */
/* Append WMM IE to the last index of out_ie */
#if 0
for (j = i; j < i + (in_ie[i + 1] + 2); j++) {
out_ie[ielength] = in_ie[j];
ielength++;
}
out_ie[initial_out_len + 8] = 0x00; /* force the QoS Info Field to be zero */
#endif
for (j = i; j < i + 9; j++) {
out_ie[ielength] = in_ie[j];
ielength++;
}
out_ie[initial_out_len + 1] = 0x07;
out_ie[initial_out_len + 6] = 0x00;
#ifdef CONFIG_WMMPS_STA
switch(pqospriv->uapsd_max_sp_len) {
case NO_LIMIT:
/* do nothing */
break;
case TWO_MSDU:
SET_FLAG(qos_info, BIT5);
break;
case FOUR_MSDU:
SET_FLAG(qos_info, BIT6);
break;
case SIX_MSDU:
SET_FLAG(qos_info, BIT5);
SET_FLAG(qos_info, BIT6);
break;
default:
/* do nothing */
break;
};
/* check TID7 and TID6 for AC_VO to set corresponding Qos_info bit in WMM IE */
if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID7)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID6)))
SET_FLAG(qos_info, WMM_IE_UAPSD_VO);
/* check TID5 and TID4 for AC_VI to set corresponding Qos_info bit in WMM IE */
if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID5)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID4)))
SET_FLAG(qos_info, WMM_IE_UAPSD_VI);
/* check TID2 and TID1 for AC_BK to set corresponding Qos_info bit in WMM IE */
if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID2)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID1)))
SET_FLAG(qos_info, WMM_IE_UAPSD_BK);
/* check TID3 and TID0 for AC_BE to set corresponding Qos_info bit in WMM IE */
if((TEST_FLAG(pqospriv->uapsd_tid, WMM_TID3)) && (TEST_FLAG(pqospriv->uapsd_tid, WMM_TID0)))
SET_FLAG(qos_info, WMM_IE_UAPSD_BE);
#endif /* CONFIG_WMMPS_STA */
out_ie[initial_out_len + 8] = qos_info;
break;
}
i += (in_ie[i + 1] + 2); /* to the next IE element */
}
return ielength;
}
/*
* Ported from 8185: IsInPreAuthKeyList(). (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.)
* Added by Annie, 2006-05-07.
*
* Search by BSSID,
* Return Value:
* -1 :if there is no pre-auth key in the table
* >=0 :if there is pre-auth key, and return the entry id
*
* */
static int SecIsInPMKIDList(_adapter *adapter, u8 *bssid)
{
struct security_priv *psecuritypriv = &adapter->securitypriv;
int i = 0;
do {
if ((psecuritypriv->PMKIDList[i].bUsed) &&
(_rtw_memcmp(psecuritypriv->PMKIDList[i].Bssid, bssid, ETH_ALEN) == _TRUE))
break;
else {
i++;
/* continue; */
}
} while (i < NUM_PMKID_CACHE);
if (i == NUM_PMKID_CACHE) {
i = -1;/* Could not find. */
} else {
/* There is one Pre-Authentication Key for the specific BSSID. */
}
return i;
}
int rtw_cached_pmkid(_adapter *adapter, u8 *bssid)
{
return SecIsInPMKIDList(adapter, bssid);
}
int rtw_rsn_sync_pmkid(_adapter *adapter, u8 *ie, uint ie_len, int i_ent)
{
struct security_priv *sec = &adapter->securitypriv;
struct rsne_info info;
u8 gm_cs[4];
int i;
rtw_rsne_info_parse(ie, ie_len, &info);
if (info.err) {
RTW_WARN(FUNC_ADPT_FMT" rtw_rsne_info_parse error\n"
, FUNC_ADPT_ARG(adapter));
return 0;
}
if (i_ent < 0 && info.pmkid_cnt == 0)
goto exit;
if (i_ent >= 0 && info.pmkid_cnt == 1 && _rtw_memcmp(info.pmkid_list, sec->PMKIDList[i_ent].PMKID, 16)) {
RTW_INFO(FUNC_ADPT_FMT" has carried the same PMKID:"KEY_FMT"\n"
, FUNC_ADPT_ARG(adapter), KEY_ARG(&sec->PMKIDList[i_ent].PMKID));
goto exit;
}
/* bakcup group mgmt cs */
if (info.gmcs)
_rtw_memcpy(gm_cs, info.gmcs, 4);
if (info.pmkid_cnt) {
RTW_INFO(FUNC_ADPT_FMT" remove original PMKID, count:%u\n"
, FUNC_ADPT_ARG(adapter), info.pmkid_cnt);
for (i = 0; i < info.pmkid_cnt; i++)
RTW_INFO(" "KEY_FMT"\n", KEY_ARG(info.pmkid_list + i * 16));
}
if (i_ent >= 0) {
RTW_INFO(FUNC_ADPT_FMT" append PMKID:"KEY_FMT"\n"
, FUNC_ADPT_ARG(adapter), KEY_ARG(sec->PMKIDList[i_ent].PMKID));
info.pmkid_cnt = 1; /* update new pmkid_cnt */
_rtw_memcpy(info.pmkid_list, sec->PMKIDList[i_ent].PMKID, 16);
} else
info.pmkid_cnt = 0; /* update new pmkid_cnt */
RTW_PUT_LE16(info.pmkid_list - 2, info.pmkid_cnt);
if (info.gmcs)
_rtw_memcpy(info.pmkid_list + 16 * info.pmkid_cnt, gm_cs, 4);
ie_len = 1 + 1 + 2 + 4
+ 2 + 4 * info.pcs_cnt
+ 2 + 4 * info.akm_cnt
+ 2
+ 2 + 16 * info.pmkid_cnt
+ (info.gmcs ? 4 : 0)
;
ie[1] = (u8)(ie_len - 2);
exit:
return ie_len;
}
sint rtw_restruct_sec_ie(_adapter *adapter, u8 *out_ie)
{
u8 authmode = 0x0;
uint ielength = 0;
int iEntry;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct security_priv *psecuritypriv = &adapter->securitypriv;
uint ndisauthmode = psecuritypriv->ndisauthtype;
if ((ndisauthmode == Ndis802_11AuthModeWPA) || (ndisauthmode == Ndis802_11AuthModeWPAPSK))
authmode = _WPA_IE_ID_;
if ((ndisauthmode == Ndis802_11AuthModeWPA2) || (ndisauthmode == Ndis802_11AuthModeWPA2PSK))
authmode = _WPA2_IE_ID_;
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
_rtw_memcpy(out_ie, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len);
ielength = psecuritypriv->wps_ie_len;
} else if ((authmode == _WPA_IE_ID_) || (authmode == _WPA2_IE_ID_)) {
/* copy RSN or SSN */
_rtw_memcpy(out_ie, psecuritypriv->supplicant_ie, psecuritypriv->supplicant_ie[1] + 2);
/* debug for CONFIG_IEEE80211W
{
int jj;
printk("supplicant_ie_length=%d &&&&&&&&&&&&&&&&&&&\n", psecuritypriv->supplicant_ie[1]+2);
for(jj=0; jj < psecuritypriv->supplicant_ie[1]+2; jj++)
printk(" %02x ", psecuritypriv->supplicant_ie[jj]);
printk("\n");
}*/
ielength = psecuritypriv->supplicant_ie[1] + 2;
rtw_report_sec_ie(adapter, authmode, psecuritypriv->supplicant_ie);
}
if (authmode == WLAN_EID_RSN) {
iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
ielength = rtw_rsn_sync_pmkid(adapter, out_ie, ielength, iEntry);
}
return ielength;
}
void rtw_init_registrypriv_dev_network(_adapter *adapter)
{
struct registry_priv *pregistrypriv = &adapter->registrypriv;
WLAN_BSSID_EX *pdev_network = &pregistrypriv->dev_network;
u8 *myhwaddr = adapter_mac_addr(adapter);
_rtw_memcpy(pdev_network->MacAddress, myhwaddr, ETH_ALEN);
_rtw_memcpy(&pdev_network->Ssid, &pregistrypriv->ssid, sizeof(NDIS_802_11_SSID));
pdev_network->Configuration.Length = sizeof(NDIS_802_11_CONFIGURATION);
pdev_network->Configuration.BeaconPeriod = 100;
}
void rtw_update_registrypriv_dev_network(_adapter *adapter)
{
int sz = 0;
struct registry_priv *pregistrypriv = &adapter->registrypriv;
WLAN_BSSID_EX *pdev_network = &pregistrypriv->dev_network;
struct security_priv *psecuritypriv = &adapter->securitypriv;
struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
/* struct xmit_priv *pxmitpriv = &adapter->xmitpriv; */
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
#if 0
pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
pxmitpriv->vcs = pregistrypriv->vcs_type;
pxmitpriv->vcs_type = pregistrypriv->vcs_type;
/* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */
pxmitpriv->frag_len = pregistrypriv->frag_thresh;
adapter->qospriv.qos_option = pregistrypriv->wmm_enable;
#endif
pdev_network->Privacy = (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0) ; /* adhoc no 802.1x */
pdev_network->PhyInfo.rssi = 0;
pdev_network->Configuration.DSConfig = (pregistrypriv->channel);
if (cur_network->network.InfrastructureMode == Ndis802_11IBSS) {
pdev_network->Configuration.ATIMWindow = (0);
if (pmlmeext->chandef.chan != 0)
pdev_network->Configuration.DSConfig = pmlmeext->chandef.chan;
else
pdev_network->Configuration.DSConfig = 1;
}
pdev_network->InfrastructureMode = (cur_network->network.InfrastructureMode);
/* 1. Supported rates */
/* 2. IE */
/* rtw_set_supported_rate(pdev_network->SupportedRates, pregistrypriv->wireless_mode) ; */ /* will be called in rtw_generate_ie */
sz = rtw_generate_ie(pregistrypriv);
pdev_network->IELength = sz;
pdev_network->Length = get_WLAN_BSSID_EX_sz((WLAN_BSSID_EX *)pdev_network);
/* notes: translate IELength & Length after assign the Length to cmdsz in createbss_cmd(); */
/* pdev_network->IELength = cpu_to_le32(sz); */
}
void rtw_get_encrypt_decrypt_from_registrypriv(_adapter *adapter)
{
}
/* the fucntion is at passive_level */
void rtw_joinbss_reset(_adapter *padapter)
{
u8 threshold;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
/* todo: if you want to do something io/reg/hw setting before join_bss, please add code here */
#ifdef CONFIG_80211N_HT
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
pmlmepriv->num_FortyMHzIntolerant = 0;
pmlmepriv->num_sta_no_ht = 0;
phtpriv->ampdu_enable = _FALSE;/* reset to disabled */
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI)
/* TH=1 => means that invalidate usb rx aggregation */
/* TH=0 => means that validate usb rx aggregation, use init value. */
if (phtpriv->ht_option) {
if (padapter->registrypriv.wifi_spec == 1)
threshold = 1;
else
threshold = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
} else {
threshold = 1;
rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
}
#endif/* #if defined( CONFIG_USB_HCI) || defined (CONFIG_SDIO_HCI) */
#endif/* #ifdef CONFIG_80211N_HT */
}
#ifdef CONFIG_80211N_HT
void rtw_ht_get_dft_setting(_adapter *padapter,
struct protocol_cap_t *dft_proto_cap,
struct role_cap_t *dft_cap)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
BOOLEAN bHwLDPCSupport = _FALSE, bHwSTBCSupport = _FALSE;
u8 stbc_rx = 0;
#ifdef CONFIG_BEAMFORMING
BOOLEAN bHwSupportBeamformer = _FALSE, bHwSupportBeamformee = _FALSE;
#endif /* CONFIG_BEAMFORMING */
if (pregistrypriv->wifi_spec)
phtpriv->bss_coexist = 1;
else
phtpriv->bss_coexist = 0;
/*dft_proto_cap->sgi_40;*/
phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? _TRUE : _FALSE;
/*dft_proto_cap->sgi_20;*/
phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? _TRUE : _FALSE;
/* LDPC support */
CLEAR_FLAGS(phtpriv->ldpc_cap);
bHwLDPCSupport = (dft_proto_cap->ht_ldpc) ? _TRUE : _FALSE;
if (bHwLDPCSupport) {
if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT4))
SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX);
}
bHwLDPCSupport = (dft_cap->tx_ht_ldpc) ? _TRUE : _FALSE;
if (bHwLDPCSupport) {
if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT5))
SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX);
}
if (phtpriv->ldpc_cap)
RTW_INFO("[HT] HAL Support LDPC = 0x%02X\n", phtpriv->ldpc_cap);
/* STBC */
CLEAR_FLAGS(phtpriv->stbc_cap);
if (dft_proto_cap->stbc_ht_tx)
SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX);
if (dft_proto_cap->stbc_ht_rx)
SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX);
if (phtpriv->stbc_cap)
RTW_INFO("[HT] HAL Support STBC = 0x%02X\n", phtpriv->stbc_cap);
/* Beamforming setting */
CLEAR_FLAGS(phtpriv->beamform_cap);
#ifdef CONFIG_BEAMFORMING
/* only enable beamforming in STA client mode */
if (MLME_IS_STA(padapter) && !MLME_IS_GC(padapter)
&& !MLME_IS_ADHOC(padapter)
&& !MLME_IS_MESH(padapter))
{
bHwSupportBeamformer = (dft_proto_cap->ht_su_bfmr) ? _TRUE : _FALSE;
bHwSupportBeamformee = (dft_proto_cap->ht_su_bfme) ? _TRUE : _FALSE;
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT4) && bHwSupportBeamformer) {
SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
RTW_INFO("[HT] HAL Support Beamformer\n");
}
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT5) && bHwSupportBeamformee) {
SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
RTW_INFO("[HT] HAL Support Beamformee\n");
}
}
#endif /* CONFIG_BEAMFORMING */
}
void rtw_ht_use_default_setting(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
BOOLEAN bHwLDPCSupport = _FALSE, bHwSTBCSupport = _FALSE;
u8 stbc_rx = 0;
#ifdef CONFIG_BEAMFORMING
BOOLEAN bHwSupportBeamformer = _FALSE, bHwSupportBeamformee = _FALSE;
#endif /* CONFIG_BEAMFORMING */
if (pregistrypriv->wifi_spec)
phtpriv->bss_coexist = 1;
else
phtpriv->bss_coexist = 0;
phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? _TRUE : _FALSE;
phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? _TRUE : _FALSE;
/* LDPC support */
if (padapter->phl_role->proto_role_cap.ht_ldpc)
SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX);
if (padapter->phl_role->cap.tx_ht_ldpc)
SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX);
if (phtpriv->ldpc_cap)
RTW_INFO("[HT] HAL Support LDPC = 0x%02X\n", phtpriv->ldpc_cap);
/* STBC */
if (padapter->phl_role->proto_role_cap.stbc_ht_tx)
SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX);
if (padapter->phl_role->proto_role_cap.stbc_ht_rx)
SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX);
if (phtpriv->stbc_cap)
RTW_INFO("[HT] HAL Support STBC = 0x%02X\n", phtpriv->stbc_cap);
/* Beamforming setting */
CLEAR_FLAGS(phtpriv->beamform_cap);
#ifdef CONFIG_BEAMFORMING
/* only enable beamforming in STA client mode */
if (MLME_IS_STA(padapter) && !MLME_IS_GC(padapter)
&& !MLME_IS_ADHOC(padapter)
&& !MLME_IS_MESH(padapter))
{
if (padapter->phl_role->proto_role_cap.ht_su_bfmr) {
SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
RTW_INFO("[HT] HAL Support Beamformer\n");
}
if (padapter->phl_role->proto_role_cap.ht_su_bfme) {
SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
RTW_INFO("[HT] HAL Support Beamformee\n");
}
}
#endif /* CONFIG_BEAMFORMING */
}
void rtw_build_wmm_ie_ht(_adapter *padapter, u8 *out_ie, uint *pout_len)
{
unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
int out_len;
u8 *pframe;
if (padapter->mlmepriv.qospriv.qos_option == 0) {
out_len = *pout_len;
pframe = rtw_set_ie(out_ie + out_len, _VENDOR_SPECIFIC_IE_,
_WMM_IE_Length_, WMM_IE, pout_len);
padapter->mlmepriv.qospriv.qos_option = 1;
}
}
#if defined(CONFIG_80211N_HT)
/* the fucntion is >= passive_level */
unsigned int rtw_restructure_ht_ie(_adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, u8 channel, struct country_chplan *req_chplan)
{
u32 ielen, out_len;
HT_CAP_AMPDU_FACTOR max_rx_ampdu_factor = 0;
HT_CAP_AMPDU_DENSITY best_ampdu_density = 0;
unsigned char *p, *pframe;
enum band_type band = channel > 14 ? BAND_ON_5G : BAND_ON_24G;
struct rtw_ieee80211_ht_cap ht_capie;
u8 cbw40_enable = 0, rf_num = 0, rx_stbc_nss = 0, rx_nss = 0;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
#ifdef CONFIG_80211AC_VHT
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
#endif /* CONFIG_80211AC_VHT */
phtpriv->ht_option = _FALSE;
out_len = *pout_len;
_rtw_memset(&ht_capie, 0, sizeof(struct rtw_ieee80211_ht_cap));
ht_capie.cap_info = IEEE80211_HT_CAP_DSSSCCK40;
if (phtpriv->sgi_20m)
ht_capie.cap_info |= IEEE80211_HT_CAP_SGI_20;
/* check if 40MHz is allowed according to hal cap and registry */
if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_40M)) {
if (band == BAND_ON_5G) {
if (REGSTY_IS_BW_5G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
cbw40_enable = 1;
} else if (band == BAND_ON_24G) {
if (REGSTY_IS_BW_2G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
cbw40_enable = 1;
}
}
if (cbw40_enable) {
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
RT_CHANNEL_INFO *chset = rfctl->channel_set;
u8 oper_bw = CHANNEL_WIDTH_20, oper_offset = CHAN_OFFSET_NO_EXT;
if (in_ie == NULL) {
/* TDLS: TODO 20/40 issue */
if (MLME_IS_STA(padapter)) {
oper_bw = padapter->mlmeextpriv.chandef.bw;
if (oper_bw > CHANNEL_WIDTH_40)
oper_bw = CHANNEL_WIDTH_40;
} else
/* TDLS: TODO 40? */
oper_bw = CHANNEL_WIDTH_40;
} else {
p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len);
if (p && ielen == HT_OP_IE_LEN) {
if (GET_HT_OP_ELE_STA_CHL_WIDTH(p + 2)) {
switch (GET_HT_OP_ELE_2ND_CHL_OFFSET(p + 2)) {
case IEEE80211_SCA:
oper_bw = CHANNEL_WIDTH_40;
oper_offset = CHAN_OFFSET_UPPER;
break;
case IEEE80211_SCB:
oper_bw = CHANNEL_WIDTH_40;
oper_offset = CHAN_OFFSET_LOWER;
break;
}
}
}
/* IOT issue : AP TP-Link WDR6500 */
if(oper_bw == CHANNEL_WIDTH_40){
p = rtw_get_ie(in_ie, WLAN_EID_HT_CAP, &ielen, in_len);
if (p && ielen == HT_CAP_IE_LEN) {
oper_bw = GET_HT_CAP_ELE_CHL_WIDTH(p + 2) ? CHANNEL_WIDTH_40 : CHANNEL_WIDTH_20;
if(oper_bw == CHANNEL_WIDTH_20)
oper_offset = CHAN_OFFSET_NO_EXT;
}
}
}
/* adjust bw to fit in channel plan setting */
if (oper_bw == CHANNEL_WIDTH_40
&& oper_offset != CHAN_OFFSET_NO_EXT /* check this because TDLS has no info to set offset */
) {
if ((req_chplan && !rtw_country_chplan_is_chbw_valid(req_chplan, band, channel, oper_bw, oper_offset, 1, 1, pregistrypriv))
|| (!req_chplan && !rtw_chset_is_chbw_valid(chset, channel, oper_bw, oper_offset, 1, 1))
|| (IS_DFS_SLAVE_WITH_RD(rfctl)
&& !rtw_rfctl_dfs_domain_unknown(rfctl)
&& rtw_chset_is_chbw_non_ocp(chset, channel, oper_bw, oper_offset))
) {
oper_bw = CHANNEL_WIDTH_20;
oper_offset = CHAN_OFFSET_NO_EXT;
rtw_warn_on(req_chplan && !rtw_country_chplan_is_chbw_valid(req_chplan, band, channel, oper_bw, oper_offset, 1, 1, pregistrypriv));
rtw_warn_on(!req_chplan && !rtw_chset_is_chbw_valid(chset, channel, oper_bw, oper_offset, 1, 1));
if (IS_DFS_SLAVE_WITH_RD(rfctl) && !rtw_rfctl_dfs_domain_unknown(rfctl))
rtw_warn_on(rtw_chset_is_chbw_non_ocp(chset, channel, oper_bw, oper_offset));
}
}
if (oper_bw == CHANNEL_WIDTH_40) {
ht_capie.cap_info |= IEEE80211_HT_CAP_SUP_WIDTH;
if (phtpriv->sgi_40m)
ht_capie.cap_info |= IEEE80211_HT_CAP_SGI_40;
}
cbw40_enable = oper_bw == CHANNEL_WIDTH_40 ? 1 : 0;
}
/* todo: disable SM power save mode */
ht_capie.cap_info |= IEEE80211_HT_CAP_SM_PS;
/* RX LDPC */
if (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX)) {
ht_capie.cap_info |= IEEE80211_HT_CAP_LDPC_CODING;
RTW_INFO("[HT] Declare supporting RX LDPC\n");
}
/* TX STBC */
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX)) {
ht_capie.cap_info |= IEEE80211_HT_CAP_TX_STBC;
RTW_INFO("[HT] Declare supporting TX STBC\n");
}
/* RX STBC */
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX) ||
(pregistrypriv->wifi_spec == 1)) {
rx_stbc_nss = padapter->phl_role->proto_role_cap.stbc_ht_rx;
if (rx_stbc_nss > 3)
rx_stbc_nss = 3;
SET_HT_CAP_ELE_RX_STBC(&ht_capie, rx_stbc_nss);
RTW_INFO("[HT] Declare supporting RX STBC = %d\n", rx_stbc_nss);
}
/* fill default supported_mcs_set */
_rtw_memcpy(ht_capie.supp_mcs_set, pmlmeext->default_supported_mcs_set, 16);
/* update default supported_mcs_set */
rx_nss = GET_HAL_RX_NSS(adapter_to_dvobj(padapter));
switch (rx_nss) {
case 1:
set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_1R);
break;
case 2:
#ifdef CONFIG_DISABLE_MCS13TO15
if (cbw40_enable && pregistrypriv->wifi_spec != 1)
set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_2R_13TO15_OFF);
else
#endif
set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_2R);
break;
case 3:
set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_3R);
break;
case 4:
set_mcs_rate_by_mask(ht_capie.supp_mcs_set, MCS_RATE_4R);
break;
default:
RTW_WARN("rf_type:%d or rx_nss:%u is not expected\n",
GET_HAL_RFPATH(adapter_to_dvobj(padapter)), rx_nss);
}
if (padapter->phl_role->proto_role_cap.max_amsdu_len > 0) {
/*SET_HT_CAP_ELE_MAX_AMSDU_LENGTH(&ht_capie, 1);*/
RTW_INFO("%s IEEE80211_HT_CAP_MAX_AMSDU is set\n", __func__);
ht_capie.cap_info = ht_capie.cap_info | IEEE80211_HT_CAP_MAX_AMSDU;
}
if (padapter->driver_rx_ampdu_factor != 0xFF)
max_rx_ampdu_factor = (HT_CAP_AMPDU_FACTOR)padapter->driver_rx_ampdu_factor;
else
rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor);
/* rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor); */
ht_capie.ampdu_params_info = (max_rx_ampdu_factor & 0x03);
if (padapter->driver_rx_ampdu_spacing != 0xFF)
ht_capie.ampdu_params_info |= ((padapter->driver_rx_ampdu_spacing & 0x07) << 2);
else {
if (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_) {
/*
* Todo : Each chip must to ask DD , this chip best ampdu_density setting
* By yiwei.sun
*/
rtw_hal_get_def_var(padapter, HW_VAR_BEST_AMPDU_DENSITY, &best_ampdu_density);
ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & (best_ampdu_density << 2));
} else
ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00);
}
#ifdef CONFIG_BEAMFORMING
ht_capie.tx_BF_cap_info = 0;
/* HT Beamformer*/
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE)) {
/* Transmit NDP Capable */
SET_HT_CAP_TXBF_TRANSMIT_NDP_CAP(&ht_capie, 1);
/* Explicit Compressed Steering Capable */
SET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP(&ht_capie, 1);
/* Compressed Steering Number Antennas */
SET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(&ht_capie, 1);
rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMER_CAP, (u8 *)&rf_num);
if (rf_num > 3)
rf_num = 3;
SET_HT_CAP_TXBF_CHNL_ESTIMATION_NUM_ANTENNAS(&ht_capie, rf_num);
}
/* HT Beamformee */
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE)) {
/* Receive NDP Capable */
SET_HT_CAP_TXBF_RECEIVE_NDP_CAP(&ht_capie, 1);
/* Explicit Compressed Beamforming Feedback Capable */
SET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP(&ht_capie, 2);
rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMEE_CAP, (u8 *)&rf_num);
if (rf_num > 3)
rf_num = 3;
#ifdef CONFIG_80211AC_VHT
/* IOT action suggested by Yu Chen 2017/3/3 */
if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_BROADCOM) &&
!pvhtpriv->ap_bf_cap.is_mu_bfer &&
pvhtpriv->ap_bf_cap.su_sound_dim == 2)
rf_num = (rf_num >= 2 ? 2 : rf_num);
#endif
SET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(&ht_capie, rf_num);
}
#endif/*CONFIG_BEAMFORMING*/
pframe = rtw_set_ie(out_ie + out_len, _HT_CAPABILITY_IE_,
sizeof(struct rtw_ieee80211_ht_cap), (unsigned char *)&ht_capie, pout_len);
phtpriv->ht_option = _TRUE;
if (in_ie != NULL) {
p = rtw_get_ie(in_ie, _HT_ADD_INFO_IE_, &ielen, in_len);
if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) {
out_len = *pout_len;
pframe = rtw_set_ie(out_ie + out_len, _HT_ADD_INFO_IE_, ielen, p + 2 , pout_len);
}
}
return phtpriv->ht_option;
}
/* the fucntion is > passive_level (in critical_section) */
void rtw_update_ht_cap(_adapter *padapter, u8 *pie, uint ie_len, u8 channel)
{
u8 *p, max_ampdu_sz;
int len;
/* struct sta_info *bmc_sta, *psta; */
struct rtw_ieee80211_ht_cap *pht_capie;
struct ieee80211_ht_addt_info *pht_addtinfo;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
/* struct wlan_network *pcur_network = &(pmlmepriv->cur_network);; */
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 cbw40_enable = 0;
if (!phtpriv->ht_option)
return;
if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable))
return;
RTW_INFO("+rtw_update_ht_cap()\n");
/* maybe needs check if ap supports rx ampdu. */
if ((phtpriv->ampdu_enable == _FALSE) && (pregistrypriv->ampdu_enable == 1)) {
if (pregistrypriv->wifi_spec == 1) {
/* remove this part because testbed AP should disable RX AMPDU */
/* phtpriv->ampdu_enable = _FALSE; */
phtpriv->ampdu_enable = _TRUE;
} else
phtpriv->ampdu_enable = _TRUE;
}
/* check Max Rx A-MPDU Size */
len = 0;
p = rtw_get_ie(pie + sizeof(NDIS_802_11_FIXED_IEs), _HT_CAPABILITY_IE_, &len, ie_len - sizeof(NDIS_802_11_FIXED_IEs));
if (p && len > 0) {
pht_capie = (struct rtw_ieee80211_ht_cap *)(p + 2);
max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR);
max_ampdu_sz = 1 << (max_ampdu_sz + 3); /* max_ampdu_sz (kbytes); */
/* RTW_INFO("rtw_update_ht_cap(): max_ampdu_sz=%d\n", max_ampdu_sz); */
phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
}
len = 0;
p = rtw_get_ie(pie + sizeof(NDIS_802_11_FIXED_IEs), _HT_ADD_INFO_IE_, &len, ie_len - sizeof(NDIS_802_11_FIXED_IEs));
if (p && len > 0) {
pht_addtinfo = (struct ieee80211_ht_addt_info *)(p + 2);
/* todo: */
}
if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_40M)) {
if (channel > 14) {
if (REGSTY_IS_BW_5G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
cbw40_enable = 1;
} else {
if (REGSTY_IS_BW_2G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
cbw40_enable = 1;
}
}
/* update cur_bwmode & cur_ch_offset */
if ((cbw40_enable) &&
(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & BIT(1)) &&
(pmlmeinfo->HT_info.infos[0] & BIT(2))) {
int i;
u8 rx_nss = 0;
rx_nss = GET_HAL_RX_NSS(adapter_to_dvobj(padapter));
/* update the MCS set */
for (i = 0; i < 16; i++)
pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i];
/* update the MCS rates */
switch (rx_nss) {
case 1:
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R);
break;
case 2:
#ifdef CONFIG_DISABLE_MCS13TO15
if (pmlmeext->chandef.bw == CHANNEL_WIDTH_40 && pregistrypriv->wifi_spec != 1)
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_2R_13TO15_OFF);
else
#endif
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_2R);
break;
case 3:
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_3R);
break;
case 4:
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_4R);
break;
default:
RTW_WARN("rx_nss:%u is not expected\n", rx_nss);
}
/* switch to the 40M Hz mode accoring to the AP */
/* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */
/* Secondary Channel Offset */
switch ((pmlmeinfo->HT_info.infos[0] & 0x3)) {
case IEEE80211_SCA:
pmlmeext->chandef.offset = CHAN_OFFSET_UPPER;
break;
case IEEE80211_SCB:
pmlmeext->chandef.offset = CHAN_OFFSET_LOWER;
break;
default:
pmlmeext->chandef.bw = CHANNEL_WIDTH_20;
pmlmeext->chandef.offset = CHAN_OFFSET_NO_EXT;
RTW_INFO("%s : ch offset is not assigned for HT40 mod , update cur_bwmode=%u, cur_ch_offset=%u\n",
__func__, pmlmeext->chandef.bw, pmlmeext->chandef.offset);
break;
}
}
/* */
/* Config SM Power Save setting */
/* */
pmlmeinfo->SM_PS = (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & 0x0C) >> 2;
if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC) {
#if 0
u8 i;
/* update the MCS rates */
for (i = 0; i < 16; i++)
pmlmeinfo->HT_caps.HT_cap_element.MCS_rate[i] &= MCS_rate_1R[i];
#endif
RTW_INFO("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __FUNCTION__);
}
/* */
/* Config current HT Protection mode. */
/* */
pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3;
}
#endif
#ifdef CONFIG_TDLS
void rtw_issue_addbareq_cmd_tdls(_adapter *padapter, struct xmit_frame *pxmitframe)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct sta_info *ptdls_sta = NULL;
u8 issued;
int priority;
struct ht_priv *phtpriv;
priority = pattrib->priority;
if (pattrib->direct_link == _TRUE) {
ptdls_sta = rtw_get_stainfo(&padapter->stapriv, pattrib->dst);
if ((ptdls_sta != NULL) && (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)) {
phtpriv = &ptdls_sta->htpriv;
if ((phtpriv->ht_option == _TRUE) && (phtpriv->ampdu_enable == _TRUE)) {
issued = (phtpriv->agg_enable_bitmap >> priority) & 0x1;
issued |= (phtpriv->candidate_tid_bitmap >> priority) & 0x1;
if (0 == issued) {
RTW_INFO("[%s], p=%d\n", __FUNCTION__, priority);
ptdls_sta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
rtw_addbareq_cmd(padapter, (u8)priority, pattrib->dst);
}
}
}
}
}
#endif /* CONFIG_TDLS */
#ifdef CONFIG_80211N_HT
static u8 rtw_issue_addbareq_check(_adapter *padapter, struct xmit_frame *pxmitframe, u8 issue_when_busy)
{
struct registry_priv *pregpriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct registry_priv *pregistry = &padapter->registrypriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
s32 bmcst = IS_MCAST(pattrib->ra);
if (bmcst)
return _FALSE;
if (pregpriv->wifi_spec == 1)
return _TRUE;
if (pregistry->tx_quick_addba_req == 0) {
if ((issue_when_busy == _TRUE) && (pmlmepriv->LinkDetectInfo.bBusyTraffic == _FALSE))
return _FALSE;
if (pmlmepriv->LinkDetectInfo.NumTxOkInPeriod < 100)
return _FALSE;
}
return _TRUE;
}
void rtw_issue_addbareq_cmd(_adapter *padapter, struct xmit_frame *pxmitframe, u8 issue_when_busy)
{
u8 issued;
int priority;
struct sta_info *psta = NULL;
struct ht_priv *phtpriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
if (rtw_issue_addbareq_check(padapter,pxmitframe, issue_when_busy) == _FALSE)
return;
priority = pattrib->priority;
#ifdef CONFIG_TDLS
rtw_issue_addbareq_cmd_tdls(padapter, pxmitframe);
#endif /* CONFIG_TDLS */
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta) {
RTW_INFO("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta);
return;
}
if (psta == NULL) {
RTW_INFO("%s, psta==NUL\n", __func__);
return;
}
if (!(psta->state & WIFI_ASOC_STATE)) {
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return;
}
phtpriv = &psta->htpriv;
if ((phtpriv->ht_option == _TRUE) && (phtpriv->ampdu_enable == _TRUE)) {
issued = (phtpriv->agg_enable_bitmap >> priority) & 0x1;
issued |= (phtpriv->candidate_tid_bitmap >> priority) & 0x1;
if (0 == issued) {
RTW_INFO("rtw_issue_addbareq_cmd, p=%d\n", priority);
psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
rtw_addbareq_cmd(padapter, (u8) priority, pattrib->ra);
}
}
}
#endif /* CONFIG_80211N_HT */
void rtw_append_extended_cap(_adapter *padapter, u8 *out_ie, uint *pout_len)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
#ifdef CONFIG_80211AC_VHT
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
#endif /* CONFIG_80211AC_VHT */
u8 *ext_cap_data = pmlmepriv->ext_capab_ie_data;
u8 *ext_cap_data_len = &(pmlmepriv->ext_capab_ie_len);
if (phtpriv->bss_coexist)
rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, BSS_COEXT);
#ifdef CONFIG_80211AC_VHT
if (pvhtpriv->vht_option)
rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, OP_MODE_NOTIFICATION);
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_RTW_WNM
rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, BSS_TRANSITION);
#endif
#ifdef CONFIG_RTW_MBO
rtw_add_ext_cap_info(ext_cap_data, ext_cap_data_len, INTERWORKING);
#endif
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif /* CONFIG_80211AX_HE */
/*
From 802.11 specification,if a STA does not support any of capabilities defined
in the Extended Capabilities element, then the STA is not required to
transmit the Extended Capabilities element.
*/
rtw_update_ext_cap_ie(ext_cap_data, *ext_cap_data_len, out_ie, pout_len, _BEACON_IE_OFFSET_);
}
#endif
#ifdef CONFIG_LAYER2_ROAMING
inline void rtw_set_to_roam(_adapter *adapter, u8 to_roam)
{
if (to_roam == 0)
adapter->mlmepriv.to_join = _FALSE;
adapter->mlmepriv.to_roam = to_roam;
}
inline u8 rtw_dec_to_roam(_adapter *adapter)
{
adapter->mlmepriv.to_roam--;
return adapter->mlmepriv.to_roam;
}
inline u8 rtw_to_roam(_adapter *adapter)
{
return adapter->mlmepriv.to_roam;
}
void rtw_roaming(_adapter *padapter, struct wlan_network *tgt_network)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
_rtw_spinlock_bh(&pmlmepriv->lock);
_rtw_roaming(padapter, tgt_network);
_rtw_spinunlock_bh(&pmlmepriv->lock);
}
void _rtw_roaming(_adapter *padapter, struct wlan_network *tgt_network)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *cur_network = &pmlmepriv->cur_network;
int do_join_r;
if (0 < rtw_to_roam(padapter)) {
RTW_INFO("roaming from %s("MAC_FMT"), length:%d\n",
cur_network->network.Ssid.Ssid, MAC_ARG(cur_network->network.MacAddress),
cur_network->network.Ssid.SsidLength);
_rtw_memcpy(&pmlmepriv->assoc_ssid, &cur_network->network.Ssid, sizeof(NDIS_802_11_SSID));
pmlmepriv->assoc_ch = 0;
pmlmepriv->assoc_by_bssid = _FALSE;
#ifdef CONFIG_WAPI_SUPPORT
rtw_wapi_return_all_sta_info(padapter);
#endif
while (1) {
do_join_r = rtw_do_join(padapter);
if (_SUCCESS == do_join_r)
break;
else {
RTW_INFO("roaming do_join return %d\n", do_join_r);
rtw_dec_to_roam(padapter);
if (rtw_to_roam(padapter) > 0)
continue;
else {
RTW_INFO("%s(%d) -to roaming fail, indicate_disconnect\n", __FUNCTION__, __LINE__);
#ifdef CONFIG_RTW_80211R
/* rtw_ft_clr_flags(padapter, RTW_FT_PEER_EN|RTW_FT_PEER_OTD_EN); */
rtw_ft_reset_status(padapter);
#endif
rtw_indicate_disconnect(padapter, 0, _FALSE);
break;
}
}
}
}
}
#endif /* CONFIG_LAYER2_ROAMING */
bool rtw_adjust_chbw(_adapter *adapter, u8 req_ch, u8 *req_bw, u8 *req_offset)
{
struct registry_priv *regsty = adapter_to_regsty(adapter);
u8 allowed_bw;
if (req_ch < 14)
allowed_bw = REGSTY_BW_2G(regsty);
else if (req_ch == 14)
allowed_bw = CHANNEL_WIDTH_20;
else
allowed_bw = REGSTY_BW_5G(regsty);
allowed_bw = rtw_hw_largest_bw(adapter_to_dvobj(adapter), allowed_bw);
if (allowed_bw == CHANNEL_WIDTH_80 && *req_bw > CHANNEL_WIDTH_80)
*req_bw = CHANNEL_WIDTH_80;
else if (allowed_bw == CHANNEL_WIDTH_40 && *req_bw > CHANNEL_WIDTH_40)
*req_bw = CHANNEL_WIDTH_40;
else if (allowed_bw == CHANNEL_WIDTH_20 && *req_bw > CHANNEL_WIDTH_20) {
*req_bw = CHANNEL_WIDTH_20;
*req_offset = CHAN_OFFSET_NO_EXT;
} else
return _FALSE;
return _TRUE;
}
sint rtw_linked_check(_adapter *padapter)
{
if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter)
|| MLME_IS_ADHOC(padapter) || MLME_IS_ADHOC_MASTER(padapter)
) {
if (padapter->stapriv.asoc_sta_count > 1)
return _TRUE;
} else {
/* Station mode */
if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
return _TRUE;
}
return _FALSE;
}
/*#define DBG_ADAPTER_STATE_CHK*/
u8 rtw_is_adapter_up(_adapter *padapter)
{
struct dvobj_priv *dvobj;
if (padapter == NULL)
return _FALSE;
dvobj = adapter_to_dvobj(padapter);
if (RTW_CANNOT_RUN(dvobj)) {
#ifdef DBG_ADAPTER_STATE_CHK
RTW_INFO(FUNC_ADPT_FMT " FALSE -bDriverStopped(%s) bSurpriseRemoved(%s)\n"
, FUNC_ADPT_ARG(padapter)
, dev_is_drv_stopped(dvobj) ? "True" : "False"
, dev_is_surprise_removed(dvobj) ? "True" : "False");
#endif
return _FALSE;
}
if (padapter->netif_up == _FALSE) {
#ifdef DBG_ADAPTER_STATE_CHK
RTW_INFO(FUNC_ADPT_FMT " FALSE -(netif_up == _FALSE)\n", FUNC_ADPT_ARG(padapter));
#endif
return _FALSE;
}
if (padapter->phl_role == NULL) {
#ifdef DBG_ADAPTER_STATE_CHK
RTW_INFO(FUNC_ADPT_FMT " FALSE -(phl_role == NULL)\n", FUNC_ADPT_ARG(padapter));
#endif
return _FALSE;
}
return _TRUE;
}
bool is_miracast_enabled(_adapter *adapter)
{
bool enabled = 0;
#ifdef CONFIG_WFD
struct wifi_display_info *wfdinfo = &adapter->wfd_info;
enabled = (wfdinfo->stack_wfd_mode & (MIRACAST_SOURCE | MIRACAST_SINK))
|| (wfdinfo->op_wfd_mode & (MIRACAST_SOURCE | MIRACAST_SINK));
#endif
return enabled;
}
bool rtw_chk_miracast_mode(_adapter *adapter, u8 mode)
{
bool ret = 0;
#ifdef CONFIG_WFD
struct wifi_display_info *wfdinfo = &adapter->wfd_info;
ret = (wfdinfo->stack_wfd_mode & mode) || (wfdinfo->op_wfd_mode & mode);
#endif
return ret;
}
const char *get_miracast_mode_str(int mode)
{
if (mode == MIRACAST_SOURCE)
return "SOURCE";
else if (mode == MIRACAST_SINK)
return "SINK";
else if (mode == (MIRACAST_SOURCE | MIRACAST_SINK))
return "SOURCE&SINK";
else if (mode == MIRACAST_DISABLED)
return "DISABLED";
else
return "INVALID";
}
#ifdef CONFIG_WFD
static bool wfd_st_match_rule(_adapter *adapter, u8 *local_naddr, u8 *local_port, u8 *remote_naddr, u8 *remote_port)
{
struct wifi_display_info *wfdinfo = &adapter->wfd_info;
if (ntohs(*((u16 *)local_port)) == wfdinfo->rtsp_ctrlport
|| ntohs(*((u16 *)local_port)) == wfdinfo->tdls_rtsp_ctrlport
|| ntohs(*((u16 *)remote_port)) == wfdinfo->peer_rtsp_ctrlport)
return _TRUE;
return _FALSE;
}
static struct st_register wfd_st_reg = {
.s_proto = 0x06,
.rule = wfd_st_match_rule,
};
#endif /* CONFIG_WFD */
inline void rtw_wfd_st_switch(struct sta_info *sta, bool on)
{
#ifdef CONFIG_WFD
if (on)
rtw_st_ctl_register(&sta->st_ctl, SESSION_TRACKER_REG_ID_WFD, &wfd_st_reg);
else
rtw_st_ctl_unregister(&sta->st_ctl, SESSION_TRACKER_REG_ID_WFD);
#endif
}
void dump_arp_pkt(void *sel, u8 *da, u8 *sa, u8 *arp, bool tx)
{
RTW_PRINT_SEL(sel, "%s ARP da="MAC_FMT", sa="MAC_FMT"\n"
, tx ? "send" : "recv", MAC_ARG(da), MAC_ARG(sa));
RTW_PRINT_SEL(sel, "htype=%u, ptype=0x%04x, hlen=%u, plen=%u, oper=%u\n"
, GET_ARP_HTYPE(arp), GET_ARP_PTYPE(arp), GET_ARP_HLEN(arp)
, GET_ARP_PLEN(arp), GET_ARP_OPER(arp));
RTW_PRINT_SEL(sel, "sha="MAC_FMT", spa="IP_FMT"\n"
, MAC_ARG(ARP_SENDER_MAC_ADDR(arp)), IP_ARG(ARP_SENDER_IP_ADDR(arp)));
RTW_PRINT_SEL(sel, "tha="MAC_FMT", tpa="IP_FMT"\n"
, MAC_ARG(ARP_TARGET_MAC_ADDR(arp)), IP_ARG(ARP_TARGET_IP_ADDR(arp)));
}
#ifdef CONFIG_STA_CMD_DISPR
/* software setting top half for connect abort */
static void _connect_abort_sw_top_half(struct _ADAPTER *a)
{
cancel_link_timer(&a->mlmeextpriv);
cancel_assoc_timer(&a->mlmepriv);
a->mlmeextpriv.join_abort = 1;
}
/* software setting bottom half for connect abort */
static void _connect_abort_sw_bottom_half(struct _ADAPTER *a)
{
/* ref: rtw_joinbss_event_prehandle(), join_res == -4 */
_clr_fwstate_(&a->mlmepriv, WIFI_UNDER_LINKING);
rtw_reset_securitypriv(a);
a->mlmeextpriv.join_abort = 0;
}
/*
* _connect_disconncet_hw - Handle hardware part of connect abort and fail
* @a: struct _ADAPTER *
*
* Handle hardware part of connect fail.
* Most implement is reference from bottom half of rtw_joinbss_event_callback()
* with join_res < 0.
*
* Reference functions:
* 1. rtw_joinbss_event_callback()
* 2. rtw_set_hw_after_join(a, -1)
* 3. rtw_hw_connect_abort()
*/
static void _connect_disconnect_hw(struct _ADAPTER *a)
{
struct dvobj_priv *d;
void *phl;
u8 *mac;
struct sta_info *sta;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
/* ref: rtw_set_hw_after_join(a, -1) */
mac = (u8*)a->mlmeextpriv.mlmext_info.network.MacAddress;
sta = rtw_get_stainfo(&a->stapriv, mac);
if (!sta) {
RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
FUNC_ADPT_ARG(a), MAC_ARG(mac));
return;
}
/* bottom half of rtw_hw_connect_abort() - start */
rtw_phl_chanctx_del(phl, a->phl_role, NULL);
/* restore original union ch */
rtw_join_done_chk_ch(a, -1);
/* free connecting AP sta info */
rtw_free_stainfo(a, sta);
rtw_init_self_stainfo(a);
/* bottom half of rtw_hw_connect_abort() - end */
/* bottom half of rtw_joinbss_event_callback() */
rtw_mi_os_xmit_schedule(a);
}
static void _connect_abort_notify_cb(void *priv, struct phl_msg *msg)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
RTW_DBG(FUNC_ADPT_FMT ": connect_st=%u\n",
FUNC_ADPT_ARG(a), a->connect_state);
_connect_disconnect_hw(a);
_connect_abort_sw_bottom_half(a);
_rtw_spinlock(&a->connect_st_lock);
if ((a->connect_state != CONNECT_ST_ACQUIRED) || !a->connect_abort) {
RTW_ERR(FUNC_ADPT_FMT ": connect_st=%u, abort is %s !\n",
FUNC_ADPT_ARG(a), a->connect_state,
a->connect_abort?"true":"false");
} else {
a->connect_state = CONNECT_ST_IDLE;
a->connect_abort = false;
}
_rtw_spinunlock(&a->connect_st_lock);
}
static enum rtw_phl_status _connect_abort_notify(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
enum rtw_phl_status status;
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_CONNECT);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_DISCONNECT);
msg.band_idx = a->phl_role->hw_band;
msg.rsvd[0] = (u8*)a->phl_role;
attr.opt = MSG_OPT_SEND_IN_ABORT;
attr.completion.completion = _connect_abort_notify_cb;
attr.completion.priv = a;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d), &msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
return status;
}
static void _connect_swch_done_notify_cb(void *priv, struct phl_msg *msg)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
RTW_DBG(FUNC_ADPT_FMT ": connect_st=%u\n",
FUNC_ADPT_ARG(a), a->connect_state);
if (msg->inbuf) {
rtw_vmfree(msg->inbuf, msg->inlen);
msg->inbuf = NULL;
}
}
static enum rtw_phl_status _connect_swch_done_notify(struct _ADAPTER *a,
struct rtw_chan_def *chandef)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
u8 *info = NULL;
enum rtw_phl_status status;
info = rtw_vmalloc(sizeof(struct rtw_chan_def));
if (!info) {
RTW_ERR(FUNC_ADPT_FMT ": Allocate msg hub buffer fail!\n",
FUNC_ADPT_ARG(a));
return RTW_PHL_STATUS_RESOURCE;
}
_rtw_memcpy(info, chandef, sizeof(struct rtw_chan_def));
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_CONNECT);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_SWCH_DONE);
msg.band_idx = a->phl_role->hw_band;
msg.inbuf = info;
msg.inlen = sizeof(struct rtw_chan_def);
attr.completion.completion = _connect_swch_done_notify_cb;
attr.completion.priv = a;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
&msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS) {
rtw_vmfree(info, sizeof(struct rtw_chan_def));
RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
}
return status;
}
static void _connect_cmd_done(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
enum rtw_phl_status status;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
if (!a->connect_token){
RTW_ERR(FUNC_ADPT_FMT ": token is NULL!\n", FUNC_ADPT_ARG(a));
return;
}
_rtw_spinlock(&a->connect_st_lock);
status = rtw_phl_free_cmd_token(GET_PHL_INFO(d),
role->hw_band, &a->connect_token);
a->connect_token = 0;
if (status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": free_cmd_token fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
a->connect_state = CONNECT_ST_IDLE;
a->connect_abort = false;
_rtw_spinunlock(&a->connect_st_lock);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
}
static enum phl_mdl_ret_code _connect_acquired(void* dispr, void *priv)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
struct dvobj_priv *d = adapter_to_dvobj(a);
struct _WLAN_BSSID_EX *network = &a->mlmeextpriv.mlmext_info.network;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
_rtw_spinlock(&a->connect_st_lock);
if (a->connect_state != CONNECT_ST_REQUESTING)
RTW_ERR(FUNC_ADPT_FMT ": connect_st=%u, not requesting?!\n",
FUNC_ADPT_ARG(a), a->connect_state);
a->connect_state = CONNECT_ST_ACQUIRED;
_rtw_spinunlock(&a->connect_st_lock);
/*rtw_hw_prepare_connect(a, NULL, network->MacAddress);*/
rtw_phl_connect_prepare(GET_PHL_INFO(d), a->phl_role,
network->MacAddress);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _connect_abort(void* dispr, void *priv)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
bool inner_abort = false;
enum rtw_phl_status phl_status = RTW_PHL_STATUS_FAILURE;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
_rtw_spinlock(&a->connect_st_lock);
RTW_INFO(FUNC_ADPT_FMT ": connect_st=%u, abort is %s\n",
FUNC_ADPT_ARG(a), a->connect_state,
a->connect_abort?"true":"false");
if (a->connect_state == CONNECT_ST_IDLE) {
_rtw_spinunlock(&a->connect_st_lock);
return MDL_RET_SUCCESS;
}
if (!a->connect_abort) {
RTW_INFO(FUNC_ADPT_FMT ": framework asking abort!\n",
FUNC_ADPT_ARG(a));
a->connect_abort = true;
inner_abort = true;
}
_rtw_spinunlock(&a->connect_st_lock);
_connect_abort_sw_top_half(a);
if (inner_abort) {
/* ref: rtw_join_timeout_handler() */
_rtw_spinlock_bh(&a->mlmepriv.lock);
a->mlmepriv.join_status = WLAN_STATUS_UNSPECIFIED_FAILURE;
rtw_indicate_disconnect(a, a->mlmepriv.join_status, _FALSE);
#ifdef CONFIG_IOCTL_CFG80211
rtw_cfg80211_indicate_disconnect(a, a->mlmepriv.join_status, _FALSE);
#endif /* CONFIG_IOCTL_CFG80211 */
a->mlmepriv.join_status = 0;
_rtw_spinunlock_bh(&a->mlmepriv.lock);
}
if (a->connect_state == CONNECT_ST_ACQUIRED)
phl_status = _connect_abort_notify(a);
a->connect_token = 0; /* framework will free this token later */
if (phl_status != RTW_PHL_STATUS_SUCCESS) {
/* No callback function, everything should be done here */
_connect_abort_sw_bottom_half(a);
_rtw_spinlock(&a->connect_st_lock);
a->connect_state = CONNECT_ST_IDLE;
a->connect_abort = false;
_rtw_spinunlock(&a->connect_st_lock);
}
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _connect_msg_hdlr(void* dispr, void* priv,
struct phl_msg* msg)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = NULL;
struct _WLAN_BSSID_EX *network = &a->mlmeextpriv.mlmext_info.network;
struct sta_info *sta = NULL;
u8 u_ch;
enum channel_width u_bw;
enum chan_offset u_offset;
struct phl_msg nextmsg = {0};
struct phl_msg_attribute attr = {0};
enum rtw_phl_status status;
enum phl_mdl_ret_code mdl_err;
int err;
u32 res;
RTW_DBG(FUNC_ADPT_FMT ": + msg_id=0x%08x\n",
FUNC_ADPT_ARG(a), msg->msg_id);
if (MSG_MDL_ID_FIELD(msg->msg_id) != PHL_FG_MDL_CONNECT) {
RTW_INFO(FUNC_ADPT_FMT ": Message is not from connect module, "
"skip msg_id=0x%08x\n", FUNC_ADPT_ARG(a), msg->msg_id);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_IGNORE;
}
if (IS_MSG_FAIL(msg->msg_id)) {
RTW_WARN(FUNC_ADPT_FMT ": cmd dispatcher notify cmd failure on "
"msg_id=0x%08x\n", FUNC_ADPT_ARG(a), msg->msg_id);
if (MSG_EVT_ID_FIELD(msg->msg_id) != MSG_EVT_DISCONNECT)
goto send_disconnect;
}
role = a->phl_role;
SET_MSG_MDL_ID_FIELD(nextmsg.msg_id, PHL_FG_MDL_CONNECT);
nextmsg.band_idx = role->hw_band;
switch (MSG_EVT_ID_FIELD(msg->msg_id)) {
case MSG_EVT_CONNECT_START:
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_CONNECT_START\n",
FUNC_ADPT_ARG(a));
/* ref: top half of rtw_join_cmd_hdl() */
sta = rtw_get_stainfo(&a->stapriv, a->phl_role->mac_addr);
rtw_free_stainfo(a, sta);
sta = rtw_alloc_stainfo(&a->stapriv, network->MacAddress);
if (sta == NULL) {
RTW_ERR(FUNC_ADPT_FMT ": alloc sta " MAC_FMT " fail!\n",
FUNC_ADPT_ARG(a), MAC_ARG(network->MacAddress));
rtw_init_self_stainfo(a);
goto send_disconnect;
}
/* check channel, bandwidth, offset and switch */
u_ch = a->mlmeextpriv.chandef.chan;
u_bw = a->mlmeextpriv.chandef.bw;
u_offset = a->mlmeextpriv.chandef.offset;
if (!rtw_phl_chanctx_add(GET_PHL_INFO(d), role,
&u_ch, &u_bw, &u_offset))
goto send_disconnect;
rtw_hw_update_chan_def(a);
rtw_mi_update_union_chan_inf(a, u_ch, (u8)u_offset, (u8)u_bw);
#ifdef CONFIG_ANTENNA_DIVERSITY
rtw_antenna_select_cmd(a, network->PhyInfo.Optimum_antenna, _FALSE);
#endif
#ifdef CONFIG_80211D
rtw_joinbss_update_regulatory(a, network);
#endif
SET_MSG_EVT_ID_FIELD(nextmsg.msg_id, MSG_EVT_SWCH_START);
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
&nextmsg, &attr, NULL);
break;
case MSG_EVT_SWCH_START:
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_SWCH_START\n",
FUNC_ADPT_ARG(a));
if (!role) {
RTW_ERR(FUNC_ADPT_FMT ": role == NULL\n",
FUNC_ADPT_ARG(a));
break;
}
/* ref: bottom half of rtw_join_cmd_hdl() */
RTW_DBG(FUNC_ADPT_FMT ": Switch to channel before link: "
"chan(%d), bw(%d), offset(%d)\n",
FUNC_ADPT_ARG(a),
d->iface_state.union_ch, d->iface_state.union_bw,
d->iface_state.union_offset);
set_channel_bwmode(a, d->iface_state.union_ch,
d->iface_state.union_offset,
d->iface_state.union_bw, _TRUE);
status = _connect_swch_done_notify(a, &role->chandef);
break;
case MSG_EVT_SWCH_DONE:
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_SWCH_DONE\n",
FUNC_ADPT_ARG(a));
/* ref: last part of rtw_join_cmd_hdl() */
cancel_link_timer(&a->mlmeextpriv);
start_clnt_join(a);
break;
case MSG_EVT_CONNECT_LINKED:
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_CONNECT_LINKED\n",
FUNC_ADPT_ARG(a));
/* ref: top half of rtw_joinbss_event_callback() */
err = rtw_set_hw_after_join(a, 0);
if (err) {
RTW_ERR(FUNC_ADPT_FMT ": set hardware fail(%d) during "
"connecting!\n",
FUNC_ADPT_ARG(a), err);
goto send_disconnect;
}
break;
case MSG_EVT_CONNECT_END:
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_CONNECT_END\n",
FUNC_ADPT_ARG(a));
/* ref: bottom half of rtw_set_hw_after_join() */
sta = rtw_get_stainfo(&a->stapriv, network->MacAddress);
if (sta)
rtw_xmit_queue_clear(sta);
else
RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
FUNC_ADPT_ARG(a), MAC_ARG(network->MacAddress));
/* ref: bottom half of rtw_joinbss_event_callback() */
rtw_mi_os_xmit_schedule(a);
_connect_cmd_done(a);
#ifdef CONFIG_LAYER2_ROAMING
if (a->securitypriv.dot11PrivacyAlgrthm == _NO_PRIVACY_)
dequeuq_roam_pkt(a);
#endif
break;
case MSG_EVT_DISCONNECT_PREPARE:
RTW_WARN(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT_PREPARE\n",
FUNC_ADPT_ARG(a));
/* STA connect fail case, top half */
/* top half of rtw_joinbss_event_callback() */
err = rtw_set_hw_after_join(a, -1);
if (err) {
RTW_ERR(FUNC_ADPT_FMT ": set hardware fail(%d) during "
"connect abort!\n",
FUNC_ADPT_ARG(a), err);
}
rtw_phl_disconnect(GET_PHL_INFO(d), a->phl_role, false);
break;
case MSG_EVT_DISCONNECT:
RTW_WARN(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT\n",
FUNC_ADPT_ARG(a));
/* STA connect fail case, bottom half */
_connect_disconnect_hw(a);
_connect_cmd_done(a);
break;
default:
break;
}
goto exit;
send_disconnect:
/*
* Trigger software handle and notify OS by rtw_joinbss_event_prehandle()
* Trigger hardware handle by sending MSG_EVT_DISCONNECT
*/
res = report_join_res(a, -4, WLAN_STATUS_UNSPECIFIED_FAILURE);
if (res != _SUCCESS) {
/*
* Fail to send MSG_EVT_DISCONNECT_PREPARE, do jobs in
* MSG_EVT_DISCONNECT_PREPARE and MSG_EVT_DISCONNECT directly
* here.
*/
/* ref: rtw_set_hw_after_join(a, -1) */
a->mlmepriv.wpa_phase = _FALSE;
sta = rtw_get_stainfo(&a->stapriv, network->MacAddress);
if (sta) {
/* rtw_hw_connect_abort(a, sta) */
rtw_hw_del_all_key(a, sta, PHL_CMD_DIRECTLY, 0);
status = rtw_phl_cmd_update_media_status(
GET_PHL_INFO(d),
sta->phl_sta, NULL, false,
PHL_CMD_DIRECTLY, 0);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR(FUNC_ADPT_FMT ": update media status "
"fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
}
_connect_disconnect_hw(a);
} else {
RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
FUNC_ADPT_ARG(a), MAC_ARG(network->MacAddress));
}
_connect_cmd_done(a);
}
exit:
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _connect_set_info(void* dispr, void* priv,
struct phl_module_op_info* info)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_IGNORE;
}
static enum phl_mdl_ret_code _connect_query_info(void* dispr, void* priv,
struct phl_module_op_info* info)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
enum phl_mdl_ret_code ret = MDL_RET_IGNORE;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
switch (info->op_code) {
case FG_REQ_OP_GET_ROLE:
info->outbuf = (u8*)a->phl_role;
ret = MDL_RET_SUCCESS;
break;
#ifdef RTW_WKARD_MRC_ISSUE_NULL_WITH_SCAN_OPS
case FG_REQ_OP_GET_ISSUE_NULL_OPS:
{
u8 (*issue_null)(void *, u8, bool) = scan_issu_null_data_cb;
info->outbuf = (u8 *)issue_null;
info->outlen = 0;
ret = MDL_RET_SUCCESS;
}
break;
#endif
default:
break;
}
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return ret;
}
enum rtw_phl_status rtw_connect_cmd(struct _ADAPTER *a,
struct _WLAN_BSSID_EX *network)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
struct rtw_chan_def *chdef;
struct mi_state mstate = {0};
struct phl_cmd_token_req *cmd_req;
enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
RTW_DBG(FUNC_ADPT_FMT ": st=%u\n",
FUNC_ADPT_ARG(a), a->connect_state);
_rtw_spinlock(&a->connect_st_lock);
if (a->connect_state != CONNECT_ST_IDLE) {
status = RTW_PHL_STATUS_SUCCESS;
RTW_WARN(FUNC_ADPT_FMT ": connect is on going...\n",
FUNC_ADPT_ARG(a));
goto exit;
}
if ((network->IELength > MAX_IE_SZ) || (network->IELength < 2)) {
status = RTW_PHL_STATUS_INVALID_PARAM;
RTW_ERR(FUNC_ADPT_FMT ": invalid IE length(%u)\n",
FUNC_ADPT_ARG(a), network->IELength);
goto exit;
}
/* ref: top half of rtw_join_cmd_hdl(), software only */
/* Todo: disconnect before connecting */
/*set_hw_before_join(a);*/
/* Update HT/VHT/HE CAP and chan/bw/offset to a->mlmeextpriv.mlmext_info.network */
update_join_info(a, network);
/* check channel, bandwidth, offset and switch */
chdef = &a->mlmeextpriv.chandef;
if (!rtw_phl_chanctx_chk(GET_PHL_INFO(d), role,
chdef->chan, chdef->bw, chdef->offset)) {
/* ref: not group case in rtw_chk_start_clnt_join() */
rtw_mi_status_no_self(a, &mstate);
RTW_WARN(FUNC_ADPT_FMT ": channel group fail! ld_sta_num:%u, "
"ap_num:%u, mesh_num:%u\n",
FUNC_ADPT_ARG(a), MSTATE_STA_LD_NUM(&mstate),
MSTATE_AP_NUM(&mstate), MSTATE_MESH_NUM(&mstate));
if ((MSTATE_STA_LD_NUM(&mstate) + MSTATE_AP_LD_NUM(&mstate)
+ MSTATE_MESH_LD_NUM(&mstate)) >= 4) {
status = RTW_PHL_STATUS_RESOURCE;
goto exit;
}
rtw_mi_buddy_disconnect(a);
}
cmd_req = &a->connect_req;
cmd_req->role = role;
status = rtw_phl_add_cmd_token_req(GET_PHL_INFO(d),
role->hw_band,
cmd_req, &a->connect_token);
if ((status != RTW_PHL_STATUS_SUCCESS)
&& (status != RTW_PHL_STATUS_PENDING)) {
RTW_ERR(FUNC_ADPT_FMT ": add_cmd_token_req fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
goto exit;
}
a->connect_state = CONNECT_ST_REQUESTING;
status = RTW_PHL_STATUS_SUCCESS;
exit:
_rtw_spinunlock(&a->connect_st_lock);
RTW_DBG(FUNC_ADPT_FMT ": - st=%u ret=%u\n",
FUNC_ADPT_ARG(a), a->connect_state, status);
return status;
}
void rtw_connect_abort(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
enum rtw_phl_status status;
RTW_WARN(FUNC_ADPT_FMT ": connect_st=%u, abort=%u\n",
FUNC_ADPT_ARG(a), a->connect_state, a->connect_abort);
if (a->connect_state == CONNECT_ST_NOT_READY)
return;
_rtw_spinlock(&a->connect_st_lock);
if ((a->connect_state == CONNECT_ST_IDLE) || a->connect_abort) {
_rtw_spinunlock(&a->connect_st_lock);
return;
}
a->mlmepriv.wpa_phase = _FALSE;
a->connect_abort = true;
_rtw_spinunlock(&a->connect_st_lock);
status = rtw_phl_cancel_cmd_token(GET_PHL_INFO(d),
role->hw_band,
&a->connect_token);
a->connect_token = 0;
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR(FUNC_ADPT_FMT ": cancel_cmd_token fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
/* Cancel fail, and something needed to be handled by self */
/* Release connect resource (software) */
_connect_abort_sw_top_half(a);
_connect_abort_sw_bottom_half(a);
_rtw_spinlock(&a->connect_st_lock);
a->connect_state = CONNECT_ST_IDLE;
a->connect_abort = false;
_rtw_spinunlock(&a->connect_st_lock);
}
}
#define _CONNECT_ABORT_TO_ 5000 /* unit: ms */
/**
* rtw_connect_abort_wait() - Abort connect FG and wait to finish
* @a pointer of struct _ADAPTER
*
* Send cancel cmd to framework and wait connect FG to stop.
*
* Return 0 for connect FG already stopped, -1 for sending cancel command
* fail, or -2 for waiting connect FG stop timeout.
*/
int rtw_connect_abort_wait(struct _ADAPTER *a)
{
u32 timeout = _CONNECT_ABORT_TO_;
systime start_t;
u32 pass_t = 0;
u32 msg_i; /* message interval */
u32 msg_t = 0; /* next time point to print message */
int err = 0;
if (a->connect_state == CONNECT_ST_NOT_READY)
return err;
msg_i = timeout / 10; /* at most print 10 msg in whole waiting time */
if (!msg_i)
msg_i = 1;
_rtw_spinlock(&a->connect_st_lock);
start_t = rtw_get_current_time();
while (a->connect_state != CONNECT_ST_IDLE) {
if (pass_t >= msg_t) {
RTW_INFO(FUNC_ADPT_FMT ": connect st=%u, %u ms/%u pass...\n",
FUNC_ADPT_ARG(a), a->connect_state, pass_t, timeout);
msg_t += msg_i;
}
_rtw_spinunlock(&a->connect_st_lock);
pass_t = rtw_get_passing_time_ms(start_t);
if (pass_t > timeout) {
RTW_ERR(FUNC_ADPT_FMT ": Timeout, fail to abort connect!"
" used:%u > max:%u ms\n",
FUNC_ADPT_ARG(a), pass_t, timeout);
err = -2; /* Timeout */
_rtw_spinlock(&a->connect_st_lock);
break;
}
rtw_connect_abort(a);
rtw_msleep_os(1);
_rtw_spinlock(&a->connect_st_lock);
}
_rtw_spinunlock(&a->connect_st_lock);
return err;
}
void rtw_connect_req_free(struct _ADAPTER *a)
{
if (a->connect_state == CONNECT_ST_NOT_READY)
return;
rtw_connect_abort_wait(a);
_rtw_spinlock_free(&a->connect_st_lock);
/* Terminate state, lock protection is not necessary */
a->connect_state = CONNECT_ST_NOT_READY;
}
void rtw_connect_req_init(struct _ADAPTER *a)
{
struct phl_cmd_token_req *req;
if (a->connect_state != CONNECT_ST_NOT_READY) {
RTW_WARN(FUNC_ADPT_FMT ": connect_st=%u, not NOT_READY?!\n",
FUNC_ADPT_ARG(a), a->connect_state);
return;
}
_rtw_spinlock_init(&a->connect_st_lock);
req = &a->connect_req;
req->module_id = PHL_FG_MDL_CONNECT;
req->priv = a;
req->role = NULL; /* a->phl_role, but role will change by time */
req->acquired = _connect_acquired;
req->abort = _connect_abort;
req->msg_hdlr = _connect_msg_hdlr;
req->set_info = _connect_set_info;
req->query_info = _connect_query_info;
/* initialize state, lock protection is not necessary */
a->connect_state = CONNECT_ST_IDLE;
a->connect_abort = false;
}
enum rtw_phl_status rtw_connect_disconnect_prepare(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
enum rtw_phl_status status;
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_CONNECT);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_DISCONNECT_PREPARE);
msg.band_idx = a->phl_role->hw_band;
msg.rsvd[0] = (u8*)a->phl_role;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d), &msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
return status;
}
static enum rtw_phl_status _disconnect_done_notify(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
struct rtw_wifi_role_t *wrole = a->phl_role;
enum rtw_phl_status status;
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_FG_MDL_DISCONNECT);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_DISCONNECT);
msg.band_idx = wrole->hw_band;
msg.rsvd[0] = (u8*)wrole;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d), &msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": send_msg_to_dispr fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
return status;
}
static void _disconnect_free_cmdobj(struct _ADAPTER *a)
{
struct cmd_obj *cmd;
cmd = a->discon_cmd;
if (!cmd)
return;
_rtw_spinlock(&a->disconnect_lock);
a->discon_cmd = NULL;
if (cmd->sctx) {
if (cmd->res == H2C_SUCCESS)
rtw_sctx_done(&cmd->sctx);
else
rtw_sctx_done_err(&cmd->sctx, RTW_SCTX_DONE_CMD_ERROR);
}
_rtw_spinunlock(&a->disconnect_lock);
rtw_free_cmd_obj(cmd);
}
static void _disconnect_cmd_done(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
enum rtw_phl_status status;
RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
FUNC_ADPT_ARG(a), a->disconnect_token);
_rtw_spinlock(&a->disconnect_lock);
/* avoid to race with rtw_disconnect_abort() */
if (!a->disconnect_token) {
RTW_WARN(FUNC_ADPT_FMT ": Others try to stop disconnect!\n",
FUNC_ADPT_ARG(a));
_rtw_spinunlock(&a->disconnect_lock);
return;
}
status = rtw_phl_free_cmd_token(GET_PHL_INFO(d),
role->hw_band, &a->disconnect_token);
if (status != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": free_cmd_token fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
a->disconnect_token = 0;
_rtw_spinunlock(&a->disconnect_lock);
_disconnect_free_cmdobj(a);
}
static enum phl_mdl_ret_code _disconnect_acquired(void* dispr, void *priv)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
struct dvobj_priv *d = adapter_to_dvobj(a);
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
rtw_phl_disconnect(GET_PHL_INFO(d), a->phl_role, true);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _disconnect_abort(void* dispr, void *priv)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
FUNC_ADPT_ARG(a), a->disconnect_token);
/*
* Framework will free disconnect token automatically after abort,
* so do all in _disconnect_cmd_done() besides rtw_phl_free_cmd_token().
* ref: _disconnect_cmd_done()
*/
if (a->disconnect_token) {
RTW_WARN(FUNC_ADPT_FMT ": framework asking abort!\n",
FUNC_ADPT_ARG(a));
a->disconnect_token = 0;
}
_disconnect_free_cmdobj(a);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _disconnect_msg_hdlr(void* dispr, void* priv,
struct phl_msg* msg)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
struct disconnect_parm *discon;
struct stadel_event *stadel;
struct _WLAN_BSSID_EX *network;
u8 is_issue_deauth;
u32 retry = 0;
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
RTW_DBG(FUNC_ADPT_FMT ": + msg_id=0x%08x\n",
FUNC_ADPT_ARG(a), msg->msg_id);
if (MSG_MDL_ID_FIELD(msg->msg_id) != PHL_FG_MDL_DISCONNECT) {
RTW_INFO(FUNC_ADPT_FMT ": Message is not from disconnect module, "
"skip msg_id=0x%08x\n", FUNC_ADPT_ARG(a), msg->msg_id);
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_IGNORE;
}
/* Whether msg fail or not */
switch (MSG_EVT_ID_FIELD(msg->msg_id)) {
case MSG_EVT_DISCONNECT_PREPARE:
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT_PREPARE\n",
FUNC_ADPT_ARG(a));
/*
* ref: Top half of disconnect_hdl(), before and including
* rtw_mlmeext_disconnect().
* Note: The bottom half, after rtw_mlmeext_disconnect(),
* would be put to case MSG_EVT_DISCONNECT.
*/
if ((a->discon_cmd->cmdcode == CMD_SET_MLME_EVT)
#if CONFIG_DFS
|| IS_RADAR_DETECTED(adapter_to_rfctl(a))
|| adapter_to_rfctl(a)->csa_chandef.chan
#endif
)
is_issue_deauth = 0;
else
is_issue_deauth = 1;
if (is_issue_deauth) {
#ifdef CONFIG_PLATFORM_ROCKCHIPS
/*
* To avoid connecting to AP fail during resume process,
* change retry count from 5 to 1
*/
retry = 1;
#else /* !CONFIG_PLATFORM_ROCKCHIPS */
discon = (struct disconnect_parm*)a->discon_cmd->parmbuf;
retry = discon->deauth_timeout_ms / 100;
#endif /* !CONFIG_PLATFORM_ROCKCHIPS */
network = &a->mlmeextpriv.mlmext_info.network;
issue_deauth_ex(a, network->MacAddress,
WLAN_REASON_DEAUTH_LEAVING,
retry, 100);
}
rtw_mlmeext_disconnect(a);
status = _disconnect_done_notify(a);
if (status == RTW_PHL_STATUS_SUCCESS)
break;
/* fall through */
case MSG_EVT_DISCONNECT:
RTW_DBG(FUNC_ADPT_FMT ": MSG_EVT_DISCONNECT\n",
FUNC_ADPT_ARG(a));
if (a->discon_cmd->cmdcode == CMD_SET_MLME_EVT) {
/* EVT_DEL_STA case */
/* ref: bottom half of rtw_stadel_event_callback() */
stadel = (struct stadel_event*)(a->discon_cmd->parmbuf
+ sizeof(struct rtw_evt_header));
_stadel_posthandle_sta(a, stadel);
} else {
rtw_free_assoc_resources(a, _TRUE);
}
rtw_phl_disconnected_resume_hdlr(GET_PHL_INFO(adapter_to_dvobj(a)),
a->phl_role);
_disconnect_cmd_done(a);
break;
default:
break;
}
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_SUCCESS;
}
static enum phl_mdl_ret_code _disconnect_set_info(void* dispr, void* priv,
struct phl_module_op_info* info)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return MDL_RET_IGNORE;
}
static enum phl_mdl_ret_code _disconnect_query_info(void* dispr, void* priv,
struct phl_module_op_info* info)
{
struct _ADAPTER *a = (struct _ADAPTER *)priv;
enum phl_mdl_ret_code ret = MDL_RET_IGNORE;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
switch (info->op_code) {
case FG_REQ_OP_GET_ROLE:
info->outbuf = (u8 *)a->phl_role;
ret = MDL_RET_SUCCESS;
break;
default:
break;
}
RTW_DBG(FUNC_ADPT_FMT ": -\n", FUNC_ADPT_ARG(a));
return ret;
}
enum rtw_phl_status rtw_disconnect_cmd(struct _ADAPTER *a, struct cmd_obj *pcmd)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
struct rtw_evt_header *hdr;
struct stadel_event *stadel;
struct sta_info *sta;
struct phl_cmd_token_req *cmd_req;
enum rtw_phl_status phl_status = RTW_PHL_STATUS_FAILURE;
RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
FUNC_ADPT_ARG(a), a->disconnect_token);
if (a->disconnect_token) {
RTW_WARN(FUNC_ADPT_FMT ": disconnect is on going...\n",
FUNC_ADPT_ARG(a));
return RTW_PHL_STATUS_FAILURE;
}
if (pcmd->cmdcode == CMD_SET_MLME_EVT) {
/* EVT_DEL_STA case */
/* ref: top half of rtw_stadel_event_callback() */
hdr = (struct rtw_evt_header*)pcmd->parmbuf;
stadel = (struct stadel_event *)(pcmd->parmbuf + sizeof(*hdr));
sta = rtw_get_stainfo(&a->stapriv, stadel->macaddr);
if (!sta) {
RTW_ERR(FUNC_ADPT_FMT ": stainfo(" MAC_FMT ") not exist!\n",
FUNC_ADPT_ARG(a), MAC_ARG(stadel->macaddr));
return RTW_PHL_STATUS_FAILURE;
}
rtw_wfd_st_switch(sta, 0);
sta->hw_decrypted = _FALSE;
}
a->discon_cmd = pcmd;
cmd_req = &a->disconnect_req;
cmd_req->role = role;
phl_status = rtw_phl_add_cmd_token_req(GET_PHL_INFO(d),
role->hw_band,
cmd_req, &a->disconnect_token);
if ((phl_status != RTW_PHL_STATUS_SUCCESS)
&& (phl_status != RTW_PHL_STATUS_PENDING)) {
RTW_WARN(FUNC_ADPT_FMT ": add_cmd_token_req fail(0x%x)!\n",
FUNC_ADPT_ARG(a), phl_status);
return RTW_PHL_STATUS_FAILURE;
}
RTW_DBG(FUNC_ADPT_FMT ": - token=0x%08x\n",
FUNC_ADPT_ARG(a), a->disconnect_token);
return RTW_PHL_STATUS_SUCCESS;
}
/* Wait disconnect FG to finish */
static bool _disconnect_wait(struct _ADAPTER *a, u32 timeout)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
systime start;
u32 pass_t;
u32 msg_i; /* message interval */
u32 msg_t = 0; /* next time point to print message */
enum rtw_phl_status status;
bool terminated = false;
RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
FUNC_ADPT_ARG(a), a->disconnect_token);
msg_i = timeout / 10; /* at most print 10 msg in whole waiting time */
if (!msg_i)
msg_i = 1;
start = rtw_get_current_time();
do {
_rtw_spinlock(&a->disconnect_lock);
pass_t = rtw_get_passing_time_ms(start);
if (!a->discon_cmd) {
_rtw_spinunlock(&a->disconnect_lock);
terminated = true;
break;
}
_rtw_spinunlock(&a->disconnect_lock);
if (pass_t >= msg_t) {
RTW_DBG(FUNC_ADPT_FMT ": Waiting disconnect FG, %u ms/%u pass...\n",
FUNC_ADPT_ARG(a), pass_t, timeout);
msg_t += msg_i;
}
if (pass_t > timeout) {
RTW_ERR(FUNC_ADPT_FMT ": Timeout! used:%u > max:%u ms\n",
FUNC_ADPT_ARG(a), pass_t, timeout);
break;
}
rtw_usleep_os(_rtw_systime_to_us(1)); /* sleep 1/HZ sec */
} while (1);
RTW_DBG(FUNC_ADPT_FMT ": Stop waiting disconnect FG, cost %u ms\n",
FUNC_ADPT_ARG(a), pass_t);
exit:
RTW_DBG(FUNC_ADPT_FMT ": - %s\n", FUNC_ADPT_ARG(a), terminated?"OK":"Fail!");
return terminated;
}
/**
* rtw_disconnect_abort() - Send cmd to abort disconnect FG
* @a pointer of struct _ADAPTER
*
* Send cancel cmd to framework to stop disconnect FG.
*
* Return 0 for sending command ok, 1 for not necessary to send command because
* no disconnect FG exist, or negative status code returned from function
* rtw_phl_cancel_cmd_token().
*/
static int rtw_disconnect_abort(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
u32 token;
enum rtw_phl_status status;
int err = 0;
RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
FUNC_ADPT_ARG(a), a->disconnect_token);
_rtw_spinlock(&a->disconnect_lock);
/* avoid to race with _disconnect_cmd_done() */
if (!a->disconnect_token) {
_rtw_spinunlock(&a->disconnect_lock);
err = 1;
goto exit;
}
token = a->disconnect_token;
status = rtw_phl_cancel_cmd_token(GET_PHL_INFO(d),
role->hw_band, &token);
if (status == RTW_PHL_STATUS_SUCCESS) {
a->disconnect_token = 0;
} else {
err = -status;
RTW_ERR(FUNC_ADPT_FMT ": cancel_cmd_token fail(0x%x)!\n",
FUNC_ADPT_ARG(a), status);
}
_rtw_spinunlock(&a->disconnect_lock);
exit:
RTW_DBG(FUNC_ADPT_FMT ": - err=%d\n", FUNC_ADPT_ARG(a), err);
return err;
}
#define _DISCONNECT_ABORT_TO_ 3000 /* unit: ms */
/**
* rtw_disconnect_abort_wait() - Abort disconnect FG and wait to finish
* @a pointer of struct _ADAPTER
*
* Send cancel cmd to framework and wait disconnect FG to stop.
*
* Return 0 for disconnect FG already stopped, -1 for sending cancel command
* fail, or -2 for waiting disconnect FG stop timeout.
*/
int rtw_disconnect_abort_wait(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_wifi_role_t *role = a->phl_role;
u32 token;
enum rtw_phl_status status;
int ret, err = 0;
RTW_DBG(FUNC_ADPT_FMT ": + token=0x%08x\n",
FUNC_ADPT_ARG(a), a->disconnect_token);
if (!a->disconnect_token)
goto exit;
ret = rtw_disconnect_abort(a);
if (ret) {
if (ret < 0)
err = -1; /* Fail to send cancel cmd */
goto exit;
}
if (!_disconnect_wait(a, _DISCONNECT_ABORT_TO_))
err = -2; /* Timeout */
exit:
RTW_DBG(FUNC_ADPT_FMT ": - err=%d\n", FUNC_ADPT_ARG(a), err);
return err;
}
void rtw_disconnect_req_free(struct _ADAPTER *a)
{
rtw_disconnect_abort_wait(a);
_rtw_spinlock_free(&a->disconnect_lock);
}
void rtw_disconnect_req_init(struct _ADAPTER *a)
{
struct phl_cmd_token_req *req;
_rtw_spinlock_init(&a->disconnect_lock);
req = &a->disconnect_req;
req->module_id = PHL_FG_MDL_DISCONNECT;
req->priv = a;
req->role = NULL; /* a->phl_role, but role will change by time */
req->acquired = _disconnect_acquired;
req->abort = _disconnect_abort;
req->msg_hdlr = _disconnect_msg_hdlr;
req->set_info = _disconnect_set_info;
req->query_info = _disconnect_query_info;
}
#endif /* CONFIG_STA_CMD_DISPR */
|
2301_81045437/rtl8852be
|
core/rtw_mlme.c
|
C
|
agpl-3.0
| 177,636
|
/******************************************************************************
*
* Copyright(c) 2007 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_MLME_EXT_C_
#include <drv_types.h>
struct mlme_handler mlme_sta_tbl[] = {
{WIFI_ASSOCREQ, "OnAssocReq", &OnAssocReq},
{WIFI_ASSOCRSP, "OnAssocRsp", &OnAssocRsp},
{WIFI_REASSOCREQ, "OnReAssocReq", &OnAssocReq},
{WIFI_REASSOCRSP, "OnReAssocRsp", &OnAssocRsp},
{WIFI_PROBEREQ, "OnProbeReq", &OnProbeReq},
{WIFI_PROBERSP, "OnProbeRsp", &OnProbeRsp},
/*----------------------------------------------------------
below 2 are reserved
-----------------------------------------------------------*/
{0, "DoReserved", &DoReserved},
{0, "DoReserved", &DoReserved},
{WIFI_BEACON, "OnBeacon", &OnBeacon},
{WIFI_ATIM, "OnATIM", &OnAtim},
{WIFI_DISASSOC, "OnDisassoc", &OnDisassoc},
{WIFI_AUTH, "OnAuth", &OnAuthClient},
{WIFI_DEAUTH, "OnDeAuth", &OnDeAuth},
{WIFI_ACTION, "OnAction", &OnAction},
{WIFI_ACTION_NOACK, "OnActionNoAck", &OnAction},
};
#ifdef _CONFIG_NATIVEAP_MLME_
struct mlme_handler mlme_ap_tbl[] = {
{WIFI_ASSOCREQ, "OnAssocReq", &OnAssocReq},
{WIFI_ASSOCRSP, "OnAssocRsp", &OnAssocRsp},
{WIFI_REASSOCREQ, "OnReAssocReq", &OnAssocReq},
{WIFI_REASSOCRSP, "OnReAssocRsp", &OnAssocRsp},
{WIFI_PROBEREQ, "OnProbeReq", &OnProbeReq},
{WIFI_PROBERSP, "OnProbeRsp", &OnProbeRsp},
/*----------------------------------------------------------
below 2 are reserved
-----------------------------------------------------------*/
{0, "DoReserved", &DoReserved},
{0, "DoReserved", &DoReserved},
{WIFI_BEACON, "OnBeacon", &OnBeacon},
{WIFI_ATIM, "OnATIM", &OnAtim},
{WIFI_DISASSOC, "OnDisassoc", &OnDisassoc},
{WIFI_AUTH, "OnAuth", &OnAuth},
{WIFI_DEAUTH, "OnDeAuth", &OnDeAuth},
{WIFI_ACTION, "OnAction", &OnAction},
{WIFI_ACTION_NOACK, "OnActionNoAck", &OnAction},
};
#endif
struct action_handler OnAction_tbl[] = {
{RTW_WLAN_CATEGORY_SPECTRUM_MGMT, "ACTION_SPECTRUM_MGMT", on_action_spct},
{RTW_WLAN_CATEGORY_QOS, "ACTION_QOS", &OnAction_qos},
{RTW_WLAN_CATEGORY_DLS, "ACTION_DLS", &OnAction_dls},
{RTW_WLAN_CATEGORY_BACK, "ACTION_BACK", &OnAction_back},
{RTW_WLAN_CATEGORY_PUBLIC, "ACTION_PUBLIC", on_action_public},
{RTW_WLAN_CATEGORY_RADIO_MEAS, "ACTION_RADIO_MEAS", &on_action_rm},
{RTW_WLAN_CATEGORY_FT, "ACTION_FT", &OnAction_ft},
{RTW_WLAN_CATEGORY_HT, "ACTION_HT", &OnAction_ht},
#ifdef CONFIG_IEEE80211W
{RTW_WLAN_CATEGORY_SA_QUERY, "ACTION_SA_QUERY", &OnAction_sa_query},
#else
{RTW_WLAN_CATEGORY_SA_QUERY, "ACTION_SA_QUERY", &DoReserved},
#endif /* CONFIG_IEEE80211W */
#ifdef CONFIG_RTW_WNM
{RTW_WLAN_CATEGORY_WNM, "ACTION_WNM", &on_action_wnm},
#endif
{RTW_WLAN_CATEGORY_UNPROTECTED_WNM, "ACTION_UNPROTECTED_WNM", &DoReserved},
#ifdef CONFIG_RTW_MESH
{RTW_WLAN_CATEGORY_MESH, "ACTION_MESH", &on_action_mesh},
{RTW_WLAN_CATEGORY_SELF_PROTECTED, "ACTION_SELF_PROTECTED", &on_action_self_protected},
#endif
{RTW_WLAN_CATEGORY_WMM, "ACTION_WMM", &OnAction_wmm},
{RTW_WLAN_CATEGORY_VHT, "ACTION_VHT", &OnAction_vht},
{RTW_WLAN_CATEGORY_HE, "ACTION_HE", &OnAction_he},
{RTW_WLAN_CATEGORY_PROTECTED_HE, "ACTION_PROTECTED_HE", &OnAction_protected_he},
{RTW_WLAN_CATEGORY_P2P, "ACTION_P2P", &OnAction_p2p},
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
{RTW_WLAN_CATEGORY_TBTX, "ACTION_TBTX_TOKEN", &OnAction_tbtx_token}
#endif
};
u8 null_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
/**************************************************
OUI definitions for the vendor specific IE
***************************************************/
unsigned char RTW_WPA_OUI[] = {0x00, 0x50, 0xf2, 0x01};
unsigned char WMM_OUI[] = {0x00, 0x50, 0xf2, 0x02};
unsigned char WPS_OUI[] = {0x00, 0x50, 0xf2, 0x04};
unsigned char P2P_OUI[] = {0x50, 0x6F, 0x9A, 0x09};
unsigned char WFD_OUI[] = {0x50, 0x6F, 0x9A, 0x0A};
unsigned char DPP_OUI[] = {0x50, 0x6F, 0x9A, 0x1A};
unsigned char MULTI_AP_OUI[] = {0x50, 0x6F, 0x9A, 0x1B};
unsigned char WMM_INFO_OUI[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01};
unsigned char WMM_PARA_OUI[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
unsigned char WPA_TKIP_CIPHER[4] = {0x00, 0x50, 0xf2, 0x02};
unsigned char RSN_TKIP_CIPHER[4] = {0x00, 0x0f, 0xac, 0x02};
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
unsigned char REALTEK_TBTX_IE[] = {0x00, 0xe0, 0x4c, 0x01, 0x00, 0x00, 0x00, 0x00};
#endif
extern unsigned char REALTEK_96B_IE[];
static void init_channel_list(_adapter *padapter, RT_CHANNEL_INFO *channel_set
, struct p2p_channels *channel_list)
{
struct registry_priv *regsty = adapter_to_regsty(padapter);
struct p2p_oper_class_map op_class[] = {
{ IEEE80211G, 81, 1, 13, 1, BW20 },
{ IEEE80211G, 82, 14, 14, 1, BW20 },
#if 0 /* Do not enable HT40 on 2 GHz */
{ IEEE80211G, 83, 1, 9, 1, BW40PLUS },
{ IEEE80211G, 84, 5, 13, 1, BW40MINUS },
#endif
{ IEEE80211A, 115, 36, 48, 4, BW20 },
{ IEEE80211A, 116, 36, 44, 8, BW40PLUS },
{ IEEE80211A, 117, 40, 48, 8, BW40MINUS },
{ IEEE80211A, 124, 149, 161, 4, BW20 },
{ IEEE80211A, 125, 149, 169, 4, BW20 },
{ IEEE80211A, 126, 149, 157, 8, BW40PLUS },
{ IEEE80211A, 127, 153, 161, 8, BW40MINUS },
{ -1, 0, 0, 0, 0, BW20 }
};
int cla, op;
cla = 0;
for (op = 0; op_class[op].op_class; op++) {
u8 ch;
struct p2p_oper_class_map *o = &op_class[op];
struct p2p_reg_class *reg = NULL;
for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
if (rtw_chset_search_ch(channel_set, ch) == -1)
continue;
#if defined(CONFIG_80211N_HT) || defined(CONFIG_80211AC_VHT) /* CONFIG_80211AX_HE_TODO */
if ((padapter->registrypriv.ht_enable == 0) && (o->inc == 8))
continue;
if ((REGSTY_IS_BW_5G_SUPPORT(regsty, CHANNEL_WIDTH_40)) &&
((o->bw == BW40MINUS) || (o->bw == BW40PLUS)))
continue;
#endif
if (reg == NULL) {
reg = &channel_list->reg_class[cla];
cla++;
reg->reg_class = o->op_class;
reg->channels = 0;
}
reg->channel[reg->channels] = ch;
reg->channels++;
}
}
channel_list->reg_classes = cla;
}
#if CONFIG_TXPWR_LIMIT
bool rtw_rfctl_is_current_txpwr_lmt(struct rf_ctl_t *rfctl, const char *name)
{
const char *cur_name;
int band;
for (band = 0; band < BAND_MAX; band++) {
cur_name = rtw_phl_get_pw_lmt_regu_type_str(GET_PHL_INFO(rfctl_to_dvobj(rfctl)), band);
if (cur_name && strcmp(name, cur_name) == 0)
return 1;
}
return 0;
}
#endif /* CONFIG_TXPWR_LIMIT */
int rtw_rfctl_init(struct dvobj_priv *dvobj)
{
struct registry_priv *regsty = dvobj_to_regsty(dvobj);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
int ret;
rfctl->user_ChannelPlan = RTW_CHPLAN_UNSPECIFIED;
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->user_chplan_6g = RTW_CHPLAN_6G_UNSPECIFIED;
#endif
#ifdef CONFIG_80211D
rfctl->country_ie_slave_en_role = regsty->country_ie_slave_en_role;
rfctl->country_ie_slave_en_ifbmp = regsty->country_ie_slave_en_ifbmp;
rfctl->effected_cisr_id = CONFIG_IFACE_NUMBER;
#endif
rfctl->ch_sel_within_same_band = 1;
rfctl->last_edcca_mode_op_band = BAND_MAX;
#ifdef CONFIG_DFS_MASTER
rfctl->dfs_region_domain = regsty->dfs_region_domain;
rfctl->cac_start_time = rfctl->cac_end_time = RTW_CAC_STOPPED;
rtw_init_timer(&(rfctl->radar_detect_timer), rtw_dfs_rd_timer_hdl, rfctl);
#endif
#if CONFIG_DFS_SLAVE_WITH_RADAR_DETECT
rfctl->dfs_slave_with_rd = 1;
#endif
ret = op_class_pref_init(adapter);
if (ret != _SUCCESS)
op_class_pref_deinit(adapter);
return ret;
}
void rtw_rfctl_deinit(struct dvobj_priv *dvobj)
{
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
_rtw_mutex_free(&rfctl->offch_mutex);
op_class_pref_deinit(adapter);
}
/*
* Description:
* Use hardware(efuse), driver parameter(registry) and default channel plan
* to decide which one should be used.
*
* Parameters:
* rfctl pointer of rfctl
* hw_alpha2 country code from HW (efuse/eeprom/mapfile)
* hw_chplan domain code from HW (efuse/eeprom/mapfile)
* hw_chplan_6g 6g domain code from HW (efuse/eeprom/mapfile)
* hw_force_chplan if forcing HW channel plan setting (efuse/eeprom/mapfile)
* will modified tif HW channel plan setting is invlid, will
*/
void rtw_rfctl_decide_init_chplan(struct rf_ctl_t *rfctl,
const char *hw_alpha2, u8 hw_chplan, u8 hw_chplan_6g, u8 hw_force_chplan)
{
struct registry_priv *regsty;
char *sw_alpha2;
const struct country_chplan *country_ent = NULL;
struct country_chplan ent;
int chplan = -1;
int chplan_6g = -1;
u8 sw_chplan;
u8 def_chplan = RTW_CHPLAN_WORLDWIDE; /* worldwide, used when HW, SW both invalid */
#if CONFIG_IEEE80211_BAND_6GHZ
u8 sw_chplan_6g;
u8 def_chplan_6g = RTW_CHPLAN_6G_WORLDWIDE; /* worldwide, used when HW, SW both invalid */
#endif
if (hw_alpha2) {
if (rtw_get_chplan_from_country(hw_alpha2, &ent)) {
/* get chplan from hw country code, by pass hw chplan setting */
country_ent = &ent;
chplan = ent.chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
chplan_6g = ent.chplan_6g;
#endif
goto chk_sw_config;
} else
RTW_PRINT("%s unsupported hw_alpha2:\"%c%c\"\n", __func__, hw_alpha2[0], hw_alpha2[1]);
}
if (rtw_is_channel_plan_valid(hw_chplan))
chplan = hw_chplan;
else if (hw_force_chplan == _TRUE) {
RTW_PRINT("%s unsupported hw_chplan:0x%02X\n", __func__, hw_chplan);
/* hw infomaton invalid, refer to sw information */
hw_force_chplan = _FALSE;
}
#if CONFIG_IEEE80211_BAND_6GHZ
if (rtw_is_channel_plan_6g_valid(hw_chplan_6g))
chplan_6g = hw_chplan_6g;
else if (hw_force_chplan == _TRUE) {
RTW_PRINT("%s unsupported hw_chplan_6g:0x%02X\n", __func__, hw_chplan_6g);
/* hw infomaton invalid, refer to sw information */
hw_force_chplan = _FALSE;
}
#endif
chk_sw_config:
if (hw_force_chplan == _TRUE)
goto done;
regsty = dvobj_to_regsty(rfctl_to_dvobj(rfctl));
sw_alpha2 = regsty->alpha2;
sw_chplan = regsty->channel_plan;
#if CONFIG_IEEE80211_BAND_6GHZ
sw_chplan_6g = regsty->channel_plan_6g;
#endif
if (sw_alpha2 && !IS_ALPHA2_UNSPEC(sw_alpha2)) {
if (IS_ALPHA2_WORLDWIDE(sw_alpha2)
|| rtw_get_chplan_from_country(sw_alpha2, &ent)
) {
/* get chplan from sw country code, by pass sw chplan setting */
if (IS_ALPHA2_WORLDWIDE(sw_alpha2))
rtw_get_chplan_worldwide(&ent);
country_ent = &ent;
chplan = ent.chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
chplan_6g = ent.chplan_6g;
#endif
goto done;
} else
RTW_PRINT("%s unsupported sw_alpha2:\"%c%c\"\n", __func__, sw_alpha2[0], sw_alpha2[1]);
}
if (rtw_is_channel_plan_valid(sw_chplan)) {
/* cancel hw_alpha2 because chplan is specified by sw_chplan */
country_ent = NULL;
chplan = sw_chplan;
} else if (sw_chplan != RTW_CHPLAN_UNSPECIFIED)
RTW_PRINT("%s unsupported sw_chplan:0x%02X\n", __func__, sw_chplan);
#if CONFIG_IEEE80211_BAND_6GHZ
if (rtw_is_channel_plan_6g_valid(sw_chplan_6g)) {
/* cancel hw_alpha2 because chplan_6g is specified by sw_chplan_6g */
country_ent = NULL;
chplan_6g = sw_chplan_6g;
} else if (sw_chplan_6g != RTW_CHPLAN_6G_UNSPECIFIED)
RTW_PRINT("%s unsupported sw_chplan_6g:0x%02X\n", __func__, sw_chplan_6g);
#endif
done:
if (chplan == -1) {
RTW_PRINT("%s use def_chplan:0x%02X\n", __func__, def_chplan);
chplan = def_chplan;
} else
RTW_PRINT("%s chplan:0x%02X\n", __func__, chplan);
#if CONFIG_IEEE80211_BAND_6GHZ
if (chplan_6g == -1) {
RTW_PRINT("%s use def_chplan_6g:0x%02X\n", __func__, def_chplan_6g);
chplan_6g = def_chplan_6g;
} else
RTW_PRINT("%s chplan_6g:0x%02X\n", __func__, chplan_6g);
#endif
if (!country_ent) {
if (rtw_chplan_ids_is_world_wide(chplan, chplan_6g))
rtw_get_chplan_worldwide(&ent);
else {
SET_UNSPEC_ALPHA2(ent.alpha2);
ent.edcca_mode_2g_override = RTW_EDCCA_DEF;
#if CONFIG_IEEE80211_BAND_5GHZ
ent.edcca_mode_5g_override = RTW_EDCCA_DEF;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
ent.edcca_mode_6g_override = RTW_EDCCA_DEF;
#endif
ent.txpwr_lmt_override = TXPWR_LMT_DEF;
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
ent.proto_en = CHPLAN_PROTO_EN_ALL;
#endif
}
} else {
RTW_PRINT("%s country code:\"%c%c\"\n", __func__
, country_ent->alpha2[0], country_ent->alpha2[1]);
}
rfctl->disable_sw_chplan = hw_force_chplan;
rfctl->regd_inr = RTW_REGD_SET_BY_INIT;
rfctl->init_alpha2[0] = rfctl->alpha2[0] = ent.alpha2[0];
rfctl->init_alpha2[1] = rfctl->alpha2[1] = ent.alpha2[1];
rfctl->init_ChannelPlan = rfctl->ChannelPlan = chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->init_chplan_6g = rfctl->chplan_6g = chplan_6g;
#endif
rfctl->edcca_mode_2g_override = ent.edcca_mode_2g_override;
#if CONFIG_IEEE80211_BAND_5GHZ
rfctl->edcca_mode_5g_override = ent.edcca_mode_5g_override;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->edcca_mode_6g_override = ent.edcca_mode_6g_override;
#endif
#if CONFIG_TXPWR_LIMIT
rfctl->txpwr_lmt_override = ent.txpwr_lmt_override;
#endif
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
rfctl->proto_en = ent.proto_en;
#endif
}
void rtw_rfctl_chplan_init(struct dvobj_priv *dvobj)
{
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
init_channel_set(adapter);
op_class_pref_apply_regulatory(adapter, REG_CHANGE);
init_channel_list(adapter, rfctl->channel_set, &rfctl->channel_list);
}
bool rtw_rfctl_is_disable_sw_channel_plan(struct dvobj_priv *dvobj)
{
return dvobj_to_rfctl(dvobj)->disable_sw_chplan;
}
void rtw_rfctl_update_op_mode(struct rf_ctl_t *rfctl, u8 ifbmp_mod, u8 if_op)
{
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
_adapter *iface;
struct mlme_ext_priv *mlmeext;
u8 op_class = 0;
u8 op_ch = 0;
s16 op_txpwr_max;
u8 if_op_class[CONFIG_IFACE_NUMBER] = {0};
u8 if_op_ch[CONFIG_IFACE_NUMBER] = {0};
u8 ch, bw, offset;
u8 u_ch = 0, u_bw, u_offset;
bool notify = 0;
int i;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface)
continue;
mlmeext = &iface->mlmeextpriv;
if (ifbmp_mod & BIT(i)) {
if (!if_op)
continue;
} else if (!MLME_IS_ASOC(iface) || MLME_IS_OPCH_SW(iface))
continue;
ch = mlmeext->chandef.chan;
bw = mlmeext->chandef.bw;
offset = mlmeext->chandef.offset;
if_op_class[i] = rtw_get_op_class_by_chbw(ch, bw, offset);
if_op_ch[i] = if_op_class[i] ? ch : 0;
if (!u_ch) {
u_ch = ch;
u_bw = bw;
u_offset = offset;
} else {
rtw_warn_on(!rtw_is_chbw_grouped(u_ch, u_bw, u_offset, ch, bw, offset));
rtw_sync_chbw(&ch, &bw, &offset, &u_ch, &u_bw, &u_offset);
}
}
op_class = rtw_get_op_class_by_chbw(u_ch, u_bw, u_offset);
op_ch = op_class ? u_ch : 0;
op_txpwr_max = rtw_rfctl_get_oper_txpwr_max_mbm(rfctl, u_ch, u_bw, u_offset, ifbmp_mod, if_op, 1);
if (op_class != rfctl->op_class
|| op_ch != rfctl->op_ch
|| op_txpwr_max != rfctl->op_txpwr_max
|| _rtw_memcmp(if_op_class, rfctl->if_op_class, sizeof(u8) * CONFIG_IFACE_NUMBER) == _FALSE
|| _rtw_memcmp(if_op_ch, rfctl->if_op_ch, sizeof(u8) * CONFIG_IFACE_NUMBER) == _FALSE)
notify = 1;
rfctl->op_class = op_class;
rfctl->op_ch = op_ch;
rfctl->op_txpwr_max = op_txpwr_max;
_rtw_memcpy(rfctl->if_op_class, if_op_class, sizeof(u8) * CONFIG_IFACE_NUMBER);
_rtw_memcpy(rfctl->if_op_ch, if_op_ch, sizeof(u8) * CONFIG_IFACE_NUMBER);
if (0)
RTW_INFO("radio: %u,%u,%u %d notify:%d\n", u_ch, u_bw, u_offset, op_txpwr_max, notify);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface)
continue;
mlmeext = &iface->mlmeextpriv;
if (ifbmp_mod & BIT(i)) {
if (!if_op)
continue;
} else if (!MLME_IS_ASOC(iface))
continue;
if (0)
RTW_INFO(ADPT_FMT": %u,%u,%u\n", ADPT_ARG(iface)
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset);
}
if (notify)
rtw_nlrtw_radio_opmode_notify(rfctl);
}
/* domain status specific beacon hint rules */
#ifndef RTW_CHPLAN_BEACON_HINT_SPECIFIC_COUNTRY
#define RTW_CHPLAN_BEACON_HINT_SPECIFIC_COUNTRY 0
#endif
bool rtw_rfctl_reg_allow_beacon_hint(struct rf_ctl_t *rfctl)
{
return RTW_CHPLAN_BEACON_HINT_SPECIFIC_COUNTRY || RFCTL_REG_WORLDWIDE(rfctl) || RFCTL_REG_ALPHA2_UNSPEC(rfctl);
}
inline u8 rtw_rfctl_get_dfs_domain(struct rf_ctl_t *rfctl)
{
#ifdef CONFIG_DFS_MASTER
return rfctl->dfs_region_domain;
#else
return RTW_DFS_REGD_NONE;
#endif
}
inline u8 rtw_rfctl_dfs_domain_unknown(struct rf_ctl_t *rfctl)
{
#ifdef CONFIG_DFS_MASTER
return rtw_rfctl_get_dfs_domain(rfctl) == RTW_DFS_REGD_NONE;
#else
return 1;
#endif
}
#ifdef CONFIG_DFS_MASTER
/*
* called in rtw_dfs_rd_enable()
* assume the request channel coverage is DFS range
* base on the current status and the request channel coverage to check if need to reset complete CAC time
*/
bool rtw_is_cac_reset_needed(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset)
{
bool needed = _FALSE;
u32 cur_hi, cur_lo, hi, lo;
if (rfctl->radar_detected == 1) {
needed = _TRUE;
goto exit;
}
if (rfctl->radar_detect_ch == 0) {
needed = _TRUE;
goto exit;
}
if (rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo) == _FALSE) {
RTW_ERR("request detection range ch:%u, bw:%u, offset:%u\n", ch, bw, offset);
rtw_warn_on(1);
}
if (rtw_chbw_to_freq_range(rfctl->radar_detect_ch, rfctl->radar_detect_bw, rfctl->radar_detect_offset, &cur_hi, &cur_lo) == _FALSE) {
RTW_ERR("cur detection range ch:%u, bw:%u, offset:%u\n", rfctl->radar_detect_ch, rfctl->radar_detect_bw, rfctl->radar_detect_offset);
rtw_warn_on(1);
}
if (hi <= lo || cur_hi <= cur_lo) {
RTW_ERR("hi:%u, lo:%u, cur_hi:%u, cur_lo:%u\n", hi, lo, cur_hi, cur_lo);
rtw_warn_on(1);
}
if (rtw_is_range_a_in_b(hi, lo, cur_hi, cur_lo)) {
/* request is in current detect range */
goto exit;
}
/* check if request channel coverage has new range and the new range is in DFS range */
if (!rtw_is_range_overlap(hi, lo, cur_hi, cur_lo)) {
/* request has no overlap with current */
needed = _TRUE;
} else if (rtw_is_range_a_in_b(cur_hi, cur_lo, hi, lo)) {
/* request is supper set of current */
if ((hi != cur_hi && rtw_chset_is_dfs_range(rfctl->channel_set, hi, cur_hi))
|| (lo != cur_lo && rtw_chset_is_dfs_range(rfctl->channel_set, cur_lo, lo)))
needed = _TRUE;
} else {
/* request is not supper set of current, but has overlap */
if ((lo < cur_lo && rtw_chset_is_dfs_range(rfctl->channel_set, cur_lo, lo))
|| (hi > cur_hi && rtw_chset_is_dfs_range(rfctl->channel_set, hi, cur_hi)))
needed = _TRUE;
}
exit:
return needed;
}
bool _rtw_rfctl_overlap_radar_detect_ch(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset)
{
bool ret = _FALSE;
u32 hi = 0, lo = 0;
u32 r_hi = 0, r_lo = 0;
int i;
if (rfctl->radar_detect_by_others)
goto exit;
if (rfctl->radar_detect_ch == 0)
goto exit;
if (rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo) == _FALSE) {
rtw_warn_on(1);
goto exit;
}
if (rtw_chbw_to_freq_range(rfctl->radar_detect_ch
, rfctl->radar_detect_bw, rfctl->radar_detect_offset
, &r_hi, &r_lo) == _FALSE) {
rtw_warn_on(1);
goto exit;
}
if (rtw_is_range_overlap(hi, lo, r_hi, r_lo))
ret = _TRUE;
exit:
return ret;
}
bool rtw_rfctl_overlap_radar_detect_ch(struct rf_ctl_t *rfctl)
{
#if 0
struct rtw_chan_def cur_chandef = {0};
_adapter *adapter = NULL;
rtw_get_oper_chdef(adapter, &cur_chandef);
return _rtw_rfctl_overlap_radar_detect_ch(rfctl
, rfctl_to_dvobj(rfctl)->chandef.chan
, rfctl_to_dvobj(rfctl)->chandef.bw
, rfctl_to_dvobj(rfctl)->chandef.offset);
#else
return _FALSE;
#endif
}
bool rtw_rfctl_is_tx_blocked_by_ch_waiting(struct rf_ctl_t *rfctl)
{
return rtw_rfctl_overlap_radar_detect_ch(rfctl) && IS_CH_WAITING(rfctl);
}
bool rtw_chset_is_chbw_non_ocp(RT_CHANNEL_INFO *ch_set, u8 ch, u8 bw, u8 offset)
{
bool ret = _FALSE;
u32 hi = 0, lo = 0;
int i;
if (rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo) == _FALSE)
goto exit;
for (i = 0; i < MAX_CHANNEL_NUM && ch_set[i].ChannelNum != 0; i++) {
if (!rtw_ch2freq(ch_set[i].ChannelNum)) {
rtw_warn_on(1);
continue;
}
if (!CH_IS_NON_OCP(&ch_set[i]))
continue;
if (lo <= rtw_ch2freq(ch_set[i].ChannelNum)
&& rtw_ch2freq(ch_set[i].ChannelNum) <= hi
) {
ret = _TRUE;
break;
}
}
exit:
return ret;
}
bool rtw_chset_is_ch_non_ocp(RT_CHANNEL_INFO *ch_set, u8 ch)
{
return rtw_chset_is_chbw_non_ocp(ch_set, ch, CHANNEL_WIDTH_20, CHAN_OFFSET_NO_EXT);
}
u32 rtw_chset_get_ch_non_ocp_ms(RT_CHANNEL_INFO *ch_set, u8 ch, u8 bw, u8 offset)
{
int ms = 0;
systime current_time;
u32 hi = 0, lo = 0;
int i;
if (rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo) == _FALSE)
goto exit;
current_time = rtw_get_current_time();
for (i = 0; i < MAX_CHANNEL_NUM && ch_set[i].ChannelNum != 0; i++) {
if (!rtw_ch2freq(ch_set[i].ChannelNum)) {
rtw_warn_on(1);
continue;
}
if (!CH_IS_NON_OCP(&ch_set[i]))
continue;
if (lo <= rtw_ch2freq(ch_set[i].ChannelNum)
&& rtw_ch2freq(ch_set[i].ChannelNum) <= hi
) {
if (rtw_systime_to_ms(ch_set[i].non_ocp_end_time - current_time) > ms)
ms = rtw_systime_to_ms(ch_set[i].non_ocp_end_time - current_time);
}
}
exit:
return ms;
}
/**
* rtw_chset_update_non_ocp - update non_ocp_end_time according to the given @ch, @bw, @offset into @ch_set
* @ch_set: the given channel set
* @ch: channel number on which radar is detected
* @bw: bandwidth on which radar is detected
* @offset: bandwidth offset on which radar is detected
* @ms: ms to add from now to update non_ocp_end_time, ms < 0 means use NON_OCP_TIME_MS
*/
static bool _rtw_chset_update_non_ocp(RT_CHANNEL_INFO *ch_set, u8 ch, u8 bw, u8 offset, int ms)
{
u32 hi = 0, lo = 0;
int i;
bool updated = 0;
if (rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo) == _FALSE)
goto exit;
for (i = 0; i < MAX_CHANNEL_NUM && ch_set[i].ChannelNum != 0; i++) {
if (!rtw_ch2freq(ch_set[i].ChannelNum)) {
rtw_warn_on(1);
continue;
}
if (lo <= rtw_ch2freq(ch_set[i].ChannelNum)
&& rtw_ch2freq(ch_set[i].ChannelNum) <= hi
) {
if (ms >= 0)
ch_set[i].non_ocp_end_time = rtw_get_current_time() + rtw_ms_to_systime(ms);
else
ch_set[i].non_ocp_end_time = rtw_get_current_time() + rtw_ms_to_systime(NON_OCP_TIME_MS);
ch_set[i].flags |= RTW_CHF_NON_OCP;
updated = 1;
}
}
exit:
return updated;
}
inline bool rtw_chset_update_non_ocp(RT_CHANNEL_INFO *ch_set, u8 ch, u8 bw, u8 offset)
{
return _rtw_chset_update_non_ocp(ch_set, ch, bw, offset, -1);
}
inline bool rtw_chset_update_non_ocp_ms(RT_CHANNEL_INFO *ch_set, u8 ch, u8 bw, u8 offset, int ms)
{
return _rtw_chset_update_non_ocp(ch_set, ch, bw, offset, ms);
}
static bool rtw_chset_chk_non_ocp_finish_for_chbw(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset)
{
RT_CHANNEL_INFO *ch_set = rfctl->channel_set;
u8 cch;
u8 *op_chs;
u8 op_ch_num;
int i;
int ch_idx;
bool ret = 0;
cch = rtw_get_center_ch(ch, bw, offset);
if (!rtw_get_op_chs_by_cch_bw(cch, bw, &op_chs, &op_ch_num))
goto exit;
for (i = 0; i < op_ch_num; i++) {
if (0)
RTW_INFO("%u,%u,%u - cch:%u, bw:%u, op_ch:%u\n", ch, bw, offset, cch, bw, *(op_chs + i));
ch_idx = rtw_chset_search_ch(ch_set, *(op_chs + i));
if (ch_idx == -1)
break;
if (!(ch_set[ch_idx].flags & RTW_CHF_NON_OCP) || CH_IS_NON_OCP(&ch_set[ch_idx]))
break;
}
if (op_ch_num != 0 && i == op_ch_num) {
ret = 1;
/* clear RTTW_CHF_NON_OCP flag */
for (i = 0; i < op_ch_num; i++) {
ch_idx = rtw_chset_search_ch(ch_set, *(op_chs + i));
ch_set[ch_idx].flags &= ~RTW_CHF_NON_OCP;
}
rtw_nlrtw_nop_finish_event(dvobj_get_primary_adapter(rfctl_to_dvobj(rfctl)), cch, bw);
}
exit:
return ret;
}
/* called by watchdog to clear RTW_CHF_NON_OCP and generate NON_OCP finish event */
void rtw_chset_chk_non_ocp_finish(struct rf_ctl_t *rfctl)
{
u8 ch, bw, offset;
int i;
bw = CHANNEL_WIDTH_160;
while (1) {
for (i = 0; i < rfctl->max_chan_nums; i++) {
ch = rfctl->channel_set[i].ChannelNum;
if (!(rfctl->channel_set[i].flags & RTW_CHF_NON_OCP))
continue;
if (!rtw_get_offset_by_chbw(ch, bw, &offset))
continue;
rtw_chset_chk_non_ocp_finish_for_chbw(rfctl, ch, bw, offset);
}
if (bw-- == CHANNEL_WIDTH_20)
break;
}
}
u32 rtw_get_ch_waiting_ms(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset, u32 *r_non_ocp_ms, u32 *r_cac_ms)
{
u32 non_ocp_ms;
u32 cac_ms;
u8 in_rd_range = 0; /* if in current radar detection range*/
if (rtw_chset_is_chbw_non_ocp(rfctl->channel_set, ch, bw, offset))
non_ocp_ms = rtw_chset_get_ch_non_ocp_ms(rfctl->channel_set, ch, bw, offset);
else
non_ocp_ms = 0;
if (rfctl->radar_detect_enabled) {
u32 cur_hi, cur_lo, hi, lo;
if (rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo) == _FALSE) {
RTW_ERR("input range ch:%u, bw:%u, offset:%u\n", ch, bw, offset);
rtw_warn_on(1);
}
if (rtw_chbw_to_freq_range(rfctl->radar_detect_ch, rfctl->radar_detect_bw, rfctl->radar_detect_offset, &cur_hi, &cur_lo) == _FALSE) {
RTW_ERR("cur detection range ch:%u, bw:%u, offset:%u\n", rfctl->radar_detect_ch, rfctl->radar_detect_bw, rfctl->radar_detect_offset);
rtw_warn_on(1);
}
if (rtw_is_range_a_in_b(hi, lo, cur_hi, cur_lo))
in_rd_range = 1;
}
if (!rtw_chset_is_dfs_chbw(rfctl->channel_set, ch, bw, offset))
cac_ms = 0;
else if (in_rd_range && !non_ocp_ms) {
if (IS_CH_WAITING(rfctl))
cac_ms = rtw_systime_to_ms(rfctl->cac_end_time - rtw_get_current_time());
else
cac_ms = 0;
} else if (rtw_is_long_cac_ch(ch, bw, offset, rtw_rfctl_get_dfs_domain(rfctl)))
cac_ms = CAC_TIME_CE_MS;
else
cac_ms = CAC_TIME_MS;
if (r_non_ocp_ms)
*r_non_ocp_ms = non_ocp_ms;
if (r_cac_ms)
*r_cac_ms = cac_ms;
return non_ocp_ms + cac_ms;
}
void rtw_reset_cac(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset)
{
u32 non_ocp_ms;
u32 cac_ms;
rtw_get_ch_waiting_ms(rfctl
, ch
, bw
, offset
, &non_ocp_ms
, &cac_ms
);
rfctl->cac_start_time = rtw_get_current_time() + rtw_ms_to_systime(non_ocp_ms);
rfctl->cac_end_time = rfctl->cac_start_time + rtw_ms_to_systime(cac_ms);
/* skip special value */
if (rfctl->cac_start_time == RTW_CAC_STOPPED) {
rfctl->cac_start_time++;
rfctl->cac_end_time++;
}
if (rfctl->cac_end_time == RTW_CAC_STOPPED)
rfctl->cac_end_time++;
}
u32 rtw_force_stop_cac(struct rf_ctl_t *rfctl, u32 timeout_ms)
{
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
systime start;
u32 pass_ms;
start = rtw_get_current_time();
rfctl->cac_force_stop = 1;
while (rtw_get_passing_time_ms(start) <= timeout_ms
&& IS_UNDER_CAC(rfctl)
) {
if (dev_is_surprise_removed(dvobj) || dev_is_drv_stopped(dvobj))
break;
rtw_msleep_os(20);
}
if (IS_UNDER_CAC(rfctl)) {
if (!dev_is_surprise_removed(dvobj) && !dev_is_drv_stopped(dvobj))
RTW_INFO("%s waiting for cac stop timeout!\n", __func__);
}
rfctl->cac_force_stop = 0;
pass_ms = rtw_get_passing_time_ms(start);
return pass_ms;
}
#endif /* CONFIG_DFS_MASTER */
/* choose channel with shortest waiting (non ocp + cac) time */
bool rtw_choose_shortest_waiting_ch(struct rf_ctl_t *rfctl, u8 sel_ch, u8 max_bw
, u8 *dec_ch, u8 *dec_bw, u8 *dec_offset
, u8 e_flags, u8 d_flags, u8 cur_ch, bool by_int_info, u8 mesh_only)
{
#ifndef DBG_CHOOSE_SHORTEST_WAITING_CH
#define DBG_CHOOSE_SHORTEST_WAITING_CH 0
#endif
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
struct registry_priv *regsty = dvobj_to_regsty(dvobj);
u8 ch, bw, offset;
u8 ch_c = 0, bw_c = 0, offset_c = 0;
int i;
u32 min_waiting_ms = 0;
u16 int_factor_c = 0;
if (!dec_ch || !dec_bw || !dec_offset) {
rtw_warn_on(1);
return _FALSE;
}
RTW_INFO("%s: sel_ch:%u max_bw:%u e_flags:0x%02x d_flags:0x%02x cur_ch:%u within_sb:%d%s%s\n"
, __func__, sel_ch, max_bw, e_flags, d_flags, cur_ch, rfctl->ch_sel_within_same_band
, by_int_info ? " int" : "", mesh_only ? " mesh_only" : "");
/* full search and narrow bw judegement first to avoid potetial judegement timing issue */
for (bw = CHANNEL_WIDTH_20; bw <= max_bw; bw++) {
if (!rtw_hw_is_bw_support(dvobj, bw))
continue;
for (i = 0; i < rfctl->max_chan_nums; i++) {
u32 non_ocp_ms = 0;
u32 cac_ms = 0;
u32 waiting_ms = 0;
u16 int_factor = 0;
bool dfs_ch;
bool non_ocp;
bool long_cac;
ch = rfctl->channel_set[i].ChannelNum;
if (sel_ch) {
if (ch != sel_ch)
continue;
} else if (rfctl->ch_sel_within_same_band && !rtw_is_same_band(cur_ch, ch))
continue;
if (ch > 14) {
if (bw > REGSTY_BW_5G(regsty))
continue;
} else {
if (bw > REGSTY_BW_2G(regsty))
continue;
}
if (mesh_only && ch >= 5 && ch <= 9 && bw > CHANNEL_WIDTH_20)
continue;
if (!rtw_get_offset_by_chbw(ch, bw, &offset))
continue;
if (!rtw_chset_is_chbw_valid(rfctl->channel_set, ch, bw, offset, 0, 0))
continue;
if ((e_flags & RTW_CHF_DFS) || (d_flags & RTW_CHF_DFS)) {
dfs_ch = rtw_chset_is_dfs_chbw(rfctl->channel_set, ch, bw, offset);
if (((e_flags & RTW_CHF_DFS) && !dfs_ch)
|| ((d_flags & RTW_CHF_DFS) && dfs_ch))
continue;
}
if ((e_flags & RTW_CHF_LONG_CAC) || (d_flags & RTW_CHF_LONG_CAC)) {
long_cac = rtw_is_long_cac_ch(ch, bw, offset, rtw_rfctl_get_dfs_domain(rfctl));
if (((e_flags & RTW_CHF_LONG_CAC) && !long_cac)
|| ((d_flags & RTW_CHF_LONG_CAC) && long_cac))
continue;
}
if ((e_flags & RTW_CHF_NON_OCP) || (d_flags & RTW_CHF_NON_OCP)) {
non_ocp = rtw_chset_is_chbw_non_ocp(rfctl->channel_set, ch, bw, offset);
if (((e_flags & RTW_CHF_NON_OCP) && !non_ocp)
|| ((d_flags & RTW_CHF_NON_OCP) && non_ocp))
continue;
}
#ifdef CONFIG_DFS_MASTER
waiting_ms = rtw_get_ch_waiting_ms(rfctl, ch, bw, offset, &non_ocp_ms, &cac_ms);
#endif
#if 0 /* def CONFIG_RTW_ACS */
if (by_int_info) {
/* for now, consider only primary channel */
int_factor = hal_data->acs.interference_time[i];
}
#endif
if (DBG_CHOOSE_SHORTEST_WAITING_CH)
RTW_INFO("%s:%u,%u,%u %u(non_ocp:%u, cac:%u), int:%u\n"
, __func__, ch, bw, offset, waiting_ms, non_ocp_ms, cac_ms, int_factor);
if (ch_c == 0
/* first: smaller wating time */
|| min_waiting_ms > waiting_ms
/* then: less interference */
|| (min_waiting_ms == waiting_ms && int_factor_c > int_factor)
/* then: wider bw */
|| (min_waiting_ms == waiting_ms && int_factor_c == int_factor && bw > bw_c)
/* if all condition equal, same channel -> same band prefer */
|| (min_waiting_ms == waiting_ms && int_factor_c == int_factor && bw == bw_c
&& ((cur_ch != ch_c && cur_ch == ch)
|| (!rtw_is_same_band(cur_ch, ch_c) && rtw_is_same_band(cur_ch, ch)))
)
) {
ch_c = ch;
bw_c = bw;
offset_c = offset;
min_waiting_ms = waiting_ms;
int_factor_c = int_factor;
}
}
}
if (ch_c != 0) {
RTW_INFO("%s: select %u,%u,%u waiting_ms:%u\n"
, __func__, ch_c, bw_c, offset_c, min_waiting_ms);
*dec_ch = ch_c;
*dec_bw = bw_c;
*dec_offset = offset_c;
return _TRUE;
} else {
RTW_INFO("%s: not found\n", __func__);
if (d_flags == 0)
rtw_warn_on(1);
}
return _FALSE;
}
#define RTW_CHF_FMT "%s%s%s%s%s%s"
#define RTW_CHF_ARG_NO_IR(flags) (flags & RTW_CHF_NO_IR) ? " NO_IR" : ""
#define RTW_CHF_ARG_DFS(flags) , (flags & RTW_CHF_DFS) ? " DFS" : ""
#define RTW_CHF_ARG_NO_HT40U(flags) , (flags & RTW_CHF_NO_HT40U) ? " NO_40M+" : ""
#define RTW_CHF_ARG_NO_HT40L(flags) , (flags & RTW_CHF_NO_HT40L) ? " NO_40M-" : ""
#define RTW_CHF_ARG_NO_80MHZ(flags) , (flags & RTW_CHF_NO_80MHZ) ? " NO_80M" : ""
#define RTW_CHF_ARG_NO_160MHZ(flags) , (flags & RTW_CHF_NO_160MHZ) ? " NO_160M" : ""
#define RTW_CHF_ARG(flags) \
RTW_CHF_ARG_NO_IR(flags) \
RTW_CHF_ARG_DFS(flags) \
RTW_CHF_ARG_NO_HT40U(flags) \
RTW_CHF_ARG_NO_HT40L(flags) \
RTW_CHF_ARG_NO_80MHZ(flags) \
RTW_CHF_ARG_NO_160MHZ(flags)
static void dump_chset(void *sel, RT_CHANNEL_INFO *ch_set, u8 chset_num)
{
char buf[8];
u8 i;
RTW_PRINT_SEL(sel, "%-3s %-4s %-4s flags\n", "ch", "freq", "nocp");
for (i = 0; i < MAX_CHANNEL_NUM && i < chset_num && ch_set[i].ChannelNum != 0; i++) {
#ifdef CONFIG_DFS_MASTER
if ((ch_set[i].flags & RTW_CHF_DFS) && CH_IS_NON_OCP(&ch_set[i]))
snprintf(buf, 8, "%d", rtw_systime_to_ms(ch_set[i].non_ocp_end_time - rtw_get_current_time()) / 1000);
else
#endif
snprintf(buf, 8, "0");
RTW_PRINT_SEL(sel, "%3u %4u %4s"RTW_CHF_FMT"\n"
, ch_set[i].ChannelNum, rtw_ch2freq_by_band(ch_set[i].band, ch_set[i].ChannelNum), buf
, RTW_CHF_ARG(ch_set[i].flags)
);
}
RTW_PRINT_SEL(sel, "total ch number:%d\n", i);
}
#if CONFIG_TXPWR_LIMIT
static void dump_chplan_txpwr_lmts(void *sel, struct get_chplan_resp *chplan)
{
char buf[TXPWR_NAMES_STR_LEN];
RTW_PRINT_SEL(sel, "txpwr_lmt:%s\n", rtw_get_txpwr_lmt_names_str(buf, chplan->txpwr_lmt_name, 0));
}
#endif
static void dump_chplan_edcca_modes(void *sel, struct get_chplan_resp *chplan)
{
u8 modes[BAND_MAX];
char buf[EDCCA_MODES_STR_LEN];
modes[BAND_ON_24G] = chplan->edcca_mode_2g;
#if CONFIG_IEEE80211_BAND_5GHZ
modes[BAND_ON_5G] = chplan->edcca_mode_5g;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
modes[BAND_ON_6G] = chplan->edcca_mode_6g;
#endif
RTW_PRINT_SEL(sel, "edcca_mode:%s\n", rtw_get_edcca_modes_str(buf, modes));
}
void dump_cur_country(void *sel, struct rf_ctl_t *rfctl)
{
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
struct get_chplan_resp *chplan;
int i;
if (rtw_get_chplan_cmd(dvobj_get_primary_adapter(dvobj), RTW_CMDF_WAIT_ACK, &chplan) == _FAIL)
return;
RTW_PRINT_SEL(sel, "%c%c\n", chplan->alpha2[0], chplan->alpha2[1]);
rtw_vmfree(chplan, sizeof(struct get_chplan_resp) + sizeof(RT_CHANNEL_INFO) * chplan->chset_num);
}
void dump_cur_chset(void *sel, struct rf_ctl_t *rfctl)
{
struct dvobj_priv *dvobj = rfctl_to_dvobj(rfctl);
struct registry_priv *regsty = dvobj_to_regsty(dvobj);
struct get_chplan_resp *chplan;
int i;
if (rtw_get_chplan_cmd(dvobj_get_primary_adapter(dvobj), RTW_CMDF_WAIT_ACK, &chplan) == _FAIL)
return;
RTW_PRINT_SEL(sel, "regd_src:%s(%d)\n", regd_src_str(chplan->regd_src), chplan->regd_src);
RTW_PRINT_SEL(sel, "regd_inr:%s\n", regd_inr_str(chplan->regd_inr));
RTW_PRINT_SEL(sel, "alpha2:%c%c\n", chplan->alpha2[0], chplan->alpha2[1]);
#ifdef CONFIG_80211AX_HE
RTW_PRINT_SEL(sel, "ax:%d\n", (chplan->proto_en & CHPLAN_PROTO_EN_AX) ? 1 : 0);
#endif
#ifdef CONFIG_80211AC_VHT
RTW_PRINT_SEL(sel, "ac:%d\n", (chplan->proto_en & CHPLAN_PROTO_EN_AC) ? 1 : 0);
#endif
if (chplan->channel_plan == RTW_CHPLAN_UNSPECIFIED)
RTW_PRINT_SEL(sel, "chplan:NA\n");
else
RTW_PRINT_SEL(sel, "chplan:0x%02X\n", chplan->channel_plan);
#if CONFIG_IEEE80211_BAND_6GHZ
if (chplan->chplan_6g == RTW_CHPLAN_6G_UNSPECIFIED)
RTW_PRINT_SEL(sel, "chplan_6g:NA\n");
else
RTW_PRINT_SEL(sel, "chplan_6g:0x%02X\n", chplan->chplan_6g);
#endif
#if CONFIG_TXPWR_LIMIT
dump_chplan_txpwr_lmts(sel, chplan);
#endif
dump_chplan_edcca_modes(sel, chplan);
#ifdef CONFIG_DFS_MASTER
RTW_PRINT_SEL(sel, "dfs_domain:%s(%u)\n", rtw_dfs_regd_str(chplan->dfs_domain), chplan->dfs_domain);
#endif
for (i = 0; i < MAX_CHANNEL_NUM_2G_5G; i++)
if (regsty->excl_chs[i] != 0)
break;
if (i < MAX_CHANNEL_NUM_2G_5G) {
RTW_PRINT_SEL(sel, "excl_chs:");
for (i = 0; i < MAX_CHANNEL_NUM_2G_5G; i++) {
if (regsty->excl_chs[i] == 0)
break;
_RTW_PRINT_SEL(sel, "%u ", regsty->excl_chs[i]);
}
_RTW_PRINT_SEL(sel, "\n");
}
#if CONFIG_IEEE80211_BAND_6GHZ
for (i = 0; i < MAX_CHANNEL_NUM_6G; i++)
if (regsty->excl_chs_6g[i] != 0)
break;
if (i < MAX_CHANNEL_NUM_6G) {
RTW_PRINT_SEL(sel, "excl_chs_6g:");
for (i = 0; i < MAX_CHANNEL_NUM_6G; i++) {
if (regsty->excl_chs_6g[i] == 0)
break;
_RTW_PRINT_SEL(sel, "%u ", regsty->excl_chs_6g[i]);
}
_RTW_PRINT_SEL(sel, "\n");
}
#endif
dump_chset(sel, chplan->chset, chplan->chset_num);
rtw_vmfree(chplan, sizeof(struct get_chplan_resp) + sizeof(RT_CHANNEL_INFO) * chplan->chset_num);
}
/*
* Search the @param ch in given @param ch_set
* @ch_set: the given channel set
* @ch: the given channel number
*
* return the index of channel_num in channel_set, -1 if not found
*/
int rtw_chset_search_ch(RT_CHANNEL_INFO *ch_set, const u32 ch)
{
int i;
if (ch == 0)
return -1;
for (i = 0; i < MAX_CHANNEL_NUM && ch_set[i].ChannelNum != 0; i++) {
if (ch == ch_set[i].ChannelNum)
return i;
}
return -1;
}
/*
* Search the @param ch of @param band in given @param ch_set
* @ch_set: the given channel set
* @band: the given band
* @ch: the given channel number
*
* return the index of channel_num in channel_set, -1 if not found
*/
int rtw_chset_search_ch_by_band(RT_CHANNEL_INFO *ch_set, enum band_type band, const u32 ch)
{
int i;
if (ch == 0)
return -1;
for (i = 0; i < MAX_CHANNEL_NUM && ch_set[i].ChannelNum != 0; i++) {
if (band == ch_set[i].band && ch == ch_set[i].ChannelNum)
return i;
}
return -1;
}
/*
* Check if the @param ch, bw, offset is valid for the given @param ch_set
* @ch_set: the given channel set
* @ch: the given channel number
* @bw: the given bandwidth
* @offset: the given channel offset
*
* return valid (1) or not (0)
*/
u8 rtw_chset_is_chbw_valid(RT_CHANNEL_INFO *ch_set, u8 ch, u8 bw, u8 offset
, bool allow_primary_passive, bool allow_passive)
{
u8 cch;
u8 *op_chs;
u8 op_ch_num;
u8 valid = 0;
int i;
int ch_idx;
cch = rtw_phl_get_center_ch(ch, bw, offset);
if (!rtw_get_op_chs_by_cch_bw(cch, bw, &op_chs, &op_ch_num))
goto exit;
for (i = 0; i < op_ch_num; i++) {
if (0)
RTW_INFO("%u,%u,%u - cch:%u, bw:%u, op_ch:%u\n", ch, bw, offset, cch, bw, *(op_chs + i));
ch_idx = rtw_chset_search_ch(ch_set, *(op_chs + i));
if (ch_idx == -1)
break;
if (ch_set[ch_idx].flags & RTW_CHF_NO_IR) {
if (!allow_passive
|| (!allow_primary_passive && ch_set[ch_idx].ChannelNum == ch))
break;
}
if (bw >= CHANNEL_WIDTH_40) {
if ((ch_set[ch_idx].flags & RTW_CHF_NO_HT40U) && i % 2 == 0)
break;
if ((ch_set[ch_idx].flags & RTW_CHF_NO_HT40L) && i % 2 == 1)
break;
}
if (bw >= CHANNEL_WIDTH_80 && (ch_set[ch_idx].flags & RTW_CHF_NO_80MHZ))
break;
if (bw >= CHANNEL_WIDTH_160 && (ch_set[ch_idx].flags & RTW_CHF_NO_160MHZ))
break;
}
if (op_ch_num != 0 && i == op_ch_num)
valid = 1;
exit:
return valid;
}
/**
* rtw_chset_sync_chbw - obey g_ch, adjust g_bw, g_offset, bw, offset to fit in channel plan
* @ch_set: channel plan to check
* @req_ch: pointer of the request ch, may be modified further
* @req_bw: pointer of the request bw, may be modified further
* @req_offset: pointer of the request offset, may be modified further
* @g_ch: pointer of the ongoing group ch
* @g_bw: pointer of the ongoing group bw, may be modified further
* @g_offset: pointer of the ongoing group offset, may be modified further
* @allow_primary_passive: if allow passive primary ch when deciding chbw
* @allow_passive: if allow passive ch (not primary) when deciding chbw
*/
void rtw_chset_sync_chbw(RT_CHANNEL_INFO *ch_set, u8 *req_ch, u8 *req_bw, u8 *req_offset
, u8 *g_ch, u8 *g_bw, u8 *g_offset, bool allow_primary_passive, bool allow_passive)
{
u8 r_ch, r_bw, r_offset;
u8 u_ch, u_bw, u_offset;
u8 cur_bw = *req_bw;
while (1) {
r_ch = *req_ch;
r_bw = cur_bw;
r_offset = *req_offset;
u_ch = *g_ch;
u_bw = *g_bw;
u_offset = *g_offset;
rtw_sync_chbw(&r_ch, &r_bw, &r_offset, &u_ch, &u_bw, &u_offset);
if (rtw_chset_is_chbw_valid(ch_set, r_ch, r_bw, r_offset, allow_primary_passive, allow_passive))
break;
if (cur_bw == CHANNEL_WIDTH_20) {
rtw_warn_on(1);
break;
}
cur_bw--;
};
*req_ch = r_ch;
*req_bw = r_bw;
*req_offset = r_offset;
*g_ch = u_ch;
*g_bw = u_bw;
*g_offset = u_offset;
}
/*
* Check the @param ch is fit with setband setting of @param adapter
* @adapter: the given adapter
* @ch: the given channel number
*
* return _TRUE when check valid, _FALSE not valid
*/
bool rtw_mlme_band_check(_adapter *adapter, const u32 ch)
{
if (adapter->setband == WIFI_FREQUENCY_BAND_AUTO /* 2.4G and 5G */
|| (adapter->setband == WIFI_FREQUENCY_BAND_2GHZ && ch < 35) /* 2.4G only */
|| (adapter->setband == WIFI_FREQUENCY_BAND_5GHZ && ch > 35) /* 5G only */
)
return _TRUE;
return _FALSE;
}
inline void RTW_SET_SCAN_BAND_SKIP(_adapter *padapter, int skip_band)
{
int bs = ATOMIC_READ(&padapter->bandskip);
bs |= skip_band;
ATOMIC_SET(&padapter->bandskip, bs);
}
inline void RTW_CLR_SCAN_BAND_SKIP(_adapter *padapter, int skip_band)
{
int bs = ATOMIC_READ(&padapter->bandskip);
bs &= ~(skip_band);
ATOMIC_SET(&padapter->bandskip, bs);
}
inline int RTW_GET_SCAN_BAND_SKIP(_adapter *padapter)
{
return ATOMIC_READ(&padapter->bandskip);
}
#define RTW_IS_SCAN_BAND_SKIP(padapter, skip_band) (ATOMIC_READ(&padapter->bandskip) & (skip_band))
bool rtw_mlme_ignore_chan(_adapter *adapter, const u32 ch)
{
if (RTW_IS_SCAN_BAND_SKIP(adapter, BAND_24G) && ch < 35) /* SKIP 2.4G Band channel */
return _TRUE;
if (RTW_IS_SCAN_BAND_SKIP(adapter, BAND_5G) && ch > 35) /* SKIP 5G Band channel */
return _TRUE;
return _FALSE;
}
/****************************************************************************
Following are the initialization functions for WiFi MLME
*****************************************************************************/
int init_hw_mlme_ext(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
u8 rx_bar_enble = _TRUE;
/*
* Sync driver status and hardware setting
*/
/* set_opmode_cmd(padapter, infra_client_with_mlme); */ /* removed */
rtw_hal_set_hwreg(padapter, HW_VAR_ENABLE_RX_BAR, &rx_bar_enble);
set_channel_bwmode(padapter,
pmlmeext->chandef.chan,
pmlmeext->chandef.offset,
pmlmeext->chandef.bw,
_FALSE);
return _SUCCESS;
}
void init_mlme_default_rate_set(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
unsigned char end_set[1] = {0xff};
u8 offset_datarate = 0;
u8 offset_basicrate = 0;
#ifdef CONFIG_80211N_HT
unsigned char supported_mcs_set[16] = {0xff, 0xff, 0xff, 0xff, 0x00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
#endif
if (is_supported_tx_cck(padapter->registrypriv.wireless_mode)) {
unsigned char datarate_b[B_MODE_RATE_NUM] ={_1M_RATE_, _2M_RATE_, _5M_RATE_, _11M_RATE_};
_rtw_memcpy(pmlmeext->datarate, datarate_b, B_MODE_RATE_NUM);
_rtw_memcpy(pmlmeext->basicrate, datarate_b, B_MODE_RATE_NUM);
offset_datarate += B_MODE_RATE_NUM;
offset_basicrate += B_MODE_RATE_NUM;
RTW_INFO("%s: support CCK\n", __func__);
}
if(is_suuported_tx_ofdm(padapter->registrypriv.wireless_mode)) {
unsigned char datarate_g[G_MODE_RATE_NUM] ={_6M_RATE_, _9M_RATE_, _12M_RATE_, _18M_RATE_,_24M_RATE_, _36M_RATE_, _48M_RATE_, _54M_RATE_};
unsigned char basicrate_g[G_MODE_BASIC_RATE_NUM] = {_6M_RATE_, _12M_RATE_, _24M_RATE_};
_rtw_memcpy(pmlmeext->datarate + offset_datarate, datarate_g, G_MODE_RATE_NUM);
_rtw_memcpy(pmlmeext->basicrate + offset_basicrate,basicrate_g, G_MODE_BASIC_RATE_NUM);
offset_datarate += G_MODE_RATE_NUM;
offset_basicrate += G_MODE_BASIC_RATE_NUM;
RTW_INFO("%s: support OFDM\n", __func__);
}
_rtw_memcpy(pmlmeext->datarate + offset_datarate, end_set, 1);
_rtw_memcpy(pmlmeext->basicrate + offset_basicrate, end_set, 1);
#ifdef CONFIG_80211N_HT
if( padapter->registrypriv.ht_enable && is_supported_ht(padapter->registrypriv.wireless_mode))
_rtw_memcpy(pmlmeext->default_supported_mcs_set, supported_mcs_set, sizeof(pmlmeext->default_supported_mcs_set));
#endif
}
static void init_mlme_ext_priv_value(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
ATOMIC_SET(&pmlmeext->event_seq, 0);
pmlmeext->mgnt_seq = 0;/* reset to zero when disconnect at client mode */
#ifdef CONFIG_IEEE80211W
pmlmeext->sa_query_seq = 0;
#endif
pmlmeext->chandef.chan = padapter->registrypriv.channel;
pmlmeext->chandef.bw = CHANNEL_WIDTH_20;
pmlmeext->chandef.offset = CHAN_OFFSET_NO_EXT;
pmlmeext->retry = 0;
pmlmeext->cur_wireless_mode = padapter->registrypriv.wireless_mode;
init_mlme_default_rate_set(padapter);
if ((pmlmeext->chandef.chan > 14) || ((padapter->registrypriv.wireless_mode & WLAN_MD_11B) == 0))
pmlmeext->tx_rate = IEEE80211_OFDM_RATE_6MB;
else
pmlmeext->tx_rate = IEEE80211_CCK_RATE_1MB;
mlmeext_set_scan_state(pmlmeext, SCAN_DISABLE);
#if 0
pmlmeext->sitesurvey_res.channel_idx = 0;
#endif
pmlmeext->sitesurvey_res.bss_cnt = 0;
pmlmeext->sitesurvey_res.scan_ch_ms = SURVEY_TO;
pmlmeext->sitesurvey_res.rx_ampdu_accept = RX_AMPDU_ACCEPT_INVALID;
pmlmeext->sitesurvey_res.rx_ampdu_size = RX_AMPDU_SIZE_INVALID;
#ifdef CONFIG_SCAN_BACKOP
mlmeext_assign_scan_backop_flags_sta(pmlmeext, /*SS_BACKOP_EN|*/SS_BACKOP_PS_ANNC | SS_BACKOP_TX_RESUME);
#ifdef CONFIG_AP_MODE
mlmeext_assign_scan_backop_flags_ap(pmlmeext, SS_BACKOP_EN | SS_BACKOP_PS_ANNC | SS_BACKOP_TX_RESUME);
#endif
#ifdef CONFIG_RTW_MESH
mlmeext_assign_scan_backop_flags_mesh(pmlmeext, /*SS_BACKOP_EN | */SS_BACKOP_PS_ANNC | SS_BACKOP_TX_RESUME);
#endif
#if 0
pmlmeext->sitesurvey_res.scan_cnt = 0;
#endif
pmlmeext->sitesurvey_res.scan_cnt_max = RTW_SCAN_NUM_OF_CH;
pmlmeext->sitesurvey_res.backop_ms = RTW_BACK_OP_CH_MS;
#endif
#if defined(CONFIG_ANTENNA_DIVERSITY) || defined(DBG_SCAN_SW_ANTDIV_BL)
pmlmeext->sitesurvey_res.is_sw_antdiv_bl_scan = 0;
#endif
pmlmeext->scan_abort = _FALSE;
pmlmeext->scan_abort_to = _FALSE;
pmlmeinfo->state = WIFI_FW_NULL_STATE;
pmlmeinfo->reauth_count = 0;
pmlmeinfo->reassoc_count = 0;
pmlmeinfo->link_count = 0;
pmlmeinfo->auth_seq = 0;
pmlmeinfo->auth_algo = dot11AuthAlgrthm_Open;
pmlmeinfo->key_index = 0;
pmlmeinfo->iv = 0;
pmlmeinfo->enc_algo = _NO_PRIVACY_;
pmlmeinfo->authModeToggle = 0;
_rtw_memset(pmlmeinfo->chg_txt, 0, 128);
pmlmeinfo->slotTime = SHORT_SLOT_TIME;
pmlmeinfo->preamble_mode = PREAMBLE_AUTO;
pmlmeinfo->dialogToken = 0;
pmlmeext->action_public_rxseq = 0xffff;
pmlmeext->action_public_dialog_token = 0xff;
#ifdef ROKU_PRIVATE
/*infra mode, used to store AP's info*/
_rtw_memset(pmlmeinfo->SupportedRates_infra_ap, 0, NDIS_802_11_LENGTH_RATES_EX);
pmlmeinfo->ht_vht_received = 0;
#endif /* ROKU_PRIVATE */
}
void init_mlme_ext_timer(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
#if 0
rtw_init_timer(&pmlmeext->survey_timer, survey_timer_hdl, padapter);
#endif
rtw_init_timer(&pmlmeext->link_timer, link_timer_hdl, padapter);
#ifdef CONFIG_RTW_80211R
rtw_init_timer(&pmlmeext->ft_link_timer, rtw_ft_link_timer_hdl, padapter);
rtw_init_timer(&pmlmeext->ft_roam_timer, rtw_ft_roam_timer_hdl, padapter);
#endif
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
rtw_init_timer(&pmlmeext->tbtx_xmit_timer, rtw_tbtx_xmit_timer_hdl, padapter);
rtw_init_timer(&pmlmeext->tbtx_token_dispatch_timer, rtw_tbtx_token_dispatch_timer_hdl, padapter);
#endif
#ifdef ROKU_PRIVATE
rtw_init_timer(&pmlmeext->find_remote_timer, find_remote_timer_hdl, padapter);
#ifdef CONFIG_P2P
rtw_init_timer(&pmlmeext->hide_ssid_timer, hide_ssid_hdl, padapter);
#endif
#endif
#if CONFIG_DFS
rtw_init_timer(&pmlmeext->csa_timer, csa_timer_hdl, padapter);
#endif
}
int init_mlme_ext_priv(_adapter *padapter)
{
int res = _SUCCESS;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
/* We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc(). */
/* _rtw_memset((u8 *)pmlmeext, 0, sizeof(struct mlme_ext_priv)); */
pmlmeext->padapter = padapter;
init_mlme_ext_priv_value(padapter);
pmlmeinfo->bAcceptAddbaReq = pregistrypriv->bAcceptAddbaReq;
init_mlme_ext_timer(padapter);
#ifdef CONFIG_AP_MODE
init_mlme_ap_info(padapter);
#endif
pmlmeext->last_scan_time = 0;
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
pmlmeext->active_keep_alive_check = _TRUE;
#else
pmlmeext->active_keep_alive_check = _FALSE;
#endif
#ifdef DBG_FIXED_CHAN
pmlmeext->fixed_chan = 0xFF;
#endif
#ifdef CONFIG_SUPPORT_STATIC_SMPS
pmlmeext->ssmps_en = _FALSE;
pmlmeext->ssmps_tx_tp_th = SSMPS_TX_TP_TH;/*Mbps*/
pmlmeext->ssmps_rx_tp_th = SSMPS_RX_TP_TH;/*Mbps*/
#ifdef DBG_STATIC_SMPS
pmlmeext->ssmps_test = _FALSE;
#endif
#endif
#ifdef CONFIG_CTRL_TXSS_BY_TP
pmlmeext->txss_ctrl_en = _TRUE;
pmlmeext->txss_tp_th = TXSS_TP_TH;
pmlmeext->txss_tp_chk_cnt = TXSS_TP_CHK_CNT;
#endif
return res;
}
void free_mlme_ext_priv(struct mlme_ext_priv *pmlmeext)
{
_adapter *padapter = pmlmeext->padapter;
if (!padapter)
return;
if (dev_is_drv_stopped(adapter_to_dvobj(padapter))) {
/*cancel_survey_timer(pmlmeext);*/ /*_cancel_timer_ex(&pmlmeext->survey_timer);*/
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
#ifdef ROKU_PRIVATE
_cancel_timer_ex(&pmlmeext->find_remote_timer);
#ifdef CONFIG_P2P
_cancel_timer_ex(&pmlmeext->hide_ssid_timer);
#endif
#endif
#if CONFIG_DFS
_cancel_timer_ex(&pmlmeext->csa_timer);
#endif
}
}
#ifdef CONFIG_PATCH_JOIN_WRONG_CHANNEL
static u8 cmp_pkt_chnl_diff(_adapter *padapter, u8 *pframe, uint packet_len)
{
/* if the channel is same, return 0. else return channel differential */
uint len;
u8 channel;
u8 *p;
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_, _DSSET_IE_, &len, packet_len - _BEACON_IE_OFFSET_);
if (p) {
channel = *(p + 2);
if (padapter->mlmeextpriv.chandef.chan >= channel)
return padapter->mlmeextpriv.chandef.chan - channel;
else
return channel - padapter->mlmeextpriv.chandef.chan;
} else
return 0;
}
#endif /* CONFIG_PATCH_JOIN_WRONG_CHANNEL */
static void _mgt_dispatcher(_adapter *padapter, struct mlme_handler *ptable, union recv_frame *precv_frame)
{
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 *pframe = precv_frame->u.hdr.rx_data;
if (ptable->func) {
/* receive the frames that ra(a1) is my address or ra(a1) is bc address. */
if (!_rtw_memcmp(GetAddr1Ptr(pframe), adapter_mac_addr(padapter), ETH_ALEN) &&
!_rtw_memcmp(GetAddr1Ptr(pframe), bc_addr, ETH_ALEN))
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
{
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
if (!MLME_IS_STA(padapter))
return;
if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
return;
if ( pwdev_priv->pno_mac_addr[0] == 0xFF)
return;
if (!_rtw_memcmp(GetAddr1Ptr(pframe), adapter_pno_mac_addr(padapter), ETH_ALEN))
return;
}
#else
return;
#endif
ptable->func(padapter, precv_frame);
}
}
void mgt_dispatcher(_adapter *padapter, union recv_frame *precv_frame)
{
int index;
struct mlme_handler *ptable;
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 *pframe = precv_frame->u.hdr.rx_data;
struct sta_info *psta = rtw_get_stainfo(&padapter->stapriv, get_addr2_ptr(pframe));
#if 0
{
u8 *pbuf;
pbuf = GetAddr1Ptr(pframe);
RTW_INFO("A1-%x:%x:%x:%x:%x:%x\n", *pbuf, *(pbuf + 1), *(pbuf + 2), *(pbuf + 3), *(pbuf + 4), *(pbuf + 5));
pbuf = get_addr2_ptr(pframe);
RTW_INFO("A2-%x:%x:%x:%x:%x:%x\n", *pbuf, *(pbuf + 1), *(pbuf + 2), *(pbuf + 3), *(pbuf + 4), *(pbuf + 5));
pbuf = GetAddr3Ptr(pframe);
RTW_INFO("A3-%x:%x:%x:%x:%x:%x\n", *pbuf, *(pbuf + 1), *(pbuf + 2), *(pbuf + 3), *(pbuf + 4), *(pbuf + 5));
}
#endif
if (GetFrameType(pframe) != WIFI_MGT_TYPE) {
return;
}
/* receive the frames that ra(a1) is my address or ra(a1) is bc address. */
if (!_rtw_memcmp(GetAddr1Ptr(pframe), adapter_mac_addr(padapter), ETH_ALEN) &&
!_rtw_memcmp(GetAddr1Ptr(pframe), bc_addr, ETH_ALEN))
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
{
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
if (!MLME_IS_STA(padapter))
return;
if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
return;
if ( pwdev_priv->pno_mac_addr[0] == 0xFF)
return;
if (!_rtw_memcmp(GetAddr1Ptr(pframe), adapter_pno_mac_addr(padapter), ETH_ALEN))
return;
}
#else
return;
#endif
ptable = mlme_sta_tbl;
index = get_frame_sub_type(pframe) >> 4;
#ifdef CONFIG_TDLS
if ((index << 4) == WIFI_ACTION) {
/* category==public (4), action==TDLS_DISCOVERY_RESPONSE */
if (*(pframe + 24) == RTW_WLAN_CATEGORY_PUBLIC && *(pframe + 25) == TDLS_DISCOVERY_RESPONSE) {
RTW_INFO("[TDLS] Recv %s from "MAC_FMT"\n", rtw_tdls_action_txt(TDLS_DISCOVERY_RESPONSE), MAC_ARG(get_addr2_ptr(pframe)));
On_TDLS_Dis_Rsp(padapter, precv_frame);
}
}
#endif /* CONFIG_TDLS */
if (index >= (sizeof(mlme_sta_tbl) / sizeof(struct mlme_handler))) {
return;
}
ptable += index;
#if 1
if (psta != NULL) {
if (GetRetry(pframe)) {
if (precv_frame->u.hdr.attrib.seq_num == psta->RxMgmtFrameSeqNum) {
/* drop the duplicate management frame */
padapter->recvinfo.dbg_rx_dup_mgt_frame_drop_count++;
RTW_INFO("Drop duplicate management frame with seq_num = %d.\n", precv_frame->u.hdr.attrib.seq_num);
return;
}
}
psta->RxMgmtFrameSeqNum = precv_frame->u.hdr.attrib.seq_num;
}
#else
if (GetRetry(pframe)) {
/* return; */
}
#endif
#ifdef CONFIG_AP_MODE
switch (get_frame_sub_type(pframe)) {
case WIFI_AUTH:
if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter))
ptable->func = &OnAuth;
else
ptable->func = &OnAuthClient;
/* fall through */
case WIFI_ASSOCREQ:
case WIFI_REASSOCREQ:
_mgt_dispatcher(padapter, ptable, precv_frame);
#ifdef CONFIG_HOSTAPD_MLME
if (MLME_IS_AP(padapter))
rtw_hostapd_mlme_rx(padapter, precv_frame);
#endif
break;
case WIFI_PROBEREQ:
_mgt_dispatcher(padapter, ptable, precv_frame);
#ifdef CONFIG_HOSTAPD_MLME
if (MLME_IS_AP(padapter))
rtw_hostapd_mlme_rx(padapter, precv_frame);
#endif
break;
case WIFI_BEACON:
_mgt_dispatcher(padapter, ptable, precv_frame);
break;
case WIFI_ACTION:
_mgt_dispatcher(padapter, ptable, precv_frame);
break;
default:
_mgt_dispatcher(padapter, ptable, precv_frame);
#ifdef CONFIG_HOSTAPD_MLME
if (MLME_IS_AP(padapter))
rtw_hostapd_mlme_rx(padapter, precv_frame);
#endif
break;
}
#else
_mgt_dispatcher(padapter, ptable, precv_frame);
#endif
}
#ifdef CONFIG_P2P
u32 p2p_listen_state_process(_adapter *padapter, unsigned char *da)
{
bool response = _TRUE;
#ifdef CONFIG_IOCTL_CFG80211
if (rtw_cfg80211_get_is_roch(padapter) == _FALSE
|| rtw_get_oper_ch(padapter) != padapter->wdinfo.listen_channel
|| adapter_wdev_data(padapter)->p2p_enabled == _FALSE
|| padapter->mlmepriv.wps_probe_resp_ie == NULL
|| padapter->mlmepriv.p2p_probe_resp_ie == NULL
) {
#ifdef CONFIG_DEBUG_CFG80211
RTW_INFO(ADPT_FMT" DON'T issue_probersp_p2p: p2p_enabled:%d, wps_probe_resp_ie:%p, p2p_probe_resp_ie:%p\n"
, ADPT_ARG(padapter)
, adapter_wdev_data(padapter)->p2p_enabled
, padapter->mlmepriv.wps_probe_resp_ie
, padapter->mlmepriv.p2p_probe_resp_ie);
RTW_INFO(ADPT_FMT" DON'T issue_probersp_p2p: is_ro_ch:%d, op_ch:%d, p2p_listen_channel:%d\n"
, ADPT_ARG(padapter)
, rtw_cfg80211_get_is_roch(padapter)
, rtw_get_oper_ch(padapter)
, padapter->wdinfo.listen_channel);
#endif
response = _FALSE;
}
#endif /* CONFIG_IOCTL_CFG80211 */
if (response == _TRUE)
issue_probersp_p2p(padapter, da);
return _SUCCESS;
}
#endif /* CONFIG_P2P */
#ifdef ROKU_PRIVATE
static bool check_vendor_ie(_adapter *padapter, u8 *pframe, uint len, u8 ie_offset)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
unsigned int ielen;
u8 *p;
bool ret = _FALSE;
unsigned int search_len = 0, remain_len = 0, total_vendor_ie_len = 0;
int i;
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + ie_offset, _VENDOR_SPECIFIC_IE_, (int *)&ielen,
len - WLAN_HDR_A3_LEN - ie_offset);
while (p) {
for (i = 0; i < MAX_VENDOR_IE_NUM; i++) {
if (ielen == pmlmepriv->vendor_ie_len[i] &&
_rtw_memcmp(p, *(pmlmepriv->vendor_ie_filter + i), ielen + 2)) {
ret = _TRUE;
break;
}
}
total_vendor_ie_len = ielen + 2;
search_len = p - pframe;
remain_len = len - search_len - total_vendor_ie_len;
p = rtw_get_ie(p + total_vendor_ie_len, _VENDOR_SPECIFIC_IE_,
(int *)&ielen, remain_len);
}
return ret;
}
#ifdef CONFIG_P2P
static bool is_valid_probereq(_adapter *padapter, u8 *pframe, uint len)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur = &(pmlmeinfo->network);
struct registry_priv *pregpriv = &padapter->registrypriv;
bool ret = _FALSE;
unsigned int ielen;
u8 *p;
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, (int *)&ielen,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
if (p) {
if ((_rtw_memcmp((void *)(p + 2), "DIRECT-", P2P_WILDCARD_SSID_LEN) &&
(ielen == P2P_WILDCARD_SSID_LEN ||
(ielen == cur->Ssid.SsidLength &&
_rtw_memcmp((void *)(p + 2), (void *)cur->Ssid.Ssid, cur->Ssid.SsidLength)))) ||
(ielen == 0 && pregpriv->go_hidden_ssid_mode != ALL_HIDE_SSID))
ret = _TRUE;
}
return ret;
}
static void hide_ssid_in_beacon(_adapter *padapter, u8 *pframe, uint len)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
u8 *wfd_ie;
uint wfd_ielen;
/* check if need to unhide/hide SSID in beacon for miracast */
wfd_ie = rtw_get_wfd_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_,
NULL, &wfd_ielen);
if (wfd_ie) {
if (pregpriv->go_hidden_ssid_mode & BIT(MIRACAST)) {
rtw_clear_bit(MIRACAST, &pregpriv->go_hidden_ssid_mode);
/* check if there is other feature show SSID in beacon */
if (pregpriv->go_hidden_ssid_mode == MIRACAST_UNHIDE_SSID)
issue_beacon(padapter, 0);
ATOMIC_SET(&pregpriv->set_hide_ssid_timer, 1);
_set_timer(&pmlmeext->hide_ssid_timer, 25000);
} else {
if (ATOMIC_READ(&pregpriv->set_hide_ssid_timer))
_set_timer(&pmlmeext->hide_ssid_timer, 25000);
}
}
}
#endif
#endif
/****************************************************************************
Following are the callback functions for each subtype of the management frames
*****************************************************************************/
unsigned int OnProbeReq(_adapter *padapter, union recv_frame *precv_frame)
{
unsigned int ielen;
unsigned char *p;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur = &(pmlmeinfo->network);
u8 *pframe = precv_frame->u.hdr.rx_data;
uint len = precv_frame->u.hdr.len;
u8 is_valid_p2p_probereq = _FALSE;
#ifdef CONFIG_ATMEL_RC_PATCH
u8 *target_ie = NULL, *wps_ie = NULL;
u8 *start;
uint search_len = 0, wps_ielen = 0, target_ielen = 0;
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
#endif
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
u8 wifi_test_chk_rate = 1;
#endif
#ifdef CONFIG_IOCTL_CFG80211
#ifdef RTW_USE_CFG80211_REPORT_PROBE_REQ
if (GET_CFG80211_REPORT_MGMT(adapter_wdev_data(padapter),
IEEE80211_STYPE_PROBE_REQ) == _TRUE) {
#ifdef ROKU_PRIVATE
if (pmlmepriv->vendor_ie_filter_enable) {
/* check vendor ie for softAP and GO */
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) &&
!check_vendor_ie(padapter, pframe, len, _PROBEREQ_IE_OFFSET_))
return _FAIL;
}
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
if (!is_valid_probereq(padapter, pframe, len))
return _FAIL;
hide_ssid_in_beacon(padapter, pframe, len);
}
#endif
#endif
rtw_cfg80211_rx_probe_request(padapter, precv_frame);
return _SUCCESS;
} else {
return _FAIL;
}
#endif
#if !defined(RTW_WKARD_DIS_PROBE_REQ_RPT_TO_HOSTAPD)
if (MLME_IS_AP(padapter) &&
(GET_CFG80211_REPORT_MGMT(adapter_wdev_data(padapter), IEEE80211_STYPE_PROBE_REQ) == _TRUE)) {
rtw_cfg80211_rx_probe_request(padapter, precv_frame);
return _SUCCESS;
}
#endif
#ifdef CONFIG_P2P
if ((adapter_to_dvobj(padapter)->wpas_type == RTW_WPAS_W1FI) &&
!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DISABLE) &&
(GET_CFG80211_REPORT_MGMT(adapter_wdev_data(padapter),
IEEE80211_STYPE_PROBE_REQ) == _TRUE)) {
rtw_cfg80211_rx_probe_request(padapter, precv_frame);
return _SUCCESS;
}
#endif
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) ||
rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
/* Commented by Albert 2011/03/17 */
/* mcs_rate = 0->CCK 1M rate */
/* mcs_rate = 1->CCK 2M rate */
/* mcs_rate = 2->CCK 5.5M rate */
/* mcs_rate = 3->CCK 11M rate */
/* In the P2P mode, the driver should not support the CCK rate */
/* Commented by Kurt 2012/10/16 */
/* IOT issue: Google Nexus7 use 1M rate to send p2p_probe_req after GO nego completed and Nexus7 is client */
if (padapter->registrypriv.wifi_spec == 1) {
if (pattrib->data_rate <= DESC_RATE11M)
wifi_test_chk_rate = 0;
}
if (wifi_test_chk_rate == 1) {
is_valid_p2p_probereq = process_probe_req_p2p_ie(pwdinfo, pframe, len);
if (is_valid_p2p_probereq == _TRUE) {
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE)) {
/* P2P Device only responds probe response in listen state(ROCH) */
if (MLME_IS_ROCH(padapter))
p2p_listen_state_process(padapter, get_sa(pframe));
return _SUCCESS;
}
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
goto _continue;
}
}
}
_continue:
#endif /* CONFIG_P2P */
if (MLME_IS_STA(padapter))
return _SUCCESS;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE &&
check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE | WIFI_AP_STATE | WIFI_MESH_STATE) == _FALSE)
return _SUCCESS;
/* RTW_INFO("+OnProbeReq\n"); */
#ifdef CONFIG_ATMEL_RC_PATCH
wps_ie = rtw_get_wps_ie(
pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_,
NULL, &wps_ielen);
if (wps_ie)
target_ie = rtw_get_wps_attr_content(wps_ie, wps_ielen, WPS_ATTR_MANUFACTURER, NULL, &target_ielen);
if ((target_ie && (target_ielen == 4)) && (_TRUE == _rtw_memcmp((void *)target_ie, "Ozmo", 4))) {
/* psta->flag_atmel_rc = 1; */
unsigned char *sa_addr = get_sa(pframe);
printk("%s: Find Ozmo RC -- %02x:%02x:%02x:%02x:%02x:%02x \n\n",
__func__, *sa_addr, *(sa_addr + 1), *(sa_addr + 2), *(sa_addr + 3), *(sa_addr + 4), *(sa_addr + 5));
_rtw_memcpy(pstapriv->atmel_rc_pattern, get_sa(pframe), ETH_ALEN);
}
#endif
#ifdef CONFIG_AUTO_AP_MODE
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE &&
pmlmepriv->cur_network.join_res == _TRUE) {
struct sta_info *psta;
u8 *mac_addr, *peer_addr;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 RC_OUI[4] = {0x00, 0xE0, 0x4C, 0x0A};
/* EID[1] + EID_LEN[1] + RC_OUI[4] + MAC[6] + PairingID[2] + ChannelNum[2] */
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _VENDOR_SPECIFIC_IE_, (int *)&ielen,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
if (!p || ielen != 14)
goto _non_rc_device;
if (!_rtw_memcmp(p + 2, RC_OUI, sizeof(RC_OUI)))
goto _non_rc_device;
if (!_rtw_memcmp(p + 6, get_sa(pframe), ETH_ALEN)) {
RTW_INFO("%s, do rc pairing ("MAC_FMT"), but mac addr mismatch!("MAC_FMT")\n", __FUNCTION__,
MAC_ARG(get_sa(pframe)), MAC_ARG(p + 6));
goto _non_rc_device;
}
RTW_INFO("%s, got the pairing device("MAC_FMT")\n", __FUNCTION__, MAC_ARG(get_sa(pframe)));
/* new a station */
psta = rtw_get_stainfo(pstapriv, get_sa(pframe));
if (psta == NULL) {
/* allocate a new one */
RTW_INFO("going to alloc stainfo for rc="MAC_FMT"\n", MAC_ARG(get_sa(pframe)));
psta = rtw_alloc_stainfo(pstapriv, get_sa(pframe));
if (psta == NULL) {
/* TODO: */
RTW_INFO(" Exceed the upper limit of supported clients...\n");
return _SUCCESS;
}
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&psta->asoc_list)) {
psta->expire_to = pstapriv->expire_to;
rtw_list_insert_tail(&psta->asoc_list, &pstapriv->asoc_list);
pstapriv->asoc_list_cnt++;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (psta->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt++;
#endif
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
/* generate pairing ID */
mac_addr = adapter_mac_addr(padapter);
peer_addr = psta->phl_sta->mac_addr;
psta->pid = (u16)(((mac_addr[4] << 8) + mac_addr[5]) + ((peer_addr[4] << 8) + peer_addr[5]));
/* update peer stainfo */
psta->isrc = _TRUE;
/* AID assignment */
if (psta->phl_sta->aid > 0)
RTW_INFO(FUNC_ADPT_FMT" old AID=%d\n", FUNC_ADPT_ARG(padapter), psta->phl_sta->aid);
else {
if (!rtw_aid_alloc(padapter, psta)) {
RTW_INFO(FUNC_ADPT_FMT" no room for more AIDs\n", FUNC_ADPT_ARG(padapter));
return _SUCCESS;
}
RTW_INFO(FUNC_ADPT_FMT" allocate new AID=%d\n", FUNC_ADPT_ARG(padapter), psta->phl_sta->aid);
}
psta->qos_option = 1;
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_20;
psta->ieee8021x_blocked = _FALSE;
#ifdef CONFIG_80211N_HT
if(padapter->registrypriv.ht_enable &&
is_supported_ht(padapter->registrypriv.wireless_mode)) {
psta->htpriv.ht_option = _TRUE;
psta->htpriv.ampdu_enable = _FALSE;
psta->htpriv.sgi_20m = _FALSE;
psta->htpriv.sgi_40m = _FALSE;
psta->htpriv.ch_offset = CHAN_OFFSET_NO_EXT;
psta->htpriv.agg_enable_bitmap = 0x0;/* reset */
psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */
}
#endif
_rtw_memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats));
_rtw_spinlock_bh(&psta->lock);
psta->state |= WIFI_ASOC_STATE;
_rtw_spinunlock_bh(&psta->lock);
report_add_sta_event(padapter, psta->phl_sta->mac_addr);
}
issue_probersp(padapter, get_sa(pframe), _FALSE);
return _SUCCESS;
}
_non_rc_device:
return _SUCCESS;
#endif /* CONFIG_AUTO_AP_MODE */
#ifdef CONFIG_CONCURRENT_MODE
if (((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) &&
rtw_mi_buddy_check_fwstate(padapter, WIFI_UNDER_LINKING | WIFI_UNDER_SURVEY)) {
/* don't process probe req */
return _SUCCESS;
}
#endif
#ifdef ROKU_PRIVATE
if (pmlmepriv->vendor_ie_filter_enable) {
/* check vendor ie for softAP and GO */
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) &&
!check_vendor_ie(padapter, pframe, len, _PROBEREQ_IE_OFFSET_))
goto exit;
}
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
if (is_valid_probereq(padapter, pframe, len)) {
hide_ssid_in_beacon(padapter, pframe, len);
goto _issue_probersp;
} else {
goto exit;
}
}
#endif
#endif
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, (int *)&ielen,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
if (!p)
goto exit;
if (is_valid_p2p_probereq == _TRUE)
goto _issue_probersp;
if ((ielen != 0 &&
!_rtw_memcmp((void *)(p + 2), (void *)cur->Ssid.Ssid, cur->Ssid.SsidLength)) ||
(ielen == 0 && pmlmeinfo->hidden_ssid_mode))
goto exit;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, WLAN_EID_MESH_ID, (int *)&ielen,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
if (!p)
goto exit;
if (ielen != 0 && _rtw_memcmp((void *)(p + 2), (void *)cur->mesh_id.Ssid, cur->mesh_id.SsidLength) == _FALSE)
goto exit;
}
#endif
_issue_probersp:
if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE &&
pmlmepriv->cur_network.join_res == _TRUE) ||
check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
/* RTW_INFO("+issue_probersp during ap mode\n"); */
issue_probersp(padapter, get_sa(pframe), is_valid_p2p_probereq);
}
exit:
return _SUCCESS;
}
unsigned int OnProbeRsp(_adapter *padapter, union recv_frame *precv_frame)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
u8 *pframe = precv_frame->u.hdr.rx_data;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
#endif
if ((mlmeext_chk_scan_state(pmlmeext, SCAN_PROCESS))
|| (MLME_IS_MESH(padapter) && check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE))
) {
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (_rtw_memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)
&& (pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE && (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)
) {
if (!rtw_check_bcn_info(padapter, pframe, precv_frame->u.hdr.len)) {
RTW_PRINT(FUNC_ADPT_FMT" ap has changed, disconnect now\n", FUNC_ADPT_ARG(padapter));
receive_disconnect(padapter, pmlmeinfo->network.MacAddress , 0, _FALSE);
}
}
rtw_mi_report_survey_event(padapter, precv_frame);
return _SUCCESS;
}
#if 0 /* move to validate_recv_mgnt_frame */
if (_rtw_memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)) {
if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) {
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta != NULL)
psta->sta_stats.rx_mgnt_pkts++;
}
}
#endif
return _SUCCESS;
}
/* for 11n Logo 4.2.31/4.2.32 */
static void rtw_check_legacy_ap(_adapter *padapter, u8 *pframe, u32 len)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (!padapter->registrypriv.wifi_spec)
return;
if(!MLME_IS_AP(padapter))
return;
if (pmlmeext->bstart_bss == _TRUE) {
int left;
unsigned char *pos;
struct rtw_ieee802_11_elems elems;
#ifdef CONFIG_80211N_HT
u16 cur_op_mode;
#endif
/* checking IEs */
left = len - sizeof(struct rtw_ieee80211_hdr_3addr) - _BEACON_IE_OFFSET_;
pos = pframe + sizeof(struct rtw_ieee80211_hdr_3addr) + _BEACON_IE_OFFSET_;
if (rtw_ieee802_11_parse_elems(pos, left, &elems, 1) == ParseFailed) {
RTW_INFO("%s: parse fail for "MAC_FMT"\n", __func__, MAC_ARG(GetAddr3Ptr(pframe)));
return;
}
#ifdef CONFIG_80211N_HT
cur_op_mode = pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_OP_MODE_MASK;
#endif
/* for legacy ap */
if (elems.ht_capabilities == NULL && elems.ht_capabilities_len == 0) {
if (0)
RTW_INFO("%s: "MAC_FMT" is legacy ap\n", __func__, MAC_ARG(GetAddr3Ptr(pframe)));
ATOMIC_SET(&pmlmepriv->olbc, _TRUE);
ATOMIC_SET(&pmlmepriv->olbc_ht, _TRUE);
}
}
}
unsigned int OnBeacon(_adapter *padapter, union recv_frame *precv_frame)
{
struct sta_info *psta;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *pframe = precv_frame->u.hdr.rx_data;
uint len = precv_frame->u.hdr.len;
WLAN_BSSID_EX *pbss;
int ret = _SUCCESS;
#ifdef CONFIG_TDLS
struct sta_info *ptdls_sta;
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
#ifdef CONFIG_TDLS_CH_SW
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
#endif
#endif /* CONFIG_TDLS */
#if defined(CONFIG_MCC_MODE) || defined(CONFIG_RTW_LPS)
struct rtw_bcn_pkt_info bcn_info = {0};
#endif
if (pframe == NULL) {
RTW_ERR(FUNC_ADPT_FMT" pframe == NULL\n", FUNC_ADPT_ARG(padapter));
rtw_warn_on(1);
return _SUCCESS;
}
if (validate_beacon_len(pframe, len) == _FALSE) {
return _SUCCESS;
}
if (mlmeext_chk_scan_state(pmlmeext, SCAN_PROCESS)
|| (MLME_IS_MESH(padapter) && check_fwstate(pmlmepriv, WIFI_ASOC_STATE))
) {
if (_rtw_memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)
&& (pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE && (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)
) {
#ifndef RTW_PHL_TEST_FPGA
if (!rtw_check_bcn_info(padapter, pframe, len)) {
RTW_PRINT(FUNC_ADPT_FMT" ap has changed, disconnect now\n", FUNC_ADPT_ARG(padapter));
receive_disconnect(padapter, pmlmeinfo->network.MacAddress , 0, _FALSE);
}
#endif
}
rtw_mi_report_survey_event(padapter, precv_frame);
return _SUCCESS;
}
rtw_check_legacy_ap(padapter, pframe, len);
if (_rtw_memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)) {
if ((pmlmeinfo->state & WIFI_FW_AUTH_NULL)
&& (rtw_sta_linking_test_wait_done() || pmlmeext->join_abort)
) {
if (rtw_sta_linking_test_force_fail() || pmlmeext->join_abort) {
set_link_timer(pmlmeext, 1);
return _SUCCESS;
}
/* we should update current network before auth, or some IE is wrong */
pbss = (WLAN_BSSID_EX *)rtw_malloc(sizeof(WLAN_BSSID_EX));
if (pbss) {
if (collect_bss_info(padapter, precv_frame, pbss) == _SUCCESS) {
struct beacon_keys recv_beacon;
rtw_update_network(&(pmlmepriv->cur_network.network), pbss, padapter, _TRUE);
/* update bcn keys */
#ifdef RTW_PHL_TEST_FPGA
if (1)
#else
if (rtw_get_bcn_keys(padapter, pframe, len, &recv_beacon) == _TRUE)
#endif
{
RTW_INFO("%s: beacon keys ready\n", __func__);
_rtw_memcpy(&pmlmepriv->cur_beacon_keys,
&recv_beacon, sizeof(recv_beacon));
if (is_hidden_ssid(recv_beacon.ssid, recv_beacon.ssid_len)) {
_rtw_memcpy(pmlmepriv->cur_beacon_keys.ssid, pmlmeinfo->network.Ssid.Ssid, IW_ESSID_MAX_SIZE);
pmlmepriv->cur_beacon_keys.ssid_len = pmlmeinfo->network.Ssid.SsidLength;
}
} else {
RTW_ERR("%s: get beacon keys failed\n", __func__);
_rtw_memset(&pmlmepriv->cur_beacon_keys, 0, sizeof(recv_beacon));
}
}
rtw_mfree((u8 *)pbss, sizeof(WLAN_BSSID_EX));
}
/* check the vendor of the assoc AP */
pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pframe + sizeof(struct rtw_ieee80211_hdr_3addr), len - sizeof(struct rtw_ieee80211_hdr_3addr));
/* update TSF Value */
update_TSF(pmlmeext, pframe, len);
pmlmeext->bcn_cnt = 0;
pmlmeext->last_bcn_cnt = 0;
#ifdef CONFIG_P2P_PS
/* Comment by YiWei , in wifi p2p spec the "3.3 P2P Power Management" , "These mechanisms are available in a P2P Group in which only P2P Devices are associated." */
/* process_p2p_ps_ie(padapter, (pframe + WLAN_HDR_A3_LEN), (len - WLAN_HDR_A3_LEN)); */
#endif /* CONFIG_P2P_PS */
#if defined(CONFIG_P2P) && defined(CONFIG_CONCURRENT_MODE)
if (padapter->registrypriv.wifi_spec) {
if (process_p2p_cross_connect_ie(padapter, (pframe + WLAN_HDR_A3_LEN), (len - WLAN_HDR_A3_LEN)) == _FALSE) {
if (rtw_mi_buddy_check_mlmeinfo_state(padapter, WIFI_FW_AP_STATE)) {
RTW_PRINT("no issue auth, P2P cross-connect does not permit\n ");
return _SUCCESS;
}
}
}
#endif /* CONFIG_P2P CONFIG_P2P and CONFIG_CONCURRENT_MODE */
/* start auth */
start_clnt_auth(padapter);
return _SUCCESS;
}
if (((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE) && (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) {
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta != NULL) {
#ifdef CONFIG_PATCH_JOIN_WRONG_CHANNEL
/* Merge from 8712 FW code */
if (cmp_pkt_chnl_diff(padapter, pframe, len) != 0) {
/* join wrong channel, deauth and reconnect */
issue_deauth(padapter, (&(pmlmeinfo->network))->MacAddress, WLAN_REASON_DEAUTH_LEAVING);
report_del_sta_event(padapter, (&(pmlmeinfo->network))->MacAddress, WLAN_REASON_JOIN_WRONG_CHANNEL, _TRUE, _FALSE);
pmlmeinfo->state &= (~WIFI_FW_ASSOC_SUCCESS);
return _SUCCESS;
}
#endif /* CONFIG_PATCH_JOIN_WRONG_CHANNEL */
#ifdef CONFIG_RTW_80211R
rtw_ft_update_bcn(padapter, precv_frame);
#endif
#ifdef RTW_PHL_TEST_FPGA
ret = 1;
#else
ret = rtw_check_bcn_info(padapter, pframe, len);
#endif
if (!ret) {
RTW_PRINT(FUNC_ADPT_FMT" ap has changed, disconnect now\n", FUNC_ADPT_ARG(padapter));
receive_disconnect(padapter, pmlmeinfo->network.MacAddress , 0, _FALSE);
return _SUCCESS;
}
/* update WMM, ERP in the beacon */
/* todo: the timer is used instead of the number of the beacon received */
if ((sta_rx_pkts(psta) & 0xf) == 0) {
/* RTW_INFO("update_bcn_info\n"); */
update_beacon_info(padapter, pframe, len, psta);
}
if (pmlmepriv->cur_network_scanned)
pmlmepriv->cur_network_scanned->network.PhyInfo.rssi = precv_frame->u.hdr.attrib.phy_info.recv_signal_power;
pmlmeext->bcn_cnt++;
#ifdef CONFIG_BCN_RECV_TIME
rtw_rx_bcn_time_update(padapter, len, precv_frame->u.hdr.attrib.data_rate);
#endif
#if defined(CONFIG_MCC_MODE) || defined(CONFIG_RTW_LPS)
update_TSF(pmlmeext, pframe, len);
bcn_info.sta = psta->phl_sta;
bcn_info.tsf = pmlmeext->TSFValue;
rtw_phl_sta_up_rx_bcn(GET_PHL_INFO(adapter_to_dvobj(padapter)), &bcn_info);
#endif
#ifdef CONFIG_TDLS
#ifdef CONFIG_TDLS_CH_SW
if (rtw_tdls_is_chsw_allowed(padapter) == _TRUE) {
/* Send TDLS Channel Switch Request when receiving Beacon */
if ((padapter->tdlsinfo.chsw_info.ch_sw_state & TDLS_CH_SW_INITIATOR_STATE) && (ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE)
&& (pmlmeext->chandef.chan == rtw_get_oper_ch(padapter))) {
ptdls_sta = rtw_get_stainfo(&padapter->stapriv, padapter->tdlsinfo.chsw_info.addr);
if (ptdls_sta != NULL) {
if (ptdls_sta->tdls_sta_state | TDLS_LINKED_STATE)
_set_timer(&ptdls_sta->stay_on_base_chnl_timer, TDLS_CH_SW_STAY_ON_BASE_CHNL_TIMEOUT);
}
}
}
#endif
#endif /* CONFIG_TDLS */
#if CONFIG_DFS
process_csa_ie(padapter
, pframe + WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_
, len - (WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_));
#endif
#ifdef CONFIG_80211D
process_country_ie(padapter
, pframe + WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_
, len - (WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_));
#endif
#ifdef CONFIG_P2P_PS
process_p2p_ps_ie(padapter, (pframe + WLAN_HDR_A3_LEN), (len - WLAN_HDR_A3_LEN));
#endif /* CONFIG_P2P_PS */
if (ATOMIC_READ(&padapter->need_tsf_sync_done) == _TRUE) {
rtw_send_tsf_sync_done_msg(padapter);
ATOMIC_SET(&padapter->need_tsf_sync_done, _FALSE);
}
#if 0 /* move to validate_recv_mgnt_frame */
psta->sta_stats.rx_mgnt_pkts++;
#endif
}
} else if ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE) {
u8 rate_set[16];
u8 rate_num = 0;
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta != NULL) {
/*
* update WMM, ERP in the beacon
* todo: the timer is used instead of the number of the beacon received
*/
if ((sta_rx_pkts(psta) & 0xf) == 0)
update_beacon_info(padapter, pframe, len, psta);
} else {
rtw_ies_get_supported_rate(pframe + WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_, len - WLAN_HDR_A3_LEN - _BEACON_IE_OFFSET_, rate_set, &rate_num);
if (rate_num == 0) {
RTW_INFO(FUNC_ADPT_FMT" RX beacon with no supported rate\n", FUNC_ADPT_ARG(padapter));
goto _END_ONBEACON_;
}
psta = rtw_alloc_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta == NULL) {
RTW_INFO(FUNC_ADPT_FMT" Exceed the upper limit of supported clients\n", FUNC_ADPT_ARG(padapter));
goto _END_ONBEACON_;
}
psta->expire_to = pstapriv->adhoc_expire_to;
_rtw_memcpy(psta->bssrateset, rate_set, rate_num);
psta->bssratelen = rate_num;
/* update TSF Value */
update_TSF(pmlmeext, pframe, len);
/* report sta add event */
report_add_sta_event(padapter, get_addr2_ptr(pframe));
}
}
}
_END_ONBEACON_:
return _SUCCESS;
}
static u32 rtw_get_sta_num_by_state(_adapter *padapter, u32 state)
{
_list *plist, *phead;
u32 index, sta_num = 0;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &(padapter->stapriv);
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < NUM_STA; index++) {
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info , hash_list);
if ((psta->state & (state)))
sta_num++;
plist = get_next(plist);
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
/* RTW_INFO("%s : waiting for %u sta under linking \n", __func__, sta_num); */
return sta_num;
}
static u8 rtw_defs_attack_chk(_adapter *padapter)
{
struct mlme_priv *mlme = &(padapter->mlmepriv);
u8 is_reject = _FALSE;
u32 sta_limit = 0;
u32 stime = rtw_systime_to_ms(rtw_get_current_time());
static u32 ptime = 0;
/* RTW_INFO("%s : ptime=%u, stime=%u, diff=%u\n", __func__, ptime, stime, (stime - ptime)); */
if ((ptime > 0) && ((stime - ptime) < mlme->defs_lmt_time)) {
sta_limit = rtw_get_sta_num_by_state(padapter, WIFI_FW_LINKING_STATE);
if (sta_limit >= mlme->defs_lmt_sta)
is_reject = _TRUE;
}
ptime = stime;
/* RTW_INFO("%s : current linking num=%u\n", __func__, sta_limit); */
return is_reject;
}
unsigned int OnAuth(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_AP_MODE
unsigned int auth_mode, seq, ie_len;
unsigned char *sa, *p;
u16 algorithm;
int status;
static struct sta_info stat;
static struct rtw_phl_stainfo_t phl_stat;
struct sta_info *pstat = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 *pframe = precv_frame->u.hdr.rx_data;
uint len = precv_frame->u.hdr.len;
u8 offset = 0;
#ifdef CONFIG_CONCURRENT_MODE
if (((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) &&
rtw_mi_buddy_check_fwstate(padapter, WIFI_UNDER_LINKING | WIFI_UNDER_SURVEY)) {
/* don't process auth request; */
return _SUCCESS;
}
#endif /* CONFIG_CONCURRENT_MODE */
if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
return _FAIL;
if (!MLME_IS_ASOC(padapter))
return _SUCCESS;
#if defined(CONFIG_IOCTL_CFG80211) && defined(CONFIG_RTW_MESH)
if (MLME_IS_MESH(padapter))
return rtw_mesh_on_auth(padapter, precv_frame);
#endif
RTW_INFO("+OnAuth\n");
sa = get_addr2_ptr(pframe);
auth_mode = psecuritypriv->dot11AuthAlgrthm;
if (GetPrivacy(pframe)) {
u8 *iv;
struct rx_pkt_attrib *prxattrib = &(precv_frame->u.hdr.attrib);
prxattrib->hdrlen = WLAN_HDR_A3_LEN;
prxattrib->encrypt = _WEP40_;
iv = pframe + prxattrib->hdrlen;
prxattrib->key_index = ((iv[3] >> 6) & 0x3);
prxattrib->iv_len = 4;
prxattrib->icv_len = 4;
rtw_wep_decrypt(padapter, (u8 *)precv_frame);
offset = 4;
}
algorithm = le16_to_cpu(*(u16 *)((SIZE_PTR)pframe + WLAN_HDR_A3_LEN + offset));
seq = le16_to_cpu(*(u16 *)((SIZE_PTR)pframe + WLAN_HDR_A3_LEN + offset + 2));
RTW_INFO("auth alg=%x, seq=%X\n", algorithm, seq);
if (rtw_check_invalid_mac_address(sa, _FALSE)){
RTW_INFO("%s : reject invalid AUTH-req "MAC_FMT"\n",
__func__, MAC_ARG(get_addr2_ptr(pframe)));
return _FAIL;
}
if(rtw_defs_attack_chk(padapter)) {
struct sta_info *_psta;
_psta = rtw_get_stainfo(pstapriv, sa);
if ((_psta == NULL) || !(_psta->state & WIFI_FW_ASSOC_SUCCESS)) {
status = _STATS_REFUSED_TEMPORARILY_;
RTW_ERR("%s : refused temporarily for sa "MAC_FMT" !\n", __func__, MAC_ARG(sa));
goto auth_fail;
}
}
if (rtw_ap_linking_test_force_auth_fail()) {
status = rtw_ap_linking_test_force_auth_fail();
RTW_INFO(FUNC_ADPT_FMT" force auth fail with status:%u\n"
, FUNC_ADPT_ARG(padapter), status);
goto auth_fail;
}
if ((auth_mode == 2) && (algorithm != WLAN_AUTH_SAE) &&
(psecuritypriv->dot11PrivacyAlgrthm != _WEP40_) &&
(psecuritypriv->dot11PrivacyAlgrthm != _WEP104_))
auth_mode = 0;
if (((algorithm > 0 && auth_mode == 0) || /* rx a shared-key auth but shared not enabled */
(algorithm == 0 && auth_mode == 1))
#ifdef CONFIG_RTW_80211R_AP
&& (algorithm != WLAN_AUTH_FT)
#endif
) { /* rx a open-system auth but shared-key is enabled */
RTW_INFO("auth rejected due to bad alg [alg=%d, auth_mib=%d] %02X%02X%02X%02X%02X%02X\n",
algorithm, auth_mode, sa[0], sa[1], sa[2], sa[3], sa[4], sa[5]);
status = _STATS_NO_SUPP_ALG_;
goto auth_fail;
}
#if CONFIG_RTW_MACADDR_ACL
if (rtw_access_ctrl(padapter, sa) == _FALSE) {
status = _STATS_UNABLE_HANDLE_STA_;
goto auth_fail;
}
#endif
pstat = rtw_get_stainfo(pstapriv, sa);
if (pstat == NULL) {
/* allocate a new one */
RTW_INFO("going to alloc stainfo for sa="MAC_FMT"\n", MAC_ARG(sa));
pstat = rtw_alloc_stainfo_sw(pstapriv, sa);
if (pstat == NULL) {
RTW_INFO(" Exceed the upper limit of supported clients...\n");
status = _STATS_UNABLE_HANDLE_STA_;
goto auth_fail;
}
pstat->state = WIFI_FW_AUTH_NULL;
pstat->auth_seq = 0;
/* pstat->flags = 0; */
/* pstat->capability = 0; */
} else {
#ifdef ROKU_PRIVATE
RTW_INFO("STA is still connecting, disconnect it at first.\n");
rtw_cfg80211_indicate_sta_disassoc(padapter, sa, WLAN_REASON_DISASSOC_STA_HAS_LEFT);
#endif
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&pstat->asoc_list) == _FALSE) {
rtw_list_delete(&pstat->asoc_list);
pstapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (pstat->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt--;
#endif
if (pstat->expire_to > 0)
;/* TODO: STA re_auth within expire_to */
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
if (seq == 1)
; /* TODO: STA re_auth and auth timeout */
}
}
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
_rtw_spinlock_bh(&pstapriv->auth_list_lock);
if (rtw_is_list_empty(&pstat->auth_list)) {
rtw_list_insert_tail(&pstat->auth_list, &pstapriv->auth_list);
pstapriv->auth_list_cnt++;
}
_rtw_spinunlock_bh(&pstapriv->auth_list_lock);
}
if (pstat->auth_seq == 0)
pstat->expire_to = pstapriv->auth_to;
#ifdef CONFIG_IOCTL_CFG80211
if (GET_CFG80211_REPORT_MGMT(adapter_wdev_data(padapter), IEEE80211_STYPE_AUTH) == _TRUE) {
if ((algorithm == WLAN_AUTH_SAE) &&
(auth_mode == dot11AuthAlgrthm_8021X)) {
pstat->authalg = algorithm;
rtw_cfg80211_rx_mframe(padapter, precv_frame, NULL);
return _SUCCESS;
}
#ifdef CONFIG_RTW_80211R_AP
pstat->authalg = algorithm;
if (algorithm == WLAN_AUTH_FT) {
rtw_cfg80211_rx_mframe(padapter, precv_frame, "FTTA");
return _SUCCESS;
}
#endif
}
#endif /* CONFIG_IOCTL_CFG80211 */
if ((pstat->auth_seq + 1) != seq) {
RTW_INFO("(1)auth rejected because out of seq [rx_seq=%d, exp_seq=%d]!\n",
seq, pstat->auth_seq + 1);
status = _STATS_OUT_OF_AUTH_SEQ_;
goto auth_fail;
}
if (algorithm == 0 && (auth_mode == 0 || auth_mode == 2 || auth_mode == 3)) {
if (seq == 1) {
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
pstat->state &= ~WIFI_FW_AUTH_NULL;
pstat->state |= WIFI_FW_AUTH_SUCCESS;
pstat->expire_to = pstapriv->assoc_to;
}
pstat->authalg = algorithm;
} else {
RTW_INFO("(2)auth rejected because out of seq [rx_seq=%d, exp_seq=%d]!\n",
seq, pstat->auth_seq + 1);
status = _STATS_OUT_OF_AUTH_SEQ_;
goto auth_fail;
}
} else { /* shared system or auto authentication */
if (seq == 1) {
/* prepare for the challenging txt... */
/* get_random_bytes((void *)pstat->chg_txt, 128); */ /* TODO: */
_rtw_memset((void *)pstat->chg_txt, 78, 128);
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
pstat->state &= ~WIFI_FW_AUTH_NULL;
pstat->state |= WIFI_FW_AUTH_STATE;
}
pstat->authalg = algorithm;
pstat->auth_seq = 2;
} else if (seq == 3) {
/* checking for challenging txt... */
RTW_INFO("checking for challenging txt...\n");
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + 4 + _AUTH_IE_OFFSET_ , _CHLGETXT_IE_, (int *)&ie_len,
len - WLAN_HDR_A3_LEN - _AUTH_IE_OFFSET_ - 4);
if ((p == NULL) || (ie_len <= 0)) {
RTW_INFO("auth rejected because challenge failure!(1)\n");
status = _STATS_CHALLENGE_FAIL_;
goto auth_fail;
}
if (_rtw_memcmp((void *)(p + 2), pstat->chg_txt, 128)) {
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
pstat->state &= (~WIFI_FW_AUTH_STATE);
pstat->state |= WIFI_FW_AUTH_SUCCESS;
/* challenging txt is correct... */
pstat->expire_to = pstapriv->assoc_to;
}
} else {
RTW_INFO("auth rejected because challenge failure!\n");
status = _STATS_CHALLENGE_FAIL_;
goto auth_fail;
}
} else {
RTW_INFO("(3)auth rejected because out of seq [rx_seq=%d, exp_seq=%d]!\n",
seq, pstat->auth_seq + 1);
status = _STATS_OUT_OF_AUTH_SEQ_;
goto auth_fail;
}
}
/* Now, we are going to issue_auth... */
pstat->auth_seq = seq + 1;
#ifdef CONFIG_NATIVEAP_MLME
issue_auth(padapter, pstat, (unsigned short)(_STATS_SUCCESSFUL_));
#endif
if ((pstat->state & WIFI_FW_AUTH_SUCCESS) || (pstat->state & WIFI_FW_ASSOC_SUCCESS))
pstat->auth_seq = 0;
return _SUCCESS;
auth_fail:
if (pstat)
rtw_free_stainfo_sw(padapter , pstat);
pstat = &stat;
_rtw_memset((char *)pstat, '\0', sizeof(stat));
pstat->phl_sta = &phl_stat;
pstat->auth_seq = 2;
_rtw_memcpy(pstat->phl_sta->mac_addr, sa, ETH_ALEN);
#ifdef CONFIG_NATIVEAP_MLME
issue_auth(padapter, pstat, (unsigned short)status);
#endif
#endif
return _FAIL;
}
unsigned int OnAuthClient(_adapter *padapter, union recv_frame *precv_frame)
{
unsigned int seq, len, status, algthm, offset;
unsigned char *p;
unsigned int go2asoc = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 *pframe = precv_frame->u.hdr.rx_data;
uint pkt_len = precv_frame->u.hdr.len;
RTW_INFO("%s\n", __FUNCTION__);
#ifdef CONFIG_IOCTL_CFG80211
if (GET_CFG80211_REPORT_MGMT(adapter_wdev_data(padapter), IEEE80211_STYPE_AUTH) == _TRUE) {
if (rtw_sec_chk_auth_type(padapter, MLME_AUTHTYPE_SAE)) {
if (rtw_cached_pmkid(padapter, get_my_bssid(&pmlmeinfo->network)) != -1) {
RTW_INFO("SAE: PMKSA cache entry found\n");
goto normal;
}
rtw_cfg80211_rx_mframe(padapter, precv_frame, NULL);
return _SUCCESS;
}
}
normal:
#endif /* CONFIG_IOCTL_CFG80211 */
/* check A1 matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter), get_da(pframe), ETH_ALEN))
return _SUCCESS;
if (!(pmlmeinfo->state & WIFI_FW_AUTH_STATE) || pmlmeext->join_abort)
return _SUCCESS;
offset = (GetPrivacy(pframe)) ? 4 : 0;
algthm = le16_to_cpu(*(unsigned short *)((SIZE_PTR)pframe + WLAN_HDR_A3_LEN + offset));
seq = le16_to_cpu(*(unsigned short *)((SIZE_PTR)pframe + WLAN_HDR_A3_LEN + offset + 2));
status = le16_to_cpu(*(unsigned short *)((SIZE_PTR)pframe + WLAN_HDR_A3_LEN + offset + 4));
if (status != 0) {
RTW_INFO("clnt auth fail, status: %d\n", status);
if (status == 13) { /* && pmlmeinfo->auth_algo == dot11AuthAlgrthm_Auto) */
if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared)
pmlmeinfo->auth_algo = dot11AuthAlgrthm_Open;
else
pmlmeinfo->auth_algo = dot11AuthAlgrthm_Shared;
/* pmlmeinfo->reauth_count = 0; */
}
pmlmeinfo->auth_status = status;
set_link_timer(pmlmeext, 1);
goto authclnt_fail;
}
if (seq == 2) {
if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared) {
/* legendary shared system */
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _AUTH_IE_OFFSET_, _CHLGETXT_IE_, (int *)&len,
pkt_len - WLAN_HDR_A3_LEN - _AUTH_IE_OFFSET_);
if (p == NULL) {
/* RTW_INFO("marc: no challenge text?\n"); */
goto authclnt_fail;
}
_rtw_memcpy((void *)(pmlmeinfo->chg_txt), (void *)(p + 2), len);
pmlmeinfo->auth_seq = 3;
issue_auth(padapter, NULL, 0);
set_link_timer(pmlmeext, REAUTH_TO);
return _SUCCESS;
} else {
/* open, or 802.11r FTAA system */
go2asoc = 1;
}
} else if (seq == 4) {
if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared)
go2asoc = 1;
else
goto authclnt_fail;
} else {
/* this is also illegal */
/* RTW_INFO("marc: clnt auth failed due to illegal seq=%x\n", seq); */
goto authclnt_fail;
}
if (go2asoc) {
#ifdef CONFIG_RTW_80211R
if (rtw_ft_update_auth_rsp_ies(padapter, pframe, pkt_len))
return _SUCCESS;
#endif
RTW_PRINT("auth success, start assoc\n");
start_clnt_assoc(padapter);
return _SUCCESS;
}
authclnt_fail:
/* pmlmeinfo->state &= ~(WIFI_FW_AUTH_STATE); */
return _FAIL;
}
static u8 rtw_deny_legacy_sta(_adapter *padapter, struct sta_info *pstat)
{
struct registry_priv *pregpriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
u8 res = _FALSE;
sta_info_update(padapter, pstat);
rtw_ap_set_sta_wmode(padapter, pstat);
if (pmlmeext->cur_wireless_mode == WLAN_MD_11BGN) {
if ((pregpriv->deny_legacy == WLAN_MD_11BG) &&
!(pstat->phl_sta->wmode & WLAN_MD_11N))
/* 2.4G N only */
res = _TRUE;
else if ((pregpriv->deny_legacy == WLAN_MD_11B) &&
(pstat->phl_sta->wmode == WLAN_MD_11B))
/* 2.4G G+N */
res = _TRUE;
} else if (pmlmeext->cur_wireless_mode == WLAN_MD_11BG) {
if ((pregpriv->deny_legacy == WLAN_MD_11B) &&
(pstat->phl_sta->wmode == WLAN_MD_11B))
/* 2.4G G only */
res = _TRUE;
} else if (pmlmeext->cur_wireless_mode == WLAN_MD_11A_AC) {
if ((pregpriv->deny_legacy == WLAN_MD_11AN) &&
!(pstat->phl_sta->wmode & WLAN_MD_11AC))
/* 5G AC only */
res = _TRUE;
else if ((pregpriv->deny_legacy == WLAN_MD_11A) &&
(pstat->phl_sta->wmode == WLAN_MD_11A))
/* 5G N+AC */
res = _TRUE;
} else if (pmlmeext->cur_wireless_mode == WLAN_MD_11AN) {
if ((pregpriv->deny_legacy == WLAN_MD_11A) &&
(pstat->phl_sta->wmode == WLAN_MD_11A))
/* 5G N only */
res = _TRUE;
}
return res;
}
unsigned int OnAssocReq(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_AP_MODE
u16 listen_interval;
struct rtw_ieee802_11_elems elems;
struct sta_info *pstat;
unsigned char reassoc, *pos;
int left;
unsigned short status = _STATS_SUCCESSFUL_;
unsigned short frame_type, ie_offset = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
WLAN_BSSID_EX *cur = &(pmlmeinfo->network);
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *pframe = precv_frame->u.hdr.rx_data;
uint pkt_len = precv_frame->u.hdr.len;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
u8 p2p_status_code = P2P_STATUS_SUCCESS;
u8 *p2pie;
u32 p2pielen = 0;
#endif /* CONFIG_P2P */
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
u8 sta_tbtx_enable = _FALSE;
#endif
struct registry_priv *pregpriv = &padapter->registrypriv;
#ifdef CONFIG_CONCURRENT_MODE
if (((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) &&
rtw_mi_buddy_check_fwstate(padapter, WIFI_UNDER_LINKING | WIFI_UNDER_SURVEY)) {
/* don't process assoc request; */
return _SUCCESS;
}
#endif /* CONFIG_CONCURRENT_MODE */
if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
return _FAIL;
if (rtw_check_invalid_mac_address(get_addr2_ptr(pframe), _FALSE)) {
RTW_INFO("%s : reject invalid ASSOC-req "MAC_FMT"\n",
__func__, MAC_ARG(get_addr2_ptr(pframe)));
return _FAIL;
}
frame_type = get_frame_sub_type(pframe);
if (frame_type == WIFI_ASSOCREQ) {
reassoc = 0;
ie_offset = _ASOCREQ_IE_OFFSET_;
} else { /* WIFI_REASSOCREQ */
reassoc = 1;
ie_offset = _REASOCREQ_IE_OFFSET_;
}
if (pkt_len < IEEE80211_3ADDR_LEN + ie_offset) {
RTW_INFO("handle_assoc(reassoc=%d) - too short payload (len=%lu)"
"\n", reassoc, (unsigned long)pkt_len);
return _FAIL;
}
pstat = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (pstat == (struct sta_info *)NULL) {
status = _RSON_CLS2_;
goto asoc_class2_error;
}
#ifdef RTW_PHL_TEST_FPGA
DBGP(" [%s][%d] force assoc \n", __FUNCTION__, __LINE__);
pstat->state = WIFI_ASOC_STATE;
pstat->state |= WIFI_FW_ASSOC_SUCCESS;
issue_asocrsp(padapter, status, pstat, WIFI_ASSOCRSP);
return _SUCCESS;
#endif
RTW_INFO("%s\n", __FUNCTION__);
if (pstat->authalg == WLAN_AUTH_SAE) {
/* WPA3-SAE */
if (((pstat->state) & WIFI_FW_AUTH_NULL)) {
/* TODO:
Queue AssocReq and Proccess
by external auth trigger. */
RTW_INFO("%s: wait external auth trigger\n", __func__);
return _SUCCESS;
}
}
/* check if this stat has been successfully authenticated/assocated */
if (!((pstat->state) & WIFI_FW_AUTH_SUCCESS)) {
if (!((pstat->state) & WIFI_FW_ASSOC_SUCCESS)) {
status = _RSON_CLS2_;
goto asoc_class2_error;
} else {
pstat->state &= (~WIFI_FW_ASSOC_SUCCESS);
pstat->state |= WIFI_FW_ASSOC_STATE;
}
} else {
pstat->state &= (~WIFI_FW_AUTH_SUCCESS);
pstat->state |= WIFI_FW_ASSOC_STATE;
}
#if 0/* todo:tkip_countermeasures */
if (hapd->tkip_countermeasures) {
resp = WLAN_REASON_MICHAEL_MIC_FAILURE;
goto fail;
}
#endif
/*GEORGIA_TODO_MOVE_CODE_TO_DBG_SYS*/
if (rtw_ap_linking_test_force_asoc_fail()) {
status = rtw_ap_linking_test_force_asoc_fail();
RTW_INFO(FUNC_ADPT_FMT" force asoc fail with status:%u\n"
, FUNC_ADPT_ARG(padapter), status);
goto OnAssocReqFail;
}
/* now parse all ieee802_11 ie to point to elems */
left = pkt_len - (IEEE80211_3ADDR_LEN + ie_offset);
pos = pframe + (IEEE80211_3ADDR_LEN + ie_offset);
if (rtw_ieee802_11_parse_elems(pos, left, &elems, 1) == ParseFailed) {
RTW_INFO("STA " MAC_FMT " sent invalid association request\n",
MAC_ARG(pstat->phl_sta->mac_addr));
status = _STATS_FAILURE_;
goto OnAssocReqFail;
}
rtw_ap_parse_sta_capability(padapter, pstat, pframe + WLAN_HDR_A3_LEN);
listen_interval = RTW_GET_LE16(pframe + WLAN_HDR_A3_LEN + 2);
#if 0/* todo: */
/* check listen_interval */
if (listen_interval > hapd->conf->max_listen_interval) {
hostapd_logger(hapd, mgmt->sa, HOSTAPD_MODULE_IEEE80211,
HOSTAPD_LEVEL_DEBUG,
"Too large Listen Interval (%d)",
listen_interval);
resp = WLAN_STATUS_ASSOC_DENIED_LISTEN_INT_TOO_LARGE;
goto fail;
}
pstat->listen_interval = listen_interval;
#endif
/* now we should check all the fields... */
/* checking SSID */
if (elems.ssid == NULL
|| elems.ssid_len == 0
|| elems.ssid_len != cur->Ssid.SsidLength
|| _rtw_memcmp(elems.ssid, cur->Ssid.Ssid, cur->Ssid.SsidLength) == _FALSE
) {
status = _STATS_FAILURE_;
goto OnAssocReqFail;
}
/* (Extended) Supported rates */
status = rtw_ap_parse_sta_supported_rates(padapter, pstat
, pframe + WLAN_HDR_A3_LEN + ie_offset, pkt_len - WLAN_HDR_A3_LEN - ie_offset);
if (status != _STATS_SUCCESSFUL_)
goto OnAssocReqFail;
/* check RSN/WPA/WPS */
status = rtw_ap_parse_sta_security_ie(padapter, pstat, &elems);
if (status != _STATS_SUCCESSFUL_)
goto OnAssocReqFail;
/* check if there is WMM IE & support WWM-PS */
rtw_ap_parse_sta_wmm_ie(padapter, pstat
, pframe + WLAN_HDR_A3_LEN + ie_offset, pkt_len - WLAN_HDR_A3_LEN - ie_offset);
#ifdef CONFIG_RTS_FULL_BW
/*check vendor IE*/
rtw_parse_sta_vendor_ie_8812(padapter, pstat
, pframe + WLAN_HDR_A3_LEN + ie_offset, pkt_len - WLAN_HDR_A3_LEN - ie_offset);
#endif/*CONFIG_RTS_FULL_BW*/
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (elems.tbtx_cap && elems.tbtx_cap_len != 0) {
if(rtw_is_tbtx_capabilty(elems.tbtx_cap, elems.tbtx_cap_len)) {
sta_tbtx_enable = _TRUE;
}
}
#endif
rtw_ap_parse_sta_ht_ie(padapter, pstat, &elems);
rtw_ap_parse_sta_vht_ie(padapter, pstat, &elems);
rtw_ap_parse_sta_he_ie(padapter, pstat, &elems);
if (pregpriv->deny_legacy && rtw_deny_legacy_sta(padapter, pstat)) {
RTW_INFO("Deny legacy STA " MAC_FMT " association\n",
MAC_ARG(pstat->phl_sta->mac_addr));
status = WLAN_STATUS_UNSPECIFIED_FAILURE;
goto OnAssocReqFail;
}
if (((pstat->flags & WLAN_STA_HT) || (pstat->flags & WLAN_STA_VHT) || (pstat->flags & WLAN_STA_HE)) &&
((pstat->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) ||
(pstat->wpa_pairwise_cipher & WPA_CIPHER_TKIP))) {
RTW_INFO("HT/VHT/HE: " MAC_FMT " TKIP association\n", MAC_ARG(pstat->phl_sta->mac_addr));
pstat->flags &= ~WLAN_STA_HT;
pstat->flags &= ~WLAN_STA_VHT;
pstat->flags &= ~WLAN_STA_HE;
}
#ifdef CONFIG_P2P
pstat->is_p2p_device = _FALSE;
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
p2pie = rtw_get_p2p_ie(pframe + WLAN_HDR_A3_LEN + ie_offset , pkt_len - WLAN_HDR_A3_LEN - ie_offset , NULL, &p2pielen);
if (p2pie) {
pstat->is_p2p_device = _TRUE;
p2p_status_code = (u8)process_assoc_req_p2p_ie(pwdinfo, pframe, pkt_len, pstat);
if (p2p_status_code > 0) {
pstat->p2p_status_code = p2p_status_code;
status = _STATS_CAP_FAIL_;
goto OnAssocReqFail;
}
}
#ifdef CONFIG_WFD
rtw_process_wfd_ies(padapter, pframe + WLAN_HDR_A3_LEN + ie_offset, pkt_len - WLAN_HDR_A3_LEN - ie_offset, __func__);
#endif
}
pstat->p2p_status_code = p2p_status_code;
#endif /* CONFIG_P2P */
rtw_ap_parse_sta_multi_ap_ie(padapter, pstat, pos, left);
#ifdef CONFIG_RTW_MBO
rtw_mbo_process_assoc_req(padapter,
(pframe + WLAN_HDR_A3_LEN + ie_offset),
(pkt_len - WLAN_HDR_A3_LEN - ie_offset));
#endif
/* TODO: identify_proprietary_vendor_ie(); */
/* Realtek proprietary IE */
/* identify if this is Broadcom sta */
/* identify if this is ralink sta */
/* Customer proprietary IE */
#ifdef ROKU_PRIVATE
if (pmlmepriv->vendor_ie_filter_enable) {
if (!check_vendor_ie(padapter, pframe, pkt_len, _ASOCREQ_IE_OFFSET_)) {
status = _STATS_UNABLE_HANDLE_STA_;
goto OnAssocReqFail;
}
}
#endif
#ifdef CONFIG_RTW_80211K
rtw_ap_parse_sta_rm_en_cap(padapter, pstat, &elems);
#endif
#ifdef CONFIG_RTW_MBO
if (pmlmepriv->mbopriv.enable == _TRUE) {
if(pmlmepriv->mbopriv.assoc_disallow != 0){
RTW_INFO("Reject STA " MAC_FMT ":MBO association disallowed\n",
MAC_ARG(pstat->phl_sta->mac_addr));
status = WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
goto OnAssocReqFail;
}
rtw_ap_parse_sta_mbo_element(padapter, pstat,
pframe + WLAN_HDR_A3_LEN + ie_offset,
pkt_len - WLAN_HDR_A3_LEN - ie_offset);
}
#endif /*CONFIG_RTW_MBO*/
/* AID assignment */
if (pstat->phl_sta->aid > 0)
RTW_INFO(FUNC_ADPT_FMT" old AID=%d\n", FUNC_ADPT_ARG(padapter), pstat->phl_sta->aid);
else {
if (!rtw_aid_alloc(padapter, pstat)) {
RTW_INFO(FUNC_ADPT_FMT" no room for more AIDs\n", FUNC_ADPT_ARG(padapter));
status = WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
goto OnAssocReqFail;
}
RTW_INFO(FUNC_ADPT_FMT" allocate new AID=%d\n", FUNC_ADPT_ARG(padapter), pstat->phl_sta->aid);
}
pstat->state &= (~WIFI_FW_ASSOC_STATE);
pstat->state |= WIFI_FW_ASSOC_SUCCESS;
/* RTW_INFO("==================%s, %d, (%x), bpairwise_key_installed=%d, MAC:"MAC_FMT"\n"
, __func__, __LINE__, pstat->state, pstat->bpairwise_key_installed, MAC_ARG(pstat->phl_sta->mac_addr)); */
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
_rtw_spinlock_bh(&pstapriv->auth_list_lock);
if (!rtw_is_list_empty(&pstat->auth_list)) {
rtw_list_delete(&pstat->auth_list);
pstapriv->auth_list_cnt--;
}
_rtw_spinunlock_bh(&pstapriv->auth_list_lock);
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&pstat->asoc_list)) {
pstat->expire_to = pstapriv->expire_to;
rtw_list_insert_tail(&pstat->asoc_list, &pstapriv->asoc_list);
pstapriv->asoc_list_cnt++;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (sta_tbtx_enable) {
pstat->tbtx_enable = _TRUE;
pstapriv->tbtx_asoc_list_cnt++;
}
#endif
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
}
/* now the station is qualified to join our BSS... */
if (pstat && (pstat->state & WIFI_FW_ASSOC_SUCCESS) && (_STATS_SUCCESSFUL_ == status)) {
#ifdef CONFIG_NATIVEAP_MLME
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
/* .1 bss_cap_update & sta_info_update */
bss_cap_update_on_sta_join(padapter, pstat);
sta_info_update(padapter, pstat);
}
#ifdef CONFIG_IEEE80211W
if (pstat->bpairwise_key_installed == _TRUE && (pstat->flags & WLAN_STA_MFP))
status = _STATS_REFUSED_TEMPORARILY_;
#endif /* CONFIG_IEEE80211W */
#ifdef CONFIG_RTW_MBO
if (rtw_mbo_ap_assoc_disallow(padapter))
status = _STATS_UNABLE_HANDLE_STA_;
#endif
#ifdef CONFIG_RTW_80211R_AP
if ((pstat && (pstat->authalg != WLAN_AUTH_FT)))
#endif
{
/* .2 issue assoc rsp before notify station join event. */
if (frame_type == WIFI_ASSOCREQ)
issue_asocrsp(padapter, status, pstat, WIFI_ASSOCRSP);
else
issue_asocrsp(padapter, status, pstat, WIFI_REASSOCRSP);
}
#ifdef CONFIG_IOCTL_CFG80211
_rtw_spinlock_bh(&pstat->lock);
if (pstat->passoc_req) {
rtw_mfree(pstat->passoc_req, pstat->assoc_req_len);
pstat->passoc_req = NULL;
pstat->assoc_req_len = 0;
}
pstat->passoc_req = rtw_zmalloc(pkt_len);
if (pstat->passoc_req) {
_rtw_memcpy(pstat->passoc_req, pframe, pkt_len);
pstat->assoc_req_len = pkt_len;
}
_rtw_spinunlock_bh(&pstat->lock);
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_IEEE80211W
if ((pstat->bpairwise_key_installed != _TRUE && (pstat->flags & WLAN_STA_MFP))
|| !(pstat->flags & WLAN_STA_MFP))
#endif /* CONFIG_IEEE80211W */
{
/* .3-(1) report sta add event */
report_add_sta_event(padapter, pstat->phl_sta->mac_addr);
}
#ifdef CONFIG_IEEE80211W
if (pstat->bpairwise_key_installed == _TRUE && (pstat->flags & WLAN_STA_MFP)) {
RTW_INFO(MAC_FMT"\n", MAC_ARG(pstat->phl_sta->mac_addr));
issue_action_SA_Query(padapter, pstat->phl_sta->mac_addr, 0, 0, IEEE80211W_RIGHT_KEY);
}
#endif /* CONFIG_IEEE80211W */
#endif /* CONFIG_NATIVEAP_MLME */
}
return _SUCCESS;
asoc_class2_error:
#ifdef CONFIG_NATIVEAP_MLME
issue_deauth(padapter, (void *)get_addr2_ptr(pframe), status);
#endif
return _FAIL;
OnAssocReqFail:
#ifdef CONFIG_NATIVEAP_MLME
/* pstat->phl_sta->aid = 0; */
if (frame_type == WIFI_ASSOCREQ)
issue_asocrsp(padapter, status, pstat, WIFI_ASSOCRSP);
else
issue_asocrsp(padapter, status, pstat, WIFI_REASSOCRSP);
#endif
if (pstat)
rtw_free_stainfo_sw(padapter , pstat);
#endif /* CONFIG_AP_MODE */
return _FAIL;
}
#if defined(CONFIG_LAYER2_ROAMING) && defined(CONFIG_RTW_80211K)
void rtw_roam_nb_discover(_adapter *padapter, u8 bfroce)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta;
u8 nb_req_issue = _FALSE;
if (!check_fwstate(pmlmepriv, WIFI_ASOC_STATE))
return;
if (!rtw_chk_roam_flags(padapter, RTW_ROAM_ACTIVE))
return;
psta = rtw_get_stainfo(pstapriv, pmlmeinfo->network.MacAddress);
if (!psta)
return;
if (bfroce || (!pmlmepriv->nb_info.nb_rpt_is_same))
nb_req_issue = _TRUE;
if (nb_req_issue && (psta->rm_en_cap[0] & RTW_RRM_NB_RPT_EN))
rm_add_nb_req(padapter, psta);
}
#endif
static void rtw_ie_handler(struct _ADAPTER *padapter, u8 *ie, u32 ie_len)
{
int i;
struct _NDIS_802_11_VARIABLE_IEs *p = NULL;
#ifdef CONFIG_WAPI_SUPPORT
PNDIS_802_11_VARIABLE_IEs pWapiIE = NULL;
#endif
if (!ie || (ie_len == 0))
return;
for (i = 0; i < ie_len;) {
p = (struct _NDIS_802_11_VARIABLE_IEs *)(ie + i);
switch (p->ElementID) {
case _VENDOR_SPECIFIC_IE_:
if (_rtw_memcmp(p->data, WMM_PARA_OUI, 6)) /* WMM */
WMM_param_handler(padapter, p);
#if defined(CONFIG_P2P) && defined(CONFIG_WFD)
else if (_rtw_memcmp(p->data, WFD_OUI, 4)) /* WFD */
rtw_process_wfd_ie(padapter, (u8 *)p, p->Length, __func__);
#endif
break;
#ifdef CONFIG_WAPI_SUPPORT
case _WAPI_IE_:
pWapiIE = p;
break;
#endif
case _HT_CAPABILITY_IE_: /* HT caps */
HT_caps_handler(padapter, p);
#ifdef ROKU_PRIVATE
HT_caps_handler_infra_ap(padapter, p);
#endif /* ROKU_PRIVATE */
break;
case _HT_EXTRA_INFO_IE_: /* HT info */
HT_info_handler(padapter, p);
break;
#ifdef CONFIG_80211AC_VHT
case EID_VHTCapability:
VHT_caps_handler(padapter, p);
#ifdef ROKU_PRIVATE
VHT_caps_handler_infra_ap(padapter, p);
#endif /* ROKU_PRIVATE */
break;
case EID_VHTOperation:
VHT_operation_handler(padapter, p);
break;
#endif
#ifdef CONFIG_80211AX_HE
case WLAN_EID_EXTENSION:
if (p->data[0] == WLAN_EID_EXTENSION_HE_CAPABILITY)
HE_caps_handler(padapter, p);
else if (p->data[0] == WLAN_EID_EXTENSION_HE_OPERATION)
HE_operation_handler(padapter, p);
else if (p->data[0] == WLAN_EID_EXTENSION_HE_MU_EDCA)
HE_mu_edca_handler(padapter, p, _TRUE);
break;
#endif
case _ERPINFO_IE_:
ERP_IE_handler(padapter, p);
break;
#ifdef CONFIG_TDLS
case WLAN_EID_EXT_CAP:
if (check_ap_tdls_prohibited(p->data, p->Length) == _TRUE)
padapter->tdlsinfo.ap_prohibited = _TRUE;
if (check_ap_tdls_ch_switching_prohibited(p->data, p->Length) == _TRUE)
padapter->tdlsinfo.ch_switch_prohibited = _TRUE;
break;
#endif /* CONFIG_TDLS */
case _EID_RRM_EN_CAP_IE_:
RM_IE_handler(padapter, p);
break;
#ifdef ROKU_PRIVATE
/* Infra mode, used to store AP's info , Parse the supported rates from AssocRsp */
case _SUPPORTEDRATES_IE_:
Supported_rate_infra_ap(padapter, p);
break;
case _EXT_SUPPORTEDRATES_IE_:
Extended_Supported_rate_infra_ap(padapter, p);
break;
#endif /* ROKU_PRIVATE */
default:
break;
}
i += (p->Length + 2);
}
}
unsigned int OnAssocRsp(_adapter *padapter, union recv_frame *precv_frame)
{
uint i;
int res;
unsigned short status;
PNDIS_802_11_VARIABLE_IEs pIE = NULL;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
/* WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network); */
u8 *pframe = precv_frame->u.hdr.rx_data;
uint pkt_len = precv_frame->u.hdr.len;
RTW_INFO("%s\n", __FUNCTION__);
/* check A1 matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter), get_da(pframe), ETH_ALEN))
return _SUCCESS;
if (!(pmlmeinfo->state & (WIFI_FW_AUTH_SUCCESS | WIFI_FW_ASSOC_STATE)) || pmlmeext->join_abort)
return _SUCCESS;
if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)
return _SUCCESS;
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
/* status */
status = le16_to_cpu(*(unsigned short *)(pframe + WLAN_HDR_A3_LEN + 2));
if (status > 0) {
RTW_INFO("assoc reject, status code: %d\n", status);
pmlmeinfo->state = WIFI_FW_NULL_STATE;
res = -4;
goto report_assoc_result;
}
/* get capabilities */
pmlmeinfo->capability = le16_to_cpu(*(unsigned short *)(pframe + WLAN_HDR_A3_LEN));
/* set slot time */
pmlmeinfo->slotTime = (pmlmeinfo->capability & BIT(10)) ? 9 : 20;
/* AID assignment move to rtw_joinbss_update_stainfo */
res = (int)(le16_to_cpu(*(unsigned short *)(pframe + WLAN_HDR_A3_LEN + 4)) & 0x3fff);
#ifdef RTW_PHL_TEST_FPGA
res = 1;
#endif
/* check aid value */
if (res < 1 || res > 2007) {
RTW_INFO("assoc reject, aid: %d\n", res);
pmlmeinfo->state = WIFI_FW_NULL_STATE;
res = -4;
goto report_assoc_result;
}
/* following are moved to join event callback function */
/* to handle HT, WMM, rate adaptive, update MAC reg */
/* for not to handle the synchronous IO in the tasklet */
rtw_ie_handler(padapter, pframe + 6 + WLAN_HDR_A3_LEN,
pkt_len - 6 - WLAN_HDR_A3_LEN);
#ifdef CONFIG_WAPI_SUPPORT
rtw_wapi_on_assoc_ok(padapter, pIE);
#endif
pmlmeinfo->state &= (~WIFI_FW_ASSOC_STATE);
pmlmeinfo->state |= WIFI_FW_ASSOC_SUCCESS;
/* Update Basic Rate Table for spec, 2010-12-28 , by thomas */
UpdateBrateTbl(padapter, pmlmeinfo->network.SupportedRates);
report_assoc_result:
if (res > 0)
rtw_buf_update(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len, pframe, pkt_len);
else
rtw_buf_free(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len);
report_join_res(padapter, res, status);
#if defined(CONFIG_LAYER2_ROAMING) && defined(CONFIG_RTW_80211K)
rtw_roam_nb_discover(padapter, _TRUE);
#endif
return _SUCCESS;
}
unsigned int OnDeAuth(_adapter *padapter, union recv_frame *precv_frame)
{
unsigned short reason;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 *pframe = precv_frame->u.hdr.rx_data;
bool active = _FALSE;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
/* check A3 */
if (!(_rtw_memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)))
return _SUCCESS;
RTW_INFO(FUNC_ADPT_FMT" - Start to Disconnect\n", FUNC_ADPT_ARG(padapter));
reason = le16_to_cpu(*(unsigned short *)(pframe + WLAN_HDR_A3_LEN));
#ifdef CONFIG_AP_MODE
if (MLME_IS_AP(padapter)) {
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
/* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
/* rtw_free_stainfo(padapter, psta); */
/* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
RTW_PRINT(FUNC_ADPT_FMT" reason=%u, ta=%pM\n"
, FUNC_ADPT_ARG(padapter), reason, get_addr2_ptr(pframe));
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta) {
u8 updated = _FALSE;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
rtw_list_delete(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (psta->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt--;
#endif
#ifdef CONFIG_IEEE80211W
/* pmf: 4.3.3.2 */
if (psta->flags & WLAN_STA_MFP) {
psta->flags &= ~WLAN_STA_MFP;
reason = _RSON_CLS2_;
active = _TRUE;
}
#endif
updated = ap_free_sta(padapter, psta, active, reason, _TRUE, _FALSE);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
associated_clients_update(padapter, updated, STA_INFO_UPDATE_ALL);
}
return _SUCCESS;
} else
#endif
if (!MLME_IS_MESH(padapter)) {
int ignore_received_deauth = 0;
/* Commented by Albert 20130604 */
/* Before sending the auth frame to start the STA/GC mode connection with AP/GO, */
/* we will send the deauth first. */
/* However, the Win8.1 with BRCM Wi-Fi will send the deauth with reason code 6 to us after receieving our deauth. */
/* Added the following code to avoid this case. */
if ((pmlmeinfo->state & WIFI_FW_AUTH_STATE) ||
(pmlmeinfo->state & WIFI_FW_ASSOC_STATE)) {
if (reason == WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA)
ignore_received_deauth = 1;
else if (WLAN_REASON_PREV_AUTH_NOT_VALID == reason) {
/* TODO: 802.11r */
ignore_received_deauth = 1;
}
}
#ifdef CONFIG_RTW_WNM
if (!rtw_wnm_try_btm_roam_imnt(padapter))
ignore_received_deauth = 1;
#endif
RTW_PRINT(FUNC_ADPT_FMT" reason=%u, ta=%pM, ignore=%d\n"
, FUNC_ADPT_ARG(padapter), reason, get_addr2_ptr(pframe), ignore_received_deauth);
if (0 == ignore_received_deauth)
receive_disconnect(padapter, get_addr2_ptr(pframe), reason, _FALSE);
}
pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
return _SUCCESS;
}
unsigned int OnDisassoc(_adapter *padapter, union recv_frame *precv_frame)
{
unsigned short reason;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 *pframe = precv_frame->u.hdr.rx_data;
bool active = _FALSE;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
/* check A3 */
if (!(_rtw_memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)))
return _SUCCESS;
RTW_INFO(FUNC_ADPT_FMT" - Start to Disconnect\n", FUNC_ADPT_ARG(padapter));
reason = le16_to_cpu(*(unsigned short *)(pframe + WLAN_HDR_A3_LEN));
#ifdef CONFIG_AP_MODE
if (MLME_IS_AP(padapter)) {
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
/* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
/* rtw_free_stainfo(padapter, psta); */
/* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
RTW_PRINT(FUNC_ADPT_FMT" reason=%u, ta=%pM\n"
, FUNC_ADPT_ARG(padapter), reason, get_addr2_ptr(pframe));
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta) {
u8 updated = _FALSE;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
rtw_list_delete(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (psta->tbtx_enable)
pstapriv->tbtx_asoc_list_cnt--;
#endif
#ifdef CONFIG_IEEE80211W
/* pmf: 4.3.3.1 */
if (psta->flags & WLAN_STA_MFP) {
psta->flags &= ~WLAN_STA_MFP;
reason = _RSON_CLS2_;
active = _TRUE;
}
#endif
updated = ap_free_sta(padapter, psta, active, reason, _TRUE, _FALSE);
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
associated_clients_update(padapter, updated, STA_INFO_UPDATE_ALL);
}
return _SUCCESS;
} else
#endif
if (!MLME_IS_MESH(padapter)) {
RTW_PRINT(FUNC_ADPT_FMT" reason=%u, ta=%pM\n"
, FUNC_ADPT_ARG(padapter), reason, get_addr2_ptr(pframe));
#ifdef CONFIG_RTW_WNM
if (rtw_wnm_try_btm_roam_imnt(padapter) > 0)
#endif
receive_disconnect(padapter, get_addr2_ptr(pframe), reason, _FALSE);
}
pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
return _SUCCESS;
}
unsigned int OnAtim(_adapter *padapter, union recv_frame *precv_frame)
{
RTW_INFO("%s\n", __FUNCTION__);
return _SUCCESS;
}
unsigned int on_action_spct_ch_switch(_adapter *padapter, struct sta_info *psta, u8 *ies, uint ies_len)
{
unsigned int ret = _FAIL;
struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(mlmeext->mlmext_info);
if (!(pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) {
ret = _SUCCESS;
goto exit;
}
if ((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE) {
int ch_switch_mode = -1, ch = -1, ch_switch_cnt = -1;
int ch_offset = -1;
u8 bwmode;
struct ieee80211_info_element *ie;
RTW_INFO(FUNC_NDEV_FMT" from "MAC_FMT"\n",
FUNC_NDEV_ARG(padapter->pnetdev), MAC_ARG(psta->phl_sta->mac_addr));
for_each_ie(ie, ies, ies_len) {
if (ie->id == WLAN_EID_CHANNEL_SWITCH) {
ch_switch_mode = ie->data[0];
ch = ie->data[1];
ch_switch_cnt = ie->data[2];
RTW_INFO("ch_switch_mode:%d, ch:%d, ch_switch_cnt:%d\n",
ch_switch_mode, ch, ch_switch_cnt);
} else if (ie->id == WLAN_EID_SECONDARY_CHANNEL_OFFSET) {
ch_offset = secondary_ch_offset_to_hal_ch_offset(ie->data[0]);
RTW_INFO("ch_offset:%d\n", ch_offset);
}
}
if (ch == -1)
return _SUCCESS;
if (ch_offset == -1)
bwmode = mlmeext->chandef.bw;
else
bwmode = (ch_offset == CHAN_OFFSET_NO_EXT) ?
CHANNEL_WIDTH_20 : CHANNEL_WIDTH_40;
ch_offset = (ch_offset == -1) ? mlmeext->chandef.offset : ch_offset;
/* todo:
* 1. the decision of channel switching
* 2. things after channel switching
*/
ret = rtw_set_chbw_cmd(padapter, ch, bwmode, ch_offset, 0);
}
exit:
return ret;
}
unsigned int on_action_spct(_adapter *padapter, union recv_frame *precv_frame)
{
unsigned int ret = _FAIL;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *pframe = precv_frame->u.hdr.rx_data;
uint frame_len = precv_frame->u.hdr.len;
u8 *frame_body = (u8 *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
u8 category;
u8 action;
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (!psta)
goto exit;
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_SPECTRUM_MGMT)
goto exit;
action = frame_body[1];
RTW_INFO(FUNC_ADPT_FMT" action:%u\n", FUNC_ADPT_ARG(padapter), action);
switch (action) {
case RTW_WLAN_ACTION_SPCT_MSR_REQ:
case RTW_WLAN_ACTION_SPCT_MSR_RPRT:
case RTW_WLAN_ACTION_SPCT_TPC_REQ:
case RTW_WLAN_ACTION_SPCT_TPC_RPRT:
break;
case RTW_WLAN_ACTION_SPCT_CHL_SWITCH:
#ifdef CONFIG_SPCT_CH_SWITCH
ret = on_action_spct_ch_switch(padapter, psta
, frame_body + 2, frame_len - (frame_body - pframe) - 2);
#elif CONFIG_DFS
if (MLME_IS_STA(padapter) && MLME_IS_ASOC(padapter)) {
process_csa_ie(padapter
, frame_body + 2, frame_len - (frame_body - pframe) - 2);
}
#endif
break;
default:
break;
}
exit:
return ret;
}
unsigned int OnAction_qos(_adapter *padapter, union recv_frame *precv_frame)
{
return _SUCCESS;
}
unsigned int OnAction_dls(_adapter *padapter, union recv_frame *precv_frame)
{
return _SUCCESS;
}
#ifdef CONFIG_RTW_WNM
unsigned int on_action_wnm(_adapter *adapter, union recv_frame *rframe)
{
unsigned int ret = _FAIL;
struct sta_info *sta = NULL;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct sta_priv *stapriv = &(adapter->stapriv);
u8 *frame = rframe->u.hdr.rx_data;
u32 frame_len = rframe->u.hdr.len;
u8 *frame_body = (u8 *)(frame + sizeof(struct rtw_ieee80211_hdr_3addr));
u32 frame_body_len = frame_len - sizeof(struct rtw_ieee80211_hdr_3addr);
u8 category, action;
int cnt = 0;
char msg[16];
sta = rtw_get_stainfo(stapriv, get_addr2_ptr(frame));
if (!sta)
goto exit;
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_WNM)
goto exit;
action = frame_body[1];
switch (action) {
#ifdef CONFIG_RTW_80211R
case RTW_WLAN_ACTION_WNM_BTM_REQ:
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE) {
RTW_INFO("WNM: BSS Transition Management Request recv.\n");
rtw_wnm_process_btm_req(adapter, frame_body, frame_body_len);
}
ret = _SUCCESS;
break;
#endif
case RTW_WLAN_ACTION_WNM_BTM_RSP:
if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) &&
(pmlmepriv->nb_info.features & RTW_WNM_FEATURE_BTM_REQ_EN)) {
struct btm_rsp_hdr rsp;
u32 sz;
RTW_INFO("WNM: BSS Transition Management Response recv.\n");
sz = rtw_wnm_btm_rsp_candidates_sz_get(adapter,
frame_body, frame_body_len);
_rtw_memset(&rsp, 0, sizeof(rsp));
if (sz > 0)
rsp.pcandidates = rtw_zmalloc(sz);
rtw_wnm_process_btm_rsp(adapter, frame_body, frame_body_len, &rsp);
/* TODO : handle candidates info in rsp.pcandidates for upper-layer services */
if (0 && rsp.pcandidates && (rsp.candidates_num > 0))
RTW_INFO_DUMP("pcandidates : ", rsp.pcandidates, sz);
if ((sz > 0) && (rsp.pcandidates != NULL))
rtw_mfree(rsp.pcandidates, sz);
}
/* fall through */
default:
#ifdef CONFIG_RTW_MBO
if (rtw_mbo_wifi_logo_test(adapter) \
&& (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) \
&& (action == RTW_WLAN_ACTION_WNM_BTM_QUERY)) {
struct mbo_attr_info *pmbo_attr = \
&(pmlmepriv->mbo_attr);
RTW_INFO("%s: BSS Transition Management query"
" recv from "MAC_FMT"\n", __func__,
MAC_ARG(sta->phl_sta->mac_addr));
pmbo_attr->user_raw.hdr.dialog_token = \
wnm_btm_dialog_token(frame_body);
pmbo_attr->user_raw.hdr.req_mode |= \
PREFERRED_CANDIDATE_LIST_INCLUDED;
pmbo_attr->user_raw.hdr.validity_interval = 30;
rtw_wnm_process_btm_query(
adapter, frame_body, frame_body_len);
rtw_wnm_issue_btm_req(adapter, sta->phl_sta->mac_addr,
&pmbo_attr->user_raw.hdr, NULL, 0,
(u8 *)&pmbo_attr->user_raw.btm_cants,
pmbo_attr->user_raw.candidate_cnt);
break;
}
if (rtw_mbo_wifi_logo_test(adapter) \
&& (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) \
&& (action == RTW_WLAN_ACTION_WNM_NOTIF_REQ)) {
struct mbo_attr_info *pmbo_attr = \
&(pmlmepriv->mbo_attr);
RTW_INFO("%s: Notification Request"
" recv from "MAC_FMT"\n", __func__,
MAC_ARG(sta->phl_sta->mac_addr));
rtw_wnm_process_notification_req(adapter,
frame_body, frame_body_len);
break;
}
#endif /* CONFIG_RTW_MBO */
#ifdef CONFIG_IOCTL_CFG80211
cnt += sprintf((msg + cnt), "ACT_WNM %u", action);
rtw_cfg80211_rx_action(adapter, rframe, msg);
#endif
ret = _SUCCESS;
break;
}
exit:
return ret;
}
#endif /* CONFIG_RTW_WNM */
/**
* rtw_rx_ampdu_size - Get the target RX AMPDU buffer size for the specific @adapter
* @adapter: the adapter to get target RX AMPDU buffer size
*
* Returns: the target RX AMPDU buffer size
*/
u8 rtw_rx_ampdu_size(_adapter *adapter)
{
u8 size;
HT_CAP_AMPDU_FACTOR max_rx_ampdu_factor = 0;
/* for scan */
if (!mlmeext_chk_scan_state(&adapter->mlmeextpriv, SCAN_DISABLE)
&& !mlmeext_chk_scan_state(&adapter->mlmeextpriv, SCAN_COMPLETE)
&& adapter->mlmeextpriv.sitesurvey_res.rx_ampdu_size != RX_AMPDU_SIZE_INVALID
) {
size = adapter->mlmeextpriv.sitesurvey_res.rx_ampdu_size;
goto exit;
}
/* default value based on max_rx_ampdu_factor */
if (adapter->driver_rx_ampdu_factor != 0xFF)
max_rx_ampdu_factor = (HT_CAP_AMPDU_FACTOR)adapter->driver_rx_ampdu_factor;
else
rtw_hal_get_def_var(adapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor);
/* In Maximum A-MPDU Length Exponent subfield of A-MPDU Parameters field of HT Capabilities element,
the unit of max_rx_ampdu_factor are octets. 8K, 16K, 32K, 64K is right.
But the buffer size subfield of Block Ack Parameter Set field in ADDBA action frame indicates
the number of buffers available for this particular TID. Each buffer is equal to max. size of
MSDU or AMSDU.
The size variable means how many MSDUs or AMSDUs, it's not Kbytes.
*/
if (MAX_AMPDU_FACTOR_64K == max_rx_ampdu_factor)
size = 64;
else if (MAX_AMPDU_FACTOR_32K == max_rx_ampdu_factor)
size = 32;
else if (MAX_AMPDU_FACTOR_16K == max_rx_ampdu_factor)
size = 16;
else if (MAX_AMPDU_FACTOR_8K == max_rx_ampdu_factor)
size = 8;
else
size = 64;
exit:
if (size > 127)
size = 127;
return size;
}
/**
* rtw_rx_ampdu_is_accept - Get the permission if RX AMPDU should be set up for the specific @adapter
* @adapter: the adapter to get the permission if RX AMPDU should be set up
*
* Returns: accept or not
*/
bool rtw_rx_ampdu_is_accept(_adapter *adapter)
{
bool accept;
if (adapter->fix_rx_ampdu_accept != RX_AMPDU_ACCEPT_INVALID) {
accept = adapter->fix_rx_ampdu_accept;
goto exit;
}
/* for scan */
if (!mlmeext_chk_scan_state(&adapter->mlmeextpriv, SCAN_DISABLE)
&& !mlmeext_chk_scan_state(&adapter->mlmeextpriv, SCAN_COMPLETE)
&& adapter->mlmeextpriv.sitesurvey_res.rx_ampdu_accept != RX_AMPDU_ACCEPT_INVALID
) {
accept = adapter->mlmeextpriv.sitesurvey_res.rx_ampdu_accept;
goto exit;
}
/* default value for other cases */
accept = adapter->mlmeextpriv.mlmext_info.bAcceptAddbaReq;
exit:
return accept;
}
/**
* rtw_rx_ampdu_set_size - Set the target RX AMPDU buffer size for the specific @adapter and specific @reason
* @adapter: the adapter to set target RX AMPDU buffer size
* @size: the target RX AMPDU buffer size to set
* @reason: reason for the target RX AMPDU buffer size setting
*
* Returns: whether the target RX AMPDU buffer size is changed
*/
bool rtw_rx_ampdu_set_size(_adapter *adapter, u8 size, u8 reason)
{
bool is_adj = _FALSE;
struct mlme_ext_priv *mlmeext;
struct mlme_ext_info *mlmeinfo;
mlmeext = &adapter->mlmeextpriv;
mlmeinfo = &mlmeext->mlmext_info;
if (reason == RX_AMPDU_DRV_FIXED) {
if (adapter->fix_rx_ampdu_size != size) {
adapter->fix_rx_ampdu_size = size;
is_adj = _TRUE;
RTW_INFO(FUNC_ADPT_FMT" fix_rx_ampdu_size:%u\n", FUNC_ADPT_ARG(adapter), size);
}
} else if (reason == RX_AMPDU_DRV_SCAN) {
struct ss_res *ss = &adapter->mlmeextpriv.sitesurvey_res;
if (ss->rx_ampdu_size != size) {
ss->rx_ampdu_size = size;
is_adj = _TRUE;
RTW_INFO(FUNC_ADPT_FMT" ss.rx_ampdu_size:%u\n", FUNC_ADPT_ARG(adapter), size);
}
}
return is_adj;
}
/**
* rtw_rx_ampdu_set_accept - Set the permission if RX AMPDU should be set up for the specific @adapter and specific @reason
* @adapter: the adapter to set if RX AMPDU should be set up
* @accept: if RX AMPDU should be set up
* @reason: reason for the permission if RX AMPDU should be set up
*
* Returns: whether the permission if RX AMPDU should be set up is changed
*/
bool rtw_rx_ampdu_set_accept(_adapter *adapter, u8 accept, u8 reason)
{
bool is_adj = _FALSE;
struct mlme_ext_priv *mlmeext;
struct mlme_ext_info *mlmeinfo;
mlmeext = &adapter->mlmeextpriv;
mlmeinfo = &mlmeext->mlmext_info;
if (reason == RX_AMPDU_DRV_FIXED) {
if (adapter->fix_rx_ampdu_accept != accept) {
adapter->fix_rx_ampdu_accept = accept;
is_adj = _TRUE;
RTW_INFO(FUNC_ADPT_FMT" fix_rx_ampdu_accept:%u\n", FUNC_ADPT_ARG(adapter), accept);
}
} else if (reason == RX_AMPDU_DRV_SCAN) {
if (adapter->mlmeextpriv.sitesurvey_res.rx_ampdu_accept != accept) {
adapter->mlmeextpriv.sitesurvey_res.rx_ampdu_accept = accept;
is_adj = _TRUE;
RTW_INFO(FUNC_ADPT_FMT" ss.rx_ampdu_accept:%u\n", FUNC_ADPT_ARG(adapter), accept);
}
}
return is_adj;
}
/**
* rx_ampdu_apply_sta_tid - Apply RX AMPDU setting to the specific @sta and @tid
* @adapter: the adapter to which @sta belongs
* @sta: the sta to be checked
* @tid: the tid to be checked
* @accept: the target permission if RX AMPDU should be set up
* @size: the target RX AMPDU buffer size
*
* Returns:
* 0: no canceled
* 1: canceled by no permission
* 2: canceled by different buffer size
* 3: canceled by potential mismatched status
*
* Blocking function, may sleep
*/
u8 rx_ampdu_apply_sta_tid(_adapter *adapter, struct sta_info *sta, u8 tid, u8 accept, u8 size)
{
u8 ret = 0;
struct recv_reorder_ctrl *reorder_ctl = &sta->recvreorder_ctrl[tid];
if (reorder_ctl->enable == _FALSE) {
if (reorder_ctl->ampdu_size != RX_AMPDU_SIZE_INVALID) {
send_delba_sta_tid_wait_ack(adapter, 0, sta, tid, 1);
ret = 3;
}
goto exit;
}
if (accept == _FALSE) {
send_delba_sta_tid_wait_ack(adapter, 0, sta, tid, 0);
ret = 1;
} else if (reorder_ctl->ampdu_size != size) {
send_delba_sta_tid_wait_ack(adapter, 0, sta, tid, 0);
ret = 2;
}
exit:
return ret;
}
u8 rx_ampdu_size_sta_limit(_adapter *adapter, struct sta_info *sta)
{
u8 sz_limit = 0xFF;
#ifdef CONFIG_80211N_HT
struct registry_priv *regsty = adapter_to_regsty(adapter);
struct mlme_priv *mlme = &adapter->mlmepriv;
struct mlme_ext_info *mlmeinfo = &adapter->mlmeextpriv.mlmext_info;
s8 nss = -1;
u8 bw = rtw_min(sta->phl_sta->chandef.bw, adapter->mlmeextpriv.chandef.bw);
#ifdef CONFIG_80211AC_VHT
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif
if (is_supported_vht(sta->phl_sta->wmode)) {
nss = rtw_min(rtw_vht_mcsmap_to_nss(mlme->vhtpriv.vht_mcs_map)
, rtw_vht_mcsmap_to_nss(sta->vhtpriv.vht_mcs_map));
} else
#endif
if (is_supported_ht(sta->phl_sta->wmode)) {
nss = rtw_min(rtw_ht_mcsset_to_nss(mlmeinfo->HT_caps.u.HT_cap_element.MCS_rate)
, rtw_ht_mcsset_to_nss(sta->htpriv.ht_cap.supp_mcs_set));
}
if (nss >= 1)
sz_limit = regsty->rx_ampdu_sz_limit_by_nss_bw[nss - 1][bw];
#endif /* CONFIG_80211N_HT */
return sz_limit;
}
/**
* rx_ampdu_apply_sta - Apply RX AMPDU setting to the specific @sta
* @adapter: the adapter to which @sta belongs
* @sta: the sta to be checked
* @accept: the target permission if RX AMPDU should be set up
* @size: the target RX AMPDU buffer size
*
* Returns: number of the RX AMPDU assciation canceled for applying current target setting
*
* Blocking function, may sleep
*/
u8 rx_ampdu_apply_sta(_adapter *adapter, struct sta_info *sta, u8 accept, u8 size)
{
u8 change_cnt = 0;
int i;
for (i = 0; i < TID_NUM; i++) {
if (rx_ampdu_apply_sta_tid(adapter, sta, i, accept, size) != 0)
change_cnt++;
}
return change_cnt;
}
/**
* rtw_rx_ampdu_apply - Apply the current target RX AMPDU setting for the specific @adapter
* @adapter: the adapter to be applied
*
* Returns: number of the RX AMPDU assciation canceled for applying current target setting
*/
u16 rtw_rx_ampdu_apply(_adapter *adapter)
{
u16 adj_cnt = 0;
struct sta_info *sta;
u8 accept = rtw_rx_ampdu_is_accept(adapter);
u8 size;
if (adapter->fix_rx_ampdu_size != RX_AMPDU_SIZE_INVALID)
size = adapter->fix_rx_ampdu_size;
else
size = rtw_rx_ampdu_size(adapter);
if (MLME_IS_STA(adapter)) {
sta = rtw_get_stainfo(&adapter->stapriv, get_bssid(&adapter->mlmepriv));
if (sta) {
u8 sta_size = size;
if (adapter->fix_rx_ampdu_size == RX_AMPDU_SIZE_INVALID)
sta_size = rtw_min(size, rx_ampdu_size_sta_limit(adapter, sta));
adj_cnt += rx_ampdu_apply_sta(adapter, sta, accept, sta_size);
}
/* TODO: TDLS peer */
} else if (MLME_IS_AP(adapter) || MLME_IS_MESH(adapter)) {
_list *phead, *plist;
u8 peer_num = 0;
char peers[NUM_STA];
struct sta_priv *pstapriv = &adapter->stapriv;
int i;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
int stainfo_offset;
sta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
stainfo_offset = rtw_stainfo_offset(pstapriv, sta);
if (stainfo_offset_valid(stainfo_offset))
peers[peer_num++] = stainfo_offset;
}
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
for (i = 0; i < peer_num; i++) {
sta = rtw_get_stainfo_by_offset(pstapriv, peers[i]);
if (sta) {
u8 sta_size = size;
if (adapter->fix_rx_ampdu_size == RX_AMPDU_SIZE_INVALID)
sta_size = rtw_min(size, rx_ampdu_size_sta_limit(adapter, sta));
adj_cnt += rx_ampdu_apply_sta(adapter, sta, accept, sta_size);
}
}
}
/* TODO: ADHOC */
return adj_cnt;
}
unsigned int OnAction_back(_adapter *padapter, union recv_frame *precv_frame)
{
u8 *addr;
struct sta_info *psta = NULL;
struct recv_reorder_ctrl *preorder_ctrl;
unsigned char *frame_body;
unsigned char category, action;
unsigned short tid, status, reason_code = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 *pframe = precv_frame->u.hdr.rx_data;
struct sta_priv *pstapriv = &padapter->stapriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
#ifdef CONFIG_80211N_HT
RTW_INFO("%s\n", __FUNCTION__);
/* check RA matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter), GetAddr1Ptr(pframe), ETH_ALEN))
return _SUCCESS;
#if 0
/* check A1 matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter), get_da(pframe), ETH_ALEN))
return _SUCCESS;
#endif
if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
if (!(pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS))
return _SUCCESS;
addr = get_addr2_ptr(pframe);
psta = rtw_get_stainfo(pstapriv, addr);
if (psta == NULL)
return _SUCCESS;
frame_body = (unsigned char *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
category = frame_body[0];
if (category == RTW_WLAN_CATEGORY_BACK) { /* representing Block Ack */
#ifdef CONFIG_TDLS
if ((psta->tdls_sta_state & TDLS_LINKED_STATE) &&
(psta->htpriv.ht_option == _TRUE) &&
(psta->htpriv.ampdu_enable == _TRUE))
RTW_INFO("Recv [%s] from direc link\n", __FUNCTION__);
else
#endif /* CONFIG_TDLS */
if (!pmlmeinfo->HT_enable)
return _SUCCESS;
action = frame_body[1];
RTW_INFO("%s, action=%d\n", __FUNCTION__, action);
switch (action) {
case RTW_WLAN_ACTION_ADDBA_REQ: /* ADDBA request */
_rtw_memcpy(&(pmlmeinfo->ADDBA_req), &(frame_body[2]), sizeof(struct ADDBA_request));
/* process_addba_req(padapter, (u8*)&(pmlmeinfo->ADDBA_req), GetAddr3Ptr(pframe)); */
process_addba_req(padapter, (u8 *)&(pmlmeinfo->ADDBA_req), addr);
break;
case RTW_WLAN_ACTION_ADDBA_RESP: /* ADDBA response */
/* status = frame_body[3] | (frame_body[4] << 8); */ /* endian issue */
status = RTW_GET_LE16(&frame_body[3]);
tid = ((frame_body[5] >> 2) & 0x7);
if (status == 0) {
/* successful */
RTW_INFO("agg_enable for TID=%d\n", tid);
psta->htpriv.agg_enable_bitmap |= 1 << tid;
psta->htpriv.candidate_tid_bitmap &= ~BIT(tid);
/* amsdu in ampdu */
if (pregpriv->tx_ampdu_amsdu == 0)
psta->htpriv.tx_amsdu_enable = _FALSE;
else if (pregpriv->tx_ampdu_amsdu == 1)
psta->htpriv.tx_amsdu_enable = _TRUE;
else {
if (frame_body[5] & 1)
psta->htpriv.tx_amsdu_enable = _TRUE;
}
} else
psta->htpriv.agg_enable_bitmap &= ~BIT(tid);
if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
RTW_INFO("%s alive check - rx ADDBA response\n", __func__);
psta->htpriv.agg_enable_bitmap &= ~BIT(tid);
psta->expire_to = pstapriv->expire_to;
psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
}
/* RTW_INFO("marc: ADDBA RSP: %x\n", pmlmeinfo->agg_enable_bitmap); */
break;
case RTW_WLAN_ACTION_DELBA: /* DELBA */
if ((frame_body[3] & BIT(3)) == 0) {
psta->htpriv.agg_enable_bitmap &= ~(1 << ((frame_body[3] >> 4) & 0xf));
psta->htpriv.candidate_tid_bitmap &= ~(1 << ((frame_body[3] >> 4) & 0xf));
/* reason_code = frame_body[4] | (frame_body[5] << 8); */
reason_code = RTW_GET_LE16(&frame_body[4]);
} else if ((frame_body[3] & BIT(3)) == BIT(3)) {
tid = (frame_body[3] >> 4) & 0x0F;
preorder_ctrl = &psta->recvreorder_ctrl[tid];
preorder_ctrl->enable = _FALSE;
preorder_ctrl->ampdu_size = RX_AMPDU_SIZE_INVALID;
rtw_delba_cmd(padapter, addr, tid);
}
RTW_INFO("%s(): DELBA: %x(%x)\n", __FUNCTION__, pmlmeinfo->agg_enable_bitmap, reason_code);
/* todo: how to notify the host while receiving DELETE BA */
break;
default:
break;
}
}
#endif /* CONFIG_80211N_HT */
return _SUCCESS;
}
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
u32 rtw_build_vendor_ie(_adapter *padapter , unsigned char **pframe , u8 mgmt_frame_tyte)
{
int vendor_ie_num = 0;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u32 len = 0;
for (vendor_ie_num = 0 ; vendor_ie_num < WLAN_MAX_VENDOR_IE_NUM ; vendor_ie_num++) {
if (pmlmepriv->vendor_ielen[vendor_ie_num] > 0 && pmlmepriv->vendor_ie_mask[vendor_ie_num] & mgmt_frame_tyte) {
_rtw_memcpy(*pframe , pmlmepriv->vendor_ie[vendor_ie_num] , pmlmepriv->vendor_ielen[vendor_ie_num]);
*pframe += pmlmepriv->vendor_ielen[vendor_ie_num];
len += pmlmepriv->vendor_ielen[vendor_ie_num];
}
}
return len;
}
#endif
#ifdef CONFIG_P2P
void issue_probersp_p2p(_adapter *padapter, unsigned char *da)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
unsigned char *mac;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
/* WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network); */
u16 beacon_interval = 100;
u16 capInfo = 0;
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
u8 wpsie[255] = { 0x00 };
u32 wpsielen = 0, p2pielen = 0;
#ifdef CONFIG_WFD
u32 wfdielen = 0;
#endif
/* RTW_INFO("%s\n", __FUNCTION__); */
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
if (IS_CCK_RATE(pattrib->rate)) {
/* force OFDM 6M rate */
pattrib->rate = MGN_6M;
}
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
mac = adapter_mac_addr(padapter);
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
/* Use the device address for BSSID field. */
_rtw_memcpy(pwlanhdr->addr3, mac, ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(fctrl, WIFI_PROBERSP);
pattrib->hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = pattrib->hdrlen;
pframe += pattrib->hdrlen;
/* timestamp will be inserted by hardware */
pframe += 8;
pattrib->pktlen += 8;
/* beacon interval: 2 bytes */
_rtw_memcpy(pframe, (unsigned char *) &beacon_interval, 2);
pframe += 2;
pattrib->pktlen += 2;
/* capability info: 2 bytes */
/* ESS and IBSS bits must be 0 (defined in the 3.1.2.1.1 of WiFi Direct Spec) */
capInfo |= cap_ShortPremble;
capInfo |= cap_ShortSlot;
_rtw_memcpy(pframe, (unsigned char *) &capInfo, 2);
pframe += 2;
pattrib->pktlen += 2;
/* SSID */
pframe = rtw_set_ie(pframe, _SSID_IE_, 7, pwdinfo->p2p_wildcard_ssid, &pattrib->pktlen);
/* supported rates... */
/* Use the OFDM rate in the P2P probe response frame. ( 6(B), 9(B), 12, 18, 24, 36, 48, 54 ) */
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, 8, pwdinfo->support_rate, &pattrib->pktlen);
/* DS parameter set */
pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&pwdinfo->listen_channel, &pattrib->pktlen);
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(padapter)->p2p_enabled) {
if (pmlmepriv->wps_probe_resp_ie != NULL && pmlmepriv->p2p_probe_resp_ie != NULL) {
/* WPS IE */
_rtw_memcpy(pframe, pmlmepriv->wps_probe_resp_ie, pmlmepriv->wps_probe_resp_ie_len);
pattrib->pktlen += pmlmepriv->wps_probe_resp_ie_len;
pframe += pmlmepriv->wps_probe_resp_ie_len;
/* P2P IE */
_rtw_memcpy(pframe, pmlmepriv->p2p_probe_resp_ie, pmlmepriv->p2p_probe_resp_ie_len);
pattrib->pktlen += pmlmepriv->p2p_probe_resp_ie_len;
pframe += pmlmepriv->p2p_probe_resp_ie_len;
}
}
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_WFD
wfdielen = rtw_append_probe_resp_wfd_ie(padapter, pframe);
pframe += wfdielen;
pattrib->pktlen += wfdielen;
#endif
/* Vendor Specific IE */
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
pattrib->pktlen += rtw_build_vendor_ie(padapter , &pframe , WIFI_P2P_PROBERESP_VENDOR_IE_BIT);
#endif
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
return;
}
int _issue_probereq_p2p(_adapter *padapter, u8 *da, int wait_ack)
{
int ret = _FAIL;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
unsigned char *mac;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
u8 wpsie[255] = { 0x00 }, p2pie[255] = { 0x00 };
u16 wpsielen = 0, p2pielen = 0;
#ifdef CONFIG_WFD
u32 wfdielen = 0;
#endif
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
if (IS_CCK_RATE(pattrib->rate)) {
/* force OFDM 6M rate */
pattrib->rate = MGN_6M;
}
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
mac = adapter_mac_addr(padapter);
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
if (da) {
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, da, ETH_ALEN);
} else {
/* broadcast probe request frame */
_rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, bc_addr, ETH_ALEN);
}
_rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_PROBEREQ);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_ie(pframe, _SSID_IE_, P2P_WILDCARD_SSID_LEN, pwdinfo->p2p_wildcard_ssid, &(pattrib->pktlen));
/* Use the OFDM rate in the P2P probe request frame. ( 6(B), 9(B), 12(B), 24(B), 36, 48, 54 ) */
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, 8, pwdinfo->support_rate, &pattrib->pktlen);
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(padapter)->p2p_enabled) {
if (pmlmepriv->wps_probe_req_ie != NULL && pmlmepriv->p2p_probe_req_ie != NULL) {
/* WPS IE */
_rtw_memcpy(pframe, pmlmepriv->wps_probe_req_ie, pmlmepriv->wps_probe_req_ie_len);
pattrib->pktlen += pmlmepriv->wps_probe_req_ie_len;
pframe += pmlmepriv->wps_probe_req_ie_len;
/* P2P IE */
_rtw_memcpy(pframe, pmlmepriv->p2p_probe_req_ie, pmlmepriv->p2p_probe_req_ie_len);
pattrib->pktlen += pmlmepriv->p2p_probe_req_ie_len;
pframe += pmlmepriv->p2p_probe_req_ie_len;
}
}
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_WFD
wfdielen = rtw_append_probe_req_wfd_ie(padapter, pframe);
pframe += wfdielen;
pattrib->pktlen += wfdielen;
#endif
/* Vendor Specific IE */
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
pattrib->pktlen += rtw_build_vendor_ie(padapter , &pframe , WIFI_P2P_PROBEREQ_VENDOR_IE_BIT);
#endif
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
inline void issue_probereq_p2p(_adapter *adapter, u8 *da)
{
_issue_probereq_p2p(adapter, da, _FALSE);
}
#endif /* CONFIG_P2P */
s32 rtw_action_public_decache(union recv_frame *rframe, u8 token_offset)
{
_adapter *adapter = rframe->u.hdr.adapter;
struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
u8 *frame = rframe->u.hdr.rx_data;
u16 seq_ctrl = ((rframe->u.hdr.attrib.seq_num & 0xffff) << 4) | (rframe->u.hdr.attrib.frag_num & 0xf);
u8 token = *(rframe->u.hdr.rx_data + sizeof(struct rtw_ieee80211_hdr_3addr) + token_offset);
if (GetRetry(frame)) {
if ((seq_ctrl == mlmeext->action_public_rxseq)
&& (token == mlmeext->action_public_dialog_token)
) {
RTW_INFO(FUNC_ADPT_FMT" seq_ctrl=0x%x, rxseq=0x%x, token:%d\n",
FUNC_ADPT_ARG(adapter), seq_ctrl, mlmeext->action_public_rxseq, token);
return _FAIL;
}
}
/* TODO: per sta seq & token */
mlmeext->action_public_rxseq = seq_ctrl;
mlmeext->action_public_dialog_token = token;
return _SUCCESS;
}
unsigned int on_action_public_p2p(union recv_frame *precv_frame)
{
_adapter *padapter = precv_frame->u.hdr.adapter;
#ifdef CONFIG_P2P
#if defined(RTW_DEDICATED_P2P_DEVICE) || !RTW_P2P_GROUP_INTERFACE
if (!adapter_wdev_data(padapter)->p2p_enabled) {
RTW_INFO(FUNC_ADPT_FMT": failed to receive p2p action frame\n",
FUNC_ADPT_ARG(padapter));
return _FAIL;
} else
#endif
{
rtw_cfg80211_rx_p2p_action_public(padapter, precv_frame);
}
#endif /* CONFIG_P2P */
return _SUCCESS;
}
unsigned int on_action_public_vendor(union recv_frame *precv_frame)
{
unsigned int ret = _FAIL;
u8 *pframe = precv_frame->u.hdr.rx_data;
u8 *frame_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
_adapter *adapter = precv_frame->u.hdr.adapter;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
int cnt = 0;
char msg[64];
if (_rtw_memcmp(frame_body + 2, P2P_OUI, 4) == _TRUE) {
if (rtw_action_public_decache(precv_frame, 7) == _FAIL)
goto exit;
if (!rtw_hw_chk_wl_func(dvobj, WL_FUNC_MIRACAST))
rtw_rframe_del_wfd_ie(precv_frame, 8);
ret = on_action_public_p2p(precv_frame);
} else if (_rtw_memcmp(frame_body + 2, DPP_OUI, 4) == _TRUE) {
u8 dpp_type = frame_body[7];
#ifdef CONFIG_IOCTL_CFG80211
cnt += sprintf((msg + cnt), "DPP(type:%u)", dpp_type);
rtw_cfg80211_rx_action(adapter, precv_frame, msg);
#endif
}
exit:
return ret;
}
unsigned int on_action_public_default(union recv_frame *precv_frame, u8 action)
{
unsigned int ret = _FAIL;
u8 *pframe = precv_frame->u.hdr.rx_data;
u8 *frame_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
u8 token;
_adapter *adapter = precv_frame->u.hdr.adapter;
int cnt = 0;
char msg[64];
token = frame_body[2];
if (rtw_action_public_decache(precv_frame, 2) == _FAIL)
goto exit;
#ifdef CONFIG_IOCTL_CFG80211
cnt += sprintf((msg + cnt), "%s(token:%u)", action_public_str(action), token);
rtw_cfg80211_rx_action(adapter, precv_frame, msg);
#endif
ret = _SUCCESS;
exit:
return ret;
}
unsigned int on_action_public(_adapter *padapter, union recv_frame *precv_frame)
{
unsigned int ret = _FAIL;
u8 *pframe = precv_frame->u.hdr.rx_data;
uint frame_len = precv_frame->u.hdr.len;
u8 *frame_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
u8 category, action;
/* check RA matches or broadcast */
if (!(_rtw_memcmp(adapter_mac_addr(padapter), GetAddr1Ptr(pframe), ETH_ALEN) ||
is_broadcast_mac_addr(GetAddr1Ptr(pframe))))
goto exit;
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_PUBLIC)
goto exit;
action = frame_body[1];
switch (action) {
case ACT_PUBLIC_BSSCOEXIST:
#ifdef CONFIG_80211N_HT
#ifdef CONFIG_AP_MODE
/*20/40 BSS Coexistence Management frame is a Public Action frame*/
if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE)
rtw_process_public_act_bsscoex(padapter, pframe, frame_len);
#endif /*CONFIG_AP_MODE*/
#endif /*CONFIG_80211N_HT*/
break;
case ACT_PUBLIC_VENDOR:
ret = on_action_public_vendor(precv_frame);
break;
default:
ret = on_action_public_default(precv_frame, action);
break;
}
exit:
return ret;
}
unsigned int OnAction_ft(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_RTW_80211R
u32 ret = _FAIL, frame_len = 0;
u8 action_code = 0, category = 0;
u8 *pframe = NULL, *pframe_body = NULL, *pie = NULL;
u8 tgt_addr[ETH_ALEN], msg[32] = {0};
u32 ft_ie_len = 0;
u32 status_code = 0;
struct mlme_ext_priv *pmlmeext = NULL;
struct mlme_ext_info *pmlmeinfo = NULL;
struct mlme_priv *pmlmepriv = NULL;
struct wlan_network *proam_target = NULL;
struct ft_roam_info *pft_roam = NULL;
pmlmeext = &(padapter->mlmeextpriv);
pmlmeinfo = &(pmlmeext->mlmext_info);
pmlmepriv = &(padapter->mlmepriv);
pft_roam = &(pmlmepriv->ft_roam);
pframe = precv_frame->u.hdr.rx_data;
frame_len = precv_frame->u.hdr.len;
pframe_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
category = pframe_body[0];
if (category != RTW_WLAN_CATEGORY_FT)
goto exit;
action_code = pframe_body[1];
switch (action_code) {
case RTW_WLAN_ACTION_FT_RSP:
RTW_INFO("FT: RTW_WLAN_ACTION_FT_RSP recv.\n");
if (!_rtw_memcmp(adapter_mac_addr(padapter), &pframe_body[2], ETH_ALEN)) {
RTW_ERR("FT: Unmatched STA MAC Address "MAC_FMT"\n", MAC_ARG(&pframe_body[2]));
goto exit;
}
status_code = le16_to_cpu(*(u16 *)((SIZE_PTR)pframe + sizeof(struct rtw_ieee80211_hdr_3addr) + 14));
if (status_code != 0) {
RTW_ERR("FT: WLAN ACTION FT RESPONSE fail, status: %d\n", status_code);
goto exit;
}
_rtw_memcpy(tgt_addr, &pframe_body[8], ETH_ALEN);
if (is_zero_mac_addr(tgt_addr) || is_broadcast_mac_addr(tgt_addr)) {
RTW_ERR("FT: Invalid Target MAC Address "MAC_FMT"\n", MAC_ARG(tgt_addr));
goto exit;
}
pie = rtw_get_ie(pframe_body, _MDIE_, &ft_ie_len, frame_len);
if (pie) {
if (!_rtw_memcmp(&pft_roam->mdid, pie+2, 2)) {
RTW_ERR("FT: Invalid MDID\n");
goto exit;
}
}
rtw_ft_set_status(padapter, RTW_FT_REQUESTED_STA);
_cancel_timer_ex(&pmlmeext->ft_link_timer);
/*Disconnect current AP*/
receive_disconnect(padapter, pmlmepriv->cur_network.network.MacAddress, WLAN_REASON_ACTIVE_ROAM, _FALSE);
pft_roam->ft_action_len = frame_len;
_rtw_memcpy(pft_roam->ft_action, pframe, rtw_min(frame_len, RTW_FT_MAX_IE_SZ));
ret = _SUCCESS;
break;
case RTW_WLAN_ACTION_FT_REQ:
case RTW_WLAN_ACTION_FT_CONF:
case RTW_WLAN_ACTION_FT_ACK:
#ifdef CONFIG_IOCTL_CFG80211
sprintf(msg, "ACT_FT %u", action_code);
rtw_cfg80211_rx_action(padapter, precv_frame, msg);
#endif
break;
default:
RTW_ERR("FT: Unsupported FT Action!\n");
break;
}
exit:
return ret;
#else
return _SUCCESS;
#endif
}
unsigned int OnAction_ht(_adapter *padapter, union recv_frame *precv_frame)
{
u8 *pframe = precv_frame->u.hdr.rx_data;
u8 *frame_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
u8 category, action;
/* check RA matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter), GetAddr1Ptr(pframe), ETH_ALEN))
goto exit;
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_HT)
goto exit;
action = frame_body[1];
switch (action) {
case RTW_WLAN_ACTION_HT_SM_PS:
#ifdef CONFIG_80211N_HT
#ifdef CONFIG_AP_MODE
if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE)
rtw_process_ht_action_smps(padapter, get_addr2_ptr(pframe), frame_body[2]);
#endif /*CONFIG_AP_MODE*/
#endif /*CONFIG_80211N_HT*/
break;
case RTW_WLAN_ACTION_HT_COMPRESS_BEAMFORMING:
#ifdef CONFIG_BEAMFORMING
/*RTW_INFO("RTW_WLAN_ACTION_HT_COMPRESS_BEAMFORMING\n");*/
/*rtw_beamforming_get_report_frame(padapter, precv_frame);*/
#endif /*CONFIG_BEAMFORMING*/
break;
default:
break;
}
exit:
return _SUCCESS;
}
#ifdef CONFIG_IEEE80211W
unsigned int OnAction_sa_query(_adapter *padapter, union recv_frame *precv_frame)
{
u8 *pframe = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u16 tid;
/* Baron */
RTW_INFO("OnAction_sa_query\n");
switch (pframe[WLAN_HDR_A3_LEN + 1]) {
case 0: /* SA Query req */
_rtw_memcpy(&tid, &pframe[WLAN_HDR_A3_LEN + 2], sizeof(u16));
RTW_INFO("OnAction_sa_query request,action=%d, tid=%04x, pframe=%02x-%02x\n"
, pframe[WLAN_HDR_A3_LEN + 1], tid, pframe[WLAN_HDR_A3_LEN + 2], pframe[WLAN_HDR_A3_LEN + 3]);
issue_action_SA_Query(padapter, get_addr2_ptr(pframe), 1, tid, IEEE80211W_RIGHT_KEY);
break;
case 1: /* SA Query rsp */
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta != NULL)
_cancel_timer_ex(&psta->dot11w_expire_timer);
_rtw_memcpy(&tid, &pframe[WLAN_HDR_A3_LEN + 2], sizeof(u16));
RTW_INFO("OnAction_sa_query response,action=%d, tid=%04x, cancel timer\n", pframe[WLAN_HDR_A3_LEN + 1], tid);
break;
default:
break;
}
if (0) {
int pp;
printk("pattrib->pktlen = %d =>", pattrib->pkt_len);
for (pp = 0; pp < pattrib->pkt_len; pp++)
printk(" %02x ", pframe[pp]);
printk("\n");
}
return _SUCCESS;
}
#endif /* CONFIG_IEEE80211W */
unsigned int on_action_rm(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_RTW_80211K
return rm_on_action(padapter, precv_frame);
#else
return _SUCCESS;
#endif /* CONFIG_RTW_80211K */
}
unsigned int OnAction_wmm(_adapter *padapter, union recv_frame *precv_frame)
{
return _SUCCESS;
}
unsigned int OnAction_vht(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_80211AC_VHT
u8 *pframe = precv_frame->u.hdr.rx_data;
struct rtw_ieee80211_hdr_3addr *whdr = (struct rtw_ieee80211_hdr_3addr *)pframe;
u8 *frame_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
u8 category, action;
struct sta_info *psta = NULL;
/* check RA matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter), GetAddr1Ptr(pframe), ETH_ALEN))
goto exit;
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_VHT)
goto exit;
action = frame_body[1];
switch (action) {
case RTW_WLAN_ACTION_VHT_COMPRESSED_BEAMFORMING:
#ifdef CONFIG_BEAMFORMING
/*RTW_INFO("RTW_WLAN_ACTION_VHT_COMPRESSED_BEAMFORMING\n");*/
/*rtw_beamforming_get_report_frame(padapter, precv_frame);*/
#endif /*CONFIG_BEAMFORMING*/
break;
case RTW_WLAN_ACTION_VHT_OPMODE_NOTIFICATION:
/* CategoryCode(1) + ActionCode(1) + OpModeNotification(1) */
/* RTW_INFO("RTW_WLAN_ACTION_VHT_OPMODE_NOTIFICATION\n"); */
psta = rtw_get_stainfo(&padapter->stapriv, whdr->addr2);
if (psta)
rtw_process_vht_op_mode_notify(padapter, &frame_body[2], psta);
break;
case RTW_WLAN_ACTION_VHT_GROUPID_MANAGEMENT:
#ifdef CONFIG_BEAMFORMING
/*rtw_beamforming_get_vht_gid_mgnt_frame(padapter, precv_frame);*/
#endif /* CONFIG_BEAMFORMING */
break;
default:
break;
}
exit:
#endif /* CONFIG_80211AC_VHT */
return _SUCCESS;
}
unsigned int OnAction_he(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif /* CONFIG_80211AX_HE */
return _SUCCESS;
}
unsigned int OnAction_protected_he(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif /* CONFIG_80211AX_HE */
return _SUCCESS;
}
unsigned int OnAction_p2p(_adapter *padapter, union recv_frame *precv_frame)
{
#ifdef CONFIG_P2P
u8 *frame_body;
u8 category, OUI_Subtype, dialogToken = 0;
u8 *pframe = precv_frame->u.hdr.rx_data;
uint len = precv_frame->u.hdr.len;
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
/* check RA matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter), GetAddr1Ptr(pframe), ETH_ALEN))
return _SUCCESS;
frame_body = (unsigned char *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
category = frame_body[0];
if (category != RTW_WLAN_CATEGORY_P2P)
return _SUCCESS;
if (cpu_to_be32(*((u32 *)(frame_body + 1))) != P2POUI)
return _SUCCESS;
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(padapter)->p2p_enabled) {
rtw_cfg80211_rx_action_p2p(padapter, precv_frame);
return _SUCCESS;
}
#endif /* CONFIG_IOCTL_CFG80211 */
#endif /* CONFIG_P2P */
return _SUCCESS;
}
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
unsigned int OnAction_tbtx_token(_adapter *padapter, union recv_frame *precv_frame)
{
#define TOKEN_REQ 0x00
#define TOKEN_REL 0x01
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta;
u32 xmit_time;
u8 *src=NULL, *pframe = precv_frame->u.hdr.rx_data;
u8 tbtx_action_code;
u8 i, nr_send;
uint tx_duration = 0;
if (padapter->tbtx_capability == _FALSE)
goto exit;
tbtx_action_code = *(pframe + WLAN_HDR_A3_LEN + 1);
switch (tbtx_action_code)
{
case TOKEN_REQ:
// parse duration
tx_duration = le32_to_cpu(*(uint *)(pframe + WLAN_HDR_A3_LEN + 2));
padapter->tbtx_duration = tx_duration/1000; // Mirocsecond to Millisecond
ATOMIC_SET(&padapter->tbtx_tx_pause, _FALSE);
rtw_tx_control_cmd(padapter);
_set_timer(&pmlmeext->tbtx_xmit_timer, padapter->tbtx_duration);
ATOMIC_SET(&padapter->tbtx_remove_tx_pause, _FALSE);
#if defined(CONFIG_SDIO_HCI) && !defined(CONFIG_SDIO_TX_TASKLET)
_rtw_up_sema(&pxmitpriv->SdioXmitSema);
#else
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
#endif
break;
#ifdef CONFIG_AP_MODE
case TOKEN_REL:
src = get_addr2_ptr(pframe);
if (!src)
goto exit;
psta = rtw_get_stainfo(&padapter->stapriv, src);
if (!psta)
goto exit;
if (ATOMIC_READ(&pstapriv->nr_token_keeper) < 1)
goto exit;
for (i=0; i< NR_MAXSTA_INSLOT; i++) {
if (pstapriv->token_holder[i] == psta) {
pstapriv->token_holder[i] = NULL;
//RTW_INFO("macaddr1:" MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
ATOMIC_DEC(&pstapriv->nr_token_keeper);
break;
}
}
if (ATOMIC_READ(&pstapriv->nr_token_keeper) == 0)
_set_timer(&pmlmeext->tbtx_token_dispatch_timer, 1);
break;
#endif
default:
RTW_INFO("Undefined Action Code\n");
goto exit;
break;
}
exit:
return _SUCCESS;
}
void rtw_issue_action_token_rel(_adapter *padapter)
{
// Todo:
// gen token
/* Token Release Format
Category code : 1 Byte
Action code : 1 Byte */
int ret = _FAIL;
//u16 *fctrl;
u8 val = 0x01;
u8 category = RTW_WLAN_CATEGORY_TBTX;
u8 *pframe;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct rtw_ieee80211_hdr *pwlanhdr;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
//struct sta_info *psta;
//struct sta_priv *pstapriv = &padapter->stapriv;
//struct registry_priv *pregpriv = &padapter->registrypriv;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/*update attribute */
pattrib = &pmgntframe->attrib;
update_mgnt_tx_rate(padapter, IEEE80211_OFDM_RATE_24MB); // issue action request using OFDM rate? 20190322 Bruce add
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
//fctrl = &(pwlanhdr->frame_ctl);
//*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
// SetSeqNum??
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(val), &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
//RTW_INFO("%s\n", __func__);
}
#endif
unsigned int OnAction(_adapter *padapter, union recv_frame *precv_frame)
{
int i;
unsigned char category;
struct action_handler *ptable;
unsigned char *frame_body;
u8 *pframe = precv_frame->u.hdr.rx_data;
frame_body = (unsigned char *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
category = frame_body[0];
for (i = 0; i < sizeof(OnAction_tbl) / sizeof(struct action_handler); i++) {
ptable = &OnAction_tbl[i];
if (category == ptable->num)
ptable->func(padapter, precv_frame);
}
return _SUCCESS;
}
unsigned int DoReserved(_adapter *padapter, union recv_frame *precv_frame)
{
/* RTW_INFO("rcvd mgt frame(%x, %x)\n", (get_frame_sub_type(pframe) >> 4), *(unsigned int *)GetAddr1Ptr(pframe)); */
return _SUCCESS;
}
struct xmit_frame *_alloc_mgtxmitframe(struct xmit_priv *pxmitpriv, bool once)
{
struct xmit_frame *pmgntframe;
if (once)
pmgntframe = rtw_alloc_xmitframe_once(pxmitpriv);
else
pmgntframe = rtw_alloc_xmitframe_ext(pxmitpriv);
if (pmgntframe == NULL) {
RTW_INFO(FUNC_ADPT_FMT" alloc xmitframe fail, once:%d\n", FUNC_ADPT_ARG(pxmitpriv->adapter), once);
goto exit;
}
#if 0 /*CONFIG_CORE_XMITBUF*/
struct xmit_buf *pxmitbuf;
pxmitbuf = rtw_alloc_xmitbuf_ext(pxmitpriv);
if (pxmitbuf == NULL) {
RTW_INFO(FUNC_ADPT_FMT" alloc xmitbuf fail\n", FUNC_ADPT_ARG(pxmitpriv->adapter));
rtw_free_xmitframe(pxmitpriv, pmgntframe);
pmgntframe = NULL;
goto exit;
}
pmgntframe->frame_tag = MGNT_FRAMETAG;
pmgntframe->pxmitbuf = pxmitbuf;
pmgntframe->buf_addr = pxmitbuf->pbuf;
pxmitbuf->priv_data = pmgntframe;
#else
pmgntframe->frame_tag = MGNT_FRAMETAG;
#endif
exit:
return pmgntframe;
}
inline struct xmit_frame *alloc_mgtxmitframe(struct xmit_priv *pxmitpriv)
{
return _alloc_mgtxmitframe(pxmitpriv, _FALSE);
}
inline struct xmit_frame *alloc_mgtxmitframe_once(struct xmit_priv *pxmitpriv)
{
return _alloc_mgtxmitframe(pxmitpriv, _TRUE);
}
/****************************************************************************
Following are some TX fuctions for WiFi MLME
*****************************************************************************/
void update_mgnt_tx_rate(_adapter *padapter, u8 rate)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
pmlmeext->tx_rate = rate;
/* RTW_INFO("%s(): rate = %x\n",__FUNCTION__, rate); */
}
void update_monitor_frame_attrib(_adapter *padapter, struct pkt_attrib *pattrib)
{
u8 wireless_mode;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_info *psta = NULL;
struct sta_info *bmc_sta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
psta = rtw_get_stainfo(pstapriv, pattrib->ra);
bmc_sta = rtw_get_bcmc_stainfo(padapter);
if (bmc_sta == NULL) {
RTW_ERR("%s bmc_sta=NULL\n", __func__);
return;
}
pattrib->hdrlen = 24;
pattrib->nr_frags = 1;
pattrib->priority = 7;
pattrib->mac_id = bmc_sta->phl_sta->macid;
pattrib->qsel = rtw_hal_get_qsel(padapter, QSLT_MGNT_ID);
pattrib->pktlen = 0;
if (pmlmeext->tx_rate == IEEE80211_CCK_RATE_1MB)
wireless_mode = WLAN_MD_11B;
else
wireless_mode = WLAN_MD_11G;
#ifdef CONFIG_80211AC_VHT
pattrib->rate = MGN_VHT1SS_MCS9;
#else
pattrib->rate = MGN_MCS7;
#endif
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif
pattrib->encrypt = _NO_PRIVACY_;
pattrib->bswenc = _FALSE;
pattrib->qos_en = _FALSE;
pattrib->ht_en = 1;
pattrib->bwmode = CHANNEL_WIDTH_20;
pattrib->ch_offset = CHAN_OFFSET_NO_EXT;
pattrib->sgi = _FALSE;
pattrib->seqnum = pmlmeext->mgnt_seq;
pattrib->retry_ctrl = _TRUE;
pattrib->mbssid = 0;
pattrib->hw_ssn_sel = pxmitpriv->hw_ssn_seq_no;
}
void update_mgntframe_attrib(_adapter *padapter, struct pkt_attrib *pattrib)
{
u8 wireless_mode;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_info *bmc_sta = NULL;
#ifdef CONFIG_P2P_PS_NOA_USE_MACID_SLEEP
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P_PS_NOA_USE_MACID_SLEEP */
/* _rtw_memset((u8 *)(pattrib), 0, sizeof(struct pkt_attrib)); */
bmc_sta = rtw_get_bcmc_stainfo(padapter);
if (bmc_sta == NULL) {
RTW_ERR("%s bmc_sta=NULL\n", __func__);
return;
}
pattrib->type = WIFI_MGT_TYPE;
pattrib->hdrlen = 24;
pattrib->nr_frags = 1;
pattrib->priority = 8;
pattrib->mac_id = bmc_sta->phl_sta->macid;
pattrib->qsel = rtw_hal_get_qsel(padapter, QSLT_MGNT_ID);
#ifdef CONFIG_P2P_PS_NOA_USE_MACID_SLEEP
#ifdef CONFIG_CONCURRENT_MODE
if (rtw_mi_buddy_check_fwstate(padapter, WIFI_ASOC_STATE))
#endif /* CONFIG_CONCURRENT_MODE */
if (MLME_IS_GC(padapter)) {
if (pwdinfo->p2p_ps_mode > P2P_PS_NONE) {
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta;
psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
if (psta) {
/* use macid sleep during NoA, mgmt frame use ac queue & ap macid */
pattrib->mac_id = psta->phl_sta->macid;
pattrib->qsel = rtw_hal_get_qsel(padapter, QSLT_VO_ID);
} else {
if (pwdinfo->p2p_ps_state != P2P_PS_DISABLE)
RTW_ERR("%s , psta was NULL\n", __func__);
}
}
}
#endif /* CONFIG_P2P_PS_NOA_USE_MACID_SLEEP */
pattrib->pktlen = 0;
if (IS_CCK_RATE(pmlmeext->tx_rate))
wireless_mode = WLAN_MD_11B;
else
wireless_mode = WLAN_MD_11G;
pattrib->rate = pmlmeext->tx_rate;
pattrib->encrypt = _NO_PRIVACY_;
pattrib->bswenc = _FALSE;
pattrib->qos_en = _FALSE;
pattrib->ht_en = _FALSE;
pattrib->bwmode = CHANNEL_WIDTH_20;
pattrib->ch_offset = CHAN_OFFSET_NO_EXT;
pattrib->sgi = _FALSE;
pattrib->seqnum = pmlmeext->mgnt_seq;
pattrib->retry_ctrl = _TRUE;
pattrib->mbssid = 0;
pattrib->hw_ssn_sel = pxmitpriv->hw_ssn_seq_no;
}
void update_mgntframe_attrib_addr(_adapter *padapter, struct xmit_frame *pmgntframe)
{
u8 *pframe;
struct pkt_attrib *pattrib = &pmgntframe->attrib;
#if defined(CONFIG_BEAMFORMING) || defined(CONFIG_ANTENNA_DIVERSITY)
struct sta_info *sta = NULL;
#endif
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
_rtw_memcpy(pattrib->ra, GetAddr1Ptr(pframe), ETH_ALEN);
_rtw_memcpy(pattrib->ta, get_addr2_ptr(pframe), ETH_ALEN);
#if defined(CONFIG_BEAMFORMING) || defined(CONFIG_ANTENNA_DIVERSITY)
sta = pattrib->psta;
if (!sta) {
sta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
pattrib->psta = sta;
}
#endif /* defined(CONFIG_BEAMFORMING) || defined(CONFIG_ANTENNA_DIVERSITY) */
}
void dump_mgntframe(_adapter *padapter, struct xmit_frame *pmgntframe)
{
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(&padapter->xmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(&padapter->xmitpriv, pmgntframe);
return;
}
/*rtw_hal_mgnt_xmit(padapter, pmgntframe);*/
rtw_mgnt_xmit(padapter, pmgntframe);
}
s32 dump_mgntframe_and_wait(_adapter *padapter, struct xmit_frame *pmgntframe, int timeout_ms)
{
s32 ret = _FAIL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
#if 0 /*CONFIG_CORE_XMITBUF*/
struct xmit_buf *pxmitbuf = pmgntframe->pxmitbuf;
struct submit_ctx sctx;
unsigned long sp_flags;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
rtw_free_xmitbuf(&padapter->xmitpriv, pmgntframe->pxmitbuf);
rtw_free_xmitframe(&padapter->xmitpriv, pmgntframe);
return ret;
}
rtw_sctx_init(&sctx, timeout_ms);
pxmitbuf->sctx = &sctx;
/*ret = rtw_hal_mgnt_xmit(padapter, pmgntframe);*/
ret = rtw_mgnt_xmit(padapter, pmgntframe);
if (ret == _SUCCESS)
ret = rtw_sctx_wait(&sctx, __func__);
_rtw_spinlock_irq(&pxmitpriv->lock_sctx, &sp_flags);
pxmitbuf->sctx = NULL;
_rtw_spinunlock_irq(&pxmitpriv->lock_sctx, &sp_flags);
#else
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
rtw_free_xmitframe(&padapter->xmitpriv, pmgntframe);
return ret;
}
#endif
return ret;
}
s32 dump_mgntframe_and_wait_ack_timeout(_adapter *padapter, struct xmit_frame *pmgntframe, int timeout_ms)
{
#ifdef CONFIG_XMIT_ACK
static u8 seq_no = 0;
s32 ret = _FAIL;
struct xmit_priv *pxmitpriv = &(GET_PRIMARY_ADAPTER(padapter))->xmitpriv;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
rtw_free_xmitframe(&padapter->xmitpriv, pmgntframe);
return -1;
}
_rtw_mutex_lock_interruptible(&pxmitpriv->ack_tx_mutex);
pxmitpriv->ack_tx = _TRUE;
pxmitpriv->seq_no = seq_no++;
pmgntframe->ack_report = 1;
rtw_sctx_init(&(pxmitpriv->ack_tx_ops), timeout_ms);
/*if (rtw_hal_mgnt_xmit(padapter, pmgntframe) == _SUCCESS)*/
if (rtw_mgnt_xmit(padapter, pmgntframe) == _SUCCESS)
ret = rtw_sctx_wait(&(pxmitpriv->ack_tx_ops), __func__);
pxmitpriv->ack_tx = _FALSE;
_rtw_mutex_unlock(&pxmitpriv->ack_tx_mutex);
return ret;
#else /* !CONFIG_XMIT_ACK */
dump_mgntframe(padapter, pmgntframe);
rtw_msleep_os(50);
return _SUCCESS;
#endif /* !CONFIG_XMIT_ACK */
}
s32 dump_mgntframe_and_wait_ack(_adapter *padapter, struct xmit_frame *pmgntframe)
{
/* In this case, use 500 ms as the default wait_ack timeout */
return dump_mgntframe_and_wait_ack_timeout(padapter, pmgntframe, 500);
}
#ifdef RTW_PHL_BCN //core ops
s32 rtw_core_issue_beacon(_adapter *padapter, struct xmit_frame *pmgntframe)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct rtw_bcn_info_cmn *bcn_cmn = NULL;
struct pkt_attrib *pattrib = &pmgntframe->attrib;
u8 *pframe = (u8 *)(pmgntframe->buf_addr);
void *phl = padapter->dvobj->phl;
if(!wrole)
return _FAIL;
if(pattrib->pktlen > MAX_BCN_SIZE)
return _FAIL;
bcn_cmn = &wrole->bcn_cmn;
_rtw_memcpy(bcn_cmn->bcn_buf, pframe, pattrib->pktlen);
bcn_cmn->bcn_length = pattrib->pktlen;
{
u8 *pie_start, *pie_tim = NULL;
u32 total_ielen, tim_ielen = 0;
pie_start = pframe + (sizeof(struct rtw_ieee80211_hdr_3addr) + _FIXED_IE_LENGTH_);
total_ielen = pattrib->pktlen - (sizeof(struct rtw_ieee80211_hdr_3addr) + _FIXED_IE_LENGTH_);
pie_tim = rtw_get_ie(pie_start, _TIM_IE_, &tim_ielen, total_ielen);
if(pie_tim)
bcn_cmn->ie_offset_tim = (u32)(pie_tim - pie_start) + _FIXED_IE_LENGTH_;
}
if(bcn_cmn->bcn_added)
rtw_phl_cmd_issue_beacon(phl, padapter->phl_role, bcn_cmn, PHL_CMD_DIRECTLY, 0);
else {
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
_rtw_memcpy(bcn_cmn->bssid, get_my_bssid(cur_network), ETH_ALEN);
bcn_cmn->bcn_id = padapter->iface_id;
bcn_cmn->role_idx = wrole->id;
bcn_cmn->bcn_interval = pmlmeinfo->bcn_interval;
bcn_cmn->bcn_offload = (BIT(BCN_HW_SEQ) | BIT(BCN_HW_TIM));
if (pmlmeext->chandef.chan <= 14)
bcn_cmn->bcn_rate = RTW_DATA_RATE_CCK1;
else
bcn_cmn->bcn_rate = RTW_DATA_RATE_OFDM6;
rtw_phl_cmd_issue_beacon(phl, padapter->phl_role, bcn_cmn, PHL_CMD_DIRECTLY, 0);
bcn_cmn->bcn_added = 1;
/*
[todo]
bcn_id: mbssid-ieee
bcn_offload: tbd
bcn_rate, 0=cck 1=ofdm, 2mac can NOT cck
*/
}
return _SUCCESS;
}
#endif
int update_hidden_ssid(u8 *ies, u32 ies_len, u8 hidden_ssid_mode)
{
u8 *ssid_ie;
sint ssid_len_ori;
int len_diff = 0;
ssid_ie = rtw_get_ie(ies, WLAN_EID_SSID, &ssid_len_ori, ies_len);
/* RTW_INFO("%s hidden_ssid_mode:%u, ssid_ie:%p, ssid_len_ori:%d\n", __FUNCTION__, hidden_ssid_mode, ssid_ie, ssid_len_ori); */
if (ssid_ie && ssid_len_ori > 0) {
switch (hidden_ssid_mode) {
case 1: {
u8 *next_ie = ssid_ie + 2 + ssid_len_ori;
u32 remain_len = 0;
remain_len = ies_len - (next_ie - ies);
ssid_ie[1] = 0;
_rtw_memcpy(ssid_ie + 2, next_ie, remain_len);
len_diff -= ssid_len_ori;
break;
}
case 2:
_rtw_memset(&ssid_ie[2], 0, ssid_len_ori);
break;
default:
break;
}
}
return len_diff;
}
void issue_beacon(_adapter *padapter, int timeout_ms)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
unsigned int rate_len;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
#if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#endif /* #if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME) */
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
/* RTW_INFO("%s\n", __FUNCTION__); */
#if 0 /*def CONFIG_BCN_ICF*/
pmgntframe = rtw_alloc_bcnxmitframe(pxmitpriv);
if (pmgntframe == NULL)
#else
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
#endif
{
RTW_INFO("%s, alloc mgnt frame fail\n", __FUNCTION__);
return;
}
#if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
_rtw_spinlock_bh(&pmlmepriv->bcn_update_lock);
#endif /* #if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME) */
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->qsel = rtw_hal_get_qsel(padapter,QSLT_BEACON_ID);
#if defined(CONFIG_CONCURRENT_MODE)
if (padapter->hw_port == HW_PORT1)
pattrib->mbssid = 1;
#endif
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(cur_network), ETH_ALEN);
SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/);
/* pmlmeext->mgnt_seq++; */
set_frame_sub_type(pframe, WIFI_BEACON);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter)) {
/* RTW_INFO("ie len=%d\n", cur_network->IELength); */
#ifdef CONFIG_P2P
/* for P2P : Primary Device Type & Device Name */
u32 wpsielen = 0, insert_len = 0;
u8 *wpsie = NULL;
wpsie = rtw_get_wps_ie(cur_network->IEs + _FIXED_IE_LENGTH_, cur_network->IELength - _FIXED_IE_LENGTH_, NULL, &wpsielen);
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO) && wpsie && wpsielen > 0) {
uint wps_offset, remainder_ielen;
u8 *premainder_ie, *pframe_wscie;
wps_offset = (uint)(wpsie - cur_network->IEs);
premainder_ie = wpsie + wpsielen;
remainder_ielen = cur_network->IELength - wps_offset - wpsielen;
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(padapter)->p2p_enabled) {
if (pmlmepriv->wps_beacon_ie && pmlmepriv->wps_beacon_ie_len > 0) {
#ifdef ROKU_PRIVATE
/* if no feature need to show ssid, hide GO ssid in beacon */
struct registry_priv *pregpriv = &padapter->registrypriv;
int len_diff;
u8 hide_ssid = 0;
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO) && pregpriv->go_hidden_ssid_mode == ALL_HIDE_SSID)
hide_ssid = 1;
#endif
_rtw_memcpy(pframe, cur_network->IEs, wps_offset);
#ifdef ROKU_PRIVATE
len_diff = update_hidden_ssid(
pframe + _BEACON_IE_OFFSET_
, wps_offset - _BEACON_IE_OFFSET_
, hide_ssid);
pframe += len_diff;
pattrib->pktlen += len_diff;
#endif
pframe += wps_offset;
pattrib->pktlen += wps_offset;
_rtw_memcpy(pframe, pmlmepriv->wps_beacon_ie, pmlmepriv->wps_beacon_ie_len);
pframe += pmlmepriv->wps_beacon_ie_len;
pattrib->pktlen += pmlmepriv->wps_beacon_ie_len;
/* copy remainder_ie to pframe */
_rtw_memcpy(pframe, premainder_ie, remainder_ielen);
pframe += remainder_ielen;
pattrib->pktlen += remainder_ielen;
} else {
_rtw_memcpy(pframe, cur_network->IEs, cur_network->IELength);
pframe += cur_network->IELength;
pattrib->pktlen += cur_network->IELength;
}
}
#endif /* CONFIG_IOCTL_CFG80211 */
} else
#endif /* CONFIG_P2P */
{
int len_diff;
_rtw_memcpy(pframe, cur_network->IEs, cur_network->IELength);
len_diff = update_hidden_ssid(
pframe + _BEACON_IE_OFFSET_
, cur_network->IELength - _BEACON_IE_OFFSET_
, pmlmeinfo->hidden_ssid_mode
);
pframe += (cur_network->IELength + len_diff);
pattrib->pktlen += (cur_network->IELength + len_diff);
}
{
u8 *wps_ie;
uint wps_ielen;
u8 sr = 0;
wps_ie = rtw_get_wps_ie(pmgntframe->buf_addr + TXDESC_OFFSET + sizeof(struct rtw_ieee80211_hdr_3addr) + _BEACON_IE_OFFSET_,
pattrib->pktlen - sizeof(struct rtw_ieee80211_hdr_3addr) - _BEACON_IE_OFFSET_, NULL, &wps_ielen);
if (wps_ie && wps_ielen > 0)
rtw_get_wps_attr_content(wps_ie, wps_ielen, WPS_ATTR_SELECTED_REGISTRAR, (u8 *)(&sr), NULL);
if (sr != 0)
set_fwstate(pmlmepriv, WIFI_UNDER_WPS);
else
_clr_fwstate_(pmlmepriv, WIFI_UNDER_WPS);
}
#ifdef CONFIG_RTW_MBO
rtw_mbo_build_beacon_ies(padapter, &pframe, pattrib);
#endif
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
u32 len = 0;
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(padapter)->p2p_enabled) {
len = pmlmepriv->p2p_beacon_ie_len;
if (pmlmepriv->p2p_beacon_ie && len > 0) {
_rtw_memcpy(pframe, pmlmepriv->p2p_beacon_ie, len);
pframe += len;
pattrib->pktlen += len;
}
}
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_WFD
len = rtw_append_beacon_wfd_ie(padapter, pframe);
pframe += len;
pattrib->pktlen += len;
#endif
}
#endif /* CONFIG_P2P */
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
pattrib->pktlen += rtw_build_vendor_ie(padapter , &pframe , WIFI_BEACON_VENDOR_IE_BIT);
#endif
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (padapter->tbtx_capability == _TRUE)
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 8, REALTEK_TBTX_IE, &pattrib->pktlen);
#endif
goto _issue_bcn;
}
/* below for ad-hoc mode */
/* timestamp will be inserted by hardware */
pframe += 8;
pattrib->pktlen += 8;
/* beacon interval: 2 bytes */
_rtw_memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);
pframe += 2;
pattrib->pktlen += 2;
/* capability info: 2 bytes */
_rtw_memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);
pframe += 2;
pattrib->pktlen += 2;
/* SSID */
pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pattrib->pktlen);
/* supported rates... */
rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, ((rate_len > 8) ? 8 : rate_len), cur_network->SupportedRates, &pattrib->pktlen);
/* DS parameter set */
pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pattrib->pktlen);
/* if( (pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) */
{
u8 erpinfo = 0;
u32 ATIMWindow;
/* IBSS Parameter Set... */
/* ATIMWindow = cur->Configuration.ATIMWindow; */
ATIMWindow = 0;
pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pattrib->pktlen);
/* ERP IE */
pframe = rtw_set_ie(pframe, _ERPINFO_IE_, 1, &erpinfo, &pattrib->pktlen);
}
/* EXTERNDED SUPPORTED RATE */
if (rate_len > 8)
pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pattrib->pktlen);
/* todo:HT for adhoc */
_issue_bcn:
#if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
pmlmepriv->update_bcn = _FALSE;
_rtw_spinunlock_bh(&pmlmepriv->bcn_update_lock);
#endif /* #if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME) */
if ((pattrib->pktlen + TXDESC_SIZE) > MAX_BEACON_LEN) {
RTW_ERR("beacon frame too large ,len(%d,%d)\n",
(pattrib->pktlen + TXDESC_SIZE), MAX_BEACON_LEN);
rtw_warn_on(1);
return;
}
pattrib->last_txcmdsz = pattrib->pktlen;
/* RTW_INFO("issue bcn_sz=%d\n", pattrib->last_txcmdsz); */
#ifdef RTW_PHL_BCN
rtw_core_issue_beacon(padapter, pmgntframe);
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(&padapter->xmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(&padapter->xmitpriv, pmgntframe);
#else
if (timeout_ms > 0)
dump_mgntframe_and_wait(padapter, pmgntframe, timeout_ms);
else
dump_mgntframe(padapter, pmgntframe);
#endif
}
void issue_probersp(_adapter *padapter, unsigned char *da, u8 is_valid_p2p_probereq)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
unsigned char *mac, *bssid;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
#if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
u8 *pwps_ie;
uint wps_ielen;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
#endif /* #if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME) */
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
unsigned int rate_len;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
/* RTW_INFO("%s\n", __FUNCTION__); */
if (da == NULL)
return;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_INFO("%s, alloc mgnt frame fail\n", __FUNCTION__);
return;
}
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
mac = adapter_mac_addr(padapter);
bssid = cur_network->MacAddress;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, bssid, ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(fctrl, WIFI_PROBERSP);
pattrib->hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = pattrib->hdrlen;
pframe += pattrib->hdrlen;
if (cur_network->IELength > MAX_IE_SZ)
return;
#if defined(CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
if ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) {
pwps_ie = rtw_get_wps_ie(cur_network->IEs + _FIXED_IE_LENGTH_, cur_network->IELength - _FIXED_IE_LENGTH_, NULL, &wps_ielen);
/* inerset & update wps_probe_resp_ie */
if ((pmlmepriv->wps_probe_resp_ie != NULL) && pwps_ie && (wps_ielen > 0)) {
uint wps_offset, remainder_ielen;
u8 *premainder_ie;
wps_offset = (uint)(pwps_ie - cur_network->IEs);
premainder_ie = pwps_ie + wps_ielen;
remainder_ielen = cur_network->IELength - wps_offset - wps_ielen;
_rtw_memcpy(pframe, cur_network->IEs, wps_offset);
pframe += wps_offset;
pattrib->pktlen += wps_offset;
wps_ielen = (uint)pmlmepriv->wps_probe_resp_ie[1];/* to get ie data len */
if ((wps_offset + wps_ielen + 2) <= MAX_IE_SZ) {
_rtw_memcpy(pframe, pmlmepriv->wps_probe_resp_ie, wps_ielen + 2);
pframe += wps_ielen + 2;
pattrib->pktlen += wps_ielen + 2;
}
if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) {
_rtw_memcpy(pframe, premainder_ie, remainder_ielen);
pframe += remainder_ielen;
pattrib->pktlen += remainder_ielen;
}
} else {
_rtw_memcpy(pframe, cur_network->IEs, cur_network->IELength);
pframe += cur_network->IELength;
pattrib->pktlen += cur_network->IELength;
}
/* retrieve SSID IE from cur_network->Ssid */
{
u8 *ssid_ie;
sint ssid_ielen;
sint ssid_ielen_diff;
u8 buf[MAX_IE_SZ];
u8 *ies = pmgntframe->buf_addr + TXDESC_OFFSET + sizeof(struct rtw_ieee80211_hdr_3addr);
ssid_ie = rtw_get_ie(ies + _FIXED_IE_LENGTH_, _SSID_IE_, &ssid_ielen,
(pframe - ies) - _FIXED_IE_LENGTH_);
ssid_ielen_diff = cur_network->Ssid.SsidLength - ssid_ielen;
if (ssid_ie && cur_network->Ssid.SsidLength) {
uint remainder_ielen;
u8 *remainder_ie;
remainder_ie = ssid_ie + 2;
remainder_ielen = (pframe - remainder_ie);
if (remainder_ielen > MAX_IE_SZ) {
RTW_WARN(FUNC_ADPT_FMT" remainder_ielen > MAX_IE_SZ\n", FUNC_ADPT_ARG(padapter));
remainder_ielen = MAX_IE_SZ;
}
_rtw_memcpy(buf, remainder_ie, remainder_ielen);
_rtw_memcpy(remainder_ie + ssid_ielen_diff, buf, remainder_ielen);
*(ssid_ie + 1) = cur_network->Ssid.SsidLength;
_rtw_memcpy(ssid_ie + 2, cur_network->Ssid.Ssid, cur_network->Ssid.SsidLength);
pframe += ssid_ielen_diff;
pattrib->pktlen += ssid_ielen_diff;
}
}
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
pattrib->pktlen += rtw_build_vendor_ie(padapter , &pframe , WIFI_PROBERESP_VENDOR_IE_BIT);
#endif
} else
#endif
{
/* timestamp will be inserted by hardware */
pframe += 8;
pattrib->pktlen += 8;
/* beacon interval: 2 bytes */
_rtw_memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);
pframe += 2;
pattrib->pktlen += 2;
/* capability info: 2 bytes */
_rtw_memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);
pframe += 2;
pattrib->pktlen += 2;
/* below for ad-hoc mode */
/* SSID */
pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pattrib->pktlen);
/* supported rates... */
rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, ((rate_len > 8) ? 8 : rate_len), cur_network->SupportedRates, &pattrib->pktlen);
/* DS parameter set */
pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pattrib->pktlen);
if ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE) {
u8 erpinfo = 0;
u32 ATIMWindow;
/* IBSS Parameter Set... */
/* ATIMWindow = cur->Configuration.ATIMWindow; */
ATIMWindow = 0;
pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pattrib->pktlen);
/* ERP IE */
pframe = rtw_set_ie(pframe, _ERPINFO_IE_, 1, &erpinfo, &pattrib->pktlen);
}
/* EXTERNDED SUPPORTED RATE */
if (rate_len > 8)
pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pattrib->pktlen);
/* todo:HT for adhoc */
}
#ifdef CONFIG_RTW_MBO
rtw_mbo_build_probe_rsp_ies(padapter, &pframe, pattrib);
#endif
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)
/* IOT issue, When wifi_spec is not set, send probe_resp with P2P IE even if probe_req has no P2P IE */
&& (is_valid_p2p_probereq || !padapter->registrypriv.wifi_spec)) {
u32 len = 0;
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(padapter)->p2p_enabled) {
/* if pwdinfo->role == P2P_ROLE_DEVICE will call issue_probersp_p2p() */
len = pmlmepriv->p2p_go_probe_resp_ie_len;
if (pmlmepriv->p2p_go_probe_resp_ie && len > 0) {
_rtw_memcpy(pframe, pmlmepriv->p2p_go_probe_resp_ie, len);
pframe += len;
pattrib->pktlen += len;
}
}
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_WFD
len = rtw_append_probe_resp_wfd_ie(padapter, pframe);
pframe += len;
pattrib->pktlen += len;
#endif
}
#endif /* CONFIG_P2P */
#ifdef CONFIG_AUTO_AP_MODE
{
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
RTW_INFO("(%s)\n", __FUNCTION__);
/* check rc station */
psta = rtw_get_stainfo(pstapriv, da);
if (psta && psta->isrc && psta->pid > 0) {
u8 RC_OUI[4] = {0x00, 0xE0, 0x4C, 0x0A};
u8 RC_INFO[14] = {0};
/* EID[1] + EID_LEN[1] + RC_OUI[4] + MAC[6] + PairingID[2] + ChannelNum[2] */
u16 cu_ch = (u16)cur_network->Configuration.DSConfig;
RTW_INFO("%s, reply rc(pid=0x%x) device "MAC_FMT" in ch=%d\n", __FUNCTION__,
psta->pid, MAC_ARG(psta->phl_sta->mac_addr), cu_ch);
/* append vendor specific ie */
_rtw_memcpy(RC_INFO, RC_OUI, sizeof(RC_OUI));
_rtw_memcpy(&RC_INFO[4], mac, ETH_ALEN);
_rtw_memcpy(&RC_INFO[10], (u8 *)&psta->pid, 2);
_rtw_memcpy(&RC_INFO[12], (u8 *)&cu_ch, 2);
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, sizeof(RC_INFO), RC_INFO, &pattrib->pktlen);
}
}
#endif /* CONFIG_AUTO_AP_MODE */
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
return;
}
int _issue_probereq(_adapter *padapter, const NDIS_802_11_SSID *pssid, const u8 *da, u8 ch, bool append_wps, int wait_ack)
{
int ret = _FAIL;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
unsigned char *mac;
unsigned char bssrate[NumRates];
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
int bssrate_len = 0;
u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
#endif
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
if ((pwdev_priv->pno_mac_addr[0] != 0xFF)
&& (MLME_IS_STA(padapter))
&& (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _FALSE))
mac = pwdev_priv->pno_mac_addr;
else
#endif
mac = adapter_mac_addr(padapter);
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
if (da) {
/* unicast probe request frame */
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, da, ETH_ALEN);
} else {
/* broadcast probe request frame */
_rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, bc_addr, ETH_ALEN);
}
_rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
if ((pwdev_priv->pno_mac_addr[0] != 0xFF)
&& (MLME_IS_STA(padapter))
&& (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _FALSE)) {
#ifdef CONFIG_RTW_DEBUG
RTW_DBG("%s pno_scan_seq_num: %d\n", __func__,
pwdev_priv->pno_scan_seq_num);
#endif
SetSeqNum(pwlanhdr, pwdev_priv->pno_scan_seq_num);
pattrib->seqnum = pwdev_priv->pno_scan_seq_num;
pattrib->qos_en = 1;
pwdev_priv->pno_scan_seq_num++;
} else
#endif
{
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
}
set_frame_sub_type(pframe, WIFI_PROBEREQ);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
if (pssid && !MLME_IS_MESH(padapter))
pframe = rtw_set_ie(pframe, _SSID_IE_, pssid->SsidLength, pssid->Ssid, &(pattrib->pktlen));
else
pframe = rtw_set_ie(pframe, _SSID_IE_, 0, NULL, &(pattrib->pktlen));
get_rate_set(padapter, bssrate, &bssrate_len);
if (bssrate_len > 8) {
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , 8, bssrate, &(pattrib->pktlen));
pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_ , (bssrate_len - 8), (bssrate + 8), &(pattrib->pktlen));
} else
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , bssrate_len , bssrate, &(pattrib->pktlen));
if (ch)
pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, &ch, &pattrib->pktlen);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
if (pssid)
pframe = rtw_set_ie_mesh_id(pframe, &pattrib->pktlen, pssid->Ssid, pssid->SsidLength);
else
pframe = rtw_set_ie_mesh_id(pframe, &pattrib->pktlen, NULL, 0);
}
#endif
if (append_wps) {
/* add wps_ie for wps2.0 */
if (pmlmepriv->wps_probe_req_ie_len > 0 && pmlmepriv->wps_probe_req_ie) {
_rtw_memcpy(pframe, pmlmepriv->wps_probe_req_ie, pmlmepriv->wps_probe_req_ie_len);
pframe += pmlmepriv->wps_probe_req_ie_len;
pattrib->pktlen += pmlmepriv->wps_probe_req_ie_len;
/* pmlmepriv->wps_probe_req_ie_len = 0 ; */ /* reset to zero */
}
}
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
pattrib->pktlen += rtw_build_vendor_ie(padapter , &pframe , WIFI_PROBEREQ_VENDOR_IE_BIT);
#endif
#ifdef CONFIG_RTW_MBO
rtw_mbo_build_probe_req_ies(padapter, &pframe, pattrib);
#endif
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
inline void issue_probereq(_adapter *padapter, const NDIS_802_11_SSID *pssid, const u8 *da)
{
_issue_probereq(padapter, pssid, da, 0, 1, _FALSE);
}
/*
* wait_ms == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
* wait_ms > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
* try_cnt means the maximal TX count to try
*/
int issue_probereq_ex(_adapter *padapter, const NDIS_802_11_SSID *pssid, const u8 *da, u8 ch, bool append_wps,
int try_cnt, int wait_ms)
{
int ret = _FAIL;
int i = 0;
systime start = rtw_get_current_time();
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
do {
ret = _issue_probereq(padapter, pssid, da, ch, append_wps, wait_ms > 0 ? _TRUE : _FALSE);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
goto exit;
#endif
}
if (try_cnt && wait_ms) {
if (da)
RTW_INFO(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
else
RTW_INFO(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
/* if psta == NULL, indiate we are station(client) now... */
void issue_auth(_adapter *padapter, struct sta_info *psta, unsigned short status)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
unsigned int val32;
unsigned short val16;
int use_shared_key = 0;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct security_priv *psecuritypriv = &padapter->securitypriv;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_AUTH);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
if (psta) { /* for AP mode */
#ifdef CONFIG_NATIVEAP_MLME
_rtw_memcpy(pwlanhdr->addr1, psta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(padapter), ETH_ALEN);
/* setting auth algo number */
val16 = (u16)psta->authalg;
if (status != _STATS_SUCCESSFUL_)
val16 = 0;
if (val16) {
val16 = cpu_to_le16(val16);
use_shared_key = 1;
}
pframe = rtw_set_fixed_ie(pframe, _AUTH_ALGM_NUM_, (unsigned char *)&val16, &(pattrib->pktlen));
/* setting auth seq number */
val16 = (u16)psta->auth_seq;
val16 = cpu_to_le16(val16);
pframe = rtw_set_fixed_ie(pframe, _AUTH_SEQ_NUM_, (unsigned char *)&val16, &(pattrib->pktlen));
/* setting status code... */
val16 = status;
val16 = cpu_to_le16(val16);
pframe = rtw_set_fixed_ie(pframe, _STATUS_CODE_, (unsigned char *)&val16, &(pattrib->pktlen));
/* added challenging text... */
if ((psta->auth_seq == 2) && (psta->state & WIFI_FW_AUTH_STATE) && (use_shared_key == 1))
pframe = rtw_set_ie(pframe, _CHLGETXT_IE_, 128, psta->chg_txt, &(pattrib->pktlen));
#endif
} else {
_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
#ifdef CONFIG_RTW_80211R
if (rtw_ft_roam(padapter)) {
/* 2: 802.11R FTAA */
val16 = cpu_to_le16(WLAN_AUTH_FT);
} else
#endif
{
/* setting auth algo number */
val16 = (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared) ? 1 : 0; /* 0:OPEN System, 1:Shared key */
if (val16) {
val16 = cpu_to_le16(val16);
use_shared_key = 1;
}
}
/* RTW_INFO("%s auth_algo= %s auth_seq=%d\n",__FUNCTION__,(pmlmeinfo->auth_algo==0)?"OPEN":"SHARED",pmlmeinfo->auth_seq); */
/* setting IV for auth seq #3 */
if ((pmlmeinfo->auth_seq == 3) && (pmlmeinfo->state & WIFI_FW_AUTH_STATE) && (use_shared_key == 1)) {
/* RTW_INFO("==> iv(%d),key_index(%d)\n",pmlmeinfo->iv,pmlmeinfo->key_index); */
val32 = ((pmlmeinfo->iv++) | (psecuritypriv->dot11PrivacyKeyIndex << 30));
val32 = cpu_to_le32(val32);
pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *)&val32, &(pattrib->pktlen));
pattrib->iv_len = 4;
}
pframe = rtw_set_fixed_ie(pframe, _AUTH_ALGM_NUM_, (unsigned char *)&val16, &(pattrib->pktlen));
/* setting auth seq number */
val16 = pmlmeinfo->auth_seq;
val16 = cpu_to_le16(val16);
pframe = rtw_set_fixed_ie(pframe, _AUTH_SEQ_NUM_, (unsigned char *)&val16, &(pattrib->pktlen));
/* setting status code... */
val16 = status;
val16 = cpu_to_le16(val16);
pframe = rtw_set_fixed_ie(pframe, _STATUS_CODE_, (unsigned char *)&val16, &(pattrib->pktlen));
#ifdef CONFIG_RTW_80211R
rtw_ft_build_auth_req_ies(padapter, pattrib, &pframe);
#endif
/* then checking to see if sending challenging text... */
if ((pmlmeinfo->auth_seq == 3) && (pmlmeinfo->state & WIFI_FW_AUTH_STATE) && (use_shared_key == 1)) {
pframe = rtw_set_ie(pframe, _CHLGETXT_IE_, 128, pmlmeinfo->chg_txt, &(pattrib->pktlen));
SetPrivacy(fctrl);
pattrib->hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->encrypt = _WEP40_;
pattrib->icv_len = 4;
pattrib->pktlen += pattrib->icv_len;
pattrib->bswenc = _TRUE;
}
}
pattrib->last_txcmdsz = pattrib->pktlen;
rtw_wep_encrypt(padapter, (u8 *)pmgntframe);
RTW_INFO("%s\n", __FUNCTION__);
dump_mgntframe(padapter, pmgntframe);
return;
}
void issue_asocrsp(_adapter *padapter, unsigned short status, struct sta_info *pstat, int pkt_type)
{
#ifdef CONFIG_AP_MODE
struct xmit_frame *pmgntframe;
struct rtw_ieee80211_hdr *pwlanhdr;
struct pkt_attrib *pattrib;
unsigned char *pbuf, *pframe;
unsigned short val, ie_status;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = &(pmlmeinfo->network);
u8 *ie = pnetwork->IEs;
uint ie_len = 0;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#ifdef CONFIG_WFD
u32 wfdielen = 0;
#endif
#endif /* CONFIG_P2P */
#ifdef CONFIG_RTW_MBO
u8 WIFI_ALLIANCE_OUI[] = {0x50, 0x6f, 0x9a};
#endif /* CONFIG_RTW_MBO */
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
RTW_INFO("%s\n", __FUNCTION__);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy((void *)GetAddr1Ptr(pwlanhdr), pstat->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy((void *)get_addr2_ptr(pwlanhdr), adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy((void *)GetAddr3Ptr(pwlanhdr), get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
if ((pkt_type == WIFI_ASSOCRSP) || (pkt_type == WIFI_REASSOCRSP))
set_frame_sub_type(pwlanhdr, pkt_type);
else
return;
pattrib->hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen += pattrib->hdrlen;
pframe += pattrib->hdrlen;
/* capability */
val = *(unsigned short *)rtw_get_capability_from_ie(ie);
pframe = rtw_set_fixed_ie(pframe, _CAPABILITY_ , (unsigned char *)&val, &(pattrib->pktlen));
ie_status = cpu_to_le16(status);
pframe = rtw_set_fixed_ie(pframe , _STATUS_CODE_ , (unsigned char *)&ie_status, &(pattrib->pktlen));
val = cpu_to_le16(pstat->phl_sta->aid | BIT(14) | BIT(15));
pframe = rtw_set_fixed_ie(pframe, _ASOC_ID_ , (unsigned char *)&val, &(pattrib->pktlen));
if (pstat->bssratelen <= 8)
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, pstat->bssratelen, pstat->bssrateset, &(pattrib->pktlen));
else {
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, 8, pstat->bssrateset, &(pattrib->pktlen));
pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (pstat->bssratelen - 8), pstat->bssrateset + 8, &(pattrib->pktlen));
}
#ifdef CONFIG_IEEE80211W
if (status == _STATS_REFUSED_TEMPORARILY_) {
u8 timeout_itvl[5];
u32 timeout_interval = 3000;
/* Association Comeback time */
timeout_itvl[0] = 0x03;
timeout_interval = cpu_to_le32(timeout_interval);
_rtw_memcpy(timeout_itvl + 1, &timeout_interval, 4);
pframe = rtw_set_ie(pframe, _TIMEOUT_ITVL_IE_, 5, timeout_itvl, &(pattrib->pktlen));
}
#endif /* CONFIG_IEEE80211W */
#ifdef CONFIG_80211N_HT
if ((pstat->flags & WLAN_STA_HT) && (pmlmepriv->htpriv.ht_option)) {
uint ie_len = 0;
/* FILL HT CAP INFO IE */
/* p = hostapd_eid_ht_capabilities_info(hapd, p); */
pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_CAPABILITY_IE_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
}
/* FILL HT ADD INFO IE */
/* p = hostapd_eid_ht_operation(hapd, p); */
pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_ADD_INFO_IE_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
}
}
#endif
/*adding EXT_CAPAB_IE */
if (pmlmepriv->ext_capab_ie_len > 0) {
uint ie_len = 0;
pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, WLAN_EID_EXT_CAP, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
}
}
#ifdef CONFIG_RTW_80211K
/* Adding RM capability IE */
if (padapter->rmpriv.enable == _TRUE) {
pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _EID_RRM_EN_CAP_IE_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
}
}
#endif /* CONFIG_RTW_80211K */
#ifdef CONFIG_RTW_MBO
if (pmlmepriv->mbopriv.enable == _TRUE) {
ie_len = 0;
for (pbuf = ie + _BEACON_IE_OFFSET_; ; pbuf += (ie_len + 2)) {
pbuf = rtw_get_ie(pbuf, _SSN_IE_1_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)));
if ((pbuf) && (_rtw_memcmp(pbuf + 2, WIFI_ALLIANCE_OUI, 3)) && (*(pbuf+5) == MBO_OUI_TYPE)) {
/* find MBO-OCE information element */
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
break;
}
if ((pbuf == NULL) || (ie_len == 0))
break;
}
}
#endif /* CONFIG_RTW_MBO */
#ifdef CONFIG_80211AC_VHT
if ((pstat->flags & WLAN_STA_VHT) && (pmlmepriv->vhtpriv.vht_option)
&& (pstat->wpa_pairwise_cipher != WPA_CIPHER_TKIP)
&& (pstat->wpa2_pairwise_cipher != WPA_CIPHER_TKIP)) {
u32 ie_len = 0;
/* FILL VHT CAP IE */
pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, EID_VHTCapability, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
}
/* FILL VHT OPERATION IE */
pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, EID_VHTOperation, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
}
}
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
if ((pstat->flags & WLAN_STA_HE) && (pmlmepriv->hepriv.he_option)) {
u32 ie_len = 0;
u8 he_cap_eid_ext = WLAN_EID_EXTENSION_HE_CAPABILITY;
u8 he_op_eid_ext = WLAN_EID_EXTENSION_HE_OPERATION;
/* FILL HE CAP IE */
pbuf = rtw_get_ie_ex(ie + _BEACON_IE_OFFSET_, pnetwork->IELength - _BEACON_IE_OFFSET_,
WLAN_EID_EXTENSION, &he_cap_eid_ext, 1, NULL, &ie_len);
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len);
pframe += ie_len;
pattrib->pktlen += ie_len;
}
/* FILL HE OPERATION IE */
pbuf = rtw_get_ie_ex(ie + _BEACON_IE_OFFSET_, pnetwork->IELength - _BEACON_IE_OFFSET_,
WLAN_EID_EXTENSION, &he_op_eid_ext, 1, NULL, &ie_len);
if (pbuf && ie_len > 0) {
_rtw_memcpy(pframe, pbuf, ie_len);
pframe += ie_len;
pattrib->pktlen += ie_len;
}
}
#endif /* CONFIG_80211AX_HE */
#ifdef CONFIG_RTW_80211R_AP
rtw_ft_build_assoc_rsp_ies(padapter, pstat, pattrib, &pframe);
#endif
#ifdef CONFIG_RTW_MBO
rtw_mbo_build_assoc_rsp_ies(padapter, &pframe, pattrib);
#endif
/* FILL WMM IE */
if ((pstat->flags & WLAN_STA_WME) && (pmlmepriv->qospriv.qos_option)) {
uint ie_len = 0;
unsigned char WMM_PARA_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
for (pbuf = ie + _BEACON_IE_OFFSET_; ; pbuf += (ie_len + 2)) {
pbuf = rtw_get_ie(pbuf, _VENDOR_SPECIFIC_IE_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)));
if (pbuf && _rtw_memcmp(pbuf + 2, WMM_PARA_IE, 6)) {
_rtw_memcpy(pframe, pbuf, ie_len + 2);
pframe += (ie_len + 2);
pattrib->pktlen += (ie_len + 2);
break;
}
if ((pbuf == NULL) || (ie_len == 0))
break;
}
}
if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_REALTEK)
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 6 , REALTEK_96B_IE, &(pattrib->pktlen));
/* add WPS IE ie for wps 2.0 */
if (pmlmepriv->wps_assoc_resp_ie && pmlmepriv->wps_assoc_resp_ie_len > 0) {
_rtw_memcpy(pframe, pmlmepriv->wps_assoc_resp_ie, pmlmepriv->wps_assoc_resp_ie_len);
pframe += pmlmepriv->wps_assoc_resp_ie_len;
pattrib->pktlen += pmlmepriv->wps_assoc_resp_ie_len;
}
#ifdef CONFIG_P2P
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO) && (pstat->is_p2p_device == _TRUE)) {
u32 len = 0;
if (pmlmepriv->p2p_assoc_resp_ie && pmlmepriv->p2p_assoc_resp_ie_len > 0) {
len = pmlmepriv->p2p_assoc_resp_ie_len;
_rtw_memcpy(pframe, pmlmepriv->p2p_assoc_resp_ie, len);
} else if (pmlmepriv->assoc_rsp && pmlmepriv->assoc_rsp_len > 0) {
len = pmlmepriv->assoc_rsp_len;
_rtw_memcpy(pframe, pmlmepriv->assoc_rsp, len);
}
pframe += len;
pattrib->pktlen += len;
}
#ifdef CONFIG_WFD
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
wfdielen = rtw_append_assoc_resp_wfd_ie(padapter, pframe);
pframe += wfdielen;
pattrib->pktlen += wfdielen;
}
#endif
#endif /* CONFIG_P2P */
#ifdef CONFIG_RTW_MULTI_AP
if (padapter->multi_ap && (pstat->flags & WLAN_STA_MULTI_AP))
pframe = rtw_set_multi_ap_ie_ext(pframe, &pattrib->pktlen, padapter->multi_ap);
#endif
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
pattrib->pktlen += rtw_build_vendor_ie(padapter , &pframe , WIFI_ASSOCRESP_VENDOR_IE_BIT);
#endif
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (padapter->tbtx_capability == _TRUE)
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 8, REALTEK_TBTX_IE, &pattrib->pktlen);
#endif
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
#endif
}
static u32 rtw_append_assoc_req_owe_ie(_adapter *adapter, u8 *pbuf)
{
struct security_priv *sec = &adapter->securitypriv;
u32 len = 0;
if (sec == NULL)
goto exit;
if (sec->owe_ie_len > 0) {
len = sec->owe_ie_len;
_rtw_memcpy(pbuf, sec->owe_ie, len);
}
exit:
return len;
}
void _issue_assocreq(_adapter *padapter, u8 is_reassoc)
{
int ret = _FAIL;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
unsigned short val16;
unsigned int i, j, index = 0;
unsigned char bssrate[NumRates], sta_bssrate[NumRates];
PNDIS_802_11_VARIABLE_IEs pIE;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
int bssrate_len = 0, sta_bssrate_len = 0;
u8 vs_ie_length = 0;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
u8 p2pie[255] = { 0x00 };
u16 p2pielen = 0;
#ifdef CONFIG_WFD
u32 wfdielen = 0;
#endif
#endif /* CONFIG_P2P */
#if CONFIG_DFS
u16 cap;
#endif
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
if (is_reassoc == _TRUE)
set_frame_sub_type(pframe, WIFI_REASSOCREQ);
else
set_frame_sub_type(pframe, WIFI_ASSOCREQ);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
/* caps */
#if CONFIG_DFS
_rtw_memcpy(&cap, rtw_get_capability_from_ie(pmlmeinfo->network.IEs), 2);
cap |= cap_SpecMgmt;
_rtw_memcpy(pframe, &cap, 2);
#else
_rtw_memcpy(pframe, rtw_get_capability_from_ie(pmlmeinfo->network.IEs), 2);
#endif
pframe += 2;
pattrib->pktlen += 2;
/* listen interval */
/* todo: listen interval for power saving */
val16 = cpu_to_le16(3);
_rtw_memcpy(pframe , (unsigned char *)&val16, 2);
pframe += 2;
pattrib->pktlen += 2;
/*Construct Current AP Field for Reassoc-Req only*/
if (is_reassoc == _TRUE) {
_rtw_memcpy(pframe, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
pframe += ETH_ALEN;
pattrib->pktlen += ETH_ALEN;
}
/* SSID */
pframe = rtw_set_ie(pframe, _SSID_IE_, pmlmeinfo->network.Ssid.SsidLength, pmlmeinfo->network.Ssid.Ssid, &(pattrib->pktlen));
#if CONFIG_IEEE80211_BAND_5GHZ && CONFIG_DFS
/* Dot H */
if (pmlmeext->chandef.chan > 14) {
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
u8 pow_cap_ele[2] = { 0x00 };
u8 sup_ch[30 * 2] = {0x00 }, sup_ch_idx = 0, idx_5g = 2; /* For supported channel */
pow_cap_ele[0] = 13; /* Minimum transmit power capability */
pow_cap_ele[1] = 21; /* Maximum transmit power capability */
pframe = rtw_set_ie(pframe, EID_PowerCap, 2, pow_cap_ele, &(pattrib->pktlen));
/* supported channels */
while (sup_ch_idx < rfctl->max_chan_nums && rfctl->channel_set[sup_ch_idx].ChannelNum != 0) {
if (rfctl->channel_set[sup_ch_idx].ChannelNum <= 14) {
/* TODO: fix 2.4G supported channel when channel doesn't start from 1 and continuous */
sup_ch[0] = 1; /* First channel number */
sup_ch[1] = rfctl->channel_set[sup_ch_idx].ChannelNum; /* Number of channel */
} else {
sup_ch[idx_5g++] = rfctl->channel_set[sup_ch_idx].ChannelNum;
sup_ch[idx_5g++] = 1;
}
sup_ch_idx++;
}
pframe = rtw_set_ie(pframe, EID_SupportedChannels, idx_5g, sup_ch, &(pattrib->pktlen));
}
#endif /* CONFIG_IEEE80211_BAND_5GHZ && CONFIG_DFS */
/* supported rate & extended supported rate */
#if 1 /* Check if the AP's supported rates are also supported by STA. */
get_rate_set(padapter, sta_bssrate, &sta_bssrate_len);
/* RTW_INFO("sta_bssrate_len=%d\n", sta_bssrate_len); */
if (pmlmeext->chandef.chan == 14) /* for JAPAN, channel 14 can only uses B Mode(CCK) */
sta_bssrate_len = 4;
/* for (i = 0; i < sta_bssrate_len; i++) { */
/* RTW_INFO("sta_bssrate[%d]=%02X\n", i, sta_bssrate[i]); */
/* } */
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
if (pmlmeinfo->network.SupportedRates[i] == 0)
break;
RTW_INFO("network.SupportedRates[%d]=%02X\n", i, pmlmeinfo->network.SupportedRates[i]);
}
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
if (pmlmeinfo->network.SupportedRates[i] == 0)
break;
/* Check if the AP's supported rates are also supported by STA. */
for (j = 0; j < sta_bssrate_len; j++) {
/* Avoid the proprietary data rate (22Mbps) of Handlink WSG-4000 AP */
if ((pmlmeinfo->network.SupportedRates[i] | IEEE80211_BASIC_RATE_MASK)
== (sta_bssrate[j] | IEEE80211_BASIC_RATE_MASK)) {
/* RTW_INFO("match i = %d, j=%d\n", i, j); */
break;
} else {
/* RTW_INFO("not match: %02X != %02X\n", (pmlmeinfo->network.SupportedRates[i]|IEEE80211_BASIC_RATE_MASK), (sta_bssrate[j]|IEEE80211_BASIC_RATE_MASK)); */
}
}
if (j == sta_bssrate_len) {
/* the rate is not supported by STA */
RTW_INFO("%s(): the rate[%d]=%02X is not supported by STA!\n", __FUNCTION__, i, pmlmeinfo->network.SupportedRates[i]);
} else {
/* the rate is supported by STA */
bssrate[index++] = pmlmeinfo->network.SupportedRates[i];
}
}
bssrate_len = index;
RTW_INFO("bssrate_len = %d\n", bssrate_len);
#else /* Check if the AP's supported rates are also supported by STA. */
#if 0
get_rate_set(padapter, bssrate, &bssrate_len);
#else
for (bssrate_len = 0; bssrate_len < NumRates; bssrate_len++) {
if (pmlmeinfo->network.SupportedRates[bssrate_len] == 0)
break;
if (pmlmeinfo->network.SupportedRates[bssrate_len] == 0x2C) /* Avoid the proprietary data rate (22Mbps) of Handlink WSG-4000 AP */
break;
bssrate[bssrate_len] = pmlmeinfo->network.SupportedRates[bssrate_len];
}
#endif
#endif /* Check if the AP's supported rates are also supported by STA. */
if ((bssrate_len == 0) && (pmlmeinfo->network.SupportedRates[0] != 0)) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit; /* don't connect to AP if no joint supported rate */
}
if (bssrate_len > 8) {
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , 8, bssrate, &(pattrib->pktlen));
pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_ , (bssrate_len - 8), (bssrate + 8), &(pattrib->pktlen));
} else if (bssrate_len > 0)
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , bssrate_len , bssrate, &(pattrib->pktlen));
else
RTW_INFO("%s: Connect to AP without 11b and 11g data rate!\n", __FUNCTION__);
#ifdef CONFIG_RTW_MBO
rtw_mbo_build_assoc_req_ies(padapter, &pframe, pattrib);
#endif
#ifdef CONFIG_RTW_80211R
rtw_ft_build_assoc_req_ies(padapter, is_reassoc, pattrib, &pframe);
#endif
#ifdef CONFIG_RTW_80211K
if (pmlmeinfo->network.PhyInfo.rm_en_cap[0] /* RM Enabled Capabilities */
| pmlmeinfo->network.PhyInfo.rm_en_cap[1]
| pmlmeinfo->network.PhyInfo.rm_en_cap[2]
| pmlmeinfo->network.PhyInfo.rm_en_cap[3]
| pmlmeinfo->network.PhyInfo.rm_en_cap[4])
pframe = rtw_set_ie(pframe, _EID_RRM_EN_CAP_IE_, 5,
(u8 *)padapter->rmpriv.rm_en_cap_def, &(pattrib->pktlen));
#endif /* CONFIG_RTW_80211K */
/* vendor specific IE, such as WPA, WMM, WPS */
for (i = sizeof(NDIS_802_11_FIXED_IEs); i < pmlmeinfo->network.IELength;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(pmlmeinfo->network.IEs + i);
switch (pIE->ElementID) {
case _VENDOR_SPECIFIC_IE_:
if ((_rtw_memcmp(pIE->data, RTW_WPA_OUI, 4)) ||
(_rtw_memcmp(pIE->data, WMM_OUI, 4)) ||
(_rtw_memcmp(pIE->data, WPS_OUI, 4))) {
vs_ie_length = pIE->Length;
if ((!padapter->registrypriv.wifi_spec) && (_rtw_memcmp(pIE->data, WPS_OUI, 4))) {
/* Commented by Kurt 20110629 */
/* In some older APs, WPS handshake */
/* would be fail if we append vender extensions informations to AP */
vs_ie_length = 14;
}
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, vs_ie_length, pIE->data, &(pattrib->pktlen));
}
break;
case EID_WPA2:
#ifdef CONFIG_RTW_80211R
if ((is_reassoc) && (rtw_ft_roam(padapter))) {
rtw_ft_update_rsnie(padapter, _TRUE, pattrib, &pframe);
} else
#endif
{
#ifdef CONFIG_IOCTL_CFG80211
if (rtw_sec_chk_auth_alg(padapter, WLAN_AUTH_OPEN) &&
rtw_sec_chk_auth_type(padapter, MLME_AUTHTYPE_SAE)) {
s32 entry = rtw_cached_pmkid(padapter, pmlmepriv->assoc_bssid);
rtw_rsn_sync_pmkid(padapter, (u8 *)pIE, (pIE->Length + 2), entry);
}
#endif /* CONFIG_IOCTL_CFG80211 */
pframe = rtw_set_ie(pframe, EID_WPA2, pIE->Length, pIE->data, &(pattrib->pktlen));
/* tmp: update rsn's spp related opt. */
/*rtw_set_spp_amsdu_mode(padapter->registrypriv.amsdu_mode, pframe - (pIE->Length + 2), pIE->Length +2); */
}
break;
#ifdef CONFIG_80211N_HT
case EID_HTCapability:
if (padapter->mlmepriv.htpriv.ht_option == _TRUE) {
if (!(is_ap_in_tkip(padapter))) {
_rtw_memcpy(&(pmlmeinfo->HT_caps), pIE->data, sizeof(struct HT_caps_element));
pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info = cpu_to_le16(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info);
pframe = rtw_set_ie(pframe, EID_HTCapability, pIE->Length , (u8 *)(&(pmlmeinfo->HT_caps)), &(pattrib->pktlen));
}
}
break;
#endif /* CONFIG_80211N_HT */
case WLAN_EID_EXT_CAP:
pframe = rtw_set_ie(pframe, WLAN_EID_EXT_CAP, pIE->Length, pIE->data, &(pattrib->pktlen));
break;
#ifdef CONFIG_80211AC_VHT
case EID_VHTCapability:
if (padapter->mlmepriv.vhtpriv.vht_option == _TRUE)
pframe = rtw_set_ie(pframe, EID_VHTCapability, pIE->Length, pIE->data, &(pattrib->pktlen));
break;
case EID_OpModeNotification:
if (padapter->mlmepriv.vhtpriv.vht_option == _TRUE)
pframe = rtw_set_ie(pframe, EID_OpModeNotification, pIE->Length, pIE->data, &(pattrib->pktlen));
break;
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
case WLAN_EID_EXTENSION:
if ((pIE->data[0] == WLAN_EID_EXTENSION_HE_CAPABILITY)
&& (padapter->mlmepriv.hepriv.he_option == _TRUE))
pframe = rtw_set_ie(pframe, WLAN_EID_EXTENSION, pIE->Length, pIE->data, &(pattrib->pktlen));
break;
#endif /* CONFIG_80211AX_HE */
default:
break;
}
i += (pIE->Length + 2);
}
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (padapter->tbtx_capability == _TRUE)
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 8 , REALTEK_TBTX_IE, &(pattrib->pktlen));
#endif
if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_REALTEK)
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 6 , REALTEK_96B_IE, &(pattrib->pktlen));
#ifdef CONFIG_WAPI_SUPPORT
rtw_build_assoc_req_wapi_ie(padapter, pframe, pattrib);
#endif
#ifdef CONFIG_P2P
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(padapter)->p2p_enabled) {
if (pmlmepriv->p2p_assoc_req_ie && pmlmepriv->p2p_assoc_req_ie_len > 0) {
_rtw_memcpy(pframe, pmlmepriv->p2p_assoc_req_ie, pmlmepriv->p2p_assoc_req_ie_len);
pframe += pmlmepriv->p2p_assoc_req_ie_len;
pattrib->pktlen += pmlmepriv->p2p_assoc_req_ie_len;
}
}
#endif /* CONFIG_IOCTL_CFG80211 */
#ifdef CONFIG_WFD
wfdielen = rtw_append_assoc_req_wfd_ie(padapter, pframe);
pframe += wfdielen;
pattrib->pktlen += wfdielen;
#endif
#endif /* CONFIG_P2P */
#ifdef CONFIG_RTW_MULTI_AP
if (padapter->multi_ap)
pframe = rtw_set_multi_ap_ie_ext(pframe, &pattrib->pktlen, padapter->multi_ap);
#endif
/* OWE */
{
u32 owe_ie_len;
owe_ie_len = rtw_append_assoc_req_owe_ie(padapter, pframe);
pframe += owe_ie_len;
pattrib->pktlen += owe_ie_len;
}
#ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
pattrib->pktlen += rtw_build_vendor_ie(padapter , &pframe , WIFI_ASSOCREQ_VENDOR_IE_BIT);
#endif
#ifdef CONFIG_RTW_80211R
rtw_ft_build_assoc_req_ies(padapter, is_reassoc, pattrib, &pframe);
#endif
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
if (ret == _SUCCESS) {
rtw_buf_update(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len, (u8 *)pwlanhdr, pattrib->pktlen);
#ifdef CONFIG_RTW_WNM
if (is_reassoc == _TRUE)
rtw_wnm_update_reassoc_req_ie(padapter);
#endif
} else
rtw_buf_free(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len);
return;
}
void issue_assocreq(_adapter *padapter)
{
_issue_assocreq(padapter, _FALSE);
}
void issue_reassocreq(_adapter *padapter)
{
_issue_assocreq(padapter, _TRUE);
}
/* when wait_ack is ture, this function shoule be called at process context */
static int _issue_nulldata(_adapter *padapter, unsigned char *da, unsigned int power_mode, int wait_ack)
{
int ret = _FAIL;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv;
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
u8 a4_shift;
/* RTW_INFO("%s:%d\n", __FUNCTION__, power_mode); */
if (!padapter)
goto exit;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
pxmitpriv = &(padapter->xmitpriv);
pmlmeext = &(padapter->mlmeextpriv);
pmlmeinfo = &(pmlmeext->mlmext_info);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->retry_ctrl = _FALSE;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
if (MLME_IS_AP(padapter))
SetFrDs(fctrl);
else if (MLME_IS_STA(padapter))
SetToDs(fctrl);
else if (MLME_IS_MESH(padapter)) {
SetToDs(fctrl);
SetFrDs(fctrl);
}
if (power_mode)
SetPwrMgt(fctrl);
if (get_tofr_ds(fctrl) == 3) {
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr4, adapter_mac_addr(padapter), ETH_ALEN);
a4_shift = ETH_ALEN;
pattrib->hdrlen += ETH_ALEN;
} else {
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
a4_shift = 0;
}
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_DATA_NULL);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr) + a4_shift;
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr) + a4_shift;
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
/*
* When wait_ms > 0, this function should be called at process context
* wait_ms == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
* wait_ms > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
* try_cnt means the maximal TX count to try
* da == NULL for station mode
*/
int issue_nulldata(_adapter *padapter, unsigned char *da, unsigned int power_mode, int try_cnt, int wait_ms)
{
int ret = _FAIL;
int i = 0;
systime start = rtw_get_current_time();
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
/* da == NULL, assum it's null data for sta to ap */
if (da == NULL)
da = get_my_bssid(&(pmlmeinfo->network));
do {
ret = _issue_nulldata(padapter, da, power_mode, wait_ms > 0 ? _TRUE : _FALSE);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
goto exit;
#endif
}
if (try_cnt && wait_ms) {
if (da)
RTW_INFO(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
else
RTW_INFO(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
/* when wait_ack is ture, this function shoule be called at process context */
static int _issue_qos_nulldata(_adapter *padapter, unsigned char *da, u16 tid, u8 ps, int wait_ack, u8 om_info)
{
int ret = _FAIL;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl, *qc;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 a4_shift;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
/* RTW_INFO("%s\n", __FUNCTION__); */
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->hdrlen += 2;
pattrib->qos_en = _TRUE;
pattrib->eosp = 1;
pattrib->ack_policy = 0;
pattrib->mdata = 0;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
if (MLME_IS_AP(padapter))
SetFrDs(fctrl);
else if (MLME_IS_STA(padapter))
SetToDs(fctrl);
else if (MLME_IS_MESH(padapter)) {
SetToDs(fctrl);
SetFrDs(fctrl);
}
if (ps)
SetPwrMgt(fctrl);
if (pattrib->mdata)
SetMData(fctrl);
if (get_tofr_ds(fctrl) == 3) {
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr4, adapter_mac_addr(padapter), ETH_ALEN);
a4_shift = ETH_ALEN;
pattrib->hdrlen += ETH_ALEN;
} else {
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
a4_shift = 0;
}
qc = (unsigned short *)(pframe + pattrib->hdrlen - 2);
SetPriority(qc, tid);
SetEOSP(qc, pattrib->eosp);
SetAckpolicy(qc, pattrib->ack_policy);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_QOS_DATA_NULL);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr_qos) + a4_shift;
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos) + a4_shift;
#ifdef CONFIG_80211AX_HE
if (om_info) {
set_htc_order_bit(fctrl);
pattrib->rate = MGN_HE1SS_MCS0;
rtw_he_fill_htc(padapter, pattrib, (u32 *)pframe);
pframe = pframe + 4;
pattrib->pktlen = pattrib->pktlen + 4;
}
#endif
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
/*
* when wait_ms >0 , this function should be called at process context
* wait_ms == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
* wait_ms > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
* try_cnt means the maximal TX count to try
* da == NULL for station mode
*/
int issue_qos_nulldata(_adapter *padapter, unsigned char *da, u16 tid, u8 ps, int try_cnt, int wait_ms, u8 need_om)
{
int ret = _FAIL;
int i = 0;
systime start = rtw_get_current_time();
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
/* da == NULL, assum it's null data for sta to ap*/
if (da == NULL)
da = get_my_bssid(&(pmlmeinfo->network));
do {
ret = _issue_qos_nulldata(padapter, da, tid, ps, wait_ms > 0 ? _TRUE : _FALSE, need_om);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
goto exit;
#endif
}
if (try_cnt && wait_ms) {
if (da)
RTW_INFO(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
else
RTW_INFO(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
static int _issue_deauth(_adapter *padapter, unsigned char *da, unsigned short reason, u8 wait_ack, u8 key_type)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
int ret = _FAIL;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
/* RTW_INFO("%s to "MAC_FMT"\n", __func__, MAC_ARG(da)); */
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->retry_ctrl = _FALSE;
pattrib->key_type = key_type;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_DEAUTH);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
reason = cpu_to_le16(reason);
pframe = rtw_set_fixed_ie(pframe, _RSON_CODE_ , (unsigned char *)&reason, &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
int issue_deauth(_adapter *padapter, unsigned char *da, unsigned short reason)
{
RTW_INFO("%s reason(%u) to "MAC_FMT"\n", __func__, reason, MAC_ARG(da));
return _issue_deauth(padapter, da, reason, _FALSE, IEEE80211W_RIGHT_KEY);
}
#ifdef CONFIG_IEEE80211W
int issue_deauth_11w(_adapter *padapter, unsigned char *da, unsigned short reason, u8 key_type)
{
RTW_INFO("%s to "MAC_FMT"\n", __func__, MAC_ARG(da));
return _issue_deauth(padapter, da, reason, _FALSE, key_type);
}
#endif /* CONFIG_IEEE80211W */
/*
* wait_ms == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
* wait_ms > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
* try_cnt means the maximal TX count to try
*/
int issue_deauth_ex(_adapter *padapter, u8 *da, unsigned short reason, int try_cnt,
int wait_ms)
{
int ret = _FAIL;
int i = 0;
systime start = rtw_get_current_time();
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
do {
ret = _issue_deauth(padapter, da, reason, wait_ms > 0 ? _TRUE : _FALSE, IEEE80211W_RIGHT_KEY);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
goto exit;
#endif
}
if (try_cnt && wait_ms) {
if (da)
RTW_INFO(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
else
RTW_INFO(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
static int _issue_disassoc(_adapter *padapter, unsigned char *da, unsigned short reason, u8 wait_ack, u8 key_type)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
int ret = _FAIL;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
/* RTW_INFO("%s to "MAC_FMT"\n", __func__, MAC_ARG(da)); */
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->retry_ctrl = _FALSE;
pattrib->key_type = key_type;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_DISASSOC);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
reason = cpu_to_le16(reason);
pframe = rtw_set_fixed_ie(pframe, _RSON_CODE_ , (unsigned char *)&reason, &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
int issue_disassoc(_adapter *padapter, unsigned char *da, unsigned short reason)
{
RTW_INFO("%s reason(%u) to "MAC_FMT"\n", __func__, reason, MAC_ARG(da));
return _issue_disassoc(padapter, da, reason, _FALSE, IEEE80211W_RIGHT_KEY);
}
void issue_action_spct_ch_switch(_adapter *padapter, u8 *ra, u8 new_ch, u8 ch_offset)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
RTW_INFO(FUNC_NDEV_FMT" ra="MAC_FMT", ch:%u, offset:%u\n",
FUNC_NDEV_ARG(padapter->pnetdev), MAC_ARG(ra), new_ch, ch_offset);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, ra, ETH_ALEN); /* RA */
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN); /* TA */
_rtw_memcpy(pwlanhdr->addr3, ra, ETH_ALEN); /* DA = RA */
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
/* category, action */
{
u8 category, action;
category = RTW_WLAN_CATEGORY_SPECTRUM_MGMT;
action = RTW_WLAN_ACTION_SPCT_CHL_SWITCH;
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
}
pframe = rtw_set_ie_ch_switch(pframe, &(pattrib->pktlen), 0, new_ch, 0);
pframe = rtw_set_ie_secondary_ch_offset(pframe, &(pattrib->pktlen),
hal_ch_offset_to_secondary_ch_offset(ch_offset));
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
#ifdef CONFIG_IEEE80211W
void issue_action_SA_Query(_adapter *padapter, unsigned char *raddr, unsigned char action, unsigned short tid, u8 key_type)
{
u8 category = RTW_WLAN_CATEGORY_SA_QUERY;
u16 reason_code;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
u8 *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
u16 *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
RTW_INFO("%s, %04x\n", __FUNCTION__, tid);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_INFO("%s: alloc_mgtxmitframe fail\n", __FUNCTION__);
return;
}
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->key_type = key_type;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
if (raddr)
_rtw_memcpy(pwlanhdr->addr1, raddr, ETH_ALEN);
else
_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &category, &pattrib->pktlen);
pframe = rtw_set_fixed_ie(pframe, 1, &action, &pattrib->pktlen);
switch (action) {
case 0: /* SA Query req */
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)&pmlmeext->sa_query_seq, &pattrib->pktlen);
pmlmeext->sa_query_seq++;
/* send sa query request to AP, AP should reply sa query response in 1 second */
if (pattrib->key_type == IEEE80211W_RIGHT_KEY) {
psta = rtw_get_stainfo(pstapriv, pwlanhdr->addr1);
if (psta != NULL) {
/* RTW_INFO("%s, %d, set dot11w_expire_timer\n", __func__, __LINE__); */
_set_timer(&psta->dot11w_expire_timer, 1000);
}
}
break;
case 1: /* SA Query rsp */
/* RTW_INFO("rtw_set_fixed_ie, %04x\n", tid); */
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)&tid, &pattrib->pktlen);
break;
default:
break;
}
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
#endif /* CONFIG_IEEE80211W */
/**
* issue_action_ba - internal function to TX Block Ack action frame
* @padapter: the adapter to TX
* @raddr: receiver address
* @action: Block Ack Action
* @tid: tid
* @size: the announced AMPDU buffer size. used by ADDBA_RESP
* @paddba_req: used by ADDBA_RESP
* @status: status/reason code. used by ADDBA_RESP, DELBA
* @initiator: if we are the initiator of AMPDU association. used by DELBA
* @wait_ack: used xmit ack
*
* Returns:
* _SUCCESS: No xmit ack is used or acked
* _FAIL: not acked when using xmit ack
*/
static int issue_action_ba(_adapter *padapter, unsigned char *raddr,
unsigned char action, u8 tid, u8 size,
struct ADDBA_request *paddba_req, u16 status,
u8 initiator, int wait_ack)
{
int ret = _FAIL;
u8 category = RTW_WLAN_CATEGORY_BACK;
u16 start_seq;
u16 BA_para_set;
u16 BA_timeout_value;
u16 BA_starting_seqctrl;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
u8 *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
u16 *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
#ifdef CONFIG_80211N_HT
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
/* _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN); */
_rtw_memcpy(pwlanhdr->addr1, raddr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
if (category == 3) {
switch (action) {
case RTW_WLAN_ACTION_ADDBA_REQ:
do {
pmlmeinfo->dialogToken++;
} while (pmlmeinfo->dialogToken == 0);
pframe = rtw_set_fixed_ie(pframe, 1, &(pmlmeinfo->dialogToken), &(pattrib->pktlen));
BA_para_set = (0x1002 | ((tid & 0xf) << 2)); /* immediate ack & 64 buffer size */
#ifdef CONFIG_TX_AMSDU
if (padapter->tx_amsdu >= 1) /* TX AMSDU enabled */
BA_para_set |= BIT(0);
else /* TX AMSDU disabled */
BA_para_set &= ~BIT(0);
#endif
psta = rtw_get_stainfo(pstapriv, raddr);
if (psta != NULL) {
if (psta->flags & WLAN_STA_AMSDU_DISABLE)
BA_para_set &= ~BIT(0);
}
BA_para_set = cpu_to_le16(BA_para_set);
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(BA_para_set)), &(pattrib->pktlen));
/* BA_timeout_value = 0xffff; */ /* max: 65535 TUs(~ 65 ms) */
BA_timeout_value = 5000;/* ~ 5ms */
BA_timeout_value = cpu_to_le16(BA_timeout_value);
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(BA_timeout_value)), &(pattrib->pktlen));
/* if ((psta = rtw_get_stainfo(pstapriv, pmlmeinfo->network.MacAddress)) != NULL) */
psta = rtw_get_stainfo(pstapriv, raddr);
if (psta != NULL) {
start_seq = (psta->sta_xmitpriv.txseq_tid[tid & 0x07] & 0xfff) + 1;
RTW_INFO("BA_starting_seqctrl = %d for TID=%d\n", start_seq, tid & 0x07);
psta->BA_starting_seqctrl[tid & 0x07] = start_seq;
BA_starting_seqctrl = start_seq << 4;
BA_starting_seqctrl = cpu_to_le16(BA_starting_seqctrl);
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(BA_starting_seqctrl)), &(pattrib->pktlen));
}
break;
case RTW_WLAN_ACTION_ADDBA_RESP:
pframe = rtw_set_fixed_ie(pframe, 1, &(paddba_req->dialog_token), &(pattrib->pktlen));
status = cpu_to_le16(status);
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&status), &(pattrib->pktlen));
BA_para_set = le16_to_cpu(paddba_req->BA_para_set);
BA_para_set &= ~IEEE80211_ADDBA_PARAM_TID_MASK;
BA_para_set |= (tid << 2) & IEEE80211_ADDBA_PARAM_TID_MASK;
BA_para_set &= ~RTW_IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK;
BA_para_set |= (size << 6) & RTW_IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK;
if (!padapter->registrypriv.wifi_spec) {
if (pregpriv->rx_ampdu_amsdu == 0) /* disabled */
BA_para_set &= ~BIT(0);
else if (pregpriv->rx_ampdu_amsdu == 1) /* enabled */
BA_para_set |= BIT(0);
}
psta = rtw_get_stainfo(pstapriv, raddr);
if (psta != NULL) {
if (psta->flags & WLAN_STA_AMSDU_DISABLE)
BA_para_set &= ~BIT(0);
}
BA_para_set = cpu_to_le16(BA_para_set);
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(BA_para_set)), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(paddba_req->BA_timeout_value)), &(pattrib->pktlen));
break;
case RTW_WLAN_ACTION_DELBA:
BA_para_set = 0;
BA_para_set |= (tid << 12) & IEEE80211_DELBA_PARAM_TID_MASK;
BA_para_set |= (initiator << 11) & IEEE80211_DELBA_PARAM_INITIATOR_MASK;
BA_para_set = cpu_to_le16(BA_para_set);
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(BA_para_set)), &(pattrib->pktlen));
status = cpu_to_le16(status);
pframe = rtw_set_fixed_ie(pframe, 2, (unsigned char *)(&(status)), &(pattrib->pktlen));
break;
default:
break;
}
}
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
#endif /* CONFIG_80211N_HT */
return ret;
}
/**
* issue_addba_req - TX ADDBA_REQ
* @adapter: the adapter to TX
* @ra: receiver address
* @tid: tid
*/
inline void issue_addba_req(_adapter *adapter, unsigned char *ra, u8 tid)
{
issue_action_ba(adapter, ra, RTW_WLAN_ACTION_ADDBA_REQ
, tid
, 0 /* unused */
, NULL /* unused */
, 0 /* unused */
, 0 /* unused */
, _FALSE
);
RTW_INFO(FUNC_ADPT_FMT" ra="MAC_FMT" tid=%u\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(ra), tid);
}
/**
* issue_addba_rsp - TX ADDBA_RESP
* @adapter: the adapter to TX
* @ra: receiver address
* @tid: tid
* @status: status code
* @size: the announced AMPDU buffer size
* @paddba_req: used by ADDBA_RESP
*/
inline void issue_addba_rsp(_adapter *adapter, unsigned char *ra, u8 tid,
u16 status, u8 size,
struct ADDBA_request *paddba_req)
{
issue_action_ba(adapter, ra, RTW_WLAN_ACTION_ADDBA_RESP
, tid
, size
, paddba_req
, status
, 0 /* unused */
, _FALSE
);
RTW_INFO(FUNC_ADPT_FMT" ra="MAC_FMT" status=%u, tid=%u, size=%u\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(ra), status, tid, size);
}
/**
* issue_addba_rsp_wait_ack - TX ADDBA_RESP and wait ack
* @adapter: the adapter to TX
* @ra: receiver address
* @tid: tid
* @status: status code
* @size: the announced AMPDU buffer size
* @paddba_req: used by ADDBA_RESP
* @try_cnt: the maximal TX count to try
* @wait_ms: == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
* > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
*/
inline u8 issue_addba_rsp_wait_ack(_adapter *adapter, unsigned char *ra, u8 tid,
u16 status, u8 size,
struct ADDBA_request *paddba_req, int try_cnt,
int wait_ms)
{
int ret = _FAIL;
int i = 0;
systime start = rtw_get_current_time();
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(adapter)))
goto exit;
do {
ret = issue_action_ba(adapter, ra, RTW_WLAN_ACTION_ADDBA_RESP
, tid
, size
, paddba_req
, status
, 0 /* unused */
, _TRUE
);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
/* goto exit; */
#endif
}
if (try_cnt && wait_ms) {
RTW_INFO(FUNC_ADPT_FMT" ra="MAC_FMT" status:=%u tid=%u size:%u%s, %d/%d in %u ms\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(ra), status, tid, size
, ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
/**
* issue_del_ba - TX DELBA
* @adapter: the adapter to TX
* @ra: receiver address
* @tid: tid
* @reason: reason code
* @initiator: if we are the initiator of AMPDU association. used by DELBA
*/
inline void issue_del_ba(_adapter *adapter, unsigned char *ra, u8 tid, u16 reason, u8 initiator)
{
issue_action_ba(adapter, ra, RTW_WLAN_ACTION_DELBA
, tid
, 0 /* unused */
, NULL /* unused */
, reason
, initiator
, _FALSE
);
RTW_INFO(FUNC_ADPT_FMT" ra="MAC_FMT" reason=%u, tid=%u, initiator=%u\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(ra), reason, tid, initiator);
}
/**
* issue_del_ba_ex - TX DELBA with xmit ack options
* @adapter: the adapter to TX
* @ra: receiver address
* @tid: tid
* @reason: reason code
* @initiator: if we are the initiator of AMPDU association. used by DELBA
* @try_cnt: the maximal TX count to try
* @wait_ms: == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
* > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
*/
int issue_del_ba_ex(_adapter *adapter, unsigned char *ra, u8 tid, u16 reason, u8 initiator
, int try_cnt, int wait_ms)
{
int ret = _FAIL;
int i = 0;
systime start = rtw_get_current_time();
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(adapter)))
goto exit;
do {
ret = issue_action_ba(adapter, ra, RTW_WLAN_ACTION_DELBA
, tid
, 0 /* unused */
, NULL /* unused */
, reason
, initiator
, wait_ms > 0 ? _TRUE : _FALSE
);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
/* goto exit; */
#endif
}
if (try_cnt && wait_ms) {
RTW_INFO(FUNC_ADPT_FMT" ra="MAC_FMT" reason=%u, tid=%u, initiator=%u%s, %d/%d in %u ms\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(ra), reason, tid, initiator
, ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
void issue_action_BSSCoexistPacket(_adapter *padapter)
{
_list *plist, *phead;
unsigned char category, action;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct wlan_network *pnetwork = NULL;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
_queue *queue = &(pmlmepriv->scanned_queue);
u8 InfoContent[16] = {0};
u8 ICS[8][15];
#ifdef CONFIG_80211N_HT
if ((pmlmepriv->num_FortyMHzIntolerant == 0) && (pmlmepriv->num_sta_no_ht == 0))
return;
if (_TRUE == pmlmeinfo->bwmode_updated)
return;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return;
RTW_INFO("%s\n", __FUNCTION__);
category = RTW_WLAN_CATEGORY_PUBLIC;
action = ACT_PUBLIC_BSSCOEXIST;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
/* TODO calculate 40Mhz intolerant via ch and ch offset */
/* if (pmlmepriv->num_FortyMHzIntolerant > 0) */
{
u8 iedata = 0;
iedata |= BIT(2);/* 20 MHz BSS Width Request */
pframe = rtw_set_ie(pframe, EID_BSSCoexistence, 1, &iedata, &(pattrib->pktlen));
}
/* */
_rtw_memset(ICS, 0, sizeof(ICS));
if (pmlmepriv->num_sta_no_ht > 0) {
int i;
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
plist = get_next(phead);
while (1) {
int len;
u8 *p;
WLAN_BSSID_EX *pbss_network;
if (rtw_end_of_queue_search(phead, plist) == _TRUE)
break;
pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
plist = get_next(plist);
pbss_network = (WLAN_BSSID_EX *)&pnetwork->network;
p = rtw_get_ie(pbss_network->IEs + _FIXED_IE_LENGTH_, _HT_CAPABILITY_IE_, &len, pbss_network->IELength - _FIXED_IE_LENGTH_);
if ((p == NULL) || (len == 0)) { /* non-HT */
if ((pbss_network->Configuration.DSConfig <= 0) || (pbss_network->Configuration.DSConfig > 14))
continue;
ICS[0][pbss_network->Configuration.DSConfig] = 1;
if (ICS[0][0] == 0)
ICS[0][0] = 1;
}
}
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
for (i = 0; i < 8; i++) {
if (ICS[i][0] == 1) {
int j, k = 0;
InfoContent[k] = i;
/* SET_BSS_INTOLERANT_ELE_REG_CLASS(InfoContent,i); */
k++;
for (j = 1; j <= 14; j++) {
if (ICS[i][j] == 1) {
if (k < 16) {
InfoContent[k] = j; /* channel number */
/* SET_BSS_INTOLERANT_ELE_CHANNEL(InfoContent+k, j); */
k++;
}
}
}
pframe = rtw_set_ie(pframe, EID_BSSIntolerantChlReport, k, InfoContent, &(pattrib->pktlen));
}
}
}
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
#endif /* CONFIG_80211N_HT */
}
/* Spatial Multiplexing Powersave (SMPS) action frame */
int _issue_action_SM_PS(_adapter *padapter , unsigned char *raddr , u8 NewMimoPsMode , u8 wait_ack)
{
int ret = _FAIL;
unsigned char category = RTW_WLAN_CATEGORY_HT;
u8 action = RTW_WLAN_ACTION_HT_SM_PS;
u8 sm_power_control = 0;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (NewMimoPsMode == WLAN_HT_CAP_SM_PS_DISABLED) {
sm_power_control = sm_power_control & ~(BIT(0)); /* SM Power Save Enable = 0 SM Power Save Disable */
} else if (NewMimoPsMode == WLAN_HT_CAP_SM_PS_STATIC) {
sm_power_control = sm_power_control | BIT(0); /* SM Power Save Enable = 1 SM Power Save Enable */
sm_power_control = sm_power_control & ~(BIT(1)); /* SM Mode = 0 Static Mode */
} else if (NewMimoPsMode == WLAN_HT_CAP_SM_PS_DYNAMIC) {
sm_power_control = sm_power_control | BIT(0); /* SM Power Save Enable = 1 SM Power Save Enable */
sm_power_control = sm_power_control | BIT(1); /* SM Mode = 1 Dynamic Mode */
} else
return ret;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
return ret;
RTW_INFO("%s, sm_power_control=%u, NewMimoPsMode=%u\n", __FUNCTION__ , sm_power_control , NewMimoPsMode);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return ret;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, raddr, ETH_ALEN); /* RA */
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN); /* TA */
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN); /* DA = RA */
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
/* category, action */
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(sm_power_control), &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
if (ret != _SUCCESS)
RTW_INFO("%s, ack to\n", __func__);
return ret;
}
/*
* wait_ms == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
* wait_ms > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
* try_cnt means the maximal TX count to try
*/
int issue_action_SM_PS_wait_ack(_adapter *padapter, unsigned char *raddr, u8 NewMimoPsMode, int try_cnt, int wait_ms)
{
int ret = _FAIL;
int i = 0;
systime start = rtw_get_current_time();
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
do {
ret = _issue_action_SM_PS(padapter, raddr, NewMimoPsMode , wait_ms > 0 ? _TRUE : _FALSE);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
goto exit;
#endif
}
if (try_cnt && wait_ms) {
if (raddr)
RTW_INFO(FUNC_ADPT_FMT" to "MAC_FMT", %s , %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(raddr),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
else
RTW_INFO(FUNC_ADPT_FMT", %s , %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
int issue_action_SM_PS(_adapter *padapter , unsigned char *raddr , u8 NewMimoPsMode)
{
RTW_INFO("%s to "MAC_FMT"\n", __func__, MAC_ARG(raddr));
return _issue_action_SM_PS(padapter, raddr, NewMimoPsMode , _FALSE);
}
#ifdef ROKU_PRIVATE
int issue_action_find_remote(_adapter *padapter)
{
int ret = _FAIL;
u8 category = RTW_WLAN_CATEGORY_P2P;
u16 start_seq;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
u8 *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
u16 *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 ROKU_OUI[] = {0x00, 0x0d, 0x4b};
u8 vendor_spec_subtype = 0x7f;
u8 p2p_action_subtype = 0x01;
u8 p2p_action_dialog = 0x03;
u8 reserved_1 = 0xaa;
u8 reserved_2[] = {0xab, 0x01, 0x01};
u8 len = 0;
if (rtw_rfctl_is_tx_blocked_by_ch_waiting(adapter_to_rfctl(padapter)))
goto exit;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(padapter), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &category, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 3, ROKU_OUI, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &vendor_spec_subtype, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &p2p_action_subtype, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &p2p_action_dialog, &(pattrib->pktlen));
/* set remote len and MAC address */
pframe = rtw_set_fixed_ie(pframe, 1, &reserved_1, &(pattrib->pktlen));
len = pwdinfo->num_of_remote * ETH_ALEN;
pframe = rtw_set_fixed_ie(pframe, 1, &len, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, len, pwdinfo->remote_mac_address, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 3, reserved_2, &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
#endif
/**
* _send_delba_sta_tid - Cancel the AMPDU association for the specific @sta, @tid
* @adapter: the adapter to which @sta belongs
* @initiator: if we are the initiator of AMPDU association
* @sta: the sta to be checked
* @tid: the tid to be checked
* @force: cancel and send DELBA even when no AMPDU association is setup
* @wait_ack: send delba with xmit ack (valid when initiator == 0)
*
* Returns:
* _FAIL if sta is NULL
* when initiator is 1, always _SUCCESS
* when initiator is 0, _SUCCESS if DELBA is acked
*/
static unsigned int _send_delba_sta_tid(_adapter *adapter, u8 initiator, struct sta_info *sta, u8 tid
, u8 force, int wait_ack)
{
int ret = _SUCCESS;
if (sta == NULL) {
ret = _FAIL;
goto exit;
}
if (initiator == 0) {
/* recipient */
if (force || sta->recvreorder_ctrl[tid].enable == _TRUE) {
u8 ampdu_size_bak = sta->recvreorder_ctrl[tid].ampdu_size;
sta->recvreorder_ctrl[tid].enable = _FALSE;
sta->recvreorder_ctrl[tid].ampdu_size = RX_AMPDU_SIZE_INVALID;
if (rtw_del_rx_ampdu_test_trigger_no_tx_fail())
ret = _FAIL;
else if (wait_ack)
ret = issue_del_ba_ex(adapter, sta->phl_sta->mac_addr, tid, 37, initiator, 3, 1);
else
issue_del_ba(adapter, sta->phl_sta->mac_addr, tid, 37, initiator);
if (ret == _FAIL && sta->recvreorder_ctrl[tid].enable == _FALSE)
sta->recvreorder_ctrl[tid].ampdu_size = ampdu_size_bak;
}
} else if (initiator == 1) {
/* originator */
#ifdef CONFIG_80211N_HT
if (force || sta->htpriv.agg_enable_bitmap & BIT(tid)) {
sta->htpriv.agg_enable_bitmap &= ~BIT(tid);
sta->htpriv.candidate_tid_bitmap &= ~BIT(tid);
issue_del_ba(adapter, sta->phl_sta->mac_addr, tid, 37, initiator);
}
#endif
}
exit:
return ret;
}
inline unsigned int send_delba_sta_tid(_adapter *adapter, u8 initiator, struct sta_info *sta, u8 tid
, u8 force)
{
return _send_delba_sta_tid(adapter, initiator, sta, tid, force, 0);
}
inline unsigned int send_delba_sta_tid_wait_ack(_adapter *adapter, u8 initiator, struct sta_info *sta, u8 tid
, u8 force)
{
return _send_delba_sta_tid(adapter, initiator, sta, tid, force, 1);
}
unsigned int send_delba(_adapter *padapter, u8 initiator, u8 *addr)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta = NULL;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u16 tid;
if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
if (!(pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS))
return _SUCCESS;
psta = rtw_get_stainfo(pstapriv, addr);
if (psta == NULL)
return _SUCCESS;
#if 0
RTW_INFO("%s:%s\n", __func__, (initiator == 0) ? "RX_DIR" : "TX_DIR");
if (initiator == 1) /* originator */
RTW_INFO("tx agg_enable_bitmap(0x%08x)\n", psta->htpriv.agg_enable_bitmap);
#endif
for (tid = 0; tid < TID_NUM; tid++)
send_delba_sta_tid(padapter, initiator, psta, tid, 0);
return _SUCCESS;
}
unsigned int send_beacon(_adapter *padapter)
{
#ifdef RTW_PHL_BCN
/* bypass TX BCN queue because op ch is switching/waiting */
if (check_fwstate(&padapter->mlmepriv, WIFI_OP_CH_SWITCHING)
|| IS_CH_WAITING(adapter_to_rfctl(padapter))
)
return _SUCCESS;
issue_beacon(padapter, 0);
/* maybe need some mechanism to check bcn ready here */
return _SUCCESS;
#else
#if defined(CONFIG_PCI_HCI) && !defined(CONFIG_PCI_BCN_POLLING)
/* bypass TX BCN queue because op ch is switching/waiting */
if (check_fwstate(&padapter->mlmepriv, WIFI_OP_CH_SWITCHING)
|| IS_CH_WAITING(adapter_to_rfctl(padapter))
)
return _SUCCESS;
/* RTW_INFO("%s\n", __FUNCTION__); */
rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
issue_beacon(padapter, 0);
return _SUCCESS;
#endif
/* CONFIG_PCI_BCN_POLLING is for pci interface beacon polling mode */
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)|| defined(CONFIG_PCI_BCN_POLLING)
u8 bxmitok = _FALSE;
int issue = 0;
int poll = 0;
systime start = rtw_get_current_time();
/* bypass TX BCN queue because op ch is switching/waiting */
if (check_fwstate(&padapter->mlmepriv, WIFI_OP_CH_SWITCHING)
|| IS_CH_WAITING(adapter_to_rfctl(padapter))
)
return _SUCCESS;
rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
do {
#if defined(CONFIG_PCI_BCN_POLLING)
issue_beacon(padapter, 0);
#else
issue_beacon(padapter, 100);
#endif
issue++;
do {
#if defined(CONFIG_PCI_BCN_POLLING)
rtw_msleep_os(1);
#else
rtw_yield_os();
#endif
rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8 *)(&bxmitok));
poll++;
} while ((poll % 10) != 0 && _FALSE == bxmitok && !RTW_CANNOT_RUN(adapter_to_dvobj(padapter)));
#if defined(CONFIG_PCI_BCN_POLLING)
rtw_hal_unmap_beacon_icf(padapter);
#endif
} while (bxmitok == _FALSE && (issue < 100) && !RTW_CANNOT_RUN(adapter_to_dvobj(padapter)));
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
return _FAIL;
if (_FALSE == bxmitok) {
RTW_INFO("%s fail! %u ms\n", __FUNCTION__, rtw_get_passing_time_ms(start));
return _FAIL;
} else {
u32 passing_time = rtw_get_passing_time_ms(start);
if (passing_time > 100 || issue > 3)
RTW_INFO("%s success, issue:%d, poll:%d, %u ms\n", __FUNCTION__, issue, poll, rtw_get_passing_time_ms(start));
else if (0)
RTW_INFO("%s success, issue:%d, poll:%d, %u ms\n", __FUNCTION__, issue, poll, rtw_get_passing_time_ms(start));
return _SUCCESS;
}
#endif /*defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)*/
#endif /* RTW_PHL_BCN */
}
/****************************************************************************
Following are some utitity fuctions for WiFi MLME
*****************************************************************************/
BOOLEAN IsLegal5GChannel(
_adapter *adapter,
u8 channel)
{
int i = 0;
u8 Channel_5G[45] = {36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58,
60, 62, 64, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122,
124, 126, 128, 130, 132, 134, 136, 138, 140, 149, 151, 153, 155, 157, 159,
161, 163, 165
};
for (i = 0; i < sizeof(Channel_5G); i++)
if (channel == Channel_5G[i])
return _TRUE;
return _FALSE;
}
/* collect bss info from Beacon and Probe request/response frames. */
u8 collect_bss_info(_adapter *padapter, union recv_frame *precv_frame, WLAN_BSSID_EX *bssid)
{
int i;
sint len;
u8 *p;
u8 rf_path;
u16 val16, subtype;
u8 *pframe = precv_frame->u.hdr.rx_data;
u32 packet_len = precv_frame->u.hdr.len;
u8 ie_offset;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
len = packet_len - sizeof(struct rtw_ieee80211_hdr_3addr);
if (len > MAX_IE_SZ) {
/* RTW_INFO("IE too long for survey event\n"); */
return _FAIL;
}
_rtw_memset(bssid, 0, sizeof(WLAN_BSSID_EX));
subtype = get_frame_sub_type(pframe);
if (subtype == WIFI_BEACON) {
bssid->Reserved[0] = BSS_TYPE_BCN;
ie_offset = _BEACON_IE_OFFSET_;
} else {
/* FIXME : more type */
if (subtype == WIFI_PROBERSP) {
ie_offset = _PROBERSP_IE_OFFSET_;
bssid->Reserved[0] = BSS_TYPE_PROB_RSP;
} else if (subtype == WIFI_PROBEREQ) {
ie_offset = _PROBEREQ_IE_OFFSET_;
bssid->Reserved[0] = BSS_TYPE_PROB_REQ;
} else {
bssid->Reserved[0] = BSS_TYPE_UNDEF;
ie_offset = _FIXED_IE_LENGTH_;
}
}
bssid->Length = sizeof(WLAN_BSSID_EX) - MAX_IE_SZ + len;
/* below is to copy the information element */
bssid->IELength = len;
_rtw_memcpy(bssid->IEs, (pframe + sizeof(struct rtw_ieee80211_hdr_3addr)), bssid->IELength);
/*RTW_WKARD_CORE_RSSI_V1 - GEORGIA MUST REFINE*/
/* bssid->PhyInfo.rssi = precv_frame->u.hdr.attrib.SignalStrength; */ /* 0-100 index. */
bssid->PhyInfo.SignalQuality = precv_frame->u.hdr.attrib.phy_info.signal_quality;/* in percentage */
bssid->PhyInfo.SignalStrength = precv_frame->u.hdr.attrib.phy_info.signal_strength;/* in percentage */
bssid->PhyInfo.rssi = precv_frame->u.hdr.attrib.phy_info.recv_signal_power;/*dbm*/
if (precv_frame->u.hdr.attrib.data_rate >= DESC_RATE11M) {
bssid->PhyInfo.is_cck_rate = 0;
for (rf_path = 0; rf_path < GET_HAL_RFPATH_NUM(dvobj); rf_path++)
bssid->PhyInfo.rx_snr[rf_path] =
precv_frame->u.hdr.attrib.phy_info.rx_snr[rf_path];
} else
bssid->PhyInfo.is_cck_rate = 1;
/* checking SSID */
p = rtw_get_ie(bssid->IEs + ie_offset, _SSID_IE_, &len, bssid->IELength - ie_offset);
if (p == NULL) {
RTW_INFO("marc: cannot find SSID for survey event\n");
return _FAIL;
}
if (*(p + 1)) {
if (len > NDIS_802_11_LENGTH_SSID) {
RTW_INFO("%s()-%d: IE too long (%d) for survey event\n", __FUNCTION__, __LINE__, len);
return _FAIL;
}
_rtw_memcpy(bssid->Ssid.Ssid, (p + 2), *(p + 1));
bssid->Ssid.SsidLength = *(p + 1);
} else
bssid->Ssid.SsidLength = 0;
_rtw_memset(bssid->SupportedRates, 0, NDIS_802_11_LENGTH_RATES_EX);
/* checking rate info... */
i = 0;
p = rtw_get_ie(bssid->IEs + ie_offset, _SUPPORTEDRATES_IE_, &len, bssid->IELength - ie_offset);
if (p != NULL) {
if (len > NDIS_802_11_LENGTH_RATES_EX) {
RTW_INFO("%s()-%d: IE too long (%d) for survey event\n", __FUNCTION__, __LINE__, len);
return _FAIL;
}
#ifndef RTW_PHL_TEST_FPGA
if (rtw_validate_value(_SUPPORTEDRATES_IE_, p+2, len) == _FALSE) {
rtw_absorb_ssid_ifneed(padapter, bssid, pframe);
RTW_DBG_DUMP("Invalidated Support Rate IE --", p, len+2);
return _FAIL;
}
#endif
_rtw_memcpy(bssid->SupportedRates, (p + 2), len);
i = len;
}
p = rtw_get_ie(bssid->IEs + ie_offset, _EXT_SUPPORTEDRATES_IE_, &len, bssid->IELength - ie_offset);
if (p != NULL) {
if (len > (NDIS_802_11_LENGTH_RATES_EX - i)) {
RTW_INFO("%s()-%d: IE too long (%d) for survey event\n", __FUNCTION__, __LINE__, len);
return _FAIL;
}
#ifndef RTW_PHL_TEST_FPGA
if (rtw_validate_value(_EXT_SUPPORTEDRATES_IE_, p+2, len) == _FALSE) {
rtw_absorb_ssid_ifneed(padapter, bssid, pframe);
RTW_DBG_DUMP("Invalidated EXT Support Rate IE --", p, len+2);
return _FAIL;
}
#endif
_rtw_memcpy(bssid->SupportedRates + i, (p + 2), len);
}
#ifdef CONFIG_P2P
if (subtype == WIFI_PROBEREQ) {
u8 *p2p_ie;
u32 p2p_ielen;
/* Set Listion Channel */
p2p_ie = rtw_get_p2p_ie(bssid->IEs, bssid->IELength, NULL, &p2p_ielen);
if (p2p_ie) {
u32 attr_contentlen = 0;
u8 listen_ch[5] = { 0x00 };
rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_LISTEN_CH, listen_ch, &attr_contentlen);
bssid->Configuration.DSConfig = listen_ch[4];
} else {
/* use current channel */
bssid->Configuration.DSConfig = padapter->mlmeextpriv.chandef.chan;
RTW_INFO("%s()-%d: Cannot get p2p_ie. set DSconfig to op_ch(%d)\n", __FUNCTION__, __LINE__, bssid->Configuration.DSConfig);
}
/* FIXME */
bssid->InfrastructureMode = Ndis802_11Infrastructure;
_rtw_memcpy(bssid->MacAddress, get_addr2_ptr(pframe), ETH_ALEN);
bssid->Privacy = 1;
return _SUCCESS;
}
#endif /* CONFIG_P2P */
if (bssid->IELength < 12)
return _FAIL;
/* Checking for DSConfig */
p = rtw_get_ie(bssid->IEs + ie_offset, _DSSET_IE_, &len, bssid->IELength - ie_offset);
bssid->Configuration.DSConfig = 0;
bssid->Configuration.Length = 0;
if (p)
bssid->Configuration.DSConfig = *(p + 2);
else {
/* In 5G, some ap do not have DSSET IE */
/* checking HT info for channel */
p = rtw_get_ie(bssid->IEs + ie_offset, _HT_ADD_INFO_IE_, &len, bssid->IELength - ie_offset);
if (p) {
struct HT_info_element *HT_info = (struct HT_info_element *)(p + 2);
bssid->Configuration.DSConfig = HT_info->primary_channel;
} else {
/* use current channel */
bssid->Configuration.DSConfig = rtw_get_oper_ch(padapter);
}
}
_rtw_memcpy(&bssid->Configuration.BeaconPeriod, rtw_get_beacon_interval_from_ie(bssid->IEs), 2);
bssid->Configuration.BeaconPeriod = le32_to_cpu(bssid->Configuration.BeaconPeriod);
val16 = rtw_get_capability((WLAN_BSSID_EX *)bssid);
if ((val16 & 0x03) == cap_ESS) {
bssid->InfrastructureMode = Ndis802_11Infrastructure;
_rtw_memcpy(bssid->MacAddress, get_addr2_ptr(pframe), ETH_ALEN);
} else if ((val16 & 0x03) == cap_IBSS){
bssid->InfrastructureMode = Ndis802_11IBSS;
_rtw_memcpy(bssid->MacAddress, GetAddr3Ptr(pframe), ETH_ALEN);
} else if ((val16 & 0x03) == 0x00){
u8 *mesh_id_ie, *mesh_conf_ie;
sint mesh_id_ie_len, mesh_conf_ie_len;
mesh_id_ie = rtw_get_ie(bssid->IEs + ie_offset, WLAN_EID_MESH_ID, &mesh_id_ie_len, bssid->IELength - ie_offset);
mesh_conf_ie = rtw_get_ie(bssid->IEs + ie_offset, WLAN_EID_MESH_CONFIG, &mesh_conf_ie_len, bssid->IELength - ie_offset);
if (mesh_id_ie || mesh_conf_ie) {
if (!mesh_id_ie) {
RTW_INFO("cannot find Mesh ID for survey event\n");
return _FAIL;
}
if (mesh_id_ie_len) {
if (mesh_id_ie_len > NDIS_802_11_LENGTH_SSID) {
RTW_INFO("Mesh ID too long (%d) for survey event\n", mesh_id_ie_len);
return _FAIL;
}
_rtw_memcpy(bssid->mesh_id.Ssid, (mesh_id_ie + 2), mesh_id_ie_len);
bssid->mesh_id.SsidLength = mesh_id_ie_len;
} else
bssid->mesh_id.SsidLength = 0;
if (!mesh_conf_ie) {
RTW_INFO("cannot find Mesh config for survey event\n");
return _FAIL;
}
if (mesh_conf_ie_len != 7) {
RTW_INFO("invalid Mesh conf IE len (%d) for survey event\n", mesh_conf_ie_len);
return _FAIL;
}
bssid->InfrastructureMode = Ndis802_11_mesh;
_rtw_memcpy(bssid->MacAddress, GetAddr3Ptr(pframe), ETH_ALEN);
} else {
/* default cases */
bssid->InfrastructureMode = Ndis802_11IBSS;
_rtw_memcpy(bssid->MacAddress, GetAddr3Ptr(pframe), ETH_ALEN);
}
}
if (val16 & BIT(4))
bssid->Privacy = 1;
else
bssid->Privacy = 0;
bssid->Configuration.ATIMWindow = 0;
/* 20/40 BSS Coexistence check */
if ((pregistrypriv->wifi_spec == 1) && (_FALSE == pmlmeinfo->bwmode_updated)) {
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
#ifdef CONFIG_80211N_HT
p = rtw_get_ie(bssid->IEs + ie_offset, _HT_CAPABILITY_IE_, &len, bssid->IELength - ie_offset);
if (p && len > 0) {
struct HT_caps_element *pHT_caps;
pHT_caps = (struct HT_caps_element *)(p + 2);
if (pHT_caps->u.HT_cap_element.HT_caps_info & BIT(14))
pmlmepriv->num_FortyMHzIntolerant++;
} else
pmlmepriv->num_sta_no_ht++;
#endif /* CONFIG_80211N_HT */
}
#if defined(DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) & 1
if (strcmp(bssid->Ssid.Ssid, DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED) == 0) {
RTW_INFO("Receiving %s("MAC_FMT", DSConfig:%u) from ch%u with ss:%3u, sq:%3u, RawRSSI:%d\n"
, bssid->Ssid.Ssid, MAC_ARG(bssid->MacAddress), bssid->Configuration.DSConfig
, rtw_get_oper_ch(padapter)
, bssid->PhyInfo.SignalStrength, bssid->PhyInfo.SignalQuality, bssid->PhyInfo.rssi
);
}
#endif
/* mark bss info receving from nearby channel as SignalQuality 101 */
if (bssid->Configuration.DSConfig != rtw_get_oper_ch(padapter))
bssid->PhyInfo.SignalQuality = 101;
#ifdef CONFIG_RTW_80211K
p = rtw_get_ie(bssid->IEs + ie_offset, _EID_RRM_EN_CAP_IE_, &len, bssid->IELength - ie_offset);
if (p)
_rtw_memcpy(bssid->PhyInfo.rm_en_cap, (p + 2), *(p + 1));
/* save freerun counter */
bssid->PhyInfo.free_cnt = precv_frame->u.hdr.attrib.free_cnt;
#endif
return _SUCCESS;
}
void start_create_ibss(_adapter *padapter)
{
unsigned short caps;
u8 val8;
u8 join_type;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)(&(pmlmeinfo->network));
u8 do_rfk = _FALSE;
pmlmeext->chandef.chan = (u8)pnetwork->Configuration.DSConfig;
pmlmeinfo->bcn_interval = get_beacon_interval(pnetwork);
/* update wireless mode */
update_wireless_mode(padapter);
/* udpate capability */
caps = rtw_get_capability((WLAN_BSSID_EX *)pnetwork);
update_capinfo(padapter, caps);
if (caps & cap_IBSS) { /* adhoc master */
/* set_opmode_cmd(padapter, adhoc); */ /* removed */
rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, NULL);
do_rfk = _TRUE;
/* switch channel */
set_channel_bwmode(padapter,
pmlmeext->chandef.chan,
CHAN_OFFSET_NO_EXT,
CHANNEL_WIDTH_20,
do_rfk);
beacon_timing_control(padapter);
/* issue beacon */
if (send_beacon(padapter) == _FAIL) {
report_join_res(padapter, -1, WLAN_STATUS_UNSPECIFIED_FAILURE);
pmlmeinfo->state = WIFI_FW_NULL_STATE;
} else {
rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, padapter->registrypriv.dev_network.MacAddress);
rtw_hal_rcr_set_chk_bssid(padapter, MLME_ADHOC_STARTED);
join_type = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
report_join_res(padapter, 1, WLAN_STATUS_SUCCESS);
pmlmeinfo->state |= WIFI_FW_ASSOC_SUCCESS;
rtw_indicate_connect(padapter);
}
} else {
RTW_INFO("start_create_ibss, invalid cap:%x\n", caps);
return;
}
}
void start_clnt_join(_adapter *padapter)
{
unsigned short caps;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)(&(pmlmeinfo->network));
int beacon_timeout;
u8 ASIX_ID[] = {0x00, 0x0E, 0xC6};
/* update wireless mode */
update_wireless_mode(padapter);
/* udpate capability */
caps = rtw_get_capability((WLAN_BSSID_EX *)pnetwork);
update_capinfo(padapter, caps);
/* check if sta is ASIX peer and fix IOT issue if it is. */
/*GEORGIA_TODO_FIXIT_HAL_DEP*/
if (_rtw_memcmp(get_my_bssid(&pmlmeinfo->network) , ASIX_ID , 3)) {
u8 iot_flag = _TRUE;
rtw_hal_set_hwreg(padapter, HW_VAR_ASIX_IOT, (u8 *)(&iot_flag));
}
if (caps & cap_ESS) {
rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, NULL);
#ifdef CONFIG_DEAUTH_BEFORE_CONNECT
/* Because of AP's not receiving deauth before */
/* AP may: 1)not response auth or 2)deauth us after link is complete */
/* issue deauth before issuing auth to deal with the situation */
/* Commented by Albert 2012/07/21 */
/* For the Win8 P2P connection, it will be hard to have a successful connection if this Wi-Fi doesn't connect to it. */
{
#ifdef CONFIG_P2P
_queue *queue = &(padapter->mlmepriv.scanned_queue);
_list *head = get_list_head(queue);
_list *pos = get_next(head);
struct wlan_network *scanned = NULL;
u8 ie_offset = 0;
bool has_p2p_ie = _FALSE;
_rtw_spinlock_bh(&(padapter->mlmepriv.scanned_queue.lock));
for (pos = get_next(head); !rtw_end_of_queue_search(head, pos); pos = get_next(pos)) {
scanned = LIST_CONTAINOR(pos, struct wlan_network, list);
if (_rtw_memcmp(&(scanned->network.Ssid), &(pnetwork->Ssid), sizeof(NDIS_802_11_SSID)) == _TRUE
&& _rtw_memcmp(scanned->network.MacAddress, pnetwork->MacAddress, sizeof(NDIS_802_11_MAC_ADDRESS)) == _TRUE
) {
ie_offset = (scanned->network.Reserved[0] == BSS_TYPE_PROB_REQ ? 0 : 12);
if (rtw_get_p2p_ie(scanned->network.IEs + ie_offset, scanned->network.IELength - ie_offset, NULL, NULL))
has_p2p_ie = _TRUE;
break;
}
}
_rtw_spinunlock_bh(&(padapter->mlmepriv.scanned_queue.lock));
if (scanned == NULL || rtw_end_of_queue_search(head, pos) || has_p2p_ie == _FALSE)
#endif /* CONFIG_P2P */
/* To avoid connecting to AP fail during resume process, change retry count from 5 to 1 */
issue_deauth_ex(padapter, pnetwork->MacAddress, WLAN_REASON_DEAUTH_LEAVING, 1, 100);
}
#endif /* CONFIG_DEAUTH_BEFORE_CONNECT */
/* here wait for receiving the beacon to start auth */
/* and enable a timer */
beacon_timeout = decide_wait_for_beacon_timeout(pmlmeinfo->bcn_interval);
set_link_timer(pmlmeext, beacon_timeout);
/*_set_timer(&padapter->mlmepriv.assoc_timer,
(REAUTH_TO * REAUTH_LIMIT) + (REASSOC_TO * REASSOC_LIMIT) + beacon_timeout);*/
set_assoc_timer(&padapter->mlmepriv,
(REAUTH_TO * REAUTH_LIMIT) + (REASSOC_TO * REASSOC_LIMIT) + beacon_timeout);
#ifdef CONFIG_RTW_80211R
if (rtw_ft_roam(padapter)) {
rtw_ft_start_clnt_join(padapter);
} else
#endif
{
rtw_sta_linking_test_set_start();
pmlmeinfo->state = WIFI_FW_AUTH_NULL | WIFI_FW_STATION_STATE;
}
#ifdef CONFIG_DRV_FAKE_AP
_set_timer(&adapter_to_dvobj(padapter)->fakeap.bcn_timer, 5);
#endif /* CONFIG_DRV_FAKE_AP */
} else if (caps & cap_IBSS) { /* adhoc client */
rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, NULL);
beacon_timing_control(padapter);
pmlmeinfo->state = WIFI_FW_ADHOC_STATE;
report_join_res(padapter, 1, WLAN_STATUS_SUCCESS);
} else {
/* RTW_INFO("marc: invalid cap:%x\n", caps); */
return;
}
}
void start_clnt_auth(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
pmlmeinfo->state &= (~WIFI_FW_AUTH_NULL);
pmlmeinfo->state |= WIFI_FW_AUTH_STATE;
pmlmeinfo->auth_seq = 1;
pmlmeinfo->reauth_count = 0;
pmlmeinfo->reassoc_count = 0;
pmlmeinfo->link_count = 0;
pmlmeext->retry = 0;
#ifdef CONFIG_RTW_80211R
if (rtw_ft_roam(padapter)) {
rtw_ft_set_status(padapter, RTW_FT_AUTHENTICATING_STA);
RTW_PRINT("start ft auth\n");
} else
#endif
RTW_PRINT("start auth\n");
#ifdef CONFIG_IOCTL_CFG80211
if (rtw_sec_chk_auth_type(padapter, MLME_AUTHTYPE_SAE)) {
if (rtw_cached_pmkid(padapter, get_my_bssid(&pmlmeinfo->network)) != -1) {
RTW_INFO("SAE: PMKSA cache entry found\n");
padapter->securitypriv.auth_alg = WLAN_AUTH_OPEN;
goto no_external_auth;
}
RTW_PRINT("SAE: start external auth\n");
rtw_cfg80211_external_auth_request(padapter, NULL);
return;
}
no_external_auth:
#endif /* CONFIG_IOCTL_CFG80211 */
issue_auth(padapter, NULL, 0);
set_link_timer(pmlmeext, REAUTH_TO);
}
void start_clnt_assoc(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
pmlmeinfo->state &= (~(WIFI_FW_AUTH_NULL | WIFI_FW_AUTH_STATE));
pmlmeinfo->state |= (WIFI_FW_AUTH_SUCCESS | WIFI_FW_ASSOC_STATE);
#ifdef CONFIG_RTW_80211R
if (rtw_ft_roam(padapter)
#ifdef CONFIG_RTW_WNM
|| rtw_wnm_btm_reassoc_req(padapter)
#endif
)
issue_reassocreq(padapter);
else
#endif
issue_assocreq(padapter);
set_link_timer(pmlmeext, REASSOC_TO);
}
unsigned int receive_disconnect(_adapter *padapter, unsigned char *MacAddr, unsigned short reason, u8 locally_generated)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (!(_rtw_memcmp(MacAddr, get_my_bssid(&pmlmeinfo->network), ETH_ALEN)))
return _SUCCESS;
RTW_INFO("%s\n", __FUNCTION__);
if ((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE) {
if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) {
if (report_del_sta_event(padapter, MacAddr, reason, _TRUE, locally_generated) != _FAIL)
pmlmeinfo->state = WIFI_FW_NULL_STATE;
} else if (pmlmeinfo->state & WIFI_FW_LINKING_STATE) {
if (report_join_res(padapter, -2, reason) != _FAIL)
pmlmeinfo->state = WIFI_FW_NULL_STATE;
} else
RTW_INFO(FUNC_ADPT_FMT" - End to Disconnect\n", FUNC_ADPT_ARG(padapter));
#ifdef CONFIG_RTW_80211R
rtw_ft_roam_status_reset(padapter);
#endif
#ifdef CONFIG_RTW_WNM
rtw_wnm_reset_btm_state(padapter);
#endif
}
return _SUCCESS;
}
/*
* Return channel index of struct dvobj_priv.rf_ctl.channel_set[] ==
* bss->Configuration.DSConfig, or -1 if not found.
*/
static int rtw_hidden_ssid_bss_count(_adapter *adapter, WLAN_BSSID_EX *bss)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
RT_CHANNEL_INFO *chset = rfctl->channel_set;
int chset_idx;
if (bss->InfrastructureMode != Ndis802_11Infrastructure)
return -1;
if (!hidden_ssid_ap(bss))
return -1;
chset_idx = rtw_chset_search_ch(chset, bss->Configuration.DSConfig);
if (chset_idx < 0)
return chset_idx;
chset[chset_idx].hidden_bss_cnt++;
return chset_idx;
}
/****************************************************************************
Following are the functions to report events
*****************************************************************************/
void report_survey_event(_adapter *padapter, union recv_frame *precv_frame)
{
struct cmd_obj *pcmd_obj;
u8 *pevtcmd;
u32 cmdsz;
struct survey_event *psurvey_evt;
struct rtw_evt_header *evt_hdr;
struct mlme_ext_priv *pmlmeext;
struct cmd_priv *pcmdpriv;
/* u8 *pframe = precv_frame->u.hdr.rx_data; */
/* uint len = precv_frame->u.hdr.len; */
#ifdef RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN
RT_CHANNEL_INFO *chset;
int ch_set_idx = -1;
#endif /* RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN */
if (!padapter)
return;
pmlmeext = &padapter->mlmeextpriv;
pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL)
return;
pcmd_obj->padapter = padapter;
cmdsz = (sizeof(struct survey_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
return;
}
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct survey_event);
evt_hdr->id = EVT_SURVEY;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
psurvey_evt = (struct survey_event *)(pevtcmd + sizeof(struct rtw_evt_header));
if (collect_bss_info(padapter, precv_frame, (WLAN_BSSID_EX *)&psurvey_evt->bss) == _FAIL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
rtw_mfree((u8 *)pevtcmd, cmdsz);
return;
}
#ifdef RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN
ch_set_idx = rtw_hidden_ssid_bss_count(padapter, &psurvey_evt->bss);
chset = adapter_to_chset(padapter);
if ((ch_set_idx >= 0) && (chset[ch_set_idx].hidden_bss_cnt == 1)
&& pmlmeext->sitesurvey_res.scan_param) {
struct rtw_phl_scan_param *phl_scan;
struct phl_module_op_info op_info = {0};
u8 ch;
int i;
phl_scan = pmlmeext->sitesurvey_res.scan_param;
ch = chset[ch_set_idx].ChannelNum;
for (i = 0; i < phl_scan->ch_num; i++) {
if (phl_scan->ch[i].channel != ch)
continue;
if (phl_scan->ch[i].type != RTW_PHL_SCAN_PASSIVE)
break;
op_info.op_code = FG_REQ_OP_NOTIFY_BCN_RCV;
op_info.inbuf = &ch;
op_info.inlen = 1;
rtw_phl_set_cur_cmd_info(GET_PHL_INFO(adapter_to_dvobj(padapter)),
padapter->phl_role->hw_band,
&op_info);
break;
}
}
#else /* !RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN */
rtw_hidden_ssid_bss_count(padapter, &psurvey_evt->bss);
#endif /* !RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN */
rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
pmlmeext->sitesurvey_res.bss_cnt++;
return;
}
/*
* @acs: aim to trigger channel selection
*/
void report_surveydone_event(_adapter *padapter, bool acs, u8 flags)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
if (flags & RTW_CMDF_DIRECTLY) {
struct surveydone_event survey_done;
survey_done.bss_cnt = pmlmeext->sitesurvey_res.bss_cnt;
survey_done.activate_ch_cnt = pmlmeext->sitesurvey_res.activate_ch_cnt;
survey_done.acs = acs;
RTW_INFO("survey done event(%x) band:%d for "ADPT_FMT"\n",
survey_done.bss_cnt, padapter->setband, ADPT_ARG(padapter));
rtw_surveydone_event_callback(padapter, (u8 *)&survey_done);
} else {
struct cmd_obj *pcmd_obj;
u8 *pevtcmd;
u32 cmdsz;
struct surveydone_event *psurveydone_evt;
struct rtw_evt_header *evt_hdr;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL)
return;
pcmd_obj->padapter = padapter;
cmdsz = (sizeof(struct surveydone_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
return;
}
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct surveydone_event);
evt_hdr->id = EVT_SURVEY_DONE;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
psurveydone_evt = (struct surveydone_event *)(pevtcmd + sizeof(struct rtw_evt_header));
psurveydone_evt->bss_cnt = pmlmeext->sitesurvey_res.bss_cnt;
psurveydone_evt->activate_ch_cnt = pmlmeext->sitesurvey_res.activate_ch_cnt;
psurveydone_evt->acs = acs;
RTW_INFO("survey done event(%x) band:%d for "ADPT_FMT"\n",
psurveydone_evt->bss_cnt, padapter->setband, ADPT_ARG(padapter));
rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
}
return;
}
u32 report_join_res(_adapter *padapter, int aid_res, u16 status)
{
struct cmd_obj *pcmd_obj;
u8 *pevtcmd;
u32 cmdsz;
struct joinbss_event *pjoinbss_evt;
struct rtw_evt_header *evt_hdr;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u32 ret = _FAIL;
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL)
goto exit;
pcmd_obj->padapter = padapter;
cmdsz = (sizeof(struct joinbss_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
goto exit;
}
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct joinbss_event);
evt_hdr->id = EVT_JOINBSS;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
pjoinbss_evt = (struct joinbss_event *)(pevtcmd + sizeof(struct rtw_evt_header));
_rtw_memcpy((unsigned char *)(&(pjoinbss_evt->network.network)), &(pmlmeinfo->network), sizeof(WLAN_BSSID_EX));
pjoinbss_evt->network.join_res = pjoinbss_evt->network.aid = aid_res;
RTW_INFO("report_join_res(%d, %u)\n", aid_res, status);
rtw_joinbss_event_prehandle(padapter, (u8 *)&pjoinbss_evt->network, status);
ret = rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
exit:
return ret;
}
void report_wmm_edca_update(_adapter *padapter)
{
struct cmd_obj *pcmd_obj;
u8 *pevtcmd;
u32 cmdsz;
struct wmm_event *pwmm_event;
struct rtw_evt_header *evt_hdr;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL)
return;
pcmd_obj->padapter = padapter;
cmdsz = (sizeof(struct wmm_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
return;
}
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct wmm_event);
evt_hdr->id = EVT_WMM_UPDATE;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
pwmm_event = (struct wmm_event *)(pevtcmd + sizeof(struct rtw_evt_header));
pwmm_event->wmm = 0;
rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
return;
}
u32 report_del_sta_event(_adapter *padapter, unsigned char *MacAddr, unsigned short reason, bool enqueue, u8 locally_generated)
{
struct cmd_obj *pcmd_obj;
u8 *pevtcmd;
u32 cmdsz;
struct sta_info *psta;
int mac_id = -1;
struct stadel_event *pdel_sta_evt;
struct rtw_evt_header *evt_hdr;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
/* prepare cmd parameter */
cmdsz = (sizeof(struct stadel_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
res = _FAIL;
goto exit;
}
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct stadel_event);
evt_hdr->id = EVT_DEL_STA;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
pdel_sta_evt = (struct stadel_event *)(pevtcmd + sizeof(struct rtw_evt_header));
_rtw_memcpy((unsigned char *)(&(pdel_sta_evt->macaddr)), MacAddr, ETH_ALEN);
_rtw_memcpy((unsigned char *)(pdel_sta_evt->rsvd), (unsigned char *)(&reason), 2);
psta = rtw_get_stainfo(&padapter->stapriv, MacAddr);
if (psta)
mac_id = (int)psta->phl_sta->macid;
else
mac_id = (-1);
pdel_sta_evt->mac_id = mac_id;
pdel_sta_evt->locally_generated = locally_generated;
if (!enqueue) {
/* do directly */
rtw_stadel_event_callback(padapter, (u8 *)pdel_sta_evt);
rtw_mfree(pevtcmd, cmdsz);
} else {
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL) {
rtw_mfree(pevtcmd, cmdsz);
res = _FAIL;
goto exit;
}
pcmd_obj->padapter = padapter;
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
res = rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
}
exit:
RTW_INFO(FUNC_ADPT_FMT" "MAC_FMT" mac_id=%d, enqueue:%d, res:%u\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(MacAddr), mac_id, enqueue, res);
return res;
}
void report_add_sta_event(_adapter *padapter, unsigned char *MacAddr)
{
struct cmd_obj *pcmd_obj;
u8 *pevtcmd;
u32 cmdsz;
struct stassoc_event *padd_sta_evt;
struct rtw_evt_header *evt_hdr;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL)
return;
pcmd_obj->padapter = padapter;
cmdsz = (sizeof(struct stassoc_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
return;
}
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct stassoc_event);
evt_hdr->id = EVT_ADD_STA;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
padd_sta_evt = (struct stassoc_event *)(pevtcmd + sizeof(struct rtw_evt_header));
_rtw_memcpy((unsigned char *)(&(padd_sta_evt->macaddr)), MacAddr, ETH_ALEN);
RTW_INFO("report_add_sta_event: add STA\n");
rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
return;
}
/****************************************************************************
Following are the event callback functions
*****************************************************************************/
/* for sta/adhoc mode */
void update_sta_info(_adapter *padapter, struct sta_info *psta)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
/* ERP */
VCS_update(padapter, psta);
#ifdef CONFIG_80211N_HT
/* HT */
if (pmlmepriv->htpriv.ht_option) {
psta->htpriv.ht_option = _TRUE;
psta->htpriv.ampdu_enable = pmlmepriv->htpriv.ampdu_enable;
psta->htpriv.rx_ampdu_min_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & IEEE80211_HT_CAP_AMPDU_DENSITY) >> 2;
if (support_short_GI(padapter, &(pmlmeinfo->HT_caps), CHANNEL_WIDTH_20))
psta->htpriv.sgi_20m = _TRUE;
if (support_short_GI(padapter, &(pmlmeinfo->HT_caps), CHANNEL_WIDTH_40))
psta->htpriv.sgi_40m = _TRUE;
psta->qos_option = _TRUE;
psta->htpriv.ldpc_cap = pmlmepriv->htpriv.ldpc_cap;
psta->htpriv.stbc_cap = pmlmepriv->htpriv.stbc_cap;
psta->htpriv.beamform_cap = pmlmepriv->htpriv.beamform_cap;
_rtw_memcpy(&psta->htpriv.ht_cap, &pmlmeinfo->HT_caps, sizeof(struct rtw_ieee80211_ht_cap));
#ifdef CONFIG_BEAMFORMING
psta->htpriv.beamform_cap = pmlmepriv->htpriv.beamform_cap;
#endif
} else
#endif /* CONFIG_80211N_HT */
{
#ifdef CONFIG_80211N_HT
psta->htpriv.ht_option = _FALSE;
psta->htpriv.ampdu_enable = _FALSE;
psta->htpriv.tx_amsdu_enable = _FALSE;
psta->htpriv.sgi_20m = _FALSE;
psta->htpriv.sgi_40m = _FALSE;
#endif /* CONFIG_80211N_HT */
psta->qos_option = _FALSE;
}
#ifdef CONFIG_80211N_HT
psta->htpriv.ch_offset = pmlmeext->chandef.offset;
psta->htpriv.agg_enable_bitmap = 0x0;/* reset */
psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */
#endif /* CONFIG_80211N_HT */
psta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
/* QoS */
if (pmlmepriv->qospriv.qos_option)
psta->qos_option = _TRUE;
#ifdef CONFIG_80211AC_VHT
_rtw_memcpy(&psta->vhtpriv, &pmlmepriv->vhtpriv, sizeof(struct vht_priv));
if (psta->vhtpriv.vht_option) {
/* ToDo: need to API to inform hal_sta->ra_info.is_vht_enable */
/* psta->phl_sta->ra_info.is_vht_enable = _TRUE; */
#ifdef CONFIG_BEAMFORMING
psta->vhtpriv.beamform_cap = pmlmepriv->vhtpriv.beamform_cap;
#endif /*CONFIG_BEAMFORMING*/
}
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
_rtw_memcpy(&psta->hepriv, &pmlmepriv->hepriv, sizeof(struct he_priv));
#endif /* CONFIG_80211AX_HE */
/* ToDo: need to API to inform hal_sta->ra_info.is_support_sgi */
/* psta->phl_sta->ra_info.is_support_sgi = query_ra_short_GI(psta, rtw_get_tx_bw_mode(padapter, psta)); */
_rtw_spinlock_bh(&psta->lock);
psta->state = WIFI_ASOC_STATE;
_rtw_spinunlock_bh(&psta->lock);
}
void update_sta_trx_nss(_adapter *adapter, struct sta_info *psta)
{
s8 tx_nss, rx_nss;
/* get adapter tx nss */
tx_nss = rtw_get_sta_tx_nss(adapter, psta);
/* get adapter rx nss */
rx_nss = rtw_get_sta_rx_nss(adapter, psta);
/* peer sta tx should referece adapter rx_nss */
psta->phl_sta->asoc_cap.nss_tx = rx_nss;
/* peer sta rx should referece adapter tx_nss */
psta->phl_sta->asoc_cap.nss_rx = tx_nss;
#ifdef CONFIG_CTRL_TXSS_BY_TP
rtw_ctrl_txss_update(adapter, psta);
#endif
RTW_INFO("STA - MAC_ID:%d, Tx - %d SS, Rx - %d SS\n",
psta->phl_sta->macid, tx_nss, rx_nss);
}
void update_sta_smps_cap(_adapter *adapter, struct sta_info *psta)
{
/*Spatial Multiplexing Power Save*/
if (check_fwstate(&adapter->mlmepriv, WIFI_AP_STATE) == _TRUE) {
#ifdef CONFIG_80211N_HT
if (psta->htpriv.ht_option) {
if (psta->htpriv.smps_cap == 0)
psta->phl_sta->asoc_cap.sm_ps = SM_PS_STATIC;
else if (psta->htpriv.smps_cap == 1)
psta->phl_sta->asoc_cap.sm_ps = SM_PS_DYNAMIC;
else
psta->phl_sta->asoc_cap.sm_ps = SM_PS_DISABLE;
}
#endif /* CONFIG_80211N_HT */
} else {
psta->phl_sta->asoc_cap.sm_ps = SM_PS_DISABLE;
}
RTW_INFO("STA - MAC_ID:%d, SM_PS %d\n",
psta->phl_sta->macid, psta->phl_sta->asoc_cap.sm_ps);
}
void update_sta_rate_mask(_adapter *padapter, struct sta_info *psta)
{
u8 i, tx_nss;
u64 tx_ra_bitmap = 0, tmp64=0;
if (psta == NULL)
return;
/* b/g mode ra_bitmap */
for (i = 0; i < sizeof(psta->bssrateset); i++) {
if (psta->bssrateset[i])
tx_ra_bitmap |= rtw_get_bit_value_from_ieee_value(psta->bssrateset[i] & 0x7f);
}
#ifdef CONFIG_80211N_HT
if (padapter->registrypriv.ht_enable && is_supported_ht(padapter->registrypriv.wireless_mode)) {
tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
#ifdef CONFIG_80211AC_VHT
if (psta->vhtpriv.vht_option) {
/* AC mode ra_bitmap */
tx_ra_bitmap |= (rtw_vht_mcs_map_to_bitmap(psta->vhtpriv.vht_mcs_map, tx_nss) << 12);
} else
#endif /* CONFIG_80211AC_VHT */
{
if (psta->htpriv.ht_option) {
/* n mode ra_bitmap */
/* Handling SMPS mode for AP MODE only*/
if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE) {
/*0:static SMPS, 1:dynamic SMPS, 3:SMPS disabled, 2:reserved*/
if (psta->htpriv.smps_cap == 0 || psta->htpriv.smps_cap == 1)
/*operate with only one active receive chain // 11n-MCS rate <= MSC7*/
tx_nss = rtw_min(tx_nss, 1);
}
tmp64 = rtw_ht_mcs_set_to_bitmap(psta->htpriv.ht_cap.supp_mcs_set, tx_nss);
tx_ra_bitmap |= (tmp64 << 12);
}
}
}
#endif /* CONFIG_80211N_HT */
/* ToDo: Need API to inform hal_sta->ra_info.ramask */
/* psta->phl_sta->ra_info.ramask = tx_ra_bitmap;*/
psta->init_rate = get_highest_rate_idx(tx_ra_bitmap) & 0x3f;
}
void update_sta_ra_info(_adapter *padapter, struct sta_info *psta)
{
update_sta_trx_nss(padapter, psta);
update_sta_smps_cap(padapter, psta);
update_sta_rate_mask(padapter, psta);
}
#ifdef CONFIG_80211D
void rtw_joinbss_update_regulatory(_adapter *adapter, const WLAN_BSSID_EX *network)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
if (rfctl->regd_src == REGD_SRC_RTK_PRIV
&& !rtw_rfctl_is_disable_sw_channel_plan(rfctl_to_dvobj(rfctl))
) {
struct mlme_priv *mlme = &adapter->mlmepriv;
const u8 *country_ie = NULL;
sint country_ie_len = 0;
if (network) {
if (rtw_iface_accept_country_ie(adapter)) {
country_ie = rtw_get_ie(BSS_EX_TLV_IES(network)
, WLAN_EID_COUNTRY, &country_ie_len, BSS_EX_TLV_IES_LEN(network));
if (country_ie) {
if (country_ie_len < 6) {
country_ie = NULL;
country_ie_len = 0;
} else
country_ie_len += 2;
}
}
}
if (country_ie) {
rtw_buf_update(&mlme->recv_country_ie, &mlme->recv_country_ie_len, country_ie, country_ie_len);
if (rtw_apply_recv_country_ie_cmd(adapter, RTW_CMDF_DIRECTLY
, network->Configuration.DSConfig > 14 ? BAND_ON_5G : BAND_ON_24G
, network->Configuration.DSConfig, country_ie) != _SUCCESS
)
RTW_WARN(FUNC_ADPT_FMT" rtw_apply_recv_country_ie_cmd() fail\n", FUNC_ADPT_ARG(adapter));
} else
rtw_buf_free(&mlme->recv_country_ie, &mlme->recv_country_ie_len);
}
}
static void rtw_leavebss_update_regulatory(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
if (rfctl->regd_src == REGD_SRC_RTK_PRIV
&& !rtw_rfctl_is_disable_sw_channel_plan(dvobj)
) {
if (rtw_apply_recv_country_ie_cmd(adapter, RTW_CMDF_DIRECTLY, 0, 0, NULL) != _SUCCESS)
RTW_WARN(FUNC_ADPT_FMT" rtw_apply_recv_country_ie_cmd() fail\n", FUNC_ADPT_ARG(adapter));
}
}
#endif /* CONFIG_80211D */
void rtw_mlmeext_disconnect(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 self_action = MLME_ACTION_UNKNOWN;
u8 state_backup = (pmlmeinfo->state & 0x03);
u8 ASIX_ID[] = {0x00, 0x0E, 0xC6};
u8 *mac;
struct sta_info *sta;
if (MLME_IS_AP(padapter))
self_action = MLME_AP_STOPPED;
else if (MLME_IS_MESH(padapter))
self_action = MLME_MESH_STOPPED;
else if (MLME_IS_STA(padapter))
self_action = MLME_STA_DISCONNECTED;
else if (MLME_IS_ADHOC(padapter) || MLME_IS_ADHOC_MASTER(padapter))
self_action = MLME_ADHOC_STOPPED;
else {
RTW_INFO("state:0x%x\n", MLME_STATE(padapter));
rtw_warn_on(1);
}
/* check if sta is ASIX peer and fix IOT issue if it is. */
if (_rtw_memcmp(get_my_bssid(&pmlmeinfo->network) , ASIX_ID , 3)) {
u8 iot_flag = _FALSE;
rtw_hal_set_hwreg(padapter, HW_VAR_ASIX_IOT, (u8 *)(&iot_flag));
}
pmlmeinfo->state = WIFI_FW_NULL_STATE;
/* switch to the 20M Hz mode after disconnect */
pmlmeext->chandef.bw = CHANNEL_WIDTH_20;
pmlmeext->chandef.offset = CHAN_OFFSET_NO_EXT;
#ifdef CONFIG_CTRL_TXSS_BY_TP
pmlmeext->txss_1ss = _FALSE;
#endif
#ifdef CONFIG_LAYER2_ROAMING
#define RTW_ROAM_DICONNECT_DELAY 20
if (pmlmepriv->roam_network)
rtw_msleep_os(RTW_ROAM_DICONNECT_DELAY);
#endif
#ifdef CONFIG_80211D
if (self_action == MLME_STA_DISCONNECTED)
rtw_leavebss_update_regulatory(padapter);
#endif
/* before chanctx_del */
mac = pmlmeinfo->network.MacAddress;
sta = rtw_get_stainfo(&padapter->stapriv, mac);
if (sta)
rtw_hw_disconnect(padapter, sta);
else
RTW_ERR(FUNC_ADPT_FMT ": can't find drv sta info for "
MAC_FMT " !\n", FUNC_ADPT_ARG(padapter), MAC_ARG(mac));
#ifdef CONFIG_DFS_MASTER
if (!(MLME_IS_STA(padapter) && MLME_IS_OPCH_SW(padapter))) {
/* DFS no need to check here for STA under OPCH_SW */
rtw_dfs_rd_en_decision(padapter, self_action, 0);
}
#endif
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
/* pmlmepriv->LinkDetectInfo.TrafficBusyState = _FALSE; */
pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
#ifdef CONFIG_TDLS
padapter->tdlsinfo.ap_prohibited = _FALSE;
/* For TDLS channel switch, currently we only allow it to work in wifi logo test mode */
if (padapter->registrypriv.wifi_spec == 1)
padapter->tdlsinfo.ch_switch_prohibited = _FALSE;
#endif /* CONFIG_TDLS */
#ifdef CONFIG_WMMPS_STA
if (MLME_IS_STA(padapter)) {
/* reset currently related uapsd setting when the connection has broken */
pmlmepriv->qospriv.uapsd_max_sp_len = 0;
pmlmepriv->qospriv.uapsd_tid = 0;
pmlmepriv->qospriv.uapsd_tid_delivery_enabled = 0;
pmlmepriv->qospriv.uapsd_tid_trigger_enabled = 0;
pmlmepriv->qospriv.uapsd_ap_supported = 0;
}
#endif /* CONFIG_WMMPS_STA */
#ifdef CONFIG_RTS_FULL_BW
rtw_set_rts_bw(padapter);
#endif/*CONFIG_RTS_FULL_BW*/
}
/* Return 0 for success, otherwise fail. */
int rtw_set_hw_after_join(struct _ADAPTER *a, int join_res)
{
struct mlme_priv *mlme = &a->mlmepriv;
struct sta_info *sta;
u8 *mac;
int err;
if (mlme->wpa_phase == _TRUE)
mlme->wpa_phase = _FALSE;
mac = (u8*)a->mlmeextpriv.mlmext_info.network.MacAddress;
sta = rtw_get_stainfo(&a->stapriv, mac);
if (!sta) {
RTW_ERR(FUNC_ADPT_FMT ": drv sta_info(" MAC_FMT ") not exist!\n",
FUNC_ADPT_ARG(a), MAC_ARG(mac));
return -1;
}
if (join_res < 0) {
err = rtw_hw_connect_abort(a, sta);
return err;
}
#ifdef CONFIG_ARP_KEEP_ALIVE
mlme->bGetGateway = 1;
mlme->GetGatewayTryCnt = 0;
#endif
sta->phl_sta->wmode = a->mlmeextpriv.cur_wireless_mode;
err = rtw_hw_connected(a, sta);
#ifndef CONFIG_STA_CMD_DISPR /* Run in MSG_EVT_CONNECT_END@PHL_FG_MDL_CONNECT */
rtw_xmit_queue_clear(sta);
#endif /* CONFIG_STA_CMD_DISPR */
return err;
}
/* currently only adhoc mode will go here */
void mlmeext_sta_add_event_callback(_adapter *padapter, struct sta_info *psta)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 join_type;
RTW_INFO("%s\n", __FUNCTION__);
if ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE) {
if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) { /* adhoc master or sta_count>1 */
/* nothing to do */
} else { /* adhoc client */
/* start beacon */
if (send_beacon(padapter) == _FAIL)
rtw_warn_on(1);
pmlmeinfo->state |= WIFI_FW_ASSOC_SUCCESS;
}
join_type = 2;
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
}
/* update adhoc sta_info */
update_sta_info(padapter, psta);
update_sta_ra_info(padapter, psta);
/* ToDo: HT for Ad-hoc */
psta->phl_sta->wmode = rtw_check_network_type(psta->bssrateset, psta->bssratelen, pmlmeext->chandef.chan);
}
void mlmeext_sta_del_event_callback(_adapter *padapter)
{
if (is_client_associated_to_ap(padapter) || is_IBSS_empty(padapter))
rtw_mlmeext_disconnect(padapter);
}
/****************************************************************************
Following are the functions for the timer handlers
*****************************************************************************/
void _linked_info_dump(_adapter *padapter)
{
if (padapter->bLinkInfoDump) {
rtw_hal_get_def_var(padapter, HW_DEF_RA_INFO_DUMP, RTW_DBGDUMP);
/*rtw_hal_set_phydm_var(padapter, HAL_PHYDM_RX_INFO_DUMP, RTW_DBGDUMP, _FALSE);*/
}
}
/********************************************************************
When station does not receive any packet in MAX_CONTINUAL_NORXPACKET_COUNT*2 seconds,
recipient station will teardown the block ack by issuing DELBA frame.
*********************************************************************/
void rtw_delba_check(_adapter *padapter, struct sta_info *psta, u8 from_timer)
{
int i = 0;
int ret = _SUCCESS;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
/*
IOT issue,occur Broadcom ap(Buffalo WZR-D1800H,Netgear R6300).
AP is originator.AP does not transmit unicast packets when STA response its BAR.
This case probably occur ap issue BAR after AP builds BA.
Follow 802.11 spec, STA shall maintain an inactivity timer for every negotiated Block Ack setup.
The inactivity timer is not reset when MPDUs corresponding to other TIDs are received.
*/
if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_BROADCOM) {
for (i = 0; i < TID_NUM ; i++) {
if ((psta->recvreorder_ctrl[i].enable) &&
(sta_rx_data_qos_pkts(psta, i) == sta_last_rx_data_qos_pkts(psta, i)) ) {
if (_TRUE == rtw_inc_and_chk_continual_no_rx_packet(psta, i)) {
/* send a DELBA frame to the peer STA with the Reason Code field set to TIMEOUT */
if (!from_timer)
ret = issue_del_ba_ex(padapter, psta->phl_sta->mac_addr, i, 39, 0, 3, 1);
else
issue_del_ba(padapter, psta->phl_sta->mac_addr, i, 39, 0);
psta->recvreorder_ctrl[i].enable = _FALSE;
if (ret != _FAIL)
psta->recvreorder_ctrl[i].ampdu_size = RX_AMPDU_SIZE_INVALID;
rtw_reset_continual_no_rx_packet(psta, i);
}
} else {
/* The inactivity timer is reset when MPDUs to the TID is received. */
rtw_reset_continual_no_rx_packet(psta, i);
}
}
}
}
u8 chk_ap_is_alive(_adapter *padapter, struct sta_info *psta)
{
u8 ret = _FALSE;
#ifdef DBG_EXPIRATION_CHK
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
RTW_INFO(FUNC_ADPT_FMT" rx:"STA_PKTS_FMT", beacon:%llu, probersp_to_self:%llu"
/*", probersp_bm:%llu, probersp_uo:%llu, probereq:%llu, BI:%u"*/
", retry:%u\n"
, FUNC_ADPT_ARG(padapter)
, STA_RX_PKTS_DIFF_ARG(psta)
, psta->sta_stats.rx_beacon_pkts - psta->sta_stats.last_rx_beacon_pkts
, psta->sta_stats.rx_probersp_pkts - psta->sta_stats.last_rx_probersp_pkts
/*, psta->sta_stats.rx_probersp_bm_pkts - psta->sta_stats.last_rx_probersp_bm_pkts
, psta->sta_stats.rx_probersp_uo_pkts - psta->sta_stats.last_rx_probersp_uo_pkts
, psta->sta_stats.rx_probereq_pkts - psta->sta_stats.last_rx_probereq_pkts
, pmlmeinfo->bcn_interval*/
, pmlmeext->retry
);
RTW_INFO(FUNC_ADPT_FMT" tx_pkts:%llu, link_count:%u\n", FUNC_ADPT_ARG(padapter)
, sta_tx_pkts(psta)
, pmlmeinfo->link_count
);
#endif
if ((sta_rx_data_pkts(psta) == sta_last_rx_data_pkts(psta))
&& sta_rx_beacon_pkts(psta) == sta_last_rx_beacon_pkts(psta)
&& sta_rx_probersp_pkts(psta) == sta_last_rx_probersp_pkts(psta)
)
ret = _FALSE;
else
ret = _TRUE;
sta_update_last_rx_pkts(psta);
return ret;
}
u8 chk_adhoc_peer_is_alive(struct sta_info *psta)
{
u8 ret = _TRUE;
#ifdef DBG_EXPIRATION_CHK
RTW_INFO("sta:"MAC_FMT", rssi:%d, rx:"STA_PKTS_FMT", beacon:%llu, probersp_to_self:%llu"
/*", probersp_bm:%llu, probersp_uo:%llu, probereq:%llu, BI:%u"*/
", expire_to:%u\n"
, MAC_ARG(psta->phl_sta->mac_addr)
, 0 /* TODO: psta->phl_sta->hal_sta->rssi_stat.rssi */
, STA_RX_PKTS_DIFF_ARG(psta)
, psta->sta_stats.rx_beacon_pkts - psta->sta_stats.last_rx_beacon_pkts
, psta->sta_stats.rx_probersp_pkts - psta->sta_stats.last_rx_probersp_pkts
/*, psta->sta_stats.rx_probersp_bm_pkts - psta->sta_stats.last_rx_probersp_bm_pkts
, psta->sta_stats.rx_probersp_uo_pkts - psta->sta_stats.last_rx_probersp_uo_pkts
, psta->sta_stats.rx_probereq_pkts - psta->sta_stats.last_rx_probereq_pkts
, pmlmeinfo->bcn_interval*/
, psta->expire_to
);
#endif
if (sta_rx_data_pkts(psta) == sta_last_rx_data_pkts(psta)
&& sta_rx_beacon_pkts(psta) == sta_last_rx_beacon_pkts(psta)
&& sta_rx_probersp_pkts(psta) == sta_last_rx_probersp_pkts(psta))
ret = _FALSE;
sta_update_last_rx_pkts(psta);
return ret;
}
#ifdef CONFIG_TDLS
u8 chk_tdls_peer_sta_is_alive(_adapter *padapter, struct sta_info *psta)
{
if ((psta->sta_stats.rx_data_pkts == psta->sta_stats.last_rx_data_pkts)
&& (psta->sta_stats.rx_tdls_disc_rsp_pkts == psta->sta_stats.last_rx_tdls_disc_rsp_pkts))
return _FALSE;
return _TRUE;
}
void linked_status_chk_tdls(_adapter *padapter)
{
struct candidate_pool {
struct sta_info *psta;
u8 addr[ETH_ALEN];
};
struct sta_priv *pstapriv = &padapter->stapriv;
u8 ack_chk;
struct sta_info *psta;
int i, num_teardown = 0, num_checkalive = 0;
_list *plist, *phead;
struct tdls_txmgmt txmgmt;
struct candidate_pool checkalive[MAX_ALLOWED_TDLS_STA_NUM];
struct candidate_pool teardown[MAX_ALLOWED_TDLS_STA_NUM];
u8 tdls_sta_max = _FALSE;
#define ALIVE_MIN 2
#define ALIVE_MAX 5
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
_rtw_memset(checkalive, 0x00, sizeof(checkalive));
_rtw_memset(teardown, 0x00, sizeof(teardown));
if ((padapter->tdlsinfo.link_established == _TRUE)) {
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
if (psta->tdls_sta_state & TDLS_LINKED_STATE) {
psta->alive_count++;
if (psta->alive_count >= ALIVE_MIN) {
if (chk_tdls_peer_sta_is_alive(padapter, psta) == _FALSE) {
if (psta->alive_count < ALIVE_MAX) {
_rtw_memcpy(checkalive[num_checkalive].addr, psta->phl_sta->mac_addr, ETH_ALEN);
checkalive[num_checkalive].psta = psta;
num_checkalive++;
} else {
_rtw_memcpy(teardown[num_teardown].addr, psta->phl_sta->mac_addr, ETH_ALEN);
teardown[num_teardown].psta = psta;
num_teardown++;
}
} else
psta->alive_count = 0;
}
psta->sta_stats.last_rx_data_pkts = psta->sta_stats.rx_data_pkts;
psta->sta_stats.last_rx_tdls_disc_rsp_pkts = psta->sta_stats.rx_tdls_disc_rsp_pkts;
if ((num_checkalive >= MAX_ALLOWED_TDLS_STA_NUM) || (num_teardown >= MAX_ALLOWED_TDLS_STA_NUM)) {
tdls_sta_max = _TRUE;
break;
}
}
}
if (tdls_sta_max == _TRUE)
break;
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
if (num_checkalive > 0) {
for (i = 0; i < num_checkalive; i++) {
_rtw_memcpy(txmgmt.peer, checkalive[i].addr, ETH_ALEN);
issue_tdls_dis_req(padapter, &txmgmt);
issue_tdls_dis_req(padapter, &txmgmt);
issue_tdls_dis_req(padapter, &txmgmt);
}
}
if (num_teardown > 0) {
for (i = 0; i < num_teardown; i++) {
RTW_INFO("[%s %d] Send teardown to "MAC_FMT"\n", __FUNCTION__, __LINE__, MAC_ARG(teardown[i].addr));
txmgmt.status_code = _RSON_TDLS_TEAR_TOOFAR_;
_rtw_memcpy(txmgmt.peer, teardown[i].addr, ETH_ALEN);
issue_tdls_teardown(padapter, &txmgmt, _FALSE);
}
}
}
}
#endif /* CONFIG_TDLS */
inline int rtw_get_rx_chk_limit(_adapter *adapter)
{
return adapter->stapriv.rx_chk_limit;
}
inline void rtw_set_rx_chk_limit(_adapter *adapter, int limit)
{
adapter->stapriv.rx_chk_limit = limit;
}
/* from_timer == 1 means driver is in LPS */
void linked_status_chk(_adapter *padapter, u8 from_timer)
{
u32 i;
struct sta_info *psta;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_priv *pstapriv = &padapter->stapriv;
#if defined(CONFIG_ARP_KEEP_ALIVE) || defined(CONFIG_LAYER2_ROAMING)
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
#endif
#ifdef CONFIG_LAYER2_ROAMING
struct recv_info *precvinfo = &padapter->recvinfo;
#endif
#ifdef CONFIG_RTW_WDS
rtw_wds_gptr_expire(padapter);
#endif
bool is_p2p_gc = _FALSE;
if (padapter->registrypriv.mp_mode == _TRUE)
return;
if (check_fwstate(pmlmepriv, WIFI_CSA_UPDATE_BEACON))
return;
if (is_client_associated_to_ap(padapter)) {
/* linked infrastructure client mode */
int tx_chk = _SUCCESS, rx_chk = _SUCCESS;
int rx_chk_limit;
int link_count_limit;
#if defined(CONFIG_LAYER2_ROAMING)
if (rtw_chk_roam_flags(padapter, RTW_ROAM_ACTIVE)) {
RTW_INFO("signal_strength_data.avg_val = %d\n", precvinfo->signal_strength_data.avg_val);
if ((precvinfo->signal_strength_data.avg_val < pmlmepriv->roam_rssi_threshold)
&& (rtw_get_passing_time_ms(pmlmepriv->last_roaming) >= pmlmepriv->roam_scan_int*2000)) {
#ifdef CONFIG_RTW_80211K
rtw_roam_nb_discover(padapter, _FALSE);
#endif
pmlmepriv->need_to_roam = _TRUE;
rtw_drv_scan_by_self(padapter, RTW_AUTO_SCAN_REASON_ROAM);
pmlmepriv->last_roaming = rtw_get_current_time();
} else
pmlmepriv->need_to_roam = _FALSE;
}
#endif
rx_chk_limit = rtw_get_rx_chk_limit(padapter);
#ifdef CONFIG_ARP_KEEP_ALIVE
if (!from_timer && pmlmepriv->bGetGateway == 1 && pmlmepriv->GetGatewayTryCnt < 3) {
RTW_INFO("do rtw_gw_addr_query() : %d\n", pmlmepriv->GetGatewayTryCnt);
pmlmepriv->GetGatewayTryCnt++;
if (rtw_gw_addr_query(padapter) == 0)
pmlmepriv->bGetGateway = 0;
else {
_rtw_memset(pmlmepriv->gw_ip, 0, 4);
_rtw_memset(pmlmepriv->gw_mac_addr, 0, ETH_ALEN);
}
}
#endif
#ifdef CONFIG_P2P
is_p2p_gc = rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_CLIENT);
if (is_p2p_gc) {
if (!from_timer)
link_count_limit = 3; /* 8 sec */
else
link_count_limit = 15; /* 32 sec */
} else
#endif /* CONFIG_P2P */
{
if (!from_timer)
link_count_limit = 7; /* 16 sec */
else
link_count_limit = 29; /* 60 sec */
}
#ifdef CONFIG_TDLS
#ifdef CONFIG_TDLS_CH_SW
if (ATOMIC_READ(&padapter->tdlsinfo.chsw_info.chsw_on) == _TRUE)
return;
#endif /* CONFIG_TDLS_CH_SW */
#ifdef CONFIG_TDLS_AUTOCHECKALIVE
linked_status_chk_tdls(padapter);
#endif /* CONFIG_TDLS_AUTOCHECKALIVE */
#endif /* CONFIG_TDLS */
psta = rtw_get_stainfo(pstapriv, pmlmeinfo->network.MacAddress);
if (psta != NULL) {
#ifdef CONFIG_ISSUE_DELBA_WHEN_NO_TRAFFIC
/*issue delba when ap does not tx data packet that is Broadcom ap */
rtw_delba_check(padapter, psta, from_timer);
#endif
if (chk_ap_is_alive(padapter, psta) == _FALSE)
rx_chk = _FAIL;
if (sta_last_tx_pkts(psta) == sta_tx_pkts(psta))
tx_chk = _FAIL;
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
if (!from_timer && pmlmeext->active_keep_alive_check && (rx_chk == _FAIL || tx_chk == _FAIL)
) {
u8 backup_ch = 0, backup_bw = 0, backup_offset = 0;
u8 union_ch = 0, union_bw = 0, union_offset = 0;
u8 switch_channel_by_drv = _TRUE;
if (switch_channel_by_drv) {
if (!rtw_mi_get_ch_setting_union(padapter, &union_ch, &union_bw, &union_offset)
|| pmlmeext->chandef.chan != union_ch)
goto bypass_active_keep_alive;
/* switch to correct channel of current network before issue keep-alive frames */
if (rtw_get_oper_ch(padapter) != pmlmeext->chandef.chan) {
backup_ch = rtw_get_oper_ch(padapter);
backup_bw = rtw_get_oper_bw(padapter);
backup_offset = rtw_get_oper_choffset(padapter);
set_channel_bwmode(padapter, union_ch, union_offset, union_bw, _FALSE);
}
}
if (rx_chk != _SUCCESS)
issue_probereq_ex(padapter, &pmlmeinfo->network.Ssid, psta->phl_sta->mac_addr, 0, 0, 3, 1);
if ((tx_chk != _SUCCESS && pmlmeinfo->link_count++ == link_count_limit) || rx_chk != _SUCCESS) {
if (rtw_mi_check_fwstate(padapter, WIFI_UNDER_SURVEY))
tx_chk = issue_nulldata(padapter, psta->phl_sta->mac_addr, 1, 3, 1);
else
tx_chk = issue_nulldata(padapter, psta->phl_sta->mac_addr, 0, 3, 1);
/* If tx acked, set rx_chk _SUCCESS to reset the retry count
* unless it is a P2P GC. If the P2P GO is no longer a P2P GO,
* P2P GC tx may still receive acks, but no beacon.
*/
if (tx_chk == _SUCCESS && !is_p2p_gc)
rx_chk = _SUCCESS;
}
/* back to the original operation channel */
if (backup_ch > 0 && switch_channel_by_drv)
set_channel_bwmode(padapter, backup_ch, backup_offset, backup_bw, _FALSE);
bypass_active_keep_alive:
;
} else
#endif /* CONFIG_ACTIVE_KEEP_ALIVE_CHECK */
{
if (rx_chk != _SUCCESS) {
if (pmlmeext->retry == 0) {
#ifdef DBG_EXPIRATION_CHK
RTW_INFO("issue_probereq to trigger probersp, retry=%d\n", pmlmeext->retry);
#endif
issue_probereq_ex(padapter, &pmlmeinfo->network.Ssid, pmlmeinfo->network.MacAddress, 0, 0, 0, (from_timer ? 0 : 1));
issue_probereq_ex(padapter, &pmlmeinfo->network.Ssid, pmlmeinfo->network.MacAddress, 0, 0, 0, (from_timer ? 0 : 1));
issue_probereq_ex(padapter, &pmlmeinfo->network.Ssid, pmlmeinfo->network.MacAddress, 0, 0, 0, (from_timer ? 0 : 1));
}
}
if (tx_chk != _SUCCESS && pmlmeinfo->link_count++ == link_count_limit) {
#ifdef DBG_EXPIRATION_CHK
RTW_INFO("%s issue_nulldata(%d)\n", __FUNCTION__, from_timer ? 1 : 0);
#endif
if (from_timer || rtw_mi_check_fwstate(padapter, WIFI_UNDER_SURVEY))
tx_chk = issue_nulldata(padapter, NULL, 1, 0, 0);
else
tx_chk = issue_nulldata(padapter, NULL, 0, 1, 1);
}
}
if (rx_chk == _FAIL) {
pmlmeext->retry++;
if (pmlmeext->retry > rx_chk_limit) {
RTW_PRINT(FUNC_ADPT_FMT" disconnect or roaming\n",
FUNC_ADPT_ARG(padapter));
receive_disconnect(padapter, pmlmeinfo->network.MacAddress
, WLAN_REASON_EXPIRATION_CHK, _FALSE);
return;
}
} else
pmlmeext->retry = 0;
if (tx_chk == _FAIL)
pmlmeinfo->link_count %= (link_count_limit + 1);
else {
psta->sta_stats.last_tx_pkts = psta->sta_stats.tx_pkts;
pmlmeinfo->link_count = 0;
}
} /* end of if ((psta = rtw_get_stainfo(pstapriv, passoc_res->network.MacAddress)) != NULL) */
} else if (is_client_associated_to_ibss(padapter)) {
_list *phead, *plist, dlist;
_rtw_init_listhead(&dlist);
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
if (is_broadcast_mac_addr(psta->phl_sta->mac_addr))
continue;
if (chk_adhoc_peer_is_alive(psta) || !psta->expire_to)
psta->expire_to = pstapriv->adhoc_expire_to;
else
psta->expire_to--;
if (psta->expire_to <= 0) {
rtw_list_delete(&psta->list);
rtw_list_insert_tail(&psta->list, &dlist);
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
plist = get_next(&dlist);
while (rtw_end_of_queue_search(&dlist, plist) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, list);
plist = get_next(plist);
rtw_list_delete(&psta->list);
RTW_INFO(FUNC_ADPT_FMT" ibss expire "MAC_FMT"\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(psta->phl_sta->mac_addr));
report_del_sta_event(padapter, psta->phl_sta->mac_addr, WLAN_REASON_EXPIRATION_CHK, from_timer ? _TRUE : _FALSE, _FALSE);
}
}
}
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
void rtw_tbtx_xmit_timer_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
if (ATOMIC_READ(&padapter->tbtx_remove_tx_pause) == _TRUE){
ATOMIC_SET(&padapter->tbtx_tx_pause, _FALSE);
rtw_tx_control_cmd(padapter);
}else {
rtw_issue_action_token_rel(padapter);
ATOMIC_SET(&padapter->tbtx_tx_pause, _TRUE);
rtw_tx_control_cmd(padapter);
_set_timer(&pmlmeext->tbtx_xmit_timer, MAX_TXPAUSE_DURATION);
ATOMIC_SET(&padapter->tbtx_remove_tx_pause, _TRUE);
}
}
#ifdef CONFIG_AP_MODE
void rtw_tbtx_token_dispatch_timer_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
_irqL irqL;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
_list *phead, *plist;
int i, found = _FALSE;
u8 nr_send, th_idx = 0;
_rtw_spinlock_bh(&pstapriv->asoc_list_lock, &irqL);
RTW_DBG("%s:asoc_cnt: %d\n",__func__, pstapriv->tbtx_asoc_list_cnt);
// check number of TBTX sta
if (padapter->stapriv.tbtx_asoc_list_cnt < 2)
goto exit;
// dispatch token
nr_send = RTW_DIV_ROUND_UP(pstapriv->tbtx_asoc_list_cnt, NR_TBTX_SLOT);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
/* psta is supporting TBTX */
if ((!psta) || (!psta->tbtx_enable))
RTW_DBG("sta tbtx_enable is false\n");
else {
for (i = 0; i < nr_send; i++) {
if (pstapriv->last_token_holder == psta) {
found = _TRUE;
goto outof_loop;
}
}
}
plist = get_next(plist);
}
outof_loop:
RTW_DBG("rtw_tbtx_token_dispatch_timer_hdl() th_idx=%d, nr_send=%d, phead=%p, plist=%p, found=%d\n ", th_idx , nr_send, phead, plist, found);
if (!found) {
plist = get_next(phead);
while(rtw_end_of_queue_search(phead, plist) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
if ((!psta) || (!psta->tbtx_enable))
RTW_DBG("sta tbtx_enable is false\n");
else {
pstapriv->token_holder[th_idx] = psta;
rtw_issue_action_token_req(padapter, pstapriv->token_holder[th_idx++]);
break;
}
plist = get_next(plist);
}
}
for (i=th_idx; i<nr_send;) {
plist = get_next(plist);
if (plist == phead)
plist = get_next(plist);
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
if ((!psta) || (!psta->tbtx_enable))
RTW_DBG("sta tbtx_enable is false\n");
else {
pstapriv->token_holder[th_idx] = psta;
rtw_issue_action_token_req(padapter, pstapriv->token_holder[th_idx++]);
i++;
}
}
ATOMIC_SET(&pstapriv->nr_token_keeper, nr_send);
exit:
// set_timer
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock, &irqL);
_set_timer(&pmlmeext->tbtx_token_dispatch_timer, TBTX_TX_DURATION);
}
#endif /* CONFIG_AP_MODE */
#endif /* CONFIG_RTW_TOKEN_BASED_XMIT */
void link_timer_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
/* static unsigned int rx_pkt = 0; */
/* static u64 tx_cnt = 0; */
/* struct xmit_priv *pxmitpriv = &(padapter->xmitpriv); */
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
/* struct sta_priv *pstapriv = &padapter->stapriv; */
#ifdef CONFIG_RTW_80211R
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta = NULL;
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)(&(pmlmeinfo->network));
#endif
if (rtw_sta_linking_test_force_fail())
RTW_INFO("rtw_sta_linking_test_force_fail\n");
if (pmlmeext->join_abort && pmlmeinfo->state != WIFI_FW_NULL_STATE) {
RTW_INFO(FUNC_ADPT_FMT" join abort\n", FUNC_ADPT_ARG(padapter));
pmlmeinfo->state = WIFI_FW_NULL_STATE;
report_join_res(padapter, -4, WLAN_STATUS_UNSPECIFIED_FAILURE);
goto exit;
}
if (pmlmeinfo->state & WIFI_FW_AUTH_NULL) {
RTW_INFO("link_timer_hdl:no beacon while connecting\n");
pmlmeinfo->state = WIFI_FW_NULL_STATE;
report_join_res(padapter, -3, WLAN_STATUS_UNSPECIFIED_FAILURE);
} else if (pmlmeinfo->state & WIFI_FW_AUTH_STATE) {
#ifdef CONFIG_IOCTL_CFG80211
if (rtw_sec_chk_auth_type(padapter, MLME_AUTHTYPE_SAE))
return;
#endif /* CONFIG_IOCTL_CFG80211 */
/* re-auth timer */
if (++pmlmeinfo->reauth_count > REAUTH_LIMIT) {
/* if (pmlmeinfo->auth_algo != dot11AuthAlgrthm_Auto) */
/* { */
pmlmeinfo->state = 0;
if (pmlmeinfo->auth_status) {
report_join_res(padapter, -1, pmlmeinfo->auth_status);
pmlmeinfo->auth_status = 0; /* reset */
} else
report_join_res(padapter, -1, WLAN_STATUS_UNSPECIFIED_FAILURE);
return;
/* } */
/* else */
/* { */
/* pmlmeinfo->auth_algo = dot11AuthAlgrthm_Shared; */
/* pmlmeinfo->reauth_count = 0; */
/* } */
}
RTW_INFO("link_timer_hdl: auth timeout and try again\n");
pmlmeinfo->auth_seq = 1;
issue_auth(padapter, NULL, 0);
set_link_timer(pmlmeext, REAUTH_TO);
} else if (pmlmeinfo->state & WIFI_FW_ASSOC_STATE) {
/* re-assoc timer */
if (++pmlmeinfo->reassoc_count > REASSOC_LIMIT) {
pmlmeinfo->state = WIFI_FW_NULL_STATE;
#ifdef CONFIG_RTW_80211R
if (rtw_ft_roam(padapter)) {
psta = rtw_get_stainfo(pstapriv, pmlmeinfo->network.MacAddress);
if (psta)
rtw_free_stainfo(padapter, psta);
}
#endif
report_join_res(padapter, -2, WLAN_STATUS_UNSPECIFIED_FAILURE);
return;
}
#ifdef CONFIG_RTW_80211R
if (rtw_ft_roam(padapter)) {
RTW_INFO("link_timer_hdl: reassoc timeout and try again\n");
issue_reassocreq(padapter);
} else
#endif
{
RTW_INFO("link_timer_hdl: assoc timeout and try again\n");
issue_assocreq(padapter);
}
set_link_timer(pmlmeext, REASSOC_TO);
}
exit:
return;
}
void addba_timer_hdl(void *ctx)
{
struct sta_info *psta = (struct sta_info *)ctx;
#ifdef CONFIG_80211N_HT
struct ht_priv *phtpriv;
if (!psta)
return;
phtpriv = &psta->htpriv;
if ((phtpriv->ht_option == _TRUE) && (phtpriv->ampdu_enable == _TRUE)) {
if (phtpriv->candidate_tid_bitmap)
phtpriv->candidate_tid_bitmap = 0x0;
}
#endif /* CONFIG_80211N_HT */
}
#ifdef CONFIG_IEEE80211W
void report_sta_timeout_event(_adapter *padapter, u8 *MacAddr, unsigned short reason)
{
struct cmd_obj *pcmd_obj;
u8 *pevtcmd;
u32 cmdsz;
struct sta_info *psta;
int mac_id;
struct stadel_event *pdel_sta_evt;
struct rtw_evt_header *evt_hdr;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd_obj == NULL)
return;
pcmd_obj->padapter = padapter;
cmdsz = (sizeof(struct stadel_event) + sizeof(struct rtw_evt_header));
pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
if (pevtcmd == NULL) {
rtw_mfree((u8 *)pcmd_obj, sizeof(struct cmd_obj));
return;
}
_rtw_init_listhead(&pcmd_obj->list);
pcmd_obj->cmdcode = CMD_SET_MLME_EVT;
pcmd_obj->cmdsz = cmdsz;
pcmd_obj->parmbuf = pevtcmd;
pcmd_obj->rsp = NULL;
pcmd_obj->rspsz = 0;
evt_hdr = (struct rtw_evt_header *)(pevtcmd);
evt_hdr->len = sizeof(struct stadel_event);
evt_hdr->id = EVT_TIMEOUT_STA;
evt_hdr->seq = ATOMIC_INC_RETURN(&pmlmeext->event_seq);
pdel_sta_evt = (struct stadel_event *)(pevtcmd + sizeof(struct rtw_evt_header));
_rtw_memcpy((unsigned char *)(&(pdel_sta_evt->macaddr)), MacAddr, ETH_ALEN);
_rtw_memcpy((unsigned char *)(pdel_sta_evt->rsvd), (unsigned char *)(&reason), 2);
psta = rtw_get_stainfo(&padapter->stapriv, MacAddr);
if (psta)
mac_id = (int)psta->phl_sta->macid;
else
mac_id = (-1);
pdel_sta_evt->mac_id = mac_id;
RTW_INFO("report_del_sta_event: delete STA, mac_id=%d\n", mac_id);
rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
return;
}
void clnt_sa_query_timeout(_adapter *padapter)
{
struct mlme_ext_priv *mlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *mlmeinfo = &(mlmeext->mlmext_info);
RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
receive_disconnect(padapter, get_my_bssid(&(mlmeinfo->network)), WLAN_REASON_SA_QUERY_TIMEOUT, _FALSE);
}
void sa_query_timer_hdl(void *ctx)
{
struct sta_info *psta = (struct sta_info *)ctx;
_adapter *padapter = psta->padapter;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (MLME_IS_STA(padapter) &&
check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
clnt_sa_query_timeout(padapter);
else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
report_sta_timeout_event(padapter, psta->phl_sta->mac_addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
}
#endif /* CONFIG_IEEE80211W */
#ifdef ROKU_PRIVATE
void find_remote_timer_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
rtw_find_remote_wk_cmd(padapter);
set_find_remote_timer(pmlmeext, 1);
}
#ifdef CONFIG_P2P
void hide_ssid_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct registry_priv *pregpriv = &padapter->registrypriv;
rtw_set_bit(MIRACAST, &pregpriv->go_hidden_ssid_mode);
ATOMIC_SET(&pregpriv->set_hide_ssid_timer, 0);
/* check if there is other feature show SSID in beacon */
if (pregpriv->go_hidden_ssid_mode == ALL_HIDE_SSID)
rtw_hide_ssid_wk_cmd(padapter);
}
#endif
#endif
#ifdef CONFIG_AUTO_AP_MODE
void rtw_auto_ap_rx_msg_dump(_adapter *padapter, union recv_frame *precv_frame, u8 *ehdr_pos)
{
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_info *psta = precv_frame->u.hdr.psta;
struct ethhdr *ehdr = (struct ethhdr *)ehdr_pos;
RTW_INFO("eth rx: got eth_type=0x%x\n", ntohs(ehdr->h_proto));
if (psta && psta->isrc && psta->pid > 0) {
u16 rx_pid;
rx_pid = *(u16 *)(ehdr_pos + ETH_HLEN);
RTW_INFO("eth rx(pid=0x%x): sta("MAC_FMT") pid=0x%x\n",
rx_pid, MAC_ARG(psta->phl_sta->mac_addr), psta->pid);
if (rx_pid == psta->pid) {
int i;
u16 len = *(u16 *)(ehdr_pos + ETH_HLEN + 2);
/* u16 ctrl_type = *(u16 *)(ehdr_pos + ETH_HLEN + 4); */
/* RTW_INFO("eth, RC: len=0x%x, ctrl_type=0x%x\n", len, ctrl_type); */
RTW_INFO("eth, RC: len=0x%x\n", len);
for (i = 0; i < len; i++)
RTW_INFO("0x%x\n", *(ehdr_pos + ETH_HLEN + 4 + i));
/* RTW_INFO("0x%x\n", *(ehdr_pos + ETH_HLEN + 6 + i)); */
RTW_INFO("eth, RC-end\n");
}
}
}
void rtw_start_auto_ap(_adapter *adapter)
{
RTW_INFO("%s\n", __FUNCTION__);
rtw_set_802_11_infrastructure_mode(adapter, Ndis802_11APMode, 0);
rtw_setopmode_cmd(adapter, Ndis802_11APMode, RTW_CMDF_WAIT_ACK);
}
static int rtw_auto_ap_start_beacon(_adapter *adapter)
{
int ret = 0;
u8 *pbuf = NULL;
uint len;
u8 supportRate[16];
int sz = 0, rateLen;
u8 *ie;
u8 wireless_mode, oper_channel;
u8 ssid[3] = {0}; /* hidden ssid */
u32 ssid_len = sizeof(ssid);
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
return -EINVAL;
len = 128;
pbuf = rtw_zmalloc(len);
if (!pbuf)
return -ENOMEM;
/* generate beacon */
ie = pbuf;
/* timestamp will be inserted by hardware */
sz += 8;
ie += sz;
/* beacon interval : 2bytes */
*(u16 *)ie = cpu_to_le16((u16)100); /* BCN_INTERVAL=100; */
sz += 2;
ie += 2;
/* capability info */
*(u16 *)ie = 0;
*(u16 *)ie |= cpu_to_le16(cap_ESS);
*(u16 *)ie |= cpu_to_le16(cap_ShortPremble);
/* *(u16*)ie |= cpu_to_le16(cap_Privacy); */
sz += 2;
ie += 2;
/* SSID */
ie = rtw_set_ie(ie, _SSID_IE_, ssid_len, ssid, &sz);
/* Get OP ch */
if (rtw_mi_check_status(adapter, MI_LINKED))
oper_channel = rtw_mi_get_union_chan(adapter);
else
oper_channel = adapter_to_dvobj(adapter)->chandef.chan;
/* supported rates */
wireless_mode = (WIRELESS_11BG_24N & adapter->registrypriv.wireless_mode);
rtw_set_supported_rate(supportRate, wireless_mode, oper_channel);
rateLen = rtw_get_rateset_len(supportRate);
if (rateLen > 8)
ie = rtw_set_ie(ie, _SUPPORTEDRATES_IE_, 8, supportRate, &sz);
else
ie = rtw_set_ie(ie, _SUPPORTEDRATES_IE_, rateLen, supportRate, &sz);
/* DS parameter set */
ie = rtw_set_ie(ie, _DSSET_IE_, 1, &oper_channel, &sz);
/* ext supported rates */
if (rateLen > 8)
ie = rtw_set_ie(ie, _EXT_SUPPORTEDRATES_IE_, (rateLen - 8), (supportRate + 8), &sz);
RTW_INFO("%s, start auto ap beacon sz=%d\n", __FUNCTION__, sz);
/* lunch ap mode & start to issue beacon */
if (rtw_check_beacon_data(adapter, pbuf, sz) == _SUCCESS) {
} else
ret = -EINVAL;
rtw_mfree(pbuf, len);
return ret;
}
#endif/* CONFIG_AUTO_AP_MODE */
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
u8 tx_control_hdl(_adapter *adapter)
{
u8 val;
if(ATOMIC_READ(&adapter->tbtx_tx_pause))
val = 0xff;
else
val = 0x00;
rtw_hal_set_hwreg(adapter, HW_VAR_TXPAUSE, &val);
return H2C_SUCCESS;
}
#endif
void rtw_disconnect_ch_switch(_adapter *adapter)
{
u8 ch, bw, offset;
void *phl = adapter_to_dvobj(adapter)->phl;
int chanctx_num = 0;
struct rtw_chan_def chan_def = {0};
if (!(MLME_IS_STA(adapter) && MLME_IS_OPCH_SW(adapter))) {
/* channel status no need to check here for STA under OPCH_SW */
rtw_mi_get_ch_setting_union_no_self(adapter, &ch, &bw, &offset);
RTW_INFO("Core - CH:%d, BW:%d OFF:%d\n", ch, bw, offset);
chanctx_num = rtw_phl_chanctx_del(phl, adapter->phl_role, &chan_def);
RTW_INFO("PHL - CH:%d, BW:%d OFF:%d\n", chan_def.chan, chan_def.bw, chan_def.offset);
if (chanctx_num && (ch != chan_def.chan)) {
RTW_WARN("%s chandef->chan != ch\n", __func__);
rtw_warn_on(1);
}
if (chanctx_num && chan_def.chan != 0) {
set_channel_bwmode(adapter, chan_def.chan, chan_def.offset, chan_def.bw, _FALSE);
rtw_mi_update_union_chan_inf(adapter, chan_def.chan, chan_def.offset, chan_def.bw);
}
rtw_rfctl_update_op_mode(adapter_to_rfctl(adapter), BIT(adapter->iface_id), 0);
}
}
#ifdef CONFIG_AP_MODE
u8 stop_ap_hdl(_adapter *adapter)
{
RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
rtw_set_802_11_infrastructure_mode(adapter, Ndis802_11Infrastructure, RTW_CMDF_DIRECTLY);
rtw_setopmode_cmd(adapter, Ndis802_11Infrastructure, RTW_CMDF_DIRECTLY);
#ifdef CONFIG_AP_CMD_DISPR
rtw_free_bcn_entry(adapter);
#else
rtw_phl_ap_stop(adapter_to_dvobj(adapter)->phl, adapter->phl_role);
#endif
rtw_disconnect_ch_switch(adapter);
return H2C_SUCCESS;
}
#endif
u8 setopmode_hdl(_adapter *padapter, u8 *pbuf)
{
u8 type;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct setopmode_parm *psetop = (struct setopmode_parm *)pbuf;
if (psetop->mode == Ndis802_11APMode
|| psetop->mode == Ndis802_11_mesh
) {
pmlmeinfo->state = WIFI_FW_AP_STATE;
type = _HW_STATE_AP_;
} else if (psetop->mode == Ndis802_11Infrastructure) {
pmlmeinfo->state &= ~(BIT(0) | BIT(1)); /* clear state */
pmlmeinfo->state |= WIFI_FW_STATION_STATE;/* set to STATION_STATE */
type = _HW_STATE_STATION_;
} else if (psetop->mode == Ndis802_11IBSS)
type = _HW_STATE_ADHOC_;
else if (psetop->mode == Ndis802_11Monitor)
type = _HW_STATE_MONITOR_;
else
type = _HW_STATE_NOLINK_;
if (_FAIL == rtw_hw_iface_type_change(padapter, type)) {
RTW_ERR("%s - change iface type fails !\n", __func__);
return H2C_CMD_FAIL;
}
#ifdef CONFIG_AP_PORT_SWAP
rtw_hal_set_hwreg(padapter, HW_VAR_PORT_SWITCH, (u8 *)(&type));
#endif
rtw_hal_set_hwreg(padapter, HW_VAR_SET_OPMODE, (u8 *)(&type));
#ifdef CONFIG_AUTO_AP_MODE
if (psetop->mode == Ndis802_11APMode)
rtw_auto_ap_start_beacon(padapter);
#endif
return H2C_SUCCESS;
}
u8 createbss_hdl(_adapter *padapter, u8 *pbuf)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)(&(pmlmeinfo->network));
WLAN_BSSID_EX *pdev_network = &padapter->registrypriv.dev_network;
struct createbss_parm *parm = (struct createbss_parm *)pbuf;
u8 ret = H2C_SUCCESS;
/* u8 initialgain; */
#ifdef CONFIG_AP_MODE
if ((parm->req_ch == 0 && pmlmeinfo->state == WIFI_FW_AP_STATE)
|| parm->req_ch != 0
) {
start_bss_network(padapter, parm);
rtw_core_ap_swch_start(padapter, parm);
rtw_core_ap_start(padapter, parm);
goto exit;
}
#endif
/* below is for ad-hoc master */
if (parm->adhoc) {
rtw_warn_on(pdev_network->InfrastructureMode != Ndis802_11IBSS);
rtw_joinbss_reset(padapter);
pmlmeext->chandef.bw = CHANNEL_WIDTH_20;
pmlmeext->chandef.offset = CHAN_OFFSET_NO_EXT;
pmlmeinfo->ERP_enable = 0;
pmlmeinfo->WMM_enable = 0;
pmlmeinfo->HT_enable = 0;
pmlmeinfo->HT_caps_enable = 0;
pmlmeinfo->HT_info_enable = 0;
pmlmeinfo->agg_enable_bitmap = 0;
pmlmeinfo->candidate_tid_bitmap = 0;
/* cancel link timer */
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
/* clear CAM */
flush_all_cam_entry(padapter, PHL_CMD_DIRECTLY, 0);
pdev_network->Length = get_WLAN_BSSID_EX_sz(pdev_network);
_rtw_memcpy(pnetwork, pdev_network, FIELD_OFFSET(WLAN_BSSID_EX, IELength));
pnetwork->IELength = pdev_network->IELength;
if (pnetwork->IELength > MAX_IE_SZ) {
ret = H2C_PARAMETERS_ERROR;
goto ibss_post_hdl;
}
_rtw_memcpy(pnetwork->IEs, pdev_network->IEs, pnetwork->IELength);
start_create_ibss(padapter);
} else {
rtw_warn_on(1);
ret = H2C_PARAMETERS_ERROR;
}
ibss_post_hdl:
rtw_create_ibss_post_hdl(padapter, ret);
exit:
return ret;
}
static void set_hw_before_join(struct _ADAPTER *a)
{
struct mlme_ext_priv *pmlmeext = &a->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
struct _WLAN_BSSID_EX *pnetwork = &pmlmeinfo->network;
struct sta_info *sta;
/* check already connecting to AP or not */
if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) {
if (pmlmeinfo->state & WIFI_FW_STATION_STATE)
issue_deauth_ex(a, pnetwork->MacAddress,
WLAN_REASON_DEAUTH_LEAVING, 1, 100);
pmlmeinfo->state = WIFI_FW_NULL_STATE;
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
sta = rtw_get_stainfo(&a->stapriv, pnetwork->MacAddress);
if (sta)
rtw_hw_disconnect(a, sta);
else
RTW_ERR(FUNC_ADPT_FMT ": can't find drv sta info for "
MAC_FMT " !\n",
FUNC_ADPT_ARG(a),
MAC_ARG(pnetwork->MacAddress));
}
/*reset hw before connection if necessary*/
}
void update_join_info(struct _ADAPTER *a, struct _WLAN_BSSID_EX *pbuf)
{
struct mlme_ext_priv *pmlmeext = &a->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
struct _WLAN_BSSID_EX *pnetwork = &pmlmeinfo->network;
struct _NDIS_802_11_VARIABLE_IEs *pIE;
u32 i;
u8 join_type;
a->mlmepriv.num_FortyMHzIntolerant = 0;
a->mlmepriv.num_sta_no_ht = 0;
a->mlmepriv.htpriv.ampdu_enable = _FALSE;/* reset to disabled */
pmlmeinfo->ERP_enable = 0;
pmlmeinfo->WMM_enable = 0;
pmlmeinfo->HT_enable = 0;
pmlmeinfo->HT_caps_enable = 0;
pmlmeinfo->HT_info_enable = 0;
pmlmeinfo->agg_enable_bitmap = 0;
pmlmeinfo->candidate_tid_bitmap = 0;
pmlmeinfo->bwmode_updated = _FALSE;
/* pmlmeinfo->assoc_AP_vendor = HT_IOT_PEER_MAX; */
pmlmeinfo->VHT_enable = 0;
pmlmeinfo->HE_enable = 0;
#ifdef ROKU_PRIVATE
pmlmeinfo->ht_vht_received = 0;
_rtw_memset(pmlmeinfo->SupportedRates_infra_ap, 0, NDIS_802_11_LENGTH_RATES_EX);
#endif /* ROKU_PRIVATE */
_rtw_memcpy(pnetwork, pbuf, FIELD_OFFSET(WLAN_BSSID_EX, IELength));
pnetwork->IELength = pbuf->IELength;
_rtw_memcpy(pnetwork->IEs, ((WLAN_BSSID_EX *)pbuf)->IEs, pnetwork->IELength);
pmlmeinfo->bcn_interval = get_beacon_interval(pnetwork);
/* sizeof(NDIS_802_11_FIXED_IEs) */
for (i = _FIXED_IE_LENGTH_; i < (pnetwork->IELength - 2);) {
pIE = (struct _NDIS_802_11_VARIABLE_IEs*)(pnetwork->IEs + i);
switch (pIE->ElementID) {
case _VENDOR_SPECIFIC_IE_: /* Get WMM IE. */
if (_rtw_memcmp(pIE->data, WMM_OUI, 4))
WMM_param_handler(a, pIE);
break;
#ifdef CONFIG_80211N_HT
case _HT_CAPABILITY_IE_: /* Get HT Cap IE. */
pmlmeinfo->HT_caps_enable = 1;
break;
case _HT_EXTRA_INFO_IE_: /* Get HT Info IE. */
pmlmeinfo->HT_info_enable = 1;
break;
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
case EID_VHTCapability: /* Get VHT Cap IE. */
pmlmeinfo->VHT_enable = 1;
break;
case EID_VHTOperation: /* Get VHT Operation IE. */
break;
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
case WLAN_EID_EXTENSION:
if (pIE->data[0] == WLAN_EID_EXTENSION_HE_CAPABILITY)
pmlmeinfo->HE_enable = 1;
break;
#endif /* CONFIG_80211AX_HE */
default:
break;
}
i += (pIE->Length + 2);
}
/*get chan/bw/offset info from IEs*/
rtw_bss_get_chbw(pnetwork,
&pmlmeext->chandef.chan, (u8 *)&pmlmeext->chandef.bw,
(u8 *)&pmlmeext->chandef.offset, 1, 1);
/*adjust chan/bw/offset with registary and hw cap*/
rtw_adjust_chbw(a, pmlmeext->chandef.chan, (u8 *)&pmlmeext->chandef.bw,
(u8 *)&pmlmeext->chandef.offset);
}
static void set_hw_prepare_connect(_adapter *padapter, struct sta_info *sta)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
WLAN_BSSID_EX *pnetwork = &pmlmeinfo->network;
#ifdef CONFIG_ANTENNA_DIVERSITY
rtw_antenna_select_cmd(padapter, pnetwork->PhyInfo.Optimum_antenna, _FALSE);
#endif
rtw_hw_prepare_connect(padapter, sta, pnetwork->MacAddress);
}
#define CONFIG_PHL_MI
#ifdef CONFIG_PHL_MI
/*
join_res = -1 caller is rtw_hw_connect_abort
join_res = 1 caller is rtw_hw_connected
*/
void rtw_join_done_chk_ch(_adapter *adapter, int join_res)
{
#define DUMP_ADAPTERS_STATUS 0
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
_adapter *iface;
struct mlme_priv *mlme;
struct mlme_ext_priv *mlmeext;
int chanctx_num = 0;
#if 1
struct rtw_chan_def chandef = {0};
#else
struct rtw_chan_def *chandef;
#endif
u8 u_ch = 0;
enum channel_width u_bw = 0;
enum chan_offset u_offset = 0;
int i, ret;
bool is_chctx_add = false;
if (DUMP_ADAPTERS_STATUS) {
RTW_INFO(FUNC_ADPT_FMT" enter\n", FUNC_ADPT_ARG(adapter));
dump_adapters_status(RTW_DBGDUMP , dvobj);
}
chanctx_num = rtw_phl_mr_get_chanctx_num(dvobj->phl, adapter->phl_role);
if (join_res >= 0 && chanctx_num <= 0) {
dump_adapters_status(RTW_DBGDUMP , dvobj);
RTW_ERR("%s join_res:%d, chanctx_num:%d failed\n", __func__, join_res, chanctx_num);
join_res = -1;
rtw_warn_on(1);
}
#if 1
rtw_phl_mr_get_chandef(dvobj->phl, adapter->phl_role, &chandef);
if (chandef.chan == 0) {
RTW_ERR("%s chandef.chan == 0\n", __func__);
rtw_warn_on(1);
return;
}
#else
if (adapter->phl_role->chanctx) {
chandef = &adapter->phl_role->chanctx->chan_def;
if (chandef.chan == 0) {
RTW_ERR("%s chandef.chan == 0\n", __func__);
rtw_warn_on(1);
return;
}
}
#endif
u_ch = chandef.chan;
u_bw = chandef.bw;
u_offset = chandef.offset;
if (join_res >= 0) { /*client join success - restart all ap*/
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlme = &iface->mlmepriv;
mlmeext = &iface->mlmeextpriv;
if (!iface || iface == adapter || !rtw_is_adapter_up(iface))
continue;
if ((MLME_IS_AP(iface) || MLME_IS_MESH(iface))
&& check_fwstate(mlme, WIFI_ASOC_STATE)
&& check_fwstate(mlme, WIFI_OP_CH_SWITCHING)
) {
u8 ori_ch, ori_bw, ori_offset;
/* handle AP which need to switch ch setting */
ori_ch = mlmeext->chandef.chan;
ori_bw = mlmeext->chandef.bw;
ori_offset = mlmeext->chandef.offset;
/* restore original bw, adjust bw by registry setting on target ch */
mlmeext->chandef.bw = mlme->ori_chandef.bw;
#if 1
mlmeext->chandef.chan = chandef.chan;
#else
mlmeext->chandef.chan = chandef->chan;
#endif
/*adjust offset according to union chan and bw*/
rtw_adjust_chbw(iface, mlmeext->chandef.chan,
(u8 *)&mlmeext->chandef.bw,
(u8 *)&mlmeext->chandef.offset);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(iface))
rtw_mesh_adjust_chbw(mlmeext->chandef.chan,
&mlmeext->chandef.bw,
&mlmeext->chandef.offset);
#endif
#if 0
rtw_chset_sync_chbw(adapter_to_chset(adapter)
, &mlmeext->chandef.chan, &mlmeext->chandef.bw, &mlmeext->chandef.offset
, &u_ch, &u_bw, &u_offset, 1, 0);
#endif
rtw_hw_update_chan_def(iface);
is_chctx_add = rtw_phl_chanctx_add(dvobj->phl, iface->phl_role,
&u_ch, &u_bw, &u_offset);
RTW_INFO(FUNC_ADPT_FMT" ori:%u,%u,%u => cur:%u,%u,%u => grp:%u,%u,%u - chctx_add:%s\n",
FUNC_ADPT_ARG(iface),
ori_ch, ori_bw, ori_offset,
mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset,
u_ch, u_bw, u_offset,
(is_chctx_add) ? "Y" : "N");
if (is_chctx_add == false) {
RTW_ERR(FUNC_ADPT_FMT" chctx_add failed\n", FUNC_ADPT_ARG(iface));
rtw_warn_on(1);
}
rtw_ap_update_bss_chbw(iface, &(mlmeext->mlmext_info.network)
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset);
_rtw_memcpy(&(mlme->cur_network.network), &(mlmeext->mlmext_info.network), sizeof(WLAN_BSSID_EX));
rtw_start_bss_hdl_after_chbw_decided(iface);
{
#if defined(CONFIG_IOCTL_CFG80211) && (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
u8 ht_option = 0;
#ifdef CONFIG_80211N_HT
ht_option = mlme->htpriv.ht_option;
#endif
rtw_cfg80211_ch_switch_notify(iface
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset
, ht_option, 0);
#endif
}
clr_fwstate(mlme, WIFI_OP_CH_SWITCHING);
rtw_update_beacon(iface, 0xFF, NULL, _TRUE, 0);
rtw_phl_cmd_stop_beacon(adapter_to_dvobj(adapter)->phl, iface->phl_role, _FALSE, PHL_CMD_DIRECTLY, 0);
}
}
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(adapter, MLME_STA_CONNECTED, 0);
#endif
#if 1
if (chandef.chan != u_ch)
#else
if (chandef->chan != u_ch)
#endif
{
RTW_ERR("[MI] chandef->chan != u_ch\n");
rtw_warn_on(1);
}
} else { /*client join failed - restart all ap on ori-chan*/
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlme = &iface->mlmepriv;
mlmeext = &iface->mlmeextpriv;
if (!iface || iface == adapter || !rtw_is_adapter_up(iface))
continue;
if ((MLME_IS_AP(iface) || MLME_IS_MESH(iface))
&& check_fwstate(mlme, WIFI_ASOC_STATE)
&& check_fwstate(mlme, WIFI_OP_CH_SWITCHING)
) {
u_ch = mlmeext->chandef.chan;
u_bw = mlmeext->chandef.bw;
u_offset = mlmeext->chandef.offset;
is_chctx_add = rtw_phl_chanctx_add(dvobj->phl, iface->phl_role,
&u_ch, &u_bw, &u_offset);
if (is_chctx_add == _FALSE) {
RTW_ERR(FUNC_ADPT_FMT "chctx_add failed\n", FUNC_ADPT_ARG(iface));
rtw_warn_on(1);
}
RTW_INFO(FUNC_ADPT_FMT" cur:%u,%u,%u => grp:%u,%u,%u chctx_add:%s\n",
FUNC_ADPT_ARG(iface),
mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset,
u_ch, u_bw, u_offset,
(is_chctx_add) ? "Y" : "N");
clr_fwstate(mlme, WIFI_OP_CH_SWITCHING);
rtw_update_beacon(iface, 0xFF, NULL, _TRUE, 0);
rtw_phl_cmd_stop_beacon(adapter_to_dvobj(adapter)->phl, iface->phl_role, _FALSE, PHL_CMD_DIRECTLY, 0);
}
}
#ifdef CONFIG_80211D
rtw_leavebss_update_regulatory(adapter);
#endif
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(adapter, MLME_STA_DISCONNECTED, 0);
#endif
}
RTW_INFO("[MI] union:%u,%u,%u\n", u_ch, u_bw, u_offset);
#if 1
RTW_INFO("[MI] chandef:%u,%u,%u\n", chandef.chan, chandef.bw, chandef.offset);
#else
RTW_INFO("[MI] chandef:%u,%u,%u\n", chandef->chan, chandef->bw, chandef->offset);
#endif
set_channel_bwmode(adapter, u_ch, u_offset, u_bw, _FALSE);
rtw_mi_update_union_chan_inf(adapter, u_ch, u_offset, u_bw);
if (join_res >= 0)
rtw_rfctl_update_op_mode(adapter_to_rfctl(adapter), BIT(adapter->iface_id), 1);
if (DUMP_ADAPTERS_STATUS) {
RTW_INFO(FUNC_ADPT_FMT" exit\n", FUNC_ADPT_ARG(adapter));
dump_adapters_status(RTW_DBGDUMP , dvobj);
}
}
int rtw_chk_start_clnt_join(_adapter *adapter, u8 *ch, u8 *bw, u8 *offset)
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
u8 u_ch = 0, cur_ch = 0;
enum channel_width u_bw = 0, cur_bw = 0;
enum chan_offset u_offset = 0, cur_offset = 0;
bool is_chctx_add = false;
struct mi_state mstate;
bool connect_allow = _TRUE;
if (!ch || !bw || !offset) {
connect_allow = _FALSE;
rtw_warn_on(1);
goto _exit;
}
u_ch = cur_ch = pmlmeext->chandef.chan;
u_bw = cur_bw = pmlmeext->chandef.bw;
u_offset = cur_offset = pmlmeext->chandef.offset;
RTW_INFO(FUNC_ADPT_FMT" CONT - CH:%d, BW:%d OFF:%d\n",
FUNC_ADPT_ARG(adapter),cur_ch, cur_bw, cur_offset);
is_chctx_add = rtw_phl_chanctx_add(dvobj->phl, adapter->phl_role,
&u_ch, &u_bw, &u_offset);
if (is_chctx_add == false) {
rtw_mi_status_no_self(adapter, &mstate);
RTW_INFO(FUNC_ADPT_FMT" others ld_sta_num:%u, ap_num:%u, mesh_num:%u\n"
, FUNC_ADPT_ARG(adapter), MSTATE_STA_LD_NUM(&mstate)
, MSTATE_AP_NUM(&mstate), MSTATE_MESH_NUM(&mstate));
if (MSTATE_STA_LD_NUM(&mstate) + MSTATE_AP_LD_NUM(&mstate) + MSTATE_MESH_LD_NUM(&mstate) >= 4)
connect_allow = _FALSE;
#if 0 /*def CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT*/
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlme = &iface->mlmepriv;
if (MLME_IS_STA(iface)
&& check_fwstate(mlme, WIFI_ASOC_STATE)
#if defined(CONFIG_P2P)
&& rtw_p2p_chk_state(&(iface->wdinfo), P2P_STATE_NONE)
#endif
) {
connect_allow = _FALSE;
break;
}
}
#endif /* CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT */
if (connect_allow == _FALSE) {
RTW_INFO(FUNC_ADPT_FMT" connect_allow = _FALSE\n", FUNC_ADPT_ARG(adapter));
goto _exit;
}
rtw_mi_buddy_disconnect(adapter);
rtw_phl_chanctx_del_no_self(dvobj->phl, adapter->phl_role);
u_ch = cur_ch;
u_bw = cur_bw;
u_offset = cur_offset;
is_chctx_add = rtw_phl_chanctx_add(dvobj->phl, adapter->phl_role,
&u_ch, &u_bw, &u_offset);
if (is_chctx_add == false) {
RTW_ERR("%s - %d chanctx_add failed\n", __FUNCTION__, __LINE__);
rtw_warn_on(1);
connect_allow = _FALSE;
goto _exit;
}
}
#ifdef CONFIG_80211D
rtw_joinbss_update_regulatory(adapter, &adapter->mlmeextpriv.mlmext_info.network);
#endif
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(adapter, MLME_STA_CONNECTING, 0);
#endif
*ch = u_ch;
*bw = u_bw;
*offset = u_offset;
_exit:
RTW_INFO(FUNC_ADPT_FMT" chctx_add:%s\n", FUNC_ADPT_ARG(adapter), (is_chctx_add) ? "Y" : "N");
RTW_INFO("Grouped - CH:%d, BW:%d OFF:%d\n",u_ch, u_bw, u_offset);
return connect_allow;
}
#else
void rtw_join_done_chk_ch(_adapter *adapter, int join_res)
{
#define DUMP_ADAPTERS_STATUS 0
struct dvobj_priv *dvobj;
_adapter *iface;
struct mlme_priv *mlme;
struct mlme_ext_priv *mlmeext;
u8 u_ch, u_offset, u_bw;
int i, ret;
dvobj = adapter_to_dvobj(adapter);
if (DUMP_ADAPTERS_STATUS) {
RTW_INFO(FUNC_ADPT_FMT" enter\n", FUNC_ADPT_ARG(adapter));
dump_adapters_status(RTW_DBGDUMP , dvobj);
}
ret = rtw_mi_get_ch_setting_union(adapter, &u_ch, &u_bw, &u_offset);
if (join_res >= 0 && ret <= 0) {
join_res = -1;
dump_adapters_status(RTW_DBGDUMP , dvobj);
rtw_warn_on(1);
}
if (join_res >= 0) {
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlme = &iface->mlmepriv;
mlmeext = &iface->mlmeextpriv;
if (!iface || iface == adapter)
continue;
if ((MLME_IS_AP(iface) || MLME_IS_MESH(iface))
&& check_fwstate(mlme, WIFI_ASOC_STATE)
) {
u8 ori_ch, ori_bw, ori_offset;
bool is_grouped = rtw_is_chbw_grouped(u_ch, u_bw, u_offset
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset);
if (is_grouped == _FALSE) {
/* handle AP which need to switch ch setting */
ori_ch = mlmeext->chandef.chan;
ori_bw = mlmeext->chandef.bw;
ori_offset = mlmeext->chandef.offset;
/* restore original bw, adjust bw by registry setting on target ch */
mlmeext->chandef.bw = mlme->ori_chandef.bw;
mlmeext->chandef.chan = u_ch;
rtw_adjust_chbw(iface, mlmeext->chandef.chan,
(u8 *)&mlmeext->chandef.bw,
(u8 *)&mlmeext->chandef.offset);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(iface))
rtw_mesh_adjust_chbw(mlmeext->chandef.chan,
&mlmeext->chandef.bw,
&mlmeext->chandef.offset);
#endif
rtw_chset_sync_chbw(adapter_to_chset(adapter)
, &mlmeext->chandef.chan, &mlmeext->chandef.bw, &mlmeext->chandef.offset
, &u_ch, &u_bw, &u_offset, 1, 0);
RTW_INFO(FUNC_ADPT_FMT" %u,%u,%u => %u,%u,%u\n", FUNC_ADPT_ARG(iface)
, ori_ch, ori_bw, ori_offset
, mlmeext->chandef.chan, mlmeext->mlmeext->chandef.bw, mlmeext->chandef.offset);
rtw_ap_update_bss_chbw(iface, &(mlmeext->mlmext_info.network)
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset);
_rtw_memcpy(&(mlme->cur_network.network), &(mlmeext->mlmext_info.network), sizeof(WLAN_BSSID_EX));
rtw_start_bss_hdl_after_chbw_decided(iface);
{
#if defined(CONFIG_IOCTL_CFG80211) && (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
u8 ht_option = 0;
#ifdef CONFIG_80211N_HT
ht_option = mlme->htpriv.ht_option;
#endif
rtw_cfg80211_ch_switch_notify(iface
, mlmeext->chandef.chan, mlmeext->chandef.bw, mlmeext->chandef.offset
, ht_option, 0);
#endif
}
}
clr_fwstate(mlme, WIFI_OP_CH_SWITCHING);
rtw_update_beacon(iface, 0xFF, NULL, _TRUE, 0);
}
}
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(adapter, MLME_STA_CONNECTED, 0);
#endif
} else {
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlme = &iface->mlmepriv;
mlmeext = &iface->mlmeextpriv;
if (!iface || iface == adapter)
continue;
if ((MLME_IS_AP(iface) || MLME_IS_MESH(iface))
&& check_fwstate(mlme, WIFI_ASOC_STATE)
) {
clr_fwstate(mlme, WIFI_OP_CH_SWITCHING);
rtw_update_beacon(iface, 0xFF, NULL, _TRUE, 0);
}
}
#ifdef CONFIG_80211D
rtw_leavebss_update_regulatory(adapter);
#endif
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(adapter, MLME_STA_DISCONNECTED, 0);
#endif
}
if (rtw_mi_get_ch_setting_union(adapter, &u_ch, &u_bw, &u_offset)) {
RTW_INFO(FUNC_ADPT_FMT" union:%u,%u,%u\n", FUNC_ADPT_ARG(adapter), u_ch, u_bw, u_offset);
set_channel_bwmode(adapter, u_ch, u_offset, u_bw, _FALSE);
rtw_mi_update_union_chan_inf(adapter, u_ch, u_offset, u_bw);
}
if (DUMP_ADAPTERS_STATUS) {
RTW_INFO(FUNC_ADPT_FMT" exit\n", FUNC_ADPT_ARG(adapter));
dump_adapters_status(RTW_DBGDUMP , dvobj);
}
}
int rtw_chk_start_clnt_join(_adapter *adapter, u8 *ch, u8 *bw, u8 *offset)
{
#ifdef CONFIG_CONCURRENT_MODE
bool chbw_allow = _TRUE;
#endif
bool connect_allow = _TRUE;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
u8 cur_ch, cur_bw, cur_ch_offset;
u8 u_ch, u_offset, u_bw;
u_ch = cur_ch = pmlmeext->chandef.chan;
u_bw = cur_bw = pmlmeext->chandef.bw;
u_offset = cur_ch_offset = pmlmeext->chandef.offset;
if (!ch || !bw || !offset) {
connect_allow = _FALSE;
rtw_warn_on(1);
goto exit;
}
if (cur_ch == 0) {
connect_allow = _FALSE;
RTW_ERR(FUNC_ADPT_FMT" cur_ch:%u\n"
, FUNC_ADPT_ARG(adapter), cur_ch);
rtw_warn_on(1);
goto exit;
}
RTW_INFO(FUNC_ADPT_FMT" req: %u,%u,%u\n", FUNC_ADPT_ARG(adapter), u_ch, u_bw, u_offset);
#ifdef CONFIG_CONCURRENT_MODE
{
struct dvobj_priv *dvobj;
_adapter *iface;
struct mlme_priv *mlme;
struct mlme_ext_priv *mlmeext;
struct mi_state mstate;
int i;
dvobj = adapter_to_dvobj(adapter);
rtw_mi_status_no_self(adapter, &mstate);
RTW_INFO(FUNC_ADPT_FMT" others ld_sta_num:%u, ap_num:%u, mesh_num:%u\n"
, FUNC_ADPT_ARG(adapter), MSTATE_STA_LD_NUM(&mstate)
, MSTATE_AP_NUM(&mstate), MSTATE_MESH_NUM(&mstate));
if (!MSTATE_STA_LD_NUM(&mstate) && !MSTATE_AP_NUM(&mstate) && !MSTATE_MESH_NUM(&mstate)) {
/* consider linking STA? */
goto connect_allow_hdl;
}
if (rtw_mi_get_ch_setting_union_no_self(adapter, &u_ch, &u_bw, &u_offset) <= 0) {
dump_adapters_status(RTW_DBGDUMP , dvobj);
rtw_warn_on(1);
}
RTW_INFO(FUNC_ADPT_FMT" others union:%u,%u,%u\n"
, FUNC_ADPT_ARG(adapter), u_ch, u_bw, u_offset);
/* chbw_allow? */
chbw_allow = rtw_is_chbw_grouped(pmlmeext->chandef.chan, pmlmeext->chandef.bw, pmlmeext->chandef.offset
, u_ch, u_bw, u_offset);
RTW_INFO(FUNC_ADPT_FMT" chbw_allow:%d\n"
, FUNC_ADPT_ARG(adapter), chbw_allow);
if (chbw_allow == _TRUE) {
rtw_sync_chbw(&cur_ch, &cur_bw, &cur_ch_offset, &u_ch, &u_bw, &u_offset);
rtw_warn_on(cur_ch != pmlmeext->chandef.chan);
rtw_warn_on(cur_bw != pmlmeext->chandef.bw);
rtw_warn_on(cur_ch_offset != pmlmeext->chandef.offset);
goto connect_allow_hdl;
}
#ifdef CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT
/* chbw_allow is _FALSE, connect allow? */
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlme = &iface->mlmepriv;
if (MLME_IS_STA(iface) &&
#if defined(CONFIG_P2P)
!rtw_p2p_chk_role(&(iface->wdinfo), P2P_ROLE_CLIENT) &&
!rtw_p2p_chk_role(&(iface->wdinfo), P2P_ROLE_GO) &&
#endif
check_fwstate(mlme, WIFI_ASOC_STATE)) {
connect_allow = _FALSE;
break;
}
}
#endif /* CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT */
if (MSTATE_STA_LD_NUM(&mstate) + MSTATE_AP_LD_NUM(&mstate) + MSTATE_MESH_LD_NUM(&mstate) >= 4)
connect_allow = _FALSE;
RTW_INFO(FUNC_ADPT_FMT" connect_allow:%d\n"
, FUNC_ADPT_ARG(adapter), connect_allow);
if (connect_allow == _FALSE)
goto exit;
connect_allow_hdl:
/* connect_allow == _TRUE */
if (chbw_allow == _FALSE) {
u_ch = cur_ch;
u_bw = cur_bw;
u_offset = cur_ch_offset;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlme = &iface->mlmepriv;
if (!iface || iface == adapter)
continue;
if ((MLME_IS_AP(iface) || MLME_IS_MESH(iface))
&& check_fwstate(mlme, WIFI_ASOC_STATE)
) {
#ifdef CONFIG_SPCT_CH_SWITCH
if (1)
rtw_ap_inform_ch_switch(iface, pmlmeext->chandef.chan , pmlmeext->chandef.offset);
else
#endif
rtw_sta_flush(iface, _FALSE);
rtw_hal_set_hwreg(iface, HW_VAR_CHECK_TXBUF, 0);
set_fwstate(mlme, WIFI_OP_CH_SWITCHING);
} else if (MLME_IS_STA(iface)
&& check_fwstate(mlme, WIFI_ASOC_STATE)
) {
rtw_disassoc_cmd(iface, 500, RTW_CMDF_DIRECTLY);
#ifndef CONFIG_STA_CMD_DISPR
rtw_free_assoc_resources(iface, _TRUE);
#endif /* !CONFIG_STA_CMD_DISPR */
rtw_indicate_disconnect(iface, 0, _FALSE);
}
}
}
}
#endif /* CONFIG_CONCURRENT_MODE */
#ifdef CONFIG_80211D
rtw_joinbss_update_regulatory(adapter, &adapter->mlmeextpriv.mlmext_info.network);
#endif
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(adapter, MLME_STA_CONNECTING, 0);
#endif
exit:
if (connect_allow == _TRUE) {
RTW_INFO(FUNC_ADPT_FMT" union: %u,%u,%u\n", FUNC_ADPT_ARG(adapter), u_ch, u_bw, u_offset);
*ch = u_ch;
*bw = u_bw;
*offset = u_offset;
#if defined(CONFIG_IOCTL_CFG80211) && (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
{
u8 ht_option = 0;
#ifdef CONFIG_80211N_HT
ht_option = adapter->mlmepriv.htpriv.ht_option;
#endif /* CONFIG_80211N_HT */
/*
when supplicant send the mlme frame,
the bss freq is updated by channel switch event.
*/
rtw_cfg80211_ch_switch_notify(adapter,
cur_ch, cur_bw, cur_ch_offset, ht_option, 1);
}
#endif
}
return connect_allow == _TRUE ? _SUCCESS : _FAIL;
}
#endif
u8 rtw_join_cmd_hdl(_adapter *padapter, u8 *pbuf)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
WLAN_BSSID_EX *pnetwork = &pmlmeinfo->network;
struct sta_info *sta = NULL;
u8 u_ch, u_bw, u_offset;
/* Check pbuf->IELength */
if (((struct _WLAN_BSSID_EX*)pbuf)->IELength > MAX_IE_SZ)
return H2C_PARAMETERS_ERROR;
if (((struct _WLAN_BSSID_EX*)pbuf)->IELength < 2) {
report_join_res(padapter, (-4), WLAN_STATUS_UNSPECIFIED_FAILURE);
return H2C_SUCCESS;
}
set_hw_before_join(padapter);
/*update HT/VHT/HE CAP and chan/bw/offset from join_info-pbuf*/
update_join_info(padapter, (struct _WLAN_BSSID_EX *)pbuf);
sta = rtw_get_stainfo(&padapter->stapriv, padapter->phl_role->mac_addr);
rtw_free_stainfo(padapter, sta);
sta = rtw_alloc_stainfo(&padapter->stapriv, pnetwork->MacAddress);
if (sta == NULL) {
RTW_ERR("alloc sta "MAC_FMT" fail\n", MAC_ARG(pnetwork->MacAddress));
return H2C_CMD_FAIL;
}
/* check channel, bandwidth, offset and switch */
if (rtw_chk_start_clnt_join(padapter, &u_ch, &u_bw, &u_offset) == _FAIL) {
report_join_res(padapter, (-4), WLAN_STATUS_UNSPECIFIED_FAILURE);
return H2C_SUCCESS;
}
/*allow for connection*/
set_hw_prepare_connect(padapter, sta);
rtw_hw_update_chan_def(padapter);
set_channel_bwmode(padapter, u_ch, u_offset, u_bw, _TRUE);
rtw_mi_update_union_chan_inf(padapter, u_ch, u_offset, u_bw);
rtw_phl_mr_dump_cur_chandef(adapter_to_dvobj(padapter)->phl, padapter->phl_role);
/* cancel link timer */
cancel_link_timer(pmlmeext); /*_cancel_timer_ex(&pmlmeext->link_timer);*/
/*Client and AD-Hoc client*/
start_clnt_join(padapter);
return H2C_SUCCESS;
}
u8 disconnect_hdl(_adapter *padapter, unsigned char *pbuf)
{
#if CONFIG_DFS
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
#endif
struct disconnect_parm *param = (struct disconnect_parm *)pbuf;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)(&(pmlmeinfo->network));
u8 val8;
/* For STA, disconnect flow only for conneted case */
if (MLME_IS_STA(padapter) && !MLME_IS_ASOC(padapter))
goto exit;
if (is_client_associated_to_ap(padapter)
#if CONFIG_DFS
&& !IS_RADAR_DETECTED(rfctl) && !rfctl->csa_chandef.chan
#endif
) {
#ifdef CONFIG_PLATFORM_ROCKCHIPS
/* To avoid connecting to AP fail during resume process, change retry count from 5 to 1 */
issue_deauth_ex(padapter, pnetwork->MacAddress, WLAN_REASON_DEAUTH_LEAVING, 1, 100);
#else
issue_deauth_ex(padapter, pnetwork->MacAddress, WLAN_REASON_DEAUTH_LEAVING, param->deauth_timeout_ms / 100, 100);
#endif /* CONFIG_PLATFORM_ROCKCHIPS */
}
if (((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE) || ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE)) {
/* Stop BCN */
val8 = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_BCN_FUNC, (u8 *)(&val8));
}
rtw_mlmeext_disconnect(padapter);
#if 0
rtw_free_uc_swdec_pending_queue(adapter_to_dvobj(padapter));
#endif
exit:
return H2C_SUCCESS;
}
/**
* rtw_ps_annc - check and doing ps announcement for all the adapters
* @adapter: the requesting adapter
* @ps: power saving or not
*
* Returns: 0: no ps announcement is doing. 1: ps announcement is doing
*/
u8 rtw_ps_annc(_adapter *adapter, bool ps)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
_adapter *iface;
int i;
u8 ps_anc = 0;
#ifdef CONFIG_MCC_MODE
if (rtw_hw_mcc_chk_inprogress(adapter)) {
RTW_WARN("under mcc, skip ps_anc\n");
return ps_anc;
}
#endif
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface)
continue;
if (MLME_IS_STA(iface)) {
if (is_client_associated_to_ap(iface) == _TRUE) {
/* TODO: TDLS peers */
issue_nulldata(iface, NULL, ps, 3, 500);
ps_anc = 1;
}
#ifdef CONFIG_RTW_MESH
} else if (MLME_IS_MESH(iface)) {
if (rtw_mesh_ps_annc(iface, ps))
ps_anc = 1;
#endif
}
}
return ps_anc;
}
void rtw_back_opch(_adapter *adapter)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
_rtw_mutex_lock_interruptible(&rfctl->offch_mutex);
if (rfctl->offch_state != OFFCHS_NONE) {
rfctl->offch_state = OFFCHS_BACKING_OP;
rtw_hal_macid_wakeup_all_used(adapter);
rtw_ps_annc(adapter, 0);
rfctl->offch_state = OFFCHS_NONE;
rtw_mi_os_xmit_schedule(adapter);
}
_rtw_mutex_unlock(&rfctl->offch_mutex);
}
void rtw_leave_opch(_adapter *adapter)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
_rtw_mutex_lock_interruptible(&rfctl->offch_mutex);
if (rfctl->offch_state == OFFCHS_NONE) {
/* prepare to leave operating channel */
rfctl->offch_state = OFFCHS_LEAVING_OP;
/* clear HW TX queue */
rtw_hal_set_hwreg(adapter, HW_VAR_CHECK_TXBUF, 0);
rtw_hal_macid_sleep_all_used(adapter);
rtw_ps_annc(adapter, 1);
rfctl->offch_state = OFFCHS_LEAVE_OP;
}
_rtw_mutex_unlock(&rfctl->offch_mutex);
}
u8 setauth_hdl(_adapter *padapter, unsigned char *pbuf)
{
struct setauth_parm *pparm = (struct setauth_parm *)pbuf;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pparm->mode < 4)
pmlmeinfo->auth_algo = pparm->mode;
return H2C_SUCCESS;
}
static u8 amsdu_spp_enable(_adapter *pdapter, enum security_type type)
{
u8 ret = _FALSE;
if (pdapter->registrypriv.amsdu_mode == RTW_AMSDU_MODE_SPP) {
if ( type == _AES_ || type == _CCMP_256_
|| type == _GCMP_ || type == _GCMP_256_ )
ret = _SUCCESS;
}
return ret;
}
#ifdef CONFIG_CMD_DISP
/*Set WEP key or Group Key*/
u8 setkey_hdl(struct _ADAPTER *a, struct setkey_parm *key,
enum phl_cmd_type cmd_type, u32 cmd_timeout)
{
struct mlme_ext_info *info = &a->mlmeextpriv.mlmext_info;
u8 keytype = 1; /* 1 for Group Key */
u8 *mac;
struct sta_info *sta;
u8 spp = 0;
if (((info->state & 0x03) == WIFI_FW_AP_STATE)
|| ((info->state & 0x03) == WIFI_FW_ADHOC_STATE))
mac = adapter_mac_addr(a);
else
mac = get_bssid(&a->mlmepriv);
sta = rtw_get_stainfo(&a->stapriv, mac);
if (!sta) {
RTW_ERR("%s: sta %pM not found\n", __func__, mac);
goto exit;
}
/* main tx key for wep. */
if (key->set_tx)
a->mlmeextpriv.mlmext_info.key_index = key->keyid;
/* Change to Unicast for WEP */
if (is_wep_enc(key->algorithm))
keytype = 0;
#ifdef CONFIG_IEEE80211W
if (key->algorithm == _BIP_CMAC_128_)
keytype = 2;
#endif
if (amsdu_spp_enable(a, key->algorithm) == _SUCCESS)
spp = 1;
RTW_PRINT("%s: set %s key for %pM, kid:%d type:%u algo:%s\n",
__func__, is_wep_enc(key->algorithm)?"WEP":"group", mac,
key->keyid, keytype, security_type_str(key->algorithm));
rtw_hw_add_key(a, sta, key->keyid, key->algorithm, keytype, key->key, spp, cmd_type, cmd_timeout);
#ifdef CONFIG_LAYER2_ROAMING
dequeuq_roam_pkt(a);
#endif
exit:
return H2C_SUCCESS;
}
#else
/*Set WEP key or Group Key*/
u8 setkey_hdl(struct _ADAPTER *a, u8 *pbuf)
{
struct setkey_parm *key = (struct setkey_parm *)pbuf;
struct mlme_ext_info *info = &a->mlmeextpriv.mlmext_info;
u8 keytype = 1; /* 1 for Group Key */
u8 *mac;
struct sta_info *sta;
u8 spp = 0;
if (((info->state & 0x03) == WIFI_FW_AP_STATE)
|| ((info->state & 0x03) == WIFI_FW_ADHOC_STATE))
mac = adapter_mac_addr(a);
else
mac = get_bssid(&a->mlmepriv);
sta = rtw_get_stainfo(&a->stapriv, mac);
if (!sta) {
RTW_ERR("%s: sta %pM not found\n", __func__, mac);
goto exit;
}
/* main tx key for wep. */
if (key->set_tx)
a->mlmeextpriv.mlmext_info.key_index = key->keyid;
#ifdef CONFIG_LPS_PG
if (adapter_to_pwrctl(a)->lps_level == LPS_PG)
LPS_Leave(a, "SET_KEY");
#endif
/* Change to Unicast for WEP */
if (is_wep_enc(key->algorithm))
keytype = 0;
#ifdef CONFIG_IEEE80211W
if (key->algorithm == _BIP_CMAC_128_)
keytype = 2;
#endif
if (amsdu_spp_enable(a, key->algorithm) == _SUCCESS)
spp = 1;
RTW_PRINT("%s: set %s key for %pM, kid:%d type:%u algo:%s\n",
__func__, is_wep_enc(key->algorithm)?"WEP":"group", mac,
key->keyid, keytype, security_type_str(key->algorithm));
rtw_hw_add_key(a, sta, key->keyid, key->algorithm, keytype, key->key, spp, PHL_CMD_DIRECTLY, 0);
#ifdef CONFIG_LAYER2_ROAMING
dequeuq_roam_pkt(a);
#endif
exit:
return H2C_SUCCESS;
}
#endif
void rtw_ap_wep_pk_setting(_adapter *adapter, struct sta_info *psta)
{
struct security_priv *psecuritypriv = &(adapter->securitypriv);
struct set_stakey_parm sta_pparm;
sint keyid;
if (!is_wep_enc(psecuritypriv->dot11PrivacyAlgrthm))
return;
for (keyid = 0; keyid < 4; keyid++) {
if ((psecuritypriv->key_mask & BIT(keyid)) && (keyid == psecuritypriv->dot11PrivacyKeyIndex)) {
sta_pparm.algorithm = psecuritypriv->dot11PrivacyAlgrthm;
sta_pparm.keyid = keyid;
sta_pparm.gk = 0;
_rtw_memcpy(sta_pparm.key, &(psecuritypriv->dot11DefKey[keyid].skey[0]), 16);
_rtw_memcpy(sta_pparm.addr, psta->phl_sta->mac_addr, ETH_ALEN);
RTW_PRINT(FUNC_ADPT_FMT"set WEP - PK with "MAC_FMT" keyid:%u\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->phl_sta->mac_addr), keyid);
#ifdef CONFIG_CMD_DISP
set_stakey_hdl(adapter, &sta_pparm, PHL_CMD_DIRECTLY, 0);
#else /* CONFIG_FSM */
set_stakey_hdl(adapter, (u8 *)&sta_pparm);
#endif
}
}
}
#ifdef CONFIG_CMD_DISP
u8 set_stakey_hdl(struct _ADAPTER *a, struct set_stakey_parm *key,
enum phl_cmd_type cmd_type, u32 cmd_timeout)
{
struct sta_priv *pstapriv = &a->stapriv;
struct sta_info *sta;
int err = 0;
u8 ret = H2C_SUCCESS;
u8 spp = 0;
sta = rtw_get_stainfo(pstapriv, key->addr);
if (!sta) {
RTW_ERR("%s: sta %pM not found\n", __func__, key->addr);
ret = H2C_REJECTED;
goto exit;
}
a->mlmeextpriv.mlmext_info.enc_algo = key->algorithm;
if (key->algorithm == _NO_PRIVACY_) {
RTW_INFO("%s: del all key for %pM for _NO_PRIVACY_\n",
__func__, key->addr);
err = rtw_hw_del_all_key(a, sta, PHL_CMD_DIRECTLY, 0);
} else {
RTW_INFO("%s: set %s key for %pM, kid:%d algo:%s\n",
__func__, key->gk?"group":"pairwise",
key->addr, key->keyid,
security_type_str(key->algorithm));
if (amsdu_spp_enable(a, key->algorithm) == _SUCCESS)
spp = 1;
#ifdef CONFIG_WAPI_SUPPORT
if(key->algorithm == _SMS4_)
sta->phl_sta->wapi = true;
#endif
err = rtw_hw_add_key(a, sta, key->keyid, key->algorithm,
key->gk, key->key, spp, PHL_CMD_DIRECTLY, 0);
}
if (!(key->gk))
ATOMIC_INC(&sta->keytrack); /*CVE-2020-24587*/
if (err)
RTW_ERR("%s: FAIL to set %s key for %pM, kid:%d algo:%s !\n",
__func__, key->gk?"group":"pairwise",
key->addr, key->keyid,
security_type_str(key->algorithm));
ret = H2C_SUCCESS_RSP;
exit:
return ret;
}
#else /* CONFIG_FSM */
u8 set_stakey_hdl(struct _ADAPTER *a, u8 *pbuf)
{
struct set_stakey_parm *key = (struct set_stakey_parm *)pbuf;
struct sta_priv *pstapriv = &a->stapriv;
struct sta_info *sta;
int err = 0;
u8 ret = H2C_SUCCESS;
u8 spp = 0;
sta = rtw_get_stainfo(pstapriv, key->addr);
if (!sta) {
RTW_ERR("%s: sta %pM not found\n", __func__, key->addr);
ret = H2C_REJECTED;
goto exit;
}
a->mlmeextpriv.mlmext_info.enc_algo = key->algorithm;
#ifdef CONFIG_LPS_PG
if (adapter_to_pwrctl(a)->lps_level == LPS_PG)
LPS_Leave(a, "SET_KEY");
#endif
if (key->algorithm == _NO_PRIVACY_) {
RTW_INFO("%s: del all key for %pM for _NO_PRIVACY_\n",
__func__, key->addr);
err = rtw_hw_del_all_key(a, sta, PHL_CMD_DIRECTLY, 0);
} else {
RTW_INFO("%s: set %s key for %pM, kid:%d algo:%s\n",
__func__, key->gk?"group":"pairwise",
key->addr, key->keyid,
security_type_str(key->algorithm));
if (amsdu_spp_enable(a, key->algorithm) == _SUCCESS)
spp = 1;
err = rtw_hw_add_key(a, sta, key->keyid, key->algorithm,
key->gk, key->key, spp, PHL_CMD_DIRECTLY, 0);
}
if (!(key->gk))
ATOMIC_INC(&sta->keytrack); /*CVE-2020-24587*/
if (err)
RTW_ERR("%s: FAIL to set %s key for %pM, kid:%d algo:%s !\n",
__func__, key->gk?"group":"pairwise",
key->addr, key->keyid,
security_type_str(key->algorithm));
ret = H2C_SUCCESS_RSP;
exit:
return ret;
}
#endif
u8 add_ba_hdl(_adapter *padapter, unsigned char *pbuf)
{
struct addBaReq_parm *pparm = (struct addBaReq_parm *)pbuf;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_info *psta = rtw_get_stainfo(&padapter->stapriv, pparm->addr);
if (!psta)
return H2C_SUCCESS;
#ifdef CONFIG_80211N_HT
if (((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && (pmlmeinfo->HT_enable)) ||
((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE)) {
/* pmlmeinfo->ADDBA_retry_count = 0; */
/* pmlmeinfo->candidate_tid_bitmap |= (0x1 << pparm->tid); */
/* psta->htpriv.candidate_tid_bitmap |= BIT(pparm->tid); */
issue_addba_req(padapter, pparm->addr, (u8)pparm->tid);
_set_timer(&psta->addba_retry_timer, ADDBA_TO);
}
#ifdef CONFIG_TDLS
else if ((psta->tdls_sta_state & TDLS_LINKED_STATE) &&
(psta->htpriv.ht_option == _TRUE) &&
(psta->htpriv.ampdu_enable == _TRUE)) {
issue_addba_req(padapter, pparm->addr, (u8)pparm->tid);
_set_timer(&psta->addba_retry_timer, ADDBA_TO);
}
#endif /* CONFIG */
else
psta->htpriv.candidate_tid_bitmap &= ~BIT(pparm->tid);
#endif /* CONFIG_80211N_HT */
return H2C_SUCCESS;
}
u8 add_ba_rsp_hdl(_adapter *padapter, unsigned char *pbuf)
{
struct addBaRsp_parm *pparm = (struct addBaRsp_parm *)pbuf;
struct recv_reorder_ctrl *preorder_ctrl;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta;
u8 ret = _TRUE;
psta = rtw_get_stainfo(pstapriv, pparm->addr);
if (!psta)
goto exit;
if (pparm->status == 0) {
rtw_phl_start_rx_ba_session(padapter->dvobj->phl, psta->phl_sta,
pparm->preq.dialog_token, 3,
pparm->start_seq, 0, pparm->tid,
pparm->size);
}
preorder_ctrl = &psta->recvreorder_ctrl[pparm->tid];
ret = issue_addba_rsp_wait_ack(padapter, pparm->addr, pparm->tid,
pparm->status, pparm->size,
&(pparm->preq), 3, 50);
#ifdef CONFIG_UPDATE_INDICATE_SEQ_WHILE_PROCESS_ADDBA_REQ
/* status = 0 means accept this addba req, so update indicate seq = start_seq under this compile flag */
if (pparm->status == 0) {
preorder_ctrl->indicate_seq = pparm->start_seq;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_UPDATE indicate_seq:%d, start_seq:%d\n"
, FUNC_ADPT_ARG(padapter), preorder_ctrl->tid, preorder_ctrl->indicate_seq, pparm->start_seq);
#endif
}
#else
rtw_set_bit(RTW_RECV_ACK_OR_TIMEOUT, &preorder_ctrl->rec_abba_rsp_ack);
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_CLEAR indicate_seq:%d, "
"start_seq:%d preorder_ctrl->rec_abba_rsp_ack =%lu "
"pparm->preq.dialog_token=%d pparm->preq.ba_p_set=%d\n"
, FUNC_ADPT_ARG(padapter)
, preorder_ctrl->tid
, preorder_ctrl->indicate_seq
, pparm->start_seq
, preorder_ctrl->rec_abba_rsp_ack
, pparm->preq.dialog_token
, pparm->preq.ba_p_set
);
#endif
#endif
/*
* status = 0 means accept this addba req
* status = 37 means reject this addba req
*/
if (pparm->status == 0) {
preorder_ctrl->enable = _TRUE;
preorder_ctrl->ampdu_size = pparm->size;
} else if (pparm->status == 37)
preorder_ctrl->enable = _FALSE;
exit:
return H2C_SUCCESS;
}
u8 delba_hdl(struct _ADAPTER *a, unsigned char *pbuf)
{
struct addBaReq_parm *parm = (struct addBaReq_parm *)pbuf;
struct sta_info *sta;
sta = rtw_get_stainfo(&a->stapriv, parm->addr);
if (!sta) {
RTW_WARN(FUNC_ADPT_FMT ": No STA(" MAC_FMT ") for DELBA!\n",
FUNC_ADPT_ARG(a), MAC_ARG(parm->addr));
return H2C_SUCCESS;
}
rtw_phl_stop_rx_ba_session(a->dvobj->phl, sta->phl_sta, parm->tid);
return H2C_SUCCESS;
}
u8 chk_bmc_sleepq_cmd(_adapter *padapter)
{
struct cmd_obj *cmd;
struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(padapter)->cmdpriv);
u8 res = _SUCCESS;
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
init_h2fwcmd_w_parm_no_parm_rsp(cmd, CMD_CHK_BMCSLEEPQ);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
exit:
return res;
}
u8 set_tx_beacon_cmd(_adapter *padapter, u8 flags)
{
struct cmd_obj *cmd;
struct Tx_Beacon_param *ptxBeacon_parm;
struct cmd_priv *pcmdpriv = &(adapter_to_dvobj(padapter)->cmdpriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct submit_ctx sctx;
u8 res = _SUCCESS;
int len_diff = 0;
/*prepare cmd parameter*/
ptxBeacon_parm = (struct Tx_Beacon_param *)rtw_zmalloc(sizeof(struct Tx_Beacon_param));
if (ptxBeacon_parm == NULL) {
res = _FAIL;
goto exit;
}
_rtw_memcpy(&(ptxBeacon_parm->network), &(pmlmeinfo->network), sizeof(WLAN_BSSID_EX));
len_diff = update_hidden_ssid(
ptxBeacon_parm->network.IEs + _BEACON_IE_OFFSET_
, ptxBeacon_parm->network.IELength - _BEACON_IE_OFFSET_
, pmlmeinfo->hidden_ssid_mode
);
ptxBeacon_parm->network.IELength += len_diff;
/* need enqueue, prepare cmd_obj and enqueue */
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
rtw_mfree((u8 *)ptxBeacon_parm, sizeof(*ptxBeacon_parm));
goto exit;
}
cmd->padapter = padapter;
init_h2fwcmd_w_parm_no_rsp(cmd, ptxBeacon_parm, CMD_TX_BEACON);
if (flags & RTW_CMDF_WAIT_ACK) {
cmd->sctx = &sctx;
rtw_sctx_init(&sctx, 10 * 1000);
}
res = rtw_enqueue_cmd(pcmdpriv, cmd);
if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) {
rtw_sctx_wait(&sctx, __func__);
_rtw_mutex_lock_interruptible(&pcmdpriv->sctx_mutex);
if (sctx.status == RTW_SCTX_SUBMITTED)
cmd->sctx = NULL;
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
}
exit:
return res;
}
u8 mlme_evt_hdl(_adapter *padapter, unsigned char *pbuf)
{
struct rtw_evt_header *evt_hdr;
u8 *peventbuf;
void (*event_callback)(_adapter *dev, u8 *pbuf);
struct cmd_priv *pcmd_priv = &adapter_to_dvobj(padapter)->cmdpriv;
if (pbuf == NULL)
goto _abort_event_;
evt_hdr = (struct rtw_evt_header *)pbuf;
peventbuf = pbuf + sizeof(struct rtw_evt_header);
#ifdef CHECK_EVENT_SEQ
/* checking event sequence... */
if (evt_hdr->seq != (ATOMIC_READ(&pcmd_priv->event_seq) & 0x7f)) {
pcmd_priv->event_seq = (evt_hdr->seq + 1) & 0x7f;
goto _abort_event_;
}
#endif
/* checking if event code is valid */
if (evt_hdr->id >= EVT_ID_MAX) {
goto _abort_event_;
}
/* checking if event size match the event parm size */
if ((wlanevents[evt_hdr->id].parmsize != 0) &&
(wlanevents[evt_hdr->id].parmsize != evt_hdr->len)) {
goto _abort_event_;
}
ATOMIC_INC(&pcmd_priv->event_seq);
if (peventbuf) {
event_callback = wlanevents[evt_hdr->id].event_callback;
event_callback(padapter, (u8 *)peventbuf);
pcmd_priv->evt_done_cnt++;
}
_abort_event_:
return H2C_SUCCESS;
}
u8 chk_bmc_sleepq_hdl(_adapter *padapter, unsigned char *pbuf)
{
#ifdef CONFIG_AP_MODE
struct sta_info *psta_bmc;
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
/* for BC/MC Frames */
psta_bmc = rtw_get_bcmc_stainfo(padapter);
if (!psta_bmc)
return H2C_SUCCESS;
if ((rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, 0)) && (psta_bmc->sleepq_len > 0)) {
#ifndef CONFIG_PCI_HCI
rtw_msleep_os(10);/* 10ms, ATIM(HIQ) Windows */
#endif
/* _rtw_spinlock_bh(&psta_bmc->sleep_q.lock); */
_rtw_spinlock_bh(&pxmitpriv->lock);
xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
xmitframe_plist = get_next(xmitframe_plist);
rtw_list_delete(&pxmitframe->list);
psta_bmc->sleepq_len--;
if (psta_bmc->sleepq_len > 0)
pxmitframe->attrib.mdata = 1;
else
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.triggered = 1;
if (xmitframe_hiq_filter(pxmitframe) == _TRUE)
pxmitframe->attrib.qsel = rtw_hal_get_qsel(padapter,QSLT_HIGH_ID);/* HIQ */
#if 0
_rtw_spinunlock_bh(&psta_bmc->sleep_q.lock);
if (rtw_hal_xmit(padapter, pxmitframe) == _TRUE)
rtw_os_xmit_complete(padapter, pxmitframe);
_rtw_spinlock_bh(&psta_bmc->sleep_q.lock);
#endif
rtw_intf_xmitframe_enqueue(padapter, pxmitframe);
}
/* _rtw_spinunlock_bh(&psta_bmc->sleep_q.lock); */
_rtw_spinunlock_bh(&pxmitpriv->lock);
if (rtw_get_intf_type(padapter) != RTW_HCI_PCIE) {
/* check hi queue and bmc_sleepq */
rtw_chk_hi_queue_cmd(padapter);
}
}
#endif
return H2C_SUCCESS;
}
u8 tx_beacon_hdl(_adapter *padapter, unsigned char *pbuf)
{
/*RTW_INFO(FUNC_ADPT_FMT, FUNC_ADPT_ARG(padapter));*/
if (send_beacon(padapter) == _FAIL) {
RTW_INFO("issue_beacon, fail!\n");
return H2C_PARAMETERS_ERROR;
}
/* tx bc/mc frames after update TIM */
chk_bmc_sleepq_hdl(padapter, NULL);
return H2C_SUCCESS;
}
/*
* according to channel
* add/remove WLAN_BSSID_EX.IEs's ERP ie
* set WLAN_BSSID_EX.SupportedRates
* update WLAN_BSSID_EX.IEs's Supported Rate and Extended Supported Rate ie
*/
void change_band_update_ie(_adapter *padapter, WLAN_BSSID_EX *pnetwork, u8 ch)
{
u8 network_type, rate_len, total_rate_len, remainder_rate_len;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
u8 erpinfo = 0x4;
if (ch >= 36) {
network_type = WLAN_MD_11A;
total_rate_len = IEEE80211_NUM_OFDM_RATESLEN;
rtw_remove_bcn_ie(padapter, pnetwork, _ERPINFO_IE_);
#ifdef CONFIG_80211AC_VHT
/* if channel in 5G band, then add vht ie . */
if ((pmlmepriv->htpriv.ht_option == _TRUE)
&& REGSTY_IS_11AC_ENABLE(&padapter->registrypriv)
&& is_supported_vht(padapter->registrypriv.wireless_mode)
&& RFCTL_REG_EN_11AC(rfctl)
) {
if (pmlmepriv->vhtpriv.upper_layer_setting)
rtw_reattach_vht_ies(padapter, pnetwork);
else if (REGSTY_IS_11AC_AUTO(&padapter->registrypriv))
rtw_vht_ies_attach(padapter, pnetwork);
}
#endif
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif
} else {
network_type = 0;
total_rate_len = 0;
if (padapter->registrypriv.wireless_mode & WLAN_MD_11B) {
network_type |= WLAN_MD_11B;
total_rate_len += IEEE80211_CCK_RATE_LEN;
}
if (padapter->registrypriv.wireless_mode & WLAN_MD_11G) {
network_type |= WLAN_MD_11G;
total_rate_len += IEEE80211_NUM_OFDM_RATESLEN;
}
rtw_add_bcn_ie(padapter, pnetwork, _ERPINFO_IE_, &erpinfo, 1);
#ifdef CONFIG_80211AC_VHT
rtw_vht_ies_detach(padapter, pnetwork);
#endif
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif
}
rtw_set_supported_rate(pnetwork->SupportedRates, network_type, ch);
UpdateBrateTbl(padapter, pnetwork->SupportedRates);
if (total_rate_len > 8) {
rate_len = 8;
remainder_rate_len = total_rate_len - 8;
} else {
rate_len = total_rate_len;
remainder_rate_len = 0;
}
rtw_add_bcn_ie(padapter, pnetwork, _SUPPORTEDRATES_IE_, pnetwork->SupportedRates, rate_len);
if (remainder_rate_len)
rtw_add_bcn_ie(padapter, pnetwork, _EXT_SUPPORTEDRATES_IE_, (pnetwork->SupportedRates + 8), remainder_rate_len);
else
rtw_remove_bcn_ie(padapter, pnetwork, _EXT_SUPPORTEDRATES_IE_);
pnetwork->Length = get_WLAN_BSSID_EX_sz(pnetwork);
}
void rtw_set_external_auth_status(_adapter *padapter,
const void *data, int len)
{
#ifdef CONFIG_IOCTL_CFG80211
struct net_device *dev = padapter->pnetdev;
struct wiphy *wiphy = adapter_to_wiphy(padapter);
struct rtw_external_auth_params params;
/* convert data to external_auth_params */
params.action = RTW_GET_BE32((u8 *)data);
_rtw_memcpy(¶ms.bssid, (u8 *)data + 4, ETH_ALEN);
_rtw_memcpy(¶ms.ssid.ssid, (u8 *)data + 10, WLAN_SSID_MAXLEN);
params.ssid.ssid_len = RTW_GET_BE64((u8 *)data + 42);
params.key_mgmt_suite = RTW_GET_BE32((u8 *)data + 58);
params.status = RTW_GET_BE16((u8 *)data + 62);
_rtw_memcpy(¶ms.pmkid, (u8 *)data + 64, PMKID_LEN);
rtw_cfg80211_external_auth_status(wiphy, dev, ¶ms);
#endif /* CONFIG_IOCTL_CFG80211 */
}
u8 rtw_set_chbw_hdl(_adapter *padapter, u8 *pbuf)
{
struct set_ch_parm *set_ch_parm;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
if (!pbuf)
return H2C_PARAMETERS_ERROR;
set_ch_parm = (struct set_ch_parm *)pbuf;
RTW_INFO(FUNC_NDEV_FMT" ch:%u, bw:%u, ch_offset:%u\n",
FUNC_NDEV_ARG(padapter->pnetdev),
set_ch_parm->ch, set_ch_parm->bw, set_ch_parm->ch_offset);
pmlmeext->chandef.chan = set_ch_parm->ch;
pmlmeext->chandef.offset = set_ch_parm->ch_offset;
pmlmeext->chandef.bw = set_ch_parm->bw;
set_channel_bwmode(padapter,
set_ch_parm->ch,
set_ch_parm->ch_offset,
set_ch_parm->bw,
set_ch_parm->do_rfk);
rtw_rfctl_update_op_mode(dvobj_to_rfctl(dvobj), 0, 0);
return H2C_SUCCESS;
}
static void get_str_of_set_chplan_keys(char *buf, u8 buf_len, struct SetChannelPlan_param *param)
{
char *pos = buf;
#ifdef CONFIG_80211D
if (param->has_cisr) {
pos += snprintf(pos, buf_len - (pos - buf), "alpha2:"ALPHA2_FMT" %s"
, ALPHA2_ARG(param->cisr.alpha2), cis_status_str(param->cisr.status));
} else
#endif
if (param->has_country)
pos += snprintf(pos, buf_len - (pos - buf), "alpha2:"ALPHA2_FMT, ALPHA2_ARG(param->country_ent.alpha2));
else {
if (param->channel_plan == RTW_CHPLAN_UNSPECIFIED)
pos += snprintf(pos, buf_len - (pos - buf), "chplan:NA");
else
pos += snprintf(pos, buf_len - (pos - buf), "chplan:0x%02X", param->channel_plan);
#if CONFIG_IEEE80211_BAND_6GHZ
if (param->channel_plan_6g == RTW_CHPLAN_6G_UNSPECIFIED)
pos += snprintf(pos, buf_len - (pos - buf), " chplan_6g:NA");
else
pos += snprintf(pos, buf_len - (pos - buf), " chplan_6g:0x%02X", param->channel_plan_6g);
#endif
}
}
#ifdef CONFIG_80211D
static bool rtw_chplan_rtk_priv_req_prehdl_country_ie(_adapter *adapter, struct SetChannelPlan_param *param, const char *caller)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
int i;
bool effected = 1;
#ifdef CONFIG_RTW_DEBUG
if (rtw_drv_log_level >= _DRV_DEBUG_) {
RTW_PRINT("%s cisr before\n", caller);
dump_country_ie_slave_records(RTW_DBGDUMP, rfctl, 0);
}
#endif
if (param->inr == RTW_REGD_SET_BY_USER
&& rfctl->effected_cisr_id != CONFIG_IFACE_NUMBER
) {
/* country IE setting is applied, user setting is only recorded but not applied */
effected = 0;
goto exit;
}
if (param->inr == RTW_REGD_SET_BY_COUNTRY_IE) {
struct country_ie_slave_record ori_cisr = rfctl->cisr[adapter->iface_id];
struct country_ie_slave_record ori_ecisr;
u8 ori_ecisr_id = rfctl->effected_cisr_id;
u8 new_ecisr_id = CONFIG_IFACE_NUMBER;
u8 status_score[] = { /* conservative policy */
[COUNTRY_IE_SLAVE_UNKNOWN] = 3,
[COUNTRY_IE_SLAVE_OPCH_NOEXIST] = 2,
[COUNTRY_IE_SLAVE_APPLICABLE] = 1,
};
char buf[32];
if (_rtw_memcmp(&rfctl->cisr[adapter->iface_id], ¶m->cisr, sizeof(param->cisr)) == _TRUE) {
/* record no change */
effected = 0;
goto exit;
}
if (ori_ecisr_id != CONFIG_IFACE_NUMBER)
_rtw_memcpy(&ori_ecisr, &rfctl->cisr[ori_ecisr_id], sizeof(ori_ecisr));
_rtw_memcpy(&rfctl->cisr[adapter->iface_id], ¶m->cisr, sizeof(param->cisr));
if ((ori_cisr.status == COUNTRY_IE_SLAVE_NOCOUNTRY
&& rfctl->cisr[adapter->iface_id].status == COUNTRY_IE_SLAVE_NOCOUNTRY)
|| (ori_cisr.status == COUNTRY_IE_SLAVE_UNKNOWN
&& rfctl->cisr[adapter->iface_id].status == COUNTRY_IE_SLAVE_UNKNOWN)
) {
/* will take no effect */
effected = 0;
goto exit;
}
for (i = 0; i < CONFIG_IFACE_NUMBER; i++) {
if (rfctl->cisr[i].status == COUNTRY_IE_SLAVE_NOCOUNTRY)
continue;
if (new_ecisr_id == CONFIG_IFACE_NUMBER
/* high score */
|| status_score[rfctl->cisr[i].status] > status_score[rfctl->cisr[new_ecisr_id].status]
/* same score, prefer the same alpha2 as current effected(same score) one */
|| (status_score[rfctl->cisr[i].status] == status_score[rfctl->cisr[new_ecisr_id].status]
&& ori_ecisr_id != CONFIG_IFACE_NUMBER
&& rfctl->cisr[ori_ecisr_id].status == rfctl->cisr[new_ecisr_id].status
&& _rtw_memcmp(rfctl->cisr[ori_ecisr_id].alpha2, rfctl->cisr[new_ecisr_id].alpha2, 2) == _FALSE
&& _rtw_memcmp(rfctl->cisr[ori_ecisr_id].alpha2, rfctl->cisr[i].alpha2, 2) == _TRUE)
)
new_ecisr_id = i;
}
rfctl->effected_cisr_id = new_ecisr_id;
if (rfctl->effected_cisr_id == CONFIG_IFACE_NUMBER) {
/* no country IE setting */
const char *alpha2;
if (strncmp(rfctl->user_alpha2, "\x00\x00", 2) != 0) {
/* restore to user setting */
param->inr = RTW_REGD_SET_BY_USER;
alpha2 = rfctl->user_alpha2;
param->channel_plan = rfctl->user_ChannelPlan;
#if CONFIG_IEEE80211_BAND_6GHZ
param->channel_plan_6g = rfctl->user_chplan_6g;
#endif
} else {
/* restore to init setting */
param->inr = RTW_REGD_SET_BY_INIT;
alpha2 = rfctl->init_alpha2;
param->channel_plan = rfctl->init_ChannelPlan;
#if CONFIG_IEEE80211_BAND_6GHZ
param->channel_plan_6g = rfctl->init_chplan_6g;
#endif
}
if (IS_ALPHA2_UNSPEC(alpha2) || IS_ALPHA2_WORLDWIDE(alpha2))
param->has_country = 0;
else if (rtw_get_chplan_from_country(alpha2, ¶m->country_ent)) {
param->channel_plan = param->country_ent.chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
param->channel_plan_6g = param->country_ent.chplan_6g;
#endif
param->has_country = 1;
} else {
RTW_WARN("%s unexpected country_code:\"%c%c\", set to \"00\"\n", caller, alpha2[0], alpha2[1]);
rtw_warn_on(1);
rtw_get_chplan_worldwide(¶m->country_ent);
param->channel_plan = param->country_ent.chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
param->channel_plan_6g = param->country_ent.chplan_6g;
#endif
param->has_country = 1;
}
param->has_cisr = 0;
get_str_of_set_chplan_keys(buf, 32, param);
RTW_INFO("%s restore inr:%s %s\n", caller, regd_inr_str(param->inr), buf);
}
else {
/* has country IE setting */
if (ori_ecisr_id != CONFIG_IFACE_NUMBER) {
/* has country IE setting originally */
if (_rtw_memcmp(&ori_ecisr, &rfctl->cisr[new_ecisr_id], sizeof(ori_ecisr)) == _TRUE) {
/* same record content, no effect */
effected = 0;
goto exit;
}
}
rtw_get_chplan_from_cisrs(rfctl, ¶m->country_ent, caller);
param->channel_plan = param->country_ent.chplan;
#if CONFIG_IEEE80211_BAND_6GHZ
param->channel_plan_6g = param->country_ent.chplan_6g;
#endif
param->has_country = 1;
param->has_cisr = 0;
get_str_of_set_chplan_keys(buf, 32, param);
RTW_INFO("%s trigger inr:%s %s\n", caller, regd_inr_str(param->inr), buf);
}
}
exit:
#ifdef CONFIG_RTW_DEBUG
if (rtw_drv_log_level >= _DRV_DEBUG_) {
RTW_PRINT("%s cisr after\n", caller);
dump_country_ie_slave_records(RTW_DBGDUMP, rfctl, 0);
}
#endif
return effected;
}
#endif /* CONFIG_80211D */
static bool rtw_chplan_rtk_priv_req_prehdl_domain_code(_adapter *adapter, struct SetChannelPlan_param *param, const char *caller)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
/* disallow invalid input */
if ((param->channel_plan != RTW_CHPLAN_UNSPECIFIED
&& !rtw_is_channel_plan_valid(param->channel_plan))
) {
RTW_WARN("%s invalid chplan:0x%02X\n", caller, param->channel_plan);
return _FAIL;
}
#if CONFIG_IEEE80211_BAND_6GHZ
if (param->channel_plan_6g != RTW_CHPLAN_6G_UNSPECIFIED
&& !rtw_is_channel_plan_6g_valid(param->channel_plan_6g)
) {
RTW_WARN("%s invalid chplan_6g:0x%02X\n", caller, param->channel_plan_6g);
return _FAIL;
}
#endif
/* use original value when unspecified */
if (param->channel_plan == RTW_CHPLAN_UNSPECIFIED)
param->channel_plan = rfctl->ChannelPlan;
#if CONFIG_IEEE80211_BAND_6GHZ
if (param->channel_plan_6g == RTW_CHPLAN_6G_UNSPECIFIED)
param->channel_plan_6g = rfctl->chplan_6g;
#endif
return _SUCCESS;
}
static void rtw_chplan_rtk_priv_req_prehdl_country_ent(struct SetChannelPlan_param *param)
{
if (!param->has_country) {
u8 chplan_6g = RTW_CHPLAN_6G_NULL;
#if CONFIG_IEEE80211_BAND_6GHZ
chplan_6g = param->channel_plan_6g;
#endif
if (rtw_chplan_ids_is_world_wide(param->channel_plan, chplan_6g))
rtw_get_chplan_worldwide(¶m->country_ent);
else {
SET_UNSPEC_ALPHA2(param->country_ent.alpha2);
param->country_ent.edcca_mode_2g_override = RTW_EDCCA_DEF;
#if CONFIG_IEEE80211_BAND_5GHZ
param->country_ent.edcca_mode_5g_override = RTW_EDCCA_DEF;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
param->country_ent.edcca_mode_6g_override = RTW_EDCCA_DEF;
#endif
param->country_ent.txpwr_lmt_override = TXPWR_LMT_DEF;
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
param->country_ent.proto_en = CHPLAN_PROTO_EN_ALL;
#endif
}
param->has_country = 1;
}
}
u8 rtw_set_chplan_hdl(_adapter *padapter, unsigned char *pbuf)
{
struct SetChannelPlan_param *param;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
bool effected = 1;
char buf[32];
enum rtw_regd_inr ori_inr;
#ifdef CONFIG_IOCTL_CFG80211
struct get_chplan_resp *chplan;
#endif
if (!pbuf)
return H2C_PARAMETERS_ERROR;
param = (struct SetChannelPlan_param *)pbuf;
ori_inr = param->inr;
get_str_of_set_chplan_keys(buf, 32, param);
RTW_INFO("%s iface_id:%u src:%s inr:%s %s\n", __func__, padapter->iface_id
, regd_src_str(param->regd_src), regd_inr_str(param->inr), buf);
/* check input parameter */
if (param->regd_src == REGD_SRC_RTK_PRIV) {
#ifdef CONFIG_80211D
effected = rtw_chplan_rtk_priv_req_prehdl_country_ie(padapter, param, __func__);
#endif
if (rtw_chplan_rtk_priv_req_prehdl_domain_code(padapter, param, __func__) != _SUCCESS)
return H2C_PARAMETERS_ERROR;
rtw_chplan_rtk_priv_req_prehdl_country_ent(param);
}
rtw_warn_on(!param->has_country);
if (param->inr == RTW_REGD_SET_BY_USER) {
rfctl->user_alpha2[0] = param->country_ent.alpha2[0];
rfctl->user_alpha2[1] = param->country_ent.alpha2[1];
rfctl->user_ChannelPlan = param->channel_plan;
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->user_chplan_6g = param->channel_plan_6g;
#endif
}
if (!effected)
goto exit;
rfctl->regd_src = param->regd_src;
rfctl->regd_inr = param->inr;
rfctl->alpha2[0] = param->country_ent.alpha2[0];
rfctl->alpha2[1] = param->country_ent.alpha2[1];
rfctl->edcca_mode_2g_override = param->country_ent.edcca_mode_2g_override;
#if CONFIG_IEEE80211_BAND_5GHZ
rfctl->edcca_mode_5g_override = param->country_ent.edcca_mode_5g_override;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->edcca_mode_6g_override = param->country_ent.edcca_mode_6g_override;
#endif
#if CONFIG_TXPWR_LIMIT
rfctl->txpwr_lmt_override = param->country_ent.txpwr_lmt_override;
#endif
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
rfctl->proto_en = param->country_ent.proto_en;
#endif
rfctl->ChannelPlan = param->channel_plan;
#if CONFIG_IEEE80211_BAND_6GHZ
rfctl->chplan_6g = param->channel_plan_6g;
#endif
rtw_edcca_mode_update(rfctl_to_dvobj(rfctl));
rtw_update_phl_edcca_mode(padapter);
rtw_rfctl_chplan_init(dvobj);
#ifdef CONFIG_IOCTL_CFG80211
if (rfctl->regd_src != REGD_SRC_OS)
rtw_chset_hook_os_channels(rfctl);
if (rtw_get_chplan_cmd(padapter, RTW_CMDF_DIRECTLY, &chplan) == _SUCCESS) {
if (!param->rtnl_lock_needed)
rtw_regd_change_complete_sync(adapter_to_wiphy(padapter), chplan, 0);
else
rtw_warn_on(rtw_regd_change_complete_async(adapter_to_wiphy(padapter), chplan) != _SUCCESS);
} else
rtw_warn_on(1);
#endif
rtw_nlrtw_reg_change_event(padapter);
#ifdef CONFIG_LPS
LPS_Leave(padapter, "SET_CHPLAN");
#endif
if (rtw_phl_get_pwr_lmt_en(GET_PHL_INFO(rfctl_to_dvobj(rfctl)), padapter->phl_role->hw_band)
&& rtw_hw_is_init_completed(dvobj))
rtw_update_phl_txpwr_level(padapter);
exit:
return H2C_SUCCESS;
}
u8 rtw_get_chplan_hdl(_adapter *padapter, unsigned char *pbuf)
{
struct get_channel_plan_param *param;
struct get_chplan_resp *chplan;
struct rf_ctl_t *rfctl;
int i;
if (!pbuf)
return H2C_PARAMETERS_ERROR;
rfctl = adapter_to_rfctl(padapter);
param = (struct get_channel_plan_param *)pbuf;
chplan = rtw_vmalloc(sizeof(struct get_chplan_resp) + sizeof(RT_CHANNEL_INFO) * rfctl->max_chan_nums);
if (!chplan)
return H2C_CMD_FAIL;
chplan->regd_src = rfctl->regd_src;
chplan->regd_inr = rfctl->regd_inr;
chplan->alpha2[0] = rfctl->alpha2[0];
chplan->alpha2[1] = rfctl->alpha2[1];
chplan->channel_plan = rfctl->ChannelPlan;
#if CONFIG_IEEE80211_BAND_6GHZ
chplan->chplan_6g = rfctl->chplan_6g;
#endif
#if CONFIG_TXPWR_LIMIT
for (i = 0; i < BAND_MAX; i++)
chplan->txpwr_lmt_name[i] = rtw_phl_get_pw_lmt_regu_type_str(GET_PHL_INFO(rfctl_to_dvobj(rfctl)), i);
#endif
chplan->edcca_mode_2g = rfctl->edcca_mode_2g;
#if CONFIG_IEEE80211_BAND_5GHZ
chplan->edcca_mode_5g = rfctl->edcca_mode_5g;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
chplan->edcca_mode_6g = rfctl->edcca_mode_6g;
#endif
#ifdef CONFIG_DFS_MASTER
chplan->dfs_domain = rtw_rfctl_get_dfs_domain(rfctl);
#endif
chplan->proto_en = 0
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
| rfctl->proto_en
#endif
;
chplan->chset_num = rfctl->max_chan_nums;
_rtw_memcpy(chplan->chset, rfctl->channel_set, sizeof(RT_CHANNEL_INFO) * rfctl->max_chan_nums);
*param->chplan = chplan;
return H2C_SUCCESS;
}
u8 led_blink_hdl(_adapter *padapter, unsigned char *pbuf)
{
struct LedBlink_param *ledBlink_param;
if (!pbuf)
return H2C_PARAMETERS_ERROR;
ledBlink_param = (struct LedBlink_param *)pbuf;
#ifdef CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD
BlinkHandler((PLED_DATA)ledBlink_param->pLed);
#endif
return H2C_SUCCESS;
}
void csa_timer_hdl(void *FunctionContext)
{
#if CONFIG_DFS
_adapter *padapter = (_adapter *)FunctionContext;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
u8 i;
for (i = 0; i < dvobj->iface_nums; i++) {
_adapter *iface;
iface = dvobj->padapters[i];
if (!iface)
continue;
if (check_fwstate(&(iface->mlmepriv), WIFI_CSA_UPDATE_BEACON)) {
clr_fwstate(&(iface->mlmepriv), WIFI_CSA_UPDATE_BEACON);
RTW_INFO(FUNC_ADPT_FMT" wait beacons more than 70 seconds\n", FUNC_ADPT_ARG(iface));
return;
}
}
if (rfctl->csa_chandef.chan == 0) {
RTW_INFO("channel switch done\n");
return ;
}
/* channel switch */
if (rtw_set_csa_cmd(padapter) != _SUCCESS)
reset_csa_param(rfctl);
#endif
}
u8 set_csa_hdl(_adapter *adapter, unsigned char *pbuf)
{
#if CONFIG_DFS
#ifndef RTW_PHL_TEST_FPGA
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
if (rfctl->csa_chandef.chan)
rtw_dfs_ch_switch_hdl(adapter);
#endif
#endif
return H2C_SUCCESS;
}
u8 tdls_hdl(_adapter *padapter, unsigned char *pbuf)
{
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
#ifdef CONFIG_TDLS_CH_SW
struct tdls_ch_switch *pchsw_info = &ptdlsinfo->chsw_info;
#endif
struct TDLSoption_param *TDLSoption;
struct sta_info *ptdls_sta = NULL;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
struct sta_info *ap_sta = rtw_get_stainfo(&padapter->stapriv, get_my_bssid(&(pmlmeinfo->network)));
u8 survey_channel, i, min, option;
struct tdls_txmgmt txmgmt;
u32 setchtime, resp_sleep = 0, wait_time;
u8 zaddr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
u8 ret;
u8 do_rfk;
u64 tx_ra_bitmap = 0;
if (!pbuf)
return H2C_PARAMETERS_ERROR;
TDLSoption = (struct TDLSoption_param *)pbuf;
option = TDLSoption->option;
if (!_rtw_memcmp(TDLSoption->addr, zaddr, ETH_ALEN)) {
ptdls_sta = rtw_get_stainfo(&(padapter->stapriv), TDLSoption->addr);
if (ptdls_sta == NULL)
return H2C_REJECTED;
} else {
if (!(option == TDLS_RS_RCR))
return H2C_REJECTED;
}
/* _rtw_spinlock_bh(&(ptdlsinfo->hdl_lock)); */
/* RTW_INFO("[%s] option:%d\n", __FUNCTION__, option); */
switch (option) {
case TDLS_ESTABLISHED: {
/* As long as TDLS handshake success, we should set RCR_CBSSID_DATA bit to 0 */
/* So we can receive all kinds of data frames. */
u8 sta_band = 0;
/* leave ALL PS when TDLS is established */
rtw_pwr_wakeup(padapter);
rtw_hal_rcr_set_chk_bssid(padapter, MLME_TDLS_LINKED);
RTW_INFO("Created Direct Link with "MAC_FMT"\n", MAC_ARG(ptdls_sta->phl_sta->mac_addr));
/* Set TDLS sta rate. */
/* Update station supportRate */
update_sta_ra_info(padapter, ptdls_sta);
tx_ra_bitmap = ptdls_sta->phl_sta->ra_info.ramask;
if (pmlmeext->chandef.chan > 14) {
if (tx_ra_bitmap & 0xffff000)
sta_band |= WIRELESS_11_5N ;
if (tx_ra_bitmap & 0xff0)
sta_band |= WIRELESS_11A;
/* 5G band */
#ifdef CONFIG_80211AC_VHT
if (ptdls_sta->vhtpriv.vht_option)
sta_band = WIRELESS_11_5AC;
#endif
} else {
if (tx_ra_bitmap & 0xffff000)
sta_band |= WIRELESS_11_24N;
if (tx_ra_bitmap & 0xff0)
sta_band |= WIRELESS_11G;
if (tx_ra_bitmap & 0x0f)
sta_band |= WIRELESS_11B;
}
ptdls_sta->phl_sta->wmode = sta_band;
rtw_sta_media_status_rpt(padapter, ptdls_sta, 1);
break;
}
case TDLS_ISSUE_PTI:
ptdls_sta->tdls_sta_state |= TDLS_WAIT_PTR_STATE;
issue_tdls_peer_traffic_indication(padapter, ptdls_sta);
_set_timer(&ptdls_sta->pti_timer, TDLS_PTI_TIME);
break;
#ifdef CONFIG_TDLS_CH_SW
case TDLS_CH_SW_RESP:
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.status_code = 0;
_rtw_memcpy(txmgmt.peer, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
if (ap_sta)
rtw_hal_macid_sleep(padapter, ap_sta->phl_sta->macid);
issue_nulldata(padapter, NULL, 1, 3, 3);
RTW_INFO("[TDLS ] issue tdls channel switch response\n");
ret = issue_tdls_ch_switch_rsp(padapter, &txmgmt, _TRUE);
/* If we receive TDLS_CH_SW_REQ at off channel which it's target is AP's channel */
/* then we just switch to AP's channel*/
if (padapter->mlmeextpriv.chandef.chan == pchsw_info->off_ch_num) {
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_END_TO_BASE_CHNL);
break;
}
if (ret == _SUCCESS)
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_TO_OFF_CHNL);
else
RTW_INFO("[TDLS] issue_tdls_ch_switch_rsp wait ack fail !!!!!!!!!!\n");
break;
case TDLS_CH_SW_PREPARE:
pchsw_info->ch_sw_state |= TDLS_CH_SWITCH_PREPARE_STATE;
/* to collect IQK info of off-chnl */
do_rfk = _TRUE;
set_channel_bwmode(padapter,
pchsw_info->off_ch_num,
pchsw_info->ch_offset,
(pchsw_info->ch_offset) ? CHANNEL_WIDTH_40 : CHANNEL_WIDTH_20,
do_rfk);
do_rfk = _FALSE;
/* switch back to base-chnl */
set_channel_bwmode(padapter,
pmlmeext->chandef.chan,
pmlmeext->chandef.offset,
pmlmeext->chandef.bw,
do_rfk);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_START);
pchsw_info->ch_sw_state &= ~(TDLS_CH_SWITCH_PREPARE_STATE);
break;
case TDLS_CH_SW_START:
rtw_tdls_set_ch_sw_oper_control(padapter, _TRUE);
break;
case TDLS_CH_SW_TO_OFF_CHNL:
if (ap_sta)
rtw_hal_macid_sleep(padapter, ap_sta->phl_sta->macid);
issue_nulldata(padapter, NULL, 1, 3, 3);
if (padapter->registrypriv.wifi_spec == 0) {
if (!(pchsw_info->ch_sw_state & TDLS_CH_SW_INITIATOR_STATE))
_set_timer(&ptdls_sta->ch_sw_timer, (u32)(ptdls_sta->ch_switch_timeout) / 1000);
}
if (rtw_tdls_do_ch_sw(padapter, ptdls_sta, TDLS_CH_SW_OFF_CHNL, pchsw_info->off_ch_num,
pchsw_info->ch_offset, (pchsw_info->ch_offset) ? CHANNEL_WIDTH_40 : CHANNEL_WIDTH_20, ptdls_sta->ch_switch_time) == _SUCCESS) {
pchsw_info->ch_sw_state &= ~(TDLS_PEER_AT_OFF_STATE);
if (pchsw_info->ch_sw_state & TDLS_CH_SW_INITIATOR_STATE) {
if (issue_nulldata_to_TDLS_peer_STA(ptdls_sta->padapter, ptdls_sta->phl_sta->mac_addr, 0, 1,
(padapter->registrypriv.wifi_spec == 0) ? 3 : 0) == _FAIL)
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_TO_BASE_CHNL);
}
} else {
if (!(pchsw_info->ch_sw_state & TDLS_CH_SW_INITIATOR_STATE))
_cancel_timer_ex(&ptdls_sta->ch_sw_timer);
}
break;
case TDLS_CH_SW_END:
case TDLS_CH_SW_END_TO_BASE_CHNL:
rtw_tdls_set_ch_sw_oper_control(padapter, _FALSE);
_cancel_timer_ex(&ptdls_sta->ch_sw_timer);
_cancel_timer_ex(&ptdls_sta->stay_on_base_chnl_timer);
_cancel_timer_ex(&ptdls_sta->ch_sw_monitor_timer);
#if 0
_rtw_memset(pHalData->tdls_ch_sw_iqk_info_base_chnl, 0x00, sizeof(pHalData->tdls_ch_sw_iqk_info_base_chnl));
_rtw_memset(pHalData->tdls_ch_sw_iqk_info_off_chnl, 0x00, sizeof(pHalData->tdls_ch_sw_iqk_info_off_chnl));
#endif
if (option == TDLS_CH_SW_END_TO_BASE_CHNL)
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_TO_BASE_CHNL);
break;
case TDLS_CH_SW_TO_BASE_CHNL_UNSOLICITED:
case TDLS_CH_SW_TO_BASE_CHNL:
pchsw_info->ch_sw_state &= ~(TDLS_PEER_AT_OFF_STATE | TDLS_WAIT_CH_RSP_STATE);
if (option == TDLS_CH_SW_TO_BASE_CHNL_UNSOLICITED) {
if (ptdls_sta != NULL) {
/* Send unsolicited channel switch rsp. to peer */
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.status_code = 0;
_rtw_memcpy(txmgmt.peer, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
issue_tdls_ch_switch_rsp(padapter, &txmgmt, _FALSE);
}
}
if (rtw_tdls_do_ch_sw(padapter, ptdls_sta, TDLS_CH_SW_BASE_CHNL, pmlmeext->chandef.chan,
pmlmeext->chandef.offset, pmlmeext->chandef.bw, ptdls_sta->ch_switch_time) == _SUCCESS) {
if (ap_sta)
rtw_hal_macid_wakeup(padapter, ap_sta->phl_sta->macid);
issue_nulldata(padapter, NULL, 0, 3, 3);
/* set ch sw monitor timer for responder */
if (!(pchsw_info->ch_sw_state & TDLS_CH_SW_INITIATOR_STATE))
_set_timer(&ptdls_sta->ch_sw_monitor_timer, TDLS_CH_SW_MONITOR_TIMEOUT);
}
break;
#endif
case TDLS_RS_RCR:
rtw_hal_rcr_set_chk_bssid(padapter, MLME_TDLS_NOLINK);
break;
case TDLS_TEARDOWN_STA:
case TDLS_TEARDOWN_STA_NO_WAIT:
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.status_code = _RSON_TDLS_TEAR_UN_RSN_;
_rtw_memcpy(txmgmt.peer, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
issue_tdls_teardown(padapter, &txmgmt, (option == TDLS_TEARDOWN_STA) ? _TRUE : _FALSE);
break;
case TDLS_TEARDOWN_STA_LOCALLY:
case TDLS_TEARDOWN_STA_LOCALLY_POST:
#ifdef CONFIG_TDLS_CH_SW
if (_rtw_memcmp(TDLSoption->addr, pchsw_info->addr, ETH_ALEN) == _TRUE) {
pchsw_info->ch_sw_state &= ~(TDLS_CH_SW_INITIATOR_STATE |
TDLS_CH_SWITCH_ON_STATE |
TDLS_PEER_AT_OFF_STATE);
rtw_tdls_set_ch_sw_oper_control(padapter, _FALSE);
_rtw_memset(pchsw_info->addr, 0x00, ETH_ALEN);
}
#endif
if (option == TDLS_TEARDOWN_STA_LOCALLY)
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_teardown_post_hdl(padapter, ptdls_sta, _FALSE);
if (ptdlsinfo->tdls_sctx != NULL)
rtw_sctx_done(&(ptdlsinfo->tdls_sctx));
break;
}
/* _rtw_spinunlock_bh(&(ptdlsinfo->hdl_lock)); */
return H2C_SUCCESS;
#else
return H2C_REJECTED;
#endif /* CONFIG_TDLS */
}
u8 run_in_thread_hdl(_adapter *padapter, u8 *pbuf)
{
struct RunInThread_param *p;
if (NULL == pbuf)
return H2C_PARAMETERS_ERROR;
p = (struct RunInThread_param *)pbuf;
if (p->func)
p->func(p->context);
return H2C_SUCCESS;
}
int rtw_sae_preprocess(_adapter *adapter, const u8 *buf, u32 len, u8 tx)
{
#ifdef CONFIG_IOCTL_CFG80211
const u8 *frame_body = buf + sizeof(struct rtw_ieee80211_hdr_3addr);
u16 alg;
u16 seq;
u16 status;
int ret = _FAIL;
alg = RTW_GET_LE16(frame_body);
if (alg != WLAN_AUTH_SAE)
goto exit;
seq = RTW_GET_LE16(frame_body + 2);
status = RTW_GET_LE16(frame_body + 4);
RTW_INFO("RTW_%s:AUTH alg:0x%04x, seq:0x%04x, status:0x%04x, mesg:%s\n",
(tx == _TRUE) ? "Tx" : "Rx", alg, seq, status,
(seq == 1) ? "Commit" : "Confirm");
ret = _SUCCESS;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(adapter)) {
rtw_mesh_sae_check_frames(adapter, buf, len, tx, alg, seq, status);
goto exit;
}
#endif
if (tx && (seq == 2) && (status == 0) && MLME_IS_AP(adapter)) {
/* queue confirm frame until external auth status update */
struct sta_priv *pstapriv = &adapter->stapriv;
struct sta_info *psta = NULL;
psta = rtw_get_stainfo(pstapriv, GetAddr1Ptr(buf));
if (psta) {
_rtw_spinlock_bh(&psta->lock);
if (psta->pauth_frame) {
rtw_mfree(psta->pauth_frame, psta->auth_len);
psta->pauth_frame = NULL;
psta->auth_len = 0;
}
psta->pauth_frame = rtw_zmalloc(len);
if (psta->pauth_frame) {
_rtw_memcpy(psta->pauth_frame, buf, len);
psta->auth_len = len;
}
_rtw_spinunlock_bh(&psta->lock);
ret = 2;
}
}
exit:
return ret;
#else
return _SUCCESS;
#endif /* CONFIG_IOCTL_CFG80211 */
}
char UNKNOWN_EVT[16] = "UNKNOWN_EVT";
char *rtw_evt_name(struct rtw_evt_header *pev)
{
if (pev->id >= EVT_ID_MAX)
return UNKNOWN_EVT;
return wlanevents[pev->id].name;
}
|
2301_81045437/rtl8852be
|
core/rtw_mlme_ext.c
|
C
|
agpl-3.0
| 415,906
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_MP_C_
#include <drv_types.h>
#ifdef PLATFORM_FREEBSD
#include <sys/unistd.h> /* for RFHIGHPID */
#endif
#ifdef CONFIG_MP_VHT_HW_TX_MODE
#define CEILING_POS(X) ((X - (int)(X)) > 0 ? (int)(X + 1) : (int)(X))
#define CEILING_NEG(X) ((X - (int)(X)) < 0 ? (int)(X - 1) : (int)(X))
#define ceil(X) (((X) > 0) ? CEILING_POS(X) : CEILING_NEG(X))
int rtfloor(float x)
{
int i = x - 2;
while
(++i <= x - 1)
;
return i;
}
#endif
#ifdef CONFIG_MP_INCLUDED
bool rtw_mp_is_cck_rate(u16 rate)
{
return ((rate & 0x1ff) <= _11M_RATE_) ? true : false;
}
static void _init_mp_priv_(struct mp_priv *pmp_priv)
{
WLAN_BSSID_EX *pnetwork;
_rtw_memset(pmp_priv, 0, sizeof(struct mp_priv));
pmp_priv->mode = MP_OFF;
pmp_priv->channel = 1;
pmp_priv->bandwidth = CHANNEL_WIDTH_20;
pmp_priv->prime_channel_offset = CHAN_OFFSET_NO_EXT;
//pmp_priv->rateidx = RATE_1M;
pmp_priv->txpoweridx = 0;
pmp_priv->antenna_tx = MP_ANTENNA_A;
pmp_priv->antenna_rx = MP_ANTENNA_A;
pmp_priv->antenna_trx = MP_ANTENNA_A;
pmp_priv->check_mp_pkt = 0;
pmp_priv->tx_pktcount = 0;
pmp_priv->rx_bssidpktcount = 0;
pmp_priv->rx_pktcount = 0;
pmp_priv->rx_crcerrpktcount = 0;
pmp_priv->network_macaddr[0] = 0x00;
pmp_priv->network_macaddr[1] = 0xE0;
pmp_priv->network_macaddr[2] = 0x4C;
pmp_priv->network_macaddr[3] = 0x87;
pmp_priv->network_macaddr[4] = 0x66;
pmp_priv->network_macaddr[5] = 0x55;
pmp_priv->bSetRxBssid = _FALSE;
pmp_priv->bRTWSmbCfg = _FALSE;
pmp_priv->bloopback = _FALSE;
pmp_priv->bloadefusemap = _FALSE;
pmp_priv->brx_filter_beacon = _FALSE;
pmp_priv->mplink_brx = _FALSE;
pmp_priv->mp_keep_btc_mode = BTC_MODE_MAX;
pnetwork = &pmp_priv->mp_network.network;
_rtw_memcpy(pnetwork->MacAddress, pmp_priv->network_macaddr, ETH_ALEN);
pnetwork->Ssid.SsidLength = 8;
_rtw_memcpy(pnetwork->Ssid.Ssid, "mp_871x", pnetwork->Ssid.SsidLength);
pmp_priv->tx.payload = MP_TX_Payload_default_random;
#ifdef CONFIG_80211N_HT
pmp_priv->tx.attrib.ht_en = 1;
#endif
pmp_priv->mpt_ctx.mpt_rate_index = 1;
}
static void mp_init_xmit_attrib(struct mp_tx *pmptx, _adapter *padapter)
{
struct pkt_attrib *pattrib;
/* init xmitframe attribute */
pattrib = &pmptx->attrib;
_rtw_memset(pattrib, 0, sizeof(struct pkt_attrib));
_rtw_memset(pmptx->desc, 0, TXDESC_SIZE);
pattrib->ether_type = 0x8712;
#if 0
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
#endif
_rtw_memset(pattrib->dst, 0xFF, ETH_ALEN);
/* pattrib->dhcp_pkt = 0;
* pattrib->pktlen = 0; */
pattrib->ack_policy = 0;
/* pattrib->pkt_hdrlen = ETH_HLEN; */
pattrib->hdrlen = WLAN_HDR_A3_LEN;
pattrib->subtype = WIFI_DATA;
pattrib->priority = 0;
pattrib->qsel = pattrib->priority;
/* do_queue_select(padapter, pattrib); */
pattrib->nr_frags = 1;
pattrib->encrypt = 0;
pattrib->bswenc = _FALSE;
pattrib->qos_en = _FALSE;
pattrib->pktlen = 1500;
}
s32 init_mp_priv(_adapter *padapter)
{
struct mp_priv *pmppriv = &padapter->mppriv;
_init_mp_priv_(pmppriv);
pmppriv->papdater = padapter;
if (0) //(IS_HARDWARE_TYPE_8822C(padapter))
pmppriv->mp_dm = 1;/* default enable dpk tracking */
else
pmppriv->mp_dm = 0;
pmppriv->tx.stop = 1;
pmppriv->bSetTxPower = 0; /*for manually set tx power*/
pmppriv->bTxBufCkFail = _FALSE;
pmppriv->pktInterval = 100;
pmppriv->pktLength = 1000;
pmppriv->bprocess_mp_mode = _FALSE;
pmppriv->rtw_mp_tx_method = RTW_MP_PMACT_TX;
pmppriv->rtw_mp_cur_phy = 0;
pmppriv->rtw_mp_pmact_patt_idx = 0;
pmppriv->rtw_mp_pmact_ppdu_type = 0;
pmppriv->rtw_mp_dbcc = 0;
pmppriv->pre_refcw_cck_pwridxa = 0;
pmppriv->pre_refcw_cck_pwridxb = 0;
pmppriv->pre_refcw_ofdm_pwridxa = 0;
pmppriv->pre_refcw_ofdm_pwridxb = 0;
pmppriv->rtw_mp_data_bandwidth = CHANNEL_WIDTH_20;
pmppriv->rtw_mp_trxsc = 0;
pmppriv->rtw_mp_stbc = 0;
pmppriv->rtw_mp_he_sigb = 0;
pmppriv->rtw_mp_he_sigb_dcm = 0;
pmppriv->rtw_mp_plcp_gi = 1;
pmppriv->rtw_mp_plcp_ltf = 0;
pmppriv->rtw_mp_plcp_tx_time = 0;
pmppriv->rtw_mp_plcp_tx_mode = 0;
pmppriv->rtw_mp_plcp_tx_user = 1;
pmppriv->rtw_mp_he_er_su_ru_106_en = 0;
pmppriv->rtw_mp_ru_tone = MP_RU_TONE_26;
pmppriv->mp_plcp_useridx = 0;
pmppriv->mp_plcp_user[0].plcp_mcs = 0;
pmppriv->mp_plcp_user[0].aid = 0;
pmppriv->mp_plcp_user[0].coding = 0;
pmppriv->mp_plcp_user[0].dcm = 0;
pmppriv->mp_plcp_user[0].plcp_txlen = 1000;
pmppriv->mp_plcp_user[0].ru_alloc = 0;
pmppriv->mp_plcp_user[0].txbf = 0;
pmppriv->mp_plcp_user[0].pwr_boost_db = 0;
pmppriv->btc_path = BTC_MODE_WL;
_rtw_memset(pmppriv->st_giltf, 0, sizeof(struct rtw_mp_giltf_data)*5);
mp_init_xmit_attrib(&pmppriv->tx, padapter);
#if 0
switch (GET_HAL_RFPATH(padapter)) {
case RF_1T1R:
pmppriv->antenna_tx = ANTENNA_A;
pmppriv->antenna_rx = ANTENNA_A;
break;
case RF_1T2R:
default:
pmppriv->antenna_tx = ANTENNA_A;
pmppriv->antenna_rx = ANTENNA_AB;
break;
case RF_2T2R:
pmppriv->antenna_tx = ANTENNA_AB;
pmppriv->antenna_rx = ANTENNA_AB;
break;
case RF_2T4R:
pmppriv->antenna_tx = ANTENNA_BC;
pmppriv->antenna_rx = ANTENNA_ABCD;
break;
}
#endif
return _SUCCESS;
}
void free_mp_priv(struct mp_priv *pmp_priv)
{
if (pmp_priv->pallocated_mp_xmitframe_buf) {
rtw_mfree(pmp_priv->pallocated_mp_xmitframe_buf, 0);
pmp_priv->pallocated_mp_xmitframe_buf = NULL;
}
pmp_priv->pmp_xmtframe_buf = NULL;
}
#if 0
static void PHY_IQCalibrate_default(
_adapter *adapter,
BOOLEAN bReCovery
)
{
RTW_INFO("%s\n", __func__);
}
static void PHY_LCCalibrate_default(
_adapter *adapter
)
{
RTW_INFO("%s\n", __func__);
}
static void PHY_SetRFPathSwitch_default(
_adapter *adapter,
BOOLEAN bMain
)
{
RTW_INFO("%s\n", __func__);
}
#endif
void mpt_InitHWConfig(_adapter *adapter)
{
#ifdef CONFIG_RTL8822B
if (IS_HARDWARE_TYPE_8822B(adapter)) {
u32 tmp_reg = 0;
rtw_write16(adapter, REG_RXFLTMAP1_8822B, 0x2000);
/* fixed wifi can't 2.4g tx suggest by Szuyitasi 20160504 */
phy_set_bb_reg(adapter, 0x70, bMaskByte3, 0x0e);
RTW_INFO(" 0x73 = 0x%x\n", phy_query_bb_reg(adapter, 0x70, bMaskByte3));
phy_set_bb_reg(adapter, 0x1704, bMaskDWord, 0x0000ff00);
RTW_INFO(" 0x1704 = 0x%x\n", phy_query_bb_reg(adapter, 0x1704, bMaskDWord));
phy_set_bb_reg(adapter, 0x1700, bMaskDWord, 0xc00f0038);
RTW_INFO(" 0x1700 = 0x%x\n", phy_query_bb_reg(adapter, 0x1700, bMaskDWord));
}
#endif /* CONFIG_RTL8822B */
#ifdef CONFIG_RTL8821C
if (IS_HARDWARE_TYPE_8821C(adapter))
rtw_write16(adapter, REG_RXFLTMAP1_8821C, 0x2000);
#endif /* CONFIG_RTL8821C */
#if defined(CONFIG_RTL8822C)
if( IS_HARDWARE_TYPE_8822C(adapter)) {
rtw_write16(adapter, REG_RXFLTMAP1_8822C, 0x2000);
/* 0x7D8[31] : time out enable when cca is not assert
0x60D[7:0] : time out value (Unit : us)*/
rtw_write8(adapter, 0x7db, 0xc0);
RTW_INFO(" 0x7d8 = 0x%x\n", rtw_read8(adapter, 0x7d8));
rtw_write8(adapter, 0x60d, 0x0c);
RTW_INFO(" 0x60d = 0x%x\n", rtw_read8(adapter, 0x60d));
phy_set_bb_reg(adapter, 0x1c44, BIT10, 0x1);
RTW_INFO(" 0x1c44 = 0x%x\n", phy_query_bb_reg(adapter, 0x1c44, bMaskDWord));
}
#endif
#if defined(CONFIG_RTL8814B)
if(IS_HARDWARE_TYPE_8814B(adapter))
rtw_write16(adapter, REG_RXFLTMAP1_8814B, 0x2000);
#endif
}
static void PHY_IQCalibrate(_adapter *padapter, u8 bReCovery)
{
//halrf_iqk_trigger(adapter_to_phydm(padapter), bReCovery);
}
static void PHY_LCCalibrate(_adapter *padapter)
{
//halrf_lck_trigger(adapter_to_phydm(padapter));
}
static u8 PHY_QueryRFPathSwitch(_adapter *padapter)
{
u8 bmain = 0;
return bmain;
}
static void PHY_SetRFPathSwitch(_adapter *padapter , BOOLEAN bMain) {
}
static void phy_switch_rf_path_set(_adapter *padapter , u8 *prf_set_State) {
#ifdef CONFIG_RTL8821C
struct dm_struct *phydm = adapter_to_phydm(padapter);
if (IS_HARDWARE_TYPE_8821C(padapter)) {
config_phydm_set_ant_path(phydm, *prf_set_State, phydm->current_ant_num_8821c);
/* Do IQK when switching to BTG/WLG, requested by RF Binson */
if (*prf_set_State == SWITCH_TO_BTG || *prf_set_State == SWITCH_TO_WLG)
PHY_IQCalibrate(padapter, FALSE);
}
#endif
}
s32
MPT_InitializeAdapter(
_adapter *adapter,
u8 Channel
)
{
s32 rtStatus = _SUCCESS;
PMPT_CONTEXT pMptCtx = &adapter->mppriv.mpt_ctx;
/*u32 ledsetting;*/
pMptCtx->bMptDrvUnload = _FALSE;
pMptCtx->bMassProdTest = _FALSE;
pMptCtx->bMptIndexEven = _TRUE; /* default gain index is -6.0db */
pMptCtx->h2cReqNum = 0x0;
/* init for BT MP */
mpt_InitHWConfig(adapter);
pMptCtx->bMptWorkItemInProgress = _FALSE;
pMptCtx->CurrMptAct = NULL;
pMptCtx->mpt_rf_path = RF_PATH_A;
/* ------------------------------------------------------------------------- */
/* Don't accept any packets */
//rtw_write32(adapter, REG_RCR, 0);
/* ledsetting = rtw_read32(adapter, REG_LEDCFG0); */
/* rtw_write32(adapter, REG_LEDCFG0, ledsetting & ~LED0DIS); */
/* rtw_write32(adapter, REG_LEDCFG0, 0x08080); */
/*ledsetting = rtw_read32(adapter, REG_LEDCFG0);*/
PHY_LCCalibrate(adapter);
PHY_IQCalibrate(adapter, _FALSE);
/* dm_check_txpowertracking(adapter_to_phydm(adapter)); */ /* trigger thermal meter */
PHY_SetRFPathSwitch(adapter, 1/*pHalData->bDefaultAntenna*/); /* default use Main */
#if 0
pMptCtx->backup0xc50 = (u8)phy_query_bb_reg(adapter, rOFDM0_XAAGCCore1, bMaskByte0);
pMptCtx->backup0xc58 = (u8)phy_query_bb_reg(adapter, rOFDM0_XBAGCCore1, bMaskByte0);
pMptCtx->backup0xc30 = (u8)phy_query_bb_reg(adapter, rOFDM0_RxDetector1, bMaskByte0);
pMptCtx->backup0x52_RF_A = (u8)phy_query_rf_reg(adapter, RF_PATH_A, RF_0x52, 0x000F0);
pMptCtx->backup0x52_RF_B = (u8)phy_query_rf_reg(adapter, RF_PATH_B, RF_0x52, 0x000F0);
#endif
return rtStatus;
}
/*-----------------------------------------------------------------------------
* Function: MPT_DeInitAdapter()
*
* Overview: Extra DeInitialization for Mass Production Test.
*
* Input: _adapter *adapter
*
* Output: NONE
*
* Return: NONE
*
* Revised History:
* When Who Remark
* 05/08/2007 MHC Create Version 0.
* 05/18/2007 MHC Add normal driver MPHalt code.
*
*---------------------------------------------------------------------------*/
void
MPT_DeInitAdapter(
_adapter *adapter
)
{
PMPT_CONTEXT pMptCtx = &adapter->mppriv.mpt_ctx;
pMptCtx->bMptDrvUnload = _TRUE;
}
static u8 mpt_ProStartTest(_adapter *padapter)
{
PMPT_CONTEXT pMptCtx = &padapter->mppriv.mpt_ctx;
pMptCtx->bMassProdTest = _TRUE;
pMptCtx->is_start_cont_tx = _FALSE;
pMptCtx->bCckContTx = _FALSE;
pMptCtx->bOfdmContTx = _FALSE;
pMptCtx->bSingleCarrier = _FALSE;
pMptCtx->is_carrier_suppression = _FALSE;
pMptCtx->is_single_tone = _FALSE;
pMptCtx->HWTxmode = PACKETS_TX;
return _SUCCESS;
}
void rtw_mp_cal_trigger(_adapter *padapter, u8 cal_tye)
{
struct rtw_mp_cal_arg *mp_cal_arg = NULL;
struct mp_priv *pmppriv = &padapter->mppriv;
mp_cal_arg = _rtw_malloc(sizeof(struct rtw_mp_cal_arg));
if (mp_cal_arg)
_rtw_memset((void *)mp_cal_arg, 0, sizeof(struct rtw_mp_cal_arg));
else {
RTW_ERR("%s,malloc fail ! ", __func__);
return;
}
mp_cal_arg->cal_type = cal_tye;
if (cal_tye == RTW_MP_CAL_DPK_TRACK) {
if (rtw_mp_phl_calibration(padapter,
mp_cal_arg,
RTW_MP_CAL_CMD_TRIGGER_DPK_TRACKING))
RTW_INFO("%s ok\n", __func__);
else
RTW_INFO("%s fail\n", __func__);
} else {
if (rtw_mp_phl_calibration(padapter,
mp_cal_arg,
RTW_MP_CAL_CMD_TRIGGER_CAL))
RTW_INFO("%s ok\n", __func__);
else
RTW_INFO("%s fail\n", __func__);
}
if (mp_cal_arg)
_rtw_mfree(mp_cal_arg, sizeof(struct rtw_mp_cal_arg));
return;
}
void rtw_mp_cal_capab(_adapter *padapter, u8 cal_tye, u8 benable)
{
struct rtw_mp_cal_arg *mp_cal_arg = NULL;
struct mp_priv *pmppriv = &padapter->mppriv;
mp_cal_arg = _rtw_malloc(sizeof(struct rtw_mp_cal_arg));
if (mp_cal_arg)
_rtw_memset((void *)mp_cal_arg, 0, sizeof(struct rtw_mp_cal_arg));
else {
RTW_ERR("%s,malloc fail ! ", __func__);
return;
}
mp_cal_arg->cal_type = cal_tye;
mp_cal_arg->enable = benable;
if (rtw_mp_phl_calibration(padapter, mp_cal_arg, RTW_MP_CAL_CMD_SET_CAPABILITY_CAL))
RTW_INFO("%s ok\n", __func__);
else
RTW_INFO("%s fail\n", __func__);
if (mp_cal_arg)
_rtw_mfree(mp_cal_arg, sizeof(struct rtw_mp_cal_arg));
return;
}
/*
* General use
*/
s32 SetPowerTracking(_adapter *padapter, u8 enable)
{
//hal_mpt_SetPowerTracking(padapter, enable);
return 0;
}
void GetPowerTracking(_adapter *padapter, u8 *enable)
{
//hal_mpt_GetPowerTracking(padapter, enable);
return;
}
void rtw_mp_trigger_iqk(_adapter *padapter)
{
rtw_mp_cal_trigger(padapter, RTW_MP_CAL_IQK);
}
void rtw_mp_trigger_lck(_adapter *padapter)
{
rtw_mp_cal_trigger(padapter, RTW_MP_CAL_LCK);
}
void rtw_mp_trigger_dpk(_adapter *padapter)
{
rtw_mp_cal_trigger(padapter, RTW_MP_CAL_DPK);
}
void rtw_mp_trigger_tssi(_adapter *padapter)
{
rtw_mp_cal_trigger(padapter, RTW_MP_CAL_TSSI);
}
void rtw_mp_trigger_ch_rfk(_adapter *padapter)
{
rtw_mp_cal_trigger(padapter, RTW_MP_CAL_CHL_RFK);
}
void rtw_mp_trigger_dack(_adapter *padapter)
{
rtw_mp_cal_trigger(padapter, RTW_MP_CAL_DACK);
}
static void init_mp_data(_adapter *padapter)
{
#if 0
struct dm_struct *phydm = adapter_to_phydm(padapter);
/*disable BCN*/
v8 = rtw_read8(padapter, REG_BCN_CTRL);
v8 &= ~EN_BCN_FUNCTION;
rtw_write8(padapter, REG_BCN_CTRL, v8);
phydm->rf_calibrate_info.txpowertrack_control = _FALSE;
#endif
}
u32 mp_join(_adapter *padapter, u8 mode)
{
WLAN_BSSID_EX bssid;
struct sta_info *psta;
u32 length;
s32 res = _SUCCESS;
u8 i = 0;
struct mp_priv *pmppriv = &padapter->mppriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *tgt_network = &pmlmepriv->cur_network;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
WLAN_BSSID_EX *pnetwork = (WLAN_BSSID_EX *)(&(pmlmeinfo->network));
/* 1. initialize a new WLAN_BSSID_EX */
_rtw_memset(&bssid, 0, sizeof(WLAN_BSSID_EX));
RTW_INFO("%s ,pmppriv->network_macaddr=%x %x %x %x %x %x\n", __func__,
pmppriv->network_macaddr[0], pmppriv->network_macaddr[1], pmppriv->network_macaddr[2], pmppriv->network_macaddr[3], pmppriv->network_macaddr[4],
pmppriv->network_macaddr[5]);
_rtw_memcpy(bssid.MacAddress, pmppriv->network_macaddr, ETH_ALEN);
if (mode == WIFI_FW_ADHOC_STATE) {
bssid.Ssid.SsidLength = strlen("mp_pseudo_adhoc");
_rtw_memcpy(bssid.Ssid.Ssid, (u8 *)"mp_pseudo_adhoc", bssid.Ssid.SsidLength);
bssid.InfrastructureMode = Ndis802_11IBSS;
bssid.IELength = 0;
bssid.Configuration.DSConfig = pmppriv->channel;
} else if (mode == WIFI_FW_STATION_STATE) {
bssid.Ssid.SsidLength = strlen("mp_pseudo_STATION");
_rtw_memcpy(bssid.Ssid.Ssid, (u8 *)"mp_pseudo_STATION", bssid.Ssid.SsidLength);
bssid.InfrastructureMode = Ndis802_11Infrastructure;
bssid.IELength = 0;
}
length = get_WLAN_BSSID_EX_sz(&bssid);
if (length % 4)
bssid.Length = ((length >> 2) + 1) << 2; /* round up to multiple of 4 bytes. */
else
bssid.Length = length;
_rtw_spinlock_bh(&pmlmepriv->lock);
if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE)
goto end_of_mp_start_test;
/* init mp_start_test status */
for (i = 0; i < dvobj->iface_nums; i++) {
_adapter *iface = NULL;
struct mlme_priv *buddy_mlmepriv;
iface = dvobj->padapters[i];
buddy_mlmepriv = &iface->mlmepriv;
if (iface == NULL)
continue;
if (rtw_is_adapter_up(iface) == _FALSE)
continue;
if (check_fwstate(buddy_mlmepriv, WIFI_ASOC_STATE) == _TRUE) {
#ifdef CONFIG_STA_CMD_DISPR
rtw_disassoc_cmd(iface, 500, RTW_CMDF_WAIT_ACK);
#else /* !CONFIG_STA_CMD_DISPR */
rtw_disassoc_cmd(iface, 500, 0);
rtw_free_assoc_resources_cmd(iface, _TRUE, RTW_CMDF_WAIT_ACK);
#endif /* !CONFIG_STA_CMD_DISPR */
rtw_indicate_disconnect(iface, 0, _FALSE);
}
}
pmppriv->prev_fw_state = get_fwstate(pmlmepriv);
/*pmlmepriv->fw_state = WIFI_MP_STATE;*/
init_fwstate(pmlmepriv, WIFI_MP_STATE);
set_fwstate(pmlmepriv, WIFI_UNDER_LINKING);
/* 3 2. create a new psta for mp driver */
/* clear psta in the cur_network, if any */
psta = rtw_get_stainfo(&padapter->stapriv, tgt_network->network.MacAddress);
if (psta)
rtw_free_stainfo(padapter, psta);
psta = rtw_alloc_stainfo(&padapter->stapriv, bssid.MacAddress);
if (psta == NULL) {
/*pmlmepriv->fw_state = pmppriv->prev_fw_state;*/
init_fwstate(pmlmepriv, pmppriv->prev_fw_state);
res = _FAIL;
goto end_of_mp_start_test;
}
if (mode == WIFI_FW_ADHOC_STATE)
set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
else
set_fwstate(pmlmepriv, WIFI_STATION_STATE);
/* 3 3. join psudo AdHoc */
tgt_network->join_res = 1;
tgt_network->aid = psta->phl_sta->aid = 1;
_rtw_memcpy(&padapter->registrypriv.dev_network, &bssid, length);
rtw_update_registrypriv_dev_network(padapter);
_rtw_memcpy(&tgt_network->network, &padapter->registrypriv.dev_network, padapter->registrypriv.dev_network.Length);
_rtw_memcpy(pnetwork, &padapter->registrypriv.dev_network, padapter->registrypriv.dev_network.Length);
rtw_indicate_connect(padapter);
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
set_fwstate(pmlmepriv, WIFI_ASOC_STATE);
end_of_mp_start_test:
_rtw_spinunlock_bh(&pmlmepriv->lock);
if (1) { /* (res == _SUCCESS) */
/* set MSR to WIFI_FW_ADHOC_STATE */
if (mode == WIFI_FW_ADHOC_STATE) {
/* set msr to WIFI_FW_ADHOC_STATE */
pmlmeinfo->state = WIFI_FW_ADHOC_STATE;
rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, padapter->registrypriv.dev_network.MacAddress);
rtw_hal_rcr_set_chk_bssid(padapter, MLME_ADHOC_STARTED);
pmlmeinfo->state |= WIFI_FW_ASSOC_SUCCESS;
} else {
RTW_INFO("%s , pmppriv->network_macaddr =%x %x %x %x %x %x\n", __func__,
pmppriv->network_macaddr[0], pmppriv->network_macaddr[1], pmppriv->network_macaddr[2], pmppriv->network_macaddr[3], pmppriv->network_macaddr[4],
pmppriv->network_macaddr[5]);
rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, pmppriv->network_macaddr);
}
}
return res;
}
/* This function initializes the DUT to the MP test mode */
s32 mp_start_test(_adapter *padapter)
{
struct mp_priv *pmppriv = &padapter->mppriv;
s32 res = _SUCCESS;
padapter->registrypriv.mp_mode = 1;
init_mp_priv(padapter);
init_mp_data(padapter);
#if 0
#ifdef CONFIG_PCI_HCI
hal = GET_PHL_COM(adapter_to_dvobj(padapter));
hal->pci_backdoor_ctrl = 0;
rtw_pci_aspm_config(padapter);
#endif
/* 3 0. update mp_priv */
switch (GET_HAL_RFPATH(padapter)) {
case RF_1T1R:
pmppriv->antenna_tx = ANTENNA_A;
pmppriv->antenna_rx = ANTENNA_A;
break;
case RF_1T2R:
default:
pmppriv->antenna_tx = ANTENNA_A;
pmppriv->antenna_rx = ANTENNA_AB;
break;
case RF_2T2R:
pmppriv->antenna_tx = ANTENNA_AB;
pmppriv->antenna_rx = ANTENNA_AB;
break;
case RF_2T4R:
pmppriv->antenna_tx = ANTENNA_AB;
pmppriv->antenna_rx = ANTENNA_ABCD;
break;
}
#endif
mpt_ProStartTest(padapter);
mp_join(padapter, WIFI_FW_ADHOC_STATE);
return res;
}
/* ------------------------------------------------------------------------------
* This function change the DUT from the MP test mode into normal mode */
void mp_stop_test(_adapter *padapter)
{
struct mp_priv *pmppriv = &padapter->mppriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *tgt_network = &pmlmepriv->cur_network;
struct sta_info *psta;
#ifdef CONFIG_PCI_HCI
struct registry_priv *registry_par = &padapter->registrypriv;
#endif
if (pmppriv->mode == MP_ON) {
pmppriv->bSetTxPower = 0;
_rtw_spinlock_bh(&pmlmepriv->lock);
if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _FALSE)
goto end_of_mp_stop_test;
/* 3 1. disconnect psudo AdHoc */
rtw_indicate_disconnect(padapter, 0, _FALSE);
/* 3 2. clear psta used in mp test mode.
* rtw_free_assoc_resources(padapter, _TRUE); */
psta = rtw_get_stainfo(&padapter->stapriv, tgt_network->network.MacAddress);
if (psta)
rtw_free_stainfo(padapter, psta);
/* 3 3. return to normal state (default:station mode) */
/*pmlmepriv->fw_state = pmppriv->prev_fw_state; */ /* WIFI_STATION_STATE;*/
init_fwstate(pmlmepriv, pmppriv->prev_fw_state);
/* flush the cur_network */
_rtw_memset(tgt_network, 0, sizeof(struct wlan_network));
_clr_fwstate_(pmlmepriv, WIFI_MP_STATE);
end_of_mp_stop_test:
_rtw_spinunlock_bh(&pmlmepriv->lock);
#if 0//def CONFIG_PCI_HCI
hal = GET_PHL_COM(adapter_to_dvobj(padapter));
hal->pci_backdoor_ctrl = registry_par->pci_aspm_config;
rtw_pci_aspm_config(padapter);
#endif
}
}
void SetChannel(_adapter *padapter)
{
#ifdef CONFIG_MP_INCLUDED
rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_SET_CH_BW);
#else
//hal_mpt_SetChannel(adapter);
#endif
}
void SetBandwidth(_adapter *padapter)
{
#ifdef CONFIG_MP_INCLUDED
rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_SET_CH_BW);
#else
//hal_mpt_SetBandwidth(adapter);
#endif
}
void SetAntenna(_adapter *padapter)
{
mp_ant_path mp_trx_path = padapter->mppriv.antenna_trx;
u8 cfg_rf_path = RF_PATH_A;
switch (mp_trx_path) {
case MP_ANTENNA_A:
cfg_rf_path = RF_PATH_A;
break;
case MP_ANTENNA_B:
cfg_rf_path = RF_PATH_B;
break;
case MP_ANTENNA_C:
cfg_rf_path = RF_PATH_C;
break;
case MP_ANTENNA_D:
cfg_rf_path = RF_PATH_D;
break;
case MP_ANTENNA_AB:
cfg_rf_path = RF_PATH_AB;
break;
case MP_ANTENNA_AC:
cfg_rf_path = RF_PATH_AC;
break;
case MP_ANTENNA_AD:
cfg_rf_path = RF_PATH_AD;
break;
case MP_ANTENNA_BC:
cfg_rf_path = RF_PATH_BC;
break;
case MP_ANTENNA_BD:
cfg_rf_path = RF_PATH_BD;
break;
case MP_ANTENNA_CD:
cfg_rf_path = RF_PATH_CD;
break;
case MP_ANTENNA_ABC:
cfg_rf_path = RF_PATH_ABC;
break;
case MP_ANTENNA_BCD:
cfg_rf_path = RF_PATH_BCD;
break;
case MP_ANTENNA_ABD:
cfg_rf_path = RF_PATH_ABD;
break;
case MP_ANTENNA_ACD:
cfg_rf_path = RF_PATH_ACD;
break;
case MP_ANTENNA_ABCD:
cfg_rf_path = RF_PATH_ABCD;
break;
default:
RTW_INFO("%s ,default Antenna Path A\n", __func__);
break;
}
padapter->mppriv.antenna_trx = cfg_rf_path;
rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_SET_RF_TXRX_PATH);
}
int rtw_mp_txpoweridx(_adapter *adapter)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &adapter->mppriv;
u8 tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(adapter));
u8 i = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.txpwr_index = pmppriv->txpoweridx * TX_POWER_CODE_WORD_BASE;
for (i = 0; i < tx_nss; i++) {
ptxpwr_arg.rfpath = i;
ptxpwr_arg.is_cck = rtw_mp_is_cck_rate(pmppriv->rateidx);
rtw_mp_phl_txpower(adapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_SET_TXPWR_INDEX);
}
return _TRUE;
}
s16 rtw_mp_get_pwr_refcw(_adapter *adapter, u8 rfpath, u8 is_cck)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &adapter->mppriv;
s16 txpwr_refcw_idx;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.rfpath = rfpath;
ptxpwr_arg.is_cck = is_cck;
rtw_mp_phl_txpower(adapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_GET_TXPWR_REF_CW);
txpwr_refcw_idx = ptxpwr_arg.txpwr_index / TX_POWER_CODE_WORD_BASE;
RTW_INFO("%s ,pwr ref cw: %d\n", __func__, txpwr_refcw_idx);
return txpwr_refcw_idx;
}
u16 rtw_mp_get_pwr_ref(_adapter *adapter, u8 rfpath)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &adapter->mppriv;
s16 txpwr_ref;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.rfpath = rfpath;
ptxpwr_arg.is_cck = rtw_mp_is_cck_rate(pmppriv->rateidx);
rtw_mp_phl_txpower(adapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_GET_TXPWR_REF);
txpwr_ref = ptxpwr_arg.txpwr_ref / TX_POWER_BASE;
RTW_INFO("%s ,pwr ref: %d\n", __func__, txpwr_ref);
return txpwr_ref;
}
u16 rtw_mp_get_pwrtab_dbm(_adapter *adapter, u8 rfpath)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &adapter->mppriv;
s16 txpwr_dbm;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.rfpath = rfpath;
ptxpwr_arg.is_cck = rtw_mp_is_cck_rate(pmppriv->rateidx);
ptxpwr_arg.rate = pmppriv->rateidx;
ptxpwr_arg.dcm = 0;
ptxpwr_arg.offset = 0;
ptxpwr_arg.bandwidth = pmppriv->bandwidth;
ptxpwr_arg.beamforming = 0;
ptxpwr_arg.channel = pmppriv->channel;
rtw_mp_phl_txpower(adapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_READ_PWR_TABLE);
txpwr_dbm = ptxpwr_arg.table_item / TX_POWER_BASE;
RTW_INFO("%s ,read PwrTab dbm: %d\n", __func__, txpwr_dbm);
return txpwr_dbm;
}
u16 rtw_mp_txpower_dbm(_adapter *adapter, u8 rf_path)
{
struct mp_priv *pmppriv = &adapter->mppriv;
struct rtw_mp_txpwr_arg ptxpwr_arg;
u16 tmp_power_ref = 0;
u16 agc_cw_val = 0;
s16 pre_pwr_refcw_idx = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.txpwr = pmppriv->txpowerdbm;
ptxpwr_arg.is_cck = rtw_mp_is_cck_rate(pmppriv->rateidx);
ptxpwr_arg.rfpath = rf_path;
rtw_mp_phl_txpower(adapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_SET_TXPWR);
if (pmppriv->pre_refcw_cck_pwridxa == 0 || pmppriv->pre_refcw_cck_pwridxb == 0) {
pmppriv->pre_refcw_cck_pwridxa = rtw_mp_get_pwr_refcw(adapter, RF_PATH_A, 1);
pmppriv->pre_refcw_cck_pwridxb = rtw_mp_get_pwr_refcw(adapter, RF_PATH_B, 1);
}
if (pmppriv->pre_refcw_ofdm_pwridxa == 0 || pmppriv->pre_refcw_ofdm_pwridxb == 0) {
pmppriv->pre_refcw_ofdm_pwridxa = rtw_mp_get_pwr_refcw(adapter, RF_PATH_A, 0);
pmppriv->pre_refcw_ofdm_pwridxb = rtw_mp_get_pwr_refcw(adapter, RF_PATH_B, 0);
}
if (rf_path == RF_PATH_A && ptxpwr_arg.is_cck == true)
pre_pwr_refcw_idx = pmppriv->pre_refcw_cck_pwridxa;
else if (rf_path == RF_PATH_B && ptxpwr_arg.is_cck == true)
pre_pwr_refcw_idx = pmppriv->pre_refcw_cck_pwridxb;
else if (rf_path == RF_PATH_A && ptxpwr_arg.is_cck == false)
pre_pwr_refcw_idx = pmppriv->pre_refcw_ofdm_pwridxa;
else if (rf_path == RF_PATH_B && ptxpwr_arg.is_cck == false)
pre_pwr_refcw_idx = pmppriv->pre_refcw_ofdm_pwridxb;
tmp_power_ref = rtw_mp_get_pwr_ref(adapter, rf_path);
RTW_INFO("%s () tmp_power_ref: %d !! pre_pwr_refcw_idx:%d, pwr offset %d\n",
__func__, tmp_power_ref, pre_pwr_refcw_idx , pmppriv->txpoweridx);
agc_cw_val = pmppriv->txpowerdbm - tmp_power_ref + pre_pwr_refcw_idx + pmppriv->txpoweridx;
ptxpwr_arg.txpwr_index = (pre_pwr_refcw_idx + pmppriv->txpoweridx) * TX_POWER_CODE_WORD_BASE;
rtw_mp_phl_txpower(adapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_SET_TXPWR_INDEX);
return agc_cw_val;
}
void SetDataRate(_adapter *padapter)
{
rtw_mp_phl_config_arg(padapter, RTW_MP_CONFIG_CMD_SET_RATE_IDX);
return;
}
void SetTxAGCOffset(_adapter *adapter, u32 ulTxAGCOffset)
{
u32 TxAGCOffset_B, TxAGCOffset_C, TxAGCOffset_D, tmpAGC;
TxAGCOffset_B = (ulTxAGCOffset & 0x000000ff);
TxAGCOffset_C = ((ulTxAGCOffset & 0x0000ff00) >> 8);
TxAGCOffset_D = ((ulTxAGCOffset & 0x00ff0000) >> 16);
tmpAGC = (TxAGCOffset_D << 8 | TxAGCOffset_C << 4 | TxAGCOffset_B);
// write_bbreg(adapter, rFPGA0_TxGainStage,
// (bXBTxAGC | bXCTxAGC | bXDTxAGC), tmpAGC);
}
void MP_PHY_SetRFPathSwitch(_adapter *adapter , BOOLEAN bMain)
{
//PHY_SetRFPathSwitch(adapter, bMain);
return;
}
void mp_phy_switch_rf_path_set(_adapter *adapter , u8 *pstate)
{
//phy_switch_rf_path_set(adapter, pstate);
return;
}
u8 MP_PHY_QueryRFPathSwitch(_adapter *adapter)
{
//return PHY_QueryRFPathSwitch(adapter);
return 0;
}
s32 SetThermalMeter(_adapter *adapter, u8 target_ther)
{
//return hal_mpt_SetThermalMeter(adapter, target_ther);
return 0;
}
#if 0
static void TriggerRFThermalMeter(_adapter *adapter)
{
hal_mpt_TriggerRFThermalMeter(adapter);
}
static u8 ReadRFThermalMeter(_adapter *adapter)
{
return hal_mpt_ReadRFThermalMeter(adapter);
}
#endif
void GetThermalMeter(_adapter *adapter, u8 rfpath ,u8 *value)
{
struct mp_priv *pmppriv = &adapter->mppriv;
struct rtw_mp_txpwr_arg ptxpwr_arg;
u16 i = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.mp_class = RTW_MP_CLASS_TXPWR;
ptxpwr_arg.cmd = RTW_MP_TXPWR_CMD_GET_THERMAL;
ptxpwr_arg.rfpath = rfpath;
rtw_mp_set_phl_cmd(adapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
while (i != 100) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(adapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
if (ptxpwr_arg.cmd_ok && ptxpwr_arg.status == RTW_PHL_STATUS_SUCCESS) {
*value = ptxpwr_arg.thermal;
RTW_INFO("%s, SET CMD OK, thermal = %d\n", __func__, ptxpwr_arg.thermal);
break;
} else {
if (i > 100) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__, ptxpwr_arg.status);
break;
}
i++;
rtw_msleep_os(10);
}
}
}
void rtw_mp_singlecarrier_tx(_adapter *adapter, u8 bstart)
{
RTW_INFO("Not Supported SetSingleCarrierTx \n");
}
void rtw_mp_singletone_tx(_adapter *adapter, u8 bstart)
{
struct mp_priv *pmp_priv = &adapter->mppriv;
rtw_mp_txpwr_level(adapter);
rtw_phl_mp_tx_cmd(adapter, RTW_MP_TX_SINGLE_TONE, pmp_priv->rtw_mp_tx_method, bstart);
}
void rtw_mp_carriersuppr_tx(_adapter *adapter, u8 bstart)
{
struct mp_priv *pmp_priv = &adapter->mppriv;
rtw_mp_txpwr_level(adapter);
rtw_phl_mp_tx_cmd(adapter, RTW_MP_TX_CCK_Carrier_Suppression, pmp_priv->rtw_mp_tx_method, bstart);
}
void rtw_mp_continuous_tx(_adapter *adapter, u8 bstart)
{
struct mp_priv *pmp_priv = &adapter->mppriv;
rtw_mp_txpwr_level(adapter);
rtw_phl_mp_tx_cmd(adapter, RTW_MP_TX_CONTINUOUS, pmp_priv->rtw_mp_tx_method, bstart);
}
void rtw_mp_txpwr_level(_adapter *adapter)
{
struct mp_priv *pmp_priv = &adapter->mppriv;
/*
if (pmp_priv->bSetTxPower == 0)
rtw_hal_set_tx_power_level(adapter, pmp_priv->channel);
*/
return;
}
/* ------------------------------------------------------------------------------ */
static void dump_mpframe(_adapter *padapter, struct xmit_frame *pmpframe)
{
/*rtw_hal_mgnt_xmit(padapter, pmpframe);*/
rtw_mgnt_xmit(padapter, pmpframe);
}
static struct xmit_frame *alloc_mp_xmitframe(struct xmit_priv *pxmitpriv)
{
#if 0 /*CONFIG_CORE_XMITBUF*/
struct xmit_frame *pmpframe;
struct xmit_buf *pxmitbuf;
pmpframe = rtw_alloc_xmitframe(pxmitpriv);
if (pmpframe == NULL)
return NULL;
pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
if (pxmitbuf == NULL) {
rtw_free_xmitframe(pxmitpriv, pmpframe);
return NULL;
}
pmpframe->frame_tag = MP_FRAMETAG;
pmpframe->pxmitbuf = pxmitbuf;
pmpframe->buf_addr = pxmitbuf->pbuf;
pxmitbuf->priv_data = pmpframe;
#else
struct xmit_frame *pmpframe;
pmpframe = rtw_alloc_xmitframe(pxmitpriv, 0);
if (pmpframe == NULL)
return NULL;
pmpframe->frame_tag = MP_FRAMETAG;
#endif
return pmpframe;
}
static thread_return mp_xmit_packet_thread(thread_context context)
{
struct xmit_frame *pxmitframe;
struct mp_tx *pmptx;
struct mp_priv *pmp_priv;
struct xmit_priv *pxmitpriv;
_adapter *padapter;
pmp_priv = (struct mp_priv *)context;
pmptx = &pmp_priv->tx;
padapter = pmp_priv->papdater;
pxmitpriv = &(padapter->xmitpriv);
rtw_thread_enter("RTW_MP_THREAD");
RTW_INFO("%s:pkTx Start\n", __func__);
while (1) {
pxmitframe = alloc_mp_xmitframe(pxmitpriv);
if (pxmitframe == NULL) {
if (pmptx->stop ||
RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
goto exit;
else {
rtw_usleep_os(10);
continue;
}
}
_rtw_memcpy((u8 *)(pxmitframe->buf_addr + TXDESC_OFFSET), pmptx->buf, pmptx->write_size);
_rtw_memcpy(&(pxmitframe->attrib), &(pmptx->attrib), sizeof(struct pkt_attrib));
rtw_usleep_os(padapter->mppriv.pktInterval);
dump_mpframe(padapter, pxmitframe);
pmptx->sended++;
pmp_priv->tx_pktcount++;
if (pmptx->stop ||
RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
goto exit;
if ((pmptx->count != 0) &&
(pmptx->count == pmptx->sended))
goto exit;
flush_signals_thread();
}
exit:
/* RTW_INFO("%s:pkTx Exit\n", __func__); */
rtw_mfree(pmptx->pallocated_buf, pmptx->buf_size);
pmptx->pallocated_buf = NULL;
pmptx->stop = 1;
rtw_thread_exit(NULL);
return 0;
}
void fill_txdesc_for_mp(_adapter *padapter, u8 *ptxdesc)
{
struct mp_priv *pmp_priv = &padapter->mppriv;
_rtw_memcpy(ptxdesc, pmp_priv->tx.desc, TXDESC_SIZE);
}
static void Rtw_MPSetMacTxEDCA(_adapter *padapter)
{
#if 0
rtw_write32(padapter, 0x508 , 0x00a422); /* Disable EDCA BE Txop for MP pkt tx adjust Packet interval */
/* RTW_INFO("%s:write 0x508~~~~~~ 0x%x\n", __func__,rtw_read32(padapter, 0x508)); */
phy_set_mac_reg(padapter, 0x458 , bMaskDWord , 0x0);
/*RTW_INFO("%s()!!!!! 0x460 = 0x%x\n" ,__func__, phy_query_bb_reg(padapter, 0x460, bMaskDWord));*/
phy_set_mac_reg(padapter, 0x460 , bMaskLWord , 0x0); /* fast EDCA queue packet interval & time out value*/
/*phy_set_mac_reg(padapter, ODM_EDCA_VO_PARAM ,bMaskLWord , 0x431C);*/
/*phy_set_mac_reg(padapter, ODM_EDCA_BE_PARAM ,bMaskLWord , 0x431C);*/
/*phy_set_mac_reg(padapter, ODM_EDCA_BK_PARAM ,bMaskLWord , 0x431C);*/
RTW_INFO("%s()!!!!! 0x460 = 0x%x\n" , __func__, phy_query_bb_reg(padapter, 0x460, bMaskDWord));
#endif
}
u8 rtw_phl_mp_tx_cmd(_adapter *padapter, enum rtw_mp_tx_cmd cmdid,
enum rtw_mp_tx_method tx_method, boolean bstart)
{
struct mp_priv *pmppriv = &padapter->mppriv;
struct pkt_attrib *pattrib = &pmppriv->tx.attrib;
struct rtw_mp_tx_arg tx_arg;
u16 i = 0;
u8 user_idx = pmppriv->mp_plcp_useridx;
_rtw_memset((void *)&tx_arg, 0, sizeof(struct rtw_mp_tx_arg));
tx_arg.mp_class = RTW_MP_CLASS_TX;
tx_arg.tx_method = tx_method;
tx_arg.cmd = cmdid;
tx_arg.cmd_ok = 0;
tx_arg.tx_ok = 0;
tx_arg.data_rate = pmppriv->rateidx;
tx_arg.is_cck = rtw_mp_is_cck_rate(pmppriv->rateidx);
tx_arg.start_tx = bstart;
tx_arg.tx_path = pmppriv->antenna_trx;
tx_arg.gi = pmppriv->rtw_mp_plcp_gi;
tx_arg.period = pmppriv->pktInterval;
tx_arg.plcp_usr_idx = user_idx;
tx_arg.stbc = pmppriv->rtw_mp_stbc;
switch (cmdid) {
case RTW_MP_TX_PACKETS:
RTW_INFO("%s,SET MP_TX_PACKETS tx_method %d\n", __func__, tx_arg.tx_method);
if (tx_method == RTW_MP_PMACT_TX) {
tx_arg.tx_mode = RTW_MP_PMAC_PKTS_TX;
tx_arg.tx_cnt = pmppriv->tx.count;
} else if (tx_method == RTW_MP_FW_PMACT_TX) {
tx_arg.tx_mode = RTW_MP_PMAC_FW_TRIG_TX;
tx_arg.tx_cnt = 0;
tx_arg.tx_time = 60;
}
break;
case RTW_MP_TX_CONTINUOUS:
RTW_INFO("%s,SET MP_TX_CONTINUOUS\n", __func__);
tx_arg.tx_mode = RTW_MP_PMAC_CONT_TX;
break;
case RTW_MP_TX_SINGLE_TONE:
RTW_INFO("%s,SET TX_OFDM_Single_Tone\n", __func__);
tx_arg.tx_mode = RTW_MP_PMAC_OFDM_SINGLE_TONE_TX;
break;
case RTW_MP_TX_CCK_Carrier_Suppression:
RTW_INFO("%s,SET TX_CCK_Carrier_Suppression\n", __func__);
tx_arg.tx_mode = RTW_MP_PMAC_CCK_CARRIER_SIPPRESSION_TX;
break;
case RTW_MP_TX_CONFIG_PLCP_PATTERN:
RTW_INFO("%s,SET MP_TX_CONFIG_PLCP_PATTERN\n", __func__);
tx_arg.plcp_case_id = pmppriv->rtw_mp_pmact_patt_idx;
tx_arg.plcp_ppdu_type = pmppriv->rtw_mp_pmact_ppdu_type;
break;
case RTW_MP_TX_CONFIG_PLCP_COMMON_INFO:
tx_arg.dbw = pmppriv->rtw_mp_data_bandwidth;
tx_arg.long_preamble_en = pmppriv->preamble;
tx_arg.stbc = pmppriv->rtw_mp_stbc;
tx_arg.gi = pmppriv->rtw_mp_plcp_gi;
tx_arg.he_ltf_type = pmppriv->rtw_mp_plcp_ltf;
tx_arg.he_mcs_sigb = pmppriv->rtw_mp_he_sigb;
tx_arg.he_dcm_sigb = pmppriv->rtw_mp_he_sigb_dcm;
tx_arg.bss_color = 0;
tx_arg.he_er_u106ru_en = pmppriv->rtw_mp_he_er_su_ru_106_en;
if (pmppriv->rtw_mp_tx_method == RTW_MP_FW_PMACT_TX) {
pmppriv->rtw_mp_plcp_tx_time = 5484;
pmppriv->rtw_mp_plcp_tx_mode = 1;
}
tx_arg.max_tx_time_0p4us = pmppriv->rtw_mp_plcp_tx_time;
tx_arg.mode = pmppriv->rtw_mp_plcp_tx_mode;
tx_arg.ppdu_type = pmppriv->rtw_mp_pmact_ppdu_type;
tx_arg.cbw = pmppriv->bandwidth;
tx_arg.txsc = pmppriv->rtw_mp_trxsc;
tx_arg.n_user = pmppriv->rtw_mp_plcp_tx_user;
RTW_INFO("%s,SET TX_CONFIG_PLCP_COMMON_INFO\n", __func__);
RTW_INFO("%s=============================\n", __func__);
RTW_INFO("%s dbw = %d\n", __func__, tx_arg.dbw);
RTW_INFO("%s long_preamble_en = %d\n", __func__, tx_arg.long_preamble_en);
RTW_INFO("%s stbc = %d\n", __func__, tx_arg.stbc);
RTW_INFO("%s gi = %d\n", __func__, tx_arg.gi);
RTW_INFO("%s tb_l_len = %d\n", __func__, tx_arg.tb_l_len);
RTW_INFO("%s he_ltf_type = %d\n", __func__, tx_arg.he_ltf_type);
RTW_INFO("%s he_mcs_sigb = %d\n", __func__, tx_arg.he_mcs_sigb);
RTW_INFO("%s he_dcm_sigb = %d\n", __func__, tx_arg.he_dcm_sigb);
RTW_INFO("%s max_tx_time_0p4us = %d\n", __func__, tx_arg.max_tx_time_0p4us);
RTW_INFO("%s bss_color = %d\n", __func__, tx_arg.bss_color);
RTW_INFO("%s he_er_u106ru_en = %d\n", __func__, tx_arg.he_er_u106ru_en);
RTW_INFO("%s mode = %d\n", __func__, tx_arg.mode);
RTW_INFO("%s ppdu_type = %d\n", __func__, tx_arg.ppdu_type);
RTW_INFO("%s cbw = %d\n", __func__, tx_arg.cbw);
RTW_INFO("%s txsc = %d\n", __func__, tx_arg.txsc);
RTW_INFO("%s n_user = %d\n", __func__, tx_arg.n_user);
RTW_INFO("%s=============================\n", __func__);
break;
case RTW_MP_TX_CMD_PHY_OK:
/*TBD. API not ready*/
RTW_INFO("%s,SET MP_TX_CMD_PHY_OK\n", __func__);
break;
case RTW_MP_TX_CONFIG_PLCP_USER_INFO:
tx_arg.plcp_usr_idx = user_idx;
tx_arg.mcs = pmppriv->mp_plcp_user[user_idx].plcp_mcs;
tx_arg.fec = pmppriv->mp_plcp_user[user_idx].coding;
tx_arg.dcm = pmppriv->mp_plcp_user[user_idx].dcm;
tx_arg.aid = pmppriv->mp_plcp_user[user_idx].aid;
tx_arg.scrambler_seed = (rtw_random32() % 127) + 1;
tx_arg.random_init_seed = (rtw_random32() % 127) + 1;
tx_arg.apep = pmppriv->mp_plcp_user[user_idx].plcp_txlen;
tx_arg.ru_alloc = pmppriv->mp_plcp_user[user_idx].ru_alloc;
tx_arg.nss = pmppriv->mp_plcp_user[user_idx].plcp_nss + 1;
tx_arg.pwr_boost_db = pmppriv->mp_plcp_user[user_idx].pwr_boost_db;
tx_arg.fec = pmppriv->mp_plcp_user[user_idx].coding;
RTW_INFO("%s,SET MP_TX_CONFIG_PLCP_USER_INFO\n", __func__);
RTW_INFO("%s plcp_usr_idx = %d\n", __func__, tx_arg.plcp_usr_idx);
RTW_INFO("%s mcs = %d\n", __func__, tx_arg.mcs);
RTW_INFO("%s fec = %d\n", __func__, tx_arg.fec);
RTW_INFO("%s dcm = %d\n", __func__, tx_arg.dcm);
RTW_INFO("%s ascrambler_seed = %d\n", __func__, tx_arg.scrambler_seed);
RTW_INFO("%s random_init_seed = %d\n", __func__, tx_arg.random_init_seed);
RTW_INFO("%s apep = %d\n", __func__, tx_arg.apep);
RTW_INFO("%s ru_alloc = %d\n", __func__, tx_arg.ru_alloc);
RTW_INFO("%s nss = %d\n", __func__, tx_arg.nss);
break;
case RTW_MP_TX_MODE_SWITCH:
if (pmppriv->rtw_mp_tx_method == RTW_MP_TMACT_TX)
tx_arg.tx_mode = 0;/* mode: 0 = tmac, 1 = pmac */
else
tx_arg.tx_mode = 1;/* mode: 0 = tmac, 1 = pmac */
RTW_INFO("%s,SET MP_TX_MODE_SWITCH\n", __func__);
break;
default:
RTW_INFO("%s,SET MP_TX_MODE None\n", __func__);
return 0;
}
rtw_mp_set_phl_cmd(padapter, (void*)&tx_arg, sizeof(struct rtw_mp_tx_arg));
while (i != 100) {
rtw_mp_get_phl_cmd(padapter, (void*)&tx_arg, sizeof(struct rtw_mp_tx_arg));
if (tx_arg.cmd_ok && tx_arg.status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,SET CMD OK\n", __func__);
if (cmdid == RTW_MP_TX_CMD_PHY_OK) {
RTW_INFO("%s, Get Tx Rpt OK CNT:%d\n", __func__, tx_arg.tx_ok);
padapter->mppriv.tx.sended = tx_arg.tx_ok;
}
break;
} else {
if (i > 100) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__, tx_arg.status);
break;
}
i++;
rtw_msleep_os(10);
}
}
return (tx_arg.cmd_ok);
}
static thread_return mp_xmit_phl_packet_thread(thread_context context)
{
struct mp_priv *pmppriv = (struct mp_priv *)context;
struct mp_tx *pmptx = &pmppriv->tx;
_adapter *padapter = pmppriv->papdater;
struct pkt_attrib *pattrib = &pmppriv->tx.attrib;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_trx_test_param test_param = {0};
u16 i = 0;
RTW_INFO("%s: Start !!\n", __func__);
rtw_phl_trx_default_param(GET_PHL_INFO(dvobj), &test_param);
test_param.tx_cap.f_rate = (u16)pmppriv->rateidx;
test_param.tx_payload_size = pattrib->pktlen;
test_param.tx_cap.f_gi_ltf = 0;
test_param.tx_cap.f_stbc = 0;
test_param.tx_cap.f_ldpc = 0;
RTW_INFO("%s: Start !! tx method %d\n", __func__, pmppriv->rtw_mp_tx_method);
while (1) {
if (pmppriv->rtw_mp_tx_method == RTW_MP_TMACT_TX) {
/*/if (rtw_phl_mp_tx_cmd(padapter, RTW_MP_TX_PACKETS, pmppriv->rtw_mp_tx_method, _TRUE)) {*/
if (rtw_phl_trx_testsuite(GET_PHL_INFO(dvobj), &test_param) == 0)
RTW_DBG("%s: rtw_phl_trx_testsuite!!\n", __func__);
else
rtw_usleep_os(10);
}
pmptx->sended++;
pmppriv->tx_pktcount++;
rtw_usleep_os(padapter->mppriv.pktInterval);
if (pmptx->stop || RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
goto exit;
if ((pmptx->count != 0) && (pmptx->count == pmptx->sended))
goto exit;
flush_signals_thread();
}
exit:
pmptx->stop = 1;
RTW_INFO("%s: Exit !!\n", __func__);
rtw_thread_exit(NULL);
return 0;
}
void rtw_set_phl_packet_tx(_adapter *padapter, u8 bStart)
{
struct mp_priv *pmp_priv;
u8 rfpath_i = 0;
u8 tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
pmp_priv = &padapter->mppriv;
for (rfpath_i = 0 ; rfpath_i < tx_nss; rfpath_i ++)
rtw_mp_txpower_dbm(padapter, rfpath_i);
RTW_INFO("%s: PACKET TX tx method %d!!\n", __func__, pmp_priv->rtw_mp_tx_method);
if (bStart) {
RTW_INFO("%s: !! tx method %d\n", __func__, pmp_priv->rtw_mp_tx_method);
pmp_priv->tx.sended = 0;
pmp_priv->tx.stop = 0;
pmp_priv->tx_pktcount = 0;
if (pmp_priv->rtw_mp_tx_method == RTW_MP_PMACT_TX ||
pmp_priv->rtw_mp_tx_method == RTW_MP_FW_PMACT_TX) {
RTW_INFO("%s: PLCP_USER_INFO & PLCP_COMMON_INFO!!\n", __func__);
if (rtw_phl_mp_tx_cmd(padapter, RTW_MP_TX_CONFIG_PLCP_USER_INFO, pmp_priv->rtw_mp_tx_method, _TRUE) == true)
RTW_INFO("%s: PLCP_USER_INFO done!!\n", __func__);
rtw_msleep_os(100);
if (rtw_phl_mp_tx_cmd(padapter, RTW_MP_TX_CONFIG_PLCP_COMMON_INFO, pmp_priv->rtw_mp_tx_method, _TRUE) == true)
RTW_INFO("%s: RTW_MP_TX_CONFIG_PLCP_COMMON_INFO done!!\n", __func__);
rtw_msleep_os(100);
}
if (pmp_priv->rtw_mp_tx_method == RTW_MP_FW_PMACT_TX) {
if (rtw_phl_mp_tx_cmd(padapter, RTW_MP_TX_PACKETS, pmp_priv->rtw_mp_tx_method, _TRUE))
RTW_INFO("%s: RTW_MP_FW_PMACT_TX!!\n", __func__);
else
RTW_INFO("%s: RTW_MP_FW_PMACT_TX fail!!\n", __func__);
} else if (pmp_priv->rtw_mp_tx_method == RTW_MP_PMACT_TX) {
if (rtw_phl_mp_tx_cmd(padapter, RTW_MP_TX_PACKETS, pmp_priv->rtw_mp_tx_method, _TRUE))
RTW_DBG("%s: RTW_MP_TX_PACKETS!!\n", __func__);
} else {
pmp_priv->tx.PktTxThread = rtw_thread_start(
mp_xmit_phl_packet_thread, pmp_priv, "RTW_MP_Tx_THREAD");
if (pmp_priv->tx.PktTxThread == NULL)
RTW_ERR("Create PktTx Thread Fail !!!!!\n");
}
}
if (!bStart) {
if (pmp_priv->rtw_mp_tx_method == RTW_MP_FW_PMACT_TX) {
if (rtw_phl_mp_tx_cmd(padapter, RTW_MP_TX_PACKETS, pmp_priv->rtw_mp_tx_method, false)) {
RTW_INFO("%s: RTW_MP_FW_TMACT_TX Stop TX!!\n", __func__);
return;
}
} else if (pmp_priv->rtw_mp_tx_method == RTW_MP_PMACT_TX) {
if (rtw_phl_mp_tx_cmd(padapter, RTW_MP_TX_PACKETS, pmp_priv->rtw_mp_tx_method, false)) {
RTW_INFO("%s: RTW_MP_PMACT_TX Stop TX!!\n", __func__);
return;
}
}
}
}
void rtw_mp_set_packet_tx(_adapter *padapter)
{
u8 *ptr, *pkt_start, *pkt_end;
u32 pkt_size = 0, i = 0, idx = 0, tmp_idx = 0;
struct rtw_ieee80211_hdr *hdr;
u8 payload;
s32 bmcast;
struct pkt_attrib *pattrib;
struct mp_priv *pmp_priv;
pmp_priv = &padapter->mppriv;
if (pmp_priv->tx.stop)
return;
pmp_priv->tx.sended = 0;
pmp_priv->tx.stop = 0;
pmp_priv->tx_pktcount = 0;
/* 3 1. update_attrib() */
pattrib = &pmp_priv->tx.attrib;
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
_rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
bmcast = IS_MCAST(pattrib->ra);
if (bmcast)
pattrib->psta = rtw_get_bcmc_stainfo(padapter);
else
pattrib->psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
if (pattrib->psta == NULL) {
RTW_INFO("%s:psta = NULL !!\n", __func__);
return;
}
pattrib->mac_id = pattrib->psta->phl_sta->macid;
pattrib->mbssid = 0;
pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->pktlen;
/* 3 2. allocate xmit buffer */
pkt_size = pattrib->last_txcmdsz;
if (pmp_priv->tx.pallocated_buf)
rtw_mfree(pmp_priv->tx.pallocated_buf, pmp_priv->tx.buf_size);
pmp_priv->tx.write_size = pkt_size;
pmp_priv->tx.buf_size = pkt_size + SZ_ALIGN_XMITFRAME_EXT;
pmp_priv->tx.pallocated_buf = rtw_zmalloc(pmp_priv->tx.buf_size);
if (pmp_priv->tx.pallocated_buf == NULL) {
RTW_INFO("%s: malloc(%d) fail!!\n", __func__, pmp_priv->tx.buf_size);
return;
}
pmp_priv->tx.buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pmp_priv->tx.pallocated_buf), SZ_ALIGN_XMITFRAME_EXT);
ptr = pmp_priv->tx.buf;
_rtw_memset(pmp_priv->tx.desc, 0, TXDESC_SIZE);
pkt_start = ptr;
pkt_end = pkt_start + pkt_size;
/* 3 3. init TX descriptor */
#if defined(CONFIG_RTL8822B)
if (IS_HARDWARE_TYPE_8822B(padapter))
rtl8822b_prepare_mp_txdesc(padapter, pmp_priv);
#endif /* CONFIG_RTL8822B */
#if defined(CONFIG_RTL8822C)
if (IS_HARDWARE_TYPE_8822C(padapter))
rtl8822c_prepare_mp_txdesc(padapter, pmp_priv);
#endif /* CONFIG_RTL8822C */
#if defined(CONFIG_RTL8821C)
if (IS_HARDWARE_TYPE_8821C(padapter))
rtl8821c_prepare_mp_txdesc(padapter, pmp_priv);
#endif /* CONFIG_RTL8821C */
#if defined(CONFIG_RTL8814B)
if (IS_HARDWARE_TYPE_8814B(padapter))
rtl8814b_prepare_mp_txdesc(padapter, pmp_priv);
#endif /* CONFIG_RTL8814B */
/* 3 4. make wlan header, make_wlanhdr() */
hdr = (struct rtw_ieee80211_hdr *)pkt_start;
set_frame_sub_type(&hdr->frame_ctl, pattrib->subtype);
_rtw_memcpy(hdr->addr1, pattrib->dst, ETH_ALEN); /* DA */
_rtw_memcpy(hdr->addr2, pattrib->src, ETH_ALEN); /* SA */
_rtw_memcpy(hdr->addr3, get_bssid(&padapter->mlmepriv), ETH_ALEN); /* RA, BSSID */
/* 3 5. make payload */
ptr = pkt_start + pattrib->hdrlen;
if (pmp_priv->mplink_btx == _TRUE) {
_rtw_memcpy(ptr, pmp_priv->mplink_buf, pkt_end - ptr);
} else {
switch (pmp_priv->tx.payload) {
case MP_TX_Payload_00:
RTW_INFO("MP packet tx 0x00 payload!\n");
payload = 0x00;
_rtw_memset(ptr, 0x00, pkt_end - ptr);
break;
case MP_TX_Payload_5a:
RTW_INFO("MP packet tx 0x5a payload!\n");
payload = 0x5a;
_rtw_memset(ptr, 0x5a, pkt_end - ptr);
break;
case MP_TX_Payload_a5:
RTW_INFO("MP packet tx 0xa5 payload!\n");
payload = 0xa5;
_rtw_memset(ptr, 0xa5, pkt_end - ptr);
break;
case MP_TX_Payload_ff:
RTW_INFO("MP packet tx 0xff payload!\n");
payload = 0xff;
_rtw_memset(ptr, 0xff, pkt_end - ptr);
break;
case MP_TX_Payload_prbs9:
RTW_INFO("MP packet tx PRBS9 payload!\n");
while (idx <= pkt_end - ptr) {
int start = 0x02;
int a = start;
for (i = 0;; i++) {
int newbit = (((a >> 8) ^ (a >> 4)) & 1);
a = ((a << 1) | newbit) & 0x1ff;
RTW_DBG("%x ", a);
ptr[idx + i] = a;
if (a == start) {
RTW_INFO("payload repetition period is %d , end %d\n", i , idx);
tmp_idx += i;
break;
}
if (idx + i >= (pkt_end - ptr)) {
tmp_idx += (idx + i);
RTW_INFO(" repetition period payload end curr ptr %d\n", idx + i);
break;
}
}
idx = tmp_idx;
}
break;
case MP_TX_Payload_default_random:
RTW_INFO("MP packet tx default random payload!\n");
for (i = 0; i < pkt_end - ptr; i++)
ptr[i] = rtw_random32() % 0xFF;
break;
default:
RTW_INFO("Config payload type default use 0x%x\n!", pmp_priv->tx.payload);
_rtw_memset(ptr, pmp_priv->tx.payload, pkt_end - ptr);
break;
}
}
/* 3 6. start thread */
#ifdef PLATFORM_LINUX
pmp_priv->tx.PktTxThread = rtw_thread_start(mp_xmit_packet_thread, pmp_priv, "RTW_MP_THREAD");
if (pmp_priv->tx.PktTxThread == NULL)
RTW_ERR("Create PktTx Thread Fail !!!!!\n");
#endif
#ifdef PLATFORM_FREEBSD
{
struct proc *p;
struct thread *td;
pmp_priv->tx.PktTxThread = kproc_kthread_add(mp_xmit_packet_thread, pmp_priv,
&p, &td, RFHIGHPID, 0, "MPXmitThread", "MPXmitThread");
if (pmp_priv->tx.PktTxThread < 0)
RTW_INFO("Create PktTx Thread Fail !!!!!\n");
}
#endif
Rtw_MPSetMacTxEDCA(padapter);
return;
}
void rtw_mp_reset_phy_count(_adapter *adapter)
{
RTW_INFO("%s()!!!\n", __func__);
rtw_mp_phl_config_arg(adapter, RTW_MP_CONFIG_CMD_SET_RESET_PHY_COUNT);
rtw_mp_phl_config_arg(adapter, RTW_MP_CONFIG_CMD_SET_RESET_MAC_COUNT);
rtw_mp_phl_config_arg(adapter, RTW_MP_CONFIG_CMD_SET_RESET_DRV_COUNT);
}
struct psd_init_regs {
/* 3 wire */
int reg_88c;
int reg_c00;
int reg_e00;
int reg_1800;
int reg_1a00;
/* cck */
int reg_800;
int reg_808;
};
static int rtw_mp_psd_init(_adapter *padapter, struct psd_init_regs *regs)
{
u8 rf_type = GET_HAL_RFPATH(adapter_to_dvobj(padapter));
#if 0
switch (rf_type) {
/* 1R */
case RF_1T1R:
if (rtw_hw_chk_proto_cap(padapter, PROTO_CAP_11AC)) {
/* 11AC 1R PSD Setting 3wire & cck off */
regs->reg_c00 = rtw_read32(padapter, 0xC00);
phy_set_bb_reg(padapter, 0xC00, 0x3, 0x00);
regs->reg_808 = rtw_read32(padapter, 0x808);
phy_set_bb_reg(padapter, 0x808, 0x10000000, 0x0);
} else {
/* 11N 3-wire off 1 */
regs->reg_88c = rtw_read32(padapter, 0x88C);
phy_set_bb_reg(padapter, 0x88C, 0x300000, 0x3);
/* 11N CCK off */
regs->reg_800 = rtw_read32(padapter, 0x800);
phy_set_bb_reg(padapter, 0x800, 0x1000000, 0x0);
}
break;
/* 2R */
case RF_1T2R:
case RF_2T2R:
if (rtw_hw_chk_proto_cap(padapter, PROTO_CAP_11AC)) {
/* 11AC 2R PSD Setting 3wire & cck off */
regs->reg_c00 = rtw_read32(padapter, 0xC00);
regs->reg_e00 = rtw_read32(padapter, 0xE00);
phy_set_bb_reg(padapter, 0xC00, 0x3, 0x00);
phy_set_bb_reg(padapter, 0xE00, 0x3, 0x00);
regs->reg_808 = rtw_read32(padapter, 0x808);
phy_set_bb_reg(padapter, 0x808, 0x10000000, 0x0);
} else {
/* 11N 3-wire off 2 */
regs->reg_88c = rtw_read32(padapter, 0x88C);
phy_set_bb_reg(padapter, 0x88C, 0xF00000, 0xF);
/* 11N CCK off */
regs->reg_800 = rtw_read32(padapter, 0x800);
phy_set_bb_reg(padapter, 0x800, 0x1000000, 0x0);
}
break;
/* 3R */
case RF_2T3R:
case RF_3T3R:
if (rtw_hw_chk_proto_cap(padapter, PROTO_CAP_11AC)) {
/* 11AC 3R PSD Setting 3wire & cck off */
regs->reg_c00 = rtw_read32(padapter, 0xC00);
regs->reg_e00 = rtw_read32(padapter, 0xE00);
regs->reg_1800 = rtw_read32(padapter, 0x1800);
phy_set_bb_reg(padapter, 0xC00, 0x3, 0x00);
phy_set_bb_reg(padapter, 0xE00, 0x3, 0x00);
phy_set_bb_reg(padapter, 0x1800, 0x3, 0x00);
regs->reg_808 = rtw_read32(padapter, 0x808);
phy_set_bb_reg(padapter, 0x808, 0x10000000, 0x0);
} else {
RTW_ERR("%s: 11n don't support 3R\n", __func__);
return -1;
}
break;
/* 4R */
case RF_2T4R:
case RF_3T4R:
case RF_4T4R:
if (rtw_hw_chk_proto_cap(padapter, PROTO_CAP_11AC)) {
/* 11AC 4R PSD Setting 3wire & cck off */
regs->reg_c00 = rtw_read32(padapter, 0xC00);
regs->reg_e00 = rtw_read32(padapter, 0xE00);
regs->reg_1800 = rtw_read32(padapter, 0x1800);
regs->reg_1a00 = rtw_read32(padapter, 0x1A00);
phy_set_bb_reg(padapter, 0xC00, 0x3, 0x00);
phy_set_bb_reg(padapter, 0xE00, 0x3, 0x00);
phy_set_bb_reg(padapter, 0x1800, 0x3, 0x00);
phy_set_bb_reg(padapter, 0x1A00, 0x3, 0x00);
regs->reg_808 = rtw_read32(padapter, 0x808);
phy_set_bb_reg(padapter, 0x808, 0x10000000, 0x0);
} else {
RTW_ERR("%s: 11n don't support 4R\n", __func__);
return -1;
}
break;
default:
RTW_ERR("%s: unknown %d rf type\n", __func__,
GET_HAL_RFPATH(adapter_to_dvobj(padapter)));
return -1;
}
/* Set PSD points, 0=128, 1=256, 2=512, 3=1024 */
if (rtw_hw_chk_proto_cap(padapter, PROTO_CAP_11AC))
phy_set_bb_reg(padapter, 0x910, 0xC000, 3);
else
phy_set_bb_reg(padapter, 0x808, 0xC000, 3);
#endif
RTW_INFO("%s: set %d rf type done\n", __func__,
GET_HAL_RFPATH(adapter_to_dvobj(padapter)));
return 0;
}
static int rtw_mp_psd_close(_adapter *padapter, struct psd_init_regs *regs)
{
u8 rf_type = GET_HAL_RFPATH(adapter_to_dvobj(padapter));
#if 0
if (!rtw_hw_chk_proto_cap(padapter, PROTO_CAP_11AC)) {
/* 11n 3wire restore */
rtw_write32(padapter, 0x88C, regs->reg_88c);
/* 11n cck restore */
rtw_write32(padapter, 0x800, regs->reg_800);
RTW_INFO("%s: restore %d rf type\n", __func__, rf_type);
return 0;
}
/* 11ac 3wire restore */
switch (rf_type) {
case RF_1T1R:
rtw_write32(padapter, 0xC00, regs->reg_c00);
break;
case RF_1T2R:
case RF_2T2R:
rtw_write32(padapter, 0xC00, regs->reg_c00);
rtw_write32(padapter, 0xE00, regs->reg_e00);
break;
case RF_2T3R:
case RF_3T3R:
rtw_write32(padapter, 0xC00, regs->reg_c00);
rtw_write32(padapter, 0xE00, regs->reg_e00);
rtw_write32(padapter, 0x1800, regs->reg_1800);
break;
case RF_2T4R:
case RF_3T4R:
case RF_4T4R:
rtw_write32(padapter, 0xC00, regs->reg_c00);
rtw_write32(padapter, 0xE00, regs->reg_e00);
rtw_write32(padapter, 0x1800, regs->reg_1800);
rtw_write32(padapter, 0x1A00, regs->reg_1a00);
break;
default:
RTW_WARN("%s: unknown %d rf type\n", __func__, rf_type);
break;
}
/* 11ac cck restore */
rtw_write32(padapter, 0x808, regs->reg_808);
#endif
RTW_INFO("%s: restore %d rf type done\n", __func__, rf_type);
return 0;
}
/* reg 0x808[9:0]: FFT data x
* reg 0x808[22]: 0 --> 1 to get 1 FFT data y
* reg 0x8B4[15:0]: FFT data y report */
static u32 rtw_GetPSDData(_adapter *adapter, u32 point)
{
u32 psd_val = 0;
#if 0
#if defined(CONFIG_RTL8822B) || defined(CONFIG_RTL8821C) || defined(CONFIG_RTL8822C)
u16 psd_reg = 0x910;
u16 psd_regL = 0xF44;
#else
u16 psd_reg = 0x808;
u16 psd_regL = 0x8B4;
#endif
psd_val = rtw_read32(adapter, psd_reg);
psd_val &= 0xFFBFFC00;
psd_val |= point;
rtw_write32(adapter, psd_reg, psd_val);
rtw_mdelay_os(1);
psd_val |= 0x00400000;
rtw_write32(adapter, psd_reg, psd_val);
rtw_mdelay_os(1);
psd_val = rtw_read32(adapter, psd_regL);
#if defined(CONFIG_RTL8821C)
psd_val = (psd_val & 0x00FFFFFF) / 32;
#else
psd_val &= 0x0000FFFF;
#endif
#endif
return psd_val;
}
u8 rtw_mp_phl_psd_cmd(_adapter *padapter, struct rtw_mp_cal_arg *psd_arg, u8 cmdid)
{
struct mp_priv *pmppriv = &padapter->mppriv;
u16 i = 0;
u32 cmd_size = sizeof(struct rtw_mp_cal_arg);
psd_arg->mp_class = RTW_MP_CLASS_CAL;
psd_arg->cmd = cmdid;
rtw_mp_set_phl_cmd(padapter, (void*)psd_arg, cmd_size);
while (i <= 100) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(padapter, (void*)psd_arg, cmd_size);
if (psd_arg->cmd_ok && psd_arg->status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,SET CMD OK\n", __func__);
return psd_arg->cmd_ok;
} else {
if (i > 100) {
RTW_DBG("%s,GET CMD FAIL !!! status %d\n", __func__, psd_arg->status);
break;
}
i++;
}
}
return 0;
}
/*
* pts start_point_min stop_point_max
* 128 64 64 + 128 = 192
* 256 128 128 + 256 = 384
* 512 256 256 + 512 = 768
* 1024 512 512 + 1024 = 1536
*
*/
u32 mp_query_psd(_adapter *adapter, u8 *data)
{
struct mp_priv *pmppriv = &adapter->mppriv;
struct rtw_mp_cal_arg *my_psd_arg = NULL;
u32 i, psd_pts = 0, psd_start = 0, psd_stop = 0;
u32 fft = 0, avg = 0, iq_path = 0;
u32 psd_data = 0;
my_psd_arg = _rtw_malloc(sizeof(struct rtw_mp_cal_arg));
if (my_psd_arg)
_rtw_memset((void *)my_psd_arg, 0, sizeof(struct rtw_mp_cal_arg));
else {
RTW_ERR("%s() psd_arg malloc fail !\n", __func__);
return 0;
}
if (sscanf(data, "fft=%d,avg=%d,iq=%d", &fft, &avg, &iq_path) == 3) {
my_psd_arg->path = pmppriv->antenna_trx;
my_psd_arg->iq_path = iq_path;
my_psd_arg->avg = avg;
my_psd_arg->fft = fft;
RTW_INFO("%s: PSD RF_Path:%d fft=%d,avg=%d,iq_path=%d !\n",
__func__, pmppriv->antenna_trx, fft, avg, iq_path);
if (rtw_mp_phl_psd_cmd(adapter, my_psd_arg, RTW_MP_CAL_CMD_PSD_INIT))
RTW_INFO("PSD_INIT CMD OK!\n");
else
RTW_INFO("PSD_INIT CMD FAIL!\n");
} else if (strncmp(data, "restore", 7) == 0) {
my_psd_arg->path = pmppriv->antenna_trx;
if (rtw_mp_phl_psd_cmd(adapter, my_psd_arg, RTW_MP_CAL_CMD_PSD_RESTORE))
RTW_INFO("PSD_RESTORE CMD OK!\n");
else
RTW_INFO("PSD_RESTORE CMD FAIL!\n");
} else {
if (sscanf(data, "pts=%d,start=%d,stop=%d",
&psd_pts, &psd_start, &psd_stop) == 3) {
my_psd_arg->upoint = psd_pts;
my_psd_arg->start_point = psd_start;
my_psd_arg->stop_point = psd_stop;
} else {
my_psd_arg->upoint = 1280;
my_psd_arg->start_point = 640;
my_psd_arg->stop_point = 960;
RTW_INFO("Default PSD setting!\n");
}
if (rtw_mp_phl_psd_cmd(adapter, my_psd_arg, RTW_MP_CAL_CMD_PSD_QUERY))
RTW_INFO("PSD_QUERY CMD OK!\n");
else
RTW_INFO("PSD_QUERY CMD FAIL!\n");
data[0] = '\0';
i = 0;
while (i < 320) {
sprintf(data, "%s%x ", data, (my_psd_arg->outbuf[i]));
i++;
}
}
if (my_psd_arg)
_rtw_mfree(my_psd_arg, sizeof(struct rtw_mp_cal_arg));
return strlen(data) + 1;
}
u8
mpt_to_mgnt_rate(
u32 MptRateIdx
)
{
/* Mapped to MGN_XXX defined in MgntGen.h */
switch (MptRateIdx) {
/* CCK rate. */
case MPT_RATE_1M:
return MGN_1M;
case MPT_RATE_2M:
return MGN_2M;
case MPT_RATE_55M:
return MGN_5_5M;
case MPT_RATE_11M:
return MGN_11M;
/* OFDM rate. */
case MPT_RATE_6M:
return MGN_6M;
case MPT_RATE_9M:
return MGN_9M;
case MPT_RATE_12M:
return MGN_12M;
case MPT_RATE_18M:
return MGN_18M;
case MPT_RATE_24M:
return MGN_24M;
case MPT_RATE_36M:
return MGN_36M;
case MPT_RATE_48M:
return MGN_48M;
case MPT_RATE_54M:
return MGN_54M;
/* HT rate. */
case MPT_RATE_MCS0:
return MGN_MCS0;
case MPT_RATE_MCS1:
return MGN_MCS1;
case MPT_RATE_MCS2:
return MGN_MCS2;
case MPT_RATE_MCS3:
return MGN_MCS3;
case MPT_RATE_MCS4:
return MGN_MCS4;
case MPT_RATE_MCS5:
return MGN_MCS5;
case MPT_RATE_MCS6:
return MGN_MCS6;
case MPT_RATE_MCS7:
return MGN_MCS7;
case MPT_RATE_MCS8:
return MGN_MCS8;
case MPT_RATE_MCS9:
return MGN_MCS9;
case MPT_RATE_MCS10:
return MGN_MCS10;
case MPT_RATE_MCS11:
return MGN_MCS11;
case MPT_RATE_MCS12:
return MGN_MCS12;
case MPT_RATE_MCS13:
return MGN_MCS13;
case MPT_RATE_MCS14:
return MGN_MCS14;
case MPT_RATE_MCS15:
return MGN_MCS15;
case MPT_RATE_MCS16:
return MGN_MCS16;
case MPT_RATE_MCS17:
return MGN_MCS17;
case MPT_RATE_MCS18:
return MGN_MCS18;
case MPT_RATE_MCS19:
return MGN_MCS19;
case MPT_RATE_MCS20:
return MGN_MCS20;
case MPT_RATE_MCS21:
return MGN_MCS21;
case MPT_RATE_MCS22:
return MGN_MCS22;
case MPT_RATE_MCS23:
return MGN_MCS23;
case MPT_RATE_MCS24:
return MGN_MCS24;
case MPT_RATE_MCS25:
return MGN_MCS25;
case MPT_RATE_MCS26:
return MGN_MCS26;
case MPT_RATE_MCS27:
return MGN_MCS27;
case MPT_RATE_MCS28:
return MGN_MCS28;
case MPT_RATE_MCS29:
return MGN_MCS29;
case MPT_RATE_MCS30:
return MGN_MCS30;
case MPT_RATE_MCS31:
return MGN_MCS31;
/* VHT rate. */
case MPT_RATE_VHT1SS_MCS0:
return MGN_VHT1SS_MCS0;
case MPT_RATE_VHT1SS_MCS1:
return MGN_VHT1SS_MCS1;
case MPT_RATE_VHT1SS_MCS2:
return MGN_VHT1SS_MCS2;
case MPT_RATE_VHT1SS_MCS3:
return MGN_VHT1SS_MCS3;
case MPT_RATE_VHT1SS_MCS4:
return MGN_VHT1SS_MCS4;
case MPT_RATE_VHT1SS_MCS5:
return MGN_VHT1SS_MCS5;
case MPT_RATE_VHT1SS_MCS6:
return MGN_VHT1SS_MCS6;
case MPT_RATE_VHT1SS_MCS7:
return MGN_VHT1SS_MCS7;
case MPT_RATE_VHT1SS_MCS8:
return MGN_VHT1SS_MCS8;
case MPT_RATE_VHT1SS_MCS9:
return MGN_VHT1SS_MCS9;
case MPT_RATE_VHT2SS_MCS0:
return MGN_VHT2SS_MCS0;
case MPT_RATE_VHT2SS_MCS1:
return MGN_VHT2SS_MCS1;
case MPT_RATE_VHT2SS_MCS2:
return MGN_VHT2SS_MCS2;
case MPT_RATE_VHT2SS_MCS3:
return MGN_VHT2SS_MCS3;
case MPT_RATE_VHT2SS_MCS4:
return MGN_VHT2SS_MCS4;
case MPT_RATE_VHT2SS_MCS5:
return MGN_VHT2SS_MCS5;
case MPT_RATE_VHT2SS_MCS6:
return MGN_VHT2SS_MCS6;
case MPT_RATE_VHT2SS_MCS7:
return MGN_VHT2SS_MCS7;
case MPT_RATE_VHT2SS_MCS8:
return MGN_VHT2SS_MCS8;
case MPT_RATE_VHT2SS_MCS9:
return MGN_VHT2SS_MCS9;
case MPT_RATE_VHT3SS_MCS0:
return MGN_VHT3SS_MCS0;
case MPT_RATE_VHT3SS_MCS1:
return MGN_VHT3SS_MCS1;
case MPT_RATE_VHT3SS_MCS2:
return MGN_VHT3SS_MCS2;
case MPT_RATE_VHT3SS_MCS3:
return MGN_VHT3SS_MCS3;
case MPT_RATE_VHT3SS_MCS4:
return MGN_VHT3SS_MCS4;
case MPT_RATE_VHT3SS_MCS5:
return MGN_VHT3SS_MCS5;
case MPT_RATE_VHT3SS_MCS6:
return MGN_VHT3SS_MCS6;
case MPT_RATE_VHT3SS_MCS7:
return MGN_VHT3SS_MCS7;
case MPT_RATE_VHT3SS_MCS8:
return MGN_VHT3SS_MCS8;
case MPT_RATE_VHT3SS_MCS9:
return MGN_VHT3SS_MCS9;
case MPT_RATE_VHT4SS_MCS0:
return MGN_VHT4SS_MCS0;
case MPT_RATE_VHT4SS_MCS1:
return MGN_VHT4SS_MCS1;
case MPT_RATE_VHT4SS_MCS2:
return MGN_VHT4SS_MCS2;
case MPT_RATE_VHT4SS_MCS3:
return MGN_VHT4SS_MCS3;
case MPT_RATE_VHT4SS_MCS4:
return MGN_VHT4SS_MCS4;
case MPT_RATE_VHT4SS_MCS5:
return MGN_VHT4SS_MCS5;
case MPT_RATE_VHT4SS_MCS6:
return MGN_VHT4SS_MCS6;
case MPT_RATE_VHT4SS_MCS7:
return MGN_VHT4SS_MCS7;
case MPT_RATE_VHT4SS_MCS8:
return MGN_VHT4SS_MCS8;
case MPT_RATE_VHT4SS_MCS9:
return MGN_VHT4SS_MCS9;
case MPT_RATE_LAST: /* fully automatiMGN_VHT2SS_MCS1; */
default:
RTW_INFO("<===mpt_to_mgnt_rate(), Invalid Rate: %d!!\n", MptRateIdx);
return 0x0;
}
}
u8 rtw_mp_hwrate2mptrate(u8 rate)
{
u8 ret_rate = MGN_1M;
switch (rate) {
case DESC_RATE1M:
ret_rate = MPT_RATE_1M;
break;
case DESC_RATE2M:
ret_rate = MPT_RATE_2M;
break;
case DESC_RATE5_5M:
ret_rate = MPT_RATE_55M;
break;
case DESC_RATE11M:
ret_rate = MPT_RATE_11M;
break;
case DESC_RATE6M:
ret_rate = MPT_RATE_6M;
break;
case DESC_RATE9M:
ret_rate = MPT_RATE_9M;
break;
case DESC_RATE12M:
ret_rate = MPT_RATE_12M;
break;
case DESC_RATE18M:
ret_rate = MPT_RATE_18M;
break;
case DESC_RATE24M:
ret_rate = MPT_RATE_24M;
break;
case DESC_RATE36M:
ret_rate = MPT_RATE_36M;
break;
case DESC_RATE48M:
ret_rate = MPT_RATE_48M;
break;
case DESC_RATE54M:
ret_rate = MPT_RATE_54M;
break;
case DESC_RATEMCS0:
ret_rate = MPT_RATE_MCS0;
break;
case DESC_RATEMCS1:
ret_rate = MPT_RATE_MCS1;
break;
case DESC_RATEMCS2:
ret_rate = MPT_RATE_MCS2;
break;
case DESC_RATEMCS3:
ret_rate = MPT_RATE_MCS3;
break;
case DESC_RATEMCS4:
ret_rate = MPT_RATE_MCS4;
break;
case DESC_RATEMCS5:
ret_rate = MPT_RATE_MCS5;
break;
case DESC_RATEMCS6:
ret_rate = MPT_RATE_MCS6;
break;
case DESC_RATEMCS7:
ret_rate = MPT_RATE_MCS7;
break;
case DESC_RATEMCS8:
ret_rate = MPT_RATE_MCS8;
break;
case DESC_RATEMCS9:
ret_rate = MPT_RATE_MCS9;
break;
case DESC_RATEMCS10:
ret_rate = MPT_RATE_MCS10;
break;
case DESC_RATEMCS11:
ret_rate = MPT_RATE_MCS11;
break;
case DESC_RATEMCS12:
ret_rate = MPT_RATE_MCS12;
break;
case DESC_RATEMCS13:
ret_rate = MPT_RATE_MCS13;
break;
case DESC_RATEMCS14:
ret_rate = MPT_RATE_MCS14;
break;
case DESC_RATEMCS15:
ret_rate = MPT_RATE_MCS15;
break;
case DESC_RATEMCS16:
ret_rate = MPT_RATE_MCS16;
break;
case DESC_RATEMCS17:
ret_rate = MPT_RATE_MCS17;
break;
case DESC_RATEMCS18:
ret_rate = MPT_RATE_MCS18;
break;
case DESC_RATEMCS19:
ret_rate = MPT_RATE_MCS19;
break;
case DESC_RATEMCS20:
ret_rate = MPT_RATE_MCS20;
break;
case DESC_RATEMCS21:
ret_rate = MPT_RATE_MCS21;
break;
case DESC_RATEMCS22:
ret_rate = MPT_RATE_MCS22;
break;
case DESC_RATEMCS23:
ret_rate = MPT_RATE_MCS23;
break;
case DESC_RATEMCS24:
ret_rate = MPT_RATE_MCS24;
break;
case DESC_RATEMCS25:
ret_rate = MPT_RATE_MCS25;
break;
case DESC_RATEMCS26:
ret_rate = MPT_RATE_MCS26;
break;
case DESC_RATEMCS27:
ret_rate = MPT_RATE_MCS27;
break;
case DESC_RATEMCS28:
ret_rate = MPT_RATE_MCS28;
break;
case DESC_RATEMCS29:
ret_rate = MPT_RATE_MCS29;
break;
case DESC_RATEMCS30:
ret_rate = MPT_RATE_MCS30;
break;
case DESC_RATEMCS31:
ret_rate = MPT_RATE_MCS31;
break;
case DESC_RATEVHTSS1MCS0:
ret_rate = MPT_RATE_VHT1SS_MCS0;
break;
case DESC_RATEVHTSS1MCS1:
ret_rate = MPT_RATE_VHT1SS_MCS1;
break;
case DESC_RATEVHTSS1MCS2:
ret_rate = MPT_RATE_VHT1SS_MCS2;
break;
case DESC_RATEVHTSS1MCS3:
ret_rate = MPT_RATE_VHT1SS_MCS3;
break;
case DESC_RATEVHTSS1MCS4:
ret_rate = MPT_RATE_VHT1SS_MCS4;
break;
case DESC_RATEVHTSS1MCS5:
ret_rate = MPT_RATE_VHT1SS_MCS5;
break;
case DESC_RATEVHTSS1MCS6:
ret_rate = MPT_RATE_VHT1SS_MCS6;
break;
case DESC_RATEVHTSS1MCS7:
ret_rate = MPT_RATE_VHT1SS_MCS7;
break;
case DESC_RATEVHTSS1MCS8:
ret_rate = MPT_RATE_VHT1SS_MCS8;
break;
case DESC_RATEVHTSS1MCS9:
ret_rate = MPT_RATE_VHT1SS_MCS9;
break;
case DESC_RATEVHTSS2MCS0:
ret_rate = MPT_RATE_VHT2SS_MCS0;
break;
case DESC_RATEVHTSS2MCS1:
ret_rate = MPT_RATE_VHT2SS_MCS1;
break;
case DESC_RATEVHTSS2MCS2:
ret_rate = MPT_RATE_VHT2SS_MCS2;
break;
case DESC_RATEVHTSS2MCS3:
ret_rate = MPT_RATE_VHT2SS_MCS3;
break;
case DESC_RATEVHTSS2MCS4:
ret_rate = MPT_RATE_VHT2SS_MCS4;
break;
case DESC_RATEVHTSS2MCS5:
ret_rate = MPT_RATE_VHT2SS_MCS5;
break;
case DESC_RATEVHTSS2MCS6:
ret_rate = MPT_RATE_VHT2SS_MCS6;
break;
case DESC_RATEVHTSS2MCS7:
ret_rate = MPT_RATE_VHT2SS_MCS7;
break;
case DESC_RATEVHTSS2MCS8:
ret_rate = MPT_RATE_VHT2SS_MCS8;
break;
case DESC_RATEVHTSS2MCS9:
ret_rate = MPT_RATE_VHT2SS_MCS9;
break;
case DESC_RATEVHTSS3MCS0:
ret_rate = MPT_RATE_VHT3SS_MCS0;
break;
case DESC_RATEVHTSS3MCS1:
ret_rate = MPT_RATE_VHT3SS_MCS1;
break;
case DESC_RATEVHTSS3MCS2:
ret_rate = MPT_RATE_VHT3SS_MCS2;
break;
case DESC_RATEVHTSS3MCS3:
ret_rate = MPT_RATE_VHT3SS_MCS3;
break;
case DESC_RATEVHTSS3MCS4:
ret_rate = MPT_RATE_VHT3SS_MCS4;
break;
case DESC_RATEVHTSS3MCS5:
ret_rate = MPT_RATE_VHT3SS_MCS5;
break;
case DESC_RATEVHTSS3MCS6:
ret_rate = MPT_RATE_VHT3SS_MCS6;
break;
case DESC_RATEVHTSS3MCS7:
ret_rate = MPT_RATE_VHT3SS_MCS7;
break;
case DESC_RATEVHTSS3MCS8:
ret_rate = MPT_RATE_VHT3SS_MCS8;
break;
case DESC_RATEVHTSS3MCS9:
ret_rate = MPT_RATE_VHT3SS_MCS9;
break;
case DESC_RATEVHTSS4MCS0:
ret_rate = MPT_RATE_VHT4SS_MCS0;
break;
case DESC_RATEVHTSS4MCS1:
ret_rate = MPT_RATE_VHT4SS_MCS1;
break;
case DESC_RATEVHTSS4MCS2:
ret_rate = MPT_RATE_VHT4SS_MCS2;
break;
case DESC_RATEVHTSS4MCS3:
ret_rate = MPT_RATE_VHT4SS_MCS3;
break;
case DESC_RATEVHTSS4MCS4:
ret_rate = MPT_RATE_VHT4SS_MCS4;
break;
case DESC_RATEVHTSS4MCS5:
ret_rate = MPT_RATE_VHT4SS_MCS5;
break;
case DESC_RATEVHTSS4MCS6:
ret_rate = MPT_RATE_VHT4SS_MCS6;
break;
case DESC_RATEVHTSS4MCS7:
ret_rate = MPT_RATE_VHT4SS_MCS7;
break;
case DESC_RATEVHTSS4MCS8:
ret_rate = MPT_RATE_VHT4SS_MCS8;
break;
case DESC_RATEVHTSS4MCS9:
ret_rate = MPT_RATE_VHT4SS_MCS9;
break;
default:
RTW_INFO("hwrate_to_mrate(): Non supported Rate [%x]!!!\n", rate);
break;
}
return ret_rate;
}
static u16 srate2herate(u8 *str)
{
RTW_INFO("%s(): %s!!!\n", __func__, str);
if (!strcmp(str, "1M")) return HRATE_CCK1;
else if (!strcmp(str, "2M")) return HRATE_CCK2;
else if (!strcmp(str, "5.5M")) return HRATE_CCK5_5;
else if (!strcmp(str, "11M")) return HRATE_CCK11;
else if (!strcmp(str, "6M")) return HRATE_OFDM6;
else if (!strcmp(str, "9M")) return HRATE_OFDM9;
else if (!strcmp(str, "12M")) return HRATE_OFDM12;
else if (!strcmp(str, "18M")) return HRATE_OFDM18;
else if (!strcmp(str, "24M")) return HRATE_OFDM24;
else if (!strcmp(str, "36M")) return HRATE_OFDM36;
else if (!strcmp(str, "48M")) return HRATE_OFDM48;
else if (!strcmp(str, "54M")) return HRATE_OFDM54;
else if (!strcmp(str, "HTMCS0")) return HRATE_MCS0;
else if (!strcmp(str, "HTMCS1")) return HRATE_MCS1;
else if (!strcmp(str, "HTMCS2")) return HRATE_MCS2;
else if (!strcmp(str, "HTMCS3")) return HRATE_MCS3;
else if (!strcmp(str, "HTMCS4")) return HRATE_MCS4;
else if (!strcmp(str, "HTMCS5")) return HRATE_MCS5;
else if (!strcmp(str, "HTMCS6")) return HRATE_MCS6;
else if (!strcmp(str, "HTMCS7")) return HRATE_MCS7;
else if (!strcmp(str, "HTMCS8")) return HRATE_MCS8;
else if (!strcmp(str, "HTMCS9")) return HRATE_MCS9;
else if (!strcmp(str, "HTMCS10")) return HRATE_MCS10;
else if (!strcmp(str, "HTMCS11")) return HRATE_MCS11;
else if (!strcmp(str, "HTMCS12")) return HRATE_MCS12;
else if (!strcmp(str, "HTMCS13")) return HRATE_MCS13;
else if (!strcmp(str, "HTMCS14")) return HRATE_MCS14;
else if (!strcmp(str, "HTMCS15")) return HRATE_MCS15;
else if (!strcmp(str, "HTMCS16")) return HRATE_MCS16;
else if (!strcmp(str, "HTMCS17")) return HRATE_MCS17;
else if (!strcmp(str, "HTMCS18")) return HRATE_MCS18;
else if (!strcmp(str, "HTMCS19")) return HRATE_MCS19;
else if (!strcmp(str, "HTMCS20")) return HRATE_MCS20;
else if (!strcmp(str, "HTMCS21")) return HRATE_MCS21;
else if (!strcmp(str, "HTMCS22")) return HRATE_MCS22;
else if (!strcmp(str, "HTMCS23")) return HRATE_MCS23;
else if (!strcmp(str, "HTMCS24")) return HRATE_MCS24;
else if (!strcmp(str, "HTMCS25")) return HRATE_MCS25;
else if (!strcmp(str, "HTMCS26")) return HRATE_MCS26;
else if (!strcmp(str, "HTMCS27")) return HRATE_MCS27;
else if (!strcmp(str, "HTMCS28")) return HRATE_MCS28;
else if (!strcmp(str, "HTMCS29")) return HRATE_MCS29;
else if (!strcmp(str, "HTMCS30")) return HRATE_MCS30;
else if (!strcmp(str, "HTMCS31")) return HRATE_MCS31;
else if (!strcmp(str, "VHT1MCS0")) return HRATE_VHT_NSS1_MCS0;
else if (!strcmp(str, "VHT1MCS1")) return HRATE_VHT_NSS1_MCS1;
else if (!strcmp(str, "VHT1MCS2")) return HRATE_VHT_NSS1_MCS2;
else if (!strcmp(str, "VHT1MCS3")) return HRATE_VHT_NSS1_MCS3;
else if (!strcmp(str, "VHT1MCS4")) return HRATE_VHT_NSS1_MCS4;
else if (!strcmp(str, "VHT1MCS5")) return HRATE_VHT_NSS1_MCS5;
else if (!strcmp(str, "VHT1MCS6")) return HRATE_VHT_NSS1_MCS6;
else if (!strcmp(str, "VHT1MCS7")) return HRATE_VHT_NSS1_MCS7;
else if (!strcmp(str, "VHT1MCS8")) return HRATE_VHT_NSS1_MCS8;
else if (!strcmp(str, "VHT1MCS9")) return HRATE_VHT_NSS1_MCS9;
else if (!strcmp(str, "VHT2MCS0")) return HRATE_VHT_NSS2_MCS0;
else if (!strcmp(str, "VHT2MCS1")) return HRATE_VHT_NSS2_MCS1;
else if (!strcmp(str, "VHT2MCS2")) return HRATE_VHT_NSS2_MCS2;
else if (!strcmp(str, "VHT2MCS3")) return HRATE_VHT_NSS2_MCS3;
else if (!strcmp(str, "VHT2MCS4")) return HRATE_VHT_NSS2_MCS4;
else if (!strcmp(str, "VHT2MCS5")) return HRATE_VHT_NSS2_MCS5;
else if (!strcmp(str, "VHT2MCS6")) return HRATE_VHT_NSS2_MCS6;
else if (!strcmp(str, "VHT2MCS7")) return HRATE_VHT_NSS2_MCS7;
else if (!strcmp(str, "VHT2MCS8")) return HRATE_VHT_NSS2_MCS8;
else if (!strcmp(str, "VHT2MCS9")) return HRATE_VHT_NSS2_MCS9;
else if (!strcmp(str, "VHT3MCS0")) return HRATE_VHT_NSS3_MCS0;
else if (!strcmp(str, "VHT3MCS1")) return HRATE_VHT_NSS3_MCS1;
else if (!strcmp(str, "VHT3MCS2")) return HRATE_VHT_NSS3_MCS2;
else if (!strcmp(str, "VHT3MCS3")) return HRATE_VHT_NSS3_MCS3;
else if (!strcmp(str, "VHT3MCS4")) return HRATE_VHT_NSS3_MCS4;
else if (!strcmp(str, "VHT3MCS5")) return HRATE_VHT_NSS3_MCS5;
else if (!strcmp(str, "VHT3MCS6")) return HRATE_VHT_NSS3_MCS6;
else if (!strcmp(str, "VHT3MCS7")) return HRATE_VHT_NSS3_MCS7;
else if (!strcmp(str, "VHT3MCS8")) return HRATE_VHT_NSS3_MCS8;
else if (!strcmp(str, "VHT3MCS9")) return HRATE_VHT_NSS3_MCS9;
else if (!strcmp(str, "VHT4MCS0")) return HRATE_VHT_NSS4_MCS0;
else if (!strcmp(str, "VHT4MCS1")) return HRATE_VHT_NSS4_MCS1;
else if (!strcmp(str, "VHT4MCS2")) return HRATE_VHT_NSS4_MCS2;
else if (!strcmp(str, "VHT4MCS3")) return HRATE_VHT_NSS4_MCS3;
else if (!strcmp(str, "VHT4MCS4")) return HRATE_VHT_NSS4_MCS4;
else if (!strcmp(str, "VHT4MCS5")) return HRATE_VHT_NSS4_MCS5;
else if (!strcmp(str, "VHT4MCS6")) return HRATE_VHT_NSS4_MCS6;
else if (!strcmp(str, "VHT4MCS7")) return HRATE_VHT_NSS4_MCS7;
else if (!strcmp(str, "VHT4MCS8")) return HRATE_VHT_NSS4_MCS8;
else if (!strcmp(str, "VHT4MCS9")) return HRATE_VHT_NSS4_MCS9;
else if (!strcmp(str, "HE1MCS0")) return HRATE_HE_NSS1_MCS0;
else if (!strcmp(str, "HE1MCS1")) return HRATE_HE_NSS1_MCS1;
else if (!strcmp(str, "HE1MCS2")) return HRATE_HE_NSS1_MCS2;
else if (!strcmp(str, "HE1MCS3")) return HRATE_HE_NSS1_MCS3;
else if (!strcmp(str, "HE1MCS4")) return HRATE_HE_NSS1_MCS4;
else if (!strcmp(str, "HE1MCS5")) return HRATE_HE_NSS1_MCS5;
else if (!strcmp(str, "HE1MCS6")) return HRATE_HE_NSS1_MCS6;
else if (!strcmp(str, "HE1MCS7")) return HRATE_HE_NSS1_MCS7;
else if (!strcmp(str, "HE1MCS8")) return HRATE_HE_NSS1_MCS8;
else if (!strcmp(str, "HE1MCS9")) return HRATE_HE_NSS1_MCS9;
else if (!strcmp(str, "HE1MCS10")) return HRATE_HE_NSS1_MCS10;
else if (!strcmp(str, "HE1MCS11")) return HRATE_HE_NSS1_MCS11;
else if (!strcmp(str, "HE2MCS0")) return HRATE_HE_NSS2_MCS0;
else if (!strcmp(str, "HE2MCS1")) return HRATE_HE_NSS2_MCS1;
else if (!strcmp(str, "HE2MCS2")) return HRATE_HE_NSS2_MCS2;
else if (!strcmp(str, "HE2MCS3")) return HRATE_HE_NSS2_MCS3;
else if (!strcmp(str, "HE2MCS4")) return HRATE_HE_NSS2_MCS4;
else if (!strcmp(str, "HE2MCS5")) return HRATE_HE_NSS2_MCS5;
else if (!strcmp(str, "HE2MCS6")) return HRATE_HE_NSS2_MCS6;
else if (!strcmp(str, "HE2MCS7")) return HRATE_HE_NSS2_MCS7;
else if (!strcmp(str, "HE2MCS8")) return HRATE_HE_NSS2_MCS8;
else if (!strcmp(str, "HE2MCS9")) return HRATE_HE_NSS2_MCS9;
else if (!strcmp(str, "HE2MCS10")) return HRATE_HE_NSS2_MCS10;
else if (!strcmp(str, "HE2MCS11")) return HRATE_HE_NSS2_MCS11;
else if (!strcmp(str, "HE3MCS0")) return HRATE_HE_NSS3_MCS0;
else if (!strcmp(str, "HE3MCS1")) return HRATE_HE_NSS3_MCS1;
else if (!strcmp(str, "HE3MCS2")) return HRATE_HE_NSS3_MCS2;
else if (!strcmp(str, "HE3MCS3")) return HRATE_HE_NSS3_MCS3;
else if (!strcmp(str, "HE3MCS4")) return HRATE_HE_NSS3_MCS4;
else if (!strcmp(str, "HE3MCS5")) return HRATE_HE_NSS3_MCS5;
else if (!strcmp(str, "HE3MCS6")) return HRATE_HE_NSS3_MCS6;
else if (!strcmp(str, "HE3MCS7")) return HRATE_HE_NSS3_MCS7;
else if (!strcmp(str, "HE3MCS8")) return HRATE_HE_NSS3_MCS8;
else if (!strcmp(str, "HE3MCS9")) return HRATE_HE_NSS3_MCS9;
else if (!strcmp(str, "HE3MCS10")) return HRATE_HE_NSS3_MCS10;
else if (!strcmp(str, "HE3MCS11")) return HRATE_HE_NSS3_MCS11;
else if (!strcmp(str, "HE4MCS0")) return HRATE_HE_NSS4_MCS0;
else if (!strcmp(str, "HE4MCS1")) return HRATE_HE_NSS4_MCS1;
else if (!strcmp(str, "HE4MCS2")) return HRATE_HE_NSS4_MCS2;
else if (!strcmp(str, "HE4MCS3")) return HRATE_HE_NSS4_MCS3;
else if (!strcmp(str, "HE4MCS4")) return HRATE_HE_NSS4_MCS4;
else if (!strcmp(str, "HE4MCS5")) return HRATE_HE_NSS4_MCS5;
else if (!strcmp(str, "HE4MCS6")) return HRATE_HE_NSS4_MCS6;
else if (!strcmp(str, "HE4MCS7")) return HRATE_HE_NSS4_MCS7;
else if (!strcmp(str, "HE4MCS8")) return HRATE_HE_NSS4_MCS8;
else if (!strcmp(str, "HE4MCS9")) return HRATE_HE_NSS4_MCS9;
else if (!strcmp(str, "HE4MCS10")) return HRATE_HE_NSS4_MCS10;
else if (!strcmp(str, "HE4MCS11")) return HRATE_HE_NSS4_MCS11;
return 0;
}
#define MP_RATE_STR_NUM 132
#define MP_RATE_STR_LEN 12
const char rtw_mp_rateidx_arrdef[MP_RATE_STR_NUM][MP_RATE_STR_LEN] = {
"1M", "2M", "5.5M", "11M", "6M", "9M", "12M", "18M", "24M", "36M", "48M", "54M",
"HTMCS0", "HTMCS1", "HTMCS2", "HTMCS3", "HTMCS4", "HTMCS5", "HTMCS6", "HTMCS7",
"HTMCS8", "HTMCS9", "HTMCS10", "HTMCS11", "HTMCS12", "HTMCS13", "HTMCS14", "HTMCS15",
"HTMCS16", "HTMCS17", "HTMCS18", "HTMCS19", "HTMCS20", "HTMCS21", "HTMCS22", "HTMCS23",
"HTMCS24", "HTMCS25", "HTMCS26", "HTMCS27", "HTMCS28", "HTMCS29", "HTMCS30", "HTMCS31",
"VHT1MCS0", "VHT1MCS1", "VHT1MCS2", "VHT1MCS3", "VHT1MCS4",
"VHT1MCS5", "VHT1MCS6", "VHT1MCS7", "VHT1MCS8", "VHT1MCS9",
"VHT2MCS0", "VHT2MCS1", "VHT2MCS2", "VHT2MCS3", "VHT2MCS4",
"VHT2MCS5", "VHT2MCS6", "VHT2MCS7", "VHT2MCS8", "VHT2MCS9",
"VHT3MCS0", "VHT3MCS1", "VHT3MCS2", "VHT3MCS3", "VHT3MCS4",
"VHT3MCS5", "VHT3MCS6", "VHT3MCS7", "VHT3MCS8", "VHT3MCS9",
"VHT4MCS0", "VHT4MCS1", "VHT4MCS2", "VHT4MCS3", "VHT4MCS4",
"VHT4MCS5", "VHT4MCS6", "VHT4MCS7", "VHT4MCS8", "VHT4MCS9",
"HE1MCS0", "HE1MCS1", "HE1MCS2", "HE1MCS3", "HE1MCS4", "HE1MCS5",
"HE1MCS6", "HE1MCS7", "HE1MCS8", "HE1MCS9", "HE1MCS10", "HE1MCS11",
"HE2MCS0", "HE2MCS1", "HE2MCS2", "HE2MCS3", "HE2MCS4", "HE2MCS5",
"HE2MCS6", "HE2MCS7", "HE2MCS8", "HE2MCS9", "HE2MCS10", "HE2MCS11",
"HE3MCS0", "HE3MCS1", "HE3MCS2", "HE3MCS3", "HE3MCS4", "HE3MCS5",
"HE3MCS6", "HE3MCS7", "HE3MCS8", "HE3MCS9", "HE3MCS10", "HE3MCS11",
"HE4MCS0", "HE4MCS1", "HE4MCS2", "HE4MCS3", "HE4MCS4", "HE4MCS5",
"HE4MCS6", "HE4MCS7", "HE4MCS8", "HE4MCS9", "HE4MCS10", "HE4MCS11"};
u16 rtw_mp_rate_parse(_adapter *adapter, u8 *target_str)
{
struct mp_priv *pmppriv = &adapter->mppriv;
u16 i = 0, mcs_idx_base = 0;
u16 hrateidx = 0;
u8 plcp_nss = 0, ppdu_type = 0;
u8 user_idx = pmppriv->mp_plcp_useridx;
#if 1/*def CONFIG_80211AX_HE*/
hrateidx = srate2herate(target_str);
if (MP_IS_1T_HRATE(hrateidx))
plcp_nss = MP_NSS1;
else if (MP_IS_2T_HRATE(hrateidx))
plcp_nss = MP_NSS2;
else if (MP_IS_3T_HRATE(hrateidx))
plcp_nss = MP_NSS3;
else if (MP_IS_4T_HRATE(hrateidx))
plcp_nss = MP_NSS4;
RTW_INFO("%s , PLCP NSS idx = %d\n", __func__ , plcp_nss);
if (MP_IS_CCK_HRATE(hrateidx))
ppdu_type = RTW_MP_TYPE_CCK;
else if (MP_IS_OFDM_HRATE(hrateidx)) {
ppdu_type = RTW_MP_TYPE_LEGACY;
mcs_idx_base = 4;
} else if (MP_IS_HT_HRATE(hrateidx)) {
ppdu_type = RTW_MP_TYPE_HT_MF;
mcs_idx_base = 12;
} else if (MP_IS_VHT_HRATE(hrateidx)) {
if (plcp_nss == MP_NSS1)
mcs_idx_base = 44;
else if (plcp_nss == MP_NSS2)
mcs_idx_base = 44 + 10;
else if (plcp_nss == MP_NSS3)
mcs_idx_base = 44 + 20;
else if (plcp_nss == MP_NSS4)
mcs_idx_base = 44 + 30;
ppdu_type = RTW_MP_TYPE_VHT;
} else if (MP_IS_HE_HRATE(hrateidx)) {
if (plcp_nss == MP_NSS1)
mcs_idx_base = 84;
else if (plcp_nss == MP_NSS2)
mcs_idx_base = 84 + 12;
else if (plcp_nss == MP_NSS3)
mcs_idx_base = 84 + 24;
else if (plcp_nss == MP_NSS4)
mcs_idx_base = 84+ 36;
ppdu_type = RTW_MP_TYPE_HE_SU;
}
pmppriv->mp_plcp_user[user_idx].plcp_nss = plcp_nss;
pmppriv->rtw_mp_pmact_ppdu_type = ppdu_type;
rtw_update_giltf(adapter);
rtw_mp_update_coding(adapter);
for (i = 0; i <= MP_RATE_STR_NUM; i++) {
if (strcmp(target_str, rtw_mp_rateidx_arrdef[i+ mcs_idx_base]) == 0) {
pmppriv->mp_plcp_user[user_idx].plcp_mcs = i;
RTW_INFO("%s , PLCP MCS = %d\n", __func__ , pmppriv->mp_plcp_user[user_idx].plcp_mcs);
break;
}
}
if (1) {
printk("%s ,please input a Data RATE String as:", __func__);
for (i = 0; i <= MP_RATE_STR_NUM; i++) {
printk("%s ", rtw_mp_rateidx_arrdef[i]);
if (i % 10 == 0)
printk("\n");
}
}
return hrateidx;
#else
for (i = 0; i <= MP_RATE_STR_NUM; i++) {
if (strcmp(targetStr, rtw_mp_rateidx_arrdef[i]) == 0) {
RTW_INFO("%s , index = %d\n", __func__ , i);
return i;
}
}
printk("%s ,please input a Data RATE String as:", __func__);
for (i = 0; i <= MP_RATE_STR_NUM; i++) {
printk("%s ", rtw_mp_rateidx_arrdef[i]);
if (i % 10 == 0)
printk("\n");
}
return _FAIL;
#endif
}
u8 rtw_mp_mode_check(_adapter *adapter)
{
_adapter *primary_adapter = GET_PRIMARY_ADAPTER(adapter);
if (primary_adapter->registrypriv.mp_mode == 1 || primary_adapter->mppriv.bprocess_mp_mode == _TRUE)
return _TRUE;
else
return _FALSE;
}
bool rtw_is_mp_tssitrk_on(_adapter *adapter)
{
_adapter *primary_adapter = GET_PRIMARY_ADAPTER(adapter);
return primary_adapter->mppriv.tssitrk_on;
}
u32 mpt_ProQueryCalTxPower(
_adapter *adapter,
u8 RfPath
)
{
PMPT_CONTEXT pMptCtx = &(adapter->mppriv.mpt_ctx);
#if 0
u32 TxPower = 1;
struct txpwr_idx_comp tic;
u8 mgn_rate = mpt_to_mgnt_rate(pMptCtx->mpt_rate_index);
RATE_SECTION rs = mgn_rate_to_rs(mgn_rate);
TxPower = rtw_hal_get_tx_power_index(adapter, RfPath, rs, mgn_rate
, pHalData->current_channel_bw, pHalData->current_band_type, pHalData->current_channel, &tic);
dump_tx_power_index_inline(RTW_DBGDUMP, RfPath
, pHalData->current_channel_bw, pHalData->current_channel
, mgn_rate, TxPower, &tic);
adapter->mppriv.txpoweridx = (u8)TxPower;
if (RfPath == RF_PATH_A)
pMptCtx->TxPwrLevel[RF_PATH_A] = (u8)TxPower;
else if (RfPath == RF_PATH_B)
pMptCtx->TxPwrLevel[RF_PATH_B] = (u8)TxPower;
else if (RfPath == RF_PATH_C)
pMptCtx->TxPwrLevel[RF_PATH_C] = (u8)TxPower;
else if (RfPath == RF_PATH_D)
pMptCtx->TxPwrLevel[RF_PATH_D] = (u8)TxPower;
hal_mpt_SetTxPower(adapter);
return TxPower;
#endif
return 0;
}
u32 mpt_get_tx_power_finalabs_val(_adapter *padapter, u8 rf_path)
{
PMPT_CONTEXT pMptCtx = &(padapter->mppriv.mpt_ctx);
u8 mgn_rate = mpt_to_mgnt_rate(pMptCtx->mpt_rate_index);
u32 powerdbm = 0;
#ifdef CONFIG_80211AX_HE
struct mp_priv *pmppriv = &padapter->mppriv;
struct rtw_mp_txpwr_arg ptxpwr_arg;
u16 i = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.mp_class = RTW_MP_CLASS_TXPWR;
ptxpwr_arg.cmd = RTW_MP_TXPWR_CMD_READ_PWR_TABLE;
ptxpwr_arg.channel = pmppriv->channel;
ptxpwr_arg.bandwidth = pmppriv->bandwidth;
ptxpwr_arg.rate = pmppriv->rateidx;
ptxpwr_arg.rfpath = pmppriv->antenna_tx;
ptxpwr_arg.beamforming = 0;
ptxpwr_arg.dcm = 0;
ptxpwr_arg.offset = 0;
rtw_mp_set_phl_cmd(padapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
while (i != 100) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(padapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
if (ptxpwr_arg.cmd_ok && ptxpwr_arg.status == RTW_PHL_STATUS_SUCCESS) {
powerdbm = ptxpwr_arg.table_item;
RTW_INFO("%s,SET CMD OK\n", __func__);
break;
} else {
if (i > 100) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__, ptxpwr_arg.status);
break;
}
i++;
}
}
#else
/*
powerdbm = phy_get_tx_power_final_absolute_value(padapter, rf_path, mgn_rate, pHalData->current_channel_bw, pHalData->current_channel);
RTW_INFO("bw=%d, ch=%d, rateid=%d, TSSI Power(dBm):%d\n",
pHalData->current_channel_bw, pHalData->current_channel, mgn_rate ,powerdbm);
*/
#endif
return powerdbm;
}
u8 rtw_mpt_set_power_limit_en(_adapter *padapter, bool en_val)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
u16 i = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.mp_class = RTW_MP_CLASS_TXPWR;
ptxpwr_arg.cmd = RTW_MP_TXPWR_CMD_SET_PWR_LMT_EN;
ptxpwr_arg.pwr_lmt_en = en_val;
rtw_mp_set_phl_cmd(padapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
while (i != 10) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(padapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
if (ptxpwr_arg.cmd_ok && ptxpwr_arg.status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,SET CMD OK\n", __func__);
return ptxpwr_arg.cmd_ok;
} else {
if (i > 10) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__, ptxpwr_arg.status);
break;
}
i++;
}
}
return 0;
}
bool rtw_mpt_get_power_limit_en(_adapter *padapter)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
u16 i = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.mp_class = RTW_MP_CLASS_TXPWR;
ptxpwr_arg.cmd = RTW_MP_TXPWR_CMD_GET_PWR_LMT_EN;
ptxpwr_arg.pwr_lmt_en = _FALSE;
rtw_mp_set_phl_cmd(padapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
while (i != 10) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(padapter, (void*)&ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
if (ptxpwr_arg.cmd_ok && ptxpwr_arg.status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s, CMD OK\n", __func__);
return ptxpwr_arg.pwr_lmt_en;
} else {
if (i > 10) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n",
__func__, ptxpwr_arg.status);
break;
}
i++;
}
}
return ptxpwr_arg.pwr_lmt_en;
}
void rtw_mp_get_phl_cmd(_adapter *padapter, void* buf, u32 buflen)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct phl_info_t *phl_info = (struct phl_info_t *)(dvobj->phl);
struct rtw_mp_test_cmdbuf *cmdbuf = NULL;
if (buflen > RTW_MAX_TEST_CMD_BUF) {
RTW_ERR("%s, buflen %d over CMD BUF Size !\n", __func__, buflen);
return;
}
cmdbuf = _rtw_malloc(sizeof(struct rtw_mp_test_cmdbuf));
if (cmdbuf) {
_rtw_memset((void *)cmdbuf, 0, sizeof(struct rtw_mp_test_cmdbuf));
cmdbuf->type = 0;
cmdbuf->len = buflen;
_rtw_memcpy((void *)cmdbuf->buf, buf, buflen);
rtw_phl_test_submodule_get_rpt(rtw_phl_get_com(phl_info), (void *)cmdbuf, sizeof(struct rtw_mp_test_cmdbuf));
_rtw_memcpy((void *)buf, (void *)cmdbuf->buf, buflen);
}
if (cmdbuf)
_rtw_mfree(cmdbuf, sizeof(struct rtw_mp_test_cmdbuf));
}
void rtw_mp_set_phl_cmd(_adapter *padapter, void* buf, u32 buflen)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct phl_info_t *phl_info = (struct phl_info_t *)(dvobj->phl);
struct rtw_mp_test_cmdbuf *cmdbuf = NULL;
if (buflen > RTW_MAX_TEST_CMD_BUF) {
RTW_ERR("%s, buflen %d over CMD BUF Size !\n", __func__, buflen);
return;
}
cmdbuf = _rtw_malloc(sizeof(struct rtw_mp_test_cmdbuf));
if (cmdbuf) {
_rtw_memset((void *)cmdbuf, 0, sizeof(struct rtw_mp_test_cmdbuf));
cmdbuf->type = 0;
cmdbuf->len = buflen;
_rtw_memcpy((void *)cmdbuf->buf, buf, buflen);
rtw_phl_test_submodule_cmd_process(rtw_phl_get_com(phl_info), (void*)cmdbuf, sizeof(struct rtw_mp_test_cmdbuf));
}
if (cmdbuf)
_rtw_mfree(cmdbuf, sizeof(struct rtw_mp_test_cmdbuf));
}
u8 rtw_mp_phl_txpower(_adapter *padapter, struct rtw_mp_txpwr_arg *ptxpwr_arg, u8 cmdid)
{
struct mp_priv *pmppriv = &padapter->mppriv;
u16 i = 0;
ptxpwr_arg->mp_class = RTW_MP_CLASS_TXPWR;
ptxpwr_arg->cmd = cmdid;
rtw_mp_set_phl_cmd(padapter, (void*)ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
while (i <= 10) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(padapter, (void*)ptxpwr_arg, sizeof(struct rtw_mp_txpwr_arg));
if (ptxpwr_arg->cmd_ok && ptxpwr_arg->status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,SET CMD OK\n", __func__);
break;
} else {
if (i > 10) {
RTW_DBG("%s,GET CMD FAIL !!! status %d\n", __func__, ptxpwr_arg->status);
break;
}
i++;
}
}
return ptxpwr_arg->cmd_ok;
}
bool rtw_mp_phl_config_arg(_adapter *padapter, enum rtw_mp_config_cmdid cmdid)
{
struct mp_priv *pmppriv = &padapter->mppriv;
struct rtw_mp_config_arg pmp_arg;
u16 i = 0;
_rtw_memset((void *)&pmp_arg, 0, sizeof(struct rtw_mp_config_arg));
pmp_arg.mp_class = RTW_MP_CLASS_CONFIG;
pmp_arg.cmd = cmdid;
RTW_INFO("%s, id: %d !!!\n", __func__, cmdid);
switch (cmdid) {
case RTW_MP_CONFIG_CMD_SET_CH_BW:
pmp_arg.channel = pmppriv->channel;
pmp_arg.bandwidth = pmppriv->bandwidth;
pmp_arg.sc_idx = pmppriv->prime_channel_offset;
break;
case RTW_MP_CONFIG_CMD_SET_RATE_IDX:
pmp_arg.rate_idx= pmppriv->rateidx;
break;
case RTW_MP_CONFIG_CMD_SET_RF_TXRX_PATH:
pmp_arg.ant_tx = pmppriv->antenna_trx;
pmp_arg.ant_rx = pmppriv->antenna_trx;
break;
case RTW_MP_CONFIG_CMD_STOP_DUT:
case RTW_MP_CONFIG_CMD_START_DUT:
case RTW_MP_CONFIG_CMD_SET_PHY_INDEX:
pmp_arg.cur_phy = pmppriv->rtw_mp_cur_phy;
break;
case RTW_MP_CONFIG_CMD_SET_RESET_PHY_COUNT:
case RTW_MP_CONFIG_CMD_SET_RESET_MAC_COUNT:
case RTW_MP_CONFIG_CMD_SET_RESET_DRV_COUNT:
pmp_arg.cur_phy = pmppriv->rtw_mp_cur_phy;
break;
case RTW_MP_CONFIG_CMD_SWITCH_BT_PATH:
pmp_arg.btc_mode = pmppriv->btc_path;
break;
default:
RTW_INFO("%s, No CMD case match !!!\n", __func__);
return _FALSE;
}
rtw_mp_set_phl_cmd(padapter, (void*)&pmp_arg, sizeof(struct rtw_mp_config_arg));
while (1) {
rtw_mp_get_phl_cmd(padapter, (void*)&pmp_arg, sizeof(struct rtw_mp_config_arg));
if (pmp_arg.cmd_ok && pmp_arg.status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s, %d GET CMD OK !!!\n", __func__, cmdid);
break;
} else {
i++;
rtw_msleep_os(10);
if (i == 100) {
RTW_INFO("%s, %d GET CMD FAIL !!!\n", __func__, cmdid);
break;
}
}
}
return pmp_arg.cmd_ok;
}
void rtw_mp_phl_rx_physts(_adapter *padapter, struct rtw_mp_rx_arg *rx_arg, bool bstart)
{
struct mp_priv *pmppriv = &padapter->mppriv;
u8 i = 0;
rx_arg->mp_class = RTW_MP_CLASS_RX;
rx_arg->cmd = RTW_MP_RX_CMD_GET_PHYSTS;
rx_arg->enable = bstart;
rx_arg->cmd_ok = _FALSE;
rtw_mp_set_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
while (i != 10) {
rtw_msleep_os(100);
rtw_mp_get_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
if (rx_arg->cmd_ok && rx_arg->status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,GET CMD RX OK\n", __func__);
break;
} else {
if (i > 10) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__,rx_arg->status);
break;
}
i++;
}
}
}
void rtw_mp_phl_rx_rssi(_adapter *padapter, struct rtw_mp_rx_arg *rx_arg)
{
struct mp_priv *pmppriv = &padapter->mppriv;
u8 i = 0;
rx_arg->mp_class = RTW_MP_CLASS_RX;
rx_arg->cmd = RTW_MP_RX_CMD_GET_RSSI;
rx_arg->cmd_ok = _FALSE;
rtw_mp_set_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
while (i != 10) {
rtw_msleep_os(100);
rtw_mp_get_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
if (rx_arg->cmd_ok && rx_arg->status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,Path%d rssi:%d GET CMD RX OK\n", __func__, rx_arg->rf_path, rx_arg->rssi);
break;
} else {
if (i > 10) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__,rx_arg->status);
break;
}
i++;
}
}
}
void rtw_mp_phl_rx_gain_offset(_adapter *padapter, struct rtw_mp_rx_arg *rx_arg, u8 path_num)
{
struct mp_priv *pmppriv = &padapter->mppriv;
u8 all_path_num = path_num;
u8 rf_path = 0;
rx_arg->mp_class = RTW_MP_CLASS_RX;
rx_arg->cmd = RTW_MP_RX_CMD_SET_GAIN_OFFSET;
if (path_num > 1) {
path_num = 0;
all_path_num -= 1;
}
for (rf_path = path_num; rf_path <= all_path_num; rf_path++) {
u16 i = 0;
rx_arg->rf_path = rf_path;
rx_arg->cmd_ok = _FALSE;
rtw_mp_set_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
while (i != 10) {
rtw_msleep_os(100);
rtw_mp_get_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
if (rx_arg->cmd_ok && rx_arg->status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,rf path %d GET CMD RX OK\n", __func__, rx_arg->rf_path);
break;
} else {
if (i > 10) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__,rx_arg->status);
break;
}
i++;
}
}
}
}
void rtw_mp_phl_query_rx(_adapter *padapter, struct rtw_mp_rx_arg *rx_arg ,u8 rx_qurey_type)
{
struct mp_priv *pmppriv = &padapter->mppriv;
u8 rxcmd[2] = {0, 0};
u8 cmd_idx = 0;
rx_arg->mp_class = RTW_MP_CLASS_RX;
rx_arg->rx_ok = 0;
rx_arg->rx_err = 0;
if (rx_qurey_type == 0) {
rxcmd[0] = RTW_MP_RX_CMD_PHY_CRC_OK;
rxcmd[1] = RTW_MP_RX_CMD_PHY_CRC_ERR;
} else if (rx_qurey_type == 1) {
rxcmd[0] = RTW_MP_RX_CMD_MAC_CRC_OK;
rxcmd[1] = RTW_MP_RX_CMD_MAC_CRC_ERR;
} else if (rx_qurey_type == 2) {
rxcmd[0] = RTW_MP_RX_CMD_DRV_CRC_OK;
rxcmd[1] = RTW_MP_RX_CMD_DRV_CRC_ERR;
}
for (cmd_idx = 0; cmd_idx < 2 ; cmd_idx++) {
u16 i = 0;
rx_arg->cmd = rxcmd[cmd_idx];
rx_arg->cmd_ok = _FALSE;
rtw_mp_set_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
while (i != 10) {
rtw_msleep_os(100);
rtw_mp_get_phl_cmd(padapter, (void*)rx_arg, sizeof(struct rtw_mp_rx_arg));
if (rx_arg->cmd_ok && rx_arg->status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,GET CMD RX OK:%d ,RX ERR:%d\n", __func__, rx_arg->rx_ok, rx_arg->rx_err);
break;
} else {
if (i > 10) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__,rx_arg->status);
break;
}
i++;
}
}
}
}
void rtw_mp_set_crystal_cap(_adapter *padapter, u32 xcapvalue)
{
struct rtw_mp_reg_arg cfg_arg;
u8 sc_xo_idx = 1;
u8 i = 0;
cfg_arg.mp_class = RTW_MP_CLASS_REG;
cfg_arg.cmd = RTW_MP_REG_CMD_SET_XCAP;
for (i <=0 ; i <= sc_xo_idx; i++) {
cfg_arg.cmd_ok = 0;
cfg_arg.sc_xo = i;
cfg_arg.io_value = xcapvalue;
rtw_mp_set_phl_cmd(padapter, (void*)&cfg_arg, sizeof(struct rtw_mp_reg_arg));
while (i != 10) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(padapter, (void*)&cfg_arg, sizeof(struct rtw_mp_reg_arg));
if (cfg_arg.cmd_ok && cfg_arg.status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,SET CMD TX OK\n", __func__);
break;
} else {
if (i > 10) {
RTW_INFO("%s,GET CMD FAIL !!! status %d\n", __func__, cfg_arg.status);
break;
}
i++;
}
}
}
}
u8 rtw_mp_phl_calibration(_adapter *padapter, struct rtw_mp_cal_arg *pcal_arg, u8 cmdid)
{
struct mp_priv *pmppriv = &padapter->mppriv;
u16 i = 0;
u32 cmd_size = sizeof(struct rtw_mp_cal_arg);
pcal_arg->mp_class = RTW_MP_CLASS_CAL;
pcal_arg->cmd = cmdid;
rtw_mp_set_phl_cmd(padapter, (void*)pcal_arg, cmd_size);
while (i <= 10) {
rtw_msleep_os(10);
rtw_mp_get_phl_cmd(padapter, (void*)pcal_arg, cmd_size);
if (pcal_arg->cmd_ok && pcal_arg->status == RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s,SET CMD OK\n", __func__);
break;
} else {
if (i > 10) {
RTW_DBG("%s,GET CMD FAIL !!! status %d\n", __func__, pcal_arg->status);
break;
}
i++;
}
}
return pcal_arg->cmd_ok;
}
u8 rtw_update_giltf(_adapter *padapter)
{
struct mp_priv *pmp_priv = (struct mp_priv *)&padapter->mppriv;
u8 idx = 0;
u8 ppdu_type = pmp_priv->rtw_mp_pmact_ppdu_type;
u8 user_idx = pmp_priv->mp_plcp_useridx;
RTW_INFO("%s: ppdu_type=%s\n", __func__ , PPDU_TYPE_STR(pmp_priv->rtw_mp_pmact_ppdu_type));
if (ppdu_type == RTW_MP_TYPE_HT_MF || ppdu_type == RTW_MP_TYPE_HT_GF
|| ppdu_type == RTW_MP_TYPE_VHT) {
pmp_priv->st_giltf[0].gi = 0;
pmp_priv->st_giltf[0].ltf = 0;
strcpy(pmp_priv->st_giltf[0].type_str, "0.4");
pmp_priv->st_giltf[1].gi = 1;
pmp_priv->st_giltf[1].ltf = 0;
strcpy(pmp_priv->st_giltf[1].type_str, "0.8");
idx = 1;
} else if (ppdu_type > RTW_MP_TYPE_VHT) {
if (ppdu_type == RTW_MP_TYPE_HE_SU || ppdu_type == RTW_MP_TYPE_HE_ER_SU) {
if (!pmp_priv->mp_plcp_user[user_idx].dcm && !pmp_priv->rtw_mp_stbc) {
pmp_priv->st_giltf[0].gi = 1;
pmp_priv->st_giltf[0].ltf = 0;
strcpy(pmp_priv->st_giltf[0].type_str, "1x 0.8");
pmp_priv->st_giltf[1].gi = 1;
pmp_priv->st_giltf[1].ltf = 1;
strcpy(pmp_priv->st_giltf[1].type_str, "2x 0.8");
pmp_priv->st_giltf[2].gi = 2;
pmp_priv->st_giltf[2].ltf = 1;
strcpy(pmp_priv->st_giltf[2].type_str, "2x 1.6");
pmp_priv->st_giltf[3].gi = 3;
pmp_priv->st_giltf[3].ltf = 2;
strcpy(pmp_priv->st_giltf[3].type_str, "4x 3.2");
pmp_priv->st_giltf[4].gi = 1;
pmp_priv->st_giltf[4].ltf = 2;
strcpy(pmp_priv->st_giltf[4].type_str, "4x 0.8");
idx = 4;
} else {
pmp_priv->st_giltf[0].gi = 1;
pmp_priv->st_giltf[0].ltf = 0;
strcpy(pmp_priv->st_giltf[0].type_str, "1x 0.8");
pmp_priv->st_giltf[1].gi = 1;
pmp_priv->st_giltf[1].ltf = 1;
strcpy(pmp_priv->st_giltf[1].type_str, "2x 0.8");
pmp_priv->st_giltf[2].gi = 2;
pmp_priv->st_giltf[2].ltf = 1;
strcpy(pmp_priv->st_giltf[2].type_str, "2x 1.6");
pmp_priv->st_giltf[3].gi = 3;
pmp_priv->st_giltf[3].ltf = 2;
strcpy(pmp_priv->st_giltf[3].type_str, "4x 3.2");
idx = 3;
}
}else if (ppdu_type == RTW_MP_TYPE_HE_MU_OFDMA) {
pmp_priv->st_giltf[0].gi = 1;
pmp_priv->st_giltf[0].ltf = 1;
strcpy(pmp_priv->st_giltf[0].type_str, "2x 0.8");
pmp_priv->st_giltf[1].gi = 2;
pmp_priv->st_giltf[1].ltf = 1;
strcpy(pmp_priv->st_giltf[1].type_str, "2x 1.6");
pmp_priv->st_giltf[2].gi = 1;
pmp_priv->st_giltf[2].ltf = 2;
strcpy(pmp_priv->st_giltf[2].type_str, "4x 0.8");
pmp_priv->st_giltf[3].gi = 3;
pmp_priv->st_giltf[3].ltf = 2;
strcpy(pmp_priv->st_giltf[3].type_str, "4x 3.2");
idx = 3;
} else if (ppdu_type == RTW_MP_TYPE_HE_TB) {
pmp_priv->st_giltf[0].gi = 2;
pmp_priv->st_giltf[0].ltf = 0;
strcpy(pmp_priv->st_giltf[0].type_str, "1x 1.6");
pmp_priv->st_giltf[1].gi = 2;
pmp_priv->st_giltf[1].ltf = 1;
strcpy(pmp_priv->st_giltf[1].type_str, "2x 1.6");
pmp_priv->st_giltf[2].gi = 3;
pmp_priv->st_giltf[2].ltf = 2;
strcpy(pmp_priv->st_giltf[2].type_str, "4x 3.2");
idx = 2;
}
}
return idx;
}
void rtw_mp_update_coding(_adapter *padapter)
{
struct mp_priv *pmp_priv = (struct mp_priv *)&padapter->mppriv;
u8 ppdu_type = pmp_priv->rtw_mp_pmact_ppdu_type;
u8 user_idx = pmp_priv->mp_plcp_useridx;
if (ppdu_type == RTW_MP_TYPE_HE_SU || pmp_priv->bandwidth >= CHANNEL_WIDTH_40 ||
pmp_priv->rtw_mp_ru_tone >= MP_RU_TONE_484) {
RTW_INFO("%s, PPDU HE SU , over 40M, RU Tone over 484\n", __func__);
pmp_priv->mp_plcp_user[user_idx].coding = 1;/* 1 LDPC, 0 BCC */
} else if (ppdu_type == RTW_MP_TYPE_HE_MU_OFDMA) {
RTW_INFO("%s, PPDU HE MU\n", __func__);
pmp_priv->mp_plcp_user[user_idx].coding = 0;/* 1 LDPC, 0 BCC */
}
RTW_INFO("%s, coding: %s\n", __func__, (pmp_priv->mp_plcp_user[user_idx].coding?"LDPC":"BCC"));
}
u8 rtw_mp_update_ru_tone(_adapter *padapter)
{
struct mp_priv *pmp_priv = (struct mp_priv *)&padapter->mppriv;
u8 user_idx = pmp_priv->mp_plcp_useridx;
u8 cur_coding = pmp_priv->mp_plcp_user[user_idx].coding;
u8 ruidx = MP_RU_TONE_26;
u8 i = 0 , j = 0;
if (cur_coding == 0) {/* 1 LDPC, 0 BCC */
ruidx = MP_RU_TONE_242;
if (pmp_priv->rtw_mp_ru_tone < MP_RU_TONE_242)
pmp_priv->rtw_mp_ru_tone = MP_RU_TONE_242;
} else {
ruidx = MP_RU_TONE_26;
}
for (i = 0; i <= 5; i++) {
pmp_priv->ru_tone_sel_list[i] = ruidx++;
if (ruidx > MP_RU_TONE_966)
break;
}
return i;
}
u8 rtw_mp_update_ru_alloc(_adapter *padapter)
{
struct mp_priv *pmp_priv = (struct mp_priv *)&padapter->mppriv;
u8 cur_tone = pmp_priv->rtw_mp_ru_tone;
u8 i = 0;
u8 alloc_start = 0, alloc_end = 0;
u8 user_idx = pmp_priv->mp_plcp_useridx;
switch (cur_tone) {
case MP_RU_TONE_26:
alloc_start = 0;
alloc_end = 9;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_40)
alloc_end = 18;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_80)
alloc_end = 37;
break;
case MP_RU_TONE_52:
alloc_start = 37;
alloc_end = 41;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_40)
alloc_end = 45;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_80)
alloc_end = 53;
break;
case MP_RU_TONE_106:
alloc_start = 53;
alloc_end = 55;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_40)
alloc_end = 57;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_80)
alloc_end = 61;
break;
case MP_RU_TONE_242:
alloc_start = 61;
alloc_end = 61;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_40)
alloc_end = 62;
if (pmp_priv->bandwidth == CHANNEL_WIDTH_80)
alloc_end = 64;
break;
case MP_RU_TONE_484:
alloc_start = 65;
alloc_end = 66;
break;
case MP_RU_TONE_966:
alloc_start = 67;
alloc_end = 67;
break;
};
if (pmp_priv->mp_plcp_user[user_idx].ru_alloc < alloc_start ||
pmp_priv->mp_plcp_user[user_idx].ru_alloc > alloc_end)
pmp_priv->mp_plcp_user[user_idx].ru_alloc = alloc_start;
for (i = 0; i < 68; i++) {
if (alloc_start + i > alloc_end)
break;
pmp_priv->ru_alloc_list[i] = alloc_start + i;
RTW_INFO("%s, Ru alloc:%d\n", __func__, pmp_priv->ru_alloc_list[i]);
}
return i;
}
u32 rtw_mp_get_tssi_de(_adapter *padapter, u8 rf_path)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &padapter->mppriv;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.rfpath = rf_path;
if (rtw_mp_phl_txpower(padapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_GET_TSSI))
return ptxpwr_arg.tssi;
else
return 0;
}
s32 rtw_mp_get_online_tssi_de(_adapter *padapter, s32 out_pwr, s32 tgdbm, u8 rf_path)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &padapter->mppriv;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.dbm = tgdbm;
ptxpwr_arg.pout = out_pwr;
ptxpwr_arg.rfpath = rf_path;
if (rtw_mp_phl_txpower(padapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_GET_ONLINE_TSSI_DE))
return ptxpwr_arg.online_tssi_de;
else
return 0;
}
u8 rtw_mp_set_tsside2verify(_adapter *padapter, u32 tssi_de, u8 rf_path)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &padapter->mppriv;
u8 tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
u8 i = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.tssi = tssi_de;
ptxpwr_arg.rfpath = rf_path;
if (rtw_mp_phl_txpower(padapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_SET_TSSI))
return true;
else
return false;
}
u8 rtw_mp_set_tssi_offset(_adapter *padapter, u32 tssi_offset, u8 rf_path)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
struct mp_priv *pmppriv = &padapter->mppriv;
u8 tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
u8 i = 0;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.tssi_de_offset = tssi_offset;
ptxpwr_arg.rfpath = rf_path;
if (rtw_mp_phl_txpower(padapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_SET_TSSI_OFFSET))
return true;
else
return false;
}
u8 rtw_mp_set_tssi_pwrtrk(_adapter *padapter, u8 tssi_state)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
ptxpwr_arg.txpwr_track_status = tssi_state;
if (rtw_mp_phl_txpower(padapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_SET_PWR_TRACK_STATUS))
return true;
else
return false;
}
u8 rtw_mp_get_tssi_pwrtrk(_adapter *padapter)
{
struct rtw_mp_txpwr_arg ptxpwr_arg;
u8 tssi_state = RTW_MP_TSSI_OFF;
_rtw_memset((void *)&ptxpwr_arg, 0, sizeof(struct rtw_mp_txpwr_arg));
if (rtw_mp_phl_txpower(padapter, &ptxpwr_arg, RTW_MP_TXPWR_CMD_GET_PWR_TRACK_STATUS)) {
tssi_state = ptxpwr_arg.txpwr_track_status;
RTW_INFO("%s, get tssi_state = %d\n", __func__, tssi_state);
} else
RTW_INFO("%s, rtw_mp_phl_txpower fail\n", __func__);
return tssi_state;
}
#endif
|
2301_81045437/rtl8852be
|
core/rtw_mp.c
|
C
|
agpl-3.0
| 101,895
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_P2P_C_
#include <drv_types.h>
#ifdef CONFIG_P2P
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37))
#error "Linux kernel version is too old to enable CONFIG_P2P"
#endif
#ifndef CONFIG_IOCTL_CFG80211
#error "Enable CONFIG_P2P without CONFIG_IOCTL_CFG80211"
#endif
int is_any_client_associated(_adapter *padapter)
{
return padapter->stapriv.asoc_list_cnt ? _TRUE : _FALSE;
}
#ifdef CONFIG_WFD
u32 build_beacon_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u16 val16 = 0;
u32 len = 0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110812 */
/* According to the WFD Specification, the beacon frame should contain 4 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID */
/* 3. Coupled Sink Information */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
if (P2P_ROLE_GO == pwdinfo->role) {
if (is_any_client_associated(pwdinfo->padapter)) {
/* WFD primary sink + WiFi Direct mode + WSD (WFD Service Discovery) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
} else {
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD (WFD Service Discovery) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
}
} else {
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
}
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_probe_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u16 val16 = 0;
u32 len = 0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110812 */
/* According to the WFD Specification, the probe request frame should contain 4 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID */
/* 3. Coupled Sink Information */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
if (1 == pwdinfo->wfd_tdls_enable) {
/* WFD primary sink + available for WFD session + WiFi TDLS mode + WSC ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type |
WFD_DEVINFO_SESSION_AVAIL |
WFD_DEVINFO_WSD |
WFD_DEVINFO_PC_TDLS;
RTW_PUT_BE16(wfdie + wfdielen, val16);
} else {
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSC ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type |
WFD_DEVINFO_SESSION_AVAIL |
WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
}
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_probe_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf, u8 tunneled)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
u16 v16 = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110812 */
/* According to the WFD Specification, the probe response frame should contain 4 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID */
/* 3. Coupled Sink Information */
/* 4. WFD Session Information */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + available for WFD session + WiFi Direct mode */
if (P2P_ROLE_GO == pwdinfo->role) {
if (is_any_client_associated(pwdinfo->padapter)) {
if (pwdinfo->wfd_tdls_enable) {
/* TDLS mode + WSD ( WFD Service Discovery ) */
v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT;
RTW_PUT_BE16(wfdie + wfdielen, v16);
} else {
/* WiFi Direct mode + WSD ( WFD Service Discovery ) */
v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT;
RTW_PUT_BE16(wfdie + wfdielen, v16);
}
} else {
if (pwdinfo->wfd_tdls_enable) {
/* available for WFD session + TDLS mode + WSD ( WFD Service Discovery ) */
v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT;
RTW_PUT_BE16(wfdie + wfdielen, v16);
} else {
/* available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT;
RTW_PUT_BE16(wfdie + wfdielen, v16);
}
}
} else {
if (pwdinfo->wfd_tdls_enable) {
/* available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT;
RTW_PUT_BE16(wfdie + wfdielen, v16);
} else {
/* available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT;
RTW_PUT_BE16(wfdie + wfdielen, v16);
}
}
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
/* WFD Session Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_SESSION_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
wfdielen += 2;
/* Todo: to add the list of WFD device info descriptor in WFD group. */
}
#ifdef CONFIG_CONCURRENT_MODE
#ifdef CONFIG_TDLS
{
int i;
_adapter *iface = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
if (iface == padapter)
continue;
if ((tunneled == 0) && (iface->wdinfo.wfd_tdls_enable == 1)) {
/* Alternative MAC Address ATTR
Type: */
wfdie[wfdielen++] = WFD_ATTR_ALTER_MAC;
/* Length:
Note: In the WFD specification, the size of length field is 2.*/
RTW_PUT_BE16(wfdie + wfdielen, ETH_ALEN);
wfdielen += 2;
/* Value:
Alternative MAC Address*/
_rtw_memcpy(wfdie + wfdielen, adapter_mac_addr(iface), ETH_ALEN);
wfdielen += ETH_ALEN;
}
}
}
}
#endif /* CONFIG_TDLS*/
#endif /* CONFIG_CONCURRENT_MODE */
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_assoc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u16 val16 = 0;
u32 len = 0, wfdielen = 0;
_adapter *padapter = NULL;
struct mlme_priv *pmlmepriv = NULL;
struct wifi_display_info *pwfd_info = NULL;
padapter = pwdinfo->padapter;
pmlmepriv = &padapter->mlmepriv;
pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* Only P2P GC need to include the WFD IE in the association request */
if (!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110812 */
/* According to the WFD Specification, the probe request frame should contain 4 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID */
/* 3. Coupled Sink Information */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_assoc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
u16 val16 = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110812 */
/* According to the WFD Specification, the probe request frame should contain 4 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID */
/* 3. Coupled Sink Information */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_nego_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
u16 val16 = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110825 */
/* According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID ( Optional ) */
/* 3. Local IP Adress ( Optional ) */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_nego_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
u16 val16 = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110825 */
/* According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID ( Optional ) */
/* 3. Local IP Adress ( Optional ) */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_nego_confirm_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
u16 val16 = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110825 */
/* According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID ( Optional ) */
/* 3. Local IP Adress ( Optional ) */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_invitation_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
u16 val16 = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110825 */
/* According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID ( Optional ) */
/* 3. Local IP Adress ( Optional ) */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
if (P2P_ROLE_GO == pwdinfo->role) {
/* WFD Session Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_SESSION_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
wfdielen += 2;
/* Todo: to add the list of WFD device info descriptor in WFD group. */
}
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_invitation_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u16 val16 = 0;
u32 len = 0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110825 */
/* According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID ( Optional ) */
/* 3. Local IP Adress ( Optional ) */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
if (P2P_ROLE_GO == pwdinfo->role) {
/* WFD Session Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_SESSION_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
wfdielen += 2;
/* Todo: to add the list of WFD device info descriptor in WFD group. */
}
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_provdisc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
u16 val16 = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110825 */
/* According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID ( Optional ) */
/* 3. Local IP Adress ( Optional ) */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
u32 build_provdisc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 len = 0, wfdielen = 0;
u16 val16 = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->wdinfo.wfd_info;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
goto exit;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/* Commented by Albert 20110825 */
/* According to the WFD Specification, the provision discovery response frame should contain 3 WFD attributes */
/* 1. WFD Device Information */
/* 2. Associated BSSID ( Optional ) */
/* 3. Local IP Adress ( Optional ) */
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery ) */
val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, val16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
wfdielen += ETH_ALEN;
/* Coupled Sink Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_COUPLED_SINK_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
/* Value: */
/* Coupled Sink Status bitmap */
/* Not coupled/available for Coupling */
wfdie[wfdielen++] = 0;
/* MAC Addr. */
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
wfdie[wfdielen++] = 0;
rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
exit:
return len;
}
#endif /* CONFIG_WFD */
u32 process_probe_req_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
{
u8 *p;
u32 ret = _FALSE;
u8 *p2pie;
u32 p2pielen = 0;
int ssid_len = 0, rate_cnt = 0;
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SUPPORTEDRATES_IE_, (int *)&rate_cnt,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
if (rate_cnt <= 4) {
int i, g_rate = 0;
for (i = 0; i < rate_cnt; i++) {
if (((*(p + 2 + i) & 0xff) != 0x02) &&
((*(p + 2 + i) & 0xff) != 0x04) &&
((*(p + 2 + i) & 0xff) != 0x0B) &&
((*(p + 2 + i) & 0xff) != 0x16))
g_rate = 1;
}
if (g_rate == 0) {
/* There is no OFDM rate included in SupportedRates IE of this probe request frame */
/* The driver should response this probe request. */
return ret;
}
} else {
/* rate_cnt > 4 means the SupportRates IE contains the OFDM rate because the count of CCK rates are 4. */
/* We should proceed the following check for this probe request. */
}
/* Added comments by Albert 20100906 */
/* There are several items we should check here. */
/* 1. This probe request frame must contain the P2P IE. (Done) */
/* 2. This probe request frame must contain the wildcard SSID. (Done) */
/* 3. Wildcard BSSID. (Todo) */
/* 4. Destination Address. ( Done in mgt_dispatcher function ) */
/* 5. Requested Device Type in WSC IE. (Todo) */
/* 6. Device ID attribute in P2P IE. (Todo) */
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, (int *)&ssid_len,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
ssid_len &= 0xff; /* Just last 1 byte is valid for ssid len of the probe request */
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) || rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
p2pie = rtw_get_p2p_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_ , len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_ , NULL, &p2pielen);
if (p2pie) {
if ((p != NULL) && _rtw_memcmp((void *)(p + 2), (void *) pwdinfo->p2p_wildcard_ssid , 7)) {
/* todo: */
/* Check Requested Device Type attributes in WSC IE. */
/* Check Device ID attribute in P2P IE */
ret = _TRUE;
} else if ((p != NULL) && (ssid_len == 0))
ret = _TRUE;
} else {
/* non -p2p device */
}
}
return ret;
}
u32 process_assoc_req_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pframe, uint len, struct sta_info *psta)
{
u8 status_code = P2P_STATUS_SUCCESS;
u8 *pbuf, *pattr_content = NULL;
u32 attr_contentlen = 0;
u16 cap_attr = 0;
unsigned short frame_type, ie_offset = 0;
u8 *ies;
u32 ies_len;
u8 *p2p_ie;
u32 p2p_ielen = 0;
if (!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
return P2P_STATUS_FAIL_REQUEST_UNABLE;
frame_type = get_frame_sub_type(pframe);
if (frame_type == WIFI_ASSOCREQ)
ie_offset = _ASOCREQ_IE_OFFSET_;
else /* WIFI_REASSOCREQ */
ie_offset = _REASOCREQ_IE_OFFSET_;
ies = pframe + WLAN_HDR_A3_LEN + ie_offset;
ies_len = len - WLAN_HDR_A3_LEN - ie_offset;
p2p_ie = rtw_get_p2p_ie(ies , ies_len , NULL, &p2p_ielen);
if (!p2p_ie) {
RTW_INFO("[%s] P2P IE not Found!!\n", __FUNCTION__);
status_code = P2P_STATUS_FAIL_INVALID_PARAM;
} else
RTW_INFO("[%s] P2P IE Found!!\n", __FUNCTION__);
while (p2p_ie) {
/* Check P2P Capability ATTR */
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CAPABILITY, (u8 *)&cap_attr, (uint *) &attr_contentlen)) {
RTW_INFO("[%s] Got P2P Capability Attr!!\n", __FUNCTION__);
cap_attr = le16_to_cpu(cap_attr);
psta->dev_cap = cap_attr & 0xff;
}
/* Check Extended Listen Timing ATTR */
/* Check P2P Device Info ATTR */
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_INFO, NULL, (uint *)&attr_contentlen)) {
RTW_INFO("[%s] Got P2P DEVICE INFO Attr!!\n", __FUNCTION__);
pattr_content = pbuf = rtw_zmalloc(attr_contentlen);
if (pattr_content) {
u8 num_of_secdev_type;
u16 dev_name_len;
rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_INFO , pattr_content, (uint *)&attr_contentlen);
_rtw_memcpy(psta->dev_addr, pattr_content, ETH_ALEN);/* P2P Device Address */
pattr_content += ETH_ALEN;
_rtw_memcpy(&psta->config_methods, pattr_content, 2);/* Config Methods */
psta->config_methods = be16_to_cpu(psta->config_methods);
pattr_content += 2;
_rtw_memcpy(psta->primary_dev_type, pattr_content, 8);
pattr_content += 8;
num_of_secdev_type = *pattr_content;
pattr_content += 1;
if (num_of_secdev_type == 0)
psta->num_of_secdev_type = 0;
else {
u32 len;
psta->num_of_secdev_type = num_of_secdev_type;
len = (sizeof(psta->secdev_types_list) < (num_of_secdev_type * 8)) ? (sizeof(psta->secdev_types_list)) : (num_of_secdev_type * 8);
_rtw_memcpy(psta->secdev_types_list, pattr_content, len);
pattr_content += (num_of_secdev_type * 8);
}
/* dev_name_len = attr_contentlen - ETH_ALEN - 2 - 8 - 1 - (num_of_secdev_type*8); */
psta->dev_name_len = 0;
if (WPS_ATTR_DEVICE_NAME == be16_to_cpu(*(u16 *)pattr_content)) {
dev_name_len = be16_to_cpu(*(u16 *)(pattr_content + 2));
psta->dev_name_len = (sizeof(psta->dev_name) < dev_name_len) ? sizeof(psta->dev_name) : dev_name_len;
_rtw_memcpy(psta->dev_name, pattr_content + 4, psta->dev_name_len);
}
rtw_mfree(pbuf, attr_contentlen);
}
}
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
return status_code;
}
#ifdef CONFIG_IOCTL_CFG80211
#if 0
static void rtw_change_p2pie_op_ch(_adapter *padapter, const u8 *frame_body, u32 len, u8 ch)
{
u8 *ies, *p2p_ie;
u32 ies_len, p2p_ielen;
ies = (u8 *)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie) {
u32 attr_contentlen = 0;
u8 *pattr = NULL;
/* Check P2P_ATTR_OPERATING_CH */
attr_contentlen = 0;
pattr = NULL;
pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, (uint *)&attr_contentlen);
if (pattr != NULL)
*(pattr + 4) = ch;
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
}
#endif
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
static void rtw_change_p2pie_ch_list(_adapter *padapter, const u8 *frame_body, u32 len, u8 ch)
{
u8 *ies, *p2p_ie;
u32 ies_len, p2p_ielen;
ies = (u8 *)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie) {
u32 attr_contentlen = 0;
u8 *pattr = NULL;
/* Check P2P_ATTR_CH_LIST */
pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, (uint *)&attr_contentlen);
if (pattr != NULL) {
int i;
u32 num_of_ch;
u8 *pattr_temp = pattr + 3 ;
attr_contentlen -= 3;
while (attr_contentlen > 0) {
num_of_ch = *(pattr_temp + 1);
for (i = 0; i < num_of_ch; i++)
*(pattr_temp + 2 + i) = ch;
pattr_temp += (2 + num_of_ch);
attr_contentlen -= (2 + num_of_ch);
}
}
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
}
#endif
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
static bool rtw_chk_p2pie_ch_list_with_buddy(_adapter *padapter, const u8 *frame_body, u32 len)
{
bool fit = _FALSE;
u8 *ies, *p2p_ie;
u32 ies_len, p2p_ielen;
u8 union_ch = rtw_mi_get_union_chan(padapter);
ies = (u8 *)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie) {
u32 attr_contentlen = 0;
u8 *pattr = NULL;
/* Check P2P_ATTR_CH_LIST */
pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, (uint *)&attr_contentlen);
if (pattr != NULL) {
int i;
u32 num_of_ch;
u8 *pattr_temp = pattr + 3 ;
attr_contentlen -= 3;
while (attr_contentlen > 0) {
num_of_ch = *(pattr_temp + 1);
for (i = 0; i < num_of_ch; i++) {
if (*(pattr_temp + 2 + i) == union_ch) {
RTW_INFO(FUNC_ADPT_FMT" ch_list fit buddy_ch:%u\n", FUNC_ADPT_ARG(padapter), union_ch);
fit = _TRUE;
break;
}
}
pattr_temp += (2 + num_of_ch);
attr_contentlen -= (2 + num_of_ch);
}
}
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
return fit;
}
#if defined(CONFIG_P2P_INVITE_IOT)
static bool rtw_chk_p2pie_op_ch_with_buddy(_adapter *padapter, const u8 *frame_body, u32 len)
{
bool fit = _FALSE;
u8 *ies, *p2p_ie;
u32 ies_len, p2p_ielen;
u8 union_ch = rtw_mi_get_union_chan(padapter);
ies = (u8 *)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie) {
u32 attr_contentlen = 0;
u8 *pattr = NULL;
/* Check P2P_ATTR_OPERATING_CH */
attr_contentlen = 0;
pattr = NULL;
pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, (uint *)&attr_contentlen);
if (pattr != NULL) {
if (*(pattr + 4) == union_ch) {
RTW_INFO(FUNC_ADPT_FMT" op_ch fit buddy_ch:%u\n", FUNC_ADPT_ARG(padapter), union_ch);
fit = _TRUE;
break;
}
}
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
return fit;
}
#endif
static void rtw_cfg80211_adjust_p2pie_channel(_adapter *padapter, const u8 *frame_body, u32 len)
{
u8 *ies, *p2p_ie;
u32 ies_len, p2p_ielen;
u8 union_ch = rtw_mi_get_union_chan(padapter);
ies = (u8 *)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie) {
u32 attr_contentlen = 0;
u8 *pattr = NULL;
/* Check P2P_ATTR_CH_LIST */
pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, (uint *)&attr_contentlen);
if (pattr != NULL) {
int i;
u32 num_of_ch;
u8 *pattr_temp = pattr + 3 ;
attr_contentlen -= 3;
while (attr_contentlen > 0) {
num_of_ch = *(pattr_temp + 1);
for (i = 0; i < num_of_ch; i++) {
if (*(pattr_temp + 2 + i) && *(pattr_temp + 2 + i) != union_ch) {
RTW_ERR("replace ch_list:%u with:%u\n", *(pattr_temp + 2 + i), union_ch);
*(pattr_temp + 2 + i) = union_ch; /*forcing to the same channel*/
}
}
pattr_temp += (2 + num_of_ch);
attr_contentlen -= (2 + num_of_ch);
}
}
/* Check P2P_ATTR_OPERATING_CH */
attr_contentlen = 0;
pattr = NULL;
pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, (uint *)&attr_contentlen);
if (pattr != NULL) {
if (*(pattr + 4) && *(pattr + 4) != union_ch) {
RTW_ERR("replace op_ch:%u with:%u\n", *(pattr + 4), union_ch);
*(pattr + 4) = union_ch; /*forcing to the same channel */
}
}
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
}
#endif
#ifdef CONFIG_WFD
u32 rtw_xframe_build_wfd_ie(struct xmit_frame *xframe)
{
_adapter *adapter = xframe->padapter;
struct wifidirect_info *wdinfo = &adapter->wdinfo;
u8 *frame = xframe->buf_addr + TXDESC_OFFSET;
u8 *frame_body = frame + sizeof(struct rtw_ieee80211_hdr_3addr);
u8 *frame_tail = frame + xframe->attrib.pktlen;
u8 category, action, OUI_Subtype, dialogToken = 0;
u32 wfdielen = 0;
category = frame_body[0];
if (category == RTW_WLAN_CATEGORY_PUBLIC) {
action = frame_body[1];
if (action == ACT_PUBLIC_VENDOR
&& _rtw_memcmp(frame_body + 2, P2P_OUI, 4) == _TRUE
) {
OUI_Subtype = frame_body[6];
dialogToken = frame_body[7];
switch (OUI_Subtype) {
case P2P_GO_NEGO_REQ:
wfdielen = build_nego_req_wfd_ie(wdinfo, frame_tail);
break;
case P2P_GO_NEGO_RESP:
wfdielen = build_nego_resp_wfd_ie(wdinfo, frame_tail);
break;
case P2P_GO_NEGO_CONF:
wfdielen = build_nego_confirm_wfd_ie(wdinfo, frame_tail);
break;
case P2P_INVIT_REQ:
wfdielen = build_invitation_req_wfd_ie(wdinfo, frame_tail);
break;
case P2P_INVIT_RESP:
wfdielen = build_invitation_resp_wfd_ie(wdinfo, frame_tail);
break;
case P2P_PROVISION_DISC_REQ:
wfdielen = build_provdisc_req_wfd_ie(wdinfo, frame_tail);
break;
case P2P_PROVISION_DISC_RESP:
wfdielen = build_provdisc_resp_wfd_ie(wdinfo, frame_tail);
break;
case P2P_DEVDISC_REQ:
case P2P_DEVDISC_RESP:
default:
break;
}
}
} else if (category == RTW_WLAN_CATEGORY_P2P) {
OUI_Subtype = frame_body[5];
dialogToken = frame_body[6];
#ifdef CONFIG_DEBUG_CFG80211
RTW_INFO("ACTION_CATEGORY_P2P: OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n"
, cpu_to_be32(*((u32 *)(frame_body + 1))), OUI_Subtype, dialogToken);
#endif
switch (OUI_Subtype) {
case P2P_NOTICE_OF_ABSENCE:
break;
case P2P_PRESENCE_REQUEST:
break;
case P2P_PRESENCE_RESPONSE:
break;
case P2P_GO_DISC_REQUEST:
break;
default:
break;
}
} else
RTW_INFO("%s, action frame category=%d\n", __func__, category);
xframe->attrib.pktlen += wfdielen;
return wfdielen;
}
#endif /* CONFIG_WFD */
bool rtw_xframe_del_wfd_ie(struct xmit_frame *xframe)
{
#define DBG_XFRAME_DEL_WFD_IE 0
u8 *frame = xframe->buf_addr + TXDESC_OFFSET;
u8 *frame_body = frame + sizeof(struct rtw_ieee80211_hdr_3addr);
u8 *frame_tail = frame + xframe->attrib.pktlen;
u8 category, action, OUI_Subtype;
u8 *ies = NULL;
uint ies_len_ori = 0;
uint ies_len = 0;
category = frame_body[0];
if (category == RTW_WLAN_CATEGORY_PUBLIC) {
action = frame_body[1];
if (action == ACT_PUBLIC_VENDOR
&& _rtw_memcmp(frame_body + 2, P2P_OUI, 4) == _TRUE
) {
OUI_Subtype = frame_body[6];
switch (OUI_Subtype) {
case P2P_GO_NEGO_REQ:
case P2P_GO_NEGO_RESP:
case P2P_GO_NEGO_CONF:
case P2P_INVIT_REQ:
case P2P_INVIT_RESP:
case P2P_PROVISION_DISC_REQ:
case P2P_PROVISION_DISC_RESP:
ies = frame_body + 8;
ies_len_ori = frame_tail - (frame_body + 8);
break;
}
}
}
if (ies && ies_len_ori) {
ies_len = rtw_del_wfd_ie(ies, ies_len_ori, DBG_XFRAME_DEL_WFD_IE ? __func__ : NULL);
xframe->attrib.pktlen -= (ies_len_ori - ies_len);
}
return ies_len_ori != ies_len;
}
/*
* rtw_xframe_chk_wfd_ie -
*
*/
void rtw_xframe_chk_wfd_ie(struct xmit_frame *xframe)
{
_adapter *adapter = xframe->padapter;
#ifdef CONFIG_IOCTL_CFG80211
struct wifidirect_info *wdinfo = &adapter->wdinfo;
#endif
u8 build = 0;
u8 del = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
del = 1;
#ifdef CONFIG_IOCTL_CFG80211
if (wdinfo->wfd_info->wfd_enable == _TRUE)
#endif
del = build = 1;
if (del)
rtw_xframe_del_wfd_ie(xframe);
#ifdef CONFIG_WFD
if (build)
rtw_xframe_build_wfd_ie(xframe);
#endif
}
u8 *dump_p2p_attr_ch_list(u8 *p2p_ie, uint p2p_ielen, u8 *buf, u32 buf_len)
{
uint attr_contentlen = 0;
u8 *pattr = NULL;
int w_sz = 0;
u8 ch_cnt = 0;
u8 ch_list[40];
pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, &attr_contentlen);
if (pattr != NULL) {
int i, j;
u32 num_of_ch;
u8 *pattr_temp = pattr + 3 ;
attr_contentlen -= 3;
_rtw_memset(ch_list, 0, 40);
while (attr_contentlen > 0) {
num_of_ch = *(pattr_temp + 1);
for (i = 0; i < num_of_ch; i++) {
for (j = 0; j < ch_cnt; j++) {
if (ch_list[j] == *(pattr_temp + 2 + i))
break;
}
if (j >= ch_cnt)
ch_list[ch_cnt++] = *(pattr_temp + 2 + i);
}
pattr_temp += (2 + num_of_ch);
attr_contentlen -= (2 + num_of_ch);
}
for (j = 0; j < ch_cnt; j++) {
if (j == 0)
w_sz += snprintf(buf + w_sz, buf_len - w_sz, "%u", ch_list[j]);
else if (ch_list[j] - ch_list[j - 1] != 1)
w_sz += snprintf(buf + w_sz, buf_len - w_sz, ", %u", ch_list[j]);
else if (j != ch_cnt - 1 && ch_list[j + 1] - ch_list[j] == 1) {
/* empty */
} else
w_sz += snprintf(buf + w_sz, buf_len - w_sz, "-%u", ch_list[j]);
}
}
return buf;
}
/*
* return _TRUE if requester is GO, _FALSE if responder is GO
*/
bool rtw_p2p_nego_intent_compare(u8 req, u8 resp)
{
if (req >> 1 == resp >> 1)
return req & 0x01 ? _TRUE : _FALSE;
else if (req >> 1 > resp >> 1)
return _TRUE;
else
return _FALSE;
}
int rtw_p2p_check_frames(_adapter *padapter, const u8 *buf, u32 len, u8 tx)
{
int is_p2p_frame = (-1);
unsigned char *frame_body;
u8 category, action, OUI_Subtype, dialogToken = 0;
u8 *p2p_ie = NULL;
uint p2p_ielen = 0;
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
int status = -1;
u8 ch_list_buf[128] = {'\0'};
int op_ch = -1;
int listen_ch = -1;
u8 intent = 0;
u8 *iaddr = NULL;
u8 *gbssid = NULL;
frame_body = (unsigned char *)(buf + sizeof(struct rtw_ieee80211_hdr_3addr));
category = frame_body[0];
/* just for check */
if (category == RTW_WLAN_CATEGORY_PUBLIC) {
action = frame_body[1];
if (action == ACT_PUBLIC_VENDOR
&& _rtw_memcmp(frame_body + 2, P2P_OUI, 4) == _TRUE
) {
OUI_Subtype = frame_body[6];
dialogToken = frame_body[7];
is_p2p_frame = OUI_Subtype;
#ifdef CONFIG_DEBUG_CFG80211
RTW_INFO("ACTION_CATEGORY_PUBLIC: ACT_PUBLIC_VENDOR, OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
cpu_to_be32(*((u32 *)(frame_body + 2))), OUI_Subtype, dialogToken);
#endif
p2p_ie = rtw_get_p2p_ie(
(u8 *)buf + sizeof(struct rtw_ieee80211_hdr_3addr) + _PUBLIC_ACTION_IE_OFFSET_
, len - sizeof(struct rtw_ieee80211_hdr_3addr) - _PUBLIC_ACTION_IE_OFFSET_
, NULL, &p2p_ielen);
switch (OUI_Subtype) { /* OUI Subtype */
u8 *cont;
uint cont_len;
case P2P_GO_NEGO_REQ: {
struct rtw_wdev_nego_info *nego_info = &pwdev_priv->nego_info;
if (tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED) && padapter->registrypriv.full_ch_in_p2p_handshake == 0)
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len);
if (cont)
op_ch = *(cont + 4);
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_LISTEN_CH, NULL, &cont_len);
if (cont)
listen_ch = *(cont + 4);
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT, NULL, &cont_len);
if (cont)
intent = *cont;
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_INTENDED_IF_ADDR, NULL, &cont_len);
if (cont && cont_len == 6)
iaddr = cont;
if (nego_info->token != dialogToken)
rtw_wdev_nego_info_init(nego_info);
_rtw_memcpy(nego_info->peer_mac, tx ? GetAddr1Ptr(buf) : get_addr2_ptr(buf), ETH_ALEN);
if (iaddr)
_rtw_memcpy(tx ? nego_info->iface_addr : nego_info->peer_iface_addr, iaddr, ETH_ALEN);
nego_info->active = tx ? 1 : 0;
nego_info->token = dialogToken;
nego_info->req_op_ch = op_ch;
nego_info->req_listen_ch = listen_ch;
nego_info->req_intent = intent;
nego_info->state = 0;
dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
RTW_INFO("RTW_%s:P2P_GO_NEGO_REQ, dialogToken=%d, intent:%u%s, listen_ch:%d, op_ch:%d, ch_list:%s"
, (tx == _TRUE) ? "Tx" : "Rx" , dialogToken , (intent >> 1) , intent & 0x1 ? "+" : "-" , listen_ch , op_ch , ch_list_buf);
if (iaddr)
_RTW_INFO(", iaddr:"MAC_FMT, MAC_ARG(iaddr));
_RTW_INFO("\n");
if (!tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED)
&& rtw_chk_p2pie_ch_list_with_buddy(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE
&& padapter->registrypriv.full_ch_in_p2p_handshake == 0) {
RTW_INFO(FUNC_ADPT_FMT" ch_list has no intersect with buddy\n", FUNC_ADPT_ARG(padapter));
rtw_change_p2pie_ch_list(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr), 0);
}
#endif
}
break;
}
case P2P_GO_NEGO_RESP: {
struct rtw_wdev_nego_info *nego_info = &pwdev_priv->nego_info;
if (tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED) && padapter->registrypriv.full_ch_in_p2p_handshake == 0)
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len);
if (cont)
op_ch = *(cont + 4);
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT, NULL, &cont_len);
if (cont)
intent = *cont;
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
if (cont)
status = *cont;
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_INTENDED_IF_ADDR, NULL, &cont_len);
if (cont && cont_len == 6)
iaddr = cont;
if (nego_info->token == dialogToken && nego_info->state == 0
&& _rtw_memcmp(nego_info->peer_mac, tx ? GetAddr1Ptr(buf) : get_addr2_ptr(buf), ETH_ALEN) == _TRUE
) {
if (iaddr)
_rtw_memcpy(tx ? nego_info->iface_addr : nego_info->peer_iface_addr, iaddr, ETH_ALEN);
nego_info->status = (status == -1) ? 0xff : status;
nego_info->rsp_op_ch = op_ch;
nego_info->rsp_intent = intent;
nego_info->state = 1;
if (status != 0)
nego_info->token = 0; /* init */
}
dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
RTW_INFO("RTW_%s:P2P_GO_NEGO_RESP, dialogToken=%d, intent:%u%s, status:%d, op_ch:%d, ch_list:%s"
, (tx == _TRUE) ? "Tx" : "Rx", dialogToken, (intent >> 1), intent & 0x1 ? "+" : "-", status, op_ch, ch_list_buf);
if (iaddr)
_RTW_INFO(", iaddr:"MAC_FMT, MAC_ARG(iaddr));
_RTW_INFO("\n");
if (!tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED)
&& rtw_chk_p2pie_ch_list_with_buddy(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE
&& padapter->registrypriv.full_ch_in_p2p_handshake == 0) {
RTW_INFO(FUNC_ADPT_FMT" ch_list has no intersect with buddy\n", FUNC_ADPT_ARG(padapter));
rtw_change_p2pie_ch_list(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr), 0);
}
#endif
}
break;
}
case P2P_GO_NEGO_CONF: {
struct rtw_wdev_nego_info *nego_info = &pwdev_priv->nego_info;
bool is_go = _FALSE;
if (tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED) && padapter->registrypriv.full_ch_in_p2p_handshake == 0)
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len);
if (cont)
op_ch = *(cont + 4);
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
if (cont)
status = *cont;
if (nego_info->token == dialogToken && nego_info->state == 1
&& _rtw_memcmp(nego_info->peer_mac, tx ? GetAddr1Ptr(buf) : get_addr2_ptr(buf), ETH_ALEN) == _TRUE
) {
nego_info->status = (status == -1) ? 0xff : status;
nego_info->conf_op_ch = (op_ch == -1) ? 0 : op_ch;
nego_info->state = 2;
if (status == 0) {
if (rtw_p2p_nego_intent_compare(nego_info->req_intent, nego_info->rsp_intent) ^ !tx)
is_go = _TRUE;
}
nego_info->token = 0; /* init */
}
dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
RTW_INFO("RTW_%s:P2P_GO_NEGO_CONF, dialogToken=%d, status:%d, op_ch:%d, ch_list:%s\n"
, (tx == _TRUE) ? "Tx" : "Rx", dialogToken, status, op_ch, ch_list_buf);
if (!tx) {
}
break;
}
case P2P_INVIT_REQ: {
struct rtw_wdev_invit_info *invit_info = &pwdev_priv->invit_info;
int flags = -1;
if (tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED)
&& padapter->registrypriv.full_ch_in_p2p_handshake == 0)
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_INVITATION_FLAGS, NULL, &cont_len);
if (cont)
flags = *cont;
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len);
if (cont)
op_ch = *(cont + 4);
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GROUP_BSSID, NULL, &cont_len);
if (cont && cont_len == 6)
gbssid = cont;
if (invit_info->token != dialogToken)
rtw_wdev_invit_info_init(invit_info);
_rtw_memcpy(invit_info->peer_mac, tx ? GetAddr1Ptr(buf) : get_addr2_ptr(buf), ETH_ALEN);
if (gbssid)
_rtw_memcpy(invit_info->group_bssid, gbssid, ETH_ALEN);
invit_info->active = tx ? 1 : 0;
invit_info->token = dialogToken;
invit_info->flags = (flags == -1) ? 0x0 : flags;
invit_info->req_op_ch = op_ch;
invit_info->state = 0;
dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
RTW_INFO("RTW_%s:P2P_INVIT_REQ, dialogToken=%d, flags:0x%02x, op_ch:%d, ch_list:%s"
, (tx == _TRUE) ? "Tx" : "Rx", dialogToken, flags, op_ch, ch_list_buf);
if (gbssid)
_RTW_INFO(", gbssid:"MAC_FMT, MAC_ARG(gbssid));
_RTW_INFO("\n");
if (!tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED) && padapter->registrypriv.full_ch_in_p2p_handshake == 0) {
#if defined(CONFIG_P2P_INVITE_IOT)
if (op_ch != -1 && rtw_chk_p2pie_op_ch_with_buddy(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE) {
RTW_INFO(FUNC_ADPT_FMT" op_ch:%u has no intersect with buddy\n", FUNC_ADPT_ARG(padapter), op_ch);
rtw_change_p2pie_ch_list(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr), 0);
} else
#endif
if (rtw_chk_p2pie_ch_list_with_buddy(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE) {
RTW_INFO(FUNC_ADPT_FMT" ch_list has no intersect with buddy\n", FUNC_ADPT_ARG(padapter));
rtw_change_p2pie_ch_list(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr), 0);
}
}
#endif
}
break;
}
case P2P_INVIT_RESP: {
struct rtw_wdev_invit_info *invit_info = &pwdev_priv->invit_info;
if (tx) {
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
if (rtw_mi_check_status(padapter, MI_LINKED) && padapter->registrypriv.full_ch_in_p2p_handshake == 0)
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len - sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
if (cont) {
#ifdef CONFIG_P2P_INVITE_IOT
if (tx && *cont == 7) {
RTW_INFO("TX_P2P_INVITE_RESP, status is no common channel, change to unknown group\n");
*cont = 8; /* unknow group status */
}
#endif /* CONFIG_P2P_INVITE_IOT */
status = *cont;
}
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len);
if (cont)
op_ch = *(cont + 4);
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GROUP_BSSID, NULL, &cont_len);
if (cont && cont_len == 6)
gbssid = cont;
if (invit_info->token == dialogToken && invit_info->state == 0
&& _rtw_memcmp(invit_info->peer_mac, tx ? GetAddr1Ptr(buf) : get_addr2_ptr(buf), ETH_ALEN) == _TRUE
) {
invit_info->status = (status == -1) ? 0xff : status;
invit_info->rsp_op_ch = op_ch;
invit_info->state = 1;
invit_info->token = 0; /* init */
}
dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
RTW_INFO("RTW_%s:P2P_INVIT_RESP, dialogToken=%d, status:%d, op_ch:%d, ch_list:%s"
, (tx == _TRUE) ? "Tx" : "Rx", dialogToken, status, op_ch, ch_list_buf);
if (gbssid)
_RTW_INFO(", gbssid:"MAC_FMT, MAC_ARG(gbssid));
_RTW_INFO("\n");
if (!tx) {
}
break;
}
case P2P_DEVDISC_REQ:
RTW_INFO("RTW_%s:P2P_DEVDISC_REQ, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken);
break;
case P2P_DEVDISC_RESP:
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
RTW_INFO("RTW_%s:P2P_DEVDISC_RESP, dialogToken=%d, status:%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken, cont ? *cont : -1);
break;
case P2P_PROVISION_DISC_REQ:
RTW_INFO("RTW_%s:P2P_PROVISION_DISC_REQ, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken);
break;
case P2P_PROVISION_DISC_RESP:
RTW_INFO("RTW_%s:P2P_PROVISION_DISC_RESP, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken);
break;
default:
RTW_INFO("RTW_%s:OUI_Subtype=%d, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", OUI_Subtype, dialogToken);
break;
}
}
} else if (category == RTW_WLAN_CATEGORY_P2P) {
OUI_Subtype = frame_body[5];
dialogToken = frame_body[6];
#ifdef CONFIG_DEBUG_CFG80211
RTW_INFO("ACTION_CATEGORY_P2P: OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
cpu_to_be32(*((u32 *)(frame_body + 1))), OUI_Subtype, dialogToken);
#endif
is_p2p_frame = OUI_Subtype;
switch (OUI_Subtype) {
case P2P_NOTICE_OF_ABSENCE:
RTW_INFO("RTW_%s:P2P_NOTICE_OF_ABSENCE, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken);
break;
case P2P_PRESENCE_REQUEST:
RTW_INFO("RTW_%s:P2P_PRESENCE_REQUEST, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken);
break;
case P2P_PRESENCE_RESPONSE:
RTW_INFO("RTW_%s:P2P_PRESENCE_RESPONSE, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken);
break;
case P2P_GO_DISC_REQUEST:
RTW_INFO("RTW_%s:P2P_GO_DISC_REQUEST, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", dialogToken);
break;
default:
RTW_INFO("RTW_%s:OUI_Subtype=%d, dialogToken=%d\n", (tx == _TRUE) ? "Tx" : "Rx", OUI_Subtype, dialogToken);
break;
}
}
return is_p2p_frame;
}
#endif /* CONFIG_IOCTL_CFG80211 */
int process_p2p_cross_connect_ie(_adapter *padapter, u8 *IEs, u32 IELength)
{
int ret = _TRUE;
u8 *ies;
u32 ies_len;
u8 *p2p_ie;
u32 p2p_ielen = 0;
u8 p2p_attr[MAX_P2P_IE_LEN] = { 0x00 };/* NoA length should be n*(13) + 2 */
u32 attr_contentlen = 0;
if (IELength <= _BEACON_IE_OFFSET_)
return ret;
ies = IEs + _BEACON_IE_OFFSET_;
ies_len = IELength - _BEACON_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie) {
/* Get P2P Manageability IE. */
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_MANAGEABILITY, p2p_attr, &attr_contentlen)) {
if ((p2p_attr[0] & (BIT(0) | BIT(1))) == 0x01)
ret = _FALSE;
break;
}
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
return ret;
}
#ifdef CONFIG_P2P_PS
void process_p2p_ps_ie(_adapter *padapter, u8 *IEs, u32 IELength)
{
u8 *ies;
u32 ies_len;
u8 *p2p_ie;
u32 p2p_ielen = 0;
u8 *noa_attr; /* NoA length should be n*(13) + 2 */
u32 attr_contentlen = 0;
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
u8 find_p2p = _FALSE, find_p2p_ps = _FALSE;
u8 noa_offset, noa_num, noa_index;
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DISABLE) ||
rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE))
return;
#ifdef CONFIG_CONCURRENT_MODE
#ifndef CONFIG_FW_MULTI_PORT_SUPPORT
if (padapter->hw_port != HW_PORT0)
return;
#endif
#endif
if (IELength <= _BEACON_IE_OFFSET_)
return;
ies = IEs + _BEACON_IE_OFFSET_;
ies_len = IELength - _BEACON_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie(ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie) {
find_p2p = _TRUE;
/* Get Notice of Absence IE. */
noa_attr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_NOA, NULL, &attr_contentlen);
if (noa_attr) {
find_p2p_ps = _TRUE;
noa_index = noa_attr[0];
if ((pwdinfo->p2p_ps_mode == P2P_PS_NONE) ||
(noa_index != pwdinfo->noa_index)) { /* if index change, driver should reconfigure related setting. */
pwdinfo->noa_index = noa_index;
pwdinfo->opp_ps = noa_attr[1] >> 7;
if (pwdinfo->opp_ps != 1)
pwdinfo->ctwindow = 0;
else
pwdinfo->ctwindow = noa_attr[1] & 0x7F;
noa_offset = 2;
noa_num = 0;
/* NoA length should be n*(13) + 2 */
if (attr_contentlen > 2 && (attr_contentlen - 2) % 13 == 0) {
while (noa_offset < attr_contentlen && noa_num < P2P_MAX_NOA_NUM) {
/* _rtw_memcpy(&wifidirect_info->noa_count[noa_num], &noa_attr[noa_offset], 1); */
pwdinfo->noa_count[noa_num] = noa_attr[noa_offset];
noa_offset += 1;
_rtw_memcpy(&pwdinfo->noa_duration[noa_num], &noa_attr[noa_offset], 4);
noa_offset += 4;
_rtw_memcpy(&pwdinfo->noa_interval[noa_num], &noa_attr[noa_offset], 4);
noa_offset += 4;
_rtw_memcpy(&pwdinfo->noa_start_time[noa_num], &noa_attr[noa_offset], 4);
noa_offset += 4;
noa_num++;
}
}
pwdinfo->noa_num = noa_num;
if (pwdinfo->opp_ps == 1) {
pwdinfo->p2p_ps_mode = P2P_PS_CTWINDOW;
/* driver should wait LPS for entering CTWindow */
if (adapter_to_pwrctl(padapter)->bFwCurrentInPSMode == _TRUE)
p2p_ps_wk_cmd(padapter, P2P_PS_ENABLE, 1);
} else if (pwdinfo->noa_num > 0) {
pwdinfo->p2p_ps_mode = P2P_PS_NOA;
p2p_ps_wk_cmd(padapter, P2P_PS_ENABLE, 1);
} else if (pwdinfo->p2p_ps_mode > P2P_PS_NONE)
p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
}
break; /* find target, just break. */
}
/* Get the next P2P IE */
p2p_ie = rtw_get_p2p_ie(p2p_ie + p2p_ielen, ies_len - (p2p_ie - ies + p2p_ielen), NULL, &p2p_ielen);
}
if (find_p2p == _TRUE) {
if ((pwdinfo->p2p_ps_mode > P2P_PS_NONE) && (find_p2p_ps == _FALSE))
p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
}
}
void p2p_ps_wk_hdl(_adapter *padapter, u8 p2p_ps_state)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
u32 ps_deny = 0;
/* Pre action for p2p state */
switch (p2p_ps_state) {
case P2P_PS_DISABLE:
pwdinfo->p2p_ps_state = p2p_ps_state;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
if (pwdinfo->opp_ps == 1) {
if (pwrpriv->smart_ps == 0) {
pwrpriv->smart_ps = 2;
if (pwrpriv->pwr_mode != PM_PS_MODE_ACTIVE)
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&(pwrpriv->pwr_mode)));
}
}
pwdinfo->noa_index = 0;
pwdinfo->ctwindow = 0;
pwdinfo->opp_ps = 0;
pwdinfo->noa_num = 0;
pwdinfo->p2p_ps_mode = P2P_PS_NONE;
break;
case P2P_PS_ENABLE:
_enter_pwrlock(&adapter_to_pwrctl(padapter)->lock);
ps_deny = rtw_ps_deny_get(padapter);
_exit_pwrlock(&adapter_to_pwrctl(padapter)->lock);
if ((ps_deny & (PS_DENY_SCAN | PS_DENY_JOIN))
|| rtw_mi_check_fwstate(padapter, (WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING))) {
pwdinfo->p2p_ps_mode = P2P_PS_NONE;
RTW_DBG(FUNC_ADPT_FMT" Block P2P PS under site survey or LINKING\n", FUNC_ADPT_ARG(padapter));
return;
}
if (pwdinfo->p2p_ps_mode > P2P_PS_NONE) {
pwdinfo->p2p_ps_state = p2p_ps_state;
if (pwdinfo->ctwindow > 0) {
if (pwrpriv->smart_ps != 0) {
pwrpriv->smart_ps = 0;
RTW_INFO("%s(): Enter CTW, change SmartPS\n", __FUNCTION__);
if (pwrpriv->pwr_mode != PM_PS_MODE_ACTIVE)
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&(pwrpriv->pwr_mode)));
}
}
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
}
break;
case P2P_PS_SCAN:
case P2P_PS_SCAN_DONE:
case P2P_PS_ALLSTASLEEP:
if (pwdinfo->p2p_ps_mode > P2P_PS_NONE) {
pwdinfo->p2p_ps_state = p2p_ps_state;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
}
break;
default:
break;
}
}
u8 p2p_ps_wk_cmd(_adapter *padapter, u8 p2p_ps_state, u8 enqueue)
{
struct cmd_obj *cmd;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DISABLE) ||
rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) ||
#ifdef CONFIG_CONCURRENT_MODE
#ifndef CONFIG_FW_MULTI_PORT_SUPPORT
(padapter->hw_port != HW_PORT0) ||
#endif
#endif
0)
return res;
if (enqueue) {
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
res = _FAIL;
goto exit;
}
cmd->padapter = padapter;
pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm == NULL) {
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = P2P_PS_WK_CID;
pdrvextra_cmd_parm->type = p2p_ps_state;
pdrvextra_cmd_parm->size = 0;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(cmd, pdrvextra_cmd_parm, CMD_SET_DRV_EXTRA);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
} else
p2p_ps_wk_hdl(padapter, p2p_ps_state);
exit:
return res;
}
#endif /* CONFIG_P2P_PS */
void reset_global_wifidirect_info(_adapter *padapter)
{
struct wifidirect_info *pwdinfo;
pwdinfo = &padapter->wdinfo;
rtw_tdls_wfd_enable(padapter, 0);
pwdinfo->wfd_tdls_weaksec = _TRUE;
}
#ifdef CONFIG_WFD
int rtw_init_wifi_display_info(_adapter *padapter)
{
int res = _SUCCESS;
struct wifi_display_info *pwfd_info = &padapter->wfd_info;
/* Used in P2P and TDLS */
pwfd_info->init_rtsp_ctrlport = 554;
#ifdef CONFIG_IOCTL_CFG80211
pwfd_info->rtsp_ctrlport = 0;
#else
pwfd_info->rtsp_ctrlport = pwfd_info->init_rtsp_ctrlport; /* set non-zero value for legacy wfd */
#endif
pwfd_info->tdls_rtsp_ctrlport = 0;
pwfd_info->peer_rtsp_ctrlport = 0; /* Reset to 0 */
pwfd_info->wfd_enable = _FALSE;
pwfd_info->wfd_device_type = WFD_DEVINFO_PSINK;
pwfd_info->scan_result_type = SCAN_RESULT_P2P_ONLY;
/* Used in P2P */
pwfd_info->peer_session_avail = _TRUE;
pwfd_info->wfd_pc = _FALSE;
/* Used in TDLS */
_rtw_memset(pwfd_info->ip_address, 0x00, 4);
_rtw_memset(pwfd_info->peer_ip_address, 0x00, 4);
return res;
}
inline void rtw_wfd_enable(_adapter *adapter, bool on)
{
struct wifi_display_info *wfdinfo = &adapter->wfd_info;
if (on) {
wfdinfo->rtsp_ctrlport = wfdinfo->init_rtsp_ctrlport;
wfdinfo->wfd_enable = _TRUE;
} else {
wfdinfo->wfd_enable = _FALSE;
wfdinfo->rtsp_ctrlport = 0;
}
}
inline void rtw_wfd_set_ctrl_port(_adapter *adapter, u16 port)
{
struct wifi_display_info *wfdinfo = &adapter->wfd_info;
wfdinfo->init_rtsp_ctrlport = port;
if (wfdinfo->wfd_enable == _TRUE)
wfdinfo->rtsp_ctrlport = port;
if (adapter->wdinfo.wfd_tdls_enable == 1)
wfdinfo->tdls_rtsp_ctrlport = port;
}
inline void rtw_tdls_wfd_enable(_adapter *adapter, bool on)
{
struct wifi_display_info *wfdinfo = &adapter->wfd_info;
if (on) {
wfdinfo->tdls_rtsp_ctrlport = wfdinfo->init_rtsp_ctrlport;
adapter->wdinfo.wfd_tdls_enable = 1;
} else {
adapter->wdinfo.wfd_tdls_enable = 0;
wfdinfo->tdls_rtsp_ctrlport = 0;
}
}
u32 rtw_append_beacon_wfd_ie(_adapter *adapter, u8 *pbuf)
{
struct wifidirect_info *wdinfo = &adapter->wdinfo;
struct mlme_priv *mlme = &adapter->mlmepriv;
u8 build_ie_by_self = 0;
u32 len = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
goto exit;
#ifdef CONFIG_IOCTL_CFG80211
if (_TRUE == wdinfo->wfd_info->wfd_enable)
#endif
build_ie_by_self = 1;
if (build_ie_by_self)
len = build_beacon_wfd_ie(wdinfo, pbuf);
#ifdef CONFIG_IOCTL_CFG80211
else if (mlme->wfd_beacon_ie && mlme->wfd_beacon_ie_len > 0) {
len = mlme->wfd_beacon_ie_len;
_rtw_memcpy(pbuf, mlme->wfd_beacon_ie, len);
}
#endif
exit:
return len;
}
u32 rtw_append_probe_req_wfd_ie(_adapter *adapter, u8 *pbuf)
{
struct wifidirect_info *wdinfo = &adapter->wdinfo;
struct mlme_priv *mlme = &adapter->mlmepriv;
u8 build_ie_by_self = 0;
u32 len = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
goto exit;
#ifdef CONFIG_IOCTL_CFG80211
if (_TRUE == wdinfo->wfd_info->wfd_enable)
#endif
build_ie_by_self = 1;
if (build_ie_by_self)
len = build_probe_req_wfd_ie(wdinfo, pbuf);
#ifdef CONFIG_IOCTL_CFG80211
else if (mlme->wfd_probe_req_ie && mlme->wfd_probe_req_ie_len > 0) {
len = mlme->wfd_probe_req_ie_len;
_rtw_memcpy(pbuf, mlme->wfd_probe_req_ie, len);
}
#endif
exit:
return len;
}
u32 rtw_append_probe_resp_wfd_ie(_adapter *adapter, u8 *pbuf)
{
struct wifidirect_info *wdinfo = &adapter->wdinfo;
struct mlme_priv *mlme = &adapter->mlmepriv;
u8 build_ie_by_self = 0;
u32 len = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
goto exit;
#ifdef CONFIG_IOCTL_CFG80211
if (_TRUE == wdinfo->wfd_info->wfd_enable)
#endif
build_ie_by_self = 1;
if (build_ie_by_self)
len = build_probe_resp_wfd_ie(wdinfo, pbuf, 0);
#ifdef CONFIG_IOCTL_CFG80211
else if (mlme->wfd_probe_resp_ie && mlme->wfd_probe_resp_ie_len > 0) {
len = mlme->wfd_probe_resp_ie_len;
_rtw_memcpy(pbuf, mlme->wfd_probe_resp_ie, len);
}
#endif
exit:
return len;
}
u32 rtw_append_assoc_req_wfd_ie(_adapter *adapter, u8 *pbuf)
{
struct wifidirect_info *wdinfo = &adapter->wdinfo;
struct mlme_priv *mlme = &adapter->mlmepriv;
u8 build_ie_by_self = 0;
u32 len = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
goto exit;
#ifdef CONFIG_IOCTL_CFG80211
if (_TRUE == wdinfo->wfd_info->wfd_enable)
#endif
build_ie_by_self = 1;
if (build_ie_by_self)
len = build_assoc_req_wfd_ie(wdinfo, pbuf);
#ifdef CONFIG_IOCTL_CFG80211
else if (mlme->wfd_assoc_req_ie && mlme->wfd_assoc_req_ie_len > 0) {
len = mlme->wfd_assoc_req_ie_len;
_rtw_memcpy(pbuf, mlme->wfd_assoc_req_ie, len);
}
#endif
exit:
return len;
}
u32 rtw_append_assoc_resp_wfd_ie(_adapter *adapter, u8 *pbuf)
{
struct wifidirect_info *wdinfo = &adapter->wdinfo;
struct mlme_priv *mlme = &adapter->mlmepriv;
u8 build_ie_by_self = 0;
u32 len = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
goto exit;
#ifdef CONFIG_IOCTL_CFG80211
if (_TRUE == wdinfo->wfd_info->wfd_enable)
#endif
build_ie_by_self = 1;
if (build_ie_by_self)
len = build_assoc_resp_wfd_ie(wdinfo, pbuf);
#ifdef CONFIG_IOCTL_CFG80211
else if (mlme->wfd_assoc_resp_ie && mlme->wfd_assoc_resp_ie_len > 0) {
len = mlme->wfd_assoc_resp_ie_len;
_rtw_memcpy(pbuf, mlme->wfd_assoc_resp_ie, len);
}
#endif
exit:
return len;
}
#endif /* CONFIG_WFD */
void init_wifidirect_info(_adapter *padapter, enum P2P_ROLE role)
{
struct wifidirect_info *pwdinfo;
#ifdef CONFIG_WFD
struct wifi_display_info *pwfd_info = &padapter->wfd_info;
#endif
pwdinfo = &padapter->wdinfo;
pwdinfo->padapter = padapter;
if (role == P2P_ROLE_DEVICE)
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
else if (role == P2P_ROLE_CLIENT)
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
else if (role == P2P_ROLE_GO)
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
/* Use the OFDM rate in the P2P probe response frame. ( 6(B), 9(B), 12, 18, 24, 36, 48, 54 ) */
pwdinfo->support_rate[0] = 0x8c; /* 6(B) */
pwdinfo->support_rate[1] = 0x92; /* 9(B) */
pwdinfo->support_rate[2] = 0x18; /* 12 */
pwdinfo->support_rate[3] = 0x24; /* 18 */
pwdinfo->support_rate[4] = 0x30; /* 24 */
pwdinfo->support_rate[5] = 0x48; /* 36 */
pwdinfo->support_rate[6] = 0x60; /* 48 */
pwdinfo->support_rate[7] = 0x6c; /* 54 */
_rtw_memcpy((void *) pwdinfo->p2p_wildcard_ssid, "DIRECT-", 7);
#ifdef CONFIG_WFD
pwdinfo->wfd_info = pwfd_info;
#endif /* CONFIG_WFD */
pwdinfo->wfd_tdls_enable = 0;
}
void _rtw_p2p_set_role(struct wifidirect_info *wdinfo, enum P2P_ROLE role)
{
if (wdinfo->role != role) {
wdinfo->role = role;
rtw_mi_update_iface_status(&(wdinfo->padapter->mlmepriv), 0);
}
}
#ifdef CONFIG_DBG_P2P
/**
* rtw_p2p_role_txt - Get the p2p role name as a text string
* @role: P2P role
* Returns: The state name as a printable text string
*/
const char *rtw_p2p_role_txt(enum P2P_ROLE role)
{
switch (role) {
case P2P_ROLE_DISABLE:
return "P2P_ROLE_DISABLE";
case P2P_ROLE_DEVICE:
return "P2P_ROLE_DEVICE";
case P2P_ROLE_CLIENT:
return "P2P_ROLE_CLIENT";
case P2P_ROLE_GO:
return "P2P_ROLE_GO";
default:
return "UNKNOWN";
}
}
/**
* rtw_p2p_state_txt - Get the p2p state name as a text string
* @state: P2P state
* Returns: The state name as a printable text string
*/
const char *rtw_p2p_state_txt(enum P2P_STATE state)
{
switch (state) {
case P2P_STATE_NONE:
return "P2P_STATE_NONE";
case P2P_STATE_IDLE:
return "P2P_STATE_IDLE";
case P2P_STATE_LISTEN:
return "P2P_STATE_LISTEN";
case P2P_STATE_FIND_PHASE_SEARCH:
return "P2P_STATE_FIND_PHASE_SEARCH";
case P2P_STATE_GONEGO_OK:
return "P2P_STATE_GONEGO_OK";
default:
return "UNKNOWN";
}
}
#if 0
void dbg_rtw_p2p_restore_state(struct wifidirect_info *wdinfo, const char *caller, int line)
{
if (wdinfo->pre_p2p_state != -1) {
RTW_INFO("[CONFIG_DBG_P2P]%s:%d restore from %s to %s\n", caller, line
, p2p_state_str[wdinfo->p2p_state], p2p_state_str[wdinfo->pre_p2p_state]
);
_rtw_p2p_restore_state(wdinfo);
} else {
RTW_INFO("[CONFIG_DBG_P2P]%s:%d restore no pre state, cur state %s\n", caller, line
, p2p_state_str[wdinfo->p2p_state]
);
}
}
#endif
void dbg_rtw_p2p_set_role(struct wifidirect_info *wdinfo, enum P2P_ROLE role, const char *caller, int line)
{
if (wdinfo->role != role) {
enum P2P_ROLE old_role = wdinfo->role;
_rtw_p2p_set_role(wdinfo, role);
RTW_INFO("[CONFIG_DBG_P2P]%s:%d set_role from %s to %s\n", caller, line
, rtw_p2p_role_txt(old_role), rtw_p2p_role_txt(wdinfo->role)
);
} else {
RTW_INFO("[CONFIG_DBG_P2P]%s:%d set_role to same role %s\n", caller, line
, rtw_p2p_role_txt(wdinfo->role)
);
}
}
#endif /* CONFIG_DBG_P2P */
int rtw_p2p_enable(_adapter *padapter, enum P2P_ROLE role)
{
int ret = _SUCCESS;
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
if (role == P2P_ROLE_DEVICE || role == P2P_ROLE_CLIENT || role == P2P_ROLE_GO) {
#ifndef RTW_USE_CFG80211_REPORT_PROBE_REQ
#if defined(CONFIG_CONCURRENT_MODE) && !RTW_P2P_GROUP_INTERFACE
/* Commented by Albert 2011/12/30 */
/* The driver just supports 1 P2P group operation. */
/* So, this function will do nothing if the buddy adapter had enabled the P2P function. */
/*if(!rtw_p2p_chk_state(pbuddy_wdinfo, P2P_STATE_NONE))
return ret;*/
/* Only selected interface can be P2P interface */
if (padapter->iface_id != padapter->registrypriv.sel_p2p_iface) {
RTW_ERR("%s, iface_id:%d is not P2P interface!\n", __func__, padapter->iface_id);
ret = _FAIL;
return ret;
}
#endif
#endif
/* leave IPS/Autosuspend */
if (_FAIL == rtw_pwr_wakeup(padapter)) {
ret = _FAIL;
goto exit;
}
/* The P2P device does not need to remove the CCK rate of the
* adapter as it can act as an STA.
*/
if (role != P2P_ROLE_DEVICE)
update_tx_basic_rate(padapter, WLAN_MD_11AGN);
/* Enable P2P function */
init_wifidirect_info(padapter, role);
#ifdef CONFIG_IOCTL_CFG80211
adapter_wdev_data(padapter)->p2p_enabled = _TRUE;
#endif
#if 0
rtw_hal_set_phydm_var(padapter, HAL_PHYDM_P2P_STATE, NULL, _TRUE);
#ifdef CONFIG_WFD
if (rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
rtw_hal_set_phydm_var(padapter, HAL_PHYDM_WIFI_DISPLAY_STATE, NULL, _TRUE);
#endif
#endif
} else if (role == P2P_ROLE_DISABLE) {
#ifdef CONFIG_IOCTL_CFG80211
adapter_wdev_data(padapter)->p2p_enabled = _FALSE;
#endif
pwdinfo->listen_channel = 0;
/* Disable P2P function */
if (!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DISABLE))
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DISABLE);
else
RTW_ERR("%s, disable P2P when p2p role is P2P_ROLE_DISABLE!\n", __func__);
#if 0
rtw_hal_set_phydm_var(padapter, HAL_PHYDM_P2P_STATE, NULL, _FALSE);
#ifdef CONFIG_WFD
if (rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
rtw_hal_set_phydm_var(padapter, HAL_PHYDM_WIFI_DISPLAY_STATE, NULL, _FALSE);
#endif
#endif
if (_FAIL == rtw_pwr_wakeup(padapter)) {
ret = _FAIL;
goto exit;
}
/* Restore to initial setting. */
update_tx_basic_rate(padapter, padapter->registrypriv.wireless_mode);
}
exit:
return ret;
}
#endif /* CONFIG_P2P */
|
2301_81045437/rtl8852be
|
core/rtw_p2p.c
|
C
|
agpl-3.0
| 87,623
|
/******************************************************************************
*
* Copyright(c) 2019 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_PHL_C_
#include <drv_types.h>
/***************** export API to osdep/core*****************/
static const char *const _band_cap_str[] = {
/* BIT0 */"2G",
/* BIT1 */"5G",
/* BIT2 */"6G",
};
static const char *const _bw_cap_str[] = {
/* BIT0 */"20M",
/* BIT1 */"40M",
/* BIT2 */"80M",
/* BIT3 */"160M",
/* BIT4 */"80_80M",
/* BIT5 */"5M",
/* BIT6 */"10M",
};
static const char *const _proto_cap_str[] = {
/* BIT0 */"b",
/* BIT1 */"g",
/* BIT2 */"n",
/* BIT3 */"ac",
};
static const char *const _wl_func_str[] = {
/* BIT0 */"P2P",
/* BIT1 */"MIRACAST",
/* BIT2 */"TDLS",
/* BIT3 */"FTM",
};
static const char *const hw_cap_str = "[HW-CAP]";
void rtw_hw_dump_hal_spec(void *sel, struct dvobj_priv *dvobj)
{
struct hal_spec_t *hal_spec = GET_HAL_SPEC(dvobj);
int i;
RTW_PRINT_SEL(sel, "%s ic_name:%s\n", hw_cap_str, hal_spec->ic_name);
RTW_PRINT_SEL(sel, "%s macid_num:%u\n", hw_cap_str, hal_spec->macid_num);
RTW_PRINT_SEL(sel, "%s sec_cap:0x%02x\n", hw_cap_str, hal_spec->sec_cap);
RTW_PRINT_SEL(sel, "%s sec_cam_ent_num:%u\n", hw_cap_str, hal_spec->sec_cam_ent_num);
RTW_PRINT_SEL(sel, "%s rfpath_num_2g:%u\n", hw_cap_str, hal_spec->rfpath_num_2g);
RTW_PRINT_SEL(sel, "%s rfpath_num_5g:%u\n", hw_cap_str, hal_spec->rfpath_num_5g);
RTW_PRINT_SEL(sel, "%s rf_reg_path_num:%u\n", hw_cap_str, hal_spec->rf_reg_path_num);
RTW_PRINT_SEL(sel, "%s max_tx_cnt:%u\n", hw_cap_str, hal_spec->max_tx_cnt);
RTW_PRINT_SEL(sel, "%s tx_nss_num:%u\n", hw_cap_str, hal_spec->tx_nss_num);
RTW_PRINT_SEL(sel, "%s rx_nss_num:%u\n", hw_cap_str, hal_spec->rx_nss_num);
RTW_PRINT_SEL(sel, "%s band_cap:", hw_cap_str);
for (i = 0; i < BAND_CAP_BIT_NUM; i++) {
if (((hal_spec->band_cap) >> i) & BIT0 && _band_cap_str[i])
_RTW_PRINT_SEL(sel, "%s ", _band_cap_str[i]);
}
_RTW_PRINT_SEL(sel, "\n");
RTW_PRINT_SEL(sel, "%s bw_cap:", hw_cap_str);
for (i = 0; i < BW_CAP_BIT_NUM; i++) {
if (((hal_spec->bw_cap) >> i) & BIT0 && _bw_cap_str[i])
_RTW_PRINT_SEL(sel, "%s ", _bw_cap_str[i]);
}
_RTW_PRINT_SEL(sel, "\n");
RTW_PRINT_SEL(sel, "%s proto_cap:", hw_cap_str);
for (i = 0; i < PROTO_CAP_BIT_NUM; i++) {
if (((hal_spec->proto_cap) >> i) & BIT0 && _proto_cap_str[i])
_RTW_PRINT_SEL(sel, "%s ", _proto_cap_str[i]);
}
_RTW_PRINT_SEL(sel, "\n");
#if 0 /*GEORGIA_TODO_FIXIT*/
RTW_PRINT_SEL(sel, "%s txgi_max:%u\n", hw_cap_str, hal_spec->txgi_max);
RTW_PRINT_SEL(sel, "%s txgi_pdbm:%u\n", hw_cap_str, hal_spec->txgi_pdbm);
#endif
RTW_PRINT_SEL(sel, "%s wl_func:", hw_cap_str);
for (i = 0; i < WL_FUNC_BIT_NUM; i++) {
if (((hal_spec->wl_func) >> i) & BIT0 && _wl_func_str[i])
_RTW_PRINT_SEL(sel, "%s ", _wl_func_str[i]);
}
_RTW_PRINT_SEL(sel, "\n");
#if 0 /*GEORGIA_TODO_FIXIT*/
RTW_PRINT_SEL(sel, "%s pg_txpwr_saddr:0x%X\n", hw_cap_str, hal_spec->pg_txpwr_saddr);
RTW_PRINT_SEL(sel, "%s pg_txgi_diff_factor:%u\n", hw_cap_str, hal_spec->pg_txgi_diff_factor);
#endif
}
void rtw_dump_phl_sta_info(void *sel, struct sta_info *sta)
{
struct rtw_phl_stainfo_t *phl_sta = sta->phl_sta;
RTW_PRINT_SEL(sel, "[PHL STA]- role-idx: %d\n", phl_sta->wrole->id);
RTW_PRINT_SEL(sel, "[PHL STA]- mac_addr:"MAC_FMT"\n", MAC_ARG(phl_sta->mac_addr));
RTW_PRINT_SEL(sel, "[PHL STA]- aid: %d\n", phl_sta->aid);
RTW_PRINT_SEL(sel, "[PHL STA]- macid: %d\n", phl_sta->macid);
RTW_PRINT_SEL(sel, "[PHL STA]- wifi_band: %d\n", phl_sta->chandef.band);
RTW_PRINT_SEL(sel, "[PHL STA]- bw: %d\n", phl_sta->chandef.bw);
RTW_PRINT_SEL(sel, "[PHL STA]- chan: %d\n", phl_sta->chandef.chan);
RTW_PRINT_SEL(sel, "[PHL STA]- offset: %d\n", phl_sta->chandef.offset);
}
inline bool rtw_hw_chk_band_cap(struct dvobj_priv *dvobj, u8 cap)
{
return GET_HAL_SPEC(dvobj)->band_cap & cap;
}
inline bool rtw_hw_chk_bw_cap(struct dvobj_priv *dvobj, u8 cap)
{
return GET_HAL_SPEC(dvobj)->bw_cap & cap;
}
inline bool rtw_hw_chk_proto_cap(struct dvobj_priv *dvobj, u8 cap)
{
return GET_HAL_SPEC(dvobj)->proto_cap & cap;
}
inline bool rtw_hw_chk_wl_func(struct dvobj_priv *dvobj, u8 func)
{
return GET_HAL_SPEC(dvobj)->wl_func & func;
}
inline bool rtw_hw_is_band_support(struct dvobj_priv *dvobj, u8 band)
{
return GET_HAL_SPEC(dvobj)->band_cap & band_to_band_cap(band);
}
inline bool rtw_hw_is_bw_support(struct dvobj_priv *dvobj, u8 bw)
{
return GET_HAL_SPEC(dvobj)->bw_cap & ch_width_to_bw_cap(bw);
}
inline bool rtw_hw_is_wireless_mode_support(struct dvobj_priv *dvobj, u8 mode)
{
u8 proto_cap = GET_HAL_SPEC(dvobj)->proto_cap;
if (mode == WLAN_MD_11B)
if ((proto_cap & PROTO_CAP_11B) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_2G))
return 1;
if (mode == WLAN_MD_11G)
if ((proto_cap & PROTO_CAP_11G) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_2G))
return 1;
if (mode == WLAN_MD_11A)
if ((proto_cap & PROTO_CAP_11G) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_5G))
return 1;
#ifdef CONFIG_80211N_HT
if (mode == WLAN_MD_11N)
if (proto_cap & PROTO_CAP_11N)
return 1;
#endif
#ifdef CONFIG_80211AC_VHT
if (mode == WLAN_MD_11AC)
if ((proto_cap & PROTO_CAP_11AC) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_5G))
return 1;
#endif
#ifdef CONFIG_80211AX_HE
if (mode == WLAN_MD_11AX)
if (proto_cap & PROTO_CAP_11AX)
return 1;
#endif
return 0;
}
inline u8 rtw_hw_get_wireless_mode(struct dvobj_priv *dvobj)
{
u8 proto_cap = GET_HAL_SPEC(dvobj)->proto_cap;
u8 band_cap = GET_HAL_SPEC(dvobj)->band_cap;
u8 wireless_mode = 0;
if(proto_cap & PROTO_CAP_11B)
wireless_mode |= WLAN_MD_11B;
if(proto_cap & PROTO_CAP_11G)
wireless_mode |= WLAN_MD_11G;
if(band_cap & BAND_CAP_5G)
wireless_mode |= WLAN_MD_11A;
#ifdef CONFIG_80211N_HT
if(proto_cap & PROTO_CAP_11N)
wireless_mode |= WLAN_MD_11N;
#endif
#ifdef CONFIG_80211AC_VHT
if(proto_cap & PROTO_CAP_11AC)
wireless_mode |= WLAN_MD_11AC;
#endif
#ifdef CONFIG_80211AX_HE
if(proto_cap & PROTO_CAP_11AX) {
wireless_mode |= WLAN_MD_11AX;
}
#endif
return wireless_mode;
}
inline u8 rtw_hw_get_band_type(struct dvobj_priv *dvobj)
{
u8 band_cap = GET_HAL_SPEC(dvobj)->band_cap;
u8 band_type = 0;
if(band_cap & BAND_CAP_2G)
band_type |= BAND_CAP_2G;
#if CONFIG_IEEE80211_BAND_5GHZ
if(band_cap & BAND_CAP_5G)
band_type |= BAND_CAP_5G;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
if(band_cap & BAND_CAP_6G)
band_type |= BAND_CAP_6G;
#endif
return band_type;
}
inline bool rtw_hw_is_mimo_support(struct dvobj_priv *dvobj)
{
if ((GET_HAL_TX_NSS(dvobj) == 1) &&
(GET_HAL_RX_NSS(dvobj) == 1))
return 0;
return 1;
}
/*
* rtw_hw_largest_bw - starting from in_bw, get largest bw supported by HAL
* @adapter:
* @in_bw: starting bw, value of enum channel_width
*
* Returns: value of enum channel_width
*/
u8 rtw_hw_largest_bw(struct dvobj_priv *dvobj, u8 in_bw)
{
for (; in_bw > CHANNEL_WIDTH_20; in_bw--) {
if (rtw_hw_is_bw_support(dvobj, in_bw))
break;
}
if (!rtw_hw_is_bw_support(dvobj, in_bw))
rtw_warn_on(1);
return in_bw;
}
u8 rtw_hw_get_mac_addr(struct dvobj_priv *dvobj, u8 *hw_mac_addr)
{
if (rtw_phl_get_mac_addr_efuse(dvobj->phl, hw_mac_addr) != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s failed\n", __func__);
return _FAIL;
}
return _SUCCESS;
}
/***************** register hw *****************/
#if 0 /*GEORGIA_TODO_ADDIT*/
#define hal_trx_error_msg(ops_fun) \
RTW_PRINT("### %s - Error : Please hook hal_trx_ops.%s ###\n", __FUNCTION__, ops_fun)
static u8 rtw_hw_trx_ops_check(struct hal_com_t *hal_com)
{
u8 rst = _SUCCESS;
if (!hal_com->trx_ops.intf_hal_configure) {
hal_trx_error_msg("intf_hal_configure");
rst = _FAIL;
}
if (!hal_com->trx_ops.get_txdesc_len) {
hal_trx_error_msg("get_txdesc_len");
rst = _FAIL;
}
if (!hal_com->trx_ops.fill_txdesc_h2c) {
hal_trx_error_msg("fill_txdesc_h2c");
rst = _FAIL;
}
if (!hal_com->trx_ops.fill_txdesc_fwdl) {
hal_trx_error_msg("fill_txdesc_fwdl");
rst = _FAIL;
}
if (!hal_com->trx_ops.fill_txdesc_pkt) {
hal_trx_error_msg("fill_txdesc_pkt");
rst = _FAIL;
}
#if defined(CONFIG_USB_HCI)
if (!hal_com->trx_ops.get_bulkout_id) {
hal_trx_error_msg("get_bulkout_id");
rst = _FAIL;
}
#endif
#if 0 /*GEORGIA_TODO_ADDIT*/
if (!hal_com->trx_ops.init_xmit) {
hal_trx_error_msg("init_xmit");
rst = _FAIL;
}
if (!hal_com->trx_ops.init_recv) {
hal_trx_error_msg("init_recv");
rst = _FAIL;
}
#if defined(CONFIG_PCI_HCI)
if (!hal_com->trx_ops.check_enough_txdesc) {
hal_trx_error_msg("check_enough_txdesc");
rst = _FAIL;
}
if (!hal_com->trx_ops.trxbd_init) {
hal_trx_error_msg("trxbd_init");
rst = _FAIL;
}
if (!hal_com->trx_ops.trxbd_deinit) {
hal_trx_error_msg("trxbd_deinit");
rst = _FAIL;
}
if (!hal_com->trx_ops.trxbd_reset) {
hal_trx_error_msg("trxbd_reset");
rst = _FAIL;
}
if (!hal_com->trx_ops.interrupt_handler) {
hal_trx_error_msg("interrupt_handler");
rst = _FAIL;
}
#endif
#if defined(CONFIG_USB_HCI)
#ifdef CONFIG_SUPPORT_USB_INT
if (!hal_com->trx_ops.interrupt_handler) {
hal_trx_error_msg("interrupt_handler");
rst = _FAIL;
}
#endif
#endif
if (!hal_com->trx_ops.enable_interrupt) {
hal_trx_error_msg("enable_interrupt");
rst = _FAIL;
}
if (!hal_com->trx_ops.disable_interrupt) {
hal_trx_error_msg("disable_interrupt");
rst = _FAIL;
}
#if defined(CONFIG_SDIO_HCI)
if (!hal_com->trx_ops.interrupt_handler) {
hal_trx_error_msg("interrupt_handler");
rst = _FAIL;
}
if (!hal_com->trx_ops.get_tx_addr) {
hal_trx_error_msg("get_tx_addr");
rst = _FAIL;
}
#endif
#endif
return rst;
}
#endif
u8 rtw_core_deregister_phl_msg(struct dvobj_priv *dvobj)
{
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
psts = rtw_phl_msg_hub_deregister_recver(dvobj->phl, MSG_RECV_CORE);
if(psts == RTW_PHL_STATUS_FAILURE) {
RTW_ERR("%s failed\n", __func__);
return _FAIL;
}
return _SUCCESS;
}
void rtw_hw_deinit(struct dvobj_priv *dvobj)
{
if (dvobj->phl) {
rtw_phl_trx_free(dvobj->phl);
rtw_core_deregister_phl_msg(dvobj);
rtw_phl_watchdog_deinit(dvobj->phl);
rtw_clear_phl_regulation_ctx(dvobj);
rtw_phl_deinit(dvobj->phl);
}
#ifdef DBG_PHL_MEM_ALLOC
RTW_INFO("[PHL-MEM] %s PHL memory :%d\n", __func__,
ATOMIC_READ(&(dvobj->phl_mem)));
#endif
}
#if 0
void dump_ic_spec(struct dvobj_priv *dvobj)
{
struct hal_com_t *hal_com = dvobj->hal_com;
struct hal_spec_t *hal_spec = &hal_com->hal_spec;
RTW_INFO("dvobj:%p,hal:%p(size:%d), hal_com:%p, hal_spec:%p\n",
dvobj, dvobj->hal_info, dvobj->hal_info_sz, hal_com, hal_spec);
RTW_INFO("dvobj:%p, hal_com:%p, hal_spec:%p\n", dvobj, GET_PHL_COM(dvobj), GET_HAL_SPEC(dvobj));
RTW_INFO("[IC-SPEC]- band_cap: %x\n", GET_HAL_SPEC(dvobj)->band_cap);
}
#endif
#if 0 /*GEORGIA_TODO_FIXIT*/
void rtw_hw_intf_cfg(struct dvobj_priv *dvobj, struct hal_com_t *hal_com)
{
struct hci_info_st hci_info;
#ifdef CONFIG_PCI_HCI
if (dvobj->interface_type == RTW_HCI_PCIE) {
PPCI_DATA pci = dvobj_to_pci(dvobj);
//hci_info.
}
#endif
#ifdef CONFIG_USB_HCI
if (dvobj->interface_type == RTW_HCI_USB) {
PUSB_DATA usb = dvobj_to_usb(dvobj);
#if 0
u8 usb_speed; /* 1.1, 2.0 or 3.0 */
u16 usb_bulkout_size;
u8 nr_endpoint; /*MAX_ENDPOINT_NUM*/
/* Bulk In , Out Pipe information */
int RtInPipe[MAX_BULKIN_NUM];
u8 RtNumInPipes;
int RtOutPipe[MAX_BULKOUT_NUM];
u8 RtNumOutPipes;
#endif
//hci_info
}
#endif
#ifdef CONFIG_SDIO_HCI
if (dvobj->interface_type == RTW_HCI_SDIO) {
PSDIO_DATA sdio = dvobj_to_sdio(dvobj);
hci_info.clock = sdio->clock;
hci_info.timing = sdio->timing;
hci_info.sd3_bus_mode = sdio->sd3_bus_mode;
hci_info.block_sz = sdio->block_transfer_len;
hci_info.align_sz = sdio->block_transfer_len;
}
#endif
rtw_hal_intf_config(hal_com, &hci_info);
}
#endif
static void _hw_ic_info_cfg(struct dvobj_priv *dvobj, struct rtw_ic_info *ic_info)
{
_rtw_memset(ic_info, 0,sizeof(struct rtw_ic_info));
ic_info->ic_id = dvobj->ic_id;
ic_info->hci_type = dvobj->interface_type;
#ifdef CONFIG_PCI_HCI
if (dvobj->interface_type == RTW_HCI_PCIE) {
PPCI_DATA pci = dvobj_to_pci(dvobj);
}
#endif
#ifdef CONFIG_USB_HCI
if (dvobj->interface_type == RTW_HCI_USB) {
PUSB_DATA usb = dvobj_to_usb(dvobj);
ic_info->usb_info.usb_speed = usb->usb_speed;
ic_info->usb_info.usb_bulkout_size = usb->usb_bulkout_size;
ic_info->usb_info.inep_num = usb->RtNumInPipes;
ic_info->usb_info.outep_num = usb->RtNumOutPipes;
}
#endif
#ifdef CONFIG_SDIO_HCI
if (dvobj->interface_type == RTW_HCI_SDIO) {
PSDIO_DATA sdio = dvobj_to_sdio(dvobj);
ic_info->sdio_info.clock = sdio->clock;
ic_info->sdio_info.timing = sdio->timing;
ic_info->sdio_info.sd3_bus_mode = sdio->sd3_bus_mode;
ic_info->sdio_info.io_align_sz = 4;
ic_info->sdio_info.block_sz = sdio->block_transfer_len;
ic_info->sdio_info.tx_align_sz = sdio->block_transfer_len;
ic_info->sdio_info.tx_512_by_byte_mode =
(sdio->max_byte_size >= 512) ? true : false;
}
#endif
}
static void core_hdl_phl_evt(struct dvobj_priv *dvobj, u16 evt_id)
{
_adapter *iface;
u8 i = 0;
if(evt_id == MSG_EVT_BCN_RESEND) {
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if(!rtw_is_adapter_up(iface))
continue;
if(MLME_IS_MESH(iface)
|| MLME_IS_AP(iface)
|| MLME_IS_ADHOC_MASTER(iface)) {
if (send_beacon(iface) == _FAIL)
RTW_ERR(ADPT_FMT" issue_beacon, fail!\n",
ADPT_ARG(iface));
}
}
}
else if (evt_id == MSG_EVT_SER_L2) {
RTW_INFO("RECV PHL MSG_EVT_SER_L2\n");
}
#ifdef CONFIG_XMIT_ACK
else if (evt_id == MSG_EVT_CCX_REPORT_TX_OK) {
iface = dvobj_get_primary_adapter(dvobj);
rtw_ack_tx_done(&iface->xmitpriv, RTW_SCTX_DONE_SUCCESS);
}
else if (evt_id == MSG_EVT_CCX_REPORT_TX_FAIL) {
iface = dvobj_get_primary_adapter(dvobj);
rtw_ack_tx_done(&iface->xmitpriv, RTW_SCTX_DONE_CCX_PKT_FAIL);
}
#endif
else {
RTW_INFO("%s evt_id :%d\n", __func__, evt_id);
}
}
void core_handler_phl_msg(void *drv_priv, struct phl_msg *msg)
{
struct dvobj_priv *dvobj = (struct dvobj_priv *)drv_priv;
u8 mdl_id = MSG_MDL_ID_FIELD(msg->msg_id);
u16 evt_id = MSG_EVT_ID_FIELD(msg->msg_id);
switch(mdl_id) {
case PHL_MDL_RX:
case PHL_MDL_SER:
case PHL_MDL_WOW:
core_hdl_phl_evt(dvobj, evt_id);
break;
default:
RTW_ERR("%s mdl_id :%d not support\n", __func__, mdl_id);
break;
}
}
u8 rtw_core_register_phl_msg(struct dvobj_priv *dvobj)
{
struct phl_msg_receiver ctx = {0};
u8 imr[] = {PHL_MDL_RX, PHL_MDL_SER, PHL_MDL_WOW};
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
ctx.incoming_evt_notify = core_handler_phl_msg;
ctx.priv = (void*)dvobj;
psts = rtw_phl_msg_hub_register_recver(dvobj->phl, &ctx, MSG_RECV_CORE);
if(psts == RTW_PHL_STATUS_FAILURE) {
RTW_ERR("phl_msg_hub_register failed\n");
return _FAIL;
}
psts = rtw_phl_msg_hub_update_recver_mask(dvobj->phl,
MSG_RECV_CORE, imr, sizeof(imr), false);
if(psts == RTW_PHL_STATUS_FAILURE) {
RTW_ERR("phl_msg_hub_update_recver_mask failed\n");
return _FAIL;
}
return _SUCCESS;
}
/*RTW_WKARD_CORE_RSSI_V1*/
s8 rtw_phl_rssi_to_dbm(u8 rssi)
{
return rssi - PHL_MAX_RSSI;
}
#ifdef CONFIG_MCC_MODE
u8 rtw_hw_mcc_chk_inprogress(struct _ADAPTER *a)
{
struct dvobj_priv *d;
void *phl;
u8 ret = _FALSE;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
goto exit;
ret = rtw_phl_mr_query_mcc_inprogress(phl, a->phl_role, RTW_PHL_MCC_CHK_INPROGRESS);
exit:
return ret;
}
#ifdef CONFIG_P2P_PS
static int _mcc_update_noa(void *priv, struct rtw_phl_mcc_noa *param)
{
struct dvobj_priv *dvobj = (struct dvobj_priv *) priv;
struct rtw_wifi_role_t *wrole = NULL;
struct _ADAPTER *a = NULL;
struct wifidirect_info *wdinfo;
u8 id = 0;
u8 ret = _SUCCESS;
#ifdef CONFIG_PHL_P2PPS
struct rtw_phl_noa_desc desc= {0};
#endif
wrole = param->wrole;
if (wrole == NULL) {
RTW_ERR("%s wrole is NULL\n", __func__);
ret = _FAIL;
goto exit;
}
id = wrole->id;
if (id >= CONFIG_IFACE_NUMBER) {
RTW_ERR("%s error id (%d)\n", __func__, id);
ret = _FAIL;
goto exit;
}
a = dvobj->padapters[id];
if (a == NULL) {
RTW_ERR("%s adapter(%d) is NULL\n", __func__, id);
ret = _FAIL;
goto exit;
}
/* by pass non-GO case */
if (!MLME_IS_GO(a))
goto exit;
wdinfo = &a->wdinfo;
RTW_INFO(FUNC_ADPT_FMT":(%d)\n", FUNC_ADPT_ARG(a), id);
RTW_INFO("start_t_h=0x%02x,start_t_l=0x%02x\n", param->start_t_h, param->start_t_l);
RTW_INFO("dur=0x%d,cnt=0x%d,interval=0x%d\n", param->dur, param->cnt, param->interval);
#ifdef CONFIG_PHL_P2PPS
/* enable TSF32 toggle */
desc.tag = P2PPS_TRIG_MCC;
desc.enable = true;
desc.duration = param->dur * NET80211_TU_TO_US;
desc.interval = param->interval * NET80211_TU_TO_US;
desc.start_t_h = param->start_t_h;
desc.start_t_l = param->start_t_l;
desc.count = param->cnt;
desc.w_role = param->wrole;
if (rtw_phl_p2pps_noa_update(dvobj->phl, &desc) != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s rtw_phl_p2pps_noa_update fail\n", __func__);
ret = _FAIL;
goto exit;
}
#endif
/* update NoA IE */
wdinfo->noa_index = wdinfo->noa_index + 1;
wdinfo->noa_num = 1;
wdinfo->noa_count[0] = param->cnt;
wdinfo->noa_duration[0] =param->dur * NET80211_TU_TO_US;
wdinfo->noa_interval[0] = param->interval * NET80211_TU_TO_US;
wdinfo->noa_start_time[0] = param->start_t_l;
rtw_update_beacon(a, _VENDOR_SPECIFIC_IE_, P2P_OUI, _TRUE, RTW_CMDF_DIRECTLY);
exit:
return ret;
}
#endif
/* default setting */
static int _mcc_get_setting(void *priv, struct rtw_phl_mcc_setting_info *param)
{
struct dvobj_priv *dvobj = (struct dvobj_priv *) priv;
struct rtw_wifi_role_t *wrole = NULL;
struct _ADAPTER *a = NULL;
struct wifidirect_info *wdinfo;
u8 id = 0;
u8 ret = _SUCCESS;
wrole = param->wrole;
if (wrole == NULL) {
RTW_ERR("%s wrole is NULL\n", __func__);
ret = _FAIL;
goto exit;
}
id = wrole->id;
if (id >= CONFIG_IFACE_NUMBER) {
RTW_ERR("%s error id (%d)\n", __func__, id);
ret = _FAIL;
goto exit;
}
a = dvobj->padapters[id];
if (a == NULL) {
RTW_ERR("%s adapter(%d) is NULL\n", __func__, id);
ret = _FAIL;
goto exit;
}
if (MLME_IS_GO(a) || MLME_IS_GC(a))
param->dur = 50;
else
param->dur = 50;
if (MLME_IS_STA(a) || MLME_IS_GC(a))
param->tx_null_early = 5;
else
param->tx_null_early = NONSPECIFIC_SETTING;
RTW_INFO("%s: adapter(%d) dur=%d, tx_null_early=%d\n", __func__, id, param->dur, param->tx_null_early);
exit:
return ret;
}
struct rtw_phl_mcc_ops rtw_mcc_ops = {
.priv = NULL,
.mcc_update_noa = _mcc_update_noa,
.mcc_get_setting = _mcc_get_setting,
};
#endif
struct rtw_phl_mr_ops rtw_mr_ops = {
#ifdef CONFIG_MCC_MODE
.mcc_ops = &rtw_mcc_ops,
#endif
};
void rtw_core_register_mr_config(struct dvobj_priv *dvobj)
{
#ifdef CONFIG_MCC_MODE
rtw_mr_ops.mcc_ops->priv = (void *)dvobj;
#endif
rtw_phl_mr_ops_init(dvobj->phl, &rtw_mr_ops);
}
#if CONFIG_DFS
#ifdef CONFIG_ECSA_PHL
static void rtw_core_set_ecsa_ops(struct dvobj_priv *d)
{
struct rtw_phl_ecsa_ops ops = {0};
ops.priv = (void *)d;
ops.update_beacon = rtw_ecsa_update_beacon;
ops.update_chan_info = rtw_ecsa_mr_update_chan_info_by_role;
ops.check_ecsa_allow = rtw_ap_check_ecsa_allow;
ops.ecsa_complete = rtw_ecsa_complete;
ops.check_tx_resume_allow = rtw_ecsa_check_tx_resume_allow;
rtw_phl_ecsa_init_ops(GET_PHL_INFO(d), &ops);
}
#endif
#endif
u8 rtw_hw_init(struct dvobj_priv *dvobj)
{
u8 rst = _FAIL;
enum rtw_phl_status phl_status;
struct rtw_ic_info ic_info;
struct rtw_phl_evt_ops *evt_ops;
#ifdef DBG_PHL_MEM_ALLOC
ATOMIC_SET(&dvobj->phl_mem, 0);
#endif
_hw_ic_info_cfg(dvobj, &ic_info);
phl_status = rtw_phl_init(dvobj, &(dvobj->phl), &ic_info);
if ((phl_status != RTW_PHL_STATUS_SUCCESS) || (dvobj->phl == NULL)) {
RTW_ERR("%s - rtw_phl_init failed status(%d), dvobj->phl(%p)\n",
__func__, phl_status, dvobj->phl);
goto _free_hal;
}
dvobj->phl_com = rtw_phl_get_com(dvobj->phl);
/*init sw cap from registary*/
rtw_core_update_default_setting(dvobj);
/* sw & hw cap*/
rtw_phl_cap_pre_config(dvobj->phl);
#ifdef CONFIG_RX_PSTS_PER_PKT
rtw_phl_init_ppdu_sts_para(dvobj->phl_com,
_TRUE, _FALSE,
RTW_PHL_PSTS_FLTR_MGNT | RTW_PHL_PSTS_FLTR_DATA /*| RTW_PHL_PSTS_FLTR_CTRL*/
);
#endif
/*init datapath section*/
rtw_phl_trx_alloc(dvobj->phl);
evt_ops = &(dvobj->phl_com->evt_ops);
evt_ops->rx_process = rtw_core_rx_process;
evt_ops->tx_recycle = rtw_core_tx_recycle;
#ifdef CONFIG_RTW_IPS
evt_ops->set_rf_state = rtw_core_set_ips_state;
#endif
#ifdef CONFIG_GTK_OL
evt_ops->wow_handle_sec_info_update = rtw_update_gtk_ofld_info;
#endif
rtw_core_register_phl_msg(dvobj);
/* load wifi feature or capability from efuse*/
rtw_phl_preload(dvobj->phl);
rtw_phl_final_cap_decision(dvobj->phl);
/* after final cap decision */
rtw_core_register_mr_config(dvobj);
#if CONFIG_DFS
#ifdef CONFIG_ECSA_PHL
rtw_core_set_ecsa_ops(dvobj);
#endif
#endif
rtw_hw_dump_hal_spec(RTW_DBGDUMP, dvobj);
#ifdef CONFIG_CMD_GENERAL
rtw_phl_watchdog_init(dvobj->phl,
0,
rtw_core_watchdog_sw_hdlr,
rtw_core_watchdog_hw_hdlr);
#else
rtw_phl_job_reg_wdog(dvobj->phl,
rtw_dynamic_check_handlder,
dvobj, NULL, 0, "rtw_dm", PWR_BASIC_IO);
#endif
rtw_set_phl_regulation_ctx(dvobj);
rst = _SUCCESS;
return rst;
_free_hal :
rtw_hw_deinit(dvobj);
return rst;
}
u8 rtw_hw_start(struct dvobj_priv *dvobj)
{
if (dev_is_hw_start(dvobj))
return _FAIL;
if (rtw_phl_start(GET_PHL_INFO(dvobj)) != RTW_PHL_STATUS_SUCCESS)
return _FAIL;
#ifdef CONFIG_PCI_HCI
//intr init flag
dvobj_to_pci(dvobj)->irq_enabled = 1;
#endif
#ifdef CONFIG_CMD_GENERAL
rtw_phl_watchdog_start(dvobj->phl);
#endif
dev_set_hw_start(dvobj);
return _SUCCESS;
}
void rtw_hw_stop(struct dvobj_priv *dvobj)
{
if (!dev_is_hw_start(dvobj))
return;
#ifdef CONFIG_CMD_GENERAL
rtw_phl_watchdog_stop(dvobj->phl);
#endif
rtw_phl_stop(GET_PHL_INFO(dvobj));
#ifdef CONFIG_PCI_HCI
//intr init flag
dvobj_to_pci(dvobj)->irq_enabled = 0;
#endif
dev_clr_hw_start(dvobj);
}
bool rtw_hw_get_init_completed(struct dvobj_priv *dvobj)
{
return rtw_phl_is_init_completed(GET_PHL_INFO(dvobj));
}
bool rtw_hw_is_init_completed(struct dvobj_priv *dvobj)
{
return (rtw_phl_is_init_completed(GET_PHL_INFO(dvobj))) ? _TRUE : _FALSE;
}
#define NSS_VALID(nss) (nss > 0)
void rtw_hw_cap_init(struct dvobj_priv *dvobj)
{
struct hal_spec_t *hal_spec = GET_HAL_SPEC(dvobj);
struct registry_priv *regpriv =
&(dvobj_get_primary_adapter(dvobj)->registrypriv);
#ifdef DIRTY_FOR_WORK
dvobj->phl_com->tx_nss = hal_spec->tx_nss_num; /*GET_HAL_TX_NSS*/
if (NSS_VALID(regpriv->tx_nss))
dvobj->phl_com->tx_nss =
rtw_min(dvobj->phl_com->tx_nss, regpriv->tx_nss);
dvobj->phl_com->rx_nss = hal_spec->rx_nss_num; /*GET_HAL_RX_NSS*/
if (NSS_VALID(regpriv->rx_nss))
dvobj->phl_com->rx_nss =
rtw_min(dvobj->phl_com->rx_nss, regpriv->rx_nss);
dvobj->phl_com->rf_path_num = hal_spec->rf_reg_path_num; /*GET_HAL_RFPATH_NUM*/
dvobj->phl_com->rf_type = RF_2T2R; /*GET_HAL_RFPATH*/
/* GEORGIA_TODO move related control module to phl layer*/
/* macid_ctl moved to phl */
/* dvobj->macid_ctl.num = rtw_min(hal_spec->macid_num, MACID_NUM_SW_LIMIT); */
// Freddie ToDo: check macid_number from PHL?
dvobj->wow_ctl.wow_cap = hal_spec->wow_cap;
dvobj->cam_ctl.sec_cap = hal_spec->sec_cap;
dvobj->cam_ctl.num = rtw_min(hal_spec->sec_cam_ent_num, SEC_CAM_ENT_NUM_SW_LIMIT);
#endif
}
/*
* _ch_offset_drv2phl() - Convert driver channel offset to PHL type
* @ch_offset: channel offset, ref: HAL_PRIME_CHNL_OFFSET_*
*
* Return PHL channel offset type "enum chan_offset"
*/
static enum chan_offset _ch_offset_drv2phl(u8 ch_offset)
{
if (ch_offset == CHAN_OFFSET_UPPER)
return CHAN_OFFSET_UPPER;
if (ch_offset == CHAN_OFFSET_LOWER)
return CHAN_OFFSET_LOWER;
return CHAN_OFFSET_NO_EXT;
}
/*
* rtw_hw_set_ch_bw() - Set channel, bandwidth and channel offset
* @a: pointer of struct _ADAPTER
* @ch: channel
* @bw: bandwidth
* @offset: channel offset, ref: HAL_PRIME_CHNL_OFFSET_*
*
* Set channel, bandwidth and channel offset.
*
* Return 0 for success, otherwise fail
*/
int rtw_hw_set_ch_bw(struct _ADAPTER *a, u8 ch, enum channel_width bw,
u8 offset, u8 do_rfk)
{
enum rtw_phl_status status = RTW_PHL_STATUS_SUCCESS;
struct dvobj_priv *dvobj = adapter_to_dvobj(a);
int err = 0;
struct rtw_chan_def chdef = {0};
enum phl_cmd_type cmd_type = PHL_CMD_DIRECTLY;
u32 cmd_timeout = 0;
#ifdef CONFIG_MCC_MODE
if (rtw_hw_mcc_chk_inprogress(a)) {
RTW_WARN("under mcc, skip ch setting\n");
return err;
}
#endif
chdef.chan = ch;
chdef.bw = bw;
chdef.offset = offset;
chdef.band = (ch > 14) ? BAND_ON_5G : BAND_ON_24G;
_rtw_mutex_lock_interruptible(&dvobj->setch_mutex);
#ifdef DBG_CONFIG_CMD_DISP
if (a->cmd_type == 0xFF) {
cmd_type = PHL_CMD_DIRECTLY;
cmd_timeout = 0;
}
else {
cmd_type = a->cmd_type;
cmd_timeout = a->cmd_timeout;
}
#endif
status = rtw_phl_cmd_set_ch_bw(a->phl_role,
&chdef, do_rfk,
cmd_type, cmd_timeout);
if (status == RTW_PHL_STATUS_SUCCESS) {
if (a->bNotifyChannelChange)
RTW_INFO("[%s] ch = %d, offset = %d, bwmode = %d, success\n",
__FUNCTION__, ch, offset, bw);
} else {
err = -1;
RTW_ERR("%s: set ch(%u) bw(%u) offset(%u) FAIL!\n",
__func__, ch, bw, offset);
}
_rtw_mutex_unlock(&dvobj->setch_mutex);
return err;
}
void rtw_hw_update_chan_def(_adapter *adapter)
{
struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
struct rtw_phl_stainfo_t *phl_sta_self = NULL;
/*update chan_def*/
adapter->phl_role->chandef.band =
(mlmeext->chandef.chan > 14) ? BAND_ON_5G : BAND_ON_24G;
adapter->phl_role->chandef.chan = mlmeext->chandef.chan;
adapter->phl_role->chandef.bw = mlmeext->chandef.bw;
adapter->phl_role->chandef.offset = mlmeext->chandef.offset;
adapter->phl_role->chandef.center_ch = rtw_phl_get_center_ch(mlmeext->chandef.chan,
mlmeext->chandef.bw, mlmeext->chandef.offset);
/* ToDo: 80+80 BW & 160 BW */
phl_sta_self = rtw_phl_get_stainfo_self(adapter_to_dvobj(adapter)->phl, adapter->phl_role);
_rtw_memcpy(&phl_sta_self->chandef, &adapter->phl_role->chandef, sizeof(struct rtw_chan_def));
}
static void _dump_phl_role_info(struct rtw_wifi_role_t *wrole)
{
RTW_INFO("[WROLE]- role-idx: %d\n", wrole->id);
RTW_INFO("[WROLE]- type: %d\n", wrole->type);
RTW_INFO("[WROLE]- mstate: %d\n", wrole->mstate);
RTW_INFO("[WROLE]- mac_addr:"MAC_FMT"\n", MAC_ARG(wrole->mac_addr));
RTW_INFO("[WROLE]- hw_band: %d\n", wrole->hw_band);
RTW_INFO("[WROLE]- hw_port: %d\n", wrole->hw_port);
RTW_INFO("[WROLE]- hw_wmm: %d\n", wrole->hw_wmm);
RTW_INFO("[WROLE]- band: %d\n", wrole->chandef.band);
RTW_INFO("[WROLE]- chan: %d\n", wrole->chandef.chan);
RTW_INFO("[WROLE]- bw: %d\n", wrole->chandef.bw);
RTW_INFO("[WROLE]- offset: %d\n", wrole->chandef.offset);
// Freddie ToDo: MBSSID
}
u8 rtw_hw_iface_init(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
u8 phl_role_idx = INVALID_WIFI_ROLE_IDX;
u8 rst = _FAIL;
int chctx_num = 0;
#if defined(CONFIG_RTW_IPS) || defined(CONFIG_RTW_LPS)
bool ps_allow = _FALSE;
rtw_phl_ps_set_rt_cap(GET_PHL_INFO(dvobj), HW_BAND_0, ps_allow, PS_RT_CORE_INIT);
#endif
// Freddie ToDo: For AP mode, net type should be set to net device already.
/* will allocate phl self sta info */
phl_role_idx = rtw_phl_wifi_role_alloc(GET_PHL_INFO(dvobj),
adapter_mac_addr(adapter), PHL_RTYPE_STATION,
adapter->iface_id, &(adapter->phl_role), _FALSE);
if ((phl_role_idx == INVALID_WIFI_ROLE_IDX) ||
(adapter->phl_role == NULL)) {
RTW_ERR("rtw_phl_wifi_role_alloc failed\n");
rtw_warn_on(1);
goto _error;
}
/*init default value*/
#ifdef DBG_CONFIG_CMD_DISP
adapter->cmd_type = 0xFF;
adapter->cmd_timeout = 0;
#endif
rtw_hw_update_chan_def(adapter);
chctx_num = rtw_phl_mr_get_chanctx_num(GET_PHL_INFO(dvobj), adapter->phl_role);
if (chctx_num == 0) {
if (rtw_phl_cmd_set_ch_bw(adapter->phl_role,
&(adapter->phl_role->chandef),
_FALSE,
PHL_CMD_WAIT, 0) != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s init ch failed\n", __func__);
}
}
_dump_phl_role_info(adapter->phl_role);
/* init self staion info after wifi role alloc */
rst = rtw_init_self_stainfo(adapter);
#if defined (CONFIG_PCI_HCI) && defined (CONFIG_PCIE_TRX_MIT)
rtw_pcie_trx_mit_cmd(adapter, 0, 0,
PCIE_RX_INT_MIT_TIMER, 0, 1);
#endif
#if defined(CONFIG_RTW_IPS) || defined(CONFIG_RTW_LPS)
ps_allow = _TRUE;
rtw_phl_ps_set_rt_cap(GET_PHL_INFO(dvobj), HW_BAND_0, ps_allow, PS_RT_CORE_INIT);
#endif
return rst;
_error:
return rst;
}
u8 rtw_hw_iface_type_change(_adapter *adapter, u8 iface_type)
{
void *phl = GET_PHL_INFO(adapter_to_dvobj(adapter));
#ifdef CONFIG_WIFI_MONITOR
struct rtw_phl_com_t *phl_com = GET_PHL_COM(adapter_to_dvobj(adapter));
#endif
struct rtw_wifi_role_t *wrole = adapter->phl_role;
enum role_type rtype = PHL_RTYPE_NONE;
enum rtw_phl_status status;
struct sta_info *sta = NULL;
if (wrole == NULL) {
RTW_ERR("%s - wrole = NULL\n", __func__);
rtw_warn_on(1);
return _FAIL;
}
switch (iface_type) {
case _HW_STATE_ADHOC_:
rtype = PHL_RTYPE_ADHOC;
break;
case _HW_STATE_STATION_:
rtype = PHL_RTYPE_STATION;
break;
case _HW_STATE_AP_:
rtype = PHL_RTYPE_AP;
break;
case _HW_STATE_MONITOR_:
rtype = PHL_RTYPE_MONITOR;
break;
case _HW_STATE_NOLINK_:
default:
/* TBD */
break;
}
status = rtw_phl_cmd_wrole_change(phl, wrole,
WR_CHG_TYPE, (u8*)&rtype, sizeof(enum role_type),
PHL_CMD_DIRECTLY, 0);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s - change to phl role type = %d fail with error = %d\n",
__func__, rtype, status);
rtw_warn_on(1);
return _FAIL;
}
#ifdef CONFIG_WIFI_MONITOR
if (rtype == PHL_RTYPE_MONITOR) {
phl_com->append_fcs = false; /* This need to check again by yiwei*/
rtw_phl_enter_mon_mode(phl, wrole);
} else {
phl_com->append_fcs = true; /* This need to check again by yiwei*/
rtw_phl_leave_mon_mode(phl, wrole);
}
#endif
/* AP allocates self-station and changes broadcast-station before hostapd adds key */
if (rtype == PHL_RTYPE_AP) {
sta = rtw_get_stainfo(&adapter->stapriv, adapter_mac_addr(adapter));
if (sta == NULL) {
sta = rtw_alloc_stainfo(&adapter->stapriv, adapter_mac_addr(adapter));
if (sta == NULL) {
RTW_ERR("%s - allocate AP self-station failed\n", __func__);
rtw_warn_on(1);
return _FAIL;
}
}
}
RTW_INFO("%s - change to type = %d success !\n", __func__, iface_type);
return _SUCCESS;
}
void rtw_hw_iface_deinit(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
#if defined(CONFIG_RTW_IPS) || defined(CONFIG_RTW_LPS)
bool ps_allow = _FALSE;
rtw_phl_ps_set_rt_cap(GET_PHL_INFO(dvobj), HW_BAND_0, ps_allow, PS_RT_CORE_INIT);
#endif
if (adapter->phl_role) {
rtw_free_self_stainfo(adapter);
rtw_phl_wifi_role_free(GET_PHL_INFO(dvobj), adapter->phl_role->id);
adapter->phl_role = NULL;
}
#if defined(CONFIG_RTW_IPS) || defined(CONFIG_RTW_LPS)
ps_allow = _TRUE;
rtw_phl_ps_set_rt_cap(GET_PHL_INFO(dvobj), HW_BAND_0, ps_allow, PS_RT_CORE_INIT);
#endif
}
/*
* _sec_algo_drv2phl() - Convert security algorithm to PHL's definition
* @drv_algo: security algorithm
* @phl_algo: security algorithm for PHL, ref to enum rtw_enc_algo
* @phl_key_len: key length
*
* Convert driver's security algorithm defintion to PHL's type.
*
*/
static void _sec_algo_drv2phl(enum security_type drv_algo,
u8 *algo, u8 *key_len)
{
u8 phl_algo = RTW_ENC_NONE;
u8 phl_key_len = 0;
switch(drv_algo) {
case _NO_PRIVACY_:
phl_algo = RTW_ENC_NONE;
phl_key_len = 0;
break;
case _WEP40_:
phl_algo = RTW_ENC_WEP40;
phl_key_len = 5;
break;
case _TKIP_:
case _TKIP_WTMIC_:
phl_algo = RTW_ENC_TKIP;
phl_key_len = 16;
break;
case _AES_:
phl_algo = RTW_ENC_CCMP;
phl_key_len = 16;
break;
case _WEP104_:
phl_algo = RTW_ENC_WEP104;
phl_key_len = 13;
break;
case _SMS4_:
phl_algo = RTW_ENC_WAPI;
phl_key_len = 32;
break;
case _GCMP_:
phl_algo = RTW_ENC_GCMP;
phl_key_len = 16;
break;
case _CCMP_256_:
phl_algo = RTW_ENC_CCMP256;
phl_key_len = 32;
break;
case _GCMP_256_:
phl_algo = RTW_ENC_GCMP256;
phl_key_len = 32;
break;
#ifdef CONFIG_IEEE80211W
case _BIP_CMAC_128_:
phl_algo = RTW_ENC_BIP_CCMP128;
phl_key_len = 16;
break;
#endif /* CONFIG_IEEE80211W */
default:
RTW_ERR("%s: No rule to covert drv algo(0x%x) to phl!!\n",
__func__, drv_algo);
phl_algo = RTW_ENC_MAX;
phl_key_len = 0;
break;
}
if(algo)
*algo = phl_algo;
if(key_len)
*key_len = phl_key_len;
}
/*
* _sec_algo_phl2drv() - Convert security algorithm to core layer definition
* @drv_algo: security algorithm for core layer, ref to enum security_type
* @phl_algo: security algorithm for PHL, ref to enum rtw_enc_algo
* @drv_key_len: key length
*
* Convert PHL's security algorithm defintion to core layer definition.
*
*/
static void _sec_algo_phl2drv(enum rtw_enc_algo phl_algo,
u8 *algo, u8 *key_len)
{
u8 drv_algo = RTW_ENC_NONE;
u8 drv_key_len = 0;
switch(phl_algo) {
case RTW_ENC_NONE:
drv_algo = _NO_PRIVACY_;
drv_key_len = 0;
break;
case RTW_ENC_WEP40:
drv_algo = _WEP40_;
drv_key_len = 5;
break;
case RTW_ENC_TKIP:
/* drv_algo = _TKIP_WTMIC_ */
drv_algo = _TKIP_;
drv_key_len = 16;
break;
case RTW_ENC_CCMP:
drv_algo = _AES_;
drv_key_len = 16;
break;
case RTW_ENC_WEP104:
drv_algo = _WEP104_;
drv_key_len = 13;
break;
case RTW_ENC_WAPI:
drv_algo = _SMS4_;
drv_key_len = 32;
break;
case RTW_ENC_GCMP:
drv_algo = _GCMP_;
drv_key_len = 16;
break;
case RTW_ENC_CCMP256:
drv_algo = _CCMP_256_;
drv_key_len = 32;
break;
case RTW_ENC_GCMP256:
drv_algo = _GCMP_256_;
drv_key_len = 32;
break;
#ifdef CONFIG_IEEE80211W
case RTW_ENC_BIP_CCMP128:
drv_algo = _BIP_CMAC_128_;
drv_key_len = 16;
break;
#endif /* CONFIG_IEEE80211W */
default:
RTW_ERR("%s: No rule to covert phl algo(0x%x) to drv!!\n",
__func__, phl_algo);
drv_algo = _SEC_TYPE_MAX_;
drv_key_len = 0;
break;
}
if(algo)
*algo = drv_algo;
if(key_len)
*key_len = drv_key_len;
}
u8 rtw_sec_algo_drv2phl(enum security_type drv_algo)
{
u8 algo = 0;
_sec_algo_drv2phl(drv_algo, &algo, NULL);
return algo;
}
u8 rtw_sec_algo_phl2drv(enum rtw_enc_algo phl_algo)
{
u8 algo = 0;
_sec_algo_phl2drv(phl_algo, &algo, NULL);
return algo;
}
static int rtw_hw_chk_sec_mode(struct _ADAPTER *a, struct sta_info *sta,
enum phl_cmd_type cmd_type, u32 cmd_timeout)
{
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
u8 sec_mode = 0;
struct security_priv *psecuritypriv = &a->securitypriv;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return _FAIL;
sec_mode = rtw_phl_trans_sec_mode(
rtw_sec_algo_drv2phl(psecuritypriv->dot11PrivacyAlgrthm),
rtw_sec_algo_drv2phl(psecuritypriv->dot118021XGrpPrivacy));
RTW_INFO("After phl trans_sec_mode = %d\n", sec_mode);
if (sec_mode != sta->phl_sta->sec_mode) {
RTW_INFO("%s: original sec_mode =%d update sec mode to %d.\n",
__func__, sta->phl_sta->sec_mode, sec_mode);
status = rtw_phl_cmd_change_stainfo(phl, sta->phl_sta, STA_CHG_SEC_MODE,
&sec_mode, sizeof(u8), cmd_type, cmd_timeout);
/* To Do: check the return status */
} else {
RTW_INFO("%s: sec mode remains the same. skip update.\n", __func__);
}
return _SUCCESS;
}
/*
* rtw_hw_add_key() - Add security key
* @a: pointer of struct _ADAPTER
* @sta: pointer of struct sta_info
* @keyid: key index
* @keyalgo: key algorithm
* @keytype: 0: unicast / 1: multicast / 2: bip (ref: enum SEC_CAM_KEY_TYPE)
* @key: key content
* @spp: spp mode
*
* Add security key.
*
* Return 0 for success, otherwise fail.
*/
int rtw_hw_add_key(struct _ADAPTER *a, struct sta_info *sta,
u8 keyid, enum security_type keyalgo, u8 keytype, u8 *key,
u8 spp, enum phl_cmd_type cmd_type, u32 cmd_timeout)
{
struct dvobj_priv *d;
void *phl;
struct phl_sec_param_h crypt = {0};
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
if (rtw_hw_chk_sec_mode(a, sta, cmd_type, cmd_timeout) == _FAIL)
return -1;
crypt.keyid = keyid;
crypt.key_type= keytype;
crypt.spp = spp;
_sec_algo_drv2phl(keyalgo, &crypt.enc_type, &crypt.key_len);
/* delete key before adding key */
rtw_phl_cmd_del_key(phl, sta->phl_sta, &crypt, cmd_type, cmd_timeout);
status = rtw_phl_cmd_add_key(phl, sta->phl_sta, &crypt, key, cmd_type, cmd_timeout);
if (status != RTW_PHL_STATUS_SUCCESS)
return -1;
return 0;
}
/*
* rtw_hw_del_key() - Delete security key
* @a: pointer of struct _ADAPTER
* @sta: pointer of struct sta_info
* @keyid: key index
* @keytype: 0: unicast / 1: multicast / 2: bip (ref: enum SEC_CAM_KEY_TYPE)
*
* Delete security key by macid, keyid and keytype.
*
* Return 0 for success, otherwise fail.
*/
int rtw_hw_del_key(struct _ADAPTER *a, struct sta_info *sta,
u8 keyid, u8 keytype, enum phl_cmd_type cmd_type, u32 cmd_timeout)
{
struct dvobj_priv *d;
void *phl;
struct phl_sec_param_h crypt = {0};
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
crypt.keyid = keyid;
crypt.key_type= keytype;
status = rtw_phl_cmd_del_key(phl, sta->phl_sta, &crypt, cmd_type, cmd_timeout);
if (status != RTW_PHL_STATUS_SUCCESS)
return -1;
return 0;
}
/*
* rtw_hw_del_all_key() - Delete all security key for this STA
* @a: pointer of struct _ADAPTER
* @sta: pointer of struct sta_info
*
* Delete all security keys belong to this STA.
*
* Return 0 for success, otherwise fail.
*/
int rtw_hw_del_all_key(struct _ADAPTER *a, struct sta_info *sta,
enum phl_cmd_type cmd_type, u32 cmd_timeout)
{
struct dvobj_priv *d;
void *phl;
u8 keyid;
u8 keytype;
struct phl_sec_param_h crypt = {0};
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
/* Delete Group and Pairwise key */
for (keytype = 0; keytype < 2; keytype++) {
for (keyid = 0; keyid < 4; keyid++) {
crypt.keyid = keyid;
crypt.key_type = keytype;
rtw_phl_cmd_del_key(phl, sta->phl_sta, &crypt, cmd_type, cmd_timeout);
}
}
/* Delete BIP key */
crypt.key_type = 2;
for (keyid = 4; keyid <= BIP_MAX_KEYID; keyid++) {
crypt.keyid = keyid;
rtw_phl_cmd_del_key(phl, sta->phl_sta, &crypt, cmd_type, cmd_timeout);
}
return 0;
}
int rtw_hw_start_bss_network(struct _ADAPTER *a)
{
/* some hw related ap settings */
if (rtw_phl_ap_started(adapter_to_dvobj(a)->phl, a->phl_role) !=
RTW_PHL_STATUS_SUCCESS)
return _FAIL;
return _SUCCESS;
}
/* connect */
int rtw_hw_prepare_connect(struct _ADAPTER *a, struct sta_info *sta, u8 *target_addr)
{
/*adapter->phl_role.mac_addr*/
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
status = rtw_phl_connect_prepare(phl, a->phl_role, target_addr);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s: Fail to setup hardware for connecting!(%d)\n",
__func__, status);
return -1;
}
/* Todo: Enable TSF update */
/* Todo: Set support short preamble or not by beacon capability */
/* Todo: Set slot time */
return 0;
}
/* Handle connect fail case */
int rtw_hw_connect_abort(struct _ADAPTER *a, struct sta_info *sta)
{
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
rtw_hw_del_all_key(a, sta, PHL_CMD_DIRECTLY, 0);
status = rtw_phl_cmd_update_media_status(phl, sta->phl_sta, NULL, false,
PHL_CMD_DIRECTLY, 0);
if (status != RTW_PHL_STATUS_SUCCESS)
return -1;
#ifndef CONFIG_STA_CMD_DISPR
/*
* In CONFIG_STA_CMD_DISPR case, connect abort hw setting has been moved
* to MSG_EVT_DISCONNECT@PHL_FG_MDL_CONNECT .
*/
/* disconnect hw setting */
rtw_phl_disconnect(phl, a->phl_role);
/* delete sta channel ctx */
rtw_phl_chanctx_del(adapter_to_dvobj(a)->phl, a->phl_role, NULL);
/* restore orig union ch */
rtw_join_done_chk_ch(a, -1);
/* free connecting AP sta info */
rtw_free_stainfo(a, sta);
rtw_init_self_stainfo(a);
#endif /* !CONFIG_STA_CMD_DISPR */
return 0;
}
#ifdef RTW_WKARD_UPDATE_PHL_ROLE_CAP
/**
* rtw_update_phl_cap_by_rgstry() - Update cap & proto_role_cap of phl_role
* @a: struct _ADAPTER*
*
* Update cap & proto_role_cap of a->phl_role by registry/driver parameters.
*
*/
void rtw_update_phl_cap_by_rgstry(struct _ADAPTER *a)
{
struct registry_priv *rgstry;
struct role_cap_t *cap;
struct protocol_cap_t *prtcl;
rgstry = &a->registrypriv;
cap = &a->phl_role->cap;
prtcl = &a->phl_role->proto_role_cap;
/* LDPC */
prtcl->ht_ldpc &= (TEST_FLAG(rgstry->ldpc_cap, BIT4) ? 1 : 0);
cap->tx_ht_ldpc &= (TEST_FLAG(rgstry->ldpc_cap, BIT5) ? 1 : 0);
prtcl->vht_ldpc &= (TEST_FLAG(rgstry->ldpc_cap, BIT0) ? 1 : 0);
cap->tx_vht_ldpc &= (TEST_FLAG(rgstry->ldpc_cap, BIT1) ? 1 : 0);
/* no HE LDPC control setting in registry, follow PHL default */
}
#endif /* RTW_WKARD_UPDATE_PHL_ROLE_CAP */
static void _dump_phl_sta_asoc_cap(struct sta_info *sta)
{
struct rtw_phl_stainfo_t *phl_sta = sta->phl_sta;
struct protocol_cap_t *asoc_cap = &phl_sta->asoc_cap;
#define _loc_dbg_func RTW_DBG
#define _loc_dbg(f) _loc_dbg_func(#f ": %u\n", asoc_cap->f)
_loc_dbg_func("[PHL STA ASOC CAP]- mac_addr: " MAC_FMT "\n",
MAC_ARG(phl_sta->mac_addr));
_loc_dbg(ht_ldpc);
_loc_dbg(vht_ldpc);
_loc_dbg(he_ldpc);
_loc_dbg(stbc_ht_rx);
_loc_dbg(stbc_vht_rx);
_loc_dbg(stbc_he_rx);
_loc_dbg(vht_su_bfmr);
_loc_dbg(vht_su_bfme);
_loc_dbg(vht_mu_bfmr);
_loc_dbg(vht_mu_bfme);
_loc_dbg(bfme_sts);
_loc_dbg(num_snd_dim);
_loc_dbg_func("[PHL STA ASOC CAP]- end\n");
}
#ifdef CONFIG_80211N_HT
#ifdef CONFIG_80211AC_VHT
static void update_phl_sta_cap_vht(struct _ADAPTER *a, struct sta_info *sta,
struct protocol_cap_t *cap)
{
struct vht_priv *vht;
vht = &sta->vhtpriv;
if (cap->ampdu_len_exp < vht->ampdu_len)
cap->ampdu_len_exp = vht->ampdu_len;
if (cap->max_amsdu_len < vht->max_mpdu_len)
cap->max_amsdu_len = vht->max_mpdu_len;
cap->sgi_80 = (vht->sgi_80m == _TRUE) ? 1 : 0;
_rtw_memcpy(cap->vht_rx_mcs, vht->vht_mcs_map, 2);
/* Todo: cap->vht_tx_mcs[2]; */
if (vht->op_present)
_rtw_memcpy(cap->vht_basic_mcs, &vht->vht_op[3], 2);
}
#endif /* CONFIG_80211AC_VHT */
static void update_phl_sta_cap_ht(struct _ADAPTER *a, struct sta_info *sta,
struct protocol_cap_t *cap)
{
struct mlme_ext_info *info;
struct ht_priv *ht;
info = &a->mlmeextpriv.mlmext_info;
ht = &sta->htpriv;
cap->num_ampdu = 0xFF; /* Set to MAX */
cap->ampdu_density = ht->rx_ampdu_min_spacing;
cap->ampdu_len_exp = GET_HT_CAP_ELE_MAX_AMPDU_LEN_EXP(&ht->ht_cap);
cap->amsdu_in_ampdu = 1;
cap->max_amsdu_len = GET_HT_CAP_ELE_MAX_AMSDU_LENGTH(&ht->ht_cap);
/*GET_HT_CAP_ELE_SM_PS(&info->HT_caps.u.HT_cap_element.HT_caps_info);*/
cap->sm_ps = info->SM_PS;
cap->sgi_20 = (ht->sgi_20m == _TRUE) ? 1 : 0;
cap->sgi_40 = (ht->sgi_40m == _TRUE) ? 1 : 0;
_rtw_memcpy(cap->ht_rx_mcs, ht->ht_cap.supp_mcs_set, 4);
/* Todo: cap->ht_tx_mcs[4]; */
if (info->HT_info_enable)
_rtw_memcpy(cap->ht_basic_mcs, info->HT_info.MCS_rate, 4);
}
#endif /* CONFIG_80211N_HT */
void rtw_update_phl_sta_cap(struct _ADAPTER *a, struct sta_info *sta,
struct protocol_cap_t *cap)
{
struct mlme_ext_info *info;
info = &a->mlmeextpriv.mlmext_info;
/* MAC related */
/* update beacon interval */
cap->bcn_interval = info->bcn_interval;
#if 0
cap->num_ampdu; /* HT, VHT, HE */
cap->ampdu_density:3; /* HT, VHT, HE */
cap->ampdu_len_exp; /* HT, VHT, HE */
cap->amsdu_in_ampdu:1; /* HT, VHT, HE */
cap->max_amsdu_len:2; /* HT, VHT, HE */
cap->htc_rx:1;
cap->sm_ps:2; /* HT */
cap->trig_padding:2;
cap->twt:6;
cap->all_ack:1;
cap->a_ctrl:3;
cap->ops:1;
cap->ht_vht_trig_rx:1;
#endif
cap->short_slot = (info->slotTime == SHORT_SLOT_TIME) ? 1 : 0;
cap->preamble = (info->preamble_mode == PREAMBLE_SHORT) ? 1 : 0;
#if 0
cap->sgi_20:1; /* HT */
cap->sgi_40:1; /* HT */
cap->sgi_80:1; /* VHT */
cap->sgi_160:1 /* VHT, HE */
/* BB related */
cap->ht_ldpc:1; /* HT, HT_caps_handler() */
cap->vht_ldpc:1; /* VHT, VHT_caps_handler() */
cap->he_ldpc:1; /* HE, HE_phy_caps_handler() */
cap->sgi:1;
cap->su_bfmr:1;
cap->su_bfme:1;
cap->mu_bfmr:1;
cap->mu_bfme:1;
cap->bfme_sts:3;
cap->num_snd_dim:3;
#endif
_rtw_memset(cap->supported_rates, 0, 12);
_rtw_memcpy(cap->supported_rates, sta->bssrateset,
sta->bssratelen < 12 ? sta->bssratelen : 12);
#if 0
cap->ht_rx_mcs[4]; /* HT */
cap->ht_tx_mcs[4]; /* HT */
cap->ht_basic_mcs[4]; /* Basic rate of HT */
cap->vht_rx_mcs[2]; /* VHT */
cap->vht_tx_mcs[2]; /* VHT */
cap->vht_basic_mcs[2]; /* Basic rate of VHT */
#endif
#if 0
/* HE done */
cap->he_rx_mcs[2];
cap->he_tx_mcs[2];
cap->he_basic_mcs[2]; /* Basic rate of HE */
cap->stbc_ht_rx:2; /* HT_caps_handler() */
cap->stbc_vht_rx:3; /* VHT_caps_handler() */
cap->stbc_he_rx:1; /* HE_phy_caps_handler() */
cap->stbc_tx:1;
cap->ltf_gi;
cap->doppler_tx:1;
cap->doppler_rx:1;
cap->dcm_max_const_tx:2;
cap->dcm_max_nss_tx:1;
cap->dcm_max_const_rx:2;
cap->dcm_max_nss_rx:1;
cap->partial_bw_su_in_mu:1;
cap->bfme_sts_greater_80mhz:3;
cap->num_snd_dim_greater_80mhz:3;
cap->stbc_tx_greater_80mhz:1;
cap->stbc_rx_greater_80mhz:1;
cap->ng_16_su_fb:1;
cap->ng_16_mu_fb:1;
cap->cb_sz_su_fb:1;
cap->cb_sz_mu_fb:1;
cap->trig_su_bfm_fb:1;
cap->trig_mu_bfm_fb:1;
cap->trig_cqi_fb:1;
cap->partial_bw_su_er:1;
cap->pkt_padding:2;
cap->ppe_th[24];
cap->pwr_bst_factor:1;
cap->max_nc:3;
cap->dcm_max_ru:2;
cap->long_sigb_symbol:1;
cap->non_trig_cqi_fb:1;
cap->tx_1024q_ru:1;
cap->rx_1024q_ru:1;
cap->fbw_su_using_mu_cmprs_sigb:1;
cap->fbw_su_using_mu_non_cmprs_sigb:1;
cap->er_su:1;
cap->tb_pe:3;
cap->txop_du_rts_th;
#endif
#ifdef CONFIG_80211N_HT
if (sta->htpriv.ht_option) {
update_phl_sta_cap_ht(a, sta, cap);
#ifdef CONFIG_80211AC_VHT
if (sta->vhtpriv.vht_option)
update_phl_sta_cap_vht(a, sta, cap);;
#endif /* CONFIG_80211AC_VHT */
}
#endif /* CONFIG_80211N_HT */
}
/**
* rtw_hw_set_edca() - setup WMM EDCA parameter
* @a: struct _ADAPTER *
* @ac: Access Category, 0:BE, 1:BK, 2:VI, 3:VO
* @param: AIFS:BIT[7:0], CWMIN:BIT[11:8], CWMAX:BIT[15:12],
* TXOP:BIT[31:16]
*
* Setup WMM EDCA parameter set.
*
* Return 0 for SUCCESS, otherwise fail.
*/
int rtw_hw_set_edca(struct _ADAPTER *a, u8 ac, u32 param)
{
struct dvobj_priv *d;
void *phl;
struct rtw_edca_param edca = {0};
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
edca.ac = ac;
edca.param = param;
status = rtw_phl_cmd_wrole_change(phl, a->phl_role,
WR_CHG_EDCA_PARAM, (u8*)&edca, sizeof(struct rtw_edca_param),
PHL_CMD_DIRECTLY, 0);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s: fail to set edca parameter, ac(%u), "
"param(0x%08x)\n",
__func__, ac, param);
return -1;
}
return 0;
}
int rtw_hw_connected(struct _ADAPTER *a, struct sta_info *sta)
{
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
struct security_priv *psecuritypriv = &a->securitypriv;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
rtw_update_phl_sta_cap(a, sta, &sta->phl_sta->asoc_cap);
_dump_phl_sta_asoc_cap(sta);
status = rtw_phl_cmd_update_media_status(phl, sta->phl_sta,
sta->phl_sta->mac_addr, true,
PHL_CMD_DIRECTLY, 0);
if (status != RTW_PHL_STATUS_SUCCESS)
return -1;
rtw_dump_phl_sta_info(RTW_DBGDUMP, sta);
/* Todo: update IOT-releated issue */
#if 0
update_IOT_info(a);
#endif
/* Todo: RTS full bandwidth setting */
#if 0
#ifdef CONFIG_RTS_FULL_BW
rtw_set_rts_bw(a);
#endif /* CONFIG_RTS_FULL_BW */
#endif
/* Todo: Basic rate setting */
#if 0
rtw_hal_set_hwreg(a, HW_VAR_BASIC_RATE, cur_network->SupportedRates);
#endif
/* Todo: udpate capability: short preamble, slot time */
update_capinfo(a, a->mlmeextpriv.mlmext_info.capability);
WMMOnAssocRsp(a);
/* Todo: HT: AMPDU factor, min space, max time and related parameters */
#if 0
#ifdef CONFIG_80211N_HT
HTOnAssocRsp(a);
#endif /* CONFIG_80211N_HT */
#endif
/* Todo: VHT */
#if 0
#ifdef CONFIG_80211AC_VHT
VHTOnAssocRsp(a);
#endif
#endif
/* Todo: Set Data rate and RA */
#if 0
set_sta_rate(a, psta);
#endif
/* Todo: Firmware media status report */
#if 0
rtw_sta_media_status_rpt(a, psta, 1);
#endif
/* Todo: IC specific hardware setting */
#if 0
join_type = 2;
rtw_hal_set_hwreg(a, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
#endif
if ((a->mlmeextpriv.mlmext_info.state & 0x03) == WIFI_FW_STATION_STATE) {
/* Todo: Correct TSF */
#if 0
correct_TSF(a, MLME_STA_CONNECTED);
#endif
}
/* Todo: btcoex connect event notify */
#if 0
rtw_btcoex_connect_notify(a, join_type);
#endif
/* Todo: Beamforming setting */
#if 0
beamforming_wk_cmd(a, BEAMFORMING_CTRL_ENTER, (u8 *)psta, sizeof(struct sta_info), 0);
#endif
rtw_join_done_chk_ch(a, 1);
rtw_phl_connected(phl, a->phl_role, sta->phl_sta);
#ifdef CONFIG_80211AX_HE
rtw_he_init_om_info(a);
#endif
ATOMIC_SET(&a->need_tsf_sync_done, _TRUE);
return 0;
}
int rtw_hw_disconnect(struct _ADAPTER *a, struct sta_info *sta)
{
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
int tid;
u8 is_ap_self = _FALSE;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
if (MLME_IS_AP(a) &&
_rtw_memcmp(a->phl_role->mac_addr, sta->phl_sta->mac_addr, ETH_ALEN))
is_ap_self = _TRUE;
/* Check and reset setting related to rx ampdu resources of PHL. */
for (tid = 0; tid < TID_NUM; tid++) {
if(sta->recvreorder_ctrl[tid].enable == _TRUE) {
sta->recvreorder_ctrl[tid].enable =_FALSE;
rtw_phl_stop_rx_ba_session(phl, sta->phl_sta, tid);
RTW_INFO(FUNC_ADPT_FMT"stop process tid %d \n",
FUNC_ADPT_ARG(a), tid);
}
}
/*reset sec setting and clean all connection setting*/
rtw_hw_del_all_key(a, sta, PHL_CMD_DIRECTLY, 0);
if (is_ap_self == _FALSE) {
status = rtw_phl_cmd_update_media_status(phl, sta->phl_sta, NULL, false,
PHL_CMD_DIRECTLY, 0);
if (status != RTW_PHL_STATUS_SUCCESS)
return -1;
rtw_dump_phl_sta_info(RTW_DBGDUMP, sta);
}
if (MLME_IS_STA(a)) {
/*
* the following flow only for STA
* bypass client disconnect from softAP
*/
#ifndef CONFIG_STA_CMD_DISPR
rtw_phl_disconnect(phl, a->phl_role);
#endif /* !CONFIG_STA_CMD_DISPR */
rtw_disconnect_ch_switch(a);
}
return 0;
}
int rtw_hw_connected_apmode(struct _ADAPTER *a, struct sta_info *sta)
{
struct dvobj_priv *d;
void *phl;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!phl)
return -1;
rtw_ap_set_sta_wmode(a, sta);
update_sta_ra_info(a, sta);
rtw_update_phl_sta_cap(a, sta, &sta->phl_sta->asoc_cap);
if (RTW_PHL_STATUS_SUCCESS != rtw_phl_cmd_update_media_status(
phl, sta->phl_sta, sta->phl_sta->mac_addr, true,
PHL_CMD_DIRECTLY, 0))
return -1;
rtw_dump_phl_sta_info(RTW_DBGDUMP, sta);
return 0;
}
u8 rtw_hal_get_def_var(struct _ADAPTER *a,
enum _HAL_DEF_VARIABLE def_var, void *val)
{
switch (def_var) {
case HAL_DEF_IS_SUPPORT_ANT_DIV:
*(u8*)val = _FALSE;
break;
case HAL_DEF_DBG_DUMP_RXPKT:
*(u8*)val = 0;
break;
case HAL_DEF_BEAMFORMER_CAP:
*(u8*)val = a->phl_role->proto_role_cap.num_snd_dim;
break;
case HAL_DEF_BEAMFORMEE_CAP:
*(u8*)val = a->phl_role->proto_role_cap.bfme_sts;
break;
case HW_VAR_MAX_RX_AMPDU_FACTOR:
/* HT only */
*(enum _HT_CAP_AMPDU_FACTOR*)val = MAX_AMPDU_FACTOR_64K;
break;
case HW_DEF_RA_INFO_DUMP:
/* do nothing */
break;
case HAL_DEF_DBG_DUMP_TXPKT:
*(u8*)val = 0;
break;
case HAL_DEF_TX_PAGE_SIZE:
/* would be removed later */
break;
case HW_VAR_BEST_AMPDU_DENSITY:
*(u8*)val = 0;
break;
default:
break;
}
return 0;
}
#ifdef CONFIG_RTW_ACS
u16 rtw_acs_get_channel_by_idx(struct _ADAPTER *a, u8 idx)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
void *phl = GET_PHL_INFO(d);
if (phl)
return rtw_phl_acs_get_channel_by_idx(phl, idx);
else
return 0;
}
u8 rtw_acs_get_clm_ratio_by_idx(struct _ADAPTER *a, u8 idx)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
void *phl = GET_PHL_INFO(d);
if (phl)
return rtw_phl_acs_get_clm_ratio_by_idx(phl, idx);
else
return 0;
}
s8 rtw_noise_query_by_idx(struct _ADAPTER *a, u8 idx)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
void *phl = GET_PHL_INFO(d);
if (phl)
return rtw_phl_noise_query_by_idx(phl, idx);
else
return 0;
}
#endif /* CONFIG_RTW_ACS */
void rtw_dump_env_rpt(struct _ADAPTER *a, void *sel)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct rtw_phl_com_t *phl_com = GET_PHL_COM(d);
void *phl = GET_PHL_INFO(d);
struct rtw_env_report rpt;
rtw_phl_get_env_rpt(phl, &rpt, a->phl_role);
RTW_PRINT_SEL(sel, "clm_ratio:%d (%%)\n", rpt.nhm_cca_ratio);
RTW_PRINT_SEL(sel, "nhm_ratio:%d (%%)\n", rpt.nhm_ratio);
}
#ifdef CONFIG_WOWLAN
static u8 _cfg_keep_alive_info(struct _ADAPTER *a, u8 enable)
{
struct rtw_keep_alive_info info;
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
u8 check_period = 5;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
_rtw_memset(&info, 0, sizeof(struct rtw_keep_alive_info));
info.keep_alive_en = enable;
info.keep_alive_period = check_period;
RTW_INFO("%s: keep_alive_en=%d, keep_alive_period=%d\n",
__func__, info.keep_alive_en, info.keep_alive_period);
status = rtw_phl_cfg_keep_alive_info(phl, &info);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s fail(%d)\n", __func__, status);
return _FAIL;
}
return _SUCCESS;
}
static u8 _cfg_disc_det_info(struct _ADAPTER *a, u8 enable)
{
struct wow_priv *wowpriv = adapter_to_wowlan(a);
struct rtw_disc_det_info *wow_disc = &wowpriv->wow_disc;
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
struct registry_priv *registry_par;
u8 check_period = 100, trypkt_num = 5;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
registry_par = &a->registrypriv;
wow_disc->disc_det_en = enable;
/* wake up event includes deauth wake up */
if (registry_par->wakeup_event & BIT(2))
wow_disc->disc_wake_en = _TRUE;
else
wow_disc->disc_wake_en = _FALSE;
wow_disc->try_pkt_count = trypkt_num;
wow_disc->check_period = check_period;
wow_disc->cnt_bcn_lost_en = 0;
wow_disc->cnt_bcn_lost_limit = 0;
status = rtw_phl_cfg_disc_det_info(phl, wow_disc);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s fail(%d)\n", __func__, status);
return _FAIL;
}
return _SUCCESS;
}
static u8 _cfg_nlo_info(struct _ADAPTER *a)
{
struct rtw_nlo_info info;
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
_rtw_memset(&info, 0, sizeof(struct rtw_nlo_info));
status = rtw_phl_cfg_nlo_info(phl, &info);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s fail(%d)\n", __func__, status);
return _FAIL;
}
return _SUCCESS;
}
static u8 _cfg_arp_ofld_info(struct _ADAPTER *a)
{
struct rtw_arp_ofld_info info;
struct dvobj_priv *d;
struct registry_priv *registry_par;
void *phl;
struct mlme_ext_priv *pmlmeext = &(a->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
/* struct mlme_priv *pmlmepriv = &(a->mlmepriv); */
/* u8 *target_ip = NULL, *target_mac = NULL; */
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
registry_par = &a->registrypriv;
_rtw_memset(&info, 0, sizeof(struct rtw_arp_ofld_info));
if (registry_par->wakeup_event)
info.arp_en = 1;
else
info.arp_en = 0;
if (info.arp_en) {
/* Sender IP address */
_rtw_memcpy(info.arp_ofld_content.host_ipv4_addr,
pmlmeinfo->ip_addr,
IPV4_ADDRESS_LENGTH);
/* TODO : FW doesn't support arp keep alive */
/* #ifdef CONFIG_ARP_KEEP_ALIVE */
#if 0
if (!is_zero_mac_addr(pmlmepriv->gw_mac_addr)) {
target_ip = pmlmepriv->gw_ip;
target_mac = pmlmepriv->gw_mac_addr;
RTW_INFO("Enabel CONFIG_ARP_KEEP_ALIVE\n");
} else
#endif
/* No need to fill Target IP & Target MAC address.
* FW will fill correct Target IP & Target MAC address. */
#if 0
{
target_ip = pmlmeinfo->ip_addr;
target_mac = get_my_bssid(&(pmlmeinfo->network));
}
/* Targe IP address */
_rtw_memcpy(info.arp_ofld_content.remote_ipv4_addr, target_ip,
IPV4_ADDRESS_LENGTH);
/* PHL doesn't use this variable */
_rtw_memcpy(&(info.arp_ofld_content.mac_addr[0]), target_mac,
MAC_ADDRESS_LENGTH);
#endif
}
rtw_phl_cfg_arp_ofld_info(phl, &info);
return _SUCCESS;
}
static u8 _cfg_ndp_ofld_info(struct _ADAPTER *a)
{
struct rtw_ndp_ofld_info info;
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
_rtw_memset(&info, 0, sizeof(struct rtw_ndp_ofld_info));
rtw_phl_cfg_ndp_ofld_info(phl, &info);
return _SUCCESS;
}
#ifdef CONFIG_GTK_OL
static u8 _cfg_gtk_ofld_info(struct _ADAPTER *a)
{
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
struct rtw_gtk_ofld_info gtk_ofld_info = {0};
struct rtw_gtk_ofld_content *gtk_ofld_content = NULL;
struct security_priv *securitypriv = &a->securitypriv;
struct sta_info *sta = NULL;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
sta = rtw_get_stainfo(&a->stapriv, get_bssid(&a->mlmepriv));
gtk_ofld_content = >k_ofld_info.gtk_ofld_content;
if (securitypriv->binstallKCK_KEK) {
gtk_ofld_info.gtk_en = _TRUE;
gtk_ofld_info.akmtype_byte3 = securitypriv->rsn_akm_suite_type;
gtk_ofld_content->kck_len = RTW_KCK_LEN;
_rtw_memcpy(gtk_ofld_content->kck, sta->kck, RTW_KCK_LEN);
gtk_ofld_content->kek_len = RTW_KEK_LEN;
_rtw_memcpy(gtk_ofld_content->kek, sta->kek, RTW_KEK_LEN);
if (securitypriv->dot11PrivacyAlgrthm == _TKIP_) {
gtk_ofld_info.tkip_en = _TRUE;
/* The driver offloads the Tx MIC key here, which is
* actually the Rx MIC key, but the driver definition is
* the opposite of the correct definition.
*/
_rtw_memcpy(gtk_ofld_content->rxmickey,
sta->dot11tkiptxmickey.skey, RTW_TKIP_MIC_LEN);
}
_rtw_memcpy(gtk_ofld_content->replay_cnt, sta->replay_ctr,
RTW_REPLAY_CTR_LEN);
}
#ifdef CONFIG_IEEE80211W
if (SEC_IS_BIP_KEY_INSTALLED(securitypriv)) {
gtk_ofld_info.ieee80211w_en = 1;
RTW_PUT_LE32(gtk_ofld_content->igtk_keyid,
securitypriv->dot11wBIPKeyid);
RTW_PUT_LE64(gtk_ofld_content->ipn,
securitypriv->dot11wBIPrxpn.val);
_rtw_memcpy(gtk_ofld_content->igtk[0],
securitypriv->dot11wBIPKey[4].skey, RTW_IGTK_LEN);
_rtw_memcpy(gtk_ofld_content->igtk[1],
securitypriv->dot11wBIPKey[5].skey, RTW_IGTK_LEN);
gtk_ofld_content->igtk_len = RTW_IGTK_LEN;
_rtw_memcpy(gtk_ofld_content->psk,
sta->dot118021x_UncstKey.skey, RTW_PTK_LEN);
gtk_ofld_content->psk_len = RTW_PTK_LEN;
}
#endif
rtw_phl_cfg_gtk_ofld_info(phl, >k_ofld_info);
return _SUCCESS;
}
#endif
static u8 _cfg_realwow_info(struct _ADAPTER *a)
{
struct rtw_realwow_info info;
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
/* default disable */
_rtw_memset(&info, 0, sizeof(struct rtw_realwow_info));
status = rtw_phl_cfg_realwow_info(phl, &info);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s fail(%d)\n", __func__, status);
return _FAIL;
}
return _SUCCESS;
}
static u8 _cfg_wow_wake(struct _ADAPTER *a, u8 wow_en)
{
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
struct wow_priv *wowpriv = adapter_to_wowlan(a);
struct rtw_wow_wake_info *wow_wake_event = &wowpriv->wow_wake_event;
struct security_priv *securitypriv;
struct registry_priv *registry_par = &a->registrypriv;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
securitypriv = &a->securitypriv;
wow_wake_event->wow_en = _TRUE;
/* wake up by magic packet */
if (registry_par->wakeup_event & BIT(0))
wow_wake_event->magic_pkt_en = _TRUE;
else
wow_wake_event->magic_pkt_en = _FALSE;
/* wake up by deauth packet */
if (registry_par->wakeup_event & BIT(2))
wow_wake_event->deauth_wakeup = _TRUE;
else
wow_wake_event->deauth_wakeup = _FALSE;
/* wake up by pattern match packet */
if (registry_par->wakeup_event & (BIT(1) | BIT(3))) {
wow_wake_event->pattern_match_en = _TRUE;
rtw_wow_pattern_clean(a, RTW_DEFAULT_PATTERN);
if (registry_par->wakeup_event & BIT(1))
rtw_set_default_pattern(a);
if (!(registry_par->wakeup_event & BIT(3)))
rtw_wow_pattern_clean(a, RTW_CUSTOMIZED_PATTERN);
} else {
wow_wake_event->pattern_match_en = _FALSE;
}
/* wake up by ptk rekey */
if (registry_par->wakeup_event & BIT(4))
wow_wake_event->rekey_wakeup = _TRUE;
else
wow_wake_event->rekey_wakeup = _FALSE;
wow_wake_event->pairwise_sec_algo = rtw_sec_algo_drv2phl(securitypriv->dot11PrivacyAlgrthm);
wow_wake_event->group_sec_algo = rtw_sec_algo_drv2phl(securitypriv->dot118021XGrpPrivacy);
#ifdef CONFIG_IEEE80211W
if (SEC_IS_BIP_KEY_INSTALLED(securitypriv))
wow_wake_event->bip_sec_algo = rtw_sec_algo_drv2phl(securitypriv->dot11wCipher);
#endif
rtw_construct_remote_control_info(a, &wow_wake_event->remote_wake_ctrl_info);
status = rtw_phl_cfg_wow_wake(phl, wow_wake_event);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s fail(%d)\n", __func__, status);
return _FAIL;
}
return _SUCCESS;
}
static u8 _cfg_wow_gpio(struct _ADAPTER *a)
{
struct rtw_wow_wake_info info;
struct dvobj_priv *d;
void *phl;
enum rtw_phl_status status;
struct wow_priv *wowpriv = adapter_to_wowlan(a);
struct rtw_wow_gpio_info *wow_gpio = &wowpriv->wow_gpio;
struct registry_priv *registry_par = &a->registrypriv;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
#ifdef CONFIG_GPIO_WAKEUP
wow_gpio->dev2hst_gpio_en = _TRUE;
/* ToDo: fw/halmac do not support so far
pwrctrlpriv->hst2dev_high_active = HIGH_ACTIVE_HST2DEV;
*/
#ifdef CONFIG_RTW_ONE_PIN_GPIO
wow_gpio->dev2hst_gpio_mode = RTW_AX_SW_IO_MODE_INPUT;
status = rtw_phl_cfg_wow_set_sw_gpio_mode(phl, gpio);
#else
#ifdef CONFIG_WAKEUP_GPIO_INPUT_MODE
wow_gpio->dev2hst_gpio_mode = RTW_AX_SW_IO_MODE_OUTPUT_OD;
wow_gpio->gpio_output_input = _TRUE;
#else
wow_gpio->dev2hst_gpio_mode = RTW_AX_SW_IO_MODE_OUTPUT_PP;
wow_gpio->gpio_output_input = _FALSE;
#endif /*CONFIG_WAKEUP_GPIO_INPUT_MODE*/
/* switch GPIO to open-drain or push-pull */
status = rtw_phl_cfg_wow_set_sw_gpio_mode(phl, wow_gpio);
/*default low active, gpio_active and dev2hst_high is the same thing
, but two halmac implementation. FW and halmac need to refine */
status = rtw_phl_cfg_wow_sw_gpio_ctrl(phl, wow_gpio);
RTW_INFO("%s: set GPIO_%d %d as default. status=%d\n",
__func__, WAKEUP_GPIO_IDX, wow_gpio->dev2hst_high, status);
#endif /* CONFIG_RTW_ONE_PIN_GPIO */
/* SDIO inband wake sdio_wakeup_enable
wow_gpio->data_pin_wakeup = info->data_pin_wakeup;
*/
/* two halmac implementation. FW and halmac need to refine */
wow_gpio->dev2hst_gpio = WAKEUP_GPIO_IDX;
wow_gpio->gpio_num = WAKEUP_GPIO_IDX;
status = rtw_phl_cfg_gpio_wake_pulse(phl, wow_gpio);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("%s fail(%d)\n", __func__, status);
return _FAIL;
}
#endif /* CONFIG_GPIO_WAKEUP */
return _SUCCESS;
}
static u8 _wow_cfg(struct _ADAPTER *a, u8 wow_en)
{
struct dvobj_priv *d;
void *phl;
struct rtw_phl_stainfo_t *phl_sta;
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
if (!_cfg_keep_alive_info(a, wow_en))
return _FAIL;
if(!_cfg_disc_det_info(a, wow_en))
return _FAIL;
if (!_cfg_nlo_info(a))
return _FAIL;
if (!_cfg_arp_ofld_info(a))
return _FAIL;
if (!_cfg_ndp_ofld_info(a))
return _FAIL;
#ifdef CONFIG_GTK_OL
if (!_cfg_gtk_ofld_info(a))
return _FAIL;
#endif
if (!_cfg_realwow_info(a))
return _FAIL;
if (!_cfg_wow_wake(a, wow_en))
return _FAIL;
if(!_cfg_wow_gpio(a))
return _FAIL;
return _SUCCESS;
}
u8 rtw_hw_wow(struct _ADAPTER *a, u8 wow_en)
{
struct dvobj_priv *d;
void *phl;
struct rtw_phl_stainfo_t *phl_sta;
enum rtw_phl_status status;
d = adapter_to_dvobj(a);
phl = GET_PHL_INFO(d);
rtw_wow_lps_level_decide(a, _TRUE);
if (!_wow_cfg(a, wow_en))
return _FAIL;
phl_sta = rtw_phl_get_stainfo_by_addr(phl, a->phl_role, get_bssid(&a->mlmepriv));
if (wow_en)
status = rtw_phl_suspend(phl, phl_sta, wow_en);
else
status = rtw_phl_resume(phl, phl_sta, &wow_en);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s wow %s fail(status: %d)\n", __func__, wow_en ? "enable" : "disable", status);
return _FAIL;
}
return _SUCCESS;
}
#endif
static enum rtw_edcca_mode rtw_edcca_mode_to_phl(enum rtw_edcca_mode_t mode)
{
switch (mode) {
case RTW_EDCCA_NORM:
return RTW_EDCCA_NORMAL;
case RTW_EDCCA_ADAPT:
return RTW_EDCCA_ETSI;
case RTW_EDCCA_CS:
return RTW_EDCCA_JP;
default:
return RTW_EDCCA_MAX;
}
}
void rtw_update_phl_edcca_mode(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
void *phl = GET_PHL_INFO(d);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(d);
struct rtw_chan_def chdef;
enum band_type band;
u8 mode = RTW_EDCCA_NORM;
enum rtw_edcca_mode phl_mode = rtw_edcca_mode_to_phl(mode);
if (!a->phl_role)
goto exit;
if (rtw_phl_mr_get_chandef(phl, a->phl_role, &chdef) != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s get union chandef failed\n", __func__);
rtw_warn_on(1);
goto exit;
}
if (chdef.chan != 0 && rtw_mi_check_fwstate(a, WIFI_ASOC_STATE)) {
band = chdef.band;
rfctl->last_edcca_mode_op_band = band;
} else if (rfctl->last_edcca_mode_op_band != BAND_MAX)
band = rfctl->last_edcca_mode_op_band;
else {
rtw_phl_get_cur_hal_chdef(a->phl_role, &chdef);
band = chdef.band;
}
mode = rtw_get_edcca_mode(d, band);
/*
* may get band not existing in current channel plan
* then edcca mode RTW_EDCCA_MODE_NUM is got
* this is not a real problem because this band is not used for TX
* change to RTW_EDCCA_NORM to avoid warning calltrace below
*/
if (mode == RTW_EDCCA_MODE_NUM)
mode = RTW_EDCCA_NORM;
phl_mode = rtw_edcca_mode_to_phl(mode);
if (phl_mode == RTW_EDCCA_MAX) {
RTW_WARN("%s can't get valid phl mode from %s(%d)\n", __func__, rtw_edcca_mode_str(mode), mode);
rtw_warn_on(1);
return;
}
exit:
if (rtw_phl_get_edcca_mode(phl) != phl_mode)
rtw_phl_set_edcca_mode(phl, phl_mode);
}
void rtw_dump_phl_tx_power_ext_info(void *sel, _adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
void *phl_info = GET_PHL_INFO(dvobj);
struct rtw_phl_com_t *phl_com = GET_PHL_COM(dvobj);
u8 band_idx;
if (!adapter->phl_role)
return;
band_idx = adapter->phl_role->hw_band;
RTW_PRINT_SEL(sel, "tx_power_by_rate: %s, %s, %s\n"
, phl_com->dev_cap.pwrbyrate_off == RTW_PW_BY_RATE_ON ? "enabled" : "disabled"
, phl_com->dev_cap.pwrbyrate_off == RTW_PW_BY_RATE_ON ? "loaded" : "unloaded"
, phl_com->phy_sw_cap[0].rf_txpwr_byrate_info.para_src == RTW_PARA_SRC_EXTNAL ? "file" : "default"
);
RTW_PRINT_SEL(sel, "tx_power_limit: %s, %s, %s\n"
, rtw_phl_get_pwr_lmt_en(phl_info, band_idx) ? "enabled" : "disabled"
, rtw_phl_get_pwr_lmt_en(phl_info, band_idx) ? "loaded" : "unloaded"
, phl_com->phy_sw_cap[0].rf_txpwrlmt_info.para_src == RTW_PARA_SRC_EXTNAL ? "file" : "default"
);
RTW_PRINT_SEL(sel, "tx_power_limit_ru: %s, %s, %s\n"
, rtw_phl_get_pwr_lmt_en(phl_info, band_idx) ? "enabled" : "disabled"
, rtw_phl_get_pwr_lmt_en(phl_info, band_idx) ? "loaded" : "unloaded"
, phl_com->phy_sw_cap[0].rf_txpwrlmt_ru_info.para_src == RTW_PARA_SRC_EXTNAL ? "file" : "default"
);
}
void rtw_update_phl_txpwr_level(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
rtw_phl_set_tx_power(GET_PHL_INFO(dvobj), adapter->phl_role->hw_band);
rtw_rfctl_update_op_mode(adapter_to_rfctl(adapter), 0, 0);
}
|
2301_81045437/rtl8852be
|
core/rtw_phl.c
|
C
|
agpl-3.0
| 68,075
|
/******************************************************************************
*
* Copyright(c) 2019 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#if defined(CONFIG_CMD_GENERAL) || defined(CONFIG_STA_CMD_DISPR) || defined(CONFIG_CMD_TSF_SYNC)
#ifdef CONFIG_CMD_GENERAL/*for warkaround*/
static void
phl_run_core_cmd(void *drv_priv, u8 *cmd, u32 cmd_len, enum rtw_phl_status status)
{
struct dvobj_priv *dvobj = (struct dvobj_priv *)drv_priv;
struct cmd_obj *pcmd = (struct cmd_obj *)cmd;
_adapter *padapter = pcmd->padapter;
struct cmd_priv *pcmdpriv = &dvobj->cmdpriv;
if (status == RTW_PHL_STATUS_CANNOT_IO ||
status == RTW_PHL_STATUS_CMD_ERROR ||
RTW_CANNOT_RUN(dvobj)) {
RTW_INFO(FUNC_ADPT_FMT "%s FALSE -bDriverStopped(%s) bSurpriseRemoved(%s)\n"
, FUNC_ADPT_ARG(padapter)
, rtw_cmd_name(pcmd)
, dev_is_drv_stopped(dvobj) ? "True" : "False"
, dev_is_surprise_removed(dvobj) ? "True" : "False");
if (pcmd->cmdcode == CMD_SET_DRV_EXTRA) {
struct drvextra_cmd_parm *extra_parm =
(struct drvextra_cmd_parm *)pcmd->parmbuf;
if (extra_parm->pbuf && (extra_parm->size > 0))
rtw_mfree(extra_parm->pbuf, extra_parm->size);
}
_rtw_mutex_lock(&pcmdpriv->sctx_mutex);
if (pcmd->sctx) {
if (0)
RTW_PRINT(FUNC_ADPT_FMT" pcmd->sctx\n", FUNC_ADPT_ARG(pcmd->padapter));
rtw_sctx_done_err(&pcmd->sctx, RTW_SCTX_DONE_CMD_DROP);
}
_rtw_mutex_unlock(&pcmdpriv->sctx_mutex);
rtw_free_cmd_obj(pcmd);
return;
}
if (status == RTW_PHL_STATUS_CMD_TIMEOUT)
RTW_ERR("%s %s cmd timeout\n", __func__, rtw_cmd_name(pcmd));
else if (status == RTW_PHL_STATUS_FAILURE) /*PHL fail due to 1. CMD_DROP:cmd abort or cancel 2.CMD_FAIL*/
RTW_ERR("%s %s cmd failure\n", __func__, rtw_cmd_name(pcmd));
rtw_run_cmd(padapter, pcmd, false);
}
#endif /* CONFIG_CMD_GENERAL */
#ifdef CONFIG_STA_CMD_DISPR
static u32 _evt_joinbss_hdl(struct _ADAPTER *a, struct wlan_network *network)
{
struct dvobj_priv *d;
u8 *mac;
struct sta_info *sta;
enum rtw_phl_status status;
u32 res = _FAIL;
d = adapter_to_dvobj(a);
mac = network->network.MacAddress;
sta = rtw_get_stainfo(&a->stapriv, mac);
if (!sta) {
RTW_ERR(FUNC_ADPT_FMT ": sta(" MAC_FMT ") not found!\n",
FUNC_ADPT_ARG(a), MAC_ARG(mac));
goto disconnect;
}
if (network->join_res < 0)
goto disconnect;
status = rtw_phl_connect_linked(d->phl, a->phl_role, sta->phl_sta, mac);
if (status == RTW_PHL_STATUS_SUCCESS)
return _SUCCESS;
RTW_ERR(FUNC_ADPT_FMT ": rtw_phl_connect_linked FAIL(%u)!\n",
FUNC_ADPT_ARG(a), status);
disconnect:
RTW_INFO(FUNC_ADPT_FMT ": something may go wrong, run disconnect! "
"join_res=%d for " MAC_FMT "\n",
FUNC_ADPT_ARG(a), network->join_res, MAC_ARG(mac));
status = rtw_connect_disconnect_prepare(a);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR(FUNC_ADPT_FMT ": rtw_connect_disconnect_prepare FAIL(%u)!\n",
FUNC_ADPT_ARG(a), status);
goto exit;
}
res = _SUCCESS;
exit:
return res;
}
#endif /* CONFIG_STA_CMD_DISPR */
#ifdef CONFIG_CMD_TSF_SYNC
enum rtw_phl_status rtw_send_tsf_sync_done_msg(struct _ADAPTER *a)
{
struct dvobj_priv *d = adapter_to_dvobj(a);
struct phl_msg msg = {0};
struct phl_msg_attribute attr = {0};
struct rtw_wifi_role_t *role = a->phl_role;
enum rtw_phl_status status;
RTW_DBG(FUNC_ADPT_FMT ": +\n", FUNC_ADPT_ARG(a));
SET_MSG_MDL_ID_FIELD(msg.msg_id, PHL_MDL_MRC);
SET_MSG_EVT_ID_FIELD(msg.msg_id, MSG_EVT_TSF_SYNC_DONE);
msg.band_idx = role->hw_band;
msg.inbuf = (u8 *)role;
status = rtw_phl_send_msg_to_dispr(GET_PHL_INFO(d),
&msg, &attr, NULL);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR(FUNC_ADPT_FMT ": Send tsf sync done event fail(0x%02x)!\n",
FUNC_ADPT_ARG(a), status);
}
return status;
}
#endif /* CONFIG_CMD_TSF_SYNC */
#ifdef CONFIG_PCIE_TRX_MIT
static void rtw_pcie_trx_mit_cb(void *drv_priv, u8 *cmd, u32 cmd_len, enum rtw_phl_status status)
{
/* cmd point to mit_info. */
struct rtw_pcie_trx_mit_info_t *mit_info = (struct rtw_pcie_trx_mit_info_t *)cmd;
RTW_DBG("%s: mit_info pointer=%p\n", __func__, mit_info);
rtw_mfree(mit_info, sizeof(struct rtw_pcie_trx_mit_info_t));
}
u8 rtw_pcie_trx_mit_cmd(_adapter *padapter, u32 tx_timer, u8 tx_counter,
u32 rx_timer, u8 rx_counter, u8 fixed_mit)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_pcie_trx_mit_info_t *mit_info;
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
u8 res = _FAIL;
mit_info = (struct rtw_pcie_trx_mit_info_t *)rtw_zmalloc(sizeof(struct rtw_pcie_trx_mit_info_t));
if (mit_info == NULL)
goto exit;
mit_info->tx_timer = tx_timer;
mit_info->tx_counter = tx_counter;
mit_info->rx_timer = rx_timer;
mit_info->rx_counter = rx_counter;
mit_info->fixed_mitigation = fixed_mit;
RTW_DBG("%s: mit_info pointer=%p\n", __func__, mit_info);
psts = rtw_phl_cmd_enqueue(dvobj->phl,
padapter->phl_role->hw_band,
MSG_EVT_PCIE_TRX_MIT,
(u8 *)mit_info, sizeof(mit_info),
rtw_pcie_trx_mit_cb,
PHL_CMD_NO_WAIT, 0);
/* Send cmd fail */
if (psts != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s: cmd failed!\n", __func__);
rtw_mfree(mit_info, sizeof(struct rtw_pcie_trx_mit_info_t));
goto exit;
}
res = _SUCCESS;
exit:
return res;
}
#endif /* CONFIG_PCIE_TRX_MIT */
u32 rtw_enqueue_phl_cmd(struct cmd_obj *pcmd)
{
u32 res = _FAIL;
_adapter *padapter = pcmd->padapter;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
if (rtw_is_adapter_up(padapter) == _FALSE)
goto free_cmd;
#if defined(CONFIG_STA_CMD_DISPR) || defined(CONFIG_CMD_TSF_SYNC) || defined(CONFIG_CMD_AP_DISPR)
switch (pcmd->cmdcode) {
#ifdef CONFIG_STA_CMD_DISPR
case CMD_JOINBSS:
{
struct _WLAN_BSSID_EX *network;
network = (struct _WLAN_BSSID_EX*)pcmd->parmbuf;
psts = rtw_connect_cmd(padapter, network);
if (psts == RTW_PHL_STATUS_SUCCESS)
res = _SUCCESS;
/* pcmd & pcmd->parmbuf should be freed here */
goto free_cmd;
}
case CMD_DISCONNECT:
/*
* Disconnect for STA wouldn't come to here,
* because it would be handled in rtw_disassoc_cmd() directly.
*/
break;
case CMD_SET_MLME_EVT:
{
struct rtw_evt_header *hdr;
struct wlan_network *network;
hdr = (struct rtw_evt_header*)pcmd->parmbuf;
switch (hdr->id) {
case EVT_JOINBSS:
network = (struct wlan_network *)(pcmd->parmbuf + sizeof(*hdr));
res = _evt_joinbss_hdl(padapter, network);
goto free_cmd;
case EVT_DEL_STA:
if (MLME_IS_STA(padapter)) {
psts = rtw_disconnect_cmd(padapter, pcmd);
if (psts != RTW_PHL_STATUS_SUCCESS)
goto free_cmd;
/* pcmd & pcmd->parmbuf would be freed in framework */
res = _SUCCESS;
goto exit;
}
break;
default:
break;
}
/* not handled event would be processed later */
break;
}
#endif /* CONFIG_STA_CMD_DISPR */
#ifdef CONFIG_AP_CMD_DISPR
case CMD_CREATE_BSS:
{
psts = rtw_ap_start_cmd(pcmd);
if (psts != RTW_PHL_STATUS_SUCCESS)
goto free_cmd;
/* pcmd & pcmd->parmbuf should be freed here */
res = _SUCCESS;
goto exit;
}
#endif /* CONFIG_AP_CMD_DISPR */
#ifdef CONFIG_AP_CMD_DISPR
case CMD_SET_DRV_EXTRA:
{
struct drvextra_cmd_parm *parm;
parm = (struct drvextra_cmd_parm *)pcmd->parmbuf;
if (parm->ec_id == STOP_AP_WK_CID) {
psts = rtw_ap_stop_cmd(pcmd);
if (psts != RTW_PHL_STATUS_SUCCESS)
goto free_cmd;
res = _SUCCESS;
goto exit;
}
break;
}
#endif /* CONFIG_CMD_TSF_SYNC || CONFIG_AP_CMD_DISPR */
default:
break;
}
#endif /* CONFIG_STA_CMD_DISPR || CONFIG_CMD_TSF_SYNC || CONFIG_CMD_AP_DISPR */
#ifdef CONFIG_CMD_GENERAL
psts = rtw_phl_cmd_enqueue(dvobj->phl,
padapter->phl_role->hw_band,
MSG_EVT_LINUX_CMD_WRK,
(u8 *)pcmd, sizeof(struct cmd_obj),
phl_run_core_cmd,
PHL_CMD_NO_WAIT, 0);
/* Send cmd fail */
if (psts != RTW_PHL_STATUS_SUCCESS)
goto free_cmd; /* keep res == _FAIL */
#endif /* CONFIG_CMD_GENERAL */
res = _SUCCESS;
goto exit;
free_cmd:
if (pcmd->cmdcode == CMD_SET_DRV_EXTRA) {
struct drvextra_cmd_parm *extra_parm =
(struct drvextra_cmd_parm *)pcmd->parmbuf;
if (extra_parm->pbuf && (extra_parm->size > 0))
rtw_mfree(extra_parm->pbuf, extra_parm->size);
}
rtw_free_cmd_obj(pcmd);
exit:
return res;
}
#else /*CONFIG_FSM*/
static void phl_run_core_cmd(void *priv, void *parm, bool discard)
{
_adapter *padapter = (_adapter *)priv;
struct cmd_obj *pcmd = (struct cmd_obj *)parm;
rtw_run_cmd(padapter, pcmd, discard);
}
#define PHL_RES2RES(a) (a == RTW_PHL_STATUS_SUCCESS) ? _SUCCESS : _FAIL
u32 rtw_enqueue_phl_cmd(struct cmd_obj *pcmd)
{
u32 res = RTW_PHL_STATUS_FAILURE;
_adapter *padapter = pcmd->padapter;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct phl_cmd_job job;
void *msg;
_rtw_memset(&job, 0, sizeof(job));
switch (pcmd->cmdcode) {
#ifndef CONFIG_CMD_SCAN
case CMD_SITE_SURVEY:
{
res = rtw_site_survey_fsm(padapter, pcmd);
}
break;
#endif /*CONFIG_CMD_SCAN*/
case CMD_SET_DRV_EXTRA:
{
struct drvextra_cmd_parm *parm;
parm = (struct drvextra_cmd_parm *)pcmd->parmbuf;
if ((parm->ec_id == MGNT_TX_WK_CID) &&
(rtw_cfg80211_get_is_roch(padapter))) {
rtw_phl_job_fill_fptr(dvobj->phl, &job,
phl_run_core_cmd, padapter,
pcmd, rtw_cmd_name(pcmd),
(pcmd->no_io) ? PWR_NO_IO : PWR_BASIC_IO);
res = rtw_phl_scan_off_ch_tx(
dvobj->phl, &job, sizeof(job));
if (res != RTW_PHL_STATUS_SUCCESS)
goto free_cmd;
return PHL_RES2RES(res);
}
}
/* fall through */
default:
rtw_phl_job_fill_fptr(dvobj->phl, &job,
phl_run_core_cmd, padapter,
pcmd, rtw_cmd_name(pcmd),
(pcmd->no_io) ? PWR_NO_IO : PWR_BASIC_IO);
res = phl_cmd_complete_job(dvobj->phl, &job);
if (res != RTW_PHL_STATUS_SUCCESS)
goto free_cmd;
return PHL_RES2RES(res);
}
free_cmd:
if (pcmd->cmdcode == CMD_SET_DRV_EXTRA) {
struct drvextra_cmd_parm *extra_parm =
(struct drvextra_cmd_parm *)pcmd->parmbuf;
if (extra_parm->pbuf && extra_parm->size > 0)
rtw_mfree(extra_parm->pbuf, extra_parm->size);
}
rtw_free_cmd_obj(pcmd);
return PHL_RES2RES(res);
}
#endif /*CONFIG_FSM*/
|
2301_81045437/rtl8852be
|
core/rtw_phl_cmd.c
|
C
|
agpl-3.0
| 10,616
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_PWRCTRL_C_
#include <drv_types.h>
#ifdef CONFIG_RTW_IPS
bool rtw_core_set_ips_state(void *drv_priv, enum rtw_rf_state state)
{
struct dvobj_priv *dvobj = (struct dvobj_priv *)drv_priv;
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
if (state == RTW_RF_ON) {
pstatus = rtw_phl_rf_on(dvobj->phl);
} else if (state == RTW_RF_OFF) {
pstatus = rtw_phl_rf_off(dvobj->phl);
}
if (RTW_PHL_STATUS_SUCCESS == pstatus)
return true;
else
return false;
}
#endif
#ifdef DBG_CHECK_FW_PS_STATE
int rtw_fw_ps_state(_adapter *padapter)
{
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
int ret = _FAIL, dont_care = 0;
u8 ps_state = 0;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct registry_priv *registry_par = &padapter->registrypriv;
if (registry_par->check_fw_ps != 1)
return _SUCCESS;
_enter_pwrlock(&pwrpriv->check_32k_lock);
if (RTW_CANNOT_RUN(psdpriv)) {
RTW_INFO("%s: bSurpriseRemoved=%s , hw_init_completed=%d, bDriverStopped=%s\n", __func__
, dev_is_surprise_removed(adapter_to_dvobj(padapter)) ? "True" : "False"
, rtw_hw_get_init_completed(adapter_to_dvobj(padapter))
, dev_is_drv_stopped(adapter_to_dvobj(padapter)) ? "True" : "False");
goto exit_fw_ps_state;
}
rtw_hal_get_hwreg(padapter, HW_VAR_FW_PS_STATE, (u8 *)&ps_state);
if (ps_state == PS_ACTIVE) {
ret = _SUCCESS;
} else {
pdbgpriv->dbg_poll_fail_cnt++;
RTW_INFO("%s: fw_ps_state=%04x\n", __func__, ps_state);
}
exit_fw_ps_state:
_exit_pwrlock(&pwrpriv->check_32k_lock);
return ret;
}
#endif /*DBG_CHECK_FW_PS_STATE*/
#ifdef CONFIG_IPS
void _ips_enter(_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->bips_processing = _TRUE;
/* syn ips_mode with request */
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
RTW_INFO("==>ips_enter cnts:%d\n", pwrpriv->ips_enter_cnts);
if (rf_off == pwrpriv->change_rfpwrstate) {
pwrpriv->bpower_saving = _TRUE;
RTW_PRINT("nolinked power save enter\n");
if (pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = _TRUE;
#ifdef CONFIG_RTW_CFGVENDOR_LLSTATS
pwrpriv->pwr_saving_start_time = rtw_get_current_time();
#endif /* CONFIG_RTW_CFGVENDOR_LLSTATS */
rtw_ips_pwr_down(padapter);
pwrpriv->rf_pwrstate = rf_off;
}
pwrpriv->bips_processing = _FALSE;
}
void ips_enter(_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
_enter_pwrlock(&pwrpriv->lock);
_ips_enter(padapter);
_exit_pwrlock(&pwrpriv->lock);
#ifdef CONFIG_PCI_DYNAMIC_ASPM
rtw_pci_dynamic_aspm_set_mode(padapter, ASPM_MODE_PS);
#endif
}
int _ips_leave(_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
int result = _SUCCESS;
if ((pwrpriv->rf_pwrstate == rf_off) && (!pwrpriv->bips_processing)) {
pwrpriv->bips_processing = _TRUE;
pwrpriv->change_rfpwrstate = rf_on;
pwrpriv->ips_leave_cnts++;
RTW_INFO("==>ips_leave cnts:%d\n", pwrpriv->ips_leave_cnts);
result = rtw_ips_pwr_up(padapter);
if (result == _SUCCESS)
pwrpriv->rf_pwrstate = rf_on;
#ifdef CONFIG_RTW_CFGVENDOR_LLSTATS
pwrpriv->pwr_saving_time += rtw_get_passing_time_ms(pwrpriv->pwr_saving_start_time);
#endif /* CONFIG_RTW_CFGVENDOR_LLSTATS */
RTW_PRINT("nolinked power save leave\n");
#if 0 /*GEORGIA_TODO_REDEFINE_IO*/
RTW_INFO("==> ips_leave.....LED(0x%08x)...\n", rtw_read32(padapter, 0x4c));
#endif
pwrpriv->bips_processing = _FALSE;
pwrpriv->bkeepfwalive = _FALSE;
pwrpriv->bpower_saving = _FALSE;
}
return result;
}
int ips_leave(_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
#ifdef DBG_CHECK_FW_PS_STATE
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
#endif
int ret;
if (!is_primary_adapter(padapter))
return _SUCCESS;
_enter_pwrlock(&pwrpriv->lock);
ret = _ips_leave(padapter);
#ifdef DBG_CHECK_FW_PS_STATE
if (rtw_fw_ps_state(padapter) == _FAIL) {
RTW_INFO("ips leave doesn't leave 32k\n");
pdbgpriv->dbg_leave_ips_fail_cnt++;
}
#endif /* DBG_CHECK_FW_PS_STATE */
_exit_pwrlock(&pwrpriv->lock);
#ifdef CONFIG_PCI_DYNAMIC_ASPM
rtw_pci_dynamic_aspm_set_mode(padapter, ASPM_MODE_PERF);
#endif
return ret;
}
#endif /* CONFIG_IPS */
#ifdef CONFIG_POWER_SAVING
bool rtw_pwr_unassociated_idle(_adapter *adapter)
{
u8 i;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct xmit_priv *pxmit_priv = &adapter->xmitpriv;
struct mlme_priv *pmlmepriv;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo;
#endif
u8 xmitbuf_nr = GET_HAL_XMITBUF_NR(dvobj);
u8 xmitbuf_ext_nr = GET_HAL_XMITBUF_EXT_NR(dvobj);
bool ret = _FALSE;
if (adapter_to_pwrctl(adapter)->bpower_saving == _TRUE) {
/* RTW_INFO("%s: already in LPS or IPS mode\n", __func__); */
goto exit;
}
if (rtw_time_after(adapter_to_pwrctl(adapter)->ips_deny_time, rtw_get_current_time())) {
/* RTW_INFO("%s ips_deny_time\n", __func__); */
goto exit;
}
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
pmlmepriv = &(iface->mlmepriv);
#ifdef CONFIG_P2P
pwdinfo = &(iface->wdinfo);
#endif
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE | WIFI_UNDER_SURVEY)
|| check_fwstate(pmlmepriv, WIFI_UNDER_LINKING | WIFI_UNDER_WPS)
|| MLME_IS_AP(iface)
|| MLME_IS_MESH(iface)
|| check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE)
#if defined(CONFIG_P2P) && defined(CONFIG_IOCTL_CFG80211)
|| rtw_cfg80211_get_is_roch(iface) == _TRUE
|| (rtw_cfg80211_is_ro_ch_once(adapter)
&& rtw_cfg80211_get_last_ro_ch_passing_ms(adapter) < 3000)
#endif
)
goto exit;
}
}
#if (MP_DRIVER == 1)
if (adapter->registrypriv.mp_mode == 1)
goto exit;
#endif
if (pxmit_priv->free_xmitbuf_cnt != xmitbuf_nr ||
pxmit_priv->free_xmit_extbuf_cnt != xmitbuf_ext_nr) {
RTW_PRINT("There are some pkts to transmit\n");
RTW_PRINT("free_xmitbuf_cnt: %d, free_xmit_extbuf_cnt: %d\n",
pxmit_priv->free_xmitbuf_cnt, pxmit_priv->free_xmit_extbuf_cnt);
goto exit;
}
ret = _TRUE;
exit:
return ret;
}
/*
* ATTENTION:
* rtw_ps_processor() doesn't handle LPS.
*/
void rtw_ps_processor(_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
u32 ps_deny = 0;
_enter_pwrlock(&adapter_to_pwrctl(padapter)->lock);
ps_deny = rtw_ps_deny_get(padapter);
_exit_pwrlock(&adapter_to_pwrctl(padapter)->lock);
if (ps_deny != 0) {
if (!MLME_IS_MONITOR(padapter)) {
RTW_INFO(FUNC_ADPT_FMT ": ps_deny=0x%08X, skip power save!\n",
FUNC_ADPT_ARG(padapter), ps_deny);
}
goto exit;
}
if (pwrpriv->bInSuspend == _TRUE) { /* system suspend or autosuspend */
pdbgpriv->dbg_ps_insuspend_cnt++;
RTW_INFO("%s, pwrpriv->bInSuspend == _TRUE ignore this process\n", __FUNCTION__);
return;
}
pwrpriv->ps_processing = _TRUE;
if (pwrpriv->ips_mode_req == IPS_NONE)
goto exit;
if (rtw_pwr_unassociated_idle(padapter) == _FALSE)
goto exit;
if ((pwrpriv->rf_pwrstate == rf_on) && ((pwrpriv->pwr_state_check_cnts % 4) == 0)) {
RTW_INFO("==>%s .fw_state(%x)\n", __FUNCTION__, get_fwstate(pmlmepriv));
pwrpriv->change_rfpwrstate = rf_off;
#ifdef CONFIG_IPS
ips_enter(padapter);
#endif
}
exit:
#ifndef CONFIG_IPS_CHECK_IN_WD
rtw_set_pwr_state_check_timer(pwrpriv);
#endif
pwrpriv->ps_processing = _FALSE;
return;
}
#endif
#ifdef CONFIG_POWER_SAVING
void pwr_state_check_handler(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
rtw_ps_cmd(padapter);
}
#endif
#ifdef CONFIG_LPS
#ifdef CONFIG_CHECK_LEAVE_LPS
#ifdef CONFIG_LPS_CHK_BY_TP
void traffic_check_for_leave_lps_by_tp(_adapter *padapter, u8 tx, struct sta_info *sta)
{
struct stainfo_stats *pstats = &sta->sta_stats;
u64 cur_acc_tx_bytes = 0, cur_acc_rx_bytes = 0;
u32 tx_tp_kbyte = 0, rx_tp_kbyte = 0;
u32 tx_tp_th = 0, rx_tp_th = 0;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
u8 leave_lps = _FALSE;
if (tx) { /* from tx */
cur_acc_tx_bytes = pstats->tx_bytes - pstats->acc_tx_bytes;
tx_tp_kbyte = cur_acc_tx_bytes >> 10;
tx_tp_th = pwrpriv->lps_tx_tp_th * 1024 / 8 * 2; /*KBytes @2s*/
if (tx_tp_kbyte >= tx_tp_th ||
padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod >= pwrpriv->lps_tx_pkts){
if (pwrpriv->bLeisurePs
&& (pwrpriv->pwr_mode != PM_PS_MODE_ACTIVE)
) {
leave_lps = _TRUE;
}
}
} else { /* from rx path */
cur_acc_rx_bytes = pstats->rx_bytes - pstats->acc_rx_bytes;
rx_tp_kbyte = cur_acc_rx_bytes >> 10;
rx_tp_th = pwrpriv->lps_rx_tp_th * 1024 / 8 * 2;
if (rx_tp_kbyte>= rx_tp_th ||
padapter->mlmepriv.LinkDetectInfo.NumRxUnicastOkInPeriod >= pwrpriv->lps_rx_pkts) {
if (pwrpriv->bLeisurePs
&& (pwrpriv->pwr_mode != PM_PS_MODE_ACTIVE)
) {
leave_lps = _TRUE;
}
}
}
if (leave_lps) {
#ifdef DBG_LPS_CHK_BY_TP
RTW_INFO("leave lps via %s, ", tx ? "Tx" : "Rx");
if (tx)
RTW_INFO("Tx = %d [%d] (KB)\n", tx_tp_kbyte, tx_tp_th);
else
RTW_INFO("Rx = %d [%d] (KB)\n", rx_tp_kbyte, rx_tp_th);
#endif
pwrpriv->lps_chk_cnt = pwrpriv->lps_chk_cnt_th;
/* rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 0); */
rtw_lps_ctrl_wk_cmd(padapter, tx ? LPS_CTRL_TX_TRAFFIC_LEAVE : LPS_CTRL_RX_TRAFFIC_LEAVE, 0);
}
}
#endif /*CONFIG_LPS_CHK_BY_TP*/
void traffic_check_for_leave_lps(_adapter *padapter, u8 tx, u32 tx_packets)
{
static systime start_time = 0;
static u32 xmit_cnt = 0;
u8 bLeaveLPS = _FALSE;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (tx) { /* from tx */
xmit_cnt += tx_packets;
if (start_time == 0)
start_time = rtw_get_current_time();
if (rtw_get_passing_time_ms(start_time) > 2000) { /* 2 sec == watch dog timer */
if (xmit_cnt > 8) {
if ((adapter_to_pwrctl(padapter)->bLeisurePs)
&& (adapter_to_pwrctl(padapter)->pwr_mode != PM_PS_MODE_ACTIVE)
) {
/* RTW_INFO("leave lps via Tx = %d\n", xmit_cnt); */
bLeaveLPS = _TRUE;
}
}
start_time = rtw_get_current_time();
xmit_cnt = 0;
}
} else { /* from rx path */
if (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 4/*2*/) {
if ((adapter_to_pwrctl(padapter)->bLeisurePs)
&& (adapter_to_pwrctl(padapter)->pwr_mode != PM_PS_MODE_ACTIVE)
) {
/* RTW_INFO("leave lps via Rx = %d\n", pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod); */
bLeaveLPS = _TRUE;
}
}
}
if (bLeaveLPS) {
/* RTW_INFO("leave lps via %s, Tx = %d, Rx = %d\n", tx?"Tx":"Rx", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod,pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod); */
/* rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 0); */
rtw_lps_ctrl_wk_cmd(padapter, tx ? LPS_CTRL_TX_TRAFFIC_LEAVE : LPS_CTRL_RX_TRAFFIC_LEAVE, tx ? RTW_CMDF_DIRECTLY : 0);
}
}
#endif /* CONFIG_CHECK_LEAVE_LPS */
#ifdef CONFIG_LPS_LCLK
#define LPS_CPWM_TIMEOUT_MS 10 /*ms*/
#define LPS_RPWM_RETRY_CNT 3
u8 rtw_cpwm_polling(_adapter *adapter, u8 rpwm, u8 cpwm_orig)
{
u8 rst = _FAIL;
u8 cpwm_now = 0;
systime start_time;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
#ifdef DBG_CHECK_FW_PS_STATE
struct debug_priv *pdbgpriv = &(adapter_to_dvobj(adapter)->drv_dbg);
#endif
pwrpriv->rpwm_retry = 0;
do {
start_time = rtw_get_current_time();
do {
rtw_msleep_os(1);
rtw_hal_get_hwreg(adapter, HW_VAR_CPWM, &cpwm_now);
if ((cpwm_orig ^ cpwm_now) & 0x80) {
pwrpriv->cpwm = PS_STATE_S4;
pwrpriv->cpwm_tog = cpwm_now & PS_TOGGLE;
rst = _SUCCESS;
break;
}
} while (rtw_get_passing_time_ms(start_time) < LPS_CPWM_TIMEOUT_MS && !RTW_CANNOT_RUN(adapter_to_dvobj(adapter)));
if (rst == _SUCCESS)
break;
else {
/* rpwm retry */
cpwm_orig = cpwm_now;
rpwm &= ~PS_TOGGLE;
rpwm |= pwrpriv->tog;
rtw_hal_set_hwreg(adapter, HW_VAR_SET_RPWM, (u8 *)(&rpwm));
pwrpriv->tog += 0x80;
}
} while (pwrpriv->rpwm_retry++ < LPS_RPWM_RETRY_CNT && !RTW_CANNOT_RUN(adapter_to_dvobj(adapter)));
if (rst == _SUCCESS) {
#ifdef DBG_CHECK_FW_PS_STATE
RTW_INFO("%s: polling cpwm OK! rpwm_retry=%d, cpwm_orig=%02x, cpwm_now=%02x , 0x100=0x%x\n"
, __func__, pwrpriv->rpwm_retry, cpwm_orig, cpwm_now, rtw_read8(adapter, REG_CR));
if (rtw_fw_ps_state(adapter) == _FAIL) {
RTW_INFO("leave 32k but fw state in 32k\n");
pdbgpriv->dbg_rpwm_toogle_cnt++;
}
#endif /* DBG_CHECK_FW_PS_STATE */
} else {
RTW_ERR("%s: polling cpwm timeout! rpwm_retry=%d, cpwm_orig=%02x, cpwm_now=%02x\n"
, __func__, pwrpriv->rpwm_retry, cpwm_orig, cpwm_now);
#ifdef DBG_CHECK_FW_PS_STATE
if (rtw_fw_ps_state(adapter) == _FAIL) {
RTW_INFO("rpwm timeout and fw ps state in 32k\n");
pdbgpriv->dbg_rpwm_timeout_fail_cnt++;
}
#endif /* DBG_CHECK_FW_PS_STATE */
#ifdef CONFIG_LPS_RPWM_TIMER
_set_timer(&pwrpriv->pwr_rpwm_timer, 1);
#endif /* CONFIG_LPS_RPWM_TIMER */
}
return rst;
}
#endif
/*
* Description:
* This function MUST be called under power lock protect
*
* Parameters
* padapter
* pslv power state level, only could be PS_STATE_S0 ~ PS_STATE_S4
*
*/
u8 rtw_set_rpwm(_adapter *padapter, u8 pslv)
{
u8 rpwm = 0xFF;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
#ifdef CONFIG_LPS_LCLK
u8 cpwm_orig;
#endif
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
pslv = PS_STATE(pslv);
#ifdef CONFIG_LPS_RPWM_TIMER
if (pwrpriv->brpwmtimeout == _TRUE)
RTW_INFO("%s: RPWM timeout, force to set RPWM(0x%02X) again!\n", __FUNCTION__, pslv);
else
#endif /* CONFIG_LPS_RPWM_TIMER */
{
if ((pwrpriv->rpwm == pslv)
#ifdef CONFIG_LPS_LCLK
|| ((pwrpriv->rpwm >= PS_STATE_S2) && (pslv >= PS_STATE_S2))
#endif
|| (pwrpriv->lps_level == LPS_NORMAL)
) {
return rpwm;
}
}
if (dev_is_surprise_removed(dvobj) ||
(!rtw_hw_is_init_completed(dvobj))) {
pwrpriv->cpwm = PS_STATE_S4;
return rpwm;
}
if (dev_is_drv_stopped(dvobj))
if (pslv < PS_STATE_S2)
return rpwm;
rpwm = pslv | pwrpriv->tog;
#ifdef CONFIG_LPS_LCLK
/* only when from PS_STATE S0/S1 to S2 and higher needs ACK */
if ((pwrpriv->cpwm < PS_STATE_S2) && (pslv >= PS_STATE_S2))
rpwm |= PS_ACK;
#endif
pwrpriv->rpwm = pslv;
#ifdef CONFIG_LPS_LCLK
cpwm_orig = 0;
if (rpwm & PS_ACK)
rtw_hal_get_hwreg(padapter, HW_VAR_CPWM, &cpwm_orig);
#endif
#if defined(CONFIG_LPS_RPWM_TIMER) && !defined(CONFIG_DETECT_CPWM_BY_POLLING)
if (rpwm & PS_ACK) {
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN) || defined(CONFIG_P2P_WOWLAN)
if (pwrpriv->wowlan_mode != _TRUE &&
pwrpriv->wowlan_ap_mode != _TRUE &&
pwrpriv->wowlan_p2p_mode != _TRUE)
#endif
_set_timer(&pwrpriv->pwr_rpwm_timer, LPS_CPWM_TIMEOUT_MS);
}
#endif /* CONFIG_LPS_RPWM_TIMER & !CONFIG_DETECT_CPWM_BY_POLLING */
rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&rpwm));
pwrpriv->tog += 0x80;
#ifdef CONFIG_LPS_LCLK
/* No LPS 32K, No Ack */
if (rpwm & PS_ACK) {
#ifdef CONFIG_DETECT_CPWM_BY_POLLING
rtw_cpwm_polling(padapter, rpwm, cpwm_orig);
#else
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN) || defined(CONFIG_P2P_WOWLAN)
if (pwrpriv->wowlan_mode == _TRUE ||
pwrpriv->wowlan_ap_mode == _TRUE ||
pwrpriv->wowlan_p2p_mode == _TRUE)
rtw_cpwm_polling(padapter, rpwm, cpwm_orig);
#endif /*#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN) || defined(CONFIG_P2P_WOWLAN)*/
#endif /*#ifdef CONFIG_DETECT_CPWM_BY_POLLING*/
} else
#endif /* CONFIG_LPS_LCLK */
{
pwrpriv->cpwm = pslv;
}
return rpwm;
}
u8 PS_RDY_CHECK(_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
if (_TRUE == pwrpriv->bInSuspend && pwrpriv->wowlan_mode)
return _TRUE;
else if (_TRUE == pwrpriv->bInSuspend && pwrpriv->wowlan_ap_mode)
return _TRUE;
else if (_TRUE == pwrpriv->bInSuspend)
return _FALSE;
#else
if (_TRUE == pwrpriv->bInSuspend)
return _FALSE;
#endif
if (rtw_time_after(pwrpriv->lps_deny_time, rtw_get_current_time()))
return _FALSE;
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)
|| check_fwstate(pmlmepriv, WIFI_UNDER_LINKING | WIFI_UNDER_WPS)
|| MLME_IS_AP(padapter)
|| MLME_IS_MESH(padapter)
|| MLME_IS_MONITOR(padapter)
|| check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE)
#if defined(CONFIG_P2P) && defined(CONFIG_IOCTL_CFG80211)
|| rtw_cfg80211_get_is_roch(padapter) == _TRUE
#endif
|| rtw_is_scan_deny(padapter)
#ifdef CONFIG_TDLS
/* TDLS link is established. */
|| (padapter->tdlsinfo.link_established == _TRUE)
#endif /* CONFIG_TDLS */
#ifdef CONFIG_DFS_MASTER
|| adapter_to_rfctl(padapter)->radar_detect_enabled
#endif
)
return _FALSE;
if ((padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) && (padapter->securitypriv.binstallGrpkey == _FALSE)) {
RTW_INFO("Group handshake still in progress !!!\n");
return _FALSE;
}
#ifdef CONFIG_IOCTL_CFG80211
if (!rtw_cfg80211_pwr_mgmt(padapter))
return _FALSE;
#endif
return _TRUE;
}
void rtw_leave_lps_and_chk(_adapter *padapter, u8 ps_mode)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
#ifdef CONFIG_LPS_ACK
_rtw_mutex_lock_interruptible(&pwrpriv->lps_ack_mutex);
rtw_sctx_init(&pwrpriv->lps_ack_sctx, 100);
#endif /* CONFIG_LPS_ACK */
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
rtw_hal_set_hwreg(padapter, HW_VAR_LPS_STATE_CHK, (u8 *)(&ps_mode));
#ifdef CONFIG_LPS_ACK
_rtw_mutex_unlock(&pwrpriv->lps_ack_mutex);
#endif /* CONFIG_LPS_ACK */
}
void rtw_set_ps_mode(_adapter *padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode, const char *msg)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN) || defined(CONFIG_P2P_WOWLAN)
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
#endif
#ifdef CONFIG_WMMPS_STA
struct registry_priv *pregistrypriv = &padapter->registrypriv;
#endif
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
#ifdef CONFIG_TDLS
struct sta_priv *pstapriv = &padapter->stapriv;
int i, j;
_list *plist, *phead;
struct sta_info *ptdls_sta;
#endif /* CONFIG_TDLS */
#ifdef CONFIG_LPS_PG
u8 lps_pg_hdl_id = 0;
#endif
if (ps_mode > PM_CARD_DISABLE) {
return;
}
if (pwrpriv->pwr_mode == ps_mode) {
if (PM_PS_MODE_ACTIVE == ps_mode)
return;
#ifndef CONFIG_BTC
#ifdef CONFIG_WMMPS_STA
if (!rtw_is_wmmps_mode(padapter))
#endif /* CONFIG_WMMPS_STA */
if ((pwrpriv->smart_ps == smart_ps) &&
(pwrpriv->bcn_ant_mode == bcn_ant_mode))
return;
#endif /* !CONFIG_BTC */
}
#ifdef CONFIG_FW_MULTI_PORT_SUPPORT
if (PM_PS_MODE_ACTIVE != ps_mode) {
rtw_set_ps_rsvd_page(padapter);
rtw_set_default_port_id(padapter);
}
#endif
#ifdef CONFIG_LPS_PG
if ((PM_PS_MODE_ACTIVE != ps_mode) && (pwrpriv->lps_level == LPS_PG)) {
if (pwrpriv->wowlan_mode != _TRUE) {
/*rtw_hal_set_lps_pg_info(padapter);*/
lps_pg_hdl_id = LPS_PG_INFO_CFG;
rtw_hal_set_hwreg(padapter, HW_VAR_LPS_PG_HANDLE, (u8 *)(&lps_pg_hdl_id));
}
}
#endif
#ifdef CONFIG_LPS_LCLK
_enter_pwrlock(&pwrpriv->lock);
#endif
/* if(pwrpriv->pwr_mode == PM_PS_MODE_ACTIVE) */
if (ps_mode == PM_PS_MODE_ACTIVE) {
if (1
#ifdef CONFIG_P2P_PS
&& (pwdinfo->opp_ps == 0)
#endif /* CONFIG_P2P_PS */
) {
RTW_INFO(FUNC_ADPT_FMT" Leave 802.11 power save - %s\n",
FUNC_ADPT_ARG(padapter), msg);
if (pwrpriv->lps_leave_cnts < UINT_MAX)
pwrpriv->lps_leave_cnts++;
else
pwrpriv->lps_leave_cnts = 0;
#ifdef CONFIG_TDLS
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
ptdls_sta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)
issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta->phl_sta->mac_addr, 0, 0, 0);
plist = get_next(plist);
}
}
#endif /* CONFIG_TDLS */
pwrpriv->pwr_mode = ps_mode;
rtw_set_rpwm(padapter, PS_STATE_S4);
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN) || defined(CONFIG_P2P_WOWLAN)
if (pwrpriv->wowlan_mode == _TRUE ||
pwrpriv->wowlan_ap_mode == _TRUE ||
pwrpriv->wowlan_p2p_mode == _TRUE) {
systime start_time;
u32 delay_ms;
u8 val8;
delay_ms = 20;
start_time = rtw_get_current_time();
do {
rtw_hal_get_hwreg(padapter, HW_VAR_SYS_CLKR, &val8);
if (!(val8 & BIT(4))) { /* 0x08 bit4 =1 --> in 32k, bit4 = 0 --> leave 32k */
pwrpriv->cpwm = PS_STATE_S4;
break;
}
if (rtw_get_passing_time_ms(start_time) > delay_ms) {
RTW_INFO("%s: Wait for FW 32K leave more than %u ms!!!\n",
__FUNCTION__, delay_ms);
pdbgpriv->dbg_wow_leave_ps_fail_cnt++;
break;
}
rtw_usleep_os(100);
} while (1);
}
#endif
#ifdef CONFIG_LPS_PG
if (pwrpriv->lps_level == LPS_PG) {
lps_pg_hdl_id = LPS_PG_REDLEMEM;
rtw_hal_set_hwreg(padapter, HW_VAR_LPS_PG_HANDLE, (u8 *)(&lps_pg_hdl_id));
}
#endif
#ifdef CONFIG_WOWLAN
if (pwrpriv->wowlan_mode == _TRUE)
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_INACTIVE_IPS, (u8 *)(&ps_mode));
#endif /* CONFIG_WOWLAN */
rtw_leave_lps_and_chk(padapter, ps_mode);
#ifdef CONFIG_LPS_PG
if (pwrpriv->lps_level == LPS_PG) {
lps_pg_hdl_id = LPS_PG_PHYDM_EN;
rtw_hal_set_hwreg(padapter, HW_VAR_LPS_PG_HANDLE, (u8 *)(&lps_pg_hdl_id));
}
#endif
pwrpriv->bFwCurrentInPSMode = _FALSE;
}
} else {
if ((PS_RDY_CHECK(padapter) && check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE))
#ifdef CONFIG_P2P_WOWLAN
|| (_TRUE == pwrpriv->wowlan_p2p_mode)
#endif /* CONFIG_P2P_WOWLAN */
#ifdef CONFIG_WOWLAN
|| WOWLAN_IS_STA_MIX_MODE(padapter)
#endif /* CONFIG_WOWLAN */
) {
u8 pslv;
RTW_INFO(FUNC_ADPT_FMT" Enter 802.11 power save - %s\n",
FUNC_ADPT_ARG(padapter), msg);
if (pwrpriv->lps_enter_cnts < UINT_MAX)
pwrpriv->lps_enter_cnts++;
else
pwrpriv->lps_enter_cnts = 0;
#ifdef CONFIG_TDLS
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
ptdls_sta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)
issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta->phl_sta->mac_addr, 1, 0, 0);
plist = get_next(plist);
}
}
#endif /* CONFIG_TDLS */
pwrpriv->bFwCurrentInPSMode = _TRUE;
pwrpriv->pwr_mode = ps_mode;
pwrpriv->smart_ps = smart_ps;
pwrpriv->bcn_ant_mode = bcn_ant_mode;
#ifdef CONFIG_LPS_PG
if (pwrpriv->lps_level == LPS_PG) {
lps_pg_hdl_id = LPS_PG_PHYDM_DIS;
rtw_hal_set_hwreg(padapter, HW_VAR_LPS_PG_HANDLE, (u8 *)(&lps_pg_hdl_id));
}
#endif
#ifdef CONFIG_WMMPS_STA
pwrpriv->wmm_smart_ps = pregistrypriv->wmm_smart_ps;
#endif /* CONFIG_WMMPS_STA */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE))
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
#ifdef CONFIG_WOWLAN
if (pwrpriv->wowlan_mode == _TRUE)
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_INACTIVE_IPS, (u8 *)(&ps_mode));
#endif /* CONFIG_WOWLAN */
#ifdef CONFIG_P2P_PS
/* Set CTWindow after LPS */
if (pwdinfo->opp_ps == 1)
p2p_ps_wk_cmd(padapter, P2P_PS_ENABLE, 0);
#endif /* CONFIG_P2P_PS */
pslv = PS_STATE_S2;
#ifdef CONFIG_LPS_LCLK
if (pwrpriv->alives == 0)
pslv = PS_STATE_S0;
#endif /* CONFIG_LPS_LCLK */
rtw_set_rpwm(padapter, pslv);
}
}
#ifdef CONFIG_LPS_LCLK
_exit_pwrlock(&pwrpriv->lock);
#endif
}
const char * const LPS_CTRL_PHYDM = "LPS_CTRL_PHYDM";
/*
* Description:
* Enter the leisure power save mode.
* */
void LPS_Enter(_adapter *padapter, const char *msg)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
int i;
char buf[32] = {0};
#ifdef DBG_LA_MODE
struct registry_priv *registry_par = &(padapter->registrypriv);
#endif
/* RTW_INFO("+LeisurePSEnter\n"); */
#if 0 /*GEORGIA_TODO_FIXIT*/
if (GET_PHL_COM(dvobj)->fw_ready == _FALSE)
return;
#endif
#ifdef DBG_LA_MODE
if(registry_par->la_mode_en == 1) {
RTW_INFO("%s LA debug mode lps_leave \n", __func__);
return;
}
#endif
/* Skip lps enter request if number of assocated adapters is not 1 */
if (rtw_mi_get_assoc_if_num(padapter) != 1)
return;
#ifndef CONFIG_FW_MULTI_PORT_SUPPORT
/* Skip lps enter request for adapter not port0 */
if (get_hw_port(padapter) != HW_PORT0)
return;
#endif
for (i = 0; i < dvobj->iface_nums; i++) {
if (PS_RDY_CHECK(dvobj->padapters[i]) == _FALSE)
return;
}
#ifdef CONFIG_P2P_PS
if (padapter->wdinfo.p2p_ps_mode == P2P_PS_NOA) {
return;/* supporting p2p client ps NOA via H2C_8723B_P2P_PS_OFFLOAD */
}
#endif /* CONFIG_P2P_PS */
if (pwrpriv->bLeisurePs) {
/* Idle for a while if we connect to AP a while ago. */
if (pwrpriv->LpsIdleCount >= 2) { /* 4 Sec */
if (pwrpriv->pwr_mode == PM_PS_MODE_ACTIVE) {
#ifdef CONFIG_WMMPS_STA
if (rtw_is_wmmps_mode(padapter))
msg = "WMMPS_IDLE";
#endif /* CONFIG_WMMPS_STA */
sprintf(buf, "WIFI-%s", msg);
pwrpriv->bpower_saving = _TRUE;
#ifdef CONFIG_RTW_CFGVENDOR_LLSTATS
pwrpriv->pwr_saving_start_time = rtw_get_current_time();
#endif /* CONFIG_RTW_CFGVENDOR_LLSTATS */
rtw_set_ps_mode(padapter, pwrpriv->power_mgnt, padapter->registrypriv.smart_ps, 0, buf);
#ifdef CONFIG_PCI_DYNAMIC_ASPM
if (msg != LPS_CTRL_PHYDM)
rtw_pci_dynamic_aspm_set_mode(padapter, ASPM_MODE_PS);
#endif
}
} else
pwrpriv->LpsIdleCount++;
}
/* RTW_INFO("-LeisurePSEnter\n"); */
}
/*
* Description:
* Leave the leisure power save mode.
* */
void LPS_Leave(_adapter *padapter, const char *msg)
{
#define LPS_LEAVE_TIMEOUT_MS 100
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
char buf[32] = {0};
#ifdef DBG_CHECK_FW_PS_STATE
struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
#endif
/* RTW_INFO("+LeisurePSLeave\n"); */
if (pwrpriv->bLeisurePs) {
if (pwrpriv->pwr_mode != PM_PS_MODE_ACTIVE) {
#ifdef CONFIG_PCI_DYNAMIC_ASPM
if (msg != LPS_CTRL_PHYDM)
rtw_pci_dynamic_aspm_set_mode(padapter, ASPM_MODE_PERF);
#endif
#ifdef CONFIG_WMMPS_STA
if (rtw_is_wmmps_mode(padapter))
msg = "WMMPS_BUSY";
#endif /* CONFIG_WMMPS_STA */
sprintf(buf, "WIFI-%s", msg);
rtw_set_ps_mode(padapter, PM_PS_MODE_ACTIVE, 0, 0, buf);
#ifdef CONFIG_RTW_CFGVENDOR_LLSTATS
pwrpriv->pwr_saving_time += rtw_get_passing_time_ms(pwrpriv->pwr_saving_start_time);
#endif /* CONFIG_RTW_CFGVENDOR_LLSTATS */
}
}
pwrpriv->bpower_saving = _FALSE;
#ifdef DBG_CHECK_FW_PS_STATE
if (rtw_fw_ps_state(padapter) == _FAIL) {
RTW_INFO("leave lps, fw in 32k\n");
pdbgpriv->dbg_leave_lps_fail_cnt++;
}
#endif /* DBG_CHECK_FW_PS_STATE
* RTW_INFO("-LeisurePSLeave\n"); */
}
#endif /* CONFIG_LPS */
void LeaveAllPowerSaveModeDirect(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
_adapter *pri_padapter = GET_PRIMARY_ADAPTER(adapter);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
#ifdef CONFIG_LPS_LCLK
#ifndef CONFIG_DETECT_CPWM_BY_POLLING
u8 cpwm_orig;
#endif /* CONFIG_DETECT_CPWM_BY_POLLING */
u8 rpwm;
#endif
int i;
RTW_INFO("%s.....\n", __FUNCTION__);
if (dev_is_surprise_removed(adapter_to_dvobj(adapter))) {
RTW_INFO(FUNC_ADPT_FMT ": bSurpriseRemoved=_TRUE Skip!\n", FUNC_ADPT_ARG(adapter));
return;
}
if (rtw_mi_check_status(adapter, MI_LINKED)) { /*connect*/
if (pwrpriv->pwr_mode == PM_PS_MODE_ACTIVE) {
RTW_INFO("%s: Driver Already Leave LPS\n", __FUNCTION__);
return;
}
#ifdef CONFIG_LPS_LCLK
_enter_pwrlock(&pwrpriv->lock);
#ifndef CONFIG_DETECT_CPWM_BY_POLLING
cpwm_orig = 0;
rtw_hal_get_hwreg(adapter, HW_VAR_CPWM, &cpwm_orig);
#endif /* CONFIG_DETECT_CPWM_BY_POLLING */
rpwm = rtw_set_rpwm(adapter, PS_STATE_S4);
#ifndef CONFIG_DETECT_CPWM_BY_POLLING
if (rpwm != 0xFF && rpwm & PS_ACK)
rtw_cpwm_polling(adapter, rpwm, cpwm_orig);
#endif /* CONFIG_DETECT_CPWM_BY_POLLING */
_exit_pwrlock(&pwrpriv->lock);
#endif/*CONFIG_LPS_LCLK*/
#ifdef CONFIG_P2P_PS
for (i = 0; i < dvobj->iface_nums; i++) {
_adapter *iface = dvobj->padapters[i];
struct wifidirect_info *pwdinfo = &(iface->wdinfo);
if (pwdinfo->p2p_ps_mode > P2P_PS_NONE)
p2p_ps_wk_cmd(iface, P2P_PS_DISABLE, 0);
}
#endif /* CONFIG_P2P_PS */
#ifdef CONFIG_LPS
rtw_lps_ctrl_wk_cmd(pri_padapter, LPS_CTRL_LEAVE, RTW_CMDF_DIRECTLY);
#endif
} else {
if (pwrpriv->rf_pwrstate == rf_off) {
#if defined(CONFIG_FWLPS_IN_IPS) || defined(CONFIG_SWLPS_IN_IPS)
#ifdef CONFIG_IPS
if (_FALSE == ips_leave(pri_padapter))
RTW_INFO("======> ips_leave fail.............\n");
#endif
#endif /* defined(CONFIG_FWLPS_IN_IPS) || defined(CONFIG_SWLPS_IN_IPS) */
}
}
}
/*
* Description: Leave all power save mode: LPS, FwLPS, IPS if needed.
* Move code to function by tynli. 2010.03.26.
* */
void LeaveAllPowerSaveMode(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
u8 enqueue = 0;
int i;
/* RTW_INFO(FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));*/
if (dev_is_surprise_removed(adapter_to_dvobj(adapter))) {
RTW_INFO(FUNC_ADPT_FMT ": bSurpriseRemoved=_TRUE Skip!\n", FUNC_ADPT_ARG(adapter));
return;
}
if (rtw_mi_get_assoc_if_num(adapter)) {
/* connect */
#ifdef CONFIG_LPS_LCLK
enqueue = 1;
#endif
#ifdef CONFIG_P2P_PS
for (i = 0; i < dvobj->iface_nums; i++) {
_adapter *iface = dvobj->padapters[i];
struct wifidirect_info *pwdinfo = &(iface->wdinfo);
if (pwdinfo->p2p_ps_mode > P2P_PS_NONE)
p2p_ps_wk_cmd(iface, P2P_PS_DISABLE, enqueue);
}
#endif /* CONFIG_P2P_PS */
#ifdef CONFIG_LPS
rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_LEAVE, enqueue ? 0 : RTW_CMDF_DIRECTLY);
#endif
#ifdef CONFIG_LPS_LCLK
LPS_Leave_check(adapter);
#endif
} else {
if (adapter_to_pwrctl(adapter)->rf_pwrstate == rf_off) {
#if defined(CONFIG_FWLPS_IN_IPS) || defined(CONFIG_SWLPS_IN_IPS)
#ifdef CONFIG_IPS
if (_FALSE == ips_leave(adapter))
RTW_INFO("======> ips_leave fail.............\n");
#endif
#endif /* defined(CONFIG_FWLPS_IN_IPS) || defined(CONFIG_SWLPS_IN_IPS) */
}
}
}
#ifdef CONFIG_LPS_LCLK
void LPS_Leave_check(
_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
systime start_time;
u8 bReady;
bReady = _FALSE;
start_time = rtw_get_current_time();
rtw_yield_os();
while (1) {
_enter_pwrlock(&pwrpriv->lock);
if (dev_is_surprise_removed(dvobj)
|| (!rtw_hw_is_init_completed(dvobj))
#ifdef CONFIG_USB_HCI
|| dev_is_drv_stopped(dvobj)
#endif
|| (pwrpriv->pwr_mode == PM_PS_MODE_ACTIVE)
)
bReady = _TRUE;
_exit_pwrlock(&pwrpriv->lock);
if (_TRUE == bReady)
break;
if (rtw_get_passing_time_ms(start_time) > 100) {
RTW_ERR("Wait for cpwm event than 100 ms!!!\n");
break;
}
rtw_msleep_os(1);
}
}
/*
* Caller:ISR handler...
*
* This will be called when CPWM interrupt is up.
*
* using to update cpwn of drv; and drv willl make a decision to up or down pwr level
*/
void cpwm_int_hdl(
_adapter *padapter,
struct reportpwrstate_parm *preportpwrstate)
{
struct pwrctrl_priv *pwrpriv;
if (!padapter)
goto exit;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
goto exit;
pwrpriv = adapter_to_pwrctl(padapter);
#if 0
if (pwrpriv->cpwm_tog == (preportpwrstate->state & PS_TOGGLE)) {
goto exit;
}
#endif
_enter_pwrlock(&pwrpriv->lock);
#ifdef CONFIG_LPS_RPWM_TIMER
if (pwrpriv->rpwm < PS_STATE_S2) {
RTW_INFO("%s: Redundant CPWM Int. RPWM=0x%02X CPWM=0x%02x\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
_exit_pwrlock(&pwrpriv->lock);
goto exit;
}
#endif /* CONFIG_LPS_RPWM_TIMER */
pwrpriv->cpwm = PS_STATE(preportpwrstate->state);
pwrpriv->cpwm_tog = preportpwrstate->state & PS_TOGGLE;
if (pwrpriv->cpwm >= PS_STATE_S2) {
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
if (pwrpriv->alives & CMD_ALIVE)
_rtw_up_sema(&padapter->cmdpriv.cmd_queue_sema);
#endif
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
if (pwrpriv->alives & XMIT_ALIVE)
_rtw_up_sema(&padapter->xmitpriv.xmit_sema);
#endif
}
_exit_pwrlock(&pwrpriv->lock);
exit:
return;
}
static void cpwm_event_callback(struct work_struct *work)
{
struct pwrctrl_priv *pwrpriv = container_of(work, struct pwrctrl_priv, cpwm_event);
struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
struct reportpwrstate_parm report;
/* RTW_INFO("%s\n",__FUNCTION__); */
report.state = PS_STATE_S2;
cpwm_int_hdl(adapter, &report);
}
static void dma_event_callback(struct work_struct *work)
{
struct pwrctrl_priv *pwrpriv = container_of(work, struct pwrctrl_priv, dma_event);
struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
rtw_unregister_tx_alive(adapter);
}
#ifdef CONFIG_LPS_RPWM_TIMER
#if defined(DBG_CPWM_CHK_FAIL)
extern void rtw_cpwm_chk_fail_debug(_adapter *padapter, struct pwrctrl_priv *pwrpriv);
#endif
static void rpwmtimeout_workitem_callback(struct work_struct *work)
{
_adapter *padapter;
struct dvobj_priv *dvobj;
struct pwrctrl_priv *pwrpriv;
pwrpriv = container_of(work, struct pwrctrl_priv, rpwmtimeoutwi);
dvobj = pwrctl_to_dvobj(pwrpriv);
padapter = dvobj_get_primary_adapter(dvobj);
if (!padapter)
return;
if (RTW_CANNOT_RUN(dvobj))
return;
_enter_pwrlock(&pwrpriv->lock);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2)) {
RTW_INFO("%s: rpwm=0x%02X cpwm=0x%02X CPWM done!\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
goto exit;
}
if (pwrpriv->rpwm_retry++ < LPS_RPWM_RETRY_CNT) {
u8 rpwm = (pwrpriv->rpwm | pwrpriv->tog | PS_ACK);
rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&rpwm));
pwrpriv->tog += 0x80;
_set_timer(&pwrpriv->pwr_rpwm_timer, LPS_CPWM_TIMEOUT_MS);
goto exit;
}
pwrpriv->rpwm_retry = 0;
_exit_pwrlock(&pwrpriv->lock);
#if defined(DBG_CPWM_CHK_FAIL)
rtw_cpwm_chk_fail_debug(padapter, pwrpriv);
#endif
#if 0 /*GEORGIA_TODO_REDEFINE_IO*/
if (rtw_read8(padapter, 0x100) != 0xEA)
#else
if (!rtw_hal_is_leave_ps(padapter))
#endif
{
#if 1
struct reportpwrstate_parm report;
report.state = PS_STATE_S2;
RTW_INFO("\n%s: FW already leave 32K!\n\n", __func__);
cpwm_int_hdl(padapter, &report);
#else
RTW_INFO("\n%s: FW already leave 32K!\n\n", __func__);
cpwm_event_callback(&pwrpriv->cpwm_event);
#endif
return;
}
_enter_pwrlock(&pwrpriv->lock);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2)) {
RTW_INFO("%s: cpwm=%d, nothing to do!\n", __func__, pwrpriv->cpwm);
goto exit;
}
pwrpriv->brpwmtimeout = _TRUE;
rtw_set_rpwm(padapter, pwrpriv->rpwm);
pwrpriv->brpwmtimeout = _FALSE;
exit:
_exit_pwrlock(&pwrpriv->lock);
}
/*
* This function is a timer handler, can't do any IO in it.
*/
static void pwr_rpwm_timeout_handler(void *FunctionContext)
{
_adapter *padapter;
struct pwrctrl_priv *pwrpriv;
padapter = (_adapter *)FunctionContext;
if (!padapter)
return;
pwrpriv = adapter_to_pwrctl(padapter);
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
return;
RTW_INFO("+%s: rpwm=0x%02X cpwm=0x%02X\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2)) {
RTW_INFO("+%s: cpwm=%d, nothing to do!\n", __func__, pwrpriv->cpwm);
return;
}
_set_workitem(&pwrpriv->rpwmtimeoutwi);
}
#endif /* CONFIG_LPS_RPWM_TIMER */
__inline static void register_task_alive(struct pwrctrl_priv *pwrctrl, u32 tag)
{
pwrctrl->alives |= tag;
}
__inline static void unregister_task_alive(struct pwrctrl_priv *pwrctrl, u32 tag)
{
pwrctrl->alives &= ~tag;
}
/*
* Description:
* Check if the fw_pwrstate is okay for I/O.
* If not (cpwm is less than S2), then the sub-routine
* will raise the cpwm to be greater than or equal to S2.
*
* Calling Context: Passive
*
* Constraint:
* 1. this function will request pwrctrl->lock
*
* Return Value:
* _SUCCESS hardware is ready for I/O
* _FAIL can't I/O right now
*/
s32 rtw_register_task_alive(_adapter *padapter, u32 task)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, task);
if (pwrctrl->bFwCurrentInPSMode == _TRUE) {
if (pwrctrl->cpwm < pslv) {
if (pwrctrl->cpwm < PS_STATE_S2)
res = _FAIL;
if (pwrctrl->rpwm < pslv)
rtw_set_rpwm(padapter, pslv);
}
}
_exit_pwrlock(&pwrctrl->lock);
#ifdef CONFIG_DETECT_CPWM_BY_POLLING
if (_FAIL == res) {
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
}
#endif /* CONFIG_DETECT_CPWM_BY_POLLING */
return res;
}
/*
* Description:
* If task is done, call this func. to power down firmware again.
*
* Constraint:
* 1. this function will request pwrctrl->lock
*
* Return Value:
* none
*/
void rtw_unregister_task_alive(_adapter *padapter, u32 task)
{
struct pwrctrl_priv *pwrctrl;
u8 pslv;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
_enter_pwrlock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, task);
if ((pwrctrl->pwr_mode != PM_PS_MODE_ACTIVE)
&& (pwrctrl->bFwCurrentInPSMode == _TRUE)) {
if (pwrctrl->cpwm > pslv) {
if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
rtw_set_rpwm(padapter, pslv);
}
}
_exit_pwrlock(&pwrctrl->lock);
}
/*
* Caller: rtw_xmit_thread
*
* Check if the fw_pwrstate is okay for xmit.
* If not (cpwm is less than S3), then the sub-routine
* will raise the cpwm to be greater than or equal to S3.
*
* Calling Context: Passive
*
* Return Value:
* _SUCCESS rtw_xmit_thread can write fifo/txcmd afterwards.
* _FAIL rtw_xmit_thread can not do anything.
*/
s32 rtw_register_tx_alive(_adapter *padapter)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, XMIT_ALIVE);
if (pwrctrl->bFwCurrentInPSMode == _TRUE) {
if (pwrctrl->cpwm < pslv) {
if (pwrctrl->cpwm < PS_STATE_S2)
res = _FAIL;
if (pwrctrl->rpwm < pslv)
rtw_set_rpwm(padapter, pslv);
}
}
_exit_pwrlock(&pwrctrl->lock);
#ifdef CONFIG_DETECT_CPWM_BY_POLLING
if (_FAIL == res) {
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
}
#endif /* CONFIG_DETECT_CPWM_BY_POLLING */
return res;
}
/*
* Caller: rtw_cmd_thread
*
* Check if the fw_pwrstate is okay for issuing cmd.
* If not (cpwm should be is less than S2), then the sub-routine
* will raise the cpwm to be greater than or equal to S2.
*
* Calling Context: Passive
*
* Return Value:
* _SUCCESS rtw_cmd_thread can issue cmds to firmware afterwards.
* _FAIL rtw_cmd_thread can not do anything.
*/
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
s32 rtw_register_cmd_alive(_adapter *padapter)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, CMD_ALIVE);
if (pwrctrl->bFwCurrentInPSMode == _TRUE) {
if (pwrctrl->cpwm < pslv) {
if (pwrctrl->cpwm < PS_STATE_S2)
res = _FAIL;
if (pwrctrl->rpwm < pslv)
rtw_set_rpwm(padapter, pslv);
}
}
_exit_pwrlock(&pwrctrl->lock);
#ifdef CONFIG_DETECT_CPWM_BY_POLLING
if (_FAIL == res) {
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
}
#endif /* CONFIG_DETECT_CPWM_BY_POLLING */
return res;
}
#endif
/*
* Caller: rx_isr
*
* Calling Context: Dispatch/ISR
*
* Return Value:
* _SUCCESS
* _FAIL
*/
s32 rtw_register_rx_alive(_adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
pwrctrl = adapter_to_pwrctl(padapter);
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, RECV_ALIVE);
_exit_pwrlock(&pwrctrl->lock);
return _SUCCESS;
}
/*
* Caller: ISR
*
* If ISR's txdone,
* No more pkts for TX,
* Then driver shall call this fun. to power down firmware again.
*/
void rtw_unregister_tx_alive(_adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 pslv, i;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
#ifdef CONFIG_P2P_PS
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
if (iface->wdinfo.p2p_ps_mode > P2P_PS_NONE) {
pslv = PS_STATE_S2;
break;
}
}
}
#endif
_enter_pwrlock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, XMIT_ALIVE);
if ((pwrctrl->pwr_mode != PM_PS_MODE_ACTIVE)
&& (pwrctrl->bFwCurrentInPSMode == _TRUE)) {
if (pwrctrl->cpwm > pslv) {
if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
rtw_set_rpwm(padapter, pslv);
}
}
_exit_pwrlock(&pwrctrl->lock);
}
/*
* Caller: ISR
*
* If all commands have been done,
* and no more command to do,
* then driver shall call this fun. to power down firmware again.
*/
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
void rtw_unregister_cmd_alive(_adapter *padapter)
{
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrctrl;
u8 pslv, i;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
#ifdef CONFIG_P2P_PS
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
if (iface->wdinfo.p2p_ps_mode > P2P_PS_NONE) {
pslv = PS_STATE_S2;
break;
}
}
}
#endif
_enter_pwrlock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, CMD_ALIVE);
if ((pwrctrl->pwr_mode != PM_PS_MODE_ACTIVE)
&& (pwrctrl->bFwCurrentInPSMode == _TRUE)) {
if (pwrctrl->cpwm > pslv) {
if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
rtw_set_rpwm(padapter, pslv);
}
}
_exit_pwrlock(&pwrctrl->lock);
}
#endif
/*
* Caller: ISR
*/
void rtw_unregister_rx_alive(_adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
pwrctrl = adapter_to_pwrctl(padapter);
_enter_pwrlock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, RECV_ALIVE);
_exit_pwrlock(&pwrctrl->lock);
}
#endif /* CONFIG_LPS_LCLK */
#ifdef CONFIG_RESUME_IN_WORKQUEUE
static void resume_workitem_callback(struct work_struct *work);
#endif /* CONFIG_RESUME_IN_WORKQUEUE */
void rtw_init_pwrctrl_priv(_adapter *padapter)
{
#ifdef CONFIG_LPS_1T1R
#define LPS_1T1R_FMT ", LPS_1T1R=%d"
#define LPS_1T1R_ARG , pwrctrlpriv->lps_1t1r
#else
#define LPS_1T1R_FMT ""
#define LPS_1T1R_ARG
#endif
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
#if defined(CONFIG_CONCURRENT_MODE)
if (!is_primary_adapter(padapter))
return;
#endif
_init_pwrlock(&pwrctrlpriv->lock);
_init_pwrlock(&pwrctrlpriv->check_32k_lock);
pwrctrlpriv->rf_pwrstate = rf_on;
pwrctrlpriv->ips_enter_cnts = 0;
pwrctrlpriv->ips_leave_cnts = 0;
pwrctrlpriv->lps_enter_cnts = 0;
pwrctrlpriv->lps_leave_cnts = 0;
pwrctrlpriv->bips_processing = _FALSE;
#ifdef CONFIG_LPS_CHK_BY_TP
pwrctrlpriv->lps_chk_by_tp = padapter->registrypriv.lps_chk_by_tp;
pwrctrlpriv->lps_tx_tp_th = LPS_TX_TP_TH;
pwrctrlpriv->lps_rx_tp_th = LPS_RX_TP_TH;
pwrctrlpriv->lps_bi_tp_th = LPS_BI_TP_TH;
pwrctrlpriv->lps_chk_cnt = pwrctrlpriv->lps_chk_cnt_th = LPS_TP_CHK_CNT;
pwrctrlpriv->lps_tx_pkts = LPS_CHK_PKTS_TX;
pwrctrlpriv->lps_rx_pkts = LPS_CHK_PKTS_RX;
#endif
pwrctrlpriv->ips_mode = padapter->registrypriv.ips_mode;
pwrctrlpriv->ips_mode_req = padapter->registrypriv.ips_mode;
pwrctrlpriv->ips_deny_time = rtw_get_current_time();
pwrctrlpriv->lps_level = padapter->registrypriv.lps_level;
#ifdef CONFIG_LPS_1T1R
pwrctrlpriv->lps_1t1r = padapter->registrypriv.lps_1t1r;
#endif
pwrctrlpriv->pwr_state_check_interval = RTW_PWR_STATE_CHK_INTERVAL;
pwrctrlpriv->pwr_state_check_cnts = 0;
pwrctrlpriv->bInSuspend = _FALSE;
pwrctrlpriv->bkeepfwalive = _FALSE;
pwrctrlpriv->LpsIdleCount = 0;
/* pwrctrlpriv->FWCtrlPSMode =padapter->registrypriv.power_mgnt; */ /* PM_PS_MODE_MIN; */
if (padapter->registrypriv.mp_mode == 1)
pwrctrlpriv->power_mgnt = PM_PS_MODE_ACTIVE ;
else
pwrctrlpriv->power_mgnt = padapter->registrypriv.power_mgnt; /* PM_PS_MODE_MIN; */
pwrctrlpriv->bLeisurePs = (PM_PS_MODE_ACTIVE != pwrctrlpriv->power_mgnt) ? _TRUE : _FALSE;
pwrctrlpriv->bFwCurrentInPSMode = _FALSE;
pwrctrlpriv->lps_deny_time = rtw_get_current_time();
pwrctrlpriv->rpwm = 0;
pwrctrlpriv->cpwm = PS_STATE_S4;
pwrctrlpriv->pwr_mode = PM_PS_MODE_ACTIVE;
pwrctrlpriv->smart_ps = padapter->registrypriv.smart_ps;
pwrctrlpriv->bcn_ant_mode = 0;
pwrctrlpriv->dtim = 0;
pwrctrlpriv->tog = 0x80;
pwrctrlpriv->rpwm_retry = 0;
RTW_INFO("%s: IPS_mode=%d, LPS_mode=%d, LPS_level=%d"LPS_1T1R_FMT"\n",
__func__, pwrctrlpriv->ips_mode, pwrctrlpriv->power_mgnt, pwrctrlpriv->lps_level
LPS_1T1R_ARG
);
#ifdef CONFIG_LPS_LCLK
rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&pwrctrlpriv->rpwm));
_init_workitem(&pwrctrlpriv->cpwm_event, cpwm_event_callback, NULL);
_init_workitem(&pwrctrlpriv->dma_event, dma_event_callback, NULL);
#ifdef CONFIG_LPS_RPWM_TIMER
pwrctrlpriv->brpwmtimeout = _FALSE;
_init_workitem(&pwrctrlpriv->rpwmtimeoutwi, rpwmtimeout_workitem_callback, NULL);
rtw_init_timer(&pwrctrlpriv->pwr_rpwm_timer, pwr_rpwm_timeout_handler, padapter);
#endif /* CONFIG_LPS_RPWM_TIMER */
#endif /* CONFIG_LPS_LCLK */
#ifdef CONFIG_LPS_PG
pwrctrlpriv->lpspg_info.name = "LPSPG_INFO";
#ifdef CONFIG_RTL8822C
pwrctrlpriv->lpspg_dpk_info.name = "LPSPG_DPK_INFO";
pwrctrlpriv->lpspg_iqk_info.name = "LPSPG_IQK_INFO";
#endif
#endif
#ifdef CONFIG_POWER_SAVING
rtw_init_timer(&pwrctrlpriv->pwr_state_check_timer, pwr_state_check_handler, padapter);
#endif
#ifdef CONFIG_RESUME_IN_WORKQUEUE
_init_workitem(&pwrctrlpriv->resume_work, resume_workitem_callback, NULL);
pwrctrlpriv->rtw_workqueue = create_singlethread_workqueue("rtw_workqueue");
#endif /* CONFIG_RESUME_IN_WORKQUEUE */
#ifdef CONFIG_LPS_ACK
_rtw_mutex_init(&pwrctrlpriv->lps_ack_mutex);
pwrctrlpriv->lps_ack_status = -1;
#endif /* CONFIG_LPS_ACK */
}
void rtw_free_pwrctrl_priv(_adapter *adapter)
{
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(adapter);
#if defined(CONFIG_CONCURRENT_MODE)
if (!is_primary_adapter(adapter))
return;
#endif
/* _rtw_memset((unsigned char *)pwrctrlpriv, 0, sizeof(struct pwrctrl_priv)); */
#ifdef CONFIG_RESUME_IN_WORKQUEUE
if (pwrctrlpriv->rtw_workqueue) {
flush_workqueue(pwrctrlpriv->rtw_workqueue);
destroy_workqueue(pwrctrlpriv->rtw_workqueue);
}
#endif
#ifdef CONFIG_LPS_LCLK
_cancel_workitem_sync(&pwrctrlpriv->cpwm_event);
_cancel_workitem_sync(&pwrctrlpriv->dma_event);
#ifdef CONFIG_LPS_RPWM_TIMER
_cancel_workitem_sync(&pwrctrlpriv->rpwmtimeoutwi);
#endif
#endif /* CONFIG_LPS_LCLK */
#ifdef CONFIG_LPS_PG
rsvd_page_cache_free(&pwrctrlpriv->lpspg_info);
#ifdef CONFIG_RTL8822C
rsvd_page_cache_free(&pwrctrlpriv->lpspg_dpk_info);
rsvd_page_cache_free(&pwrctrlpriv->lpspg_iqk_info);
#endif
#endif
_free_pwrlock(&pwrctrlpriv->lock);
_free_pwrlock(&pwrctrlpriv->check_32k_lock);
#ifdef CONFIG_LPS_ACK
_rtw_mutex_free(&pwrctrlpriv->lps_ack_mutex);
#endif /* CONFIG_LPS_ACK */
}
#ifdef CONFIG_RESUME_IN_WORKQUEUE
extern int rtw_resume_process(_adapter *padapter);
static void resume_workitem_callback(struct work_struct *work)
{
struct pwrctrl_priv *pwrpriv = container_of(work, struct pwrctrl_priv, resume_work);
struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
RTW_INFO("%s\n", __FUNCTION__);
rtw_resume_process(adapter);
rtw_resume_unlock_suspend();
}
void rtw_resume_in_workqueue(struct pwrctrl_priv *pwrpriv)
{
/* accquire system's suspend lock preventing from falliing asleep while resume in workqueue */
/* rtw_lock_suspend(); */
rtw_resume_lock_suspend();
#if 1
queue_work(pwrpriv->rtw_workqueue, &pwrpriv->resume_work);
#else
_set_workitem(&pwrpriv->resume_work);
#endif
}
#endif /* CONFIG_RESUME_IN_WORKQUEUE */
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER)
inline bool rtw_is_earlysuspend_registered(struct pwrctrl_priv *pwrpriv)
{
return (pwrpriv->early_suspend.suspend) ? _TRUE : _FALSE;
}
inline bool rtw_is_do_late_resume(struct pwrctrl_priv *pwrpriv)
{
return (pwrpriv->do_late_resume) ? _TRUE : _FALSE;
}
inline void rtw_set_do_late_resume(struct pwrctrl_priv *pwrpriv, bool enable)
{
pwrpriv->do_late_resume = enable;
}
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
extern int rtw_resume_process(_adapter *padapter);
static void rtw_early_suspend(struct early_suspend *h)
{
struct pwrctrl_priv *pwrpriv = container_of(h, struct pwrctrl_priv, early_suspend);
RTW_INFO("%s\n", __FUNCTION__);
rtw_set_do_late_resume(pwrpriv, _FALSE);
}
static void rtw_late_resume(struct early_suspend *h)
{
struct pwrctrl_priv *pwrpriv = container_of(h, struct pwrctrl_priv, early_suspend);
struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
RTW_INFO("%s\n", __FUNCTION__);
if (pwrpriv->do_late_resume) {
rtw_set_do_late_resume(pwrpriv, _FALSE);
rtw_resume_process(adapter);
}
}
void rtw_register_early_suspend(struct pwrctrl_priv *pwrpriv)
{
RTW_INFO("%s\n", __FUNCTION__);
/* jeff: set the early suspend level before blank screen, so we wll do late resume after scree is lit */
pwrpriv->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 20;
pwrpriv->early_suspend.suspend = rtw_early_suspend;
pwrpriv->early_suspend.resume = rtw_late_resume;
register_early_suspend(&pwrpriv->early_suspend);
}
void rtw_unregister_early_suspend(struct pwrctrl_priv *pwrpriv)
{
RTW_INFO("%s\n", __FUNCTION__);
rtw_set_do_late_resume(pwrpriv, _FALSE);
if (pwrpriv->early_suspend.suspend)
unregister_early_suspend(&pwrpriv->early_suspend);
pwrpriv->early_suspend.suspend = NULL;
pwrpriv->early_suspend.resume = NULL;
}
#endif /* CONFIG_HAS_EARLYSUSPEND */
#ifdef CONFIG_ANDROID_POWER
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
extern int rtw_resume_process(_adapter *padapter);
#endif
static void rtw_early_suspend(android_early_suspend_t *h)
{
struct pwrctrl_priv *pwrpriv = container_of(h, struct pwrctrl_priv, early_suspend);
RTW_INFO("%s\n", __FUNCTION__);
rtw_set_do_late_resume(pwrpriv, _FALSE);
}
static void rtw_late_resume(android_early_suspend_t *h)
{
struct pwrctrl_priv *pwrpriv = container_of(h, struct pwrctrl_priv, early_suspend);
struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
RTW_INFO("%s\n", __FUNCTION__);
if (pwrpriv->do_late_resume) {
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
rtw_set_do_late_resume(pwrpriv, _FALSE);
rtw_resume_process(adapter);
#endif
}
}
void rtw_register_early_suspend(struct pwrctrl_priv *pwrpriv)
{
RTW_INFO("%s\n", __FUNCTION__);
/* jeff: set the early suspend level before blank screen, so we wll do late resume after scree is lit */
pwrpriv->early_suspend.level = ANDROID_EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 20;
pwrpriv->early_suspend.suspend = rtw_early_suspend;
pwrpriv->early_suspend.resume = rtw_late_resume;
android_register_early_suspend(&pwrpriv->early_suspend);
}
void rtw_unregister_early_suspend(struct pwrctrl_priv *pwrpriv)
{
RTW_INFO("%s\n", __FUNCTION__);
rtw_set_do_late_resume(pwrpriv, _FALSE);
if (pwrpriv->early_suspend.suspend)
android_unregister_early_suspend(&pwrpriv->early_suspend);
pwrpriv->early_suspend.suspend = NULL;
pwrpriv->early_suspend.resume = NULL;
}
#endif /* CONFIG_ANDROID_POWER */
inline void rtw_set_ips_deny(_adapter *padapter, u32 ms)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->ips_deny_time = rtw_get_current_time() + rtw_ms_to_systime(ms);
}
/*
* rtw_pwr_wakeup - Wake the NIC up from: 1)IPS. 2)USB autosuspend
* @adapter: pointer to _adapter structure
* @ips_deffer_ms: the ms wiil prevent from falling into IPS after wakeup
* Return _SUCCESS or _FAIL
*/
int _rtw_pwr_wakeup(_adapter *padapter, u32 ips_deffer_ms, const char *caller)
{
int ret = _SUCCESS;
#ifdef CONFIG_POWER_SAVING
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
struct mlme_priv *pmlmepriv;
systime start = rtw_get_current_time();
/*RTW_INFO(FUNC_ADPT_FMT "===>\n", FUNC_ADPT_ARG(padapter));*/
/* for LPS */
LeaveAllPowerSaveMode(padapter);
/* IPS still bound with primary adapter */
padapter = GET_PRIMARY_ADAPTER(padapter);
pmlmepriv = &padapter->mlmepriv;
if (rtw_time_after(rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms), pwrpriv->ips_deny_time))
pwrpriv->ips_deny_time = rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms);
if (pwrpriv->ps_processing) {
RTW_INFO("%s wait ps_processing...\n", __func__);
while (pwrpriv->ps_processing && rtw_get_passing_time_ms(start) <= 3000)
rtw_msleep_os(10);
if (pwrpriv->ps_processing)
RTW_INFO("%s wait ps_processing timeout\n", __func__);
else
RTW_INFO("%s wait ps_processing done\n", __func__);
}
#ifdef DBG_CONFIG_ERROR_DETECT
if (rtw_hal_sreset_inprogress(padapter)) {
RTW_INFO("%s wait sreset_inprogress...\n", __func__);
while (rtw_hal_sreset_inprogress(padapter) && rtw_get_passing_time_ms(start) <= 4000)
rtw_msleep_os(10);
if (rtw_hal_sreset_inprogress(padapter))
RTW_INFO("%s wait sreset_inprogress timeout\n", __func__);
else
RTW_INFO("%s wait sreset_inprogress done\n", __func__);
}
#endif
if (pwrpriv->bInSuspend) {
RTW_INFO("%s wait bInSuspend...\n", __func__);
while (pwrpriv->bInSuspend
&& ((rtw_get_passing_time_ms(start) <= 3000 && !rtw_is_do_late_resume(pwrpriv))
|| (rtw_get_passing_time_ms(start) <= 500 && rtw_is_do_late_resume(pwrpriv)))
)
rtw_msleep_os(10);
if (pwrpriv->bInSuspend)
RTW_INFO("%s wait bInSuspend timeout\n", __func__);
else
RTW_INFO("%s wait bInSuspend done\n", __func__);
}
/* System suspend is not allowed to wakeup */
if (_TRUE == pwrpriv->bInSuspend) {
ret = _FAIL;
goto exit;
}
/* I think this should be check in IPS, LPS, autosuspend functions... */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
ret = _SUCCESS;
goto exit;
}
if (rf_off == pwrpriv->rf_pwrstate) {
#ifdef CONFIG_IPS
RTW_INFO("%s call ips_leave....\n", __FUNCTION__);
if (_FAIL == ips_leave(padapter)) {
RTW_INFO("======> ips_leave fail.............\n");
ret = _FAIL;
goto exit;
}
#endif
}
/* TODO: the following checking need to be merged... */
if (dev_is_drv_stopped(dvobj)
|| !padapter->netif_up
|| !rtw_hw_is_init_completed(dvobj)
) {
RTW_INFO("%s: bDriverStopped=%s, netif_up=%d, hw_init_completed=%u\n"
, caller
, dev_is_drv_stopped(dvobj) ? "True" : "False"
, padapter->netif_up
, rtw_hw_get_init_completed(dvobj));
ret = _FALSE;
goto exit;
}
exit:
if (rtw_time_after(rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms), pwrpriv->ips_deny_time))
pwrpriv->ips_deny_time = rtw_get_current_time() + rtw_ms_to_systime(ips_deffer_ms);
/*RTW_INFO(FUNC_ADPT_FMT "<===\n", FUNC_ADPT_ARG(padapter));*/
#endif
return ret;
}
int rtw_pm_set_lps(_adapter *padapter, u8 mode)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (mode < PM_PS_MODE_NUM) {
if (pwrctrlpriv->power_mgnt != mode) {
if (PM_PS_MODE_ACTIVE == mode)
LeaveAllPowerSaveMode(padapter);
else
pwrctrlpriv->LpsIdleCount = 2;
pwrctrlpriv->power_mgnt = mode;
pwrctrlpriv->bLeisurePs = (PM_PS_MODE_ACTIVE != pwrctrlpriv->power_mgnt) ? _TRUE : _FALSE;
}
} else
ret = -EINVAL;
return ret;
}
int rtw_pm_set_lps_level(_adapter *padapter, u8 level)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (level < LPS_LEVEL_MAX) {
if (pwrctrlpriv->lps_level != level) {
#ifdef CONFIG_LPS
if (rtw_lps_ctrl_leave_set_level_cmd(padapter, level, RTW_CMDF_WAIT_ACK) != _SUCCESS)
#endif
pwrctrlpriv->lps_level = level;
}
} else
ret = -EINVAL;
return ret;
}
#ifdef CONFIG_LPS_1T1R
int rtw_pm_set_lps_1t1r(_adapter *padapter, u8 en)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
en = en ? 1 : 0;
if (pwrctrlpriv->lps_1t1r != en) {
if (rtw_lps_ctrl_leave_set_1t1r_cmd(padapter, en, RTW_CMDF_WAIT_ACK) != _SUCCESS)
pwrctrlpriv->lps_1t1r = en;
}
return ret;
}
#endif
inline void rtw_set_lps_deny(_adapter *adapter, u32 ms)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
pwrpriv->lps_deny_time = rtw_get_current_time() + rtw_ms_to_systime(ms);
}
int rtw_pm_set_ips(_adapter *padapter, u8 mode)
{
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (mode == IPS_NORMAL || mode == IPS_LEVEL_2) {
rtw_ips_mode_req(pwrctrlpriv, mode);
RTW_INFO("%s %s\n", __FUNCTION__, mode == IPS_NORMAL ? "IPS_NORMAL" : "IPS_LEVEL_2");
return 0;
} else if (mode == IPS_NONE) {
rtw_ips_mode_req(pwrctrlpriv, mode);
RTW_INFO("%s %s\n", __FUNCTION__, "IPS_NONE");
if (!dev_is_surprise_removed(adapter_to_dvobj(padapter)) && (_FAIL == rtw_pwr_wakeup(padapter)))
return -EFAULT;
} else
return -EINVAL;
return 0;
}
/*
* ATTENTION:
* This function will request pwrctrl LOCK!
*/
void rtw_ps_deny(_adapter *padapter, PS_DENY_REASON reason)
{
struct pwrctrl_priv *pwrpriv;
/* RTW_INFO("+" FUNC_ADPT_FMT ": Request PS deny for %d (0x%08X)\n",
* FUNC_ADPT_ARG(padapter), reason, BIT(reason)); */
pwrpriv = adapter_to_pwrctl(padapter);
_enter_pwrlock(&pwrpriv->lock);
if (pwrpriv->ps_deny & BIT(reason)) {
RTW_INFO(FUNC_ADPT_FMT ": [WARNING] Reason %d had been set before!!\n",
FUNC_ADPT_ARG(padapter), reason);
}
pwrpriv->ps_deny |= BIT(reason);
_exit_pwrlock(&pwrpriv->lock);
/* RTW_INFO("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n",
* FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny); */
}
/*
* ATTENTION:
* This function will request pwrctrl LOCK!
*/
void rtw_ps_deny_cancel(_adapter *padapter, PS_DENY_REASON reason)
{
struct pwrctrl_priv *pwrpriv;
/* RTW_INFO("+" FUNC_ADPT_FMT ": Cancel PS deny for %d(0x%08X)\n",
* FUNC_ADPT_ARG(padapter), reason, BIT(reason)); */
pwrpriv = adapter_to_pwrctl(padapter);
_enter_pwrlock(&pwrpriv->lock);
if ((pwrpriv->ps_deny & BIT(reason)) == 0) {
RTW_INFO(FUNC_ADPT_FMT ": [ERROR] Reason %d had been canceled before!!\n",
FUNC_ADPT_ARG(padapter), reason);
}
pwrpriv->ps_deny &= ~BIT(reason);
_exit_pwrlock(&pwrpriv->lock);
/* RTW_INFO("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n",
* FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny); */
}
/*
* ATTENTION:
* Before calling this function pwrctrl lock should be occupied already,
* otherwise it may return incorrect value.
*/
u32 rtw_ps_deny_get(_adapter *padapter)
{
u32 deny;
deny = adapter_to_pwrctl(padapter)->ps_deny;
return deny;
}
static void _rtw_ssmps(_adapter *adapter, struct sta_info *sta)
{
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
issue_action_SM_PS_wait_ack(adapter , get_my_bssid(&(pmlmeinfo->network)),
sta->phl_sta->asoc_cap.sm_ps, 3 , 1);
if (sta->phl_sta->asoc_cap.sm_ps == SM_PS_STATIC) {
pmlmeext->txss_bk = sta->phl_sta->asoc_cap.nss_rx;
sta->phl_sta->asoc_cap.nss_rx = 1;
} else {
sta->phl_sta->asoc_cap.nss_rx = pmlmeext->txss_bk;
}
rtw_phl_cmd_change_stainfo(adapter_to_dvobj(adapter)->phl,
sta->phl_sta,
STA_CHG_RAMASK,
NULL,
0,
PHL_CMD_DIRECTLY,
0);
}
void rtw_ssmps_enter(_adapter *adapter, struct sta_info *sta)
{
if (MLME_IS_AP(adapter))
return;
if (sta->phl_sta->asoc_cap.sm_ps == SM_PS_STATIC)
return;
RTW_INFO(ADPT_FMT" STA [" MAC_FMT "]\n", ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
sta->phl_sta->asoc_cap.sm_ps = SM_PS_STATIC;
_rtw_ssmps(adapter, sta);
}
void rtw_ssmps_leave(_adapter *adapter, struct sta_info *sta)
{
if (MLME_IS_AP(adapter))
return;
if (sta->phl_sta->asoc_cap.sm_ps == SM_PS_DISABLE)
return;
RTW_INFO(ADPT_FMT" STA [" MAC_FMT "] \n", ADPT_ARG(adapter), MAC_ARG(sta->phl_sta->mac_addr));
sta->phl_sta->asoc_cap.sm_ps = SM_PS_DISABLE;
_rtw_ssmps(adapter, sta);
}
|
2301_81045437/rtl8852be
|
core/rtw_pwrctrl.c
|
C
|
agpl-3.0
| 61,443
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_RECV_C_
#include <drv_types.h>
static void rtw_signal_stat_timer_hdl(void *ctx);
enum {
SIGNAL_STAT_CALC_PROFILE_0 = 0,
SIGNAL_STAT_CALC_PROFILE_1,
SIGNAL_STAT_CALC_PROFILE_MAX
};
u8 signal_stat_calc_profile[SIGNAL_STAT_CALC_PROFILE_MAX][2] = {
{4, 1}, /* Profile 0 => pre_stat : curr_stat = 4 : 1 */
{3, 7} /* Profile 1 => pre_stat : curr_stat = 3 : 7 */
};
#ifndef RTW_SIGNAL_STATE_CALC_PROFILE
#define RTW_SIGNAL_STATE_CALC_PROFILE SIGNAL_STAT_CALC_PROFILE_1
#endif
u8 rtw_bridge_tunnel_header[] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
u8 rtw_rfc1042_header[] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
static u8 SNAP_ETH_TYPE_IPX[2] = {0x81, 0x37};
static u8 SNAP_ETH_TYPE_APPLETALK_AARP[2] = {0x80, 0xf3};
#ifdef CONFIG_TDLS
static u8 SNAP_ETH_TYPE_TDLS[2] = {0x89, 0x0d};
#endif
void _rtw_init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv)
{
_rtw_memset((u8 *)psta_recvpriv, 0, sizeof(struct sta_recv_priv));
_rtw_spinlock_init(&psta_recvpriv->lock);
/* for(i=0; i<MAX_RX_NUMBLKS; i++) */
/* _rtw_init_queue(&psta_recvpriv->blk_strms[i]); */
_rtw_init_queue(&psta_recvpriv->defrag_q);
}
u8 rtw_init_recv_info(_adapter *adapter)
{
u8 ret = _SUCCESS;
struct recv_info *recvinfo = &adapter->recvinfo;
recvinfo->sink_udpport = 0;
recvinfo->pre_rtp_rxseq = 0;
recvinfo->cur_rtp_rxseq = 0;
#ifdef CONFIG_SIGNAL_STAT_PROCESS
rtw_init_timer(&recvinfo->signal_stat_timer, rtw_signal_stat_timer_hdl, adapter);
recvinfo->signal_stat_sampling_interval = 2000; /* ms */
/* recvinfo->signal_stat_converging_constant = 5000; */ /* ms */
rtw_set_signal_stat_timer(recvinfo);
#endif
return ret;
}
/*#define DBG_RECV_FRAME*/
#ifdef DBG_RECV_FRAME
void _dump_recv_priv(struct dvobj_priv *dvobj, _queue *pfree_recv_queue)
{
struct recv_priv *precvpriv = &dvobj->recvpriv;
RTW_INFO("%s free_recvframe_cnt:%d\n", __func__, precvpriv->free_recvframe_cnt);
RTW_INFO("%s dvobj:%p pfree_recv_queue:%p : %p\n",
__func__, dvobj, &(precvpriv->free_recv_queue), pfree_recv_queue);
}
#endif
sint rtw_init_recv_priv(struct dvobj_priv *dvobj)
{
sint i;
union recv_frame *precvframe;
sint res = _SUCCESS;
struct recv_priv *precvpriv = &dvobj->recvpriv;
#ifdef CONFIG_RECV_THREAD_MODE
_rtw_init_sema(&precvpriv->recv_sema, 0);
#endif
_rtw_init_queue(&precvpriv->free_recv_queue);
#if 0
_rtw_init_queue(&precvpriv->uc_swdec_pending_queue);
#endif
precvpriv->dvobj = dvobj;
precvpriv->free_recvframe_cnt = NR_RECVFRAME;
rtw_os_recv_resource_init(precvpriv);
precvpriv->pallocated_frame_buf = rtw_zvmalloc(NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ);
if (precvpriv->pallocated_frame_buf == NULL) {
res = _FAIL;
goto exit;
}
/* _rtw_memset(precvpriv->pallocated_frame_buf, 0, NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ); */
precvpriv->precv_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(precvpriv->pallocated_frame_buf), RXFRAME_ALIGN_SZ);
/* precvpriv->precv_frame_buf = precvpriv->pallocated_frame_buf + RXFRAME_ALIGN_SZ - */
/* ((SIZE_PTR) (precvpriv->pallocated_frame_buf) &(RXFRAME_ALIGN_SZ-1)); */
precvframe = (union recv_frame *) precvpriv->precv_frame_buf;
for (i = 0; i < NR_RECVFRAME ; i++) {
_rtw_init_listhead(&(precvframe->u.list));
rtw_list_insert_tail(&(precvframe->u.list), &(precvpriv->free_recv_queue.queue));
rtw_os_recv_resource_alloc(precvframe);
precvframe->u.hdr.len = 0;
precvframe->u.hdr.dvobj = dvobj;
precvframe->u.hdr.adapter = NULL;
precvframe->u.hdr.rx_req = NULL;
precvframe++;
}
#ifdef DBG_RECV_FRAME
RTW_INFO("%s =>precvpriv->free_recvframe_cnt:%d\n", __func__, precvpriv->free_recvframe_cnt);
#endif
res = rtw_intf_init_recv_priv(dvobj);
#ifdef DBG_RECV_FRAME
_dump_recv_priv(dvobj, &dvobj->recvpriv.free_recv_queue);
#endif
exit:
return res;
}
void rtw_free_recv_priv(struct dvobj_priv *dvobj)
{
struct recv_priv *precvpriv = &dvobj->recvpriv;
#if 0
rtw_free_uc_swdec_pending_queue(dvobj);
#endif
#ifdef CONFIG_RECV_THREAD_MODE
_rtw_free_sema(&precvpriv->recv_sema);
#endif
rtw_os_recv_resource_free(precvpriv);
if (precvpriv->pallocated_frame_buf)
rtw_vmfree(precvpriv->pallocated_frame_buf, NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ);
_rtw_deinit_queue(&precvpriv->free_recv_queue);
rtw_intf_free_recv_priv(dvobj);
}
union recv_frame *_rtw_alloc_recvframe(_queue *pfree_recv_queue)
{
union recv_frame *precvframe;
_list *plist, *phead;
struct recv_priv *precvpriv;
struct dvobj_priv *dvobj;
#ifdef DBG_RECV_FRAME
RTW_INFO("%s =>pfree_recv_queue:%p\n", __func__, pfree_recv_queue);
#endif
if (_rtw_queue_empty(pfree_recv_queue) == _TRUE) {
precvframe = NULL;
}
else {
phead = get_list_head(pfree_recv_queue);
plist = get_next(phead);
precvframe = LIST_CONTAINOR(plist, union recv_frame, u);
rtw_list_delete(&precvframe->u.hdr.list);
dvobj = precvframe->u.hdr.dvobj;
precvpriv = &dvobj->recvpriv;
precvpriv->free_recvframe_cnt--;
}
return precvframe;
}
union recv_frame *rtw_alloc_recvframe(_queue *pfree_recv_queue)
{
union recv_frame *precvframe = NULL;
#ifdef DBG_RECV_FRAME
struct recv_priv *precvpriv;
struct dvobj_priv *dvobj;
RTW_INFO("%s =>pfree_recv_queue:%p\n", __func__, pfree_recv_queue);
#endif
_rtw_spinlock_bh(&pfree_recv_queue->lock);
precvframe = _rtw_alloc_recvframe(pfree_recv_queue);
_rtw_spinunlock_bh(&pfree_recv_queue->lock);
if(precvframe) {
precvframe->u.hdr.rx_req = NULL;
#ifdef DBG_RECV_FRAME
dvobj = precvframe->u.hdr.dvobj;
precvpriv = &dvobj->recvpriv;
RTW_INFO("%s =>dvobj:%p precvpriv->free_recvframe_cnt:%d\n",
__func__,
dvobj,
precvpriv->free_recvframe_cnt);
#endif
}
return precvframe;
}
void rtw_init_recvframe(union recv_frame *precvframe)
{
/* Perry: This can be removed */
_rtw_init_listhead(&precvframe->u.hdr.list);
precvframe->u.hdr.len = 0;
}
int rtw_free_recvframe(union recv_frame *precvframe)
{
struct dvobj_priv *dvobj;
struct recv_priv *precvpriv;
_queue *pfree_recv_queue;
if(!precvframe) {
RTW_ERR("%s precvframe is NULL\n", __func__);
rtw_warn_on(1);
return _FAIL;
}
dvobj = precvframe->u.hdr.dvobj;
precvpriv = &dvobj->recvpriv;
pfree_recv_queue = &(precvpriv->free_recv_queue);
#ifdef DBG_RECV_FRAME
RTW_INFO("%s dvobj:%p, phl:%p\n", __func__,dvobj, dvobj->phl);
#endif
#ifdef RTW_PHL_RX
if(precvframe->u.hdr.rx_req)
rtw_phl_return_rxbuf(GET_PHL_INFO(dvobj), (u8*)precvframe->u.hdr.rx_req);
#endif
rtw_os_free_recvframe(precvframe);
_rtw_spinlock_bh(&pfree_recv_queue->lock);
rtw_list_delete(&(precvframe->u.hdr.list));
precvframe->u.hdr.len = 0;
rtw_list_insert_tail(&(precvframe->u.hdr.list), get_list_head(pfree_recv_queue));
precvpriv->free_recvframe_cnt++;
_rtw_spinunlock_bh(&pfree_recv_queue->lock);
#ifdef DBG_RECV_FRAME
RTW_INFO("%s =>precvpriv->free_recvframe_cnt:%d\n", __func__, precvpriv->free_recvframe_cnt);
#endif
return _SUCCESS;
}
bool rtw_rframe_del_wfd_ie(union recv_frame *rframe, u8 ies_offset)
{
#define DBG_RFRAME_DEL_WFD_IE 0
u8 *ies = rframe->u.hdr.rx_data + sizeof(struct rtw_ieee80211_hdr_3addr) + ies_offset;
uint ies_len_ori = rframe->u.hdr.len - (ies - rframe->u.hdr.rx_data);
uint ies_len;
ies_len = rtw_del_wfd_ie(ies, ies_len_ori, DBG_RFRAME_DEL_WFD_IE ? __func__ : NULL);
rframe->u.hdr.len -= ies_len_ori - ies_len;
return ies_len_ori != ies_len;
}
#if 0
sint _rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
{
_adapter *padapter = precvframe->u.hdr.adapter;
struct recv_priv *precvpriv = &padapter->recvpriv;
/* _rtw_init_listhead(&(precvframe->u.hdr.list)); */
rtw_list_delete(&(precvframe->u.hdr.list));
rtw_list_insert_tail(&(precvframe->u.hdr.list), get_list_head(queue));
if (padapter != NULL) {
if (queue == &precvpriv->free_recv_queue)
precvpriv->free_recvframe_cnt++;
}
return _SUCCESS;
}
sint rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue)
{
sint ret;
/* _spinlock(&pfree_recv_queue->lock); */
_rtw_spinlock_bh(&queue->lock);
ret = _rtw_enqueue_recvframe(precvframe, queue);
/* _rtw_spinunlock(&pfree_recv_queue->lock); */
_rtw_spinunlock_bh(&queue->lock);
return ret;
}
#endif
/*
caller : defrag ; recvframe_chk_defrag in recv_thread (passive)
pframequeue: defrag_queue : will be accessed in recv_thread (passive)
using spinlock to protect
*/
void rtw_free_recvframe_queue(_queue *pframequeue)
{
union recv_frame *precvframe;
_list *plist, *phead;
_rtw_spinlock(&pframequeue->lock);
phead = get_list_head(pframequeue);
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
precvframe = LIST_CONTAINOR(plist, union recv_frame, u);
plist = get_next(plist);
/* rtw_list_delete(&precvframe->u.hdr.list); */ /* will do this in rtw_free_recvframe() */
rtw_free_recvframe(precvframe);
}
_rtw_spinunlock(&pframequeue->lock);
}
#if 0
u32 rtw_free_uc_swdec_pending_queue(struct dvobj_priv *dvobj)
{
u32 cnt = 0;
union recv_frame *pending_frame;
while ((pending_frame = rtw_alloc_recvframe(&dvobj->recvpriv.uc_swdec_pending_queue))) {
rtw_free_recvframe(pending_frame);
cnt++;
}
if (cnt)
RTW_INFO("dequeue %d\n", cnt);
return cnt;
}
#endif
sint recvframe_chkmic(_adapter *adapter, union recv_frame *precvframe)
{
sint i, res = _SUCCESS;
u32 datalen;
u8 miccode[8];
u8 bmic_err = _FALSE, brpt_micerror = _TRUE;
u8 *pframe, *payload, *pframemic;
u8 *mickey;
/* u8 *iv,rxdata_key_idx=0; */
struct sta_info *stainfo;
struct rx_pkt_attrib *prxattrib = &precvframe->u.hdr.attrib;
struct security_priv *psecuritypriv = &adapter->securitypriv;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
stainfo = rtw_get_stainfo(&adapter->stapriv , &prxattrib->ta[0]);
if (prxattrib->encrypt == _TKIP_) {
/* calculate mic code */
if (stainfo != NULL) {
if (IS_MCAST(prxattrib->ra)) {
/* mickey=&psecuritypriv->dot118021XGrprxmickey.skey[0]; */
/* iv = precvframe->u.hdr.rx_data+prxattrib->hdrlen; */
/* rxdata_key_idx =( ((iv[3])>>6)&0x3) ; */
mickey = &psecuritypriv->dot118021XGrprxmickey[prxattrib->key_index].skey[0];
/* RTW_INFO("\n recvframe_chkmic: bcmc key psecuritypriv->dot118021XGrpKeyid(%d),pmlmeinfo->key_index(%d) ,recv key_id(%d)\n", */
/* psecuritypriv->dot118021XGrpKeyid,pmlmeinfo->key_index,rxdata_key_idx); */
if (psecuritypriv->binstallGrpkey == _FALSE) {
res = _FAIL;
RTW_INFO("\n recvframe_chkmic:didn't install group key!!!!!!!!!!\n");
goto exit;
}
} else {
mickey = &stainfo->dot11tkiprxmickey.skey[0];
}
datalen = precvframe->u.hdr.len - prxattrib->hdrlen - prxattrib->iv_len - prxattrib->icv_len - 8; /* icv_len included the mic code */
pframe = precvframe->u.hdr.rx_data;
payload = pframe + prxattrib->hdrlen + prxattrib->iv_len;
/* rtw_seccalctkipmic(&stainfo->dot11tkiprxmickey.skey[0],pframe,payload, datalen ,&miccode[0],(unsigned char)prxattrib->priority); */ /* care the length of the data */
rtw_seccalctkipmic(mickey, pframe, payload, datalen , &miccode[0], (unsigned char)prxattrib->priority); /* care the length of the data */
pframemic = payload + datalen;
bmic_err = _FALSE;
for (i = 0; i < 8; i++) {
if (miccode[i] != *(pframemic + i)) {
bmic_err = _TRUE;
}
}
if (bmic_err == _TRUE) {
/* double check key_index for some timing issue , */
/* cannot compare with psecuritypriv->dot118021XGrpKeyid also cause timing issue */
if ((IS_MCAST(prxattrib->ra) == _TRUE) && (prxattrib->key_index != pmlmeinfo->key_index))
brpt_micerror = _FALSE;
if ((prxattrib->bdecrypted == _TRUE) && (brpt_micerror == _TRUE)) {
rtw_handle_tkip_mic_err(adapter, stainfo, (u8)IS_MCAST(prxattrib->ra));
RTW_INFO(" mic error :prxattrib->bdecrypted=%d\n", prxattrib->bdecrypted);
} else {
RTW_INFO(" mic error :prxattrib->bdecrypted=%d\n", prxattrib->bdecrypted);
}
res = _FAIL;
} else {
/* mic checked ok */
if ((psecuritypriv->bcheck_grpkey == _FALSE) && (IS_MCAST(prxattrib->ra) == _TRUE)) {
psecuritypriv->bcheck_grpkey = _TRUE;
}
}
}
recvframe_pull_tail(precvframe, 8);
}
exit:
return res;
}
/*#define DBG_RX_SW_DECRYPTOR*/
/* decrypt and set the ivlen,icvlen of the recv_frame */
union recv_frame *decryptor(_adapter *padapter, union recv_frame *precv_frame)
{
struct rx_pkt_attrib *prxattrib = &precv_frame->u.hdr.attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
union recv_frame *return_packet = precv_frame;
struct sta_info *psta = precv_frame->u.hdr.psta;
u32 res = _SUCCESS;
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt);
if (prxattrib->encrypt > 0) {
u8 *iv = precv_frame->u.hdr.rx_data + prxattrib->hdrlen;
prxattrib->key_index = (((iv[3]) >> 6) & 0x3) ;
if (prxattrib->key_index > WEP_KEYS) {
RTW_INFO("prxattrib->key_index(%d) > WEP_KEYS\n", prxattrib->key_index);
switch (prxattrib->encrypt) {
case _WEP40_:
case _WEP104_:
prxattrib->key_index = psecuritypriv->dot11PrivacyKeyIndex;
break;
case _TKIP_:
case _AES_:
case _GCMP_:
case _GCMP_256_:
case _CCMP_256_:
default:
prxattrib->key_index = psecuritypriv->dot118021XGrpKeyid;
break;
}
}
}
if (prxattrib->encrypt && !prxattrib->bdecrypted) {
if (GetFrameType(get_recvframe_data(precv_frame)) == WIFI_DATA
#ifdef CONFIG_CONCURRENT_MODE
&& !IS_MCAST(prxattrib->ra) /* bc/mc packets may use sw decryption for concurrent mode */
#endif
) {
if (IS_MCAST(prxattrib->ra))
psecuritypriv->hw_decrypted = _FALSE;
else
psta->hw_decrypted = _FALSE;
}
#ifdef DBG_RX_SW_DECRYPTOR
RTW_INFO(ADPT_FMT" - sec_type:%s DO SW decryption\n",
ADPT_ARG(padapter), security_type_str(prxattrib->encrypt));
#endif
#ifdef DBG_RX_DECRYPTOR
RTW_INFO("[%s] %d: PKT decrypted(%d), PKT encrypt(%d), Set %pM hw_decrypted(%d)\n",
__FUNCTION__,
__LINE__,
prxattrib->bdecrypted,
prxattrib->encrypt,
psta->phl_sta->mac_addr,
psta->hw_decrypted);
#endif
switch (prxattrib->encrypt) {
case _WEP40_:
case _WEP104_:
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_wep);
rtw_wep_decrypt(padapter, (u8 *)precv_frame);
break;
case _TKIP_:
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_tkip);
res = rtw_tkip_decrypt(padapter, (u8 *)precv_frame);
break;
case _AES_:
case _CCMP_256_:
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_aes);
res = rtw_aes_decrypt(padapter, (u8 *)precv_frame);
break;
case _GCMP_:
case _GCMP_256_:
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_gcmp);
res = rtw_gcmp_decrypt(padapter, (u8 *)precv_frame);
break;
#ifdef CONFIG_WAPI_SUPPORT
case _SMS4_:
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_wapi);
rtw_sms4_decrypt(padapter, (u8 *)precv_frame);
break;
#endif
default:
break;
}
} else if (prxattrib->bdecrypted == 1
&& prxattrib->encrypt > 0
&& (psecuritypriv->busetkipkey == 1 || prxattrib->encrypt != _TKIP_)
) {
#if 0
if ((prxstat->icv == 1) && (prxattrib->encrypt != _AES_)) {
psecuritypriv->hw_decrypted = _FALSE;
rtw_free_recvframe(precv_frame);
return_packet = NULL;
} else
#endif
{
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_hw);
psecuritypriv->hw_decrypted = _TRUE;
psta->hw_decrypted = _TRUE;
#ifdef DBG_RX_DECRYPTOR
RTW_INFO("[%s] %d: PKT decrypted(%d), PKT encrypt(%d), Set %pM hw_decrypted(%d)\n",
__FUNCTION__,
__LINE__,
prxattrib->bdecrypted,
prxattrib->encrypt,
psta->phl_sta->mac_addr,
psta->hw_decrypted);
#endif
}
} else {
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_unknown);
#ifdef DBG_RX_DECRYPTOR
RTW_INFO("[%s] %d: PKT decrypted(%d), PKT encrypt(%d), Set %pM hw_decrypted(%d)\n",
__FUNCTION__,
__LINE__,
prxattrib->bdecrypted,
prxattrib->encrypt,
psta->phl_sta->mac_addr,
psta->hw_decrypted);
#endif
}
#ifdef CONFIG_RTW_MESH
if (res != _FAIL
&& !prxattrib->amsdu
&& prxattrib->mesh_ctrl_present)
res = rtw_mesh_rx_validate_mctrl_non_amsdu(padapter, precv_frame);
#endif
if (res == _FAIL) {
/* Let rtw_core_rx_process or rtw_mi_buddy_clone_bcmc_packet */
/* to handle it.*/
/* rtw_free_recvframe(return_packet); */
return_packet = NULL;
} else
prxattrib->bdecrypted = _TRUE;
/* recvframe_chkmic(adapter, precv_frame); */ /* move to recvframme_defrag function */
return return_packet;
}
/* ###set the security information in the recv_frame */
union recv_frame *portctrl(_adapter *adapter, union recv_frame *precv_frame)
{
u8 *psta_addr = NULL;
u8 *ptr;
uint auth_alg;
struct recv_frame_hdr *pfhdr;
struct sta_info *psta;
struct sta_priv *pstapriv ;
union recv_frame *prtnframe;
u16 ether_type = 0;
u16 eapol_type = 0x888e;/* for Funia BD's WPA issue */
struct rx_pkt_attrib *pattrib;
pstapriv = &adapter->stapriv;
auth_alg = adapter->securitypriv.dot11AuthAlgrthm;
ptr = get_recvframe_data(precv_frame);
pfhdr = &precv_frame->u.hdr;
pattrib = &pfhdr->attrib;
psta_addr = pattrib->ta;
prtnframe = NULL;
psta = rtw_get_stainfo(pstapriv, psta_addr);
if (auth_alg == dot11AuthAlgrthm_8021X) {
if ((psta != NULL) && (psta->ieee8021x_blocked)) {
/* blocked */
/* only accept EAPOL frame */
prtnframe = precv_frame;
/* get ether_type */
ptr = ptr + pfhdr->attrib.hdrlen + pfhdr->attrib.iv_len + LLC_HEADER_SIZE;
_rtw_memcpy(ðer_type, ptr, 2);
ether_type = ntohs((unsigned short)ether_type);
if (ether_type == eapol_type)
prtnframe = precv_frame;
else {
/* Let rtw_core_rx_process to handle it */
/* rtw_free_recvframe(precv_frame); */
prtnframe = NULL;
}
} else {
/* allowed */
/* check decryption status, and decrypt the frame if needed */
prtnframe = precv_frame;
/* check is the EAPOL frame or not (Rekey) */
/* if(ether_type == eapol_type){ */
/* check Rekey */
/* prtnframe=precv_frame; */
/* } */
}
} else
prtnframe = precv_frame;
return prtnframe;
}
/* VALID_PN_CHK
* Return true when PN is legal, otherwise false.
* Legal PN:
* 1. If old PN is 0, any PN is legal
* 2. PN > old PN
*/
#define PN_LESS_CHK(a, b) (((a-b) & 0x800000000000) != 0)
#define VALID_PN_CHK(new, old) (((old) == 0) || PN_LESS_CHK(old, new))
sint recv_ucast_pn_decache(union recv_frame *precv_frame)
{
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_info *sta = precv_frame->u.hdr.psta;
struct stainfo_rxcache *prxcache = &sta->sta_recvpriv.rxcache;
u8 *pdata = precv_frame->u.hdr.rx_data;
sint tid = precv_frame->u.hdr.attrib.priority;
u64 curr_pn = 0, pkt_pn = 0;
u8 pn[8] = {0};
if (tid > 15)
return _FAIL;
if (pattrib->encrypt == _TKIP_ || pattrib->encrypt == _AES_ ||
pattrib->encrypt == _GCMP_ || pattrib->encrypt == _CCMP_256_ ||
pattrib->encrypt == _GCMP_256_) {
rtw_iv_to_pn((pdata + pattrib->hdrlen), pn, NULL, pattrib->encrypt);
pkt_pn = RTW_GET_LE64(pn);
rtw_iv_to_pn(prxcache->iv[tid], pn, NULL, pattrib->encrypt);
curr_pn = RTW_GET_LE64(pn);
if (!VALID_PN_CHK(pkt_pn, curr_pn)) {
/* return _FAIL; */
} else {
prxcache->last_tid = tid;
_rtw_memcpy(prxcache->iv[tid],
(pdata + pattrib->hdrlen),
sizeof(prxcache->iv[tid]));
}
}
return _SUCCESS;
}
sint recv_bcast_pn_decache(union recv_frame *precv_frame)
{
_adapter *padapter = precv_frame->u.hdr.adapter;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
u8 *pdata = precv_frame->u.hdr.rx_data;
u64 curr_pn = 0, pkt_pn = 0;
u8 pn[8] = {0};
u8 key_id;
if ((pattrib->encrypt == _TKIP_ || pattrib->encrypt == _AES_ ||
pattrib->encrypt == _GCMP_ || pattrib->encrypt == _CCMP_256_ ||
pattrib->encrypt == _GCMP_256_) &&
(MLME_IS_STA(padapter))) {
rtw_iv_to_pn((pdata + pattrib->hdrlen), pn, &key_id,
pattrib->encrypt);
pkt_pn = RTW_GET_LE64(pn);
curr_pn = le64_to_cpu(*(u64*)psecuritypriv->iv_seq[key_id]);
if (!VALID_PN_CHK(pkt_pn, curr_pn))
return _FAIL;
*(u64*)psecuritypriv->iv_seq[key_id] = cpu_to_le64(pkt_pn);
}
return _SUCCESS;
}
sint recv_decache(union recv_frame *precv_frame)
{
struct sta_info *psta = precv_frame->u.hdr.psta;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
_adapter *adapter = psta->padapter;
sint tid = pattrib->priority;
u16 seq_ctrl = ((precv_frame->u.hdr.attrib.seq_num & 0xffff) << 4) |
(precv_frame->u.hdr.attrib.frag_num & 0xf);
u16 *prxseq;
if (tid > 15)
return _FAIL;
if (pattrib->qos) {
if (IS_MCAST(pattrib->ra))
prxseq = &psta->sta_recvpriv.bmc_tid_rxseq[tid];
else
prxseq = &psta->sta_recvpriv.rxcache.tid_rxseq[tid];
} else {
if (IS_MCAST(pattrib->ra)) {
prxseq = &psta->sta_recvpriv.nonqos_bmc_rxseq;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" nonqos bmc seq_num:%d\n"
, FUNC_ADPT_ARG(adapter), pattrib->seq_num);
#endif
} else {
prxseq = &psta->sta_recvpriv.nonqos_rxseq;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" nonqos seq_num:%d\n"
, FUNC_ADPT_ARG(adapter), pattrib->seq_num);
#endif
}
}
if (seq_ctrl == *prxseq) {
/* for non-AMPDU case */
psta->sta_stats.duplicate_cnt++;
if (psta->sta_stats.duplicate_cnt % 100 == 0)
RTW_INFO("%s: tid=%u seq=%d frag=%d\n", __func__
, tid, precv_frame->u.hdr.attrib.seq_num
, precv_frame->u.hdr.attrib.frag_num);
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recv_decache _FAIL for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->phl_sta->mac_addr));
#endif
return _FAIL;
}
*prxseq = seq_ctrl;
return _SUCCESS;
}
void process_pwrbit_data(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *psta)
{
#ifdef CONFIG_AP_MODE
unsigned char pwrbit;
u8 *ptr = precv_frame->u.hdr.rx_data;
pwrbit = GetPwrMgt(ptr);
if (pwrbit) {
if (!(psta->state & WIFI_SLEEP_STATE)) {
/* psta->state |= WIFI_SLEEP_STATE; */
/* rtw_tim_map_set(padapter, pstapriv->sta_dz_bitmap, BIT(psta->phl_sta->aid)); */
stop_sta_xmit(padapter, psta);
/* RTW_INFO_DUMP("to sleep, sta_dz_bitmap=", pstapriv->sta_dz_bitmap, pstapriv->aid_bmp_len); */
}
} else {
if (psta->state & WIFI_SLEEP_STATE) {
/* psta->state ^= WIFI_SLEEP_STATE; */
/* rtw_tim_map_clear(padapter, pstapriv->sta_dz_bitmap, BIT(psta->phl_sta->aid)); */
wakeup_sta_to_xmit(padapter, psta);
/* RTW_INFO_DUMP("to wakeup, sta_dz_bitmap=", pstapriv->sta_dz_bitmap, pstapriv->aid_bmp_len); */
}
}
#endif
}
void process_wmmps_data(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *psta)
{
#ifdef CONFIG_AP_MODE
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
#ifdef CONFIG_TDLS
if (!(psta->tdls_sta_state & TDLS_LINKED_STATE)) {
#endif /* CONFIG_TDLS */
if (!psta->qos_option)
return;
if (!(psta->qos_info & 0xf))
return;
#ifdef CONFIG_TDLS
}
#endif /* CONFIG_TDLS */
if (psta->state & WIFI_SLEEP_STATE) {
u8 wmmps_ac = 0;
switch (pattrib->priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk & BIT(1);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi & BIT(1);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo & BIT(1);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be & BIT(1);
break;
}
if (wmmps_ac) {
if (psta->sleepq_ac_len > 0) {
/* process received triggered frame */
xmit_delivery_enabled_frames(padapter, psta);
} else {
/* issue one qos null frame with More data bit = 0 and the EOSP bit set (=1) */
issue_qos_nulldata(padapter, psta->phl_sta->mac_addr, (u16)pattrib->priority, 0, 0, 0, _FALSE);
}
}
}
#endif
}
#ifdef CONFIG_TDLS
sint OnTDLS(_adapter *adapter, union recv_frame *precv_frame)
{
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
sint ret = _SUCCESS;
u8 *paction = get_recvframe_data(precv_frame);
u8 category_field = 1;
#ifdef CONFIG_WFD
u8 WFA_OUI[3] = { 0x50, 0x6f, 0x9a };
#endif /* CONFIG_WFD */
struct tdls_info *ptdlsinfo = &(adapter->tdlsinfo);
u8 *ptr = precv_frame->u.hdr.rx_data;
struct sta_priv *pstapriv = &(adapter->stapriv);
struct sta_info *ptdls_sta = NULL;
/* point to action field */
paction += pattrib->hdrlen
+ pattrib->iv_len
+ SNAP_SIZE
+ ETH_TYPE_LEN
+ PAYLOAD_TYPE_LEN
+ category_field;
RTW_INFO("[TDLS] Recv %s from "MAC_FMT" with SeqNum = %d\n", rtw_tdls_action_txt(*paction), MAC_ARG(pattrib->src), GetSequence(get_recvframe_data(precv_frame)));
if (rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_TDLS) == _FALSE) {
RTW_INFO("Ignore tdls frame since hal doesn't support tdls\n");
ret = _FAIL;
return ret;
}
if (rtw_is_tdls_enabled(adapter) == _FALSE) {
RTW_INFO("recv tdls frame, "
"but tdls haven't enabled\n");
ret = _FAIL;
return ret;
}
ptdls_sta = rtw_get_stainfo(pstapriv, get_sa(ptr));
if (ptdls_sta == NULL) {
switch (*paction) {
case TDLS_SETUP_REQUEST:
case TDLS_DISCOVERY_REQUEST:
break;
default:
RTW_INFO("[TDLS] %s - Direct Link Peer = "MAC_FMT" not found for action = %d\n", __func__, MAC_ARG(get_sa(ptr)), *paction);
ret = _FAIL;
goto exit;
}
}
switch (*paction) {
case TDLS_SETUP_REQUEST:
ret = On_TDLS_Setup_Req(adapter, precv_frame, ptdls_sta);
break;
case TDLS_SETUP_RESPONSE:
ret = On_TDLS_Setup_Rsp(adapter, precv_frame, ptdls_sta);
break;
case TDLS_SETUP_CONFIRM:
ret = On_TDLS_Setup_Cfm(adapter, precv_frame, ptdls_sta);
break;
case TDLS_TEARDOWN:
ret = On_TDLS_Teardown(adapter, precv_frame, ptdls_sta);
break;
case TDLS_DISCOVERY_REQUEST:
ret = On_TDLS_Dis_Req(adapter, precv_frame);
break;
case TDLS_PEER_TRAFFIC_INDICATION:
ret = On_TDLS_Peer_Traffic_Indication(adapter, precv_frame, ptdls_sta);
break;
case TDLS_PEER_TRAFFIC_RESPONSE:
ret = On_TDLS_Peer_Traffic_Rsp(adapter, precv_frame, ptdls_sta);
break;
#ifdef CONFIG_TDLS_CH_SW
case TDLS_CHANNEL_SWITCH_REQUEST:
ret = On_TDLS_Ch_Switch_Req(adapter, precv_frame, ptdls_sta);
break;
case TDLS_CHANNEL_SWITCH_RESPONSE:
ret = On_TDLS_Ch_Switch_Rsp(adapter, precv_frame, ptdls_sta);
break;
#endif
#ifdef CONFIG_WFD
/* First byte of WFA OUI */
case 0x50:
if (_rtw_memcmp(WFA_OUI, paction, 3)) {
/* Probe request frame */
if (*(paction + 3) == 0x04) {
/* WFDTDLS: for sigma test, do not setup direct link automatically */
ptdlsinfo->dev_discovered = _TRUE;
RTW_INFO("recv tunneled probe request frame\n");
issue_tunneled_probe_rsp(adapter, precv_frame);
}
/* Probe response frame */
if (*(paction + 3) == 0x05) {
/* WFDTDLS: for sigma test, do not setup direct link automatically */
ptdlsinfo->dev_discovered = _TRUE;
RTW_INFO("recv tunneled probe response frame\n");
}
}
break;
#endif /* CONFIG_WFD */
default:
RTW_INFO("receive TDLS frame %d but not support\n", *paction);
ret = _FAIL;
break;
}
exit:
return ret;
}
sint rtw_tdls_rx_data_validate_hdr(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info **psta
)
{
u8 *ptr = precv_frame->u.hdr.rx_data;
sint ret = _SUCCESS;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u8 *mybssid = get_bssid(pmlmepriv);
u8 *myhwaddr = adapter_mac_addr(adapter);
u8 *sta_addr = pattrib->ta;
sint bmcast = IS_MCAST(pattrib->dst);
struct tdls_info *ptdlsinfo = &adapter->tdlsinfo;
#ifdef CONFIG_TDLS_CH_SW
struct tdls_ch_switch *pchsw_info = &ptdlsinfo->chsw_info;
#endif
struct sta_info *ptdls_sta = NULL;
u8 *psnap_type = ptr + pattrib->hdrlen + pattrib->iv_len + SNAP_SIZE;
/* frame body located after [+2]: ether-type, [+1]: payload type */
u8 *pframe_body = psnap_type + 2 + 1;
*psta = ptdls_sta = rtw_get_stainfo(pstapriv, pattrib->ta);
if (ptdls_sta == NULL) {
ret = _FAIL;
goto exit;
} else if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) {
/* filter packets that SA is myself or multicast or broadcast */
if (_rtw_memcmp(myhwaddr, pattrib->src, ETH_ALEN)) {
ret = _FAIL;
goto exit;
}
/* da should be for me */
if ((!_rtw_memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) {
ret = _FAIL;
goto exit;
}
/* check BSSID */
if (_rtw_memcmp(pattrib->bssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) ||
_rtw_memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) ||
(!_rtw_memcmp(pattrib->bssid, mybssid, ETH_ALEN))) {
ret = _FAIL;
goto exit;
}
#ifdef CONFIG_TDLS_CH_SW
if (ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE) {
if (adapter->mlmeextpriv.chandef.chan != rtw_get_oper_ch(adapter)) {
pchsw_info->ch_sw_state |= TDLS_PEER_AT_OFF_STATE;
if (!(pchsw_info->ch_sw_state & TDLS_CH_SW_INITIATOR_STATE))
_cancel_timer_ex(&ptdls_sta->ch_sw_timer);
/* On_TDLS_Peer_Traffic_Rsp(adapter, precv_frame); */
}
}
#endif
/* process UAPSD tdls sta */
process_pwrbit_data(adapter, precv_frame, ptdls_sta);
/* if NULL-frame, check pwrbit */
if ((get_frame_sub_type(ptr) & WIFI_DATA_NULL) == WIFI_DATA_NULL) {
/* NULL-frame with pwrbit=1, buffer_STA should buffer frames for sleep_STA */
if (GetPwrMgt(ptr)) {
/* it would be triggered when we are off channel and receiving NULL DATA */
/* we can confirm that peer STA is at off channel */
RTW_INFO("TDLS: recv peer null frame with pwr bit 1\n");
/* ptdls_sta->tdls_sta_state|=TDLS_PEER_SLEEP_STATE; */
}
/* TODO: Updated BSSID's seq. */
/* RTW_INFO("drop Null Data\n"); */
ptdls_sta->tdls_sta_state &= ~(TDLS_WAIT_PTR_STATE);
ret = _FAIL;
goto exit;
}
/* receive some of all TDLS management frames, process it at ON_TDLS */
if (_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_TDLS, 2)) {
ret = OnTDLS(adapter, precv_frame);
goto exit;
}
if ((get_frame_sub_type(ptr) & WIFI_QOS_DATA_TYPE) == WIFI_QOS_DATA_TYPE)
process_wmmps_data(adapter, precv_frame, ptdls_sta);
ptdls_sta->tdls_sta_state &= ~(TDLS_WAIT_PTR_STATE);
}
exit:
return ret;
}
#endif /* CONFIG_TDLS */
void count_rx_stats(_adapter *padapter, union recv_frame *prframe, struct sta_info *sta)
{
int sz;
struct sta_info *psta = NULL;
struct stainfo_stats *pstats = NULL;
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct recv_info *precvinfo = &padapter->recvinfo;
sz = get_recvframe_len(prframe);
precvinfo->rx_bytes += sz;
padapter->mlmepriv.LinkDetectInfo.NumRxOkInPeriod++;
if ((!MacAddr_isBcst(pattrib->dst)) && (!IS_MCAST(pattrib->dst)))
padapter->mlmepriv.LinkDetectInfo.NumRxUnicastOkInPeriod++;
if (sta)
psta = sta;
else
psta = prframe->u.hdr.psta;
if (psta) {
u8 is_ra_bmc = IS_MCAST(pattrib->ra);
pstats = &psta->sta_stats;
pstats->last_rx_time = rtw_get_current_time();
pstats->rx_data_pkts++;
pstats->rx_bytes += sz;
if (is_broadcast_mac_addr(pattrib->ra)) {
pstats->rx_data_bc_pkts++;
pstats->rx_bc_bytes += sz;
} else if (is_ra_bmc) {
pstats->rx_data_mc_pkts++;
pstats->rx_mc_bytes += sz;
}
if (!is_ra_bmc) {
pstats->rxratecnt[pattrib->data_rate]++;
/*record rx packets for every tid*/
pstats->rx_data_qos_pkts[pattrib->priority]++;
}
#if defined(CONFIG_CHECK_LEAVE_LPS) && defined(CONFIG_LPS_CHK_BY_TP)
if (adapter_to_pwrctl(padapter)->lps_chk_by_tp)
traffic_check_for_leave_lps_by_tp(padapter, _FALSE, psta);
#endif /* CONFIG_LPS */
}
#ifdef CONFIG_CHECK_LEAVE_LPS
#ifdef CONFIG_LPS_CHK_BY_TP
if (!adapter_to_pwrctl(padapter)->lps_chk_by_tp)
#endif
traffic_check_for_leave_lps(padapter, _FALSE, 0);
#endif /* CONFIG_CHECK_LEAVE_LPS */
}
sint sta2sta_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info **psta
)
{
u8 *ptr = precv_frame->u.hdr.rx_data;
sint ret = _SUCCESS;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u8 *mybssid = get_bssid(pmlmepriv);
u8 *myhwaddr = adapter_mac_addr(adapter);
u8 *sta_addr = pattrib->ta;
sint bmcast = IS_MCAST(pattrib->dst);
/* RTW_INFO("[%s] %d, seqnum:%d\n", __FUNCTION__, __LINE__, pattrib->seq_num); */
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
/* filter packets that SA is myself or multicast or broadcast */
if (_rtw_memcmp(myhwaddr, pattrib->src, ETH_ALEN)) {
ret = _FAIL;
goto exit;
}
if ((!_rtw_memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) {
ret = _FAIL;
goto exit;
}
if (_rtw_memcmp(pattrib->bssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) ||
_rtw_memcmp(mybssid, "\x0\x0\x0\x0\x0\x0", ETH_ALEN) ||
(!_rtw_memcmp(pattrib->bssid, mybssid, ETH_ALEN))) {
ret = _FAIL;
goto exit;
}
} else if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE) {
_rtw_memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->src, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->bssid, GetAddr3Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
sta_addr = mybssid;
} else
ret = _FAIL;
*psta = rtw_get_stainfo(pstapriv, sta_addr);
if (*psta == NULL) {
#ifdef CONFIG_MP_INCLUDED
if (adapter->registrypriv.mp_mode == 1) {
if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE)
adapter->mppriv.rx_pktloss++;
}
#endif
ret = _FAIL;
goto exit;
}
exit:
return ret;
}
sint ap2sta_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info **psta)
{
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
sint ret = _SUCCESS;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u8 *myhwaddr = adapter_mac_addr(adapter);
sint bmcast = IS_MCAST(pattrib->dst);
if ((check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE) &&
(check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
_rtw_memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->src, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->bssid, GetAddr3Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
*psta = rtw_get_stainfo(pstapriv, pattrib->bssid); /* get sta_info */
if (*psta == NULL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" can't get psta under WIFI_MP_STATE ; drop pkt\n"
, FUNC_ADPT_ARG(adapter));
#endif
ret = _FAIL;
goto exit;
}
} else {
if (_rtw_memcmp(myhwaddr, pattrib->dst, ETH_ALEN) && (!bmcast)) {
*psta = rtw_get_stainfo(pstapriv, pattrib->ta);
if (*psta == NULL) {
/* for AP multicast issue , modify by yiwei */
static systime send_issue_deauth_time = 0;
/* RTW_INFO("After send deauth , %u ms has elapsed.\n", rtw_get_passing_time_ms(send_issue_deauth_time)); */
if (rtw_get_passing_time_ms(send_issue_deauth_time) > 10000 || send_issue_deauth_time == 0) {
send_issue_deauth_time = rtw_get_current_time();
RTW_INFO("issue_deauth to the ap=" MAC_FMT " for the reason(7)\n", MAC_ARG(pattrib->bssid));
issue_deauth(adapter, pattrib->bssid, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
}
}
}
ret = _FAIL;
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" fw_state:0x%x\n"
, FUNC_ADPT_ARG(adapter), get_fwstate(pmlmepriv));
#endif
}
exit:
return ret;
}
sint sta2ap_data_frame(
_adapter *adapter,
union recv_frame *precv_frame,
struct sta_info **psta)
{
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
sint ret = _SUCCESS;
if ((check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE) &&
(check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
/* RTW_INFO("%s ,in WIFI_MP_STATE\n",__func__); */
_rtw_memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->src, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->bssid, GetAddr3Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
*psta = rtw_get_stainfo(pstapriv, pattrib->bssid); /* get sta_info */
if (*psta == NULL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" can't get psta under WIFI_MP_STATE ; drop pkt\n"
, FUNC_ADPT_ARG(adapter));
#endif
ret = _FAIL;
goto exit;
}
} else {
u8 *myhwaddr = adapter_mac_addr(adapter);
if (!_rtw_memcmp(pattrib->ra, myhwaddr, ETH_ALEN)) {
ret = RTW_RX_HANDLED;
goto exit;
}
#ifndef CONFIG_CUSTOMER_ALIBABA_GENERAL
RTW_INFO("issue_deauth to sta=" MAC_FMT " for the reason(7)\n", MAC_ARG(pattrib->src));
issue_deauth(adapter, pattrib->src, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
#endif
ret = RTW_RX_HANDLED;
goto exit;
}
exit:
return ret;
}
int rtw_sta_rx_data_validate_hdr(_adapter *adapter, union recv_frame *rframe, struct sta_info **sta)
{
struct sta_priv *stapriv = &adapter->stapriv;
u8 *myhwaddr = adapter_mac_addr(adapter);
struct rx_pkt_attrib *rattrib = &rframe->u.hdr.attrib;
u8 *whdr = get_recvframe_data(rframe);
u8 is_ra_bmc = IS_MCAST(GetAddr1Ptr(whdr)) ? 1 : 0;
sint ret = _FAIL;
if (rattrib->to_fr_ds == 0) {
_rtw_memcpy(rattrib->ra, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->ta, get_addr2_ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->dst, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->src, get_addr2_ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->bssid, GetAddr3Ptr(whdr), ETH_ALEN);
#ifdef CONFIG_TDLS
if (adapter->tdlsinfo.link_established == _TRUE)
ret = rtw_tdls_rx_data_validate_hdr(adapter, rframe, sta);
else
#endif
{
/* For Station mode, sa and bssid should always be BSSID, and DA is my mac-address */
if (!_rtw_memcmp(rattrib->bssid, rattrib->src, ETH_ALEN))
goto exit;
*sta = rtw_get_stainfo(stapriv, get_addr2_ptr(whdr));
if (*sta)
ret = _SUCCESS;
}
goto exit;
}
if (!(MLME_STATE(adapter) & (WIFI_ASOC_STATE | WIFI_UNDER_LINKING))) {
if (!is_ra_bmc) {
/* for AP multicast issue , modify by yiwei */
static systime send_issue_deauth_time = 0;
/* RTW_INFO("After send deauth , %u ms has elapsed.\n", rtw_get_passing_time_ms(send_issue_deauth_time)); */
if (rtw_get_passing_time_ms(send_issue_deauth_time) > 10000 || send_issue_deauth_time == 0) {
send_issue_deauth_time = rtw_get_current_time();
RTW_INFO(FUNC_ADPT_FMT" issue_deauth to "MAC_FMT" with reason(7), mlme_state:0x%x\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(get_addr2_ptr(whdr)), MLME_STATE(adapter));
issue_deauth(adapter, get_addr2_ptr(whdr), WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
}
}
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" fw_state:0x%x\n"
, FUNC_ADPT_ARG(adapter), MLME_STATE(adapter));
#endif
goto exit;
}
_rtw_memcpy(rattrib->ra, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->ta, get_addr2_ptr(whdr), ETH_ALEN);
switch (rattrib->to_fr_ds) {
case 1:
_rtw_memcpy(rattrib->dst, GetAddr1Ptr(whdr), ETH_ALEN);
_rtw_memcpy(rattrib->src, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->bssid, get_addr2_ptr(whdr), ETH_ALEN);
break;
case 3:
_rtw_memcpy(rattrib->dst, GetAddr3Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->src, GetAddr4Ptr(whdr), ETH_ALEN); /* may change after checking AMSDU subframe header */
_rtw_memcpy(rattrib->bssid, get_addr2_ptr(whdr), ETH_ALEN);
break;
default:
ret = RTW_RX_HANDLED; /* don't count for drop */
goto exit;
}
/* filter packets that SA is myself */
if (!rattrib->amsdu && _rtw_memcmp(myhwaddr, rattrib->src, ETH_ALEN)) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" SA="MAC_FMT", myhwaddr="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(rattrib->src), MAC_ARG(myhwaddr));
#endif
goto exit;
}
*sta = rtw_get_stainfo(stapriv, rattrib->ta);
if (*sta == NULL) {
#ifndef CONFIG_CUSTOMER_ALIBABA_GENERAL
if (!is_ra_bmc && !IS_RADAR_DETECTED(adapter_to_rfctl(adapter))) {
RTW_INFO(FUNC_ADPT_FMT" issue_deauth to "MAC_FMT" with reason(7), unknown TA\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(rattrib->ta));
issue_deauth(adapter, rattrib->ta, WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
}
#endif
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" can't get psta under STATION_MODE ; drop pkt\n"
, FUNC_ADPT_ARG(adapter));
#endif
goto exit;
}
#ifdef CONFIG_RTW_WDS_AUTO_EN
if (rattrib->to_fr_ds == 3 && !(sta->flags & WLAN_STA_WDS))
sta->flags |= WLAN_STA_WDS;
#endif
/*if ((get_frame_sub_type(whdr) & WIFI_QOS_DATA_TYPE) == WIFI_QOS_DATA_TYPE) {
}
*/
if (get_frame_sub_type(whdr) & BIT(6)) {
/* No data, will not indicate to upper layer, temporily count it here */
count_rx_stats(adapter, rframe, *sta);
ret = RTW_RX_HANDLED;
goto exit;
}
#ifdef CONFIG_RTW_WDS
if (adapter_use_wds(adapter)
&& !rattrib->amsdu && IS_MCAST(rattrib->dst)
&& rtw_rx_wds_gptr_check(adapter, rattrib->src)
) {
/* will not indicate to upper layer, temporily count it here */
count_rx_stats(adapter, rframe, *sta);
ret = RTW_RX_HANDLED;
goto exit;
}
#endif
ret = _SUCCESS;
exit:
return ret;
}
int rtw_sta_rx_amsdu_act_check(union recv_frame *rframe
, const u8 *da, const u8 *sa)
{
int act = RTW_RX_MSDU_ACT_INDICATE;
#ifdef CONFIG_RTW_WDS
_adapter *adapter = rframe->u.hdr.adapter;
if (adapter_use_wds(adapter)
&& IS_MCAST(da)
&& rtw_rx_wds_gptr_check(adapter, sa)
) {
act = 0;
}
#endif
return act;
}
#ifdef CONFIG_AP_MODE
sint rtw_proccess_pspoll(_adapter *adapter, union recv_frame *precv_frame, struct sta_info *psta)
{
u8 *pframe = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &adapter->stapriv;
u16 aid;
u8 wmmps_ac = 0;
aid = GetAid(pframe);
if (psta->phl_sta->aid != aid)
return _FAIL;
switch (pattrib->priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk & BIT(0);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi & BIT(0);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo & BIT(0);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be & BIT(0);
break;
}
if (wmmps_ac)
return _FAIL;
if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
RTW_INFO("%s alive check-rx ps-poll\n", __func__);
psta->expire_to = pstapriv->expire_to;
psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
}
if ((psta->state & WIFI_SLEEP_STATE) && (rtw_tim_map_is_set(adapter, pstapriv->sta_dz_bitmap, psta->phl_sta->aid))) {
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
/* _rtw_spinlock_bh(&psta->sleep_q.lock); */
_rtw_spinlock_bh(&pxmitpriv->lock);
xmitframe_phead = get_list_head(&psta->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
if ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
xmitframe_plist = get_next(xmitframe_plist);
rtw_list_delete(&pxmitframe->list);
psta->sleepq_len--;
if (psta->sleepq_len > 0)
pxmitframe->attrib.mdata = 1;
else
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.triggered = 1;
/* RTW_INFO("handling ps-poll, q_len=%d\n", psta->sleepq_len); */
/* RTW_INFO_DUMP("handling, tim=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len); */
#if 0
_rtw_spinunlock_bh(&psta->sleep_q.lock);
if (rtw_hal_xmit(padapter, pxmitframe) == _TRUE)
rtw_os_xmit_complete(padapter, pxmitframe);
_rtw_spinlock_bh(&psta->sleep_q.lock);
#endif
rtw_intf_xmitframe_enqueue(adapter, pxmitframe);
if (psta->sleepq_len == 0) {
rtw_tim_map_clear(adapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
/* RTW_INFO("after handling ps-poll\n"); */
/* RTW_INFO_DUMP("after handling, tim=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len); */
/* upate BCN for TIM IE */
/* update_BCNTIM(padapter); */
rtw_update_beacon(adapter, _TIM_IE_, NULL, _TRUE, 0);
}
/* _rtw_spinunlock_bh(&psta->sleep_q.lock); */
_rtw_spinunlock_bh(&pxmitpriv->lock);
} else {
/* _rtw_spinunlock_bh(&psta->sleep_q.lock); */
_rtw_spinunlock_bh(&pxmitpriv->lock);
/* RTW_INFO("no buffered packets to xmit\n"); */
if (rtw_tim_map_is_set(adapter, pstapriv->tim_bitmap, psta->phl_sta->aid)) {
if (psta->sleepq_len == 0) {
RTW_INFO("no buffered packets to xmit\n");
/* issue nulldata with More data bit = 0 to indicate we have no buffered packets */
issue_nulldata(adapter, psta->phl_sta->mac_addr, 0, 0, 0);
} else {
RTW_INFO("error!psta->sleepq_len=%d\n", psta->sleepq_len);
psta->sleepq_len = 0;
}
rtw_tim_map_clear(adapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
/* upate BCN for TIM IE */
/* update_BCNTIM(padapter); */
rtw_update_beacon(adapter, _TIM_IE_, NULL, _TRUE, 0);
}
}
}
return _SUCCESS;
}
#endif /*CONFIG_AP_MODE*/
sint validate_recv_ctrl_frame(_adapter *padapter, union recv_frame *precv_frame)
{
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *pframe = precv_frame->u.hdr.rx_data;
struct sta_info *psta = NULL;
/* uint len = precv_frame->u.hdr.len; */
/* RTW_INFO("+validate_recv_ctrl_frame\n"); */
if (GetFrameType(pframe) != WIFI_CTRL_TYPE)
return _FAIL;
/* receive the frames that ra(a1) is my address */
if (!_rtw_memcmp(GetAddr1Ptr(pframe), adapter_mac_addr(padapter), ETH_ALEN))
return _FAIL;
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta == NULL)
return _FAIL;
/* for rx pkt statistics */
psta->sta_stats.last_rx_time = rtw_get_current_time();
psta->sta_stats.rx_ctrl_pkts++;
switch (get_frame_sub_type(pframe)) {
#ifdef CONFIG_AP_MODE
case WIFI_PSPOLL :
{
sint rst;
rst = rtw_proccess_pspoll(padapter, precv_frame, psta);
/*RTW_INFO(FUNC_ADPT_FMT" pspoll handle %d\n", FUNC_ADPT_ARG(padapter), rst);*/
}
break;
#endif
case WIFI_BAR :
rtw_process_bar_frame(padapter, precv_frame);
break;
default :
break;
}
return _FAIL;
}
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
static sint validate_mgmt_protect(_adapter *adapter, union recv_frame *precv_frame)
{
#define DBG_VALIDATE_MGMT_PROTECT 0
#define DBG_VALIDATE_MGMT_DEC 0
struct security_priv *sec = &adapter->securitypriv;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_info *psta = precv_frame->u.hdr.psta;
u8 *ptr;
u8 type;
u8 subtype;
u8 is_bmc;
u8 category = 0xFF;
#ifdef CONFIG_IEEE80211W
const u8 *igtk;
u16 igtk_id;
u64* ipn;
enum security_type bip_cipher;
#endif
u8 *mgmt_DATA;
u32 data_len = 0;
sint ret;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(adapter)) {
if (!adapter->mesh_info.mesh_auth_id)
return pattrib->privacy ? _FAIL : _SUCCESS;
} else
#endif
if (SEC_IS_BIP_KEY_INSTALLED(sec) == _FALSE)
return _SUCCESS;
ptr = precv_frame->u.hdr.rx_data;
type = GetFrameType(ptr);
subtype = get_frame_sub_type(ptr); /* bit(7)~bit(2) */
is_bmc = IS_MCAST(GetAddr1Ptr(ptr));
#if DBG_VALIDATE_MGMT_PROTECT
if (subtype == WIFI_DEAUTH) {
RTW_INFO(FUNC_ADPT_FMT" bmc:%u, deauth, privacy:%u, encrypt:%u, bdecrypted:%u\n"
, FUNC_ADPT_ARG(adapter)
, is_bmc, pattrib->privacy, pattrib->encrypt, pattrib->bdecrypted);
} else if (subtype == WIFI_DISASSOC) {
RTW_INFO(FUNC_ADPT_FMT" bmc:%u, disassoc, privacy:%u, encrypt:%u, bdecrypted:%u\n"
, FUNC_ADPT_ARG(adapter)
, is_bmc, pattrib->privacy, pattrib->encrypt, pattrib->bdecrypted);
} if (subtype == WIFI_ACTION) {
if (pattrib->privacy) {
RTW_INFO(FUNC_ADPT_FMT" bmc:%u, action(?), privacy:%u, encrypt:%u, bdecrypted:%u\n"
, FUNC_ADPT_ARG(adapter)
, is_bmc, pattrib->privacy, pattrib->encrypt, pattrib->bdecrypted);
} else {
RTW_INFO(FUNC_ADPT_FMT" bmc:%u, action(%u), privacy:%u, encrypt:%u, bdecrypted:%u\n"
, FUNC_ADPT_ARG(adapter), is_bmc
, *(ptr + sizeof(struct rtw_ieee80211_hdr_3addr))
, pattrib->privacy, pattrib->encrypt, pattrib->bdecrypted);
}
}
#endif
if (!pattrib->privacy) {
if (!psta || !(psta->flags & WLAN_STA_MFP)) {
/* peer is not MFP capable, no need to check */
goto exit;
}
if (subtype == WIFI_ACTION)
category = *(ptr + sizeof(struct rtw_ieee80211_hdr_3addr));
if (is_bmc) {
/* broadcast cases */
if (subtype == WIFI_ACTION) {
if (CATEGORY_IS_GROUP_PRIVACY(category)) {
/* drop broadcast group privacy action frame without encryption */
#if DBG_VALIDATE_MGMT_PROTECT
RTW_INFO(FUNC_ADPT_FMT" broadcast gp action(%u) w/o encrypt\n"
, FUNC_ADPT_ARG(adapter), category);
#endif
goto fail;
}
if (CATEGORY_IS_ROBUST(category)) {
/* broadcast robust action frame need BIP check */
goto bip_verify;
}
}
if (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC) {
/* broadcast deauth or disassoc frame need BIP check */
goto bip_verify;
}
goto exit;
} else {
/* unicast cases */
#ifdef CONFIG_IEEE80211W
if (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC) {
if (!MLME_IS_MESH(adapter)
#ifdef CONFIG_RTW_WNM
&& (rtw_wnm_try_btm_roam_imnt(adapter) > 0)
#endif
) {
unsigned short reason = le16_to_cpu(*(unsigned short *)(ptr + WLAN_HDR_A3_LEN));
#if DBG_VALIDATE_MGMT_PROTECT
RTW_INFO(FUNC_ADPT_FMT" unicast %s, reason=%d w/o encrypt\n"
, FUNC_ADPT_ARG(adapter), subtype == WIFI_DEAUTH ? "deauth" : "disassoc", reason);
#endif
if (reason == 6 || reason == 7) {
/* issue sa query request */
issue_action_SA_Query(adapter, psta->phl_sta->mac_addr, 0, 0, IEEE80211W_RIGHT_KEY);
}
}
goto fail;
}
#endif
if (subtype == WIFI_ACTION && CATEGORY_IS_ROBUST(category)) {
if (psta->bpairwise_key_installed == _TRUE) {
#if DBG_VALIDATE_MGMT_PROTECT
RTW_INFO(FUNC_ADPT_FMT" unicast robust action(%d) w/o encrypt\n"
, FUNC_ADPT_ARG(adapter), category);
#endif
goto fail;
}
}
goto exit;
}
bip_verify:
#ifdef CONFIG_IEEE80211W
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(adapter)) {
if (psta->igtk_bmp) {
bip_cipher = psta->dot11wCipher;
igtk = psta->igtk.skey;
igtk_id = psta->igtk_id;
ipn = &psta->igtk_pn.val;
} else {
/* mesh MFP without IGTK */
goto exit;
}
} else
#endif
{
bip_cipher = sec->dot11wCipher;
igtk = sec->dot11wBIPKey[sec->dot11wBIPKeyid].skey;
igtk_id = sec->dot11wBIPKeyid;
ipn = &sec->dot11wBIPrxpn.val;
}
/* verify BIP MME IE */
ret = rtw_bip_verify(bip_cipher, pattrib->pkt_len,
get_recvframe_data(precv_frame),
get_recvframe_len(precv_frame),
igtk, igtk_id, ipn, (u8 *)precv_frame);
if (ret == _FAIL) {
/* RTW_INFO("802.11w BIP verify fail\n"); */
goto fail;
} else if (ret == RTW_RX_HANDLED) {
#if DBG_VALIDATE_MGMT_PROTECT
RTW_INFO(FUNC_ADPT_FMT" none protected packet\n", FUNC_ADPT_ARG(adapter));
#endif
goto fail;
}
#endif /* CONFIG_IEEE80211W */
goto exit;
}
if (!psta || !(psta->flags & WLAN_STA_MFP)) {
/* not peer or peer is not MFP capable, drop it */
goto fail;
}
/* cases to decrypt mgmt frame */
#if 0
pattrib->bdecrypted = 0;
#endif
#ifdef CONFIG_RTW_MESH
if (is_bmc)
pattrib->encrypt = psta->group_privacy;
else
#endif
pattrib->encrypt = psta->dot118021XPrivacy;
pattrib->hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
/* set iv and icv length */
SET_ICE_IV_LEN(pattrib->iv_len, pattrib->icv_len, pattrib->encrypt);
_rtw_memcpy(pattrib->ra, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ta, get_addr2_ptr(ptr), ETH_ALEN);
/* actual management data frame body */
data_len = pattrib->pkt_len - pattrib->hdrlen - pattrib->iv_len - pattrib->icv_len;
mgmt_DATA = rtw_zmalloc(data_len);
if (mgmt_DATA == NULL) {
RTW_INFO(FUNC_ADPT_FMT" mgmt allocate fail !!!!!!!!!\n", FUNC_ADPT_ARG(adapter));
goto fail;
}
#if DBG_VALIDATE_MGMT_DEC
/* dump the packet content before decrypt */
{
int pp;
printk("pattrib->pktlen = %d =>", pattrib->pkt_len);
for (pp = 0; pp < pattrib->pkt_len; pp++)
printk(" %02x ", ptr[pp]);
printk("\n");
}
#endif
precv_frame = decryptor(adapter, precv_frame);
/* save actual management data frame body */
_rtw_memcpy(mgmt_DATA, ptr + pattrib->hdrlen + pattrib->iv_len, data_len);
/* overwrite the iv field */
_rtw_memcpy(ptr + pattrib->hdrlen, mgmt_DATA, data_len);
/* remove the iv and icv length */
pattrib->pkt_len = pattrib->pkt_len - pattrib->iv_len - pattrib->icv_len;
rtw_mfree(mgmt_DATA, data_len);
#if DBG_VALIDATE_MGMT_DEC
/* print packet content after decryption */
{
int pp;
printk("after decryption pattrib->pktlen = %d @@=>", pattrib->pkt_len);
for (pp = 0; pp < pattrib->pkt_len; pp++)
printk(" %02x ", ptr[pp]);
printk("\n");
}
#endif
if (!precv_frame) {
#if DBG_VALIDATE_MGMT_PROTECT
RTW_INFO(FUNC_ADPT_FMT" mgmt descrypt fail !!!!!!!!!\n", FUNC_ADPT_ARG(adapter));
#endif
goto fail;
}
exit:
return _SUCCESS;
fail:
return _FAIL;
}
#endif /* defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH) */
s32 recvframe_chk_defrag(_adapter *padapter, union recv_frame **pprecv_frame);
sint validate_recv_mgnt_frame(_adapter *padapter, union recv_frame *precv_frame)
{
struct sta_info *psta = precv_frame->u.hdr.psta
= rtw_get_stainfo(&padapter->stapriv, get_addr2_ptr(precv_frame->u.hdr.rx_data));
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
if (validate_mgmt_protect(padapter, precv_frame) == _FAIL) {
DBG_COUNTER(padapter->rx_logs.core_rx_pre_mgmt_err_80211w);
goto exit;
}
#endif
if (recvframe_chk_defrag(padapter, &precv_frame) != CORE_RX_CONTINUE)
return _SUCCESS;
/* for rx pkt statistics */
if (psta) {
psta->sta_stats.last_rx_time = rtw_get_current_time();
psta->sta_stats.rx_mgnt_pkts++;
if (get_frame_sub_type(precv_frame->u.hdr.rx_data) == WIFI_BEACON)
psta->sta_stats.rx_beacon_pkts++;
else if (get_frame_sub_type(precv_frame->u.hdr.rx_data) == WIFI_PROBEREQ)
psta->sta_stats.rx_probereq_pkts++;
else if (get_frame_sub_type(precv_frame->u.hdr.rx_data) == WIFI_PROBERSP) {
if (_rtw_memcmp(adapter_mac_addr(padapter), GetAddr1Ptr(precv_frame->u.hdr.rx_data), ETH_ALEN) == _TRUE)
psta->sta_stats.rx_probersp_pkts++;
else if (is_broadcast_mac_addr(GetAddr1Ptr(precv_frame->u.hdr.rx_data))
|| is_multicast_mac_addr(GetAddr1Ptr(precv_frame->u.hdr.rx_data)))
psta->sta_stats.rx_probersp_bm_pkts++;
else
psta->sta_stats.rx_probersp_uo_pkts++;
}
}
mgt_dispatcher(padapter, precv_frame);
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
exit:
#endif
return _SUCCESS;
}
sint validate_recv_data_frame(_adapter *adapter, union recv_frame *precv_frame)
{
u8 bretry, a4_shift;
struct sta_info *psta = NULL;
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct security_priv *psecuritypriv = &adapter->securitypriv;
sint ret = _SUCCESS;
#ifdef ROKU_PRIVATE
struct stainfo_stats *pstats = NULL;
#endif
bretry = GetRetry(ptr);
a4_shift = (pattrib->to_fr_ds == 3) ? ETH_ALEN : 0;
/* some address fields are different when using AMSDU */
if (pattrib->qos)
pattrib->amsdu = GetAMsdu(ptr + WLAN_HDR_A3_LEN + a4_shift);
else
pattrib->amsdu = 0;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(adapter)) {
ret = rtw_mesh_rx_data_validate_hdr(adapter, precv_frame, &psta);
goto pre_validate_status_chk;
} else
#endif
#ifdef CONFIG_AP_MODE
if (MLME_IS_AP(adapter)) {
ret = rtw_ap_rx_data_validate_hdr(adapter, precv_frame, &psta);
goto pre_validate_status_chk;
} else
#endif
if (MLME_IS_STA(adapter)) {
ret = rtw_sta_rx_data_validate_hdr(adapter, precv_frame, &psta);
goto pre_validate_status_chk;
}
switch (pattrib->to_fr_ds) {
case 0:
_rtw_memcpy(pattrib->ra, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ta, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->src, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->bssid, GetAddr3Ptr(ptr), ETH_ALEN);
ret = sta2sta_data_frame(adapter, precv_frame, &psta);
break;
case 1:
_rtw_memcpy(pattrib->ra, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ta, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->src, GetAddr3Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->bssid, get_addr2_ptr(ptr), ETH_ALEN);
ret = ap2sta_data_frame(adapter, precv_frame, &psta);
break;
case 2:
_rtw_memcpy(pattrib->ra, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ta, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->dst, GetAddr3Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->src, get_addr2_ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->bssid, GetAddr1Ptr(ptr), ETH_ALEN);
ret = sta2ap_data_frame(adapter, precv_frame, &psta);
break;
case 3:
default:
/* WDS is not supported */
ret = _FAIL;
break;
}
pre_validate_status_chk:
#ifdef ROKU_PRIVATE
if(psta!=NULL && bretry){
pstats = &psta->sta_stats;
ATOMIC_ADD((ATOMIC_T *)&pstats->rx_retry_cnt, 1);
}
#endif
if (ret == _FAIL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" case:%d, res:%d, ra="MAC_FMT", ta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), pattrib->to_fr_ds, ret, MAC_ARG(GetAddr1Ptr(ptr)), MAC_ARG(get_addr2_ptr(ptr)));
#endif
goto exit;
} else if (ret == RTW_RX_HANDLED)
goto exit;
if (psta == NULL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" psta == NULL, ra="MAC_FMT", ta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(GetAddr1Ptr(ptr)), MAC_ARG(get_addr2_ptr(ptr)));
#endif
ret = _FAIL;
goto exit;
}
if ((psta->flags & WLAN_STA_AMSDU_DISABLE) && pattrib->amsdu) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" amsdu not allowed"MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->cmn.mac_addr));
#endif
ret = _FAIL;
goto exit;
}
precv_frame->u.hdr.psta = psta;
#ifdef CONFIG_RECV_REORDERING_CTRL
precv_frame->u.hdr.preorder_ctrl = NULL;
#endif
pattrib->ack_policy = 0;
/* parsing QC field */
if (pattrib->qos == 1) {
pattrib->priority = GetPriority((ptr + WLAN_HDR_A3_LEN + a4_shift)); /* point to Qos field*/
pattrib->ack_policy = GetAckpolicy((ptr + WLAN_HDR_A3_LEN + a4_shift));
pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN + a4_shift;
} else {
pattrib->priority = 0;
pattrib->hdrlen = WLAN_HDR_A3_LEN + a4_shift;
}
if (pattrib->order) /* HT-CTRL 11n */
pattrib->hdrlen += 4;
/* decache, drop duplicate recv packets */
ret = recv_decache(precv_frame);
if (ret == _FAIL)
goto exit;
if (!IS_MCAST(pattrib->ra)) {
#ifdef CONFIG_RECV_REORDERING_CTRL
if (pattrib->qos)
precv_frame->u.hdr.preorder_ctrl = &psta->recvreorder_ctrl[pattrib->priority];
#endif
if (recv_ucast_pn_decache(precv_frame) == _FAIL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recv_ucast_pn_decache return _FAIL for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->phl_sta->mac_addr));
#endif
ret = _FAIL;
goto exit;
}
} else {
if (recv_bcast_pn_decache(precv_frame) == _FAIL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recv_bcast_pn_decache return _FAIL for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->phl_sta->mac_addr));
#endif
ret = _FAIL;
goto exit;
}
}
if (pattrib->privacy) {
#ifdef CONFIG_TDLS
if ((psta->tdls_sta_state & TDLS_LINKED_STATE) && (psta->dot118021XPrivacy == _AES_))
pattrib->encrypt = psta->dot118021XPrivacy;
else
#endif /* CONFIG_TDLS */
GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, IS_MCAST(pattrib->ra));
SET_ICE_IV_LEN(pattrib->iv_len, pattrib->icv_len, pattrib->encrypt);
} else {
pattrib->encrypt = 0;
pattrib->iv_len = pattrib->icv_len = 0;
}
/* drop unprotected frame in protected network. */
if (psecuritypriv->dot11PrivacyAlgrthm != _NO_PRIVACY_ ) {
if (IS_MCAST(pattrib->ra)) {
if (!pattrib->privacy) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT"recv plaintext bmc packet for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->cmn.mac_addr));
#endif
ret = _FAIL;
goto exit;
}
} else {
/* unicast */
u16 ether_type;
u8* ether_ptr = NULL;
u16 eapol_type = 0x888e;
ether_ptr = ptr + pattrib->hdrlen + pattrib->iv_len + RATTRIB_GET_MCTRL_LEN(pattrib) + LLC_HEADER_SIZE;
_rtw_memcpy(ðer_type, ether_ptr, 2);
ether_type = ntohs((unsigned short)ether_type);
if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
/* CVE-2020-26140, CVE-2020-26143, CVE-2020-26147, let eapol packet go through*/
if (!pattrib->privacy && ether_type != eapol_type ) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT"recv plaintext unicast packet for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->cmn.mac_addr));
#endif
ret = _FAIL;
goto exit;
}
/* CVE-2020-26144, pevernt plaintext A-MSDU */
/* This can prevent plantext A-MSDU cloacked as an EAPOL frame */
if (!pattrib->privacy && pattrib->amsdu) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT"recv plaintext A-MSDU for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->cmn.mac_addr));
#endif
ret = _FAIL;
goto exit;
}
/* CVE-2020-26139, Drop any forwarding eapol packet until 4-way has done. */
if ((ether_type == eapol_type)
&& (MLME_IS_AP(adapter) || MLME_IS_MESH(adapter))
&& (psta->dot118021XPrivacy == _NO_PRIVACY_)
&& (!_rtw_memcmp( adapter_mac_addr(adapter), pattrib->dst, ETH_ALEN))) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recv eapol packet forwarding(dst:"MAC_FMT") before 4-way finish.\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(pattrib->dst));
#endif
ret = _FAIL;
goto exit;
}
} else {
/* CVE-2020-26140, CVE-2020-26143, CVE-2020-26147 */
if (!pattrib->privacy) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT"recv plaintext packet for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->cmn.mac_addr));
#endif
ret = _FAIL;
goto exit;
}
}
}
}
#ifdef CONFIG_RTW_MESH
if (!pattrib->amsdu
&& pattrib->mesh_ctrl_present
&& (!pattrib->encrypt || pattrib->bdecrypted))
ret = rtw_mesh_rx_validate_mctrl_non_amsdu(adapter, precv_frame);
#endif
exit:
#ifdef RTW_PHL_TEST_FPGA
return _SUCCESS;
#endif
return ret;
}
static inline void dump_rx_packet(u8 *ptr)
{
int i;
RTW_INFO("#############################\n");
for (i = 0; i < 64; i = i + 8)
RTW_INFO("%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X:\n", *(ptr + i),
*(ptr + i + 1), *(ptr + i + 2) , *(ptr + i + 3) , *(ptr + i + 4), *(ptr + i + 5), *(ptr + i + 6), *(ptr + i + 7));
RTW_INFO("#############################\n");
}
sint validate_recv_frame(_adapter *adapter, union recv_frame *precv_frame)
{
/* shall check frame subtype, to / from ds, da, bssid */
/* then call check if rx seq/frag. duplicated. */
u8 type;
u8 subtype;
sint retval = _SUCCESS;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct recv_info *precvinfo = &adapter->recvinfo;
u8 *ptr = precv_frame->u.hdr.rx_data;
u8 ver = (unsigned char)(*ptr) & 0x3 ;
#ifdef CONFIG_FIND_BEST_CHANNEL
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
#endif
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &adapter->tdlsinfo;
#endif /* CONFIG_TDLS */
#ifdef CONFIG_WAPI_SUPPORT
PRT_WAPI_T pWapiInfo = &adapter->wapiInfo;
struct recv_frame_hdr *phdr = &precv_frame->u.hdr;
u8 wai_pkt = 0;
u16 sc;
u8 external_len = 0;
#endif
#ifdef CONFIG_FIND_BEST_CHANNEL
if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) {
int ch_set_idx = rtw_chset_search_ch(rfctl->channel_set, rtw_get_oper_ch(adapter));
if (ch_set_idx >= 0)
rfctl->channel_set[ch_set_idx].rx_count++;
}
#endif
#ifdef CONFIG_TDLS
if (ptdlsinfo->ch_sensing == 1 && ptdlsinfo->cur_channel != 0)
ptdlsinfo->collect_pkt_num[ptdlsinfo->cur_channel - 1]++;
#endif /* CONFIG_TDLS */
#ifdef RTK_DMP_PLATFORM
if (0) {
RTW_INFO("++\n");
{
int i;
for (i = 0; i < 64; i = i + 8)
RTW_INFO("%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X:", *(ptr + i),
*(ptr + i + 1), *(ptr + i + 2) , *(ptr + i + 3) , *(ptr + i + 4), *(ptr + i + 5), *(ptr + i + 6), *(ptr + i + 7));
}
RTW_INFO("--\n");
}
#endif /* RTK_DMP_PLATFORM */
/* add version chk */
if (ver != 0) {
retval = _FAIL;
DBG_COUNTER(adapter->rx_logs.core_rx_pre_ver_err);
goto exit;
}
type = GetFrameType(ptr);
subtype = get_frame_sub_type(ptr); /* bit(7)~bit(2) */
pattrib->to_fr_ds = get_tofr_ds(ptr);
pattrib->frag_num = GetFragNum(ptr);
pattrib->seq_num = GetSequence(ptr);
pattrib->pw_save = GetPwrMgt(ptr);
pattrib->mfrag = GetMFrag(ptr);
pattrib->mdata = GetMData(ptr);
pattrib->privacy = GetPrivacy(ptr);
pattrib->order = GetOrder(ptr);
#ifdef CONFIG_WAPI_SUPPORT
sc = (pattrib->seq_num << 4) | pattrib->frag_num;
#endif
#ifdef RTW_PHL_DBG_CMD
pattrib->wl_type = type;
pattrib->wl_subtype = subtype;
if(type == WIFI_DATA_TYPE)
core_add_record(adapter, REC_RX_DATA, precv_frame);
else
core_add_record(adapter, REC_RX_MGMT, precv_frame);
#endif
#if 1 /* Dump rx packets */
{
u8 bDumpRxPkt = 0;
rtw_hal_get_def_var(adapter, HAL_DEF_DBG_DUMP_RXPKT, &(bDumpRxPkt));
if (bDumpRxPkt == 1) /* dump all rx packets */
dump_rx_packet(ptr);
else if ((bDumpRxPkt == 2) && (type == WIFI_MGT_TYPE))
dump_rx_packet(ptr);
else if ((bDumpRxPkt == 3) && (type == WIFI_DATA_TYPE))
dump_rx_packet(ptr);
}
#endif
#ifdef RTW_WKARD_CORE_RSSI_V1
rx_process_phy_info(precv_frame);
#endif
switch (type) {
case WIFI_MGT_TYPE: /* mgnt */
DBG_COUNTER(adapter->rx_logs.core_rx_pre_mgmt);
retval = validate_recv_mgnt_frame(adapter, precv_frame);
if (retval == _FAIL) {
DBG_COUNTER(adapter->rx_logs.core_rx_pre_mgmt_err);
}
retval = _FAIL; /* only data frame return _SUCCESS */
break;
case WIFI_CTRL_TYPE: /* ctrl */
DBG_COUNTER(adapter->rx_logs.core_rx_pre_ctrl);
retval = validate_recv_ctrl_frame(adapter, precv_frame);
if (retval == _FAIL) {
DBG_COUNTER(adapter->rx_logs.core_rx_pre_ctrl_err);
}
retval = _FAIL; /* only data frame return _SUCCESS */
break;
case WIFI_DATA_TYPE: /* data */
DBG_COUNTER(adapter->rx_logs.core_rx_pre_data);
#ifdef CONFIG_WAPI_SUPPORT
if (pattrib->qos)
external_len = 2;
else
external_len = 0;
wai_pkt = rtw_wapi_is_wai_packet(adapter, ptr);
phdr->bIsWaiPacket = wai_pkt;
if (wai_pkt != 0) {
if (sc != adapter->wapiInfo.wapiSeqnumAndFragNum)
adapter->wapiInfo.wapiSeqnumAndFragNum = sc;
else {
retval = _FAIL;
DBG_COUNTER(adapter->rx_logs.core_rx_pre_data_wapi_seq_err);
break;
}
} else {
if (rtw_wapi_drop_for_key_absent(adapter, get_addr2_ptr(ptr))) {
retval = _FAIL;
WAPI_TRACE(WAPI_RX, "drop for key absent for rx\n");
DBG_COUNTER(adapter->rx_logs.core_rx_pre_data_wapi_key_err);
break;
}
}
#endif
pattrib->qos = (subtype & BIT(7)) ? 1 : 0;
retval = validate_recv_data_frame(adapter, precv_frame);
if (retval == _FAIL) {
precvinfo->dbg_rx_drop_count++;
DBG_COUNTER(adapter->rx_logs.core_rx_pre_data_err);
} else if (retval == _SUCCESS) {
#ifdef DBG_RX_DUMP_EAP
if (!pattrib->encrypt || pattrib->bdecrypted) {
u8 bDumpRxPkt;
u16 eth_type;
/* dump eapol */
rtw_hal_get_def_var(adapter, HAL_DEF_DBG_DUMP_RXPKT, &(bDumpRxPkt));
/* get ether_type */
_rtw_memcpy(ð_type, ptr + pattrib->hdrlen + pattrib->iv_len + RATTRIB_GET_MCTRL_LEN(pattrib) + LLC_HEADER_SIZE, 2);
eth_type = ntohs((unsigned short) eth_type);
if ((bDumpRxPkt == 4) && (eth_type == 0x888e))
dump_rx_packet(ptr);
}
#endif
} else
DBG_COUNTER(adapter->rx_logs.core_rx_pre_data_handled);
break;
default:
DBG_COUNTER(adapter->rx_logs.core_rx_pre_unknown);
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" fail! type=0x%x\n"
, FUNC_ADPT_ARG(adapter), type);
#endif
retval = _FAIL;
break;
}
exit:
return retval;
}
/* Reture expected handling for LLC */
enum rtw_rx_llc_hdl rtw_recv_llc_parse(u8 *msdu, u16 msdu_len)
{
u16 eth_type;
if (msdu_len < 8)
return RTW_RX_LLC_KEEP;
eth_type = RTW_GET_BE16(msdu + SNAP_SIZE);
if ((_rtw_memcmp(msdu, rtw_rfc1042_header, SNAP_SIZE)
&& eth_type != ETH_P_AARP && eth_type != ETH_P_IPX)
|| _rtw_memcmp(msdu, rtw_bridge_tunnel_header, SNAP_SIZE)) {
/* remove RFC1042 or Bridge-Tunnel encapsulation and replace EtherType */
return RTW_RX_LLC_REMOVE;
} else {
/* Leave Ethernet header part of hdr and full payload */
return RTW_RX_LLC_KEEP;
}
/* TODO: VLAN tagged */
}
/* remove the wlanhdr and add the eth_hdr */
sint wlanhdr_to_ethhdr(union recv_frame *precvframe, enum rtw_rx_llc_hdl llc_hdl)
{
u8 *ptr = get_recvframe_data(precvframe) ; /* point to frame_ctrl field */
struct rx_pkt_attrib *pattrib = &precvframe->u.hdr.attrib;
sint rmv_len;
u16 len;
sint ret = _SUCCESS;
#ifdef CONFIG_RTW_CORE_RXSC
_adapter *adapter = precvframe->u.hdr.adapter;
struct core_rxsc_entry *rxsc_entry = NULL;
u16 eth_type;
#endif
if (pattrib->encrypt)
recvframe_pull_tail(precvframe, pattrib->icv_len);
rmv_len = pattrib->hdrlen + pattrib->iv_len + RATTRIB_GET_MCTRL_LEN(pattrib) + (llc_hdl ? SNAP_SIZE : 0);
len = precvframe->u.hdr.len - rmv_len;
#ifdef CONFIG_RTW_CORE_RXSC
_rtw_memcpy(ð_type, ptr + rmv_len, 2);
eth_type = ntohs((unsigned short)eth_type); /* pattrib->ether_type */
pattrib->eth_type = eth_type;
if (llc_hdl == RTW_RX_LLC_REMOVE)
pattrib->bsnaphdr = _TRUE;
else if (llc_hdl == RTW_RX_LLC_KEEP)
pattrib->bsnaphdr = _FALSE;
rxsc_entry = core_rxsc_alloc_entry(adapter, precvframe);
if (rxsc_entry) {
/* cache offset of payload */
rxsc_entry->rxsc_payload_offset = (rmv_len - sizeof(struct ethhdr) + (pattrib->bsnaphdr ? 2 : 0));
/* cache padding size of tail */
if (pattrib->encrypt)
rxsc_entry->rxsc_trim_pad = pattrib->icv_len;
else
rxsc_entry->rxsc_trim_pad = 0;
/* cache WLAN header */
_rtw_memcpy((void *)&rxsc_entry->rxsc_wlanhdr, ptr, pattrib->hdrlen);
}
#endif
ptr = recvframe_pull(precvframe, (rmv_len - sizeof(struct ethhdr) + (llc_hdl ? 2 : 0)));
if (!ptr) {
ret = _FAIL;
goto exiting;
}
_rtw_memcpy(ptr, pattrib->dst, ETH_ALEN);
_rtw_memcpy(ptr + ETH_ALEN, pattrib->src, ETH_ALEN);
if (!llc_hdl) {
len = htons(len);
_rtw_memcpy(ptr + 12, &len, 2);
}
rtw_rframe_set_os_pkt(precvframe);
#ifdef CONFIG_RTW_CORE_RXSC
if (rxsc_entry) {
/* Cache ETH header */
memcpy((void *)&rxsc_entry->rxsc_ethhdr, ptr, sizeof(rxsc_entry->rxsc_ethhdr));
/* Cache Rx Attribute */
memcpy((void *)&rxsc_entry->rxsc_attrib, pattrib, sizeof(rxsc_entry->rxsc_attrib));
}
#ifdef RTW_PHL_DBG_CMD
adapter->core_logs.rxCnt_data_orig++;
#endif
#endif
exiting:
return ret;
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
#ifndef CONFIG_SDIO_RX_COPY
#ifdef PLATFORM_LINUX
static void recvframe_expand_pkt(
_adapter *padapter,
union recv_frame *prframe)
{
struct recv_frame_hdr *pfhdr;
struct sk_buff *ppkt;
u8 shift_sz;
u32 alloc_sz;
u8 *ptr;
pfhdr = &prframe->u.hdr;
/* 6 is for IP header 8 bytes alignment in QoS packet case. */
if (pfhdr->attrib.qos)
shift_sz = 6;
else
shift_sz = 0;
/* for first fragment packet, need to allocate */
/* (1536 + RXDESC_SIZE + drvinfo_sz) to reassemble packet */
/* 8 is for skb->data 8 bytes alignment.
* alloc_sz = _RND(1536 + RXDESC_SIZE + pfhdr->attrib.drvinfosize + shift_sz + 8, 128); */
alloc_sz = 1664; /* round (1536 + 24 + 32 + shift_sz + 8) to 128 bytes alignment */
/* 3 1. alloc new skb */
/* prepare extra space for 4 bytes alignment */
ppkt = rtw_skb_alloc(alloc_sz);
if (!ppkt)
return; /* no way to expand */
/* 3 2. Prepare new skb to replace & release old skb */
/* force ppkt->data at 8-byte alignment address */
skb_reserve(ppkt, 8 - ((SIZE_PTR)ppkt->data & 7));
/* force ip_hdr at 8-byte alignment address according to shift_sz */
skb_reserve(ppkt, shift_sz);
/* copy data to new pkt */
ptr = skb_put(ppkt, pfhdr->len);
if (ptr)
_rtw_memcpy(ptr, pfhdr->rx_data, pfhdr->len);
rtw_skb_free(pfhdr->pkt);
/* attach new pkt to recvframe */
pfhdr->pkt = ppkt;
pfhdr->rx_head = ppkt->head;
pfhdr->rx_data = ppkt->data;
pfhdr->rx_tail = skb_tail_pointer(ppkt);
pfhdr->rx_end = skb_end_pointer(ppkt);
}
#else /*!= PLATFORM_LINUX*/
#warning "recvframe_expand_pkt not implement, defrag may crash system"
#endif
#endif /*#ifndef CONFIG_SDIO_RX_COPY*/
#endif
/* perform defrag */
union recv_frame *recvframe_defrag(_adapter *adapter, _queue *defrag_q)
{
_list *plist, *phead;
u8 *data, wlanhdr_offset;
u8 curfragnum;
struct recv_frame_hdr *pfhdr, *pnfhdr;
union recv_frame *prframe, *pnextrframe;
u8 *pdata = NULL;
u64 tmp_iv_hdr = 0;
u64 pkt_pn = 0, cur_pn = 0;
struct rx_pkt_attrib *pattrib = NULL;
curfragnum = 0;
phead = get_list_head(defrag_q);
plist = get_next(phead);
prframe = LIST_CONTAINOR(plist, union recv_frame, u);
/* CVE-2020-26146 */
pattrib = &prframe->u.hdr.attrib;
if (pattrib->encrypt == _AES_ || pattrib->encrypt == _CCMP_256_
|| pattrib->encrypt == _GCMP_ || pattrib->encrypt == _GCMP_256_ ) {
pdata = prframe->u.hdr.rx_data;
tmp_iv_hdr = le64_to_cpu(*(u64*)(pdata + pattrib->hdrlen));
/* get the first frame's PN. */
cur_pn = CCMPH_2_PN(tmp_iv_hdr);
}
pfhdr = &prframe->u.hdr;
rtw_list_delete(&(prframe->u.list));
if (curfragnum != pfhdr->attrib.frag_num) {
/* the first fragment number must be 0 */
/* free the whole queue */
rtw_free_recvframe(prframe);
rtw_free_recvframe_queue(defrag_q);
return NULL;
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
#ifndef CONFIG_SDIO_RX_COPY
recvframe_expand_pkt(adapter, prframe);
#endif
#endif
curfragnum++;
plist = get_list_head(defrag_q);
plist = get_next(plist);
data = get_recvframe_data(prframe);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
pnextrframe = LIST_CONTAINOR(plist, union recv_frame , u);
pnfhdr = &pnextrframe->u.hdr;
/* CVE-2020-26146, check whether the PN is consecutive. */
pattrib = &pnextrframe->u.hdr.attrib;
if (pattrib->encrypt == _AES_ || pattrib->encrypt == _CCMP_256_
|| pattrib->encrypt == _GCMP_ || pattrib->encrypt == _GCMP_256_ ) {
pdata = pnextrframe->u.hdr.rx_data;
tmp_iv_hdr = le64_to_cpu(*(u64*)(pdata + pattrib->hdrlen));
pkt_pn = CCMPH_2_PN(tmp_iv_hdr);
if (pkt_pn != cur_pn + 1) {
RTW_INFO("%s non-consective PN! old:%llu, new:%llu\n",
__func__, cur_pn, pkt_pn);
/* PN must be consecutive */
/* release the defrag_q & prframe */
rtw_free_recvframe(prframe);
rtw_free_recvframe_queue(defrag_q);
return NULL;
} else {
cur_pn = pkt_pn;
}
}
/* CVE-2020-24587, The keytrack of the fragment is supposed to be the same with other's */
if (pfhdr->keytrack != pnfhdr->keytrack) {
RTW_INFO("Inconsistent key track, drop fragmented frame!\n");
rtw_free_recvframe(prframe);
rtw_free_recvframe_queue(defrag_q);
return NULL;
}
/* check the fragment sequence (2nd ~n fragment frame) */
if (curfragnum != pnfhdr->attrib.frag_num) {
/* the fragment number must be increasing (after decache) */
/* release the defrag_q & prframe */
rtw_free_recvframe(prframe);
rtw_free_recvframe_queue(defrag_q);
return NULL;
}
curfragnum++;
/* copy the 2nd~n fragment frame's payload to the first fragment */
/* get the 2nd~last fragment frame's payload */
wlanhdr_offset = pnfhdr->attrib.hdrlen + pnfhdr->attrib.iv_len;
recvframe_pull(pnextrframe, wlanhdr_offset);
/* append to first fragment frame's tail (if privacy frame, pull the ICV) */
recvframe_pull_tail(prframe, pfhdr->attrib.icv_len);
/* _rtw_memcpy */
_rtw_memcpy(pfhdr->rx_tail, pnfhdr->rx_data, pnfhdr->len);
recvframe_put(prframe, pnfhdr->len);
pfhdr->attrib.icv_len = pnfhdr->attrib.icv_len;
plist = get_next(plist);
};
/* free the defrag_q queue and return the prframe */
rtw_free_recvframe_queue(defrag_q);
return prframe;
}
/* check if need to defrag, if needed queue the frame to defrag_q */
s32 recvframe_chk_defrag(_adapter *padapter, union recv_frame **pprecv_frame)
{
u8 ismfrag;
u8 fragnum;
u8 *psta_addr;
struct recv_frame_hdr *pfhdr;
struct sta_info *psta;
struct sta_priv *pstapriv;
_list *phead;
union recv_frame *prtnframe = NULL;
_queue *pdefrag_q = NULL;
union recv_frame *precv_frame = *pprecv_frame;
s32 ret = CORE_RX_CONTINUE;
pstapriv = &padapter->stapriv;
pfhdr = &precv_frame->u.hdr;
/* need to define struct of wlan header frame ctrl */
ismfrag = pfhdr->attrib.mfrag;
fragnum = pfhdr->attrib.frag_num;
psta_addr = pfhdr->attrib.ta;
psta = rtw_get_stainfo(pstapriv, psta_addr);
if (psta == NULL) {
u8 type = GetFrameType(pfhdr->rx_data);
if (type != WIFI_DATA_TYPE) {
psta = rtw_get_bcmc_stainfo(padapter);
if (psta)
pdefrag_q = &psta->sta_recvpriv.defrag_q;
} else
pdefrag_q = NULL;
} else
pdefrag_q = &psta->sta_recvpriv.defrag_q;
if ((ismfrag == 0) && (fragnum == 0)) {
ret = CORE_RX_CONTINUE;
} else {
/* CVE-2020-26145, group addressed frame cannot use fragmentation!! */
if (IS_MCAST(pfhdr->attrib.ra)) {
RTW_INFO("DROP group addressed fragment!\n");
ret = CORE_RX_DROP;
}
/* CVE-2020-24587 */
if ((psta) && (pdefrag_q))
precv_frame->u.hdr.keytrack = ATOMIC_READ(&psta->keytrack);
}
if (ismfrag == 1) {
/* 0~(n-1) fragment frame */
/* enqueue to defraf_g */
if (pdefrag_q != NULL) {
if (fragnum == 0) {
/* the first fragment */
if (_rtw_queue_empty(pdefrag_q) == _FALSE) {
/* free current defrag_q */
rtw_free_recvframe_queue(pdefrag_q);
}
}
/* Then enqueue the 0~(n-1) fragment into the defrag_q */
/* _rtw_spinlock(&pdefrag_q->lock); */
phead = get_list_head(pdefrag_q);
rtw_list_insert_tail(&pfhdr->list, phead);
/* _rtw_spinunlock(&pdefrag_q->lock); */
ret = CORE_RX_DEFRAG;
} else {
/* can't find this ta's defrag_queue, so free this recv_frame */
ret = CORE_RX_DROP;
}
}
if ((ismfrag == 0) && (fragnum != 0)) {
/* the last fragment frame */
/* enqueue the last fragment */
if (pdefrag_q != NULL) {
/* _rtw_spinlock(&pdefrag_q->lock); */
phead = get_list_head(pdefrag_q);
rtw_list_insert_tail(&pfhdr->list, phead);
/* _rtw_spinunlock(&pdefrag_q->lock); */
/* call recvframe_defrag to defrag */
*pprecv_frame = recvframe_defrag(padapter, pdefrag_q);
if (*pprecv_frame == NULL)
ret = CORE_RX_DROP;
else {
ret = CORE_RX_CONTINUE;
}
} else {
/* can't find this ta's defrag_queue, so free this recv_frame */
ret = CORE_RX_DROP;
}
}
return ret;
}
static int rtw_recv_indicatepkt_check(union recv_frame *rframe, u8 *ehdr_pos, u32 pkt_len)
{
_adapter *adapter = rframe->u.hdr.adapter;
struct recv_info *recvinfo = &adapter->recvinfo;
struct ethhdr *ehdr = (struct ethhdr *)ehdr_pos;
struct rx_pkt_attrib *pattrib = &rframe->u.hdr.attrib;
#ifdef DBG_IP_R_MONITOR
int i;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
#endif/*DBG_IP_R_MONITOR*/
enum eap_type eapol_type;
int ret = _FAIL;
#ifdef CONFIG_WAPI_SUPPORT
if (rtw_wapi_check_for_drop(adapter, rframe, ehdr_pos)) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" rtw_wapi_check_for_drop\n"
, FUNC_ADPT_ARG(adapter));
#endif
goto exit;
}
#endif
if (rframe->u.hdr.psta)
rtw_st_ctl_rx(rframe->u.hdr.psta, ehdr_pos);
if (ntohs(ehdr->h_proto) == 0x888e) {
eapol_type = parsing_eapol_packet(adapter, ehdr_pos + ETH_HLEN, rframe->u.hdr.psta, 0);
if ((eapol_type == EAPOL_1_4 || eapol_type == EAPOL_3_4) && pattrib->encrypt == 0) {
rframe->u.hdr.psta->resp_nonenc_eapol_key_starttime = rtw_get_current_time();
RTW_INFO("Receive unencrypted eapol key\n");
}
}
#ifdef DBG_ARP_DUMP
else if (ntohs(ehdr->h_proto) == ETH_P_ARP)
dump_arp_pkt(RTW_DBGDUMP, ehdr->h_dest, ehdr->h_source, ehdr_pos + ETH_HLEN, 0);
#endif
if (recvinfo->sink_udpport > 0)
rtw_sink_rtp_seq_dbg(adapter, ehdr_pos);
#ifdef DBG_UDP_PKT_LOSE_11AC
#define PAYLOAD_LEN_LOC_OF_IP_HDR 0x10 /*ethernet payload length location of ip header (DA + SA+eth_type+(version&hdr_len)) */
if (ntohs(ehdr->h_proto) == ETH_P_ARP) {
/* ARP Payload length will be 42bytes or 42+18(tailer)=60bytes*/
if (pkt_len != 42 && pkt_len != 60)
RTW_INFO("Error !!%s,ARP Payload length %u not correct\n" , __func__ , pkt_len);
} else if (ntohs(ehdr->h_proto) == ETH_P_IP) {
if (be16_to_cpu(*((u16 *)(ehdr_pos + PAYLOAD_LEN_LOC_OF_IP_HDR))) != (pkt_len) - ETH_HLEN) {
RTW_INFO("Error !!%s,Payload length not correct\n" , __func__);
RTW_INFO("%s, IP header describe Total length=%u\n" , __func__ , be16_to_cpu(*((u16 *)(ehdr_pos + PAYLOAD_LEN_LOC_OF_IP_HDR))));
RTW_INFO("%s, Pkt real length=%u\n" , __func__ , (pkt_len) - ETH_HLEN);
}
}
#endif
#ifdef DBG_IP_R_MONITOR
#define LEN_ARP_OP_HDR 7 /*ARP OERATION */
if (ntohs(ehdr->h_proto) == ETH_P_ARP) {
if(check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE){
if(ehdr_pos[ETHERNET_HEADER_SIZE+LEN_ARP_OP_HDR] == 2) {
RTW_INFO("%s,[DBG_ARP] Rx ARP RSP Packet;SeqNum = %d !\n",
__FUNCTION__, pattrib->seq_num);
dump_arp_pkt(RTW_DBGDUMP, ehdr->h_dest, ehdr->h_source, ehdr_pos + ETH_HLEN, 0);
}
}
}
#endif/*DBG_IP_R_MONITOR*/
#ifdef CONFIG_AUTO_AP_MODE
if (ntohs(ehdr->h_proto) == 0x8899)
rtw_auto_ap_rx_msg_dump(adapter, rframe, ehdr_pos);
#endif
ret = _SUCCESS;
#ifdef CONFIG_WAPI_SUPPORT
exit:
#endif
return ret;
}
#if defined(CONFIG_AP_MODE) || defined(CONFIG_RTW_MESH)
static void recv_free_fwd_resource(_adapter *adapter, struct xmit_frame *fwd_frame, _list *f_list)
{
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
if (fwd_frame)
core_tx_free_xmitframe(adapter, fwd_frame);
#if defined(CONFIG_RTW_WDS) || CONFIG_RTW_DATA_BMC_TO_UC
if (!rtw_is_list_empty(f_list)) {
struct xmit_frame *fframe;
_list *list;
list = get_next(f_list);
while (rtw_end_of_queue_search(f_list, list) == _FALSE) {
fframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&fframe->list);
core_tx_free_xmitframe(adapter, fframe);
}
}
#endif
}
static void recv_fwd_pkt_hdl(_adapter *adapter, struct sk_buff *pkt
, u8 act, struct xmit_frame *fwd_frame, _list *f_list)
{
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
struct sk_buff *fwd_pkt = pkt;
if (act & RTW_RX_MSDU_ACT_INDICATE) {
fwd_pkt = rtw_skb_copy(pkt);
if (!fwd_pkt) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s rtw_skb_copy fail\n", __func__);
#endif
recv_free_fwd_resource(adapter, fwd_frame, f_list);
goto exit;
}
}
#if defined(CONFIG_RTW_WDS) || CONFIG_RTW_DATA_BMC_TO_UC
if (!rtw_is_list_empty(f_list)) {
_list *list = get_next(f_list);
struct xmit_frame *fframe;
while (rtw_end_of_queue_search(f_list, list) == _FALSE) {
fframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&fframe->list);
if (!fwd_frame && rtw_is_list_empty(f_list)) /* the last fwd_pkt */
fframe->pkt = fwd_pkt;
else
fframe->pkt = rtw_skb_copy(fwd_pkt);
if (!fframe->pkt) {
core_tx_free_xmitframe(adapter, fframe);
continue;
}
core_tx_per_packet(adapter, fframe, &fframe->pkt, NULL);
}
}
#endif
if (fwd_frame) {
fwd_frame->pkt = fwd_pkt;
if (core_tx_per_packet(adapter, fwd_frame, &fwd_pkt, NULL) < 0) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s rtw_xmit_posthandle fail\n", __func__);
#endif
xmitpriv->tx_drop++;
}
}
exit:
return;
}
#endif /* defined(CONFIG_AP_MODE) || defined(CONFIG_RTW_MESH) */
/*
* From WFA suggestion: *
* If first subframe meets one of the following condition, *
* the whole received AMSDU should drop. *
* 1. subframe's DA is not the same as RA in From DS case. *
* 2. subframe's SA is not the same as TA in To DS case. *
* 3. subframe's DA is AA:AA:03:00:00:00 *
*/
static u8 validate_amsdu_content(_adapter *padapter, union recv_frame *prframe,
const u8 *da, const u8 *sa)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
u8 ret = _SUCCESS;
/* Use the recommendation method form Wi-Fi alliance to check subframe */
/* in protected network */
if (padapter->registrypriv.amsdu_mode == RTW_AMSDU_MODE_NON_SPP &&
padapter->securitypriv.dot11PrivacyAlgrthm != _NO_PRIVACY_) {
/* 1.check From DS */
if (pattrib->to_fr_ds == 1) {
if (_rtw_memcmp(da, pattrib->ra, ETH_ALEN) == _FALSE)
ret = _FAIL;
}
/* 2.check To DS */
if (pattrib->to_fr_ds == 2) {
if (_rtw_memcmp(sa, pattrib->ta, ETH_ALEN) == _FALSE)
ret = _FAIL;
}
/* 3.Check whether DA is AA:AA:03:00:00:00 */
if (_rtw_memcmp(da, rtw_rfc1042_header, ETH_ALEN) == _TRUE)
ret = _FAIL;
}
return ret;
}
int amsdu_to_msdu(_adapter *padapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *rattrib = &prframe->u.hdr.attrib;
int a_len, padding_len;
u16 nSubframe_Length;
u8 nr_subframes, i;
u8 *pdata;
struct sk_buff *sub_pkt, *subframes[MAX_SUBFRAME_COUNT];
const u8 *da, *sa;
int act;
#if defined(CONFIG_AP_MODE) || defined(CONFIG_RTW_MESH)
struct xmit_frame *fwd_frame;
_list f_list;
#endif
enum rtw_rx_llc_hdl llc_hdl;
u8 mctrl_len = 0;
int ret = _SUCCESS;
nr_subframes = 0;
recvframe_pull(prframe, rattrib->hdrlen);
if (rattrib->iv_len > 0)
recvframe_pull(prframe, rattrib->iv_len);
if (rattrib->encrypt)
recvframe_pull_tail(prframe, rattrib->icv_len);
a_len = prframe->u.hdr.len;
pdata = prframe->u.hdr.rx_data;
while (a_len > ETH_HLEN) {
/* Offset 12 denote 2 mac address */
nSubframe_Length = RTW_GET_BE16(pdata + 12);
if (a_len < (ETHERNET_HEADER_SIZE + nSubframe_Length)) {
RTW_INFO("nRemain_Length is %d and nSubframe_Length is : %d\n", a_len, nSubframe_Length);
break;
}
act = RTW_RX_MSDU_ACT_INDICATE;
#if defined(CONFIG_AP_MODE) || defined(CONFIG_RTW_MESH)
fwd_frame = NULL;
#endif
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
u8 *mda = pdata, *msa = pdata + ETH_ALEN;
struct rtw_ieee80211s_hdr *mctrl = (struct rtw_ieee80211s_hdr *)(pdata + ETH_HLEN);
int v_ret;
v_ret = rtw_mesh_rx_data_validate_mctrl(padapter, prframe
, mctrl, mda, msa, &mctrl_len, &da, &sa);
if (v_ret != _SUCCESS)
goto move_to_next;
if (validate_amsdu_content(padapter, prframe, da, sa) == _FAIL) {
RTW_INFO("%s check subframe content fail!\n", __func__);
break;
}
llc_hdl = rtw_recv_llc_parse(pdata + ETH_HLEN + mctrl_len, nSubframe_Length - mctrl_len);
act = rtw_mesh_rx_msdu_act_check(prframe
, mda, msa, da, sa, mctrl
, pdata + ETH_HLEN + mctrl_len, llc_hdl
, &fwd_frame, &f_list);
} else
#endif
{
da = pdata;
sa = pdata + ETH_ALEN;
if (validate_amsdu_content(padapter, prframe, da, sa) == _FAIL) {
RTW_INFO("%s check subframe content fail!\n", __func__);
break;
}
llc_hdl = rtw_recv_llc_parse(pdata + ETH_HLEN, nSubframe_Length);
#ifdef CONFIG_AP_MODE
if (MLME_IS_AP(padapter)) {
act = rtw_ap_rx_msdu_act_check(prframe, da, sa
, pdata + ETH_HLEN, llc_hdl, &fwd_frame, &f_list);
} else
#endif
if (MLME_IS_STA(padapter))
act = rtw_sta_rx_amsdu_act_check(prframe, da, sa);
}
if (!act)
goto move_to_next;
rtw_led_rx_control(padapter, da);
sub_pkt = rtw_os_alloc_msdu_pkt(prframe, da, sa
, pdata + ETH_HLEN + mctrl_len, nSubframe_Length - mctrl_len, llc_hdl);
if (sub_pkt == NULL) {
if (act & RTW_RX_MSDU_ACT_INDICATE) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME %s rtw_os_alloc_msdu_pkt fail\n", __func__);
#endif
}
#if defined(CONFIG_AP_MODE) || defined(CONFIG_RTW_MESH)
if (act & RTW_RX_MSDU_ACT_FORWARD) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s rtw_os_alloc_msdu_pkt fail\n", __func__);
#endif
recv_free_fwd_resource(padapter, fwd_frame, &f_list);
}
#endif
break;
}
#if defined(CONFIG_AP_MODE) || defined(CONFIG_RTW_MESH)
if (act & RTW_RX_MSDU_ACT_FORWARD) {
recv_fwd_pkt_hdl(padapter, sub_pkt, act, fwd_frame, &f_list);
if (!(act & RTW_RX_MSDU_ACT_INDICATE))
goto move_to_next;
}
#endif
if (rtw_recv_indicatepkt_check(prframe, rtw_skb_data(sub_pkt), rtw_skb_len(sub_pkt)) == _SUCCESS)
subframes[nr_subframes++] = sub_pkt;
else
rtw_skb_free(sub_pkt);
#if defined(CONFIG_AP_MODE) || defined(CONFIG_RTW_MESH)
move_to_next:
#endif
/* move the data point to data content */
pdata += ETH_HLEN;
a_len -= ETH_HLEN;
if (nr_subframes >= MAX_SUBFRAME_COUNT) {
RTW_WARN("ParseSubframe(): Too many Subframes! Packets dropped!\n");
break;
}
pdata += nSubframe_Length;
a_len -= nSubframe_Length;
if (a_len != 0) {
padding_len = 4 - ((nSubframe_Length + ETH_HLEN) & (4 - 1));
if (padding_len == 4)
padding_len = 0;
if (a_len < padding_len) {
RTW_INFO("ParseSubframe(): a_len < padding_len !\n");
break;
}
pdata += padding_len;
a_len -= padding_len;
}
}
for (i = 0; i < nr_subframes; i++) {
sub_pkt = subframes[i];
/* Indicat the packets to upper layer */
if (sub_pkt)
rtw_os_recv_indicate_pkt(padapter, sub_pkt, prframe);
}
prframe->u.hdr.len = 0;
rtw_free_recvframe(prframe);/* free this recv_frame */
return ret;
}
static int recv_process_mpdu(_adapter *padapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
int ret;
if (pattrib->amsdu) {
ret = amsdu_to_msdu(padapter, prframe);
if (ret != _SUCCESS) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" amsdu_to_msdu fail\n"
, FUNC_ADPT_ARG(padapter));
#endif
rtw_free_recvframe(prframe);
goto exit;
}
} else {
int act = RTW_RX_MSDU_ACT_INDICATE;
#ifdef CONFIG_RTW_MESH /* TODO: move AP mode forward & b2u logic here */
struct xmit_frame *fwd_frame = NULL;
_list f_list;
if (MLME_IS_MESH(padapter) && pattrib->mesh_ctrl_present) {
act = rtw_mesh_rx_msdu_act_check(prframe
, pattrib->mda, pattrib->msa
, pattrib->dst, pattrib->src
, (struct rtw_ieee80211s_hdr *)(get_recvframe_data(prframe) + pattrib->hdrlen + pattrib->iv_len)
, &fwd_frame, &f_list);
}
#endif
#ifdef CONFIG_RTW_MESH
if (!act) {
rtw_free_recvframe(prframe);
ret = _FAIL;
goto exit;
}
#endif
rtw_led_rx_control(padapter, pattrib->dst);
ret = wlanhdr_to_ethhdr(prframe, 0);
if (ret != _SUCCESS) {
if (act & RTW_RX_MSDU_ACT_INDICATE) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" wlanhdr_to_ethhdr: drop pkt\n"
, FUNC_ADPT_ARG(padapter));
#endif
}
#ifdef CONFIG_RTW_MESH
if (act & RTW_RX_MSDU_ACT_FORWARD) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s wlanhdr_to_ethhdr fail\n", __func__);
#endif
recv_free_fwd_resource(padapter, fwd_frame, &f_list);
}
#endif
rtw_free_recvframe(prframe);
goto exit;
}
#ifdef CONFIG_RTW_MESH
if (act & RTW_RX_MSDU_ACT_FORWARD) {
recv_fwd_pkt_hdl(padapter, prframe->u.hdr.pkt, act, fwd_frame, &f_list);
if (!(act & RTW_RX_MSDU_ACT_INDICATE)) {
prframe->u.hdr.pkt = NULL;
rtw_free_recvframe(prframe);
goto exit;
}
}
#endif
if (!RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
ret = rtw_recv_indicatepkt_check(prframe
, get_recvframe_data(prframe), get_recvframe_len(prframe));
if (ret != _SUCCESS) {
rtw_free_recvframe(prframe);
goto exit;
}
/* indicate this recv_frame */
ret = rtw_recv_indicatepkt(padapter, prframe);
if (ret != _SUCCESS) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" rtw_recv_indicatepkt fail!\n"
, FUNC_ADPT_ARG(padapter));
#endif
goto exit;
}
} else {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" DS:%u SR:%u\n"
, FUNC_ADPT_ARG(padapter)
, dev_is_drv_stopped(adapter_to_dvobj(padapter))
, dev_is_surprise_removed(adapter_to_dvobj(padapter)));
#endif
ret = _SUCCESS; /* don't count as packet drop */
rtw_free_recvframe(prframe);
}
}
exit:
return ret;
}
#if defined(CONFIG_80211N_HT) && defined(CONFIG_RECV_REORDERING_CTRL)
static int check_indicate_seq(struct recv_reorder_ctrl *preorder_ctrl, u16 seq_num)
{
_adapter *padapter = preorder_ctrl->padapter;
struct recv_info *precvinfo = &padapter->recvinfo;
u8 wsize = preorder_ctrl->wsize_b;
u16 wend;
/* Rx Reorder initialize condition. */
if (preorder_ctrl->indicate_seq == 0xFFFF) {
preorder_ctrl->indicate_seq = seq_num;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_INIT indicate_seq:%d, seq_num:%d\n"
, FUNC_ADPT_ARG(padapter), preorder_ctrl->tid, preorder_ctrl->indicate_seq, seq_num);
#endif
}
wend = (preorder_ctrl->indicate_seq + wsize - 1) & 0xFFF; /* % 4096; */
/* Drop out the packet which SeqNum is smaller than WinStart */
if (SN_LESS(seq_num, preorder_ctrl->indicate_seq)) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO(FUNC_ADPT_FMT" tid:%u indicate_seq:%d > seq_num:%d\n"
, FUNC_ADPT_ARG(padapter), preorder_ctrl->tid, preorder_ctrl->indicate_seq, seq_num);
#endif
return _FALSE;
}
/*
* Sliding window manipulation. Conditions includes:
* 1. Incoming SeqNum is equal to WinStart =>Window shift 1
* 2. Incoming SeqNum is larger than the WinEnd => Window shift N
*/
if (SN_EQUAL(seq_num, preorder_ctrl->indicate_seq)) {
preorder_ctrl->indicate_seq = (preorder_ctrl->indicate_seq + 1) & 0xFFF;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_EQUAL indicate_seq:%d, seq_num:%d\n"
, FUNC_ADPT_ARG(padapter), preorder_ctrl->tid, preorder_ctrl->indicate_seq, seq_num);
#endif
} else if (SN_LESS(wend, seq_num)) {
/* boundary situation, when seq_num cross 0xFFF */
if (seq_num >= (wsize - 1))
preorder_ctrl->indicate_seq = seq_num + 1 - wsize;
else
preorder_ctrl->indicate_seq = 0xFFF - (wsize - (seq_num + 1)) + 1;
precvinfo->dbg_rx_ampdu_window_shift_cnt++;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_LESS(wend, seq_num) indicate_seq:%d, seq_num:%d\n"
, FUNC_ADPT_ARG(padapter), preorder_ctrl->tid, preorder_ctrl->indicate_seq, seq_num);
#endif
}
return _TRUE;
}
static int enqueue_reorder_recvframe(struct recv_reorder_ctrl *preorder_ctrl, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
_queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
_list *phead, *plist;
union recv_frame *pnextrframe;
struct rx_pkt_attrib *pnextattrib;
/* DbgPrint("+enqueue_reorder_recvframe()\n"); */
/* _rtw_spinlock_irq(&ppending_recvframe_queue->lock, &sp_flags); */
phead = get_list_head(ppending_recvframe_queue);
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
pnextrframe = LIST_CONTAINOR(plist, union recv_frame, u);
pnextattrib = &pnextrframe->u.hdr.attrib;
if (SN_LESS(pnextattrib->seq_num, pattrib->seq_num))
plist = get_next(plist);
else if (SN_EQUAL(pnextattrib->seq_num, pattrib->seq_num)) {
/* Duplicate entry is found!! Do not insert current entry. */
/* _rtw_spinunlock_irq(&ppending_recvframe_queue->lock, &sp_flags); */
return _FALSE;
} else
break;
/* DbgPrint("enqueue_reorder_recvframe():while\n"); */
}
/* _rtw_spinlock_irq(&ppending_recvframe_queue->lock, &sp_flags); */
rtw_list_delete(&(prframe->u.hdr.list));
rtw_list_insert_tail(&(prframe->u.hdr.list), plist);
/* _rtw_spinunlock_irq(&ppending_recvframe_queue->lock, &sp_flags); */
return _TRUE;
}
static void recv_indicatepkts_pkt_loss_cnt(_adapter *padapter, u64 prev_seq, u64 current_seq)
{
struct recv_info *precvinfo = &padapter->recvinfo;
if (current_seq < prev_seq) {
precvinfo->dbg_rx_ampdu_loss_count += (4096 + current_seq - prev_seq);
precvinfo->rx_drop += (4096 + current_seq - prev_seq);
} else {
precvinfo->dbg_rx_ampdu_loss_count += (current_seq - prev_seq);
precvinfo->rx_drop += (current_seq - prev_seq);
}
}
static int recv_indicatepkts_in_order(_adapter *padapter, struct recv_reorder_ctrl *preorder_ctrl, int bforced)
{
_list *phead, *plist;
union recv_frame *prframe;
struct rx_pkt_attrib *pattrib;
/* u8 index = 0; */
int bPktInBuf = _FALSE;
struct recv_info *precvinfo = &padapter->recvinfo;
_queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
DBG_COUNTER(padapter->rx_logs.core_rx_post_indicate_in_oder);
/* DbgPrint("+recv_indicatepkts_in_order\n"); */
/* _rtw_spinlock_irq(&ppending_recvframe_queue->lock, &sp_flags); */
phead = get_list_head(ppending_recvframe_queue);
plist = get_next(phead);
#if 0
/* Check if there is any other indication thread running. */
if (pTS->RxIndicateState == RXTS_INDICATE_PROCESSING)
return;
#endif
/* Handling some condition for forced indicate case. */
if (bforced == _TRUE) {
precvinfo->dbg_rx_ampdu_forced_indicate_count++;
if (rtw_is_list_empty(phead)) {
/* _rtw_spinunlock_irq(&ppending_recvframe_queue->lock, &sp_flags); */
return _TRUE;
}
prframe = LIST_CONTAINOR(plist, union recv_frame, u);
pattrib = &prframe->u.hdr.attrib;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u FORCE indicate_seq:%d, seq_num:%d\n"
, FUNC_ADPT_ARG(padapter), preorder_ctrl->tid, preorder_ctrl->indicate_seq, pattrib->seq_num);
#endif
recv_indicatepkts_pkt_loss_cnt(padapter, preorder_ctrl->indicate_seq, pattrib->seq_num);
preorder_ctrl->indicate_seq = pattrib->seq_num;
}
/* Prepare indication list and indication. */
/* Check if there is any packet need indicate. */
while (!rtw_is_list_empty(phead)) {
prframe = LIST_CONTAINOR(plist, union recv_frame, u);
pattrib = &prframe->u.hdr.attrib;
if (!SN_LESS(preorder_ctrl->indicate_seq, pattrib->seq_num)) {
#if 0
/* This protect buffer from overflow. */
if (index >= REORDER_WIN_SIZE) {
RT_ASSERT(FALSE, ("IndicateRxReorderList(): Buffer overflow!!\n"));
bPktInBuf = TRUE;
break;
}
#endif
plist = get_next(plist);
rtw_list_delete(&(prframe->u.hdr.list));
if (SN_EQUAL(preorder_ctrl->indicate_seq, pattrib->seq_num)) {
preorder_ctrl->indicate_seq = (preorder_ctrl->indicate_seq + 1) & 0xFFF;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_EQUAL indicate_seq:%d, seq_num:%d\n"
, FUNC_ADPT_ARG(padapter), preorder_ctrl->tid, preorder_ctrl->indicate_seq, pattrib->seq_num);
#endif
}
#if 0
index++;
if (index == 1) {
/* Cancel previous pending timer. */
/* PlatformCancelTimer(adapter, &pTS->RxPktPendingTimer); */
if (bforced != _TRUE) {
/* RTW_INFO("_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);\n"); */
_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);
}
}
#endif
/* Set this as a lock to make sure that only one thread is indicating packet. */
/* pTS->RxIndicateState = RXTS_INDICATE_PROCESSING; */
/* Indicate packets */
/* RT_ASSERT((index<=REORDER_WIN_SIZE), ("RxReorderIndicatePacket(): Rx Reorder buffer full!!\n")); */
/* indicate this recv_frame */
/* DbgPrint("recv_indicatepkts_in_order, indicate_seq=%d, seq_num=%d\n", precvpriv->indicate_seq, pattrib->seq_num); */
if (recv_process_mpdu(padapter, prframe) != _SUCCESS)
precvinfo->dbg_rx_drop_count++;
/* Update local variables. */
bPktInBuf = _FALSE;
} else {
bPktInBuf = _TRUE;
break;
}
/* DbgPrint("recv_indicatepkts_in_order():while\n"); */
}
/* _rtw_spinunlock_irq(&ppending_recvframe_queue->lock, sp_flags); */
#if 0
/* Release the indication lock and set to new indication step. */
if (bPktInBuf) {
/* Set new pending timer. */
/* pTS->RxIndicateState = RXTS_INDICATE_REORDER; */
/* PlatformSetTimer(adapter, &pTS->RxPktPendingTimer, pHTInfo->RxReorderPendingTime); */
_set_timer(&preorder_ctrl->reordering_ctrl_timer, REORDER_WAIT_TIME);
} else {
/* pTS->RxIndicateState = RXTS_INDICATE_IDLE; */
}
#endif
/* _rtw_spinunlock_irq(&ppending_recvframe_queue->lock, sp_flags); */
/* return _TRUE; */
return bPktInBuf;
}
static int recv_indicatepkt_reorder(_adapter *padapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct recv_reorder_ctrl *preorder_ctrl = prframe->u.hdr.preorder_ctrl;
_queue *ppending_recvframe_queue = preorder_ctrl ? &preorder_ctrl->pending_recvframe_queue : NULL;
struct recv_info *precvinfo = &padapter->recvinfo;
if (!pattrib->qos || !preorder_ctrl || preorder_ctrl->enable == _FALSE)
goto _success_exit;
DBG_COUNTER(padapter->rx_logs.core_rx_post_indicate_reoder);
_rtw_spinlock_bh(&ppending_recvframe_queue->lock);
if(rtw_test_and_clear_bit(RTW_RECV_ACK_OR_TIMEOUT, &preorder_ctrl->rec_abba_rsp_ack))
preorder_ctrl->indicate_seq = 0xFFFF;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ %s:preorder_ctrl->rec_abba_rsp_ack = %u,indicate_seq = %d\n"
, __func__
, preorder_ctrl->rec_abba_rsp_ack
, preorder_ctrl->indicate_seq);
#endif
/* s2. check if winstart_b(indicate_seq) needs to been updated */
if (!check_indicate_seq(preorder_ctrl, pattrib->seq_num)) {
precvinfo->dbg_rx_ampdu_drop_count++;
/* pHTInfo->RxReorderDropCounter++; */
/* ReturnRFDList(adapter, pRfd); */
/* _rtw_spinunlock_irq(&ppending_recvframe_queue->lock, sp_flags); */
/* return _FAIL; */
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" check_indicate_seq fail\n"
, FUNC_ADPT_ARG(padapter));
#endif
#if 0
rtw_recv_indicatepkt(padapter, prframe);
_rtw_spinunlock_bh(&ppending_recvframe_queue->lock);
goto _success_exit;
#else
goto _err_exit;
#endif
}
/* s3. Insert all packet into Reorder Queue to maintain its ordering. */
if (!enqueue_reorder_recvframe(preorder_ctrl, prframe)) {
/* DbgPrint("recv_indicatepkt_reorder, enqueue_reorder_recvframe fail!\n"); */
/* _rtw_spinunlock_irq(&ppending_recvframe_queue->lock, sp_flags); */
/* return _FAIL; */
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" enqueue_reorder_recvframe fail\n"
, FUNC_ADPT_ARG(padapter));
#endif
goto _err_exit;
}
/* s4. */
/* Indication process. */
/* After Packet dropping and Sliding Window shifting as above, we can now just indicate the packets */
/* with the SeqNum smaller than latest WinStart and buffer other packets. */
/* */
/* For Rx Reorder condition: */
/* 1. All packets with SeqNum smaller than WinStart => Indicate */
/* 2. All packets with SeqNum larger than or equal to WinStart => Buffer it. */
/* */
/* recv_indicatepkts_in_order(padapter, preorder_ctrl, _TRUE); */
if (recv_indicatepkts_in_order(padapter, preorder_ctrl, _FALSE) == _TRUE) {
if (!preorder_ctrl->bReorderWaiting) {
preorder_ctrl->bReorderWaiting = _TRUE;
_set_timer(&preorder_ctrl->reordering_ctrl_timer, REORDER_WAIT_TIME);
}
_rtw_spinunlock_bh(&ppending_recvframe_queue->lock);
} else {
preorder_ctrl->bReorderWaiting = _FALSE;
_rtw_spinunlock_bh(&ppending_recvframe_queue->lock);
_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);
}
return RTW_RX_HANDLED;
_success_exit:
return _SUCCESS;
_err_exit:
_rtw_spinunlock_bh(&ppending_recvframe_queue->lock);
return _FAIL;
}
void rtw_reordering_ctrl_timeout_handler(void *pcontext)
{
struct recv_reorder_ctrl *preorder_ctrl = (struct recv_reorder_ctrl *)pcontext;
_adapter *padapter = NULL;
_queue *ppending_recvframe_queue = NULL;
if (preorder_ctrl == NULL)
return;
padapter = preorder_ctrl->padapter;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
return;
ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
/* RTW_INFO("+rtw_reordering_ctrl_timeout_handler()=>\n"); */
_rtw_spinlock_bh(&ppending_recvframe_queue->lock);
preorder_ctrl->bReorderWaiting = _FALSE;
if (recv_indicatepkts_in_order(padapter, preorder_ctrl, _TRUE) == _TRUE)
_set_timer(&preorder_ctrl->reordering_ctrl_timer, REORDER_WAIT_TIME);
_rtw_spinunlock_bh(&ppending_recvframe_queue->lock);
}
#endif /* defined(CONFIG_80211N_HT) && defined(CONFIG_RECV_REORDERING_CTRL) */
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
int recv_frame_monitor(_adapter *padapter, union recv_frame *rframe, struct rtw_recv_pkt *rx_req)
{
int ret = _SUCCESS;
#ifdef CONFIG_WIFI_MONITOR
struct net_device *ndev = padapter->pnetdev;
struct sk_buff *pskb = NULL;
if (rframe == NULL)
goto exit;
/* read skb information from recv frame */
pskb = rframe->u.hdr.pkt;
pskb->len = rframe->u.hdr.len;
pskb->data = rframe->u.hdr.rx_data;
skb_set_tail_pointer(pskb, rframe->u.hdr.len);
if (ndev->type == ARPHRD_IEEE80211_RADIOTAP) {
/* fill radiotap header */
if (rtw_fill_radiotap_hdr(padapter, &rframe->u.hdr.attrib, rx_req, (u8 *)pskb) == _FAIL) {
ret = _FAIL;
goto exit;
}
}
/* write skb information to recv frame */
skb_reset_mac_header(pskb);
rframe->u.hdr.len = pskb->len;
rframe->u.hdr.rx_data = pskb->data;
rframe->u.hdr.rx_head = pskb->head;
rframe->u.hdr.rx_tail = skb_tail_pointer(pskb);
rframe->u.hdr.rx_end = skb_end_pointer(pskb);
if (!RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
/* indicate this recv_frame */
ret = rtw_recv_monitor(padapter, rframe);
} else
ret = _FAIL;
exit:
#endif /* CONFIG_WIFI_MONITOR */
return ret;
}
#endif
#if 0
static void recv_set_iseq_before_mpdu_process(union recv_frame *rframe, u16 seq_num, const char *caller)
{
#if defined(CONFIG_80211N_HT) && defined(CONFIG_RECV_REORDERING_CTRL)
struct recv_reorder_ctrl *reorder_ctrl = rframe->u.hdr.preorder_ctrl;
if (reorder_ctrl) {
reorder_ctrl->indicate_seq = seq_num;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ %s("ADPT_FMT")-B tid:%u indicate_seq:%d, seq_num:%d\n"
, caller, ADPT_ARG(reorder_ctrl->padapter)
, reorder_ctrl->tid, reorder_ctrl->indicate_seq, seq_num);
#endif
}
#endif
}
static void recv_set_iseq_after_mpdu_process(union recv_frame *rframe, u16 seq_num, const char *caller)
{
#if defined(CONFIG_80211N_HT) && defined(CONFIG_RECV_REORDERING_CTRL)
struct recv_reorder_ctrl *reorder_ctrl = rframe->u.hdr.preorder_ctrl;
if (reorder_ctrl) {
reorder_ctrl->indicate_seq = (reorder_ctrl->indicate_seq + 1) % 4096;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ %s("ADPT_FMT")-A tid:%u indicate_seq:%d, seq_num:%d\n"
, caller, ADPT_ARG(reorder_ctrl->padapter)
, reorder_ctrl->tid, reorder_ctrl->indicate_seq, seq_num);
#endif
}
#endif
}
#ifdef CONFIG_MP_INCLUDED
int validate_mp_recv_frame(_adapter *adapter, union recv_frame *precv_frame)
{
int ret = _SUCCESS;
u8 *ptr = precv_frame->u.hdr.rx_data;
u8 type, subtype;
struct mp_priv *pmppriv = &adapter->mppriv;
struct mp_tx *pmptx;
unsigned char *sa , *da, *bs;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
u32 i = 0;
u8 rtk_prefix[]={0x52, 0x65, 0x61, 0x6C, 0x4C, 0x6F, 0x76, 0x65, 0x54, 0x65, 0x6B};
u8 *prx_data;
pmptx = &pmppriv->tx;
if (pmppriv->mplink_brx == _FALSE) {
u8 bDumpRxPkt = 0;
type = GetFrameType(ptr);
subtype = get_frame_sub_type(ptr); /* bit(7)~bit(2) */
RTW_INFO("hdr len = %d iv_len=%d \n", pattrib->hdrlen , pattrib->iv_len);
prx_data = ptr + pattrib->hdrlen + pattrib->iv_len;
for (i = 0; i < precv_frame->u.hdr.len; i++) {
if (precv_frame->u.hdr.len < (11 + i))
break;
if (_rtw_memcmp(prx_data + i, (void *)&rtk_prefix, 11) == _FALSE) {
bDumpRxPkt = 0;
RTW_DBG("prx_data = %02X != rtk_prefix[%d] = %02X \n", *(prx_data + i), i , rtk_prefix[i]);
} else {
bDumpRxPkt = 1;
RTW_DBG("prx_data = %02X = rtk_prefix[%d] = %02X \n", *(prx_data + i), i , rtk_prefix[i]);
break;
}
}
if (bDumpRxPkt == 1) { /* dump all rx packets */
int i;
RTW_INFO("############ type:0x%02x subtype:0x%02x #################\n", type, subtype);
for (i = 0; i < precv_frame->u.hdr.len; i = i + 8)
RTW_INFO("%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X:\n", *(ptr + i),
*(ptr + i + 1), *(ptr + i + 2) , *(ptr + i + 3) , *(ptr + i + 4), *(ptr + i + 5), *(ptr + i + 6), *(ptr + i + 7));
RTW_INFO("#############################\n");
_rtw_memset(pmppriv->mplink_buf, '\0' , sizeof(pmppriv->mplink_buf));
_rtw_memcpy(pmppriv->mplink_buf, ptr, precv_frame->u.hdr.len);
pmppriv->mplink_rx_len = precv_frame->u.hdr.len;
pmppriv->mplink_brx =_TRUE;
}
}
if (pmppriv->bloopback) {
if (_rtw_memcmp(ptr + 24, pmptx->buf + 24, precv_frame->u.hdr.len - 24) == _FALSE) {
RTW_INFO("Compare payload content Fail !!!\n");
ret = _FAIL;
}
}
if (pmppriv->bSetRxBssid == _TRUE) {
sa = get_addr2_ptr(ptr);
da = GetAddr1Ptr(ptr);
bs = GetAddr3Ptr(ptr);
type = GetFrameType(ptr);
subtype = get_frame_sub_type(ptr); /* bit(7)~bit(2) */
if (_rtw_memcmp(bs, adapter->mppriv.network_macaddr, ETH_ALEN) == _FALSE)
ret = _FAIL;
RTW_DBG("############ type:0x%02x subtype:0x%02x #################\n", type, subtype);
RTW_DBG("A2 sa %02X:%02X:%02X:%02X:%02X:%02X \n", *(sa) , *(sa + 1), *(sa+ 2), *(sa + 3), *(sa + 4), *(sa + 5));
RTW_DBG("A1 da %02X:%02X:%02X:%02X:%02X:%02X \n", *(da) , *(da + 1), *(da+ 2), *(da + 3), *(da + 4), *(da + 5));
RTW_DBG("A3 bs %02X:%02X:%02X:%02X:%02X:%02X \n --------------------------\n", *(bs) , *(bs + 1), *(bs+ 2), *(bs + 3), *(bs + 4), *(bs + 5));
}
if (!adapter->mppriv.bmac_filter)
return ret;
if (_rtw_memcmp(get_addr2_ptr(ptr), adapter->mppriv.mac_filter, ETH_ALEN) == _FALSE)
ret = _FAIL;
return ret;
}
static sint MPwlanhdr_to_ethhdr(union recv_frame *precvframe)
{
sint rmv_len;
u16 eth_type, len;
u8 bsnaphdr;
u8 *psnap_type;
u8 mcastheadermac[] = {0x01, 0x00, 0x5e};
struct ieee80211_snap_hdr *psnap;
sint ret = _SUCCESS;
_adapter *adapter = precvframe->u.hdr.adapter;
u8 *ptr = get_recvframe_data(precvframe) ; /* point to frame_ctrl field */
struct rx_pkt_attrib *pattrib = &precvframe->u.hdr.attrib;
if (pattrib->encrypt)
recvframe_pull_tail(precvframe, pattrib->icv_len);
psnap = (struct ieee80211_snap_hdr *)(ptr + pattrib->hdrlen + pattrib->iv_len);
psnap_type = ptr + pattrib->hdrlen + pattrib->iv_len + SNAP_SIZE;
/* convert hdr + possible LLC headers into Ethernet header */
/* eth_type = (psnap_type[0] << 8) | psnap_type[1]; */
if ((_rtw_memcmp(psnap, rtw_rfc1042_header, SNAP_SIZE) &&
(_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_IPX, 2) == _FALSE) &&
(_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_APPLETALK_AARP, 2) == _FALSE)) ||
/* eth_type != ETH_P_AARP && eth_type != ETH_P_IPX) || */
_rtw_memcmp(psnap, rtw_bridge_tunnel_header, SNAP_SIZE)) {
/* remove RFC1042 or Bridge-Tunnel encapsulation and replace EtherType */
bsnaphdr = _TRUE;
} else {
/* Leave Ethernet header part of hdr and full payload */
bsnaphdr = _FALSE;
}
rmv_len = pattrib->hdrlen + pattrib->iv_len + (bsnaphdr ? SNAP_SIZE : 0);
len = precvframe->u.hdr.len - rmv_len;
_rtw_memcpy(ð_type, ptr + rmv_len, 2);
eth_type = ntohs((unsigned short)eth_type); /* pattrib->ether_type */
pattrib->eth_type = eth_type;
{
ptr = recvframe_pull(precvframe, (rmv_len - sizeof(struct ethhdr) + (bsnaphdr ? 2 : 0)));
}
_rtw_memcpy(ptr, pattrib->dst, ETH_ALEN);
_rtw_memcpy(ptr + ETH_ALEN, pattrib->src, ETH_ALEN);
if (!bsnaphdr) {
len = htons(len);
_rtw_memcpy(ptr + 12, &len, 2);
}
len = htons(pattrib->seq_num);
/* RTW_INFO("wlan seq = %d ,seq_num =%x\n",len,pattrib->seq_num); */
_rtw_memcpy(ptr + 12, &len, 2);
if (adapter->mppriv.bRTWSmbCfg == _TRUE) {
/* if(_rtw_memcmp(mcastheadermac, pattrib->dst, 3) == _TRUE) */ /* SimpleConfig Dest. */
/* _rtw_memcpy(ptr+ETH_ALEN, pattrib->bssid, ETH_ALEN); */
if (_rtw_memcmp(mcastheadermac, pattrib->bssid, 3) == _TRUE) /* SimpleConfig Dest. */
_rtw_memcpy(ptr, pattrib->bssid, ETH_ALEN);
}
return ret;
}
int mp_recv_frame(_adapter *padapter, union recv_frame *rframe)
{
int ret = _SUCCESS;
struct rx_pkt_attrib *pattrib = &rframe->u.hdr.attrib;
#ifdef CONFIG_MP_INCLUDED
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mp_priv *pmppriv = &padapter->mppriv;
#endif /* CONFIG_MP_INCLUDED */
u8 type;
u8 *ptr = rframe->u.hdr.rx_data;
u8 *psa, *pda, *pbssid;
struct sta_info *psta = NULL;
DBG_COUNTER(padapter->rx_logs.core_rx_pre);
if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) { /* &&(padapter->mppriv.check_mp_pkt == 0)) */
if (pattrib->crc_err == 1)
padapter->mppriv.rx_crcerrpktcount++;
else {
if (_SUCCESS == validate_mp_recv_frame(padapter, rframe))
padapter->mppriv.rx_pktcount++;
else
padapter->mppriv.rx_pktcount_filter_out++;
}
if (pmppriv->rx_bindicatePkt == _FALSE) {
ret = _FAIL;
rtw_free_recvframe(rframe);/* free this recv_frame */
goto exit;
} else {
type = GetFrameType(ptr);
pattrib->to_fr_ds = get_tofr_ds(ptr);
pattrib->frag_num = GetFragNum(ptr);
pattrib->seq_num = GetSequence(ptr);
pattrib->pw_save = GetPwrMgt(ptr);
pattrib->mfrag = GetMFrag(ptr);
pattrib->mdata = GetMData(ptr);
pattrib->privacy = GetPrivacy(ptr);
pattrib->order = GetOrder(ptr);
if (type == WIFI_DATA_TYPE) {
pda = get_da(ptr);
psa = get_sa(ptr);
pbssid = get_hdr_bssid(ptr);
_rtw_memcpy(pattrib->dst, pda, ETH_ALEN);
_rtw_memcpy(pattrib->src, psa, ETH_ALEN);
_rtw_memcpy(pattrib->bssid, pbssid, ETH_ALEN);
switch (pattrib->to_fr_ds) {
case 0:
_rtw_memcpy(pattrib->ra, pda, ETH_ALEN);
_rtw_memcpy(pattrib->ta, psa, ETH_ALEN);
ret = sta2sta_data_frame(padapter, rframe, &psta);
break;
case 1:
_rtw_memcpy(pattrib->ra, pda, ETH_ALEN);
_rtw_memcpy(pattrib->ta, pbssid, ETH_ALEN);
ret = ap2sta_data_frame(padapter, rframe, &psta);
break;
case 2:
_rtw_memcpy(pattrib->ra, pbssid, ETH_ALEN);
_rtw_memcpy(pattrib->ta, psa, ETH_ALEN);
ret = sta2ap_data_frame(padapter, rframe, &psta);
break;
case 3:
_rtw_memcpy(pattrib->ra, GetAddr1Ptr(ptr), ETH_ALEN);
_rtw_memcpy(pattrib->ta, get_addr2_ptr(ptr), ETH_ALEN);
ret = _FAIL;
break;
default:
ret = _FAIL;
break;
}
if (ret != _SUCCESS) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" 2_data_frame fail: drop pkt\n"
, FUNC_ADPT_ARG(padapter));
#endif
ret = _FAIL;
goto exit;
}
ret = MPwlanhdr_to_ethhdr(rframe);
if (ret != _SUCCESS) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" wlanhdr_to_ethhdr: drop pkt\n"
, FUNC_ADPT_ARG(padapter));
#endif
ret = _FAIL;
goto exit;
}
if (!RTW_CANNOT_RUN(adapter_to_dvobj(padapter))) {
/* indicate this recv_frame */
ret = rtw_recv_indicatepkt(padapter, rframe);
if (ret != _SUCCESS) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" rtw_recv_indicatepkt fail!\n"
, FUNC_ADPT_ARG(padapter));
#endif
ret = _FAIL;
goto exit;
}
} else {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
, FUNC_ADPT_ARG(padapter)
, dev_is_drv_stopped(adapter_to_dvobj(padapter)) ? "True" : "False"
, dev_is_surprise_removed(adapter_to_dvobj(padapter)) ? "True" : "False");
#endif
ret = _FAIL;
goto exit;
}
}
}
}
exit:
rtw_free_recvframe(rframee);/* free this recv_frame */
ret = _FAIL;
return ret;
}
#endif
int recv_func_prehandle(_adapter *padapter, union recv_frame *rframe)
{
int ret = _SUCCESS;
#ifdef DBG_RX_COUNTER_DUMP
struct rx_pkt_attrib *pattrib = &rframe->u.hdr.attrib;
#endif
_queue *pfree_recv_queue = &padapter->recvpriv.free_recv_queue;
#ifdef DBG_RX_COUNTER_DUMP
if (padapter->dump_rx_cnt_mode & DUMP_DRV_RX_COUNTER) {
if (pattrib->crc_err == 1)
padapter->drv_rx_cnt_crcerror++;
else
padapter->drv_rx_cnt_ok++;
}
#endif
#ifdef CONFIG_MP_INCLUDED
if (padapter->registrypriv.mp_mode == 1 || padapter->mppriv.bRTWSmbCfg == _TRUE) {
mp_recv_frame(padapter, rframe);
ret = _FAIL;
goto exit;
} else
#endif
{
/* check the frame crtl field and decache */
ret = validate_recv_frame(padapter, rframe);
if (ret != _SUCCESS) {
rtw_free_recvframe(rframee);/* free this recv_frame */
goto exit;
}
}
exit:
return ret;
}
/*#define DBG_RX_BMC_FRAME*/
int recv_func_posthandle(_adapter *padapter, union recv_frame *prframe)
{
int ret = _SUCCESS;
union recv_frame *orig_prframe = prframe;
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct recv_info *precvinfo = &padapter->recvinfo;
_queue *pfree_recv_queue = &padapter->recvpriv.free_recv_queue;
#ifdef CONFIG_TDLS
u8 *psnap_type, *pcategory;
#endif /* CONFIG_TDLS */
DBG_COUNTER(padapter->rx_logs.core_rx_post);
prframe = decryptor(padapter, prframe);
if (prframe == NULL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" decryptor: drop pkt\n"
, FUNC_ADPT_ARG(padapter));
#endif
ret = _FAIL;
DBG_COUNTER(padapter->rx_logs.core_rx_post_decrypt_err);
goto _recv_data_drop;
}
#ifdef DBG_RX_BMC_FRAME
if (IS_MCAST(pattrib->ra))
RTW_INFO("%s =>"ADPT_FMT" Rx BC/MC from "MAC_FMT"\n", __func__, ADPT_ARG(padapter), MAC_ARG(pattrib->ta));
#endif
#if 0
if (is_primary_adapter(padapter)) {
RTW_INFO("+++\n");
{
int i;
u8 *ptr = get_recvframe_data(prframe);
for (i = 0; i < 140; i = i + 8)
RTW_INFO("%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X:", *(ptr + i),
*(ptr + i + 1), *(ptr + i + 2) , *(ptr + i + 3) , *(ptr + i + 4), *(ptr + i + 5), *(ptr + i + 6), *(ptr + i + 7));
}
RTW_INFO("---\n");
}
#endif
#ifdef CONFIG_TDLS
/* check TDLS frame */
psnap_type = get_recvframe_data(orig_prframe) + pattrib->hdrlen + pattrib->iv_len + SNAP_SIZE;
pcategory = psnap_type + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
if ((_rtw_memcmp(psnap_type, SNAP_ETH_TYPE_TDLS, ETH_TYPE_LEN)) &&
((*pcategory == RTW_WLAN_CATEGORY_TDLS) || (*pcategory == RTW_WLAN_CATEGORY_P2P))) {
ret = OnTDLS(padapter, prframe);
if (ret == _FAIL)
goto _exit_recv_func;
}
#endif /* CONFIG_TDLS */
prframe = recvframe_chk_defrag(padapter, prframe);
if (prframe == NULL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recvframe_chk_defrag: drop pkt\n"
, FUNC_ADPT_ARG(padapter));
#endif
DBG_COUNTER(padapter->rx_logs.core_rx_post_defrag_err);
goto _recv_data_drop;
}
prframe = portctrl(padapter, prframe);
if (prframe == NULL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" portctrl: drop pkt\n"
, FUNC_ADPT_ARG(padapter));
#endif
ret = _FAIL;
DBG_COUNTER(padapter->rx_logs.core_rx_post_portctrl_err);
goto _recv_data_drop;
}
count_rx_stats(padapter, prframe, NULL);
#ifdef CONFIG_WAPI_SUPPORT
rtw_wapi_update_info(padapter, prframe);
#endif
#if defined(CONFIG_80211N_HT) && defined(CONFIG_RECV_REORDERING_CTRL)
/* including perform A-MPDU Rx Ordering Buffer Control */
ret = recv_indicatepkt_reorder(padapter, prframe);
if (ret == _FAIL) {
rtw_free_recvframe(orig_prframe);
goto _recv_data_drop;
} else if (ret == RTW_RX_HANDLED) /* queued OR indicated in order */
goto _exit_recv_func;
#endif
recv_set_iseq_before_mpdu_process(prframe, pattrib->seq_num, __func__);
ret = recv_process_mpdu(padapter, prframe);
recv_set_iseq_after_mpdu_process(prframe, pattrib->seq_num, __func__);
if (ret == _FAIL)
goto _recv_data_drop;
_exit_recv_func:
return ret;
_recv_data_drop:
precvinfo->dbg_rx_drop_count++;
return ret;
}
int recv_func(_adapter *padapter, union recv_frame *rframe)
{
int ret;
struct rx_pkt_attrib *prxattrib = &rframe->u.hdr.attrib;
struct recv_priv *recvpriv = &padapter->recvpriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct mlme_priv *mlmepriv = &padapter->mlmepriv;
#ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
u8 type;
u8 *ptr = rframe->u.hdr.rx_data;
#endif
if (check_fwstate(mlmepriv, WIFI_MONITOR_STATE)) {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
recv_frame_monitor(padapter, rframe);
#endif
ret = _SUCCESS;
goto exit;
}
#ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
type = GetFrameType(ptr);
if ((type == WIFI_DATA_TYPE)&& MLME_IS_STA(padapter)) {
struct wlan_network *cur_network = &(mlmepriv->cur_network);
if ( _rtw_memcmp(get_addr2_ptr(ptr), cur_network->network.MacAddress, ETH_ALEN)==0) {
recv_frame_monitor(padapter, rframe);
ret = _SUCCESS;
goto exit;
}
}
#endif
/* check if need to handle uc_swdec_pending_queue*/
if (MLME_IS_STA(padapter) && psecuritypriv->busetkipkey) {
union recv_frame *pending_frame;
int cnt = 0;
while ((pending_frame = rtw_alloc_recvframe(&recvpriv->uc_swdec_pending_queue))) {
cnt++;
DBG_COUNTER(padapter->rx_logs.core_rx_dequeue);
recv_func_posthandle(padapter, pending_frame);
}
if (cnt)
RTW_INFO(FUNC_ADPT_FMT" dequeue %d from uc_swdec_pending_queue\n",
FUNC_ADPT_ARG(padapter), cnt);
}
DBG_COUNTER(padapter->rx_logs.core_rx);
ret = recv_func_prehandle(padapter, rframe);
if (ret == _SUCCESS) {
/* check if need to enqueue into uc_swdec_pending_queue*/
if (MLME_IS_STA(padapter) &&
!IS_MCAST(prxattrib->ra) && prxattrib->encrypt > 0 &&
(prxattrib->bdecrypted == 0 || psecuritypriv->sw_decrypt == _TRUE) &&
psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPAPSK &&
!psecuritypriv->busetkipkey) {
DBG_COUNTER(padapter->rx_logs.core_rx_enqueue);
rtw_enqueue_recvframe(rframe, &recvpriv->uc_swdec_pending_queue);
/* RTW_INFO("%s: no key, enqueue uc_swdec_pending_queue\n", __func__); */
if (recvpriv->free_recvframe_cnt < NR_RECVFRAME / 4) {
/* to prevent from recvframe starvation, get recvframe from uc_swdec_pending_queue to free_recvframe_cnt */
rframe = rtw_alloc_recvframe(&padapter->recvpriv.uc_swdec_pending_queue);
if (rframe)
goto do_posthandle;
}
goto exit;
}
do_posthandle:
ret = recv_func_posthandle(padapter, rframe);
}
exit:
return ret;
}
s32 rtw_recv_entry(union recv_frame *precvframe)
{
_adapter *padapter;
struct recv_info *precvinfo;
s32 ret = _SUCCESS;
padapter = precvframe->u.hdr.adapter;
precvinfo = &padapter->recvinfo;
ret = recv_func(padapter, precvframe);
if (ret == _FAIL) {
goto _recv_entry_drop;
}
precvinfo->rx_pkts++;
return ret;
_recv_entry_drop:
#ifdef CONFIG_MP_INCLUDED
if (padapter->registrypriv.mp_mode == 1)
padapter->mppriv.rx_pktloss = precvinfo->rx_drop;
#endif
return ret;
}
#endif
#ifdef CONFIG_SIGNAL_STAT_PROCESS
static void rtw_signal_stat_timer_hdl(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
struct recv_info *recvinfo = &adapter->recvinfo;
u32 tmp_s, tmp_q;
u8 avg_signal_strength = 0;
u8 avg_signal_qual = 0;
u32 num_signal_strength = 0;
u32 num_signal_qual = 0;
u8 ratio_pre_stat = 0, ratio_curr_stat = 0, ratio_total = 0, ratio_profile = SIGNAL_STAT_CALC_PROFILE_0;
if (recvinfo->is_signal_dbg) {
/* update the user specific value, signal_strength_dbg, to signal_strength, rssi */
recvinfo->signal_strength = recvinfo->signal_strength_dbg;
recvinfo->rssi = (s8)rtw_phl_rssi_to_dbm((u8)recvinfo->signal_strength_dbg);
} else {
if (recvinfo->signal_strength_data.update_req == 0) { /* update_req is clear, means we got rx */
avg_signal_strength = recvinfo->signal_strength_data.avg_val;
num_signal_strength = recvinfo->signal_strength_data.total_num;
/* after avg_vals are accquired, we can re-stat the signal values */
recvinfo->signal_strength_data.update_req = 1;
}
if (recvinfo->signal_qual_data.update_req == 0) { /* update_req is clear, means we got rx */
avg_signal_qual = recvinfo->signal_qual_data.avg_val;
num_signal_qual = recvinfo->signal_qual_data.total_num;
/* after avg_vals are accquired, we can re-stat the signal values */
recvinfo->signal_qual_data.update_req = 1;
}
if (num_signal_strength == 0) {
if (rtw_get_on_cur_ch_time(adapter) == 0
|| rtw_get_passing_time_ms(rtw_get_on_cur_ch_time(adapter)) < 2 * adapter->mlmeextpriv.mlmext_info.bcn_interval
)
goto set_timer;
}
if (check_fwstate(&adapter->mlmepriv, WIFI_UNDER_SURVEY) == _TRUE
|| check_fwstate(&adapter->mlmepriv, WIFI_ASOC_STATE) == _FALSE
)
goto set_timer;
#ifdef CONFIG_CONCURRENT_MODE
if (rtw_mi_buddy_check_fwstate(adapter, WIFI_UNDER_SURVEY) == _TRUE)
goto set_timer;
#endif
if (RTW_SIGNAL_STATE_CALC_PROFILE < SIGNAL_STAT_CALC_PROFILE_MAX)
ratio_profile = RTW_SIGNAL_STATE_CALC_PROFILE;
ratio_pre_stat = signal_stat_calc_profile[ratio_profile][0];
ratio_curr_stat = signal_stat_calc_profile[ratio_profile][1];
ratio_total = ratio_pre_stat + ratio_curr_stat;
/* update value of signal_strength, rssi, signal_qual */
tmp_s = (ratio_curr_stat * avg_signal_strength + ratio_pre_stat * recvinfo->signal_strength);
if (tmp_s % ratio_total)
tmp_s = tmp_s / ratio_total + 1;
else
tmp_s = tmp_s / ratio_total;
if (tmp_s > PHL_MAX_RSSI)
tmp_s = PHL_MAX_RSSI;
tmp_q = (ratio_curr_stat * avg_signal_qual + ratio_pre_stat * recvinfo->signal_qual);
if (tmp_q % ratio_total)
tmp_q = tmp_q / ratio_total + 1;
else
tmp_q = tmp_q / ratio_total;
if (tmp_q > PHL_MAX_RSSI)
tmp_q = PHL_MAX_RSSI;
recvinfo->signal_strength = tmp_s;
recvinfo->rssi = (s8)rtw_phl_rssi_to_dbm(tmp_s);
recvinfo->signal_qual = tmp_q;
#if defined(DBG_RX_SIGNAL_DISPLAY_PROCESSING) && 1
RTW_INFO(FUNC_ADPT_FMT" signal_strength:%3u, rssi:%3d, signal_qual:%3u"
", num_signal_strength:%u, num_signal_qual:%u"
", on_cur_ch_ms:%d"
"\n"
, FUNC_ADPT_ARG(adapter)
, recvinfo->signal_strength
, recvinfo->rssi
, recvinfo->signal_qual
, num_signal_strength, num_signal_qual
, rtw_get_on_cur_ch_time(adapter) ? rtw_get_passing_time_ms(rtw_get_on_cur_ch_time(adapter)) : 0
);
#endif
}
set_timer:
rtw_set_signal_stat_timer(recvinfo);
}
#endif/*CONFIG_SIGNAL_STAT_PROCESS*/
/*
* Increase and check if the continual_no_rx_packet of this @param pmlmepriv is larger than MAX_CONTINUAL_NORXPACKET_COUNT
* @return _TRUE:
* @return _FALSE:
*/
int rtw_inc_and_chk_continual_no_rx_packet(struct sta_info *sta, int tid_index)
{
int ret = _FALSE;
int value = ATOMIC_INC_RETURN(&sta->continual_no_rx_packet[tid_index]);
if (value >= MAX_CONTINUAL_NORXPACKET_COUNT)
ret = _TRUE;
return ret;
}
/*
* Set the continual_no_rx_packet of this @param pmlmepriv to 0
*/
void rtw_reset_continual_no_rx_packet(struct sta_info *sta, int tid_index)
{
ATOMIC_SET(&sta->continual_no_rx_packet[tid_index], 0);
}
u8 adapter_allow_bmc_data_rx(_adapter *adapter)
{
if (check_fwstate(&adapter->mlmepriv, WIFI_MONITOR_STATE | WIFI_MP_STATE) == _TRUE)
return 1;
if (MLME_IS_AP(adapter))
return 0;
if (rtw_linked_check(adapter) == _FALSE)
return 0;
return 1;
}
#if 0
s32 pre_recv_entry(union recv_frame *precvframe, u8 *pphy_status)
{
s32 ret = _SUCCESS;
u8 *pbuf = precvframe->u.hdr.rx_data;
u8 *pda = get_ra(pbuf);
u8 ra_is_bmc = IS_MCAST(pda);
_adapter *primary_padapter = precvframe->u.hdr.adapter;
#ifdef CONFIG_CONCURRENT_MODE
_adapter *iface = NULL;
#ifdef CONFIG_MP_INCLUDED
if (rtw_mp_mode_check(primary_padapter))
goto bypass_concurrent_hdl;
#endif
if (ra_is_bmc == _FALSE) { /*unicast packets*/
iface = rtw_get_iface_by_macddr(primary_padapter , pda);
if (NULL == iface) {
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
if (_rtw_memcmp(pda, adapter_pno_mac_addr(primary_padapter),
ETH_ALEN) != _TRUE)
#endif
RTW_INFO("%s [WARN] Cannot find appropriate adapter - mac_addr : "MAC_FMT"\n", __func__, MAC_ARG(pda));
/*rtw_warn_on(1);*/
} else {
precvframe->u.hdr.adapter = iface;
}
} else { /* Handle BC/MC Packets*/
rtw_mi_buddy_clone_bcmc_packet(primary_padapter, precvframe, pphy_status);
}
#ifdef CONFIG_MP_INCLUDED
bypass_concurrent_hdl:
#endif
#endif /* CONFIG_CONCURRENT_MODE */
if (primary_padapter->registrypriv.mp_mode != 1) {
/* skip unnecessary bmc data frame for primary adapter */
if (ra_is_bmc == _TRUE && GetFrameType(pbuf) == WIFI_DATA_TYPE
&& !adapter_allow_bmc_data_rx(precvframe->u.hdr.adapter)
) {
rtw_free_recvframe(precvframe);
goto exit;
}
}
if (pphy_status) {
rx_query_phy_status(precvframe, pphy_status);
#ifdef CONFIG_WIFI_MONITOR
rx_query_moinfo(&precvframe->u.hdr.attrib, pphy_status);
#endif
}
ret = rtw_recv_entry(precvframe);
exit:
return ret;
}
#endif
#ifdef CONFIG_RECV_THREAD_MODE
thread_return rtw_recv_thread(thread_context context)
{
_adapter *adapter = (_adapter *)context;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct recv_priv *recvpriv = &dvobj->recvpriv;
s32 err = _SUCCESS;
#ifdef RTW_RECV_THREAD_HIGH_PRIORITY
#ifdef PLATFORM_LINUX
struct sched_param param = { .sched_priority = 1 };
sched_setscheduler(current, SCHED_FIFO, ¶m);
#endif /* PLATFORM_LINUX */
#endif /*RTW_RECV_THREAD_HIGH_PRIORITY*/
rtw_thread_enter("RTW_RECV_THREAD");
RTW_INFO(FUNC_ADPT_FMT" enter\n", FUNC_ADPT_ARG(adapter));
do {
err = _rtw_down_sema(&recvpriv->recv_sema);
if (_FAIL == err) {
RTW_ERR(FUNC_ADPT_FMT" down recv_sema fail!\n", FUNC_ADPT_ARG(adapter));
goto exit;
}
if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter))) {
RTW_DBG(FUNC_ADPT_FMT "- bDriverStopped(%s) bSurpriseRemoved(%s)\n",
FUNC_ADPT_ARG(adapter),
dev_is_drv_stopped(adapter_to_dvobj(adapter)) ? "True" : "False",
dev_is_surprise_removed(adapter_to_dvobj(adapter)) ? "True" : "False");
goto exit;
}
err = rtw_intf_recv_hdl(adapter);
if (err == RTW_RFRAME_UNAVAIL
|| err == RTW_RFRAME_PKT_UNAVAIL
) {
rtw_msleep_os(1);
_rtw_up_sema(&recvpriv->recv_sema);
}
flush_signals_thread();
} while (err != _FAIL);
exit:
RTW_INFO(FUNC_ADPT_FMT " Exit\n", FUNC_ADPT_ARG(adapter));
rtw_thread_wait_stop();
return 0;
}
#endif /* CONFIG_RECV_THREAD_MODE */
u8 rtw_init_lite_recv_resource(struct dvobj_priv *dvobj)
{
u8 ret = _SUCCESS;
u32 literecvbuf_nr = RTW_LITERECVBUF_NR;
struct lite_data_buf *literecvbuf;
struct trx_data_buf_q *literecvbuf_q = &dvobj->literecvbuf_q;
int i;
#ifdef CONFIG_USB_HCI
struct data_urb *recvurb;
struct trx_urb_buf_q *recv_urb_q = &dvobj->recv_urb_q;
u32 recvurb_nr = RTW_RECVURB_NR;
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
struct lite_data_buf *intinbuf;
struct trx_data_buf_q *intin_buf_q = &dvobj->intin_buf_q;
u32 intin_buf_nr = RTW_INTINBUF_NR;
struct data_urb *intin_urb;
struct trx_urb_buf_q *intin_urb_q = &dvobj->intin_urb_q;
u32 intin_urb_nr = RTW_INTINURB_NR;
#endif
#endif
/* init lite_recv_buf */
_rtw_init_queue(&literecvbuf_q->free_data_buf_queue);
literecvbuf_q->alloc_data_buf =
rtw_zvmalloc(literecvbuf_nr * sizeof(struct lite_data_buf) + 4);
if (literecvbuf_q->alloc_data_buf == NULL) {
ret = _FAIL;
goto exit;
}
literecvbuf_q->data_buf=
(u8 *)N_BYTE_ALIGNMENT((SIZE_PTR)(literecvbuf_q->alloc_data_buf), 4);
literecvbuf = (struct lite_data_buf *)literecvbuf_q->data_buf;
for (i = 0; i < literecvbuf_nr; i++) {
_rtw_init_listhead(&literecvbuf->list);
rtw_list_insert_tail(&literecvbuf->list,
&(literecvbuf_q->free_data_buf_queue.queue));
literecvbuf++;
}
literecvbuf_q->free_data_buf_cnt = literecvbuf_nr;
#ifdef CONFIG_USB_HCI
/* init recv_urb */
_rtw_init_queue(&recv_urb_q->free_urb_buf_queue);
recv_urb_q->alloc_urb_buf=
rtw_zvmalloc(recvurb_nr * sizeof(struct data_urb) + 4);
if (recv_urb_q->alloc_urb_buf== NULL) {
ret = _FAIL;
goto exit;
}
recv_urb_q->urb_buf =
(u8 *)N_BYTE_ALIGNMENT((SIZE_PTR)(recv_urb_q->alloc_urb_buf), 4);
recvurb = (struct data_urb *)recv_urb_q->urb_buf;
for (i = 0; i < recvurb_nr; i++) {
_rtw_init_listhead(&recvurb->list);
ret = rtw_os_urb_resource_alloc(recvurb);
rtw_list_insert_tail(&recvurb->list,
&(recv_urb_q->free_urb_buf_queue.queue));
recvurb++;
}
recv_urb_q->free_urb_buf_cnt = recvurb_nr;
ATOMIC_SET(&(dvobj->rx_pending_cnt), 0);
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
/* init int_in_buf */
_rtw_init_queue(&intin_buf_q->free_data_buf_queue);
intin_buf_q->alloc_data_buf =
rtw_zvmalloc(intin_buf_nr * sizeof(struct lite_data_buf) + 4);
if (intin_buf_q->alloc_data_buf == NULL) {
ret = _FAIL;
goto exit;
}
intin_buf_q->data_buf=
(u8 *)N_BYTE_ALIGNMENT((SIZE_PTR)(intin_buf_q->alloc_data_buf), 4);
intinbuf = (struct lite_data_buf *)intin_buf_q->data_buf;
for (i = 0; i < intin_buf_nr; i++) {
_rtw_init_listhead(&intinbuf->list);
rtw_list_insert_tail(&intinbuf->list,
&(intin_buf_q->free_data_buf_queue.queue));
intinbuf++;
}
intin_buf_q->free_data_buf_cnt = intin_buf_nr;
/* init int_in_urb */
_rtw_init_queue(&intin_urb_q->free_urb_buf_queue);
intin_urb_q->alloc_urb_buf=
rtw_zvmalloc(intin_urb_nr * sizeof(struct data_urb) + 4);
if (intin_urb_q->alloc_urb_buf== NULL) {
ret = _FAIL;
goto exit;
}
intin_urb_q->urb_buf =
(u8 *)N_BYTE_ALIGNMENT((SIZE_PTR)(intin_urb_q->alloc_urb_buf), 4);
intin_urb = (struct data_urb *)intin_urb_q->urb_buf;
for (i = 0; i < intin_urb_nr; i++) {
_rtw_init_listhead(&intin_urb->list);
ret = rtw_os_urb_resource_alloc(intin_urb);
rtw_list_insert_tail(&intin_urb->list,
&(intin_urb_q->free_urb_buf_queue.queue));
intin_urb++;
}
intin_urb_q->free_urb_buf_cnt = intin_urb_nr;
#endif
#endif
exit:
return ret;
}
void rtw_free_lite_recv_resource(struct dvobj_priv *dvobj)
{
u8 ret = _SUCCESS;
u32 literecvbuf_nr = RTW_LITERECVBUF_NR;
struct lite_data_buf *literecvbuf;
struct trx_data_buf_q *literecvbuf_q = &dvobj->literecvbuf_q;
int i;
#ifdef CONFIG_USB_HCI
struct data_urb *recvurb;
struct trx_urb_buf_q *recv_urb_q = &dvobj->recv_urb_q;
u32 recvurb_nr = RTW_RECVURB_NR;
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
struct lite_data_buf *intinbuf;
struct trx_data_buf_q *intin_buf_q = &dvobj->intin_buf_q;
u32 intin_buf_nr = RTW_INTINBUF_NR;
struct data_urb *intin_urb;
struct trx_urb_buf_q *intin_urb_q = &dvobj->intin_urb_q;
u32 intin_urb_nr = RTW_INTINURB_NR;
#endif
#endif
if (literecvbuf_q->alloc_data_buf)
rtw_vmfree(literecvbuf_q->alloc_data_buf,
literecvbuf_nr * sizeof(struct lite_data_buf) + 4);
#ifdef CONFIG_USB_HCI
recvurb = (struct data_urb *)recv_urb_q->urb_buf;
for (i = 0; i < recvurb_nr; i++) {
rtw_os_urb_resource_free(recvurb);
recvurb++;
}
if (recv_urb_q->alloc_urb_buf)
rtw_vmfree(recv_urb_q->alloc_urb_buf,
recvurb_nr * sizeof(struct data_urb) + 4);
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
if (intin_buf_q->alloc_data_buf)
rtw_vmfree(intin_buf_q->alloc_data_buf,
intin_buf_nr * sizeof(struct lite_data_buf) + 4);
intin_urb = (struct data_urb *)intin_urb_q->urb_buf;
for (i = 0; i < intin_urb_nr; i++) {
rtw_os_urb_resource_free(intin_urb);
intin_urb++;
}
if (intin_urb_q->alloc_urb_buf)
rtw_vmfree(intin_urb_q->alloc_urb_buf,
intin_urb_nr * sizeof(struct data_urb) + 4);
#endif
#endif
}
#ifdef RTW_PHL_RX
void rx_dump_skb(struct sk_buff *skb)
{
int idx=0;
u8 *tmp=skb->data;
printk("===");
printk("[%s]skb=%p len=%d\n", __FUNCTION__, skb, skb->len);
#if 0
printk("data-tail=0x%x-0x%x(%d)\n",
skb->data, skb->tail, (skb->tail - skb->data));
printk("head-end=0x%x-0x%x(%d)\n",
skb->head, skb->end, (skb->end - skb->head));
#endif
for(idx=0; idx<skb->len; idx++){
printk("%02x ", tmp[idx]);
if(idx%20==19)
printk("\n");
}
printk("\n===\n");
}
void dump_rxreq(_adapter *adapter, union recv_frame *prframe)
{
}
void dump_recv_frame(_adapter *adapter, union recv_frame *prframe)
{
struct recv_frame_hdr *hdr = &(prframe->u.hdr);
struct rx_pkt_attrib *rxattr = &(prframe->u.hdr.attrib);
printk("[%s]prframe=0x%p len=%d\n", __FUNCTION__, prframe, hdr->len);
printk("head-tail=0x%p-0x%p\n", hdr->rx_head, hdr->rx_tail);
printk("data-end=0x%p-0x%p\n", hdr->rx_data, hdr->rx_end);
printk("dst=%pM\n", rxattr->dst);
printk("src=%pM\n", rxattr->src);
printk("ra=%pM\n", rxattr->ra);
printk("ta=%pM\n", rxattr->ta);
printk("bssid=%pM\n", rxattr->bssid);
}
void core_update_recvframe_pkt( union recv_frame *prframe, struct rtw_recv_pkt *rx_req)
{
struct rtw_pkt_buf_list *pkt = rx_req->pkt_list;
struct sk_buff *skb = prframe->u.hdr.pkt;
skb_reserve(skb, pkt->vir_addr - skb->data);
skb_put(skb, pkt->length);
prframe->u.hdr.rx_data = skb->data;
prframe->u.hdr.rx_tail = skb_tail_pointer(skb);
prframe->u.hdr.len = skb->len;
prframe->u.hdr.rx_head = skb->head;
prframe->u.hdr.rx_end = skb_end_pointer(skb);
return;
}
static int core_alloc_recvframe_pkt(union recv_frame *prframe,
struct rtw_recv_pkt *phlrx)
{
struct rtw_pkt_buf_list *pktbuf;
u8 shift_sz;
u32 alloc_sz;
struct sk_buff *pkt = NULL;
u8 *pbuf = NULL;
rtw_warn_on(phlrx->pkt_cnt > 1);
pktbuf = phlrx->pkt_list; /* &phlrx->pkt_list[0] */
/* For 8 bytes IP header alignment. */
if (phlrx->mdata.qos)
/* Qos data, wireless lan header length is 26 */
shift_sz = 6;
else
shift_sz = 0;
/*
* For first fragment packet, driver need allocate 1536 to
* defrag packet.
* And need 8 is for skb->data 8 bytes alignment.
* Round (1536 + shift_sz + 8) to 128 bytes alignment,
* and finally get 1664.
*/
alloc_sz = pktbuf->length;
if ((phlrx->mdata.more_frag == 1) && (phlrx->mdata.frag_num == 0)) {
if (alloc_sz <= 1650)
alloc_sz = 1664;
else
alloc_sz += 14;
} else {
/*
* 6 is for IP header 8 bytes alignment in QoS packet case.
* 8 is for skb->data 4 bytes alignment.
*/
alloc_sz += 14;
}
pkt = rtw_skb_alloc(alloc_sz);
if (!pkt) {
RTW_ERR("%s: alloc skb fail! sz=%u (mfrag=%u, frag_num=%u)\n",
__FUNCTION__, alloc_sz, phlrx->mdata.more_frag,
phlrx->mdata.frag_num);
return -1;
}
/* force pkt->data at 8-byte alignment address */
skb_reserve(pkt, 8 - ((SIZE_PTR)pkt->data & 7));
/* force ip_hdr at 8-byte alignment address according to shift_sz. */
skb_reserve(pkt, shift_sz);
pbuf = skb_put(pkt, pktbuf->length);
_rtw_memcpy(pbuf, pktbuf->vir_addr, pktbuf->length);
prframe->u.hdr.pkt = pkt;
prframe->u.hdr.rx_data = pkt->data;
prframe->u.hdr.rx_tail = skb_tail_pointer(pkt);
prframe->u.hdr.len = pkt->len;
prframe->u.hdr.rx_head = pkt->head;
prframe->u.hdr.rx_end = skb_end_pointer(pkt);
return 0;
}
void core_update_recvframe_mdata(union recv_frame *prframe, struct rtw_recv_pkt *rx_req)
{
struct rx_pkt_attrib *prxattrib = &prframe->u.hdr.attrib;
struct rtw_r_meta_data *mdata = &rx_req->mdata;
prxattrib->bdecrypted = !(mdata->sw_dec);
prxattrib->pkt_len = mdata->pktlen;
prxattrib->icv_err = mdata->icverr;
prxattrib->crc_err = mdata->crc32;
#ifdef CONFIG_TCP_CSUM_OFFLOAD_RX
prxattrib->csum_valid = mdata->chksum_ofld_en;
prxattrib->csum_err = mdata->chksum_status;
#endif
/* when 0 indicate no encrypt. when non-zero, indicate the encrypt algorith */
prxattrib->encrypt = rtw_sec_algo_phl2drv((enum rtw_enc_algo)mdata->sec_type);
#if 0 //todo
//Security (sw-decrypt & calculate payload offset)
u8 bdecrypted;
u8 encrypt; /* when 0 indicate no encrypt. when non-zero, indicate the encrypt algorith */
u8 iv_len;
u8 icv_len;
u8 crc_err;
u8 icv_err;
#endif
return;
}
#ifdef RTW_WKARD_CORE_RSSI_V1
static inline void _rx_process_ss_sq(_adapter *padapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct signal_stat *ss = &padapter->recvinfo.signal_strength_data;
struct signal_stat *sq = &padapter->recvinfo.signal_qual_data;
if (ss->update_req) {
ss->total_num = 0;
ss->total_val = 0;
ss->update_req = 0;
}
ss->total_num++;
ss->total_val += pattrib->phy_info.signal_strength;
ss->avg_val = ss->total_val / ss->total_num;
if (sq->update_req) {
sq->total_num = 0;
sq->total_val = 0;
sq->update_req = 0;
}
sq->total_num++;
sq->total_val += pattrib->phy_info.signal_quality;
sq->avg_val = sq->total_val / sq->total_num;
}
/*#define DBG_RECV_INFO*/
void rx_process_phy_info(union recv_frame *precvframe)
{
_adapter *padapter = precvframe->u.hdr.adapter;
struct rx_pkt_attrib *pattrib = &precvframe->u.hdr.attrib;
struct phydm_phyinfo_struct *phy_info = &pattrib->phy_info;
u8 *wlanhdr = NULL;
u8 *ta, *ra;
u8 is_ra_bmc;
struct sta_priv *pstapriv;
struct sta_info *psta = NULL;
struct recv_info *precvinfo = &padapter->recvinfo;
bool is_packet_match_bssid = _FALSE;
bool is_packet_to_self = _FALSE;
bool is_packet_beacon = _FALSE;
wlanhdr = precvframe->u.hdr.rx_data;
ta = get_ta(wlanhdr);
ra = get_ra(wlanhdr);
is_ra_bmc = IS_MCAST(ra);
if (_rtw_memcmp(adapter_mac_addr(padapter), ta, ETH_ALEN) == _TRUE) {
static systime start_time = 0;
#if 0 /*For debug */
if (IsFrameTypeCtrl(wlanhdr)) {
RTW_INFO("-->Control frame: Y\n");
RTW_INFO("-->pkt_len: %d\n", pattrib->pkt_len);
RTW_INFO("-->Sub Type = 0x%X\n", get_frame_sub_type(wlanhdr));
}
/* Dump first 40 bytes of header */
int i = 0;
for (i = 0; i < 40; i++)
RTW_INFO("%d: %X\n", i, *((u8 *)wlanhdr + i));
RTW_INFO("\n");
#endif
if ((start_time == 0) || (rtw_get_passing_time_ms(start_time) > 5000)) {
RTW_ERR("Warning!!! %s: Confilc mac addr!!\n", __func__);
start_time = rtw_get_current_time();
}
precvinfo->dbg_rx_conflic_mac_addr_cnt++;
return;
}
pstapriv = &padapter->stapriv;
psta = rtw_get_stainfo(pstapriv, ta);
is_packet_match_bssid = (!IsFrameTypeCtrl(wlanhdr))
&& (!pattrib->icv_err) && (!pattrib->crc_err)
&& ((!MLME_IS_MESH(padapter) && _rtw_memcmp(get_hdr_bssid(wlanhdr), get_bssid(&padapter->mlmepriv), ETH_ALEN))
|| (MLME_IS_MESH(padapter) && psta));
/*is_to_self = (!pattrib->icv_err) && (!pattrib->crc_err)
&& _rtw_memcmp(ra, adapter_mac_addr(padapter), ETH_ALEN);*/
is_packet_to_self = is_packet_match_bssid
&& _rtw_memcmp(ra, adapter_mac_addr(padapter), ETH_ALEN);
is_packet_beacon = is_packet_match_bssid
&& (get_frame_sub_type(wlanhdr) == WIFI_BEACON);
if (psta && IsFrameTypeData(wlanhdr)) {
if (is_ra_bmc)
psta->curr_rx_rate_bmc = pattrib->data_rate;
else
psta->curr_rx_rate = pattrib->data_rate;
}
#if 0
/* If bw is initial value, get from phy status */
if (pattrib->bw == CHANNEL_WIDTH_MAX)
pattrib->bw = p_phy_info->band_width;
#endif
#ifdef DBG_RECV_INFO
RTW_INFO("%s match_bssid:%d, to_self:%d, is_beacon:%d",
__func__, is_packet_match_bssid, is_packet_to_self, is_packet_beacon);
RTW_INFO("hdr_bssid:"MAC_FMT" my_bssid:"MAC_FMT"\n",
MAC_ARG(get_hdr_bssid(wlanhdr)),
MAC_ARG(get_bssid(&padapter->mlmepriv)));
RTW_INFO("ra:"MAC_FMT" my_addr:"MAC_FMT"\n",
MAC_ARG(ra),
MAC_ARG(adapter_mac_addr(padapter)));
#endif
precvframe->u.hdr.psta = NULL;
if (padapter->registrypriv.mp_mode != 1) {
if ((!MLME_IS_MESH(padapter) && is_packet_match_bssid)
|| (MLME_IS_MESH(padapter) && psta)) {
if (psta)
precvframe->u.hdr.psta = psta;
if (phy_info->is_valid)
_rx_process_ss_sq(padapter, precvframe);/*signal_strength & signal_quality*/
} else if (is_packet_to_self || is_packet_beacon) {
if (psta)
precvframe->u.hdr.psta = psta;
if (phy_info->is_valid)
_rx_process_ss_sq(padapter, precvframe);/*signal_strength & signal_quality*/
}
}
#if 0
#ifdef CONFIG_MP_INCLUDED
else {
#ifdef CONFIG_MP_INCLUDED
if (padapter->mppriv.brx_filter_beacon == _TRUE) {
if (is_packet_beacon) {
RTW_INFO("in MP Rx is_packet_beacon\n");
if (psta)
precvframe->u.hdr.psta = psta;
_rx_process_ss_sq(padapter, precvframe);
}
} else
#endif
{
if (psta)
precvframe->u.hdr.psta = psta;
_rx_process_ss_sq(padapter, precvframe);
}
}
#endif
#endif
}
/*#define DBG_PHY_INFO*/
void core_update_recvframe_phyinfo(union recv_frame *prframe, struct rtw_recv_pkt *rx_req)
{
struct rx_pkt_attrib *attrib = &prframe->u.hdr.attrib;
struct rtw_phl_ppdu_phy_info *phy_info = &rx_req->phy_info;
u8 ptype, pstype;
_rtw_memset(&attrib->phy_info, 0, sizeof(struct phydm_phyinfo_struct));
ptype = phy_info->frame_type & 0x03;
pstype = phy_info->frame_type >> 2;
#ifdef DBG_PHY_INFO
{
u8 type, subtype;
u8 *ptr = prframe->u.hdr.rx_data;
type = GetFrameType(ptr) >> 2;
subtype = get_frame_sub_type(ptr) >> 4; /* bit(7)~bit(2) */
if ((type != WIFI_CTRL_TYPE) && (ptype != type || pstype != subtype)) {
RTW_INFO("[DBG-PHY-INFO]- FT:0x%02x, FST:0x%02x\t", type, subtype);
RTW_INFO("A1:"MAC_FMT" A2:"MAC_FMT" A3:"MAC_FMT"\n",
MAC_ARG(GetAddr1Ptr(ptr)),
MAC_ARG(get_addr2_ptr(ptr)),
MAC_ARG(GetAddr3Ptr(ptr)));
}
}
#endif
if (phy_info->is_valid) {
attrib->phy_info.is_valid = true;
attrib->phy_info.signal_strength = phy_info->rssi;
attrib->phy_info.signal_quality = phy_info->rssi;
attrib->phy_info.recv_signal_power = rtw_phl_rssi_to_dbm(phy_info->rssi);
attrib->ch = phy_info->ch_idx;
#ifdef DBG_PHY_INFO
RTW_INFO("[PHY-INFO] ft:0x%02x-0x%02x rssi:%d, ch_idx:%d, tx_bf:%d\n",
ptype, pstype, phy_info->rssi, phy_info->ch_idx, phy_info->tx_bf);
RTW_INFO("[PHY-INFO] ss:%d sq:%d rssi:%d\n",
attrib->phy_info.signal_strength,
attrib->phy_info.signal_quality,
attrib->phy_info.recv_signal_power);
#endif
} else {
#ifdef DBG_PHY_INFO
RTW_INFO("[PHY-INFO-INVALID] ftype:0x%02x-0x%02x rssi:%d, ch_idx:%d, tx_bf:%d\n",
ptype, pstype, phy_info->rssi, phy_info->ch_idx, phy_info->tx_bf);
#endif
}
}
#endif /*RTW_WKARD_CORE_RSSI_V1*/
s32 core_rx_process_amsdu(_adapter *adapter, union recv_frame *prframe)
{
if(amsdu_to_msdu(adapter, prframe) != _SUCCESS)
return CORE_RX_DROP;
return CORE_RX_DONE;
}
s32 core_rx_process_msdu(_adapter *adapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
u8 *msdu = get_recvframe_data(prframe)
+ pattrib->hdrlen + pattrib->iv_len + RATTRIB_GET_MCTRL_LEN(pattrib);
u16 msdu_len = prframe->u.hdr.len
- pattrib->hdrlen - pattrib->iv_len - RATTRIB_GET_MCTRL_LEN(pattrib)
- (pattrib->encrypt ? pattrib->icv_len : 0);
enum rtw_rx_llc_hdl llc_hdl = rtw_recv_llc_parse(msdu, msdu_len);
int act = RTW_RX_MSDU_ACT_INDICATE;
#if defined(CONFIG_AP_MODE)
struct xmit_frame *fwd_frame = NULL;
_list f_list;
if (MLME_IS_AP(adapter))
act = rtw_ap_rx_msdu_act_check(prframe, pattrib->dst, pattrib->src
, msdu, llc_hdl, &fwd_frame, &f_list);
if (!act)
return CORE_RX_DROP;
#endif
if(wlanhdr_to_ethhdr(prframe, llc_hdl) != _SUCCESS) {
if (act & RTW_RX_MSDU_ACT_INDICATE) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" wlanhdr_to_ethhdr: drop pkt\n"
, FUNC_ADPT_ARG(adapter));
#endif
}
#if defined(CONFIG_AP_MODE)
if (act & RTW_RX_MSDU_ACT_FORWARD) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s wlanhdr_to_ethhdr fail\n", __func__);
#endif
recv_free_fwd_resource(adapter, fwd_frame, &f_list);
}
#endif
return CORE_RX_DROP;
}
#if defined(CONFIG_AP_MODE)
if (act & RTW_RX_MSDU_ACT_FORWARD) {
recv_fwd_pkt_hdl(adapter, prframe->u.hdr.pkt, act, fwd_frame, &f_list);
if (!(act & RTW_RX_MSDU_ACT_INDICATE)) {
prframe->u.hdr.pkt = NULL;
rtw_free_recvframe(prframe);
return CORE_RX_DONE;
}
}
#endif
if(rtw_recv_indicatepkt_check(prframe,
get_recvframe_data(prframe), get_recvframe_len(prframe)) != _SUCCESS)
return CORE_RX_DROP;
if(rtw_recv_indicatepkt(adapter, prframe) != _SUCCESS)
return CORE_RX_DROP;
return CORE_RX_DONE;
}
s32 rtw_core_rx_data_post_process(_adapter *adapter, union recv_frame *prframe)
{
//amsdu
//make eth hdr
//forward
//recv_process_mpdu
//amsdu_to_msdu
//wlanhdr_to_ethhdr
//rtw_recv_indicatepkt_check
//rtw_recv_indicatepkt
//todo hw amsdu
if (prframe->u.hdr.attrib.amsdu)
return core_rx_process_amsdu(adapter, prframe);
else
return core_rx_process_msdu(adapter, prframe);
}
s32 rtw_core_rx_data_pre_process(_adapter *adapter, union recv_frame **prframe)
{
//recv_func_posthandle
//decryptor
//portctrl
//count_rx_stats
#ifdef CONFIG_TDLS
#endif
#ifdef DBG_RX_BMC_FRAME
#endif
#ifdef CONFIG_WAPI_SUPPORT
#endif
union recv_frame * ret_frame = NULL;
s32 ret = CORE_RX_CONTINUE;
ret_frame = decryptor(adapter, *prframe);
if (ret_frame == NULL)
return CORE_RX_DROP;
else
*prframe = ret_frame;
ret = recvframe_chk_defrag(adapter, prframe);
if (ret != CORE_RX_CONTINUE) {
if (ret == CORE_RX_DROP) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recvframe_chk_defrag: drop pkt\n"
, FUNC_ADPT_ARG(adapter));
#endif
DBG_COUNTER(adapter->rx_logs.core_rx_post_defrag_err);
}
return ret;
}
/* Rx TKIP MIC */
if ((*prframe)->u.hdr.attrib.privacy) {
if (recvframe_chkmic(adapter, *prframe) == _FAIL) {
return CORE_RX_DROP;
}
}
ret_frame = portctrl(adapter, *prframe);
if (ret_frame == NULL)
return CORE_RX_DROP;
else
*prframe = ret_frame;
count_rx_stats(adapter, *prframe, NULL);
#ifdef CONFIG_WAPI_SUPPORT
rtw_wapi_update_info(adapter, *prframe);
#endif
return CORE_RX_CONTINUE;
}
s32 rtw_core_update_recvframe(struct dvobj_priv *dvobj,
union recv_frame *prframe, struct rtw_recv_pkt *rx_req)
{
u8 *pbuf = NULL;
u8 *pda = NULL;
_adapter *iface = NULL;
u8 is_bmc = _FALSE;
enum rtw_core_rx_state rx_state = CORE_RX_CONTINUE;
_adapter *primary_padapter = dvobj_get_primary_adapter(dvobj);
int err;
struct mlme_priv *pmlmepriv = NULL;
if (rx_req->mdata.bc || rx_req->mdata.mc)
is_bmc = _TRUE;
//pre_recv_entry
//rtw_get_iface_by_macddr
if (rx_req->os_priv) {
prframe->u.hdr.pkt = rx_req->os_priv; /*skb*/
core_update_recvframe_pkt(prframe, rx_req);
} else {
err = core_alloc_recvframe_pkt(prframe, rx_req);
if (err) {
rx_state = CORE_RX_FAIL;
goto exit;
}
}
core_update_recvframe_mdata(prframe, rx_req);
#ifdef RTW_WKARD_CORE_RSSI_V1
core_update_recvframe_phyinfo(prframe, rx_req);
#endif
prframe->u.hdr.adapter = primary_padapter;
prframe->u.hdr.pkt->dev = primary_padapter->pnetdev;
if (!is_bmc) {
pbuf = prframe->u.hdr.rx_data;
pda = get_ra(pbuf);
iface = rtw_get_iface_by_macddr(primary_padapter, pda);
if(iface) {
prframe->u.hdr.adapter = iface;
prframe->u.hdr.pkt->dev = iface->pnetdev;
}
else {
#if 0 /*#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI - TODO*/
if (_rtw_memcmp(ra, adapter_pno_mac_addr(primary_padapter), ETH_ALEN))
goto query_phy_status;
#endif
#ifdef CONFIG_RTW_MULTI_AP
/* unasoc STA RCPI */
if (rtw_unassoc_sta_src_chk(primary_padapter, UNASOC_STA_SRC_RX_NMY_UC) &&
prframe->u.hdr.attrib.phy_info.recv_signal_power != 0) {
rtw_rx_add_unassoc_sta(primary_padapter, UNASOC_STA_SRC_RX_NMY_UC,
get_ta(pbuf), prframe->u.hdr.attrib.phy_info.recv_signal_power);
} else
#endif
RTW_DBG("%s [WARN] Cannot find appropriate adapter - mac_addr : "MAC_FMT"\n"
, __func__, MAC_ARG(pda));
rx_state = CORE_RX_FAIL;
}
}
else {
/*clone bcmc frame for all active adapter*/
rtw_mi_buddy_clone_bcmc_packet(primary_padapter, prframe);
#ifdef CONFIG_RTW_MULTI_AP
pbuf = prframe->u.hdr.rx_data;
/* unasoc STA RCPI */
if (rtw_unassoc_sta_src_chk(primary_padapter, UNASOC_STA_SRC_RX_BMC) &&
prframe->u.hdr.attrib.phy_info.recv_signal_power != 0) {
rtw_rx_add_unassoc_sta(primary_padapter, UNASOC_STA_SRC_RX_BMC,
get_ta(pbuf), prframe->u.hdr.attrib.phy_info.recv_signal_power);
}
#endif
}
exit:
prframe->u.hdr.rx_req = rx_req;
pmlmepriv = &(prframe->u.hdr.adapter)->mlmepriv;
if (check_fwstate(pmlmepriv, WIFI_MONITOR_STATE)) {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
recv_frame_monitor(prframe->u.hdr.adapter, prframe, rx_req);
#endif
rx_state = CORE_RX_FAIL;
}
return rx_state;
}
#ifdef CONFIG_RTW_NAPI
#ifdef CONFIG_RTW_NAPI_V2
static void rtw_core_rx_napi_v2(struct dvobj_priv *dvobj)
{
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
struct recv_priv *recvpriv = &dvobj->recvpriv;
if (adapter->registrypriv.en_napi) {
_adapter *a;
u8 i;
for (i = 0; i < dvobj->iface_nums; i++) {
a = dvobj->padapters[i];
if ((rtw_if_up(a) == _TRUE)
&& skb_queue_len(&recvpriv->rx_napi_skb_queue))
napi_schedule(&a->napi);
}
}
}
#endif
#endif
enum rtw_phl_status rtw_core_rx_process(void *drv_priv)
{
struct dvobj_priv *dvobj = (struct dvobj_priv *)drv_priv;
_adapter *adapter = NULL;
struct rtw_recv_pkt *rx_req = NULL;
struct rtw_pkt_buf_list *pkt = NULL;
union recv_frame *prframe = NULL;
struct rx_pkt_attrib *prxattrib = NULL;
u16 rx_pkt_num = 0;
struct recv_priv *precvpriv = &dvobj->recvpriv;
s32 pre_process_ret = CORE_RX_CONTINUE;
rx_pkt_num = rtw_phl_query_new_rx_num(GET_PHL_INFO(dvobj));
#ifdef DBG_RECV_FRAME
RTW_INFO("%s dvobj:%p, phl:%p rx_pkt_num:%d, free_recv_queue:%p\n",
__func__, dvobj, dvobj->phl, rx_pkt_num, &precvpriv->free_recv_queue);
#endif
while (rx_pkt_num--) {
prframe = rtw_alloc_recvframe(&precvpriv->free_recv_queue);
if (prframe == NULL) {
RTW_ERR("F-%s L-%d rtw_alloc_recvframe failed\n", __FUNCTION__, __LINE__);
goto rx_error;
}
//_rtw_init_listhead
rx_req = rtw_phl_query_rx_pkt(GET_PHL_INFO(dvobj));
if(rx_req == NULL)
goto rx_stop;
if(rtw_core_update_recvframe(dvobj, prframe, rx_req) != CORE_RX_CONTINUE)
goto rx_next;
prxattrib = &prframe->u.hdr.attrib;
if (prxattrib->icv_err || prxattrib->crc_err)
goto rx_next;
adapter = prframe->u.hdr.adapter;
if (!rtw_is_adapter_up(adapter))
goto rx_next;
#ifdef CONFIG_RTW_CORE_RXSC
if (core_rxsc_apply_check(adapter, prframe) == CORE_RX_GO_SHORTCUT &&
core_rxsc_apply_shortcut(adapter, prframe) == CORE_RX_DONE)
continue;
#endif
//recv_func_prehandle
//mgt_dispatcher exist here && sw decrypt mgmt
//?? todo power save
if(validate_recv_frame(adapter, prframe) != CORE_RX_CONTINUE)
goto rx_next;
pre_process_ret = rtw_core_rx_data_pre_process(adapter, &prframe);
if (pre_process_ret == CORE_RX_DEFRAG)
continue;
if (pre_process_ret != CORE_RX_CONTINUE)
goto rx_next;
if(rtw_core_rx_data_post_process(adapter, prframe) == CORE_RX_DONE)
continue;
rx_next:
rtw_free_recvframe(prframe);
continue;
rx_stop:
rtw_free_recvframe(prframe);
break;
rx_error:
break;
}
#ifdef CONFIG_RTW_NAPI
#ifdef CONFIG_RTW_NAPI_V2
rtw_core_rx_napi_v2(dvobj);
#endif
#endif
return RTW_PHL_STATUS_SUCCESS;
}
#endif /*RTW_PHL_RX*/
|
2301_81045437/rtl8852be
|
core/rtw_recv.c
|
C
|
agpl-3.0
| 155,461
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#ifdef CONFIG_RTW_CORE_RXSC
#define is_equal_mac_addr(lhs,rhs) ((((unsigned long)(lhs)|(unsigned long)(rhs)) & 0x01) ? \
((*(unsigned char*)(lhs) ^ (*(unsigned char*)(rhs))) | (*(unsigned char*)(lhs + 1) ^ (*(unsigned char*)(rhs + 1))) | (*(unsigned char*)(lhs + 2) ^ (*(unsigned char*)(rhs + 2)))|\
(*(unsigned char*)(lhs + 3) ^ (*(unsigned char*)(rhs + 3))) | (*(unsigned char*)(lhs + 4) ^ (*(unsigned char*)(rhs + 4))) | (*(unsigned char*)(lhs + 5) ^ (*(unsigned char*)(rhs + 5))))==0 :\
((*(unsigned short*)(lhs) ^ (*(unsigned short*)(rhs))) | (*(unsigned short*)(lhs + 2) ^ (*(unsigned short*)(rhs + 2))) | (*(unsigned short*)(lhs + 4) ^ (*(unsigned short*)(rhs + 4))))==0 \
)
u8 core_rxsc_check_alloc(_adapter *adapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
if (!adapter->enable_rxsc)
return _FAIL;
if (pattrib->amsdu ||
!pattrib->bdecrypted ||
pattrib->mfrag ||
pattrib->to_fr_ds == 3 ||
!pattrib->bsnaphdr)
return _FAIL;
if (pattrib->eth_type == ETH_P_ARP ||
pattrib->eth_type == 0x888e ||
pattrib->eth_type == 0x8899)
return _FAIL;
if (!prframe->u.hdr.psta)
return _FAIL;
if (IS_MCAST(pattrib->ra) || IS_MCAST(pattrib->dst))
return _FAIL;
#ifdef CONFIG_RTW_MESH
if (pattrib->mesh_ctrl_present)
return _FAIL;
#endif
#ifdef CONFIG_WAPI_SUPPORT
if (prframe->u.hdr.bIsWaiPacket)
return _FAIL;
#endif
return _SUCCESS;
}
struct core_rxsc_entry *core_rxsc_alloc_entry(_adapter *adapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct sta_info *psta = prframe->u.hdr.psta;
struct core_rxsc_entry *rxsc_entry = NULL;
u8 rxsc_idx, cnt = 0;
if (core_rxsc_check_alloc(adapter, prframe)!=_SUCCESS)
return NULL;
rxsc_idx = psta->rxsc_idx_new;
for (cnt=0; cnt<NUM_RXSC_ENTRY; cnt++) {
rxsc_idx = rxsc_idx%NUM_RXSC_ENTRY;
if (psta->rxsc_entry[rxsc_idx].status != RXSC_ENTRY_APPLYING)
break;
rxsc_idx++;
}
rxsc_entry = &psta->rxsc_entry[rxsc_idx];
if (rxsc_entry->status == RXSC_ENTRY_APPLYING)
return NULL;
rxsc_entry->status = RXSC_ENTRY_VALID;
psta->rxsc_idx_new = (rxsc_idx + 1) % NUM_RXSC_ENTRY;
return rxsc_entry;
}
sint core_rxsc_get_entry(_adapter *adapter, union recv_frame *prframe)
{
struct sta_info *psta = NULL;
u8 *pframe = prframe->u.hdr.rx_data;
u8 *lhs, *rhs = NULL;
u8 idx = 0;
struct core_rxsc_entry *rxsc_entry = NULL;
if (GetFrameType(pframe)!=WIFI_DATA_TYPE)
return _FAIL;
psta = rtw_get_stainfo(&adapter->stapriv, get_addr2_ptr(pframe));
if (!psta)
return _FAIL;
lhs = GetAddr1Ptr(pframe);
for (idx = 0; idx < NUM_RXSC_ENTRY; idx++) {
rxsc_entry = &psta->rxsc_entry[(psta->rxsc_idx_cached + idx) % NUM_RXSC_ENTRY];
if (rxsc_entry->status == RXSC_ENTRY_INVALID)
continue;
rhs = (u8*)rxsc_entry->rxsc_wlanhdr.addr1;
#if 0
DBGP("(A1)lhs=%pM rhs=%pM isEqual=%d %d\n", lhs, rhs, is_equal_mac_addr(lhs,rhs), is_equal_mac_addr(lhs+1,rhs));
DBGP("(A2)lhs=%pM rhs=%pM\n", lhs+6, rhs+6);
DBGP("(A3)lhs=%pM rhs=%pM\n", lhs+12, rhs+12);
DBGP("rxsc_payload_offset=%d \n", rxsc_entry->rxsc_payload_offset);
DBGP("(LLC)lhs=%pM rhs=%pM\n",
&pframe[rxsc_entry->rxsc_payload_offset+(sizeof(struct ethhdr))-SNAP_SIZE-2], &rtw_rfc1042_header);
DBGP("(eth_type)lhs=0x%x rhs=0x%x\n",
*(unsigned short *)(&pframe[rxsc_entry->rxsc_payload_offset+(ETH_ALEN*2)]), *(unsigned short *)(&rxsc_entry->rxsc_ethhdr.h_proto));
DBGP("%d %d %d %d %d \n",
is_equal_mac_addr(lhs,rhs),
is_equal_mac_addr(lhs+6,rhs+6),
is_equal_mac_addr(lhs+12,rhs+12),
!memcmp(&pframe[rxsc_entry->rxsc_payload_offset+(sizeof(struct ethhdr))-SNAP_SIZE-2], &rtw_rfc1042_header, ETH_ALEN),
(*(unsigned short *)(&pframe[rxsc_entry->rxsc_payload_offset+(ETH_ALEN*2)]) == *(unsigned short *)(&rxsc_entry->rxsc_ethhdr.h_proto))
);
#endif
if (is_equal_mac_addr(lhs,rhs) &&
is_equal_mac_addr(lhs + 6, rhs + 6) &&
is_equal_mac_addr(lhs + 12, rhs + 12) &&
!memcmp(&pframe[rxsc_entry->rxsc_payload_offset+(sizeof(struct ethhdr)) - SNAP_SIZE - 2], &rtw_rfc1042_header, ETH_ALEN) &&
(*(unsigned short *)(&pframe[rxsc_entry->rxsc_payload_offset+(ETH_ALEN * 2)]) == *(unsigned short *)(&rxsc_entry->rxsc_ethhdr.h_proto))) {
prframe->u.hdr.psta = psta;
prframe->u.hdr.rxsc_entry = rxsc_entry;
psta->rxsc_idx_cached = idx;
return _SUCCESS;
}
}
return _FAIL;
}
s32 core_rxsc_apply_check(_adapter *adapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct core_rxsc_entry *rxsc_entry = NULL;
if (!adapter->enable_rxsc)
return CORE_RX_CONTINUE;
if (core_rxsc_get_entry(adapter, prframe) != _SUCCESS)
return CORE_RX_CONTINUE;
rxsc_entry = prframe->u.hdr.rxsc_entry;
rxsc_entry->status = RXSC_ENTRY_APPLYING;
wmb();
_rtw_memcpy(pattrib, &rxsc_entry->rxsc_attrib, sizeof(rxsc_entry->rxsc_attrib));
wmb();
rxsc_entry->status = RXSC_ENTRY_VALID;
return CORE_RX_GO_SHORTCUT;
}
s32 core_rxsc_apply_shortcut(_adapter *adapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct core_rxsc_entry *rxsc_entry = prframe->u.hdr.rxsc_entry;
struct sta_info *psta = prframe->u.hdr.psta;
u8 *pframe = prframe->u.hdr.rx_data;
u8 *ptr = NULL;
/* Shortcut of validate_recv_frame */
if (pattrib->encrypt == _AES_) {
if (pattrib->qos)
pattrib->priority = GetPriority((pframe + WLAN_HDR_A3_LEN));
else
pattrib->priority = 0;
if (!IS_MCAST(pattrib->ra)) {
#ifdef CONFIG_RECV_REORDERING_CTRL
if (pattrib->qos)
prframe->u.hdr.preorder_ctrl = &psta->recvreorder_ctrl[pattrib->priority];
#endif
if (recv_ucast_pn_decache(prframe) == _FAIL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recv_ucast_pn_decache return _FAIL for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->cmn.mac_addr));
#endif
return CORE_RX_DROP;
}
} else {
if (recv_bcast_pn_decache(prframe) == _FAIL) {
#ifdef DBG_RX_DROP_FRAME
RTW_INFO("DBG_RX_DROP_FRAME "FUNC_ADPT_FMT" recv_bcast_pn_decache return _FAIL for sta="MAC_FMT"\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(psta->cmn.mac_addr));
#endif
return CORE_RX_DROP;
}
}
}
process_pwrbit_data(adapter, prframe, psta);
if ((get_frame_sub_type(pframe) & WIFI_QOS_DATA_TYPE) == WIFI_QOS_DATA_TYPE)
process_wmmps_data(adapter, prframe, psta);
/* Shortcut of rtw_core_rx_data_pre_process */
count_rx_stats(adapter, prframe, NULL);
/* Shortcut of rtw_core_rx_data_post_process */
/* 802.11 -> 802.3 */
if (rxsc_entry->rxsc_trim_pad)
recvframe_pull_tail(prframe, rxsc_entry->rxsc_trim_pad);
ptr = recvframe_pull(prframe, rxsc_entry->rxsc_payload_offset);
_rtw_memcpy(ptr, (u8 *)(&rxsc_entry->rxsc_ethhdr), sizeof(rxsc_entry->rxsc_ethhdr));
rtw_rframe_set_os_pkt(prframe);
/* Packet forward to OS */
rtw_os_recv_indicate_pkt(adapter, prframe->u.hdr.pkt, prframe);
prframe->u.hdr.pkt = NULL;
rtw_free_recvframe(prframe);
#ifdef RTW_PHL_DBG_CMD
adapter->core_logs.rxCnt_data_shortcut++;
#endif
return CORE_RX_DONE;
}
void core_rxsc_clear_entry(_adapter *adapter, struct sta_info *psta)
{
u32 idx = 0;
for (idx=0; idx<NUM_RXSC_ENTRY; idx++)
psta->rxsc_entry[idx].status = RXSC_ENTRY_INVALID;
}
#endif /* CONFIG_RTW_CORE_RXSC */
|
2301_81045437/rtl8852be
|
core/rtw_recv_shortcut.c
|
C
|
agpl-3.0
| 7,988
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_RF_C_
#include <drv_types.h>
u8 center_ch_2g[CENTER_CH_2G_NUM] = {
/* G00 */1, 2,
/* G01 */3, 4, 5,
/* G02 */6, 7, 8,
/* G03 */9, 10, 11,
/* G04 */12, 13,
/* G05 */14
};
#define ch_to_cch_2g_idx(ch) ((ch) - 1)
u8 center_ch_2g_40m[CENTER_CH_2G_40M_NUM] = {
3,
4,
5,
6,
7,
8,
9,
10,
11,
};
u8 op_chs_of_cch_2g_40m[CENTER_CH_2G_40M_NUM][2] = {
{1, 5}, /* 3 */
{2, 6}, /* 4 */
{3, 7}, /* 5 */
{4, 8}, /* 6 */
{5, 9}, /* 7 */
{6, 10}, /* 8 */
{7, 11}, /* 9 */
{8, 12}, /* 10 */
{9, 13}, /* 11 */
};
u8 center_ch_5g_all[CENTER_CH_5G_ALL_NUM] = {
/* G00 */36, 38, 40,
42,
/* G01 */44, 46, 48,
/* 50, */
/* G02 */52, 54, 56,
58,
/* G03 */60, 62, 64,
/* G04 */100, 102, 104,
106,
/* G05 */108, 110, 112,
/* 114, */
/* G06 */116, 118, 120,
122,
/* G07 */124, 126, 128,
/* G08 */132, 134, 136,
138,
/* G09 */140, 142, 144,
/* G10 */149, 151, 153,
155,
/* G11 */157, 159, 161,
/* 163, */
/* G12 */165, 167, 169,
171,
/* G13 */173, 175, 177
};
u8 center_ch_5g_20m[CENTER_CH_5G_20M_NUM] = {
/* G00 */36, 40,
/* G01 */44, 48,
/* G02 */52, 56,
/* G03 */60, 64,
/* G04 */100, 104,
/* G05 */108, 112,
/* G06 */116, 120,
/* G07 */124, 128,
/* G08 */132, 136,
/* G09 */140, 144,
/* G10 */149, 153,
/* G11 */157, 161,
/* G12 */165, 169,
/* G13 */173, 177
};
#define ch_to_cch_5g_20m_idx(ch) \
( \
((ch) >= 36 && (ch) <= 64) ? (((ch) - 36) >> 2) : \
((ch) >= 100 && (ch) <= 144) ? 8 + (((ch) - 100) >> 2) : \
((ch) >= 149 && (ch) <= 177) ? 20 + (((ch) - 149) >> 2) : 255 \
)
u8 center_ch_5g_40m[CENTER_CH_5G_40M_NUM] = {
/* G00 */38,
/* G01 */46,
/* G02 */54,
/* G03 */62,
/* G04 */102,
/* G05 */110,
/* G06 */118,
/* G07 */126,
/* G08 */134,
/* G09 */142,
/* G10 */151,
/* G11 */159,
/* G12 */167,
/* G13 */175
};
u8 center_ch_5g_20m_40m[CENTER_CH_5G_20M_NUM + CENTER_CH_5G_40M_NUM] = {
/* G00 */36, 38, 40,
/* G01 */44, 46, 48,
/* G02 */52, 54, 56,
/* G03 */60, 62, 64,
/* G04 */100, 102, 104,
/* G05 */108, 110, 112,
/* G06 */116, 118, 120,
/* G07 */124, 126, 128,
/* G08 */132, 134, 136,
/* G09 */140, 142, 144,
/* G10 */149, 151, 153,
/* G11 */157, 159, 161,
/* G12 */165, 167, 169,
/* G13 */173, 175, 177
};
u8 op_chs_of_cch_5g_40m[CENTER_CH_5G_40M_NUM][2] = {
{36, 40}, /* 38 */
{44, 48}, /* 46 */
{52, 56}, /* 54 */
{60, 64}, /* 62 */
{100, 104}, /* 102 */
{108, 112}, /* 110 */
{116, 120}, /* 118 */
{124, 128}, /* 126 */
{132, 136}, /* 134 */
{140, 144}, /* 142 */
{149, 153}, /* 151 */
{157, 161}, /* 159 */
{165, 169}, /* 167 */
{173, 177}, /* 175 */
};
u8 center_ch_5g_80m[CENTER_CH_5G_80M_NUM] = {
/* G00 ~ G01*/42,
/* G02 ~ G03*/58,
/* G04 ~ G05*/106,
/* G06 ~ G07*/122,
/* G08 ~ G09*/138,
/* G10 ~ G11*/155,
/* G12 ~ G13*/171
};
u8 op_chs_of_cch_5g_80m[CENTER_CH_5G_80M_NUM][4] = {
{36, 40, 44, 48}, /* 42 */
{52, 56, 60, 64}, /* 58 */
{100, 104, 108, 112}, /* 106 */
{116, 120, 124, 128}, /* 122 */
{132, 136, 140, 144}, /* 138 */
{149, 153, 157, 161}, /* 155 */
{165, 169, 173, 177}, /* 171 */
};
u8 center_ch_5g_160m[CENTER_CH_5G_160M_NUM] = {
/* G00 ~ G03*/50,
/* G04 ~ G07*/114,
/* G10 ~ G13*/163
};
u8 op_chs_of_cch_5g_160m[CENTER_CH_5G_160M_NUM][8] = {
{36, 40, 44, 48, 52, 56, 60, 64}, /* 50 */
{100, 104, 108, 112, 116, 120, 124, 128}, /* 114 */
{149, 153, 157, 161, 165, 169, 173, 177}, /* 163 */
};
struct center_chs_ent_t {
u8 ch_num;
u8 *chs;
};
struct center_chs_ent_t center_chs_2g_by_bw[] = {
{CENTER_CH_2G_NUM, center_ch_2g},
{CENTER_CH_2G_40M_NUM, center_ch_2g_40m},
};
struct center_chs_ent_t center_chs_5g_by_bw[] = {
{CENTER_CH_5G_20M_NUM, center_ch_5g_20m},
{CENTER_CH_5G_40M_NUM, center_ch_5g_40m},
{CENTER_CH_5G_80M_NUM, center_ch_5g_80m},
{CENTER_CH_5G_160M_NUM, center_ch_5g_160m},
};
/*
* Get center channel of smaller bandwidth by @param cch, @param bw, @param offset
* @cch: the given center channel
* @bw: the given bandwidth
* @offset: the given primary SC offset of the given bandwidth
*
* return center channel of smaller bandiwdth if valid, or 0
*/
u8 rtw_get_scch_by_cch_offset(u8 cch, u8 bw, u8 offset)
{
u8 t_cch = 0;
if (bw == CHANNEL_WIDTH_20) {
t_cch = cch;
goto exit;
}
if (offset == CHAN_OFFSET_NO_EXT) {
rtw_warn_on(1);
goto exit;
}
/* 2.4G, 40MHz */
if (cch >= 3 && cch <= 11 && bw == CHANNEL_WIDTH_40) {
t_cch = (offset == CHAN_OFFSET_LOWER) ? cch + 2 : cch - 2;
goto exit;
}
/* 5G, 160MHz */
if (cch >= 50 && cch <= 163 && bw == CHANNEL_WIDTH_160) {
t_cch = (offset == CHAN_OFFSET_LOWER) ? cch + 8 : cch - 8;
goto exit;
/* 5G, 80MHz */
} else if (cch >= 42 && cch <= 171 && bw == CHANNEL_WIDTH_80) {
t_cch = (offset == CHAN_OFFSET_LOWER) ? cch + 4 : cch - 4;
goto exit;
/* 5G, 40MHz */
} else if (cch >= 38 && cch <= 175 && bw == CHANNEL_WIDTH_40) {
t_cch = (offset == CHAN_OFFSET_LOWER) ? cch + 2 : cch - 2;
goto exit;
} else {
rtw_warn_on(1);
goto exit;
}
exit:
return t_cch;
}
struct op_chs_ent_t {
u8 ch_num;
u8 *chs;
};
struct op_chs_ent_t op_chs_of_cch_2g_by_bw[] = {
{1, center_ch_2g},
{2, (u8 *)op_chs_of_cch_2g_40m},
};
struct op_chs_ent_t op_chs_of_cch_5g_by_bw[] = {
{1, center_ch_5g_20m},
{2, (u8 *)op_chs_of_cch_5g_40m},
{4, (u8 *)op_chs_of_cch_5g_80m},
{8, (u8 *)op_chs_of_cch_5g_160m},
};
inline u8 center_chs_2g_num(u8 bw)
{
if (bw > CHANNEL_WIDTH_40)
return 0;
return center_chs_2g_by_bw[bw].ch_num;
}
inline u8 center_chs_2g(u8 bw, u8 id)
{
if (bw > CHANNEL_WIDTH_40)
return 0;
if (id >= center_chs_2g_num(bw))
return 0;
return center_chs_2g_by_bw[bw].chs[id];
}
inline u8 center_chs_5g_num(u8 bw)
{
if (bw > CHANNEL_WIDTH_160)
return 0;
return center_chs_5g_by_bw[bw].ch_num;
}
inline u8 center_chs_5g(u8 bw, u8 id)
{
if (bw > CHANNEL_WIDTH_160)
return 0;
if (id >= center_chs_5g_num(bw))
return 0;
return center_chs_5g_by_bw[bw].chs[id];
}
/*
* Get available op channels by @param cch, @param bw
* @cch: the given center channel
* @bw: the given bandwidth
* @op_chs: the pointer to return pointer of op channel array
* @op_ch_num: the pointer to return pointer of op channel number
*
* return valid (1) or not (0)
*/
u8 rtw_get_op_chs_by_cch_bw(u8 cch, u8 bw, u8 **op_chs, u8 *op_ch_num)
{
int i;
struct center_chs_ent_t *c_chs_ent = NULL;
struct op_chs_ent_t *op_chs_ent = NULL;
u8 valid = 1;
if (cch <= 14
&& bw <= CHANNEL_WIDTH_40
) {
c_chs_ent = ¢er_chs_2g_by_bw[bw];
op_chs_ent = &op_chs_of_cch_2g_by_bw[bw];
} else if (cch >= 36 && cch <= 177
&& bw <= CHANNEL_WIDTH_160
) {
c_chs_ent = ¢er_chs_5g_by_bw[bw];
op_chs_ent = &op_chs_of_cch_5g_by_bw[bw];
} else {
valid = 0;
goto exit;
}
for (i = 0; i < c_chs_ent->ch_num; i++)
if (cch == *(c_chs_ent->chs + i))
break;
if (i == c_chs_ent->ch_num) {
valid = 0;
goto exit;
}
*op_chs = op_chs_ent->chs + op_chs_ent->ch_num * i;
*op_ch_num = op_chs_ent->ch_num;
exit:
return valid;
}
u8 rtw_get_offset_by_chbw(u8 ch, u8 bw, u8 *r_offset)
{
u8 valid = 1;
u8 offset = CHAN_OFFSET_NO_EXT;
if (bw == CHANNEL_WIDTH_20)
goto exit;
if (bw >= CHANNEL_WIDTH_80 && ch <= 14) {
valid = 0;
goto exit;
}
if (ch >= 1 && ch <= 4)
offset = CHAN_OFFSET_UPPER;
else if (ch >= 5 && ch <= 9) {
if (*r_offset == CHAN_OFFSET_UPPER || *r_offset == CHAN_OFFSET_LOWER)
offset = *r_offset; /* both lower and upper is valid, obey input value */
else
offset = CHAN_OFFSET_LOWER; /* default use upper */
} else if (ch >= 10 && ch <= 13)
offset = CHAN_OFFSET_LOWER;
else if (ch == 14) {
valid = 0; /* ch14 doesn't support 40MHz bandwidth */
goto exit;
} else if (ch >= 36 && ch <= 177) {
switch (ch) {
case 36:
case 44:
case 52:
case 60:
case 100:
case 108:
case 116:
case 124:
case 132:
case 140:
case 149:
case 157:
case 165:
case 173:
offset = CHAN_OFFSET_UPPER;
break;
case 40:
case 48:
case 56:
case 64:
case 104:
case 112:
case 120:
case 128:
case 136:
case 144:
case 153:
case 161:
case 169:
case 177:
offset = CHAN_OFFSET_LOWER;
break;
default:
valid = 0;
break;
}
} else
valid = 0;
exit:
if (valid && r_offset)
*r_offset = offset;
return valid;
}
u8 rtw_get_center_ch(u8 ch, u8 bw, u8 offset)
{
return rtw_phl_get_center_ch(ch, bw, offset);
}
u8 rtw_get_ch_group(u8 ch, u8 *group, u8 *cck_group)
{
enum band_type band = BAND_MAX;
s8 gp = -1, cck_gp = -1;
if (ch <= 14) {
band = BAND_ON_24G;
if (1 <= ch && ch <= 2)
gp = 0;
else if (3 <= ch && ch <= 5)
gp = 1;
else if (6 <= ch && ch <= 8)
gp = 2;
else if (9 <= ch && ch <= 11)
gp = 3;
else if (12 <= ch && ch <= 14)
gp = 4;
else
band = BAND_MAX;
if (ch == 14)
cck_gp = 5;
else
cck_gp = gp;
} else {
band = BAND_ON_5G;
if (36 <= ch && ch <= 42)
gp = 0;
else if (44 <= ch && ch <= 48)
gp = 1;
else if (50 <= ch && ch <= 58)
gp = 2;
else if (60 <= ch && ch <= 64)
gp = 3;
else if (100 <= ch && ch <= 106)
gp = 4;
else if (108 <= ch && ch <= 114)
gp = 5;
else if (116 <= ch && ch <= 122)
gp = 6;
else if (124 <= ch && ch <= 130)
gp = 7;
else if (132 <= ch && ch <= 138)
gp = 8;
else if (140 <= ch && ch <= 144)
gp = 9;
else if (149 <= ch && ch <= 155)
gp = 10;
else if (157 <= ch && ch <= 161)
gp = 11;
else if (165 <= ch && ch <= 171)
gp = 12;
else if (173 <= ch && ch <= 177)
gp = 13;
else
band = BAND_MAX;
}
if (band == BAND_MAX
|| (band == BAND_ON_24G && cck_gp == -1)
|| gp == -1
) {
RTW_WARN("%s invalid channel:%u", __func__, ch);
rtw_warn_on(1);
goto exit;
}
if (group)
*group = gp;
if (cck_group && band == BAND_ON_24G)
*cck_group = cck_gp;
exit:
return band;
}
#if CONFIG_IEEE80211_BAND_6GHZ
int rtw_6gch2freq(int chan)
{
if (chan >= 1 && chan <= 253)
return 5950 + chan * 5;
return 0; /* not supported */
}
#endif
int rtw_ch2freq(int chan)
{
/* see 802.11 17.3.8.3.2 and Annex J
* there are overlapping channel numbers in 5GHz and 2GHz bands */
/*
* RTK: don't consider the overlapping channel numbers: 5G channel <= 14,
* because we don't support it. simply judge from channel number
*/
if (chan >= 1 && chan <= 14) {
if (chan == 14)
return 2484;
else if (chan < 14)
return 2407 + chan * 5;
} else if (chan >= 36 && chan <= 177)
return 5000 + chan * 5;
return 0; /* not supported */
}
int rtw_ch2freq_by_band(enum band_type band, int ch)
{
#if CONFIG_IEEE80211_BAND_6GHZ
if (band == BAND_ON_6G)
return rtw_6gch2freq(ch);
else
#endif
return rtw_ch2freq(ch);
}
int rtw_freq2ch(int freq)
{
/* see 802.11 17.3.8.3.2 and Annex J */
if (freq == 2484)
return 14;
else if (freq < 2484)
return (freq - 2407) / 5;
else if (freq >= 4910 && freq <= 4980)
return (freq - 4000) / 5;
else if (freq >= 5000 && freq < 5950)
return (freq - 5000) / 5;
else if (freq >= 5950 && freq <= 7215)
return (freq - 5950) / 5;
else if (freq >= 58320 && freq <= 64800)
return (freq - 56160) / 2160;
else
return 0;
}
enum band_type rtw_freq2band(int freq)
{
if (freq <= 2484)
return BAND_ON_24G;
else if (freq >= 5000 && freq < 5950)
return BAND_ON_5G;
#if CONFIG_IEEE80211_BAND_6GHZ
else if (freq >= 5950 && freq <= 7215)
return BAND_ON_6G;
#endif
else
return BAND_MAX;
}
bool rtw_freq_consecutive(int a, int b)
{
enum band_type band_a, band_b;
band_a = rtw_freq2band(a);
if (band_a == BAND_MAX)
return 0;
band_b = rtw_freq2band(b);
if (band_b == BAND_MAX || band_a != band_b)
return 0;
switch (band_a) {
case BAND_ON_24G:
return rtw_abs(a - b) == 5;
case BAND_ON_5G:
#if CONFIG_IEEE80211_BAND_6GHZ
case BAND_ON_6G:
#endif
return rtw_abs(a - b) == 20;
default:
return 0;
}
}
bool rtw_chbw_to_freq_range(u8 ch, u8 bw, u8 offset, u32 *hi, u32 *lo)
{
u8 c_ch;
u32 freq;
u32 hi_ret = 0, lo_ret = 0;
bool valid = _FALSE;
if (hi)
*hi = 0;
if (lo)
*lo = 0;
c_ch = rtw_phl_get_center_ch(ch, bw, offset);
freq = rtw_ch2freq(c_ch);
if (!freq) {
rtw_warn_on(1);
goto exit;
}
if (bw == CHANNEL_WIDTH_160) {
hi_ret = freq + 80;
lo_ret = freq - 80;
} else if (bw == CHANNEL_WIDTH_80) {
hi_ret = freq + 40;
lo_ret = freq - 40;
} else if (bw == CHANNEL_WIDTH_40) {
hi_ret = freq + 20;
lo_ret = freq - 20;
} else if (bw == CHANNEL_WIDTH_20) {
hi_ret = freq + 10;
lo_ret = freq - 10;
} else
rtw_warn_on(1);
if (hi)
*hi = hi_ret;
if (lo)
*lo = lo_ret;
valid = _TRUE;
exit:
return valid;
}
const char *const _ch_width_str[CHANNEL_WIDTH_MAX] = {
"20MHz",
"40MHz",
"80MHz",
"160MHz",
"80_80MHz",
"5MHz",
"10MHz",
};
const u8 _ch_width_to_bw_cap[CHANNEL_WIDTH_MAX] = {
BW_CAP_20M,
BW_CAP_40M,
BW_CAP_80M,
BW_CAP_160M,
BW_CAP_80_80M,
BW_CAP_5M,
BW_CAP_10M,
};
const char *const _rtw_band_str[] = {
[BAND_ON_24G] = "2.4G",
[BAND_ON_5G] = "5G",
[BAND_ON_6G] = "6G",
[BAND_MAX] = "BAND_MAX",
};
const u8 _band_to_band_cap[] = {
[BAND_ON_24G] = BAND_CAP_2G,
[BAND_ON_5G] = BAND_CAP_5G,
[BAND_ON_6G] = BAND_CAP_6G,
[BAND_MAX] = 0,
};
const char *const _opc_bw_str[OPC_BW_NUM] = {
"20M ", /* OPC_BW20 */
"40M+", /* OPC_BW40PLUS */
"40M-", /* OPC_BW40MINUS */
"80M ", /* OPC_BW80 */
"160M ", /* OPC_BW160 */
"80+80M ", /* OPC_BW80P80 */
};
const u8 _opc_bw_to_ch_width[OPC_BW_NUM] = {
CHANNEL_WIDTH_20, /* OPC_BW20 */
CHANNEL_WIDTH_40, /* OPC_BW40PLUS */
CHANNEL_WIDTH_40, /* OPC_BW40MINUS */
CHANNEL_WIDTH_80, /* OPC_BW80 */
CHANNEL_WIDTH_160, /* OPC_BW160 */
CHANNEL_WIDTH_80_80, /* OPC_BW80P80 */
};
/* global operating class database */
struct op_class_t {
u8 class_id;
enum band_type band;
enum opc_bw bw;
u8 *len_ch_attr;
};
#define OPC_CH_LIST_LEN(_opc) (_opc.len_ch_attr[0])
#define OPC_CH_LIST_CH(_opc, _i) (_opc.len_ch_attr[_i + 1])
#define OP_CLASS_ENT(_class, _band, _bw, _len, arg...) \
{.class_id = _class, .band = _band, .bw = _bw, .len_ch_attr = (uint8_t[_len + 1]) {_len, ##arg},}
/* 802.11-2020, 802.11ax-2021 Table E-4, partial */
static const struct op_class_t global_op_class[] = {
/* 2G ch1~13, 20M */
OP_CLASS_ENT(81, BAND_ON_24G, OPC_BW20, 13, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13),
/* 2G ch14, 20M */
OP_CLASS_ENT(82, BAND_ON_24G, OPC_BW20, 1, 14),
/* 2G, 40M */
OP_CLASS_ENT(83, BAND_ON_24G, OPC_BW40PLUS, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9),
OP_CLASS_ENT(84, BAND_ON_24G, OPC_BW40MINUS, 9, 5, 6, 7, 8, 9, 10, 11, 12, 13),
/* 5G band 1, 20M & 40M */
OP_CLASS_ENT(115, BAND_ON_5G, OPC_BW20, 4, 36, 40, 44, 48),
OP_CLASS_ENT(116, BAND_ON_5G, OPC_BW40PLUS, 2, 36, 44),
OP_CLASS_ENT(117, BAND_ON_5G, OPC_BW40MINUS, 2, 40, 48),
/* 5G band 2, 20M & 40M */
OP_CLASS_ENT(118, BAND_ON_5G, OPC_BW20, 4, 52, 56, 60, 64),
OP_CLASS_ENT(119, BAND_ON_5G, OPC_BW40PLUS, 2, 52, 60),
OP_CLASS_ENT(120, BAND_ON_5G, OPC_BW40MINUS, 2, 56, 64),
/* 5G band 3, 20M & 40M */
OP_CLASS_ENT(121, BAND_ON_5G, OPC_BW20, 12, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144),
OP_CLASS_ENT(122, BAND_ON_5G, OPC_BW40PLUS, 6, 100, 108, 116, 124, 132, 140),
OP_CLASS_ENT(123, BAND_ON_5G, OPC_BW40MINUS, 6, 104, 112, 120, 128, 136, 144),
/* 5G band 4, 20M & 40M */
OP_CLASS_ENT(124, BAND_ON_5G, OPC_BW20, 4, 149, 153, 157, 161),
OP_CLASS_ENT(125, BAND_ON_5G, OPC_BW20, 8, 149, 153, 157, 161, 165, 169, 173, 177),
OP_CLASS_ENT(126, BAND_ON_5G, OPC_BW40PLUS, 4, 149, 157, 165, 173),
OP_CLASS_ENT(127, BAND_ON_5G, OPC_BW40MINUS, 4, 153, 161, 169, 177),
/* 5G, 80M & 160M */
OP_CLASS_ENT(128, BAND_ON_5G, OPC_BW80, 28, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165, 169, 173, 177),
OP_CLASS_ENT(129, BAND_ON_5G, OPC_BW160, 24, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 149, 153, 157, 161, 165, 169, 173, 177),
#if 0 /* TODO */
/* 5G, 80+80M */
OP_CLASS_ENT(130, BAND_ON_5G, OPC_BW80P80, 28, 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165, 169, 173, 177),
#endif
};
static const int global_op_class_num = sizeof(global_op_class) / sizeof(struct op_class_t);
static const struct op_class_t *get_global_op_class_by_id(u8 gid)
{
int i;
for (i = 0; i < global_op_class_num; i++)
if (global_op_class[i].class_id == gid)
break;
return i < global_op_class_num ? &global_op_class[i] : NULL;
}
bool is_valid_global_op_class_id(u8 gid)
{
return get_global_op_class_by_id(gid) ? 1 : 0;
}
static bool is_valid_global_op_class_ch(const struct op_class_t *opc, u8 ch)
{
int array_idx;
int i;
if (opc < global_op_class
|| (((u8 *)opc) - ((u8 *)global_op_class)) % sizeof(struct op_class_t)
) {
RTW_ERR("Invalid opc pointer:%p (global_op_class:%p, sizeof(struct op_class_t):%zu, %zu)\n"
, opc, global_op_class, sizeof(struct op_class_t), (((u8 *)opc) - ((u8 *)global_op_class)) % sizeof(struct op_class_t));
return 0;
}
array_idx = (((u8 *)opc) - ((u8 *)global_op_class)) / sizeof(struct op_class_t);
for (i = 0; i < OPC_CH_LIST_LEN(global_op_class[array_idx]); i++)
if (OPC_CH_LIST_CH(global_op_class[array_idx], i) == ch)
break;
return i < OPC_CH_LIST_LEN(global_op_class[array_idx]);
}
static enum opc_bw get_global_opc_bw_by_id(u8 gid)
{
int i;
for (i = 0; i < global_op_class_num; i++)
if (global_op_class[i].class_id == gid)
break;
return i < global_op_class_num ? global_op_class[i].bw : OPC_BW_NUM;
}
/* -2: logic error, -1: error, 0: is already BW20 */
s16 get_sub_op_class(u8 gid, u8 ch)
{
const struct op_class_t *opc = get_global_op_class_by_id(gid);
int i;
enum channel_width bw;
if (!opc)
return -1;
if (!is_valid_global_op_class_ch(opc, ch)) {
return -1;
}
if (opc->bw == OPC_BW20)
return 0;
bw = opc_bw_to_ch_width(opc->bw);
for (i = 0; i < global_op_class_num; i++) {
if (bw != opc_bw_to_ch_width(global_op_class[i].bw) + 1)
continue;
if (is_valid_global_op_class_ch(&global_op_class[i], ch))
break;
}
return i < global_op_class_num ? global_op_class[i].class_id : -2;
}
static void dump_op_class_ch_title(void *sel)
{
RTW_PRINT_SEL(sel, "%-5s %-4s %-7s ch_list\n"
, "class", "band", "bw");
}
static void dump_global_op_class_ch_single(void *sel, u8 gid)
{
u8 i;
char buf[100];
char *pos = buf;
for (i = 0; i < OPC_CH_LIST_LEN(global_op_class[gid]); i++)
pos += snprintf(pos, 100 - (pos - buf), " %u", OPC_CH_LIST_CH(global_op_class[gid], i));
RTW_PRINT_SEL(sel, "%5u %4s %7s%s\n"
, global_op_class[gid].class_id
, band_str(global_op_class[gid].band)
, opc_bw_str(global_op_class[gid].bw), buf);
}
#ifdef CONFIG_RTW_DEBUG
static bool dbg_global_op_class_validate(u8 gid)
{
u8 i;
u8 ch, bw, offset, cch;
bool ret = 1;
switch (global_op_class[gid].bw) {
case OPC_BW20:
bw = CHANNEL_WIDTH_20;
offset = CHAN_OFFSET_NO_EXT;
break;
case OPC_BW40PLUS:
bw = CHANNEL_WIDTH_40;
offset = CHAN_OFFSET_UPPER;
break;
case OPC_BW40MINUS:
bw = CHANNEL_WIDTH_40;
offset = CHAN_OFFSET_LOWER;
break;
case OPC_BW80:
bw = CHANNEL_WIDTH_80;
offset = CHAN_OFFSET_NO_EXT;
break;
case OPC_BW160:
bw = CHANNEL_WIDTH_160;
offset = CHAN_OFFSET_NO_EXT;
break;
case OPC_BW80P80: /* TODO */
default:
RTW_ERR("%s class:%u unsupported opc_bw:%u\n"
, __func__, global_op_class[gid].class_id, global_op_class[gid].bw);
ret = 0;
goto exit;
}
for (i = 0; i < OPC_CH_LIST_LEN(global_op_class[gid]); i++) {
u8 *op_chs;
u8 op_ch_num;
u8 k;
ch = OPC_CH_LIST_CH(global_op_class[gid], i);
cch = rtw_get_center_ch(ch ,bw, offset);
if (!cch) {
RTW_ERR("%s can't get cch from class:%u ch:%u\n"
, __func__, global_op_class[gid].class_id, ch);
ret = 0;
continue;
}
if (!rtw_get_op_chs_by_cch_bw(cch, bw, &op_chs, &op_ch_num)) {
RTW_ERR("%s can't get op chs from class:%u cch:%u\n"
, __func__, global_op_class[gid].class_id, cch);
ret = 0;
continue;
}
for (k = 0; k < op_ch_num; k++) {
if (*(op_chs + k) == ch)
break;
}
if (k >= op_ch_num) {
RTW_ERR("%s can't get ch:%u from op_chs class:%u cch:%u\n"
, __func__, ch, global_op_class[i].class_id, cch);
ret = 0;
}
}
exit:
return ret;
}
#endif /* CONFIG_RTW_DEBUG */
void dump_global_op_class(void *sel)
{
u8 i;
dump_op_class_ch_title(sel);
for (i = 0; i < global_op_class_num; i++)
dump_global_op_class_ch_single(sel, i);
}
u8 rtw_get_op_class_by_chbw(u8 ch, u8 bw, u8 offset)
{
enum band_type band = BAND_MAX;
int i;
u8 gid = 0; /* invalid */
if (rtw_is_2g_ch(ch))
band = BAND_ON_24G;
else if (rtw_is_5g_ch(ch))
band = BAND_ON_5G;
else
goto exit;
switch (bw) {
case CHANNEL_WIDTH_20:
case CHANNEL_WIDTH_40:
case CHANNEL_WIDTH_80:
case CHANNEL_WIDTH_160:
#if 0 /* TODO */
case CHANNEL_WIDTH_80_80:
#endif
break;
default:
goto exit;
}
for (i = 0; i < global_op_class_num; i++) {
if (band != global_op_class[i].band)
continue;
if (opc_bw_to_ch_width(global_op_class[i].bw) != bw)
continue;
if ((global_op_class[i].bw == OPC_BW40PLUS
&& offset != CHAN_OFFSET_UPPER)
|| (global_op_class[i].bw == OPC_BW40MINUS
&& offset != CHAN_OFFSET_LOWER)
)
continue;
if (is_valid_global_op_class_ch(&global_op_class[i], ch))
goto get;
}
get:
if (i < global_op_class_num) {
#if 0 /* TODO */
if (bw == CHANNEL_WIDTH_80_80) {
/* search another ch */
if (!is_valid_global_op_class_ch(&global_op_class[i], ch2))
goto exit;
}
#endif
gid = global_op_class[i].class_id;
}
exit:
return gid;
}
u8 rtw_get_bw_offset_by_op_class_ch(u8 gid, u8 ch, u8 *bw, u8 *offset)
{
enum opc_bw opc_bw;
u8 valid = 0;
int i;
opc_bw = get_global_opc_bw_by_id(gid);
if (opc_bw == OPC_BW_NUM)
goto exit;
*bw = opc_bw_to_ch_width(opc_bw);
if (opc_bw == OPC_BW40PLUS)
*offset = CHAN_OFFSET_UPPER;
else if (opc_bw == OPC_BW40MINUS)
*offset = CHAN_OFFSET_LOWER;
if (rtw_get_offset_by_chbw(ch, *bw, offset))
valid = 1;
exit:
return valid;
}
static struct op_class_pref_t *opc_pref_alloc(u8 class_id)
{
int i, j;
struct op_class_pref_t *opc_pref = NULL;
for (i = 0; i < global_op_class_num; i++)
if (global_op_class[i].class_id == class_id)
break;
if (i >= global_op_class_num)
goto exit;
opc_pref = rtw_zmalloc(sizeof(*opc_pref));
if (!opc_pref)
goto exit;
opc_pref->class_id = global_op_class[i].class_id;
opc_pref->band = global_op_class[i].band;
opc_pref->bw = global_op_class[i].bw;
for (j = 0; j < OPC_CH_LIST_LEN(global_op_class[i]); j++) {
opc_pref->chs[j].ch = OPC_CH_LIST_CH(global_op_class[i], j);
opc_pref->chs[j].static_non_op = 1;
opc_pref->chs[j].no_ir = 1;
opc_pref->chs[j].max_txpwr = UNSPECIFIED_MBM;
}
opc_pref->ch_num = OPC_CH_LIST_LEN(global_op_class[i]);
exit:
return opc_pref;
}
static void opc_pref_free(struct op_class_pref_t *opc_pref)
{
rtw_mfree(opc_pref, sizeof(*opc_pref));
}
int op_class_pref_init(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
struct registry_priv *regsty = dvobj_to_regsty(dvobj);
u8 bw;
struct op_class_pref_t *opc_pref;
int i;
u8 op_class_num = 0;
u8 band_bmp = 0;
u8 bw_bmp[BAND_MAX] = {0};
int ret = _FAIL;
rfctl->spt_op_class_ch = rtw_zmalloc(sizeof(struct op_class_pref_t *) * global_op_class_num);
if (!rfctl->spt_op_class_ch) {
RTW_ERR("%s alloc rfctl->spt_op_class_ch fail\n", __func__);
goto exit;
}
if (is_supported_24g(regsty->wireless_mode) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_2G))
band_bmp |= BAND_CAP_2G;
if (is_supported_5g(regsty->wireless_mode) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_5G))
band_bmp |= BAND_CAP_5G;
bw_bmp[BAND_ON_24G] = (ch_width_to_bw_cap(REGSTY_BW_2G(regsty) + 1) - 1) & (GET_HAL_SPEC(dvobj)->bw_cap);
bw_bmp[BAND_ON_5G] = (ch_width_to_bw_cap(REGSTY_BW_5G(regsty) + 1) - 1) & (GET_HAL_SPEC(dvobj)->bw_cap);
if (!REGSTY_IS_11AC_ENABLE(regsty)
|| !is_supported_vht(regsty->wireless_mode)
)
bw_bmp[BAND_ON_5G] &= ~(BW_CAP_80M | BW_CAP_160M);
if (0) {
RTW_INFO("REGSTY_BW_2G(regsty):%u\n", REGSTY_BW_2G(regsty));
RTW_INFO("REGSTY_BW_5G(regsty):%u\n", REGSTY_BW_5G(regsty));
RTW_INFO("GET_HAL_SPEC(adapter)->bw_cap:0x%x\n", GET_HAL_SPEC(dvobj)->bw_cap);
RTW_INFO("band_bmp:0x%x\n", band_bmp);
RTW_INFO("bw_bmp[2G]:0x%x\n", bw_bmp[BAND_ON_24G]);
RTW_INFO("bw_bmp[5G]:0x%x\n", bw_bmp[BAND_ON_5G]);
}
for (i = 0; i < global_op_class_num; i++) {
#ifdef CONFIG_RTW_DEBUG
rtw_warn_on(!dbg_global_op_class_validate(i));
#endif
if (!(band_bmp & band_to_band_cap(global_op_class[i].band)))
continue;
bw = opc_bw_to_ch_width(global_op_class[i].bw);
if (bw == CHANNEL_WIDTH_MAX
|| bw == CHANNEL_WIDTH_80_80 /* TODO */
)
continue;
if (!(bw_bmp[global_op_class[i].band] & ch_width_to_bw_cap(bw)))
continue;
opc_pref = opc_pref_alloc(global_op_class[i].class_id);
if (!opc_pref) {
RTW_ERR("%s opc_pref_alloc(%u) fail\n", __func__, global_op_class[i].class_id);
goto exit;
}
if (opc_pref->ch_num) {
rfctl->spt_op_class_ch[i] = opc_pref;
op_class_num++;
} else
opc_pref_free(opc_pref);
}
rfctl->cap_spt_op_class_num = op_class_num;
ret = _SUCCESS;
exit:
return ret;
}
void op_class_pref_deinit(_adapter *adapter)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
int i;
if (!rfctl->spt_op_class_ch)
return;
for (i = 0; i < global_op_class_num; i++) {
if (rfctl->spt_op_class_ch[i]) {
opc_pref_free(rfctl->spt_op_class_ch[i]);
rfctl->spt_op_class_ch[i] = NULL;
}
}
rtw_mfree(rfctl->spt_op_class_ch, sizeof(struct op_class_pref_t *) * global_op_class_num);
rfctl->spt_op_class_ch = NULL;
}
void op_class_pref_apply_regulatory(_adapter *adapter, u8 reason)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
RT_CHANNEL_INFO *chset = rfctl->channel_set;
struct registry_priv *regsty = adapter_to_regsty(adapter);
u8 ch, bw, offset, cch;
struct op_class_pref_t *opc_pref;
int i, j;
u8 reg_op_class_num = 0;
u8 op_class_num = 0;
for (i = 0; i < global_op_class_num; i++) {
if (!rfctl->spt_op_class_ch[i])
continue;
opc_pref = rfctl->spt_op_class_ch[i];
/* reset all channel */
for (j = 0; j < MAX_CHANNEL_NUM_OF_BAND && opc_pref->chs[j].ch != 0; j++) {
if (reason >= REG_CHANGE)
opc_pref->chs[j].static_non_op = 1;
if (reason != REG_TXPWR_CHANGE)
opc_pref->chs[j].no_ir = 1;
if (reason >= REG_TXPWR_CHANGE)
opc_pref->chs[j].max_txpwr = UNSPECIFIED_MBM;
}
if (reason >= REG_CHANGE)
opc_pref->op_ch_num = 0;
if (reason != REG_TXPWR_CHANGE)
opc_pref->ir_ch_num = 0;
switch (opc_pref->bw) {
case OPC_BW20:
bw = CHANNEL_WIDTH_20;
offset = CHAN_OFFSET_NO_EXT;
break;
case OPC_BW40PLUS:
bw = CHANNEL_WIDTH_40;
offset = CHAN_OFFSET_UPPER;
break;
case OPC_BW40MINUS:
bw = CHANNEL_WIDTH_40;
offset = CHAN_OFFSET_LOWER;
break;
case OPC_BW80:
bw = CHANNEL_WIDTH_80;
offset = CHAN_OFFSET_NO_EXT;
break;
case OPC_BW160:
bw = CHANNEL_WIDTH_160;
offset = CHAN_OFFSET_NO_EXT;
break;
case OPC_BW80P80: /* TODO */
default:
continue;
}
if (!RFCTL_REG_EN_11AC(rfctl)
&& (bw == CHANNEL_WIDTH_80 || bw == CHANNEL_WIDTH_160))
continue;
for (j = 0; j < MAX_CHANNEL_NUM_OF_BAND && opc_pref->chs[j].ch != 0; j++) {
u8 *op_chs;
u8 op_ch_num;
u8 k, l;
int chset_idx;
ch = opc_pref->chs[j].ch;
if (reason >= REG_TXPWR_CHANGE)
opc_pref->chs[j].max_txpwr = rtw_rfctl_get_reg_max_txpwr_mbm(rfctl, ch, bw, offset, 1);
if (reason == REG_TXPWR_CHANGE)
continue;
cch = rtw_get_center_ch(ch ,bw, offset);
if (!cch)
continue;
if (!rtw_get_op_chs_by_cch_bw(cch, bw, &op_chs, &op_ch_num))
continue;
for (k = 0, l = 0; k < op_ch_num; k++) {
chset_idx = rtw_chset_search_ch(chset, *(op_chs + k));
if (chset_idx == -1)
break;
if (bw >= CHANNEL_WIDTH_40) {
if ((chset[chset_idx].flags & RTW_CHF_NO_HT40U) && k % 2 == 0)
break;
if ((chset[chset_idx].flags & RTW_CHF_NO_HT40L) && k % 2 == 1)
break;
}
if (bw >= CHANNEL_WIDTH_80 && (chset[chset_idx].flags & RTW_CHF_NO_80MHZ))
break;
if (bw >= CHANNEL_WIDTH_160 && (chset[chset_idx].flags & RTW_CHF_NO_160MHZ))
break;
if ((chset[chset_idx].flags & RTW_CHF_DFS) && rtw_rfctl_dfs_domain_unknown(rfctl))
continue;
if (chset[chset_idx].flags & RTW_CHF_NO_IR)
continue;
l++;
}
if (k < op_ch_num)
continue;
if (reason >= REG_CHANGE) {
opc_pref->chs[j].static_non_op = 0;
opc_pref->op_ch_num++;
}
if (l >= op_ch_num) {
opc_pref->chs[j].no_ir = 0;
opc_pref->ir_ch_num++;
}
}
if (opc_pref->op_ch_num)
reg_op_class_num++;
if (opc_pref->ir_ch_num)
op_class_num++;
}
rfctl->reg_spt_op_class_num = reg_op_class_num;
rfctl->cur_spt_op_class_num = op_class_num;
}
static void dump_opc_pref_single(void *sel, struct op_class_pref_t *opc_pref, bool show_snon_ocp, bool show_no_ir, bool detail)
{
u8 i;
u8 ch_num = 0;
char buf[256];
char *pos = buf;
if (!show_snon_ocp && !opc_pref->op_ch_num)
return;
if (!show_no_ir && !opc_pref->ir_ch_num)
return;
for (i = 0; i < MAX_CHANNEL_NUM_OF_BAND && opc_pref->chs[i].ch != 0; i++) {
if ((show_snon_ocp || !opc_pref->chs[i].static_non_op)
&& (show_no_ir || !opc_pref->chs[i].no_ir)
) {
if (detail)
pos += snprintf(pos, 256 - (pos - buf), " %4u", opc_pref->chs[i].ch);
else
pos += snprintf(pos, 256 - (pos - buf), " %u", opc_pref->chs[i].ch);
}
}
RTW_PRINT_SEL(sel, "%5u %4s %7s%s\n"
, opc_pref->class_id
, band_str(opc_pref->band)
, opc_bw_str(opc_pref->bw), buf);
if (!detail)
return;
pos = buf;
for (i = 0; i < MAX_CHANNEL_NUM_OF_BAND && opc_pref->chs[i].ch != 0; i++) {
if ((show_snon_ocp || !opc_pref->chs[i].static_non_op)
&& (show_no_ir || !opc_pref->chs[i].no_ir)
) {
pos += snprintf(pos, 256 - (pos - buf), " %c%c"
, opc_pref->chs[i].no_ir ? ' ' : 'I'
, opc_pref->chs[i].static_non_op ? ' ' : 'E'
);
}
}
RTW_PRINT_SEL(sel, " %s\n", buf);
pos = buf;
for (i = 0; i < MAX_CHANNEL_NUM_OF_BAND && opc_pref->chs[i].ch != 0; i++) {
if ((show_snon_ocp || !opc_pref->chs[i].static_non_op)
&& (show_no_ir || !opc_pref->chs[i].no_ir)
) {
if (opc_pref->chs[i].max_txpwr == UNSPECIFIED_MBM)
pos += snprintf(pos, 256 - (pos - buf), " ");
else
pos += snprintf(pos, 256 - (pos - buf), " %4d", opc_pref->chs[i].max_txpwr);
}
}
RTW_PRINT_SEL(sel, " %s\n", buf);
}
void dump_cap_spt_op_class_ch(void *sel, struct rf_ctl_t *rfctl, bool detail)
{
u8 i;
dump_op_class_ch_title(sel);
for (i = 0; i < global_op_class_num; i++) {
if (!rfctl->spt_op_class_ch[i])
continue;
dump_opc_pref_single(sel, rfctl->spt_op_class_ch[i], 1, 1, detail);
}
RTW_PRINT_SEL(sel, "op_class number:%d\n", rfctl->cap_spt_op_class_num);
}
void dump_reg_spt_op_class_ch(void *sel, struct rf_ctl_t *rfctl, bool detail)
{
u8 i;
dump_op_class_ch_title(sel);
for (i = 0; i < global_op_class_num; i++) {
if (!rfctl->spt_op_class_ch[i])
continue;
dump_opc_pref_single(sel, rfctl->spt_op_class_ch[i], 0, 1, detail);
}
RTW_PRINT_SEL(sel, "op_class number:%d\n", rfctl->reg_spt_op_class_num);
}
void dump_cur_spt_op_class_ch(void *sel, struct rf_ctl_t *rfctl, bool detail)
{
u8 i;
dump_op_class_ch_title(sel);
for (i = 0; i < global_op_class_num; i++) {
if (!rfctl->spt_op_class_ch[i])
continue;
dump_opc_pref_single(sel, rfctl->spt_op_class_ch[i], 0, 0, detail);
}
RTW_PRINT_SEL(sel, "op_class number:%d\n", rfctl->cur_spt_op_class_num);
}
const u8 _rf_type_to_rf_tx_cnt[] = {
1, /*RF_1T1R*/
1, /*RF_1T2R*/
2, /*RF_2T2R*/
2, /*RF_2T3R*/
2, /*RF_2T4R*/
3, /*RF_3T3R*/
3, /*RF_3T4R*/
4, /*RF_4T4R*/
1, /*RF_TYPE_MAX*/
};
const u8 _rf_type_to_rf_rx_cnt[] = {
1, /*RF_1T1R*/
2, /*RF_1T2R*/
2, /*RF_2T2R*/
3, /*RF_2T3R*/
4, /*RF_2T4R*/
3, /*RF_3T3R*/
4, /*RF_3T4R*/
4, /*RF_4T4R*/
1, /*RF_TYPE_MAX*/
};
const char *const _rf_type_to_rfpath_str[] = {
"RF_1T1R",
"RF_1T2R",
"RF_2T2R",
"RF_2T3R",
"RF_2T4R",
"RF_3T3R",
"RF_3T4R",
"RF_4T4R",
"RF_TYPE_MAX"
};
static const u8 _trx_num_to_rf_type[RF_PATH_MAX][RF_PATH_MAX] = {
{RF_1T1R, RF_1T2R, RF_TYPE_MAX, RF_TYPE_MAX},
{RF_TYPE_MAX, RF_2T2R, RF_2T3R, RF_2T4R},
{RF_TYPE_MAX, RF_TYPE_MAX, RF_3T3R, RF_3T4R},
{RF_TYPE_MAX, RF_TYPE_MAX, RF_TYPE_MAX, RF_4T4R},
};
enum rf_type trx_num_to_rf_type(u8 tx_num, u8 rx_num)
{
if (tx_num > 0 && tx_num <= RF_PATH_MAX && rx_num > 0 && rx_num <= RF_PATH_MAX)
return _trx_num_to_rf_type[tx_num - 1][rx_num - 1];
return RF_TYPE_MAX;
}
enum rf_type trx_bmp_to_rf_type(u8 tx_bmp, u8 rx_bmp)
{
u8 tx_num = 0;
u8 rx_num = 0;
int i;
for (i = 0; i < RF_PATH_MAX; i++) {
if (tx_bmp >> i & BIT0)
tx_num++;
if (rx_bmp >> i & BIT0)
rx_num++;
}
return trx_num_to_rf_type(tx_num, rx_num);
}
bool rf_type_is_a_in_b(enum rf_type a, enum rf_type b)
{
return rf_type_to_rf_tx_cnt(a) <= rf_type_to_rf_tx_cnt(b)
&& rf_type_to_rf_rx_cnt(a) <= rf_type_to_rf_rx_cnt(b);
}
static void rtw_path_bmp_limit_from_higher(u8 *bmp, u8 *bmp_bit_cnt, u8 bit_cnt_lmt)
{
int i;
for (i = RF_PATH_MAX - 1; *bmp_bit_cnt > bit_cnt_lmt && i >= 0; i--) {
if (*bmp & BIT(i)) {
*bmp &= ~BIT(i);
(*bmp_bit_cnt)--;
}
}
}
u8 rtw_restrict_trx_path_bmp_by_rftype(u8 trx_path_bmp, enum rf_type type, u8 *tx_num, u8 *rx_num)
{
u8 bmp_tx = (trx_path_bmp & 0xF0) >> 4;
u8 bmp_rx = trx_path_bmp & 0x0F;
u8 bmp_tx_num = 0, bmp_rx_num = 0;
u8 tx_num_lmt, rx_num_lmt;
enum rf_type ret_type = RF_TYPE_MAX;
int i, j;
for (i = 0; i < RF_PATH_MAX; i++) {
if (bmp_tx & BIT(i))
bmp_tx_num++;
if (bmp_rx & BIT(i))
bmp_rx_num++;
}
/* limit higher bit first according to input type */
tx_num_lmt = rf_type_to_rf_tx_cnt(type);
rx_num_lmt = rf_type_to_rf_rx_cnt(type);
rtw_path_bmp_limit_from_higher(&bmp_tx, &bmp_tx_num, tx_num_lmt);
rtw_path_bmp_limit_from_higher(&bmp_rx, &bmp_rx_num, rx_num_lmt);
/* search for valid rf_type (larger RX prefer) */
for (j = bmp_rx_num; j > 0; j--) {
for (i = bmp_tx_num; i > 0; i--) {
ret_type = trx_num_to_rf_type(i, j);
if (RF_TYPE_VALID(ret_type)) {
rtw_path_bmp_limit_from_higher(&bmp_tx, &bmp_tx_num, i);
rtw_path_bmp_limit_from_higher(&bmp_rx, &bmp_rx_num, j);
if (tx_num)
*tx_num = bmp_tx_num;
if (rx_num)
*rx_num = bmp_rx_num;
goto exit;
}
}
}
exit:
return RF_TYPE_VALID(ret_type) ? ((bmp_tx << 4) | bmp_rx) : 0x00;
}
/*
* input with txpwr value in unit of txpwr index
* return string in length 6 at least (for -xx.xx)
*/
void txpwr_idx_get_dbm_str(s8 idx, u8 txgi_max, u8 txgi_pdbm, SIZE_T cwidth, char dbm_str[], u8 dbm_str_len)
{
char fmt[16];
if (idx == txgi_max) {
snprintf(fmt, 16, "%%%zus", cwidth >= 6 ? cwidth + 1 : 6);
snprintf(dbm_str, dbm_str_len, fmt, "NA");
} else if (idx > -txgi_pdbm && idx < 0) { /* -0.xx */
snprintf(fmt, 16, "%%%zus-0.%%02d", cwidth >= 6 ? cwidth - 4 : 1);
snprintf(dbm_str, dbm_str_len, fmt, "", (rtw_abs(idx) % txgi_pdbm) * 100 / txgi_pdbm);
} else if (idx % txgi_pdbm) { /* d.xx */
snprintf(fmt, 16, "%%%zud.%%02d", cwidth >= 6 ? cwidth - 2 : 3);
snprintf(dbm_str, dbm_str_len, fmt, idx / txgi_pdbm, (rtw_abs(idx) % txgi_pdbm) * 100 / txgi_pdbm);
} else { /* d */
snprintf(fmt, 16, "%%%zud", cwidth >= 6 ? cwidth + 1 : 6);
snprintf(dbm_str, dbm_str_len, fmt, idx / txgi_pdbm);
}
}
/*
* input with txpwr value in unit of mbm
* return string in length 6 at least (for -xx.xx)
*/
void txpwr_mbm_get_dbm_str(s16 mbm, SIZE_T cwidth, char dbm_str[], u8 dbm_str_len)
{
char fmt[16];
if (mbm == UNSPECIFIED_MBM) {
snprintf(fmt, 16, "%%%zus", cwidth >= 6 ? cwidth + 1 : 6);
snprintf(dbm_str, dbm_str_len, fmt, "NA");
} else if (mbm > -MBM_PDBM && mbm < 0) { /* -0.xx */
snprintf(fmt, 16, "%%%zus-0.%%02d", cwidth >= 6 ? cwidth - 4 : 1);
snprintf(dbm_str, dbm_str_len, fmt, "", (rtw_abs(mbm) % MBM_PDBM) * 100 / MBM_PDBM);
} else if (mbm % MBM_PDBM) { /* d.xx */
snprintf(fmt, 16, "%%%zud.%%02d", cwidth >= 6 ? cwidth - 2 : 3);
snprintf(dbm_str, dbm_str_len, fmt, mbm / MBM_PDBM, (rtw_abs(mbm) % MBM_PDBM) * 100 / MBM_PDBM);
} else { /* d */
snprintf(fmt, 16, "%%%zud", cwidth >= 6 ? cwidth + 1 : 6);
snprintf(dbm_str, dbm_str_len, fmt, mbm / MBM_PDBM);
}
}
static const s16 _mb_of_ntx[] = {
0, /* 1TX */
301, /* 2TX */
477, /* 3TX */
602, /* 4TX */
699, /* 5TX */
778, /* 6TX */
845, /* 7TX */
903, /* 8TX */
};
/* get mB(100 *dB) for specifc TX count relative to 1TX */
s16 mb_of_ntx(u8 ntx)
{
if (ntx == 0 || ntx > 8) {
RTW_ERR("ntx=%u, out of range\n", ntx);
rtw_warn_on(1);
}
return _mb_of_ntx[ntx - 1];
}
#if CONFIG_TXPWR_LIMIT
void dump_regd_exc_list(void *sel, struct rf_ctl_t *rfctl)
{
/* TODO: get from phl */
}
void dump_txpwr_lmt(void *sel, _adapter *adapter)
{
/* TODO: get from phl */
}
#endif /* CONFIG_TXPWR_LIMIT */
bool rtw_is_long_cac_range(u32 hi, u32 lo, u8 dfs_region)
{
return (dfs_region == RTW_DFS_REGD_ETSI && rtw_is_range_overlap(hi, lo, 5650, 5600)) ? _TRUE : _FALSE;
}
bool rtw_is_long_cac_ch(u8 ch, u8 bw, u8 offset, u8 dfs_region)
{
u32 hi, lo;
if (rtw_chbw_to_freq_range(ch, bw, offset, &hi, &lo) == _FALSE)
return _FALSE;
return rtw_is_long_cac_range(hi, lo, dfs_region) ? _TRUE : _FALSE;
}
|
2301_81045437/rtl8852be
|
core/rtw_rf.c
|
C
|
agpl-3.0
| 37,827
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#ifdef CONFIG_RTW_80211K
#include "rtw_rm_fsm.h"
#include "rtw_rm_util.h"
#endif
#define pstr(s) s+strlen(s)
#ifndef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
u8 rm_post_event_hdl(_adapter *padapter, u8 *pbuf)
{
#ifdef CONFIG_RTW_80211K
struct rm_event *pev = (struct rm_event *)pbuf;
_rm_post_event(padapter, pev->rmid, pev->evid);
rm_handler(padapter, pev);
#endif
return H2C_SUCCESS;
}
#ifdef CONFIG_RTW_80211K
struct cmd_meas_type_ {
u8 id;
char *name;
};
char *rm_type_req_name(u8 meas_type) {
switch (meas_type) {
case basic_req:
return "basic_req";
case cca_req:
return "cca_req";
case rpi_histo_req:
return "rpi_histo_req";
case ch_load_req:
return "ch_load_req";
case noise_histo_req:
return "noise_histo_req";
case bcn_req:
return "bcn_req";
case frame_req:
return "frame_req";
case sta_statis_req:
return "sta_statis_req";
}
return "unknown_req";
};
char *rm_type_rep_name(u8 meas_type) {
switch (meas_type) {
case basic_rep:
return "basic_rep";
case cca_rep:
return "cca_rep";
case rpi_histo_rep:
return "rpi_histo_rep";
case ch_load_rep:
return "ch_load_rep";
case noise_histo_rep:
return "noise_histo_rep";
case bcn_rep:
return "bcn_rep";
case frame_rep:
return "frame_rep";
case sta_statis_rep:
return "sta_statis_rep";
}
return "unknown_rep";
};
char *rm_en_cap_name(enum rm_cap_en en)
{
switch (en) {
case RM_LINK_MEAS_CAP_EN:
return "RM_LINK_MEAS_CAP_EN";
case RM_NB_REP_CAP_EN:
return "RM_NB_REP_CAP_EN";
case RM_PARAL_MEAS_CAP_EN:
return "RM_PARAL_MEAS_CAP_EN";
case RM_REPEAT_MEAS_CAP_EN:
return "RM_REPEAT_MEAS_CAP_EN";
case RM_BCN_PASSIVE_MEAS_CAP_EN:
return "RM_BCN_PASSIVE_MEAS_CAP_EN";
case RM_BCN_ACTIVE_MEAS_CAP_EN:
return "RM_BCN_ACTIVE_MEAS_CAP_EN";
case RM_BCN_TABLE_MEAS_CAP_EN:
return "RM_BCN_TABLE_MEAS_CAP_EN";
case RM_BCN_MEAS_REP_COND_CAP_EN:
return "RM_BCN_MEAS_REP_COND_CAP_EN";
case RM_FRAME_MEAS_CAP_EN:
return "RM_FRAME_MEAS_CAP_EN";
case RM_CH_LOAD_CAP_EN:
return "RM_CH_LOAD_CAP_EN";
case RM_NOISE_HISTO_CAP_EN:
return "RM_NOISE_HISTO_CAP_EN";
case RM_STATIS_MEAS_CAP_EN:
return "RM_STATIS_MEAS_CAP_EN";
case RM_LCI_MEAS_CAP_EN:
return "RM_LCI_MEAS_CAP_EN";
case RM_LCI_AMIMUTH_CAP_EN:
return "RM_LCI_AMIMUTH_CAP_EN";
case RM_TRANS_STREAM_CAT_MEAS_CAP_EN:
return "RM_TRANS_STREAM_CAT_MEAS_CAP_EN";
case RM_TRIG_TRANS_STREAM_CAT_MEAS_CAP_EN:
return "RM_TRIG_TRANS_STREAM_CAT_MEAS_CAP_EN";
case RM_AP_CH_REP_CAP_EN:
return "RM_AP_CH_REP_CAP_EN";
case RM_RM_MIB_CAP_EN:
return "RM_RM_MIB_CAP_EN";
case RM_OP_CH_MAX_MEAS_DUR0:
return "RM_OP_CH_MAX_MEAS_DUR0";
case RM_OP_CH_MAX_MEAS_DUR1:
return "RM_OP_CH_MAX_MEAS_DUR1";
case RM_OP_CH_MAX_MEAS_DUR2:
return "RM_OP_CH_MAX_MEAS_DUR2";
case RM_NONOP_CH_MAX_MEAS_DUR0:
return "RM_NONOP_CH_MAX_MEAS_DUR0";
case RM_NONOP_CH_MAX_MEAS_DUR1:
return "RM_NONOP_CH_MAX_MEAS_DUR1";
case RM_NONOP_CH_MAX_MEAS_DUR2:
return "RM_NONOP_CH_MAX_MEAS_DUR2";
case RM_MEAS_PILOT_CAP0:
return "RM_MEAS_PILOT_CAP0"; /* 24-26 */
case RM_MEAS_PILOT_CAP1:
return "RM_MEAS_PILOT_CAP1";
case RM_MEAS_PILOT_CAP2:
return "RM_MEAS_PILOT_CAP2";
case RM_MEAS_PILOT_TRANS_INFO_CAP_EN:
return "RM_MEAS_PILOT_TRANS_INFO_CAP_EN";
case RM_NB_REP_TSF_OFFSET_CAP_EN:
return "RM_NB_REP_TSF_OFFSET_CAP_EN";
case RM_RCPI_MEAS_CAP_EN:
return "RM_RCPI_MEAS_CAP_EN"; /* 29 */
case RM_RSNI_MEAS_CAP_EN:
return "RM_RSNI_MEAS_CAP_EN";
case RM_BSS_AVG_ACCESS_DELAY_CAP_EN:
return "RM_BSS_AVG_ACCESS_DELAY_CAP_EN";
case RM_AVALB_ADMIS_CAPACITY_CAP_EN:
return "RM_AVALB_ADMIS_CAPACITY_CAP_EN";
case RM_ANT_CAP_EN:
return "RM_ANT_CAP_EN";
case RM_RSVD:
case RM_MAX:
default:
break;
}
return "unknown";
}
int rm_en_cap_chk_and_set(struct rm_obj *prm, enum rm_cap_en en)
{
int idx;
u8 cap;
if (en >= RM_MAX)
return _FALSE;
idx = en / 8;
cap = prm->psta->padapter->rmpriv.rm_en_cap_def[idx];
if (!(cap & BIT(en - (idx*8)))) {
RTW_INFO("RM: %s incapable\n",rm_en_cap_name(en));
rm_set_rep_mode(prm, MEAS_REP_MOD_INCAP);
return _FALSE;
}
return _SUCCESS;
}
/* for caller outside rm */
u8 rm_add_nb_req(_adapter *padapter, struct sta_info *psta)
{
struct rm_obj *prm;
prm = rm_alloc_rmobj(padapter);
if (prm == NULL) {
RTW_ERR("RM: unable to alloc rm obj for requeset\n");
return _FALSE;
}
prm->psta = psta;
prm->q.category = RTW_WLAN_CATEGORY_RADIO_MEAS;
prm->q.diag_token = rm_gen_dialog_token(padapter);
prm->q.m_token = rm_gen_meas_token(padapter);
prm->rmid = rm_gen_rmid(padapter, prm, RM_MASTER);
prm->q.action_code = RM_ACT_NB_REP_REQ;
#if 0
if (pmac) { /* find sta_info according to bssid */
pmac += 4; /* skip mac= */
if (hwaddr_parse(pmac, bssid) == NULL) {
sprintf(pstr(s), "Err: \nincorrect mac format\n");
return _FAIL;
}
psta = rm_get_sta(padapter, 0xff, bssid);
}
#endif
/* enquee rmobj */
rm_enqueue_rmobj(padapter, prm, _FALSE);
RTW_INFO("RM: rmid=%x add req to " MAC_FMT "\n",
prm->rmid, MAC_ARG(psta->phl_sta->mac_addr));
return _SUCCESS;
}
static u8 *build_wlan_hdr(_adapter *padapter, struct xmit_frame *pmgntframe,
struct sta_info *psta, u16 frame_type)
{
u8 *pframe;
u16 *fctrl;
struct pkt_attrib *pattr;
struct rtw_ieee80211_hdr *pwlanhdr;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
/* update attribute */
pattr = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattr);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, psta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3,
get_my_bssid(&(pmlmeinfo->network)),ETH_ALEN);
RTW_INFO("RM: dst = " MAC_FMT "\n", MAC_ARG(pwlanhdr->addr1));
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
SetFragNum(pframe, 0);
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattr->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
return pframe;
}
void rm_set_rep_mode(struct rm_obj *prm, u8 mode)
{
RTW_INFO("RM: rmid=%x set %s\n",
prm->rmid,
mode|MEAS_REP_MOD_INCAP?"INCAP":
mode|MEAS_REP_MOD_REFUSE?"REFUSE":
mode|MEAS_REP_MOD_LATE?"LATE":"");
prm->p.m_mode |= mode;
}
int issue_null_reply(struct rm_obj *prm)
{
int len=0, my_len;
u8 *pframe, m_mode;
_adapter *padapter = prm->psta->padapter;
struct pkt_attrib *pattr;
struct xmit_frame *pmgntframe;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
m_mode = prm->p.m_mode;
if (m_mode || prm->p.rpt == 0) {
RTW_INFO("RM: rmid=%x reply (%s repeat=%d)\n",
prm->rmid,
m_mode&MEAS_REP_MOD_INCAP?"INCAP":
m_mode&MEAS_REP_MOD_REFUSE?"REFUSE":
m_mode&MEAS_REP_MOD_LATE?"LATE":"no content",
prm->p.rpt);
}
switch (prm->p.action_code) {
case RM_ACT_RADIO_MEAS_REQ:
len = 8;
break;
case RM_ACT_NB_REP_REQ:
len = 3;
break;
case RM_ACT_LINK_MEAS_REQ:
len = 3;
break;
default:
break;
}
if (len==0)
return _FALSE;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_ERR("RM: %s alloc xmit_frame fail\n",__func__);
return _FALSE;
}
pattr = &pmgntframe->attrib;
pframe = build_wlan_hdr(padapter, pmgntframe, prm->psta, WIFI_ACTION);
pframe = rtw_set_fixed_ie(pframe, 3, &prm->p.category, &pattr->pktlen);
my_len = 0;
if (len>5) {
prm->p.len = len - 3 - 2;
pframe = rtw_set_fixed_ie(pframe, len - 3,
&prm->p.e_id, &my_len);
}
pattr->pktlen += my_len;
pattr->last_txcmdsz = pattr->pktlen;
dump_mgntframe(padapter, pmgntframe);
return _SUCCESS;
}
int ready_for_scan(struct rm_obj *prm)
{
_adapter *padapter = prm->psta->padapter;
u8 ssc_chk;
if (!rtw_is_adapter_up(padapter))
return _FALSE;
ssc_chk = rtw_sitesurvey_condition_check(padapter, _FALSE);
if (ssc_chk == SS_ALLOW)
return _SUCCESS;
return _FALSE;
}
int rm_get_chset(struct rm_obj *prm)
{
int i,meas_ch_amount=0;
u8 op_class=0, val8;
struct rtw_ieee80211_channel *pch_set;
pch_set = &prm->q.ch_set[0];
_rtw_memset(pch_set, 0,
sizeof(struct rtw_ieee80211_channel) * RTW_CHANNEL_SCAN_AMOUNT);
op_class = prm->q.op_class;
if (prm->q.ch_num == 0) {
/* ch_num=0 : scan all ch in operating class */
meas_ch_amount = rm_get_ch_set(pch_set,
op_class, prm->q.ch_num);
} else if (prm->q.ch_num == 255) {
/* 802.11 p.1066 */
/* ch_num=255 : If the Channel Number is 255 and includes
* AP Channel Report subelements
*/
meas_ch_amount = rm_get_ch_set_from_bcn_req_opt(pch_set, &prm->q.opt.bcn);
} else
meas_ch_amount = rm_get_ch_set(pch_set, op_class, prm->q.ch_num);
/* get means channel */
prm->q.ch_set_ch_amount = meas_ch_amount;
#if (RM_MORE_DBG_MSG)
RTW_INFO("survey (%d) chaannels\n", meas_ch_amount);
#endif
return 0;
}
int rm_sitesurvey(struct rm_obj *prm)
{
int meas_ch_amount=0;
u8 op_class=0, val8;
struct rtw_ieee80211_channel *pch_set;
struct sitesurvey_parm parm;
RTW_INFO("RM: rmid=%x %s\n",prm->rmid, __func__);
rm_get_chset(prm);
pch_set = &prm->q.ch_set[0];
meas_ch_amount = MIN(prm->q.ch_set_ch_amount, RTW_CHANNEL_SCAN_AMOUNT);
_rtw_memset(&parm, 0, sizeof(struct sitesurvey_parm));
_rtw_memcpy(parm.ch, pch_set, sizeof(struct rtw_ieee80211_channel) * meas_ch_amount);
_rtw_memcpy(&parm.ssid[0], &prm->q.opt.bcn.ssid, IW_ESSID_MAX_SIZE);
parm.ssid_num = 1;
parm.scan_mode = prm->q.m_mode;
parm.ch_num = meas_ch_amount;
parm.rrm_token = prm->rmid;
parm.duration = prm->q.meas_dur;
parm.scan_type = RTW_SCAN_RRM;
/* parm.bw = BW_20M; */
rtw_sitesurvey_cmd(prm->psta->padapter, &parm);
return _SUCCESS;
}
static int rm_parse_ch_load_s_elem(struct rm_obj *prm, u8 *pbody, int req_len)
{
u8 *popt_id;
int i, p=0; /* position */
int len = req_len;
prm->q.opt_s_elem_len = len;
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: opt_s_elem_len=%d\n", len);
#endif
while (len) {
switch (pbody[p]) {
case ch_load_rep_info:
/* check RM_EN */
rm_en_cap_chk_and_set(prm, RM_CH_LOAD_CAP_EN);
_rtw_memcpy(&(prm->q.opt.clm.rep_cond),
&pbody[p+2], sizeof(prm->q.opt.clm.rep_cond));
RTW_INFO("RM: ch_load_rep_info=%u:%u\n",
prm->q.opt.clm.rep_cond.cond,
prm->q.opt.clm.rep_cond.threshold);
break;
default:
break;
}
len = len - (int)pbody[p+1] - 2;
p = p + (int)pbody[p+1] + 2;
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: opt_s_elem_len=%d\n",len);
#endif
}
return _SUCCESS;
}
static int rm_parse_noise_histo_s_elem(struct rm_obj *prm,
u8 *pbody, int req_len)
{
u8 *popt_id;
int i, p=0; /* position */
int len = req_len;
prm->q.opt_s_elem_len = len;
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: opt_s_elem_len=%d\n", len);
#endif
while (len) {
switch (pbody[p]) {
case noise_histo_rep_info:
/* check RM_EN */
rm_en_cap_chk_and_set(prm, RM_NOISE_HISTO_CAP_EN);
_rtw_memcpy(&(prm->q.opt.nhm.rep_cond),
&pbody[p+2], sizeof(prm->q.opt.nhm.rep_cond));
RTW_INFO("RM: noise_histo_rep_info=%u:%u\n",
prm->q.opt.nhm.rep_cond.cond,
prm->q.opt.nhm.rep_cond.threshold);
break;
default:
break;
}
len = len - (int)pbody[p+1] - 2;
p = p + (int)pbody[p+1] + 2;
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: opt_s_elem_len=%d\n",len);
#endif
}
return _SUCCESS;
}
static int rm_parse_bcn_req_s_elem(struct rm_obj *prm, u8 *pbody, int req_len)
{
u8 *popt_id;
int i, p=0; /* position */
int len = req_len;
int ap_ch_rpt_idx = 0;
struct _RT_OPERATING_CLASS *op;
/* opt length,2:pbody[0]+ pbody[1] */
/* first opt id : pbody[18] */
prm->q.opt_s_elem_len = len;
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: opt_s_elem_len=%d\n", len);
#endif
popt_id = prm->q.opt.bcn.opt_id;
while (len && prm->q.opt.bcn.opt_id_num < BCN_REQ_OPT_MAX_NUM) {
switch (pbody[p]) {
case bcn_req_ssid:
RTW_INFO("bcn_req_ssid\n");
#if (DBG_BCN_REQ_WILDCARD)
RTW_INFO("DBG set ssid to WILDCARD\n");
#else
#if (DBG_BCN_REQ_SSID)
RTW_INFO("DBG set ssid to %s\n",DBG_BCN_REQ_SSID_NAME);
i = strlen(DBG_BCN_REQ_SSID_NAME);
prm->q.opt.bcn.ssid.SsidLength = i;
_rtw_memcpy(&(prm->q.opt.bcn.ssid.Ssid),
DBG_BCN_REQ_SSID_NAME, i);
#else /* original */
prm->q.opt.bcn.ssid.SsidLength = pbody[p+1];
_rtw_memcpy(&(prm->q.opt.bcn.ssid.Ssid),
&pbody[p+2], pbody[p+1]);
#endif
#endif
RTW_INFO("RM: bcn_req_ssid=%s\n",
prm->q.opt.bcn.ssid.Ssid);
popt_id[prm->q.opt.bcn.opt_id_num++] = pbody[p];
break;
case bcn_req_rep_info:
/* check RM_EN */
rm_en_cap_chk_and_set(prm, RM_BCN_MEAS_REP_COND_CAP_EN);
_rtw_memcpy(&(prm->q.opt.bcn.rep_cond),
&pbody[p+2], sizeof(prm->q.opt.bcn.rep_cond));
RTW_INFO("bcn_req_rep_info=%u:%u\n",
prm->q.opt.bcn.rep_cond.cond,
prm->q.opt.bcn.rep_cond.threshold);
/*popt_id[prm->q.opt.bcn.opt_id_num++] = pbody[p];*/
break;
case bcn_req_rep_detail:
#if DBG_BCN_REQ_DETAIL
prm->q.opt.bcn.rep_detail = 2; /* all IE in beacon */
#else
prm->q.opt.bcn.rep_detail = pbody[p+2];
#endif
popt_id[prm->q.opt.bcn.opt_id_num++] = pbody[p];
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: report_detail=%d\n",
prm->q.opt.bcn.rep_detail);
#endif
break;
case bcn_req_req:
RTW_INFO("RM: bcn_req_req\n");
prm->q.opt.bcn.req_start = rtw_malloc(pbody[p+1]);
if (prm->q.opt.bcn.req_start == NULL) {
RTW_ERR("RM: req_start malloc fail!!\n");
break;
}
for (i = 0; i < pbody[p+1]; i++)
*((prm->q.opt.bcn.req_start)+i) =
pbody[p+2+i];
prm->q.opt.bcn.req_len = pbody[p+1];
popt_id[prm->q.opt.bcn.opt_id_num++] = pbody[p];
break;
case bcn_req_ap_ch_rep:
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: bcn_req_ap_ch_rep\n");
#endif
if (ap_ch_rpt_idx > BCN_REQ_OPT_AP_CH_RPT_MAX_NUM) {
RTW_ERR("RM: bcn_req_ap_ch_rep over size\n");
break;
}
popt_id[prm->q.opt.bcn.opt_id_num++] = pbody[p];
/* get channel list
* EID:len:op-class:ch-list
*/
op = rtw_malloc(sizeof (*op));
op->global_op_class = pbody[p + 2];
i = pbody[p + 1] - 1; /* ch list len; (-1) is op class */
#if (RM_MORE_DBG_MSG)
RTW_INFO("%d op class %d has %d ch\n",
ap_ch_rpt_idx,op->global_op_class,i);
#endif
op->Len = i;
memcpy(op->Channel, &pbody[p + 3],
MIN(i, MAX_CH_NUM_IN_OP_CLASS));
prm->q.opt.bcn.ap_ch_rpt[ap_ch_rpt_idx++] = op;
prm->q.opt.bcn.ap_ch_rpt_num = ap_ch_rpt_idx;
break;
default:
break;
}
len = len - (int)pbody[p+1] - 2;
p = p + (int)pbody[p+1] + 2;
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: opt_s_elem_len=%d\n",len);
#endif
}
return _SUCCESS;
}
static int rm_parse_meas_req(struct rm_obj *prm, u8 *pbody)
{
int p; /* position */
int req_len;
req_len = (int)pbody[1];
p = 5;
prm->q.op_class = pbody[p++];
prm->q.ch_num = pbody[p++];
prm->q.rand_intvl = le16_to_cpu(*(u16*)(&pbody[p]));
p+=2;
prm->q.meas_dur = le16_to_cpu(*(u16*)(&pbody[p]));
p+=2;
if (prm->q.m_type == bcn_req) {
/*
* 0: passive
* 1: active
* 2: bcn_table
*/
prm->q.m_mode = pbody[p++];
/* BSSID */
_rtw_memcpy(&(prm->q.bssid), &pbody[p], 6);
p+=6;
/*
* default, used when Reporting detail subelement
* is not included in Beacon Request
*/
prm->q.opt.bcn.rep_detail = 2;
}
if (req_len-(p-2) <= 0) /* without sub-element */
return _SUCCESS;
switch (prm->q.m_type) {
case bcn_req:
rm_parse_bcn_req_s_elem(prm, &pbody[p], req_len-(p-2));
break;
case ch_load_req:
rm_parse_ch_load_s_elem(prm, &pbody[p], req_len-(p-2));
break;
case noise_histo_req:
rm_parse_noise_histo_s_elem(prm, &pbody[p], req_len-(p-2));
break;
default:
break;
}
return _SUCCESS;
}
/* receive measurement request */
int rm_recv_radio_mens_req(_adapter *padapter,
union recv_frame *precv_frame, struct sta_info *psta)
{
struct rm_obj *prm;
struct rm_priv *prmpriv = &padapter->rmpriv;
u8 *pdiag_body = (u8 *)(precv_frame->u.hdr.rx_data +
sizeof(struct rtw_ieee80211_hdr_3addr));
u8 *pmeas_body = &pdiag_body[5];
u8 rmid, update = 0;
#if 0
/* search existing rm_obj */
rmid = psta->phl_sta->aid << 16
| pdiag_body[2] << 8
| RM_SLAVE;
prm = rm_get_rmobj(padapter, rmid);
if (prm) {
RTW_INFO("RM: Found an exist meas rmid=%u\n", rmid);
update = 1;
} else
#endif
prm = rm_alloc_rmobj(padapter);
if (prm == NULL) {
RTW_ERR("RM: unable to alloc rm obj for requeset\n");
return _FALSE;
}
prm->psta = psta;
prm->q.diag_token = pdiag_body[2];
prm->q.rpt = le16_to_cpu(*(u16*)(&pdiag_body[3]));
/* Figure 8-104 Measurement Requested format */
prm->q.e_id = pmeas_body[0];
prm->q.m_token = pmeas_body[2];
prm->q.m_mode = pmeas_body[3];
prm->q.m_type = pmeas_body[4];
prm->rmid = rm_gen_rmid(padapter, prm, RM_SLAVE);
RTW_INFO("RM: rmid=%x, bssid " MAC_FMT "\n", prm->rmid,
MAC_ARG(prm->psta->phl_sta->mac_addr));
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: element_id = %d\n", prm->q.e_id);
RTW_INFO("RM: length = %d\n", (int)pmeas_body[1]);
RTW_INFO("RM: meas_token = %d\n", prm->q.m_token);
RTW_INFO("RM: meas_mode = %d\n", prm->q.m_mode);
RTW_INFO("RM: meas_type = %d\n", prm->q.m_type);
#endif
if (prm->q.e_id != _MEAS_REQ_IE_) /* 38 */
return _FALSE;
switch (prm->q.m_type) {
case bcn_req:
RTW_INFO("RM: recv beacon_request\n");
switch (prm->q.m_mode) {
case bcn_req_passive:
rm_en_cap_chk_and_set(prm, RM_BCN_PASSIVE_MEAS_CAP_EN);
break;
case bcn_req_active:
rm_en_cap_chk_and_set(prm, RM_BCN_ACTIVE_MEAS_CAP_EN);
break;
case bcn_req_bcn_table:
rm_en_cap_chk_and_set(prm, RM_BCN_TABLE_MEAS_CAP_EN);
break;
default:
rm_set_rep_mode(prm, MEAS_REP_MOD_INCAP);
break;
}
break;
case ch_load_req:
RTW_INFO("RM: recv ch_load_request\n");
rm_en_cap_chk_and_set(prm, RM_CH_LOAD_CAP_EN);
break;
case noise_histo_req:
RTW_INFO("RM: recv noise_histogram_request\n");
rm_en_cap_chk_and_set(prm, RM_NOISE_HISTO_CAP_EN);
break;
default:
RTW_INFO("RM: recv unknown request type 0x%02x\n",
prm->q.m_type);
rm_set_rep_mode(prm, MEAS_REP_MOD_INCAP);
goto done;
}
rm_parse_meas_req(prm, pmeas_body);
done:
if (!update)
rm_enqueue_rmobj(padapter, prm, _FALSE);
return _SUCCESS;
}
/* receive measurement report */
int rm_recv_radio_mens_rep(_adapter *padapter,
union recv_frame *precv_frame, struct sta_info *psta)
{
int ret = _FALSE;
struct rm_obj *prm;
u32 rmid, len;
u8 *pdiag_body = (u8 *)(precv_frame->u.hdr.rx_data +
sizeof(struct rtw_ieee80211_hdr_3addr));
u8 *pmeas_body = &pdiag_body[3];
rmid = psta->phl_sta->aid << 16
| pdiag_body[2] << 8
| RM_MASTER;
prm = rm_get_rmobj(padapter, rmid);
if (prm == NULL) {
/* not belong to us, report to upper */
rtw_cfg80211_rx_rrm_action(psta->padapter, precv_frame);
return _TRUE;
}
prm->p.action_code = pdiag_body[1];
prm->p.diag_token = pdiag_body[2];
/* Figure 8-140 Measuremnt Report format */
prm->p.e_id = pmeas_body[0];
prm->p.m_token = pmeas_body[2];
prm->p.m_mode = pmeas_body[3];
prm->p.m_type = pmeas_body[4];
RTW_INFO("RM: rmid=%x, bssid " MAC_FMT "\n", prm->rmid,
MAC_ARG(prm->psta->phl_sta->mac_addr));
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: element_id = %d\n", prm->p.e_id);
RTW_INFO("RM: length = %d\n", (int)pmeas_body[1]);
RTW_INFO("RM: meas_token = %d\n", prm->p.m_token);
RTW_INFO("RM: meas_mode = %d\n", prm->p.m_mode);
RTW_INFO("RM: meas_type = %d\n", prm->p.m_type);
#endif
if (prm->p.e_id != _MEAS_RSP_IE_) /* 39 */
return _FALSE;
RTW_INFO("RM: recv %s\n", rm_type_rep_name(prm->p.m_type));
rm_post_event(padapter, prm->rmid, RM_EV_recv_rep);
/* report to upper via ioctl */
if ((prm->from_ioctl == true) &&
prm->q.m_type == bcn_req) {
len = pmeas_body[1] + 2; /* 2 : EID(1B) length(1B) */
indicate_beacon_report(prm->psta->phl_sta->mac_addr,
1, len, pmeas_body);
}
return ret;
}
/* receive link measurement request */
int rm_recv_link_mens_req(_adapter *padapter,
union recv_frame *precv_frame, struct sta_info *psta)
{
struct rm_obj *prm;
struct rm_priv *prmpriv = &padapter->rmpriv;
u8 *pdiag_body = (u8 *)(precv_frame->u.hdr.rx_data +
sizeof(struct rtw_ieee80211_hdr_3addr));
u8 *pmeas_body = &pdiag_body[3];
u8 rmid, update = 0;
int i;
prm = rm_alloc_rmobj(padapter);
if (prm == NULL) {
RTW_ERR("RM: unable to alloc rm obj for requeset\n");
return _FALSE;
}
prm->psta = psta;
prm->q.action_code = pdiag_body[1];
prm->q.diag_token = pdiag_body[2];
prm->q.tx_pwr_used = pmeas_body[0];
prm->q.tx_pwr_max = pmeas_body[1];
prm->q.rx_pwr = precv_frame->u.hdr.attrib.phy_info.rx_power;
prm->q.rx_rate = precv_frame->u.hdr.attrib.data_rate;
prm->q.rx_bw = precv_frame->u.hdr.attrib.bw;
prm->q.rx_rsni = rm_get_frame_rsni(prm, precv_frame);
prm->rmid = rm_gen_rmid(padapter, prm, RM_SLAVE);
RTW_INFO("RM: rmid=%x, bssid" MAC_FMT " rx_pwr=%ddBm, rate=%s\n",
prm->rmid, MAC_ARG(prm->psta->phl_sta->mac_addr), prm->q.rx_pwr,
MGN_RATE_STR(prm->q.rx_rate));
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: tx_pwr_used =%d dBm\n", prm->q.tx_pwr_used);
RTW_INFO("RM: tx_pwr_max =%d dBm\n", prm->q.tx_pwr_max);
#endif
if (!update)
rm_enqueue_rmobj(padapter, prm, _FALSE);
return _SUCCESS;
}
/* receive link measurement report */
int rm_recv_link_mens_rep(_adapter *padapter,
union recv_frame *precv_frame, struct sta_info *psta)
{
int ret = _FALSE;
struct rm_obj *prm;
u32 rmid;
u8 *pdiag_body = (u8 *)(precv_frame->u.hdr.rx_data +
sizeof(struct rtw_ieee80211_hdr_3addr));
u8 *pmeas_body = pdiag_body + 3;
s8 val;
rmid = psta->phl_sta->aid << 16
| pdiag_body[2] << 8
| RM_MASTER;
prm = rm_get_rmobj(padapter, rmid);
if (prm == NULL) {
/* not belong to us, report to upper */
rtw_cfg80211_rx_rrm_action(psta->padapter, precv_frame);
return _TRUE;
}
RTW_INFO("RM: rmid=%x, bssid " MAC_FMT "\n", prm->rmid,
MAC_ARG(prm->psta->phl_sta->mac_addr));
prm->p.action_code = pdiag_body[1];
prm->p.diag_token = pdiag_body[2];
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: action_code = %d\n", prm->p.action_code);
RTW_INFO("RM: diag_token = %d\n", prm->p.diag_token);
RTW_INFO("RM: xmit_power = %d dBm\n", pmeas_body[2]);
RTW_INFO("RM: link_margin = %d dBm\n", pmeas_body[3]);
RTW_INFO("RM: xmit_ant = %d\n", pmeas_body[4]);
RTW_INFO("RM: recv_ant = %d\n", pmeas_body[5]);
RTW_INFO("RM: RCPI = %d\n", pmeas_body[6]);
RTW_INFO("RM: RSNI = %d\n", pmeas_body[7]);
#endif
RTW_INFO("RM: recv link meas report ...\n");
ret = rm_post_event(padapter, prm->rmid, RM_EV_recv_rep);
return ret;
}
int rm_radio_mens_nb_rep(_adapter *padapter,
union recv_frame *precv_frame, struct sta_info *psta)
{
u8 *pdiag_body = (u8 *)(precv_frame->u.hdr.rx_data +
sizeof(struct rtw_ieee80211_hdr_3addr));
u8 *pmeas_body = &pdiag_body[3];
u32 len = precv_frame->u.hdr.len;
u32 rmid;
struct rm_obj *prm;
rmid = psta->phl_sta->aid << 16
| pdiag_body[2] << 8
| RM_MASTER;
prm = rm_get_rmobj(padapter, rmid);
if (prm == NULL) {
/* not belong to us, report to upper */
rtw_cfg80211_rx_rrm_action(psta->padapter, precv_frame);
return _TRUE;
}
prm->p.action_code = pdiag_body[1];
prm->p.diag_token = pdiag_body[2];
prm->p.e_id = pmeas_body[0];
RTW_INFO("RM: rmid=%x, bssid " MAC_FMT "\n", prm->rmid,
MAC_ARG(prm->psta->phl_sta->mac_addr));
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: element_id = %d\n", prm->p.e_id);
RTW_INFO("RM: length = %d\n", (int)pmeas_body[1]);
#endif
rm_post_event(padapter, prm->rmid, RM_EV_recv_rep);
#ifdef CONFIG_RTW_MBO
#ifdef CONFIG_LAYER2_ROAMING
if (rtw_wnm_btm_candidates_survey(padapter
,(pdiag_body + 3)
,(len - sizeof(struct rtw_ieee80211_hdr_3addr))
,_FALSE) == _FAIL)
return _FALSE;
#endif
#endif
rtw_cfg80211_rx_rrm_action(padapter, precv_frame);
return _TRUE;
}
unsigned int rm_on_action(_adapter *padapter, union recv_frame *precv_frame)
{
u32 ret = _FAIL;
u8 *pframe = NULL;
u8 *pframe_body = NULL;
u8 action_code = 0;
u8 diag_token = 0;
struct rtw_ieee80211_hdr_3addr *whdr;
struct sta_info *psta;
pframe = precv_frame->u.hdr.rx_data;
/* check RA matches or not */
if (!_rtw_memcmp(adapter_mac_addr(padapter),
GetAddr1Ptr(pframe), ETH_ALEN))
goto exit;
whdr = (struct rtw_ieee80211_hdr_3addr *)pframe;
RTW_INFO("RM: %s bssid = " MAC_FMT "\n",
__func__, MAC_ARG(whdr->addr2));
psta = rtw_get_stainfo(&padapter->stapriv, whdr->addr2);
if (!psta) {
RTW_ERR("RM: psta not found\n");
goto exit;
}
pframe_body = (unsigned char *)(pframe +
sizeof(struct rtw_ieee80211_hdr_3addr));
/* Figure 8-438 radio measurement request frame Action field format */
/* Category = pframe_body[0] = 5 (Radio Measurement) */
action_code = pframe_body[1];
diag_token = pframe_body[2];
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: %s radio_action=%x, diag_token=%x\n", __func__,
action_code, diag_token);
#endif
switch (action_code) {
case RM_ACT_RADIO_MEAS_REQ:
RTW_INFO("RM: RM_ACT_RADIO_MEAS_REQ\n");
ret = rm_recv_radio_mens_req(padapter, precv_frame, psta);
break;
case RM_ACT_RADIO_MEAS_REP:
RTW_INFO("RM: RM_ACT_RADIO_MEAS_REP\n");
ret = rm_recv_radio_mens_rep(padapter, precv_frame, psta);
break;
case RM_ACT_LINK_MEAS_REQ:
RTW_INFO("RM: RM_ACT_LINK_MEAS_REQ\n");
ret = rm_recv_link_mens_req(padapter, precv_frame, psta);
break;
case RM_ACT_LINK_MEAS_REP:
RTW_INFO("RM: RM_ACT_LINK_MEAS_REP\n");
ret = rm_recv_link_mens_rep(padapter, precv_frame, psta);
break;
case RM_ACT_NB_REP_REQ:
RTW_INFO("RM: RM_ACT_NB_REP_REQ\n");
break;
case RM_ACT_NB_REP_RESP:
RTW_INFO("RM: RM_ACT_NB_REP_RESP\n");
ret = rm_radio_mens_nb_rep(padapter, precv_frame, psta);
break;
default:
/* TODO reply incabable */
RTW_ERR("RM: unknown specturm management action %2x\n",
action_code);
break;
}
exit:
return ret;
}
static u8 *rm_gen_bcn_detail_elem(_adapter *padapter, u8 *pframe,
struct rm_obj *prm, struct wlan_network *pnetwork,
unsigned int *fr_len)
{
WLAN_BSSID_EX *pbss = &pnetwork->network;
unsigned int my_len;
int j, k, len;
u8 *plen;
u8 *ptr;
u8 val8, eid;
my_len = 0;
/* Reporting Detail values
* 0: No fixed length fields or elements
* 1: All fixed length fields and any requested elements
* in the Request info element if present
* 2: All fixed length fields and elements
* 3-255: Reserved
*/
/* report_detail = 0 */
if (prm->q.opt.bcn.rep_detail == 0
|| prm->q.opt.bcn.rep_detail > 2) {
return pframe;
}
/* ID */
val8 = 1; /* 1:reported frame body */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
plen = pframe;
val8 = 0;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* report_detail = 2 */
if (prm->q.opt.bcn.rep_detail == 2) {
pframe = rtw_set_fixed_ie(pframe, pbss->IELength - 4,
pbss->IEs, &my_len); /* -4 remove FCS */
goto done;
}
/* report_detail = 1 */
/* all fixed lenght fields */
pframe = rtw_set_fixed_ie(pframe,
_FIXED_IE_LENGTH_, pbss->IEs, &my_len);
for (j = 0; j < prm->q.opt.bcn.opt_id_num; j++) {
switch (prm->q.opt.bcn.opt_id[j]) {
case bcn_req_ssid:
/* SSID */
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: bcn_req_ssid\n");
#endif
pframe = rtw_set_ie(pframe, _SSID_IE_,
pbss->Ssid.SsidLength,
pbss->Ssid.Ssid, &my_len);
break;
case bcn_req_req:
if (prm->q.opt.bcn.req_start == NULL)
break;
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: bcn_req_req");
#endif
for (k=0; k<prm->q.opt.bcn.req_len; k++) {
eid = prm->q.opt.bcn.req_start[k];
val8 = pbss->IELength - _FIXED_IE_LENGTH_;
ptr = rtw_get_ie(pbss->IEs + _FIXED_IE_LENGTH_,
eid, &len, val8);
if (!ptr)
continue;
#if (RM_MORE_DBG_MSG)
switch (eid) {
case EID_SsId:
RTW_INFO("RM: EID_SSID\n");
break;
case EID_QBSSLoad:
RTW_INFO("RM: EID_QBSSLoad\n");
break;
case EID_HTCapability:
RTW_INFO("RM: EID_HTCapability\n");
break;
case _MDIE_:
RTW_INFO("RM: EID_MobilityDomain\n");
break;
case EID_Vendor:
RTW_INFO("RM: EID_Vendor\n");
break;
default:
RTW_INFO("RM: EID %d todo\n",eid);
break;
}
#endif
pframe = rtw_set_ie(pframe, eid,
len, ptr + 2, &my_len);
} /* for() */
break;
case bcn_req_rep_detail:
RTW_INFO("RM: bcn_req_rep_detail\n");
break;
case bcn_req_ap_ch_rep:
RTW_INFO("RM: bcn_req_ap_ch_rep\n");
break;
default:
RTW_INFO("RM: OPT %d TODO\n",prm->q.opt.bcn.opt_id[j]);
break;
}
}
done:
/*
* update my length
* content length does NOT include ID and LEN
*/
val8 = my_len - 2;
rtw_set_fixed_ie(plen, 1, &val8, &j);
/* update length to caller */
*fr_len += my_len;
return pframe;
}
u8 rm_bcn_req_cond_mach(struct rm_obj *prm, struct wlan_network *pnetwork)
{
u8 val8;
switch(prm->q.opt.bcn.rep_cond.cond) {
case bcn_rep_cond_immediately:
return _SUCCESS;
case bcn_req_cond_rcpi_greater:
val8 = rm_get_bcn_rcpi(prm, pnetwork);
if (val8 > prm->q.opt.bcn.rep_cond.threshold)
return _SUCCESS;
break;
case bcn_req_cond_rcpi_less:
val8 = rm_get_bcn_rcpi(prm, pnetwork);
if (val8 < prm->q.opt.bcn.rep_cond.threshold)
return _SUCCESS;
break;
case bcn_req_cond_rsni_greater:
val8 = rm_get_bcn_rsni(prm, pnetwork);
if (val8 != 255 && val8 > prm->q.opt.bcn.rep_cond.threshold)
return _SUCCESS;
break;
case bcn_req_cond_rsni_less:
val8 = rm_get_bcn_rsni(prm, pnetwork);
if (val8 != 255 && val8 < prm->q.opt.bcn.rep_cond.threshold)
return _SUCCESS;
break;
default:
RTW_ERR("RM: bcn_req cond %u not support\n",
prm->q.opt.bcn.rep_cond.cond);
break;
}
return _FALSE;
}
static u8 *rm_gen_bcn_rep_ie (struct rm_obj *prm,
u8 *pframe, struct wlan_network *pnetwork, unsigned int *fr_len)
{
int snr, i;
u8 val8, *plen;
u16 val16;
u32 val32;
u64 val64;
unsigned int my_len;
_adapter *padapter = prm->psta->padapter;
my_len = 0;
plen = pframe + 1;
pframe = rtw_set_fixed_ie(pframe, 7, &prm->p.e_id, &my_len);
/* Actual Measurement StartTime */
val64 = cpu_to_le64(prm->meas_start_time);
pframe = rtw_set_fixed_ie(pframe, 8, (u8 *)&val64, &my_len);
/* Measurement Duration */
val16 = prm->meas_end_time - prm->meas_start_time;
val16 = cpu_to_le16(val16);
pframe = rtw_set_fixed_ie(pframe, 2, (u8*)&val16, &my_len);
/* TODO
* ReportedFrameInformation:
* 0 :beacon or probe rsp
* 1 :pilot frame
*/
val8 = 0; /* report frame info */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* RCPI */
val8 = rm_get_bcn_rcpi(prm, pnetwork);
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* RSNI */
val8 = rm_get_bcn_rsni(prm, pnetwork);
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* BSSID */
pframe = rtw_set_fixed_ie(pframe, 6,
(u8 *)&pnetwork->network.MacAddress, &my_len);
/*
* AntennaID
* 0: unknown
* 255: multiple antenna (Diversity)
*/
val8 = 0;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* ParentTSF */
val32 = prm->meas_start_time + pnetwork->network.PhyInfo.free_cnt;
pframe = rtw_set_fixed_ie(pframe, 4, (u8 *)&val32, &my_len);
/* Generate Beacon detail */
pframe = rm_gen_bcn_detail_elem(padapter, pframe,
prm, pnetwork, &my_len);
/*
* update my length
* content length does NOT include ID and LEN
*/
val8 = my_len - 2;
rtw_set_fixed_ie(plen, 1, &val8, &i);
/* update length to caller */
*fr_len += my_len;
return pframe;
}
static int retrieve_scan_result(struct rm_obj *prm)
{
_list *plist, *phead;
_queue *queue;
_adapter *padapter = prm->psta->padapter;
struct rtw_ieee80211_channel *pch_set;
struct wlan_network *pnetwork = NULL;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int i, meas_ch_num=0;
PWLAN_BSSID_EX pbss;
unsigned int matched_network;
int len, my_len;
u8 buf_idx, *pbuf = NULL, *tmp_buf = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u16 xframe_ext_sz = SZ_XMITFRAME_EXT;
tmp_buf = rtw_malloc(xframe_ext_sz);
if (tmp_buf == NULL)
return 0;
my_len = 0;
buf_idx = 0;
matched_network = 0;
queue = &(pmlmepriv->scanned_queue);
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
plist = get_next(phead);
/* get requested measurement channel set */
pch_set = prm->q.ch_set;
meas_ch_num = prm->q.ch_set_ch_amount;
/* search scan queue to find requested SSID */
while (1) {
if (rtw_end_of_queue_search(phead, plist) == _TRUE)
break;
pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
pbss = &pnetwork->network;
#if 0
/*
* report network if requested channel set contains
* the channel matchs selected network
*/
if (rtw_chset_search_ch(adapter_to_chset(padapter),
pbss->Configuration.DSConfig) == 0)
goto next;
if (rtw_mlme_band_check(padapter, pbss->Configuration.DSConfig)
== _FALSE)
goto next;
#endif
if (rtw_validate_ssid(&(pbss->Ssid)) == _FALSE)
goto next;
/* match bssid */
if (is_wildcard_bssid(prm->q.bssid) == _FALSE)
if (_rtw_memcmp(prm->q.bssid,
pbss->MacAddress, 6) == _FALSE)
goto next;
/*
* default wildcard SSID. wildcard SSID:
* A SSID value (null) used to represent all SSIDs
*/
/* match ssid */
if ((prm->q.opt.bcn.ssid.SsidLength > 0) &&
_rtw_memcmp(prm->q.opt.bcn.ssid.Ssid,
pbss->Ssid.Ssid,
prm->q.opt.bcn.ssid.SsidLength) == _FALSE)
goto next;
/* go through measurement requested channels */
for (i = 0; i < prm->q.ch_set_ch_amount; i++) {
if ((pch_set[i].hw_value) ==
(pbss->Configuration.DSConfig)) /* match ch */
break;
}
if (i >= prm->q.ch_set_ch_amount) /* channel mismatch */
goto next;
/* match condition */
if (rm_bcn_req_cond_mach(prm, pnetwork) == _FALSE) {
RTW_INFO("RM: condition mismatch ch %u ssid %s bssid "MAC_FMT"\n",
pch_set[i].hw_value, pbss->Ssid.Ssid,
MAC_ARG(pbss->MacAddress));
RTW_INFO("RM: condition %u:%u\n",
prm->q.opt.bcn.rep_cond.cond,
prm->q.opt.bcn.rep_cond.threshold);
goto next;
}
/* Found a matched SSID */
matched_network++;
RTW_INFO("RM: ch %u Found %s bssid "MAC_FMT"\n",
pch_set[i].hw_value, pbss->Ssid.Ssid,
MAC_ARG(pbss->MacAddress));
len = 0;
_rtw_memset(tmp_buf, 0, xframe_ext_sz);
rm_gen_bcn_rep_ie(prm, tmp_buf, pnetwork, &len);
new_packet:
if (my_len == 0) {
pbuf = rtw_malloc(xframe_ext_sz);
if (pbuf == NULL)
goto fail;
prm->buf[buf_idx].pbuf = pbuf;
}
if ((xframe_ext_sz - (my_len + len + 24 + 4)) > 0) {
pbuf = rtw_set_fixed_ie(pbuf,
len, tmp_buf, &my_len);
prm->buf[buf_idx].len = my_len;
} else {
if (my_len == 0) /* not enough space */
goto fail;
my_len = 0;
buf_idx++;
goto new_packet;
}
next:
plist = get_next(plist);
} /* while() */
fail:
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
if (tmp_buf)
rtw_mfree(tmp_buf, xframe_ext_sz);
RTW_INFO("RM: Found %d matched %s\n", matched_network,
prm->q.opt.bcn.ssid.Ssid);
if (prm->buf[buf_idx].pbuf)
return buf_idx + 1;
return 0;
}
int issue_beacon_rep(struct rm_obj *prm)
{
int i, my_len;
u8 *pframe;
_adapter *padapter = prm->psta->padapter;
struct pkt_attrib *pattr;
struct xmit_frame *pmgntframe;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
int pkt_num;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u16 xframe_ext_sz = SZ_XMITFRAME_EXT;
pkt_num = retrieve_scan_result(prm);
if (pkt_num == 0) {
issue_null_reply(prm);
return _SUCCESS;
}
for (i=0;i<pkt_num;i++) {
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_ERR("RM: %s alloc xmit_frame fail\n",__func__);
goto fail;
}
pattr = &pmgntframe->attrib;
pframe = build_wlan_hdr(padapter,
pmgntframe, prm->psta, WIFI_ACTION);
pframe = rtw_set_fixed_ie(pframe,
3, &prm->p.category, &pattr->pktlen);
my_len = 0;
pframe = rtw_set_fixed_ie(pframe,
prm->buf[i].len, prm->buf[i].pbuf, &my_len);
pattr->pktlen += my_len;
pattr->last_txcmdsz = pattr->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
fail:
/*GEORGIA_TODO_FIXIT*/
for (i = 0; i < pkt_num; i++) {
if (prm->buf[i].pbuf) {
rtw_mfree(prm->buf[i].pbuf, xframe_ext_sz);
prm->buf[i].pbuf = NULL;
prm->buf[i].len = 0;
}
}
return _SUCCESS;
}
/* neighbor request */
int issue_nb_req(struct rm_obj *prm)
{
_adapter *padapter = prm->psta->padapter;
struct sta_info *psta = prm->psta;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pmgntframe = NULL;
struct pkt_attrib *pattr = NULL;
u8 val8;
u8 *pframe = NULL;
RTW_INFO("RM: %s\n", __func__);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_ERR("RM: %s alloc xmit_frame fail\n",__func__);
return _FALSE;
}
pattr = &pmgntframe->attrib;
pframe = build_wlan_hdr(padapter, pmgntframe, psta, WIFI_ACTION);
pframe = rtw_set_fixed_ie(pframe,
3, &prm->q.category, &pattr->pktlen);
if (prm->q.pssid) {
u8 sub_ie[64] = {0};
u8 *pie = &sub_ie[2];
RTW_INFO("RM: Send NB Req to "MAC_FMT" for(SSID) %s searching\n",
MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
pmlmepriv->cur_network.network.Ssid.Ssid);
val8 = strlen(prm->q.pssid);
sub_ie[0] = 0; /*SSID*/
sub_ie[1] = val8;
_rtw_memcpy(pie, prm->q.pssid, val8);
pframe = rtw_set_fixed_ie(pframe, val8 + 2,
sub_ie, &pattr->pktlen);
} else {
if (!pmlmepriv->cur_network.network.Ssid.SsidLength)
RTW_INFO("RM: Send NB Req to "MAC_FMT"\n",
MAC_ARG(pmlmepriv->cur_network.network.MacAddress));
else {
u8 sub_ie[64] = {0};
u8 *pie = &sub_ie[2];
RTW_INFO("RM: Send NB Req to "MAC_FMT" for(SSID) %s searching\n",
MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
pmlmepriv->cur_network.network.Ssid.Ssid);
sub_ie[0] = 0; /*SSID*/
sub_ie[1] = pmlmepriv->cur_network.network.Ssid.SsidLength;
_rtw_memcpy(pie, pmlmepriv->cur_network.network.Ssid.Ssid,
pmlmepriv->cur_network.network.Ssid.SsidLength);
pframe = rtw_set_fixed_ie(pframe,
pmlmepriv->cur_network.network.Ssid.SsidLength + 2,
sub_ie, &pattr->pktlen);
}
}
pattr->last_txcmdsz = pattr->pktlen;
dump_mgntframe(padapter, pmgntframe);
return _SUCCESS;
}
/* issue link measurement request */
int issue_link_meas_req(struct rm_obj *prm)
{
_adapter *padapter = prm->psta->padapter;
struct sta_info *psta = prm->psta;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pmgntframe = NULL;
struct pkt_attrib *pattr = NULL;
u8 *pframe = NULL;
s8 pwr_used, path_a_pwr;
RTW_INFO("RM: %s\n", __func__);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_ERR("RM: %s alloc xmit_frame fail\n",__func__);
return _FALSE;
}
pattr = &pmgntframe->attrib;
pframe = build_wlan_hdr(padapter, pmgntframe, psta, WIFI_ACTION);
/* Category, Action code, Dialog token */
pframe = rtw_set_fixed_ie(pframe,
3, &prm->q.category, &pattr->pktlen);
/* xmit power used */
/* we don't know actual TX power due to RA may change TX rate;
* But if we fix TX rate then we can get specific tx power
*/
pattr->rate = MGN_6M;
rm_get_tx_power(padapter, RF_PATH_A, MGN_6M, &pwr_used);
pframe = rtw_set_fixed_ie(pframe,
1, &pwr_used, &pattr->pktlen);
/* Max xmit power */
rm_get_path_a_max_tx_power(padapter, &path_a_pwr);
pframe = rtw_set_fixed_ie(pframe,
1, &path_a_pwr, &pattr->pktlen);
pattr->last_txcmdsz = pattr->pktlen;
dump_mgntframe(padapter, pmgntframe);
return _SUCCESS;
}
/* issue link measurement report */
int issue_link_meas_rep(struct rm_obj *prm)
{
u8 val8;
u8 *pframe;
unsigned int my_len;
_adapter *padapter = prm->psta->padapter;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattr;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_info *psta = prm->psta;
int i;
u8 tpc[4];
s8 pwr_used;
RTW_INFO("RM: %s\n", __func__);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_ERR("RM: ERR %s alloc xmit_frame fail\n",__func__);
return _FALSE;
}
pattr = &pmgntframe->attrib;
pframe = build_wlan_hdr(padapter, pmgntframe, psta, WIFI_ACTION);
/* Category, action code, Dialog token */
pframe = rtw_set_fixed_ie(pframe, 3,
&prm->p.category, &pattr->pktlen);
my_len = 0;
/* TPC report */
rm_get_tx_power(padapter, RF_PATH_A, MGN_6M, &pwr_used);
tpc[0] = EID_TPC;
tpc[1] = 2; /* length */
/* TX power */
tpc[2] = pwr_used;
/* link margin */
rm_get_rx_sensitivity(padapter, prm->q.rx_bw, prm->q.rx_rate, &pwr_used);
tpc[3] = prm->q.rx_pwr - pwr_used; /* RX sensitivity */
pattr->rate = MGN_6M; /* use fix rate to get fixed RX sensitivity */
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: rx_pwr=%ddBm - rx_sensitivity=%ddBm = link_margin=%ddB\n",
prm->q.rx_pwr, pwr_used, tpc[3]);
#endif
pframe = rtw_set_fixed_ie(pframe, 4, tpc, &my_len);
/* RECV antenna ID */
val8 = 0; /* unknown antenna */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* XMIT antenna ID */
/* Fix rate 6M(1T) always use main antenna to TX */
val8 = 1; /* main antenna */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* RCPI */
val8 = translate_dbm_to_rcpi(prm->q.rx_pwr);
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* RSNI */
val8 = prm->q.rx_rsni;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* length */
//val8 = (u8)my_len-2;
//rtw_set_fixed_ie(plen, 1, &val8, &i); /* use variable i to ignore it */
pattr->pktlen += my_len;
pattr->last_txcmdsz = pattr->pktlen;
dump_mgntframe(padapter, pmgntframe);
return _SUCCESS;
}
static u8 *rm_gen_bcn_req_s_elem(_adapter *padapter,
struct rm_obj *prm, u8 *pframe, unsigned int *fr_len)
{
u8 val8, l;
int i;
unsigned int my_len = 0;
struct _RT_OPERATING_CLASS *op;
val8 = bcn_req_active; /* measurement mode T8-64 */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* bssid */
pframe = rtw_set_fixed_ie(pframe, 6, prm->q.bssid, &my_len);
/*
* opt ssid (0)
*/
l = MIN(32, (int)prm->q.opt.bcn.ssid.SsidLength);
l = (int)prm->q.opt.bcn.ssid.SsidLength;
if (l > 32)
RTW_ERR("RM: %s SSID len over size %d! skip it!\n",__func__, l);
if (l > 0 && l <= 32) {
/* Type */
val8 = bcn_req_ssid;
pframe = rtw_set_fixed_ie(pframe, 1,
&val8, &my_len);
/* Len */
pframe = rtw_set_fixed_ie(pframe, 1,
&l, &my_len);
/* Value */
pframe = rtw_set_fixed_ie(pframe, l,
prm->q.opt.bcn.ssid.Ssid, &my_len);
}
/*
* opt reporting detail (2)
*/
/* Type */
val8 = bcn_req_rep_detail;
pframe = rtw_set_fixed_ie(pframe, 1,
&val8, &my_len);
/* Len */
l = 1;
pframe = rtw_set_fixed_ie(pframe, 1,
&l, &my_len);
/* Value */
pframe = rtw_set_fixed_ie(pframe, l,
&prm->q.opt.bcn.rep_detail, &my_len);
/*
* opt request (10)
*/
if (prm->q.opt.bcn.req_id_num > 0) {
/* Type */
val8 = bcn_req_req;
pframe = rtw_set_fixed_ie(pframe, 1,
&val8, &my_len);
/* Len */
l = prm->q.opt.bcn.req_id_num;
pframe = rtw_set_fixed_ie(pframe, 1,
&l, &my_len);
/* Value */
pframe = rtw_set_fixed_ie(pframe, l,
prm->q.opt.bcn.req_id, &my_len);
}
/*
* opt ap channel report (51)
*/
for (i = 0; i < prm->q.opt.bcn.ap_ch_rpt_num; i++) {
op = prm->q.opt.bcn.ap_ch_rpt[i];
if (op == NULL)
break;
/* Type */
val8 = bcn_req_ap_ch_rep;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
l = (u8)op->Len + 1;
/* length */
pframe = rtw_set_fixed_ie(pframe, 1, &l, &my_len);
/* op class */
val8 = op->global_op_class;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* channel */
pframe = rtw_set_fixed_ie(pframe, op->Len, op->Channel, &my_len);
}
/* update length to caller */
*fr_len += my_len;
/* optional subelements */
return pframe;
}
static u8 *rm_gen_ch_load_req_s_elem(_adapter *padapter,
u8 *pframe, unsigned int *fr_len)
{
u8 val8;
unsigned int my_len = 0;
val8 = 1; /* 1: channel load T8-60 */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
val8 = 2; /* channel load length = 2 (extensible) */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
val8 = 0; /* channel load condition : 0 (issue when meas done) T8-61 */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
val8 = 0; /* channel load reference value : 0 */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* update length to caller */
*fr_len += my_len;
return pframe;
}
static u8 *rm_gen_noise_histo_req_s_elem(_adapter *padapter,
u8 *pframe, unsigned int *fr_len)
{
u8 val8;
unsigned int my_len = 0;
val8 = 1; /* 1: noise histogram T8-62 */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
val8 = 2; /* noise histogram length = 2 (extensible) */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
val8 = 0; /* noise histogram condition : 0 (issue when meas done) T8-63 */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
val8 = 0; /* noise histogram reference value : 0 */
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* update length to caller */
*fr_len += my_len;
return pframe;
}
int issue_radio_meas_req(struct rm_obj *prm)
{
u8 val8;
u8 *pframe;
u8 *plen;
u16 val16;
int my_len, i;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattr;
_adapter *padapter = prm->psta->padapter;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
RTW_INFO("RM: %s - %s\n", __func__, rm_type_req_name(prm->q.m_type));
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_ERR("RM: %s alloc xmit_frame fail\n",__func__);
return _FALSE;
}
pattr = &pmgntframe->attrib;
pframe = build_wlan_hdr(padapter, pmgntframe, prm->psta, WIFI_ACTION);
/* Category, Action code, Dialog token */
pframe = rtw_set_fixed_ie(pframe, 3, &prm->q.category, &pattr->pktlen);
/* repeat */
val16 = cpu_to_le16(prm->q.rpt);
pframe = rtw_set_fixed_ie(pframe, 2,
(unsigned char *)&(val16), &pattr->pktlen);
my_len = 0;
plen = pframe + 1;
/* Element ID, Length, Meas token, Meas Mode, Meas type, op class, ch */
pframe = rtw_set_fixed_ie(pframe, 7, &prm->q.e_id, &my_len);
/* random interval */
val16 = cpu_to_le16(prm->q.rand_intvl); /* TU */
pframe = rtw_set_fixed_ie(pframe, 2, (u8 *)&val16, &my_len);
/* measurement duration */
val16 = cpu_to_le16(prm->q.meas_dur);
pframe = rtw_set_fixed_ie(pframe, 2, (u8 *)&val16, &my_len);
/* optional subelement */
switch (prm->q.m_type) {
case bcn_req:
pframe = rm_gen_bcn_req_s_elem(padapter, prm, pframe, &my_len);
break;
case ch_load_req:
pframe = rm_gen_ch_load_req_s_elem(padapter, pframe, &my_len);
break;
case noise_histo_req:
pframe = rm_gen_noise_histo_req_s_elem(padapter,
pframe, &my_len);
break;
case basic_req:
default:
break;
}
/* length */
val8 = (u8)my_len - 2;
rtw_set_fixed_ie(plen, 1, &val8, &i);
pattr->pktlen += my_len;
pattr->last_txcmdsz = pattr->pktlen;
dump_mgntframe(padapter, pmgntframe);
return _SUCCESS;
}
int rm_radio_meas_report_cond(struct rm_obj *prm)
{
u8 val8;
int i, ret = _FAIL;
switch (prm->q.m_type) {
case ch_load_req:
val8 = prm->p.ch_load;
switch (prm->q.opt.clm.rep_cond.cond) {
case ch_load_cond_immediately:
ret = _SUCCESS;
break;
case ch_load_cond_anpi_equal_greater:
if (val8 >= prm->q.opt.clm.rep_cond.threshold)
ret = _SUCCESS;
break;
case ch_load_cond_anpi_equal_less:
if (val8 <= prm->q.opt.clm.rep_cond.threshold)
ret = _SUCCESS;
break;
default:
break;
}
break;
case noise_histo_req:
val8 = prm->p.anpi;
switch (prm->q.opt.nhm.rep_cond.cond) {
case noise_histo_cond_immediately:
ret = _SUCCESS;
break;
case noise_histo_cond_anpi_equal_greater:
if (val8 >= prm->q.opt.nhm.rep_cond.threshold)
ret = _SUCCESS;
break;
case noise_histo_cond_anpi_equal_less:
if (val8 <= prm->q.opt.nhm.rep_cond.threshold)
ret = _SUCCESS;
break;
default:
break;
}
break;
default:
break;
}
return ret;
}
int retrieve_radio_meas_result(struct rm_obj *prm)
{
#ifdef CONFIG_RTW_ACS
struct dvobj_priv *dvobj = adapter_to_dvobj(prm->psta->padapter);
#endif
int i, ch = -1;
u8 val8;
ch = rtw_chset_search_ch(adapter_to_chset(prm->psta->padapter),
prm->q.ch_num);
if ((ch == -1) || (ch >= MAX_CHANNEL_NUM)) {
RTW_ERR("RM: get ch(CH:%d) fail\n", prm->q.ch_num);
ch = 0;
}
switch (prm->q.m_type) {
case ch_load_req:
#if 0 /* def CONFIG_RTW_ACS */
val8 = hal_data->acs.clm_ratio[ch];
#else
val8 = 0;
#endif
prm->p.ch_load = val8;
break;
case noise_histo_req:
#if 0 /* def CONFIG_RTW_ACS */
/* ANPI */
prm->p.anpi = hal_data->acs.nhm_ratio[ch];
/* IPI 0~10 */
for (i=0;i<11;i++)
prm->p.ipi[i] = hal_data->acs.nhm[ch][i];
#else
val8 = 0;
prm->p.anpi = val8;
for (i=0;i<11;i++)
prm->p.ipi[i] = val8;
#endif
break;
default:
break;
}
return _SUCCESS;
}
int issue_radio_meas_rep(struct rm_obj *prm)
{
u8 val8;
u8 *pframe;
u8 *plen;
u16 val16;
u64 val64;
unsigned int my_len;
_adapter *padapter = prm->psta->padapter;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattr;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct sta_info *psta = prm->psta;
int i;
RTW_INFO("RM: %s\n", __func__);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
RTW_ERR("RM: ERR %s alloc xmit_frame fail\n",__func__);
return _FALSE;
}
pattr = &pmgntframe->attrib;
pframe = build_wlan_hdr(padapter, pmgntframe, psta, WIFI_ACTION);
pframe = rtw_set_fixed_ie(pframe, 3,
&prm->p.category, &pattr->pktlen);
my_len = 0;
plen = pframe + 1;
pframe = rtw_set_fixed_ie(pframe, 7, &prm->p.e_id, &my_len);
/* Actual Meas start time - 8 bytes */
val64 = cpu_to_le64(prm->meas_start_time);
pframe = rtw_set_fixed_ie(pframe, 8, (u8 *)&val64, &my_len);
/* measurement duration */
val16 = prm->meas_end_time - prm->meas_start_time;
val16 = cpu_to_le16(val16);
pframe = rtw_set_fixed_ie(pframe, 2, (u8 *)&val16, &my_len);
/* optional subelement */
switch (prm->q.m_type) {
case ch_load_req:
val8 = prm->p.ch_load;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
break;
case noise_histo_req:
/*
* AntennaID
* 0: unknown
* 255: multiple antenna (Diversity)
*/
val8 = 0;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* ANPI */
val8 = prm->p.anpi;
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
/* IPI 0~10 */
for (i=0;i<11;i++) {
val8 = prm->p.ipi[i];
pframe = rtw_set_fixed_ie(pframe, 1, &val8, &my_len);
}
break;
default:
break;
}
/* length */
val8 = (u8)my_len-2;
rtw_set_fixed_ie(plen, 1, &val8, &i); /* use variable i to ignore it */
pattr->pktlen += my_len;
pattr->last_txcmdsz = pattr->pktlen;
dump_mgntframe(padapter, pmgntframe);
return _SUCCESS;
}
void rtw_ap_parse_sta_rm_en_cap(_adapter *padapter,
struct sta_info *psta, struct rtw_ieee802_11_elems *elem)
{
if (elem->rm_en_cap) {
RTW_INFO("assoc.rm_en_cap="RM_CAP_FMT"\n",
RM_CAP_ARG(elem->rm_en_cap));
_rtw_memcpy(psta->rm_en_cap,
(elem->rm_en_cap), elem->rm_en_cap_len);
}
}
void RM_IE_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
int i;
_rtw_memcpy(&padapter->rmpriv.rm_en_cap_assoc, pIE->data, pIE->Length);
RTW_INFO("assoc.rm_en_cap="RM_CAP_FMT"\n", RM_CAP_ARG(pIE->data));
}
void update_rm_cap(u8 *frame_head, _adapter *pa, u32 pktlen, int offset)
{
u8 *res;
sint len;
res = rtw_get_ie(frame_head + offset, _EID_RRM_EN_CAP_IE_, &len,
pktlen - offset);
if (res != NULL)
_rtw_memcpy((void *)pa->rmpriv.rm_en_cap_def, (res + 2), len);
}
/* Debug command */
#if (RM_SUPPORT_IWPRIV_DBG)
static int hex2num(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
if (c >= 'A' && c <= 'F')
return c - 'A' + 10;
return -1;
}
int hex2byte(const char *hex)
{
int a, b;
a = hex2num(*hex++);
if (a < 0)
return -1;
b = hex2num(*hex++);
if (b < 0)
return -1;
return (a << 4) | b;
}
static char * hwaddr_parse(char *txt, u8 *addr)
{
size_t i;
for (i = 0; i < ETH_ALEN; i++) {
int a;
a = hex2byte(txt);
if (a < 0)
return NULL;
txt += 2;
addr[i] = a;
if (i < ETH_ALEN - 1 && *txt++ != ':')
return NULL;
}
return txt;
}
void rm_dbg_list_sta(_adapter *padapter, char *s)
{
int i;
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
_list *plist, *phead;
sprintf(pstr(s), "\n");
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist,
struct sta_info, hash_list);
plist = get_next(plist);
sprintf(pstr(s), "=========================================\n");
sprintf(pstr(s), "mac=" MAC_FMT "\n",
MAC_ARG(psta->phl_sta->mac_addr));
sprintf(pstr(s), "state=0x%x, aid=%d, macid=%d\n",
psta->state, psta->phl_sta->aid, psta->phl_sta->macid);
sprintf(pstr(s), "rm_cap="RM_CAP_FMT"\n",
RM_CAP_ARG(psta->rm_en_cap));
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
sprintf(pstr(s), "=========================================\n");
}
void rm_dbg_help(_adapter *padapter, char *s)
{
int i;
sprintf(pstr(s), "\n");
sprintf(pstr(s), "rrm list_sta\n");
sprintf(pstr(s), "rrm list_meas\n");
sprintf(pstr(s), "rrm add_meas <aid=1|mac=>,m=<bcn|clm|nhm|nb|link>,rpt=\n");
sprintf(pstr(s), "rrm run_meas <aid=1|evid=>\n");
sprintf(pstr(s), "rrm del_meas\n");
sprintf(pstr(s), "rrm run_meas rmid=xxxx,ev=xx\n");
sprintf(pstr(s), "rrm activate\n");
for (i=0;i<RM_EV_max;i++)
sprintf(pstr(s), "\t%2d %s\n",i, rm_event_name(i) );
sprintf(pstr(s), "\n");
}
struct sta_info *rm_get_sta(_adapter *padapter, u16 aid, u8* pbssid)
{
int i;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
_list *plist, *phead;
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist,
struct sta_info, hash_list);
plist = get_next(plist);
if (psta->phl_sta->aid == aid)
goto done;
if (pbssid && _rtw_memcmp(psta->phl_sta->mac_addr,
pbssid, 6))
goto done;
}
}
psta = NULL;
done:
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
return psta;
}
static int rm_dbg_modify_meas(_adapter *padapter, char *s)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
struct mlme_ext_info *pmlmeinfo = &padapter->mlmeextpriv.mlmext_info;
struct rm_obj *prm;
struct sta_info *psta;
char *pmac, *ptr, *paid, *prpt, *pnbp, *pclm, *pnhm, *pbcn, *plnk;
unsigned val;
u8 bssid[ETH_ALEN];
int i;
/* example :
* rrm add_meas <aid=1|mac=>,m=<nb|clm|nhm|bcn|link>,<rept=>
* rrm run_meas <aid=1|evid=>
*/
paid = strstr(s, "aid=");
pmac = strstr(s, "mac=");
pbcn = strstr(s, "m=bcn");
pclm = strstr(s, "m=clm");
pnhm = strstr(s, "m=nhm");
pnbp = strstr(s, "m=nb");
plnk = strstr(s, "m=link");
prpt = strstr(s, "rpt=");
/* set all ',' to NULL (end of line) */
ptr = s;
while (ptr) {
ptr = strchr(ptr, ',');
if (ptr) {
*(ptr) = 0x0;
ptr++;
}
}
prm = (struct rm_obj *)prmpriv->prm_sel;
prm->q.m_token = rm_gen_meas_token(padapter);
psta = prm->psta;
for (i=0;i<6;i++)
prm->q.bssid[i] = 0xff; /* wildcard bssid */
if (paid) { /* find sta_info according to aid */
paid += 4; /* skip aid= */
sscanf(paid, "%u", &val); /* aid=x */
psta = rm_get_sta(padapter, val, NULL);
} else if (pmac) { /* find sta_info according to bssid */
pmac += 4; /* skip mac= */
if (hwaddr_parse(pmac, bssid) == NULL) {
sprintf(pstr(s), "Err: \nincorrect mac format\n");
return _FAIL;
}
psta = rm_get_sta(padapter, 0xff, bssid);
}
if (psta) {
prm->psta = psta;
prm->q.diag_token = rm_gen_dialog_token(padapter);
prm->rmid = rm_gen_rmid(padapter, prm, RM_MASTER);
} else
return _FAIL;
prm->q.action_code = RM_ACT_RADIO_MEAS_REQ;
if (pbcn) {
prm->q.m_type = bcn_req;
prm->q.rand_intvl = le16_to_cpu(100);
prm->q.meas_dur = le16_to_cpu(100);
} else if (pnhm) {
prm->q.m_type = noise_histo_req;
} else if (pclm) {
prm->q.m_type = ch_load_req;
} else if (pnbp) {
prm->q.action_code = RM_ACT_NB_REP_REQ;
} else if (plnk) {
prm->q.action_code = RM_ACT_LINK_MEAS_REQ;
} else
return _FAIL;
if (prpt) {
prpt += 4; /* skip rpt= */
sscanf(prpt, "%u", &val);
prm->q.rpt = (u8)val;
}
return _SUCCESS;
}
static void rm_dbg_activate_meas(_adapter *padapter, char *s)
{
struct rm_priv *prmpriv = &(padapter->rmpriv);
struct rm_obj *prm;
if (prmpriv->prm_sel == NULL) {
sprintf(pstr(s), "\nErr: No inActivate measurement\n");
return;
}
prm = (struct rm_obj *)prmpriv->prm_sel;
/* verify attributes */
if (prm->psta == NULL) {
sprintf(pstr(s), "\nErr: inActivate meas has no psta\n");
return;
}
/* measure current channel */
prm->q.ch_num = padapter->mlmeextpriv.chandef.chan;
prm->q.op_class = rm_get_oper_class_via_ch(prm->q.ch_num);
/* enquee rmobj */
rm_enqueue_rmobj(padapter, prm, _FALSE);
sprintf(pstr(s), "\nActivate rmid=%x, state=%s, meas_type=%s\n",
prm->rmid, rm_state_name(prm->state),
rm_type_req_name(prm->q.m_type));
sprintf(pstr(s), "aid=%d, mac=" MAC_FMT "\n",
prm->psta->phl_sta->aid, MAC_ARG(prm->psta->phl_sta->mac_addr));
/* clearn inActivate prm info */
prmpriv->prm_sel = NULL;
}
/* for ioctl */
int rm_send_bcn_reqs(_adapter *padapter, u8 *sta_addr, u8 op_class, u8 ch,
u16 measure_duration, u8 measure_mode, u8 *bssid, u8 *ssid,
u8 reporting_detail,
u8 n_ap_ch_rpt, struct _RT_OPERATING_CLASS *rpt,
u8 n_elem_id, u8 *elem_id_list)
{
struct rm_obj *prm;
char *pact;
struct sta_info *psta;
struct _RT_OPERATING_CLASS *prpt;
void *ptr;
int i,j,sz;
u8 bcast[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
if (n_ap_ch_rpt > BCN_REQ_OPT_AP_CH_RPT_MAX_NUM) {
RTW_ERR("RM: chset num %d > %d\n",
n_ap_ch_rpt, BCN_REQ_OPT_AP_CH_RPT_MAX_NUM);
return -1;
}
/* dest sta */
psta = rtw_get_stainfo(&padapter->stapriv, sta_addr);
if (!psta) {
RTW_ERR("RM: psta not found\n");
return -2;
}
prm = rm_alloc_rmobj(padapter);
if (prm == NULL) {
RTW_ERR("RM: unable to alloc rm obj for requeset\n");
return -3;
}
prm->psta = psta;
prm->q.meas_dur = measure_duration;
/* Figure 8-104 Measurement Requested format */
prm->q.category = RTW_WLAN_CATEGORY_RADIO_MEAS;
prm->q.action_code = RM_ACT_RADIO_MEAS_REQ;
prm->q.m_mode = measure_mode;
prm->q.m_type = bcn_req;
prm->q.diag_token = rm_gen_dialog_token(padapter);
prm->q.m_token = rm_gen_meas_token(padapter);
prm->rmid = rm_gen_rmid(padapter, prm, RM_MASTER);
prm->q.e_id = _MEAS_REQ_IE_; /* 38 */
prm->q.ch_num = ch;
prm->q.op_class = op_class;
prm->from_ioctl = true;
if (bssid != NULL)
memcpy(prm->q.bssid, bssid, ETH_ALEN);
else
memcpy(prm->q.bssid, bcast, ETH_ALEN);
if (ssid != NULL) {
i = MIN(32, strlen(ssid));
prm->q.opt.bcn.ssid.SsidLength = i;
memcpy(prm->q.opt.bcn.ssid.Ssid, ssid, i);
}
if (n_ap_ch_rpt > 0) {
prm->q.opt.bcn.ap_ch_rpt_num = n_ap_ch_rpt;
j = 0;
for (i = 0; i < n_ap_ch_rpt; i++) {
prpt = rpt++;
if (prpt == NULL)
break;
sz = sizeof(struct _RT_OPERATING_CLASS) * prpt->Len;
ptr = rtw_malloc(sz);
_rtw_memcpy(ptr, prpt, sz);
prm->q.opt.bcn.ap_ch_rpt[i] = (struct _RT_OPERATING_CLASS *)ptr;
}
}
prm->q.opt.bcn.rep_detail = reporting_detail;
if ((n_elem_id > 0) && (n_elem_id < BCN_REQ_REQ_OPT_MAX_NUM)) {
prm->q.opt.bcn.req_id_num = n_elem_id;
_rtw_memcpy(prm->q.opt.bcn.req_id, elem_id_list, n_elem_id);
}
/* enquee rmobj */
rm_enqueue_rmobj(padapter, prm, _FALSE);
RTW_INFO("\nAdd rmid=%x, meas_type=%s ok\n",
prm->rmid, rm_type_req_name(prm->q.m_type));
if (prm->psta)
RTW_INFO("mac="MAC_FMT"\n", MAC_ARG(prm->psta->phl_sta->mac_addr));
return 0;
}
void indicate_beacon_report(u8 *sta_addr,
u8 n_measure_rpt, u32 elem_len, u8 *elem)
{
RTW_INFO("RM: recv bcn reprot from mac="MAC_FMT"\n", MAC_ARG(sta_addr));
}
static void rm_dbg_add_meas(_adapter *padapter, char *s)
{
struct rm_priv *prmpriv = &(padapter->rmpriv);
struct rm_obj *prm;
char *pact;
/* example :
* rrm add_meas <aid=1|mac=>,m=<nb|clm|nhm|link>
* rrm run_meas <aid=1|evid=>
*/
prm = (struct rm_obj *)prmpriv->prm_sel;
if (prm == NULL)
prm = rm_alloc_rmobj(padapter);
if (prm == NULL) {
sprintf(pstr(s), "\nErr: alloc meas fail\n");
return;
}
prmpriv->prm_sel = prm;
pact = strstr(s, "act");
if (rm_dbg_modify_meas(padapter, s) == _FAIL) {
sprintf(pstr(s), "\nErr: add meas fail\n");
rm_free_rmobj(prm);
prmpriv->prm_sel = NULL;
return;
}
prm->q.category = RTW_WLAN_CATEGORY_RADIO_MEAS;
prm->q.e_id = _MEAS_REQ_IE_; /* 38 */
sprintf(pstr(s), "\nAdd rmid=%x, meas_type=%s ok\n",
prm->rmid, rm_type_req_name(prm->q.m_type));
if (prm->psta)
sprintf(pstr(s), "mac="MAC_FMT"\n",
MAC_ARG(prm->psta->phl_sta->mac_addr));
if (pact)
rm_dbg_activate_meas(padapter, pstr(s));
}
static void rm_dbg_del_meas(_adapter *padapter, char *s)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
struct rm_obj *prm = (struct rm_obj *)prmpriv->prm_sel;
if (prm) {
sprintf(pstr(s), "\ndelete rmid=%x\n",prm->rmid);
/* free inActivate meas - enqueue yet */
prmpriv->prm_sel = NULL;
rtw_mfree(prmpriv->prm_sel, sizeof(struct rm_obj));
} else
sprintf(pstr(s), "Err: no inActivate measurement\n");
}
static void rm_dbg_run_meas(_adapter *padapter, char *s)
{
struct rm_obj *prm;
char *pevid, *prmid;
u32 rmid, evid;
prmid = strstr(s, "rmid="); /* hex */
pevid = strstr(s, "evid="); /* dec */
if (prmid && pevid) {
prmid += 5; /* rmid= */
sscanf(prmid, "%x", &rmid);
pevid += 5; /* evid= */
sscanf(pevid, "%u", &evid);
} else {
sprintf(pstr(s), "\nErr: incorrect attribute\n");
return;
}
prm = rm_get_rmobj(padapter, rmid);
if (!prm) {
sprintf(pstr(s), "\nErr: measurement not found\n");
return;
}
if (evid >= RM_EV_max) {
sprintf(pstr(s), "\nErr: wrong event id\n");
return;
}
rm_post_event(padapter, prm->rmid, evid);
sprintf(pstr(s), "\npost %s to rmid=%x\n",rm_event_name(evid), rmid);
}
static void rm_dbg_show_meas(struct rm_obj *prm, char *s)
{
struct sta_info *psta;
psta = prm->psta;
if (prm->q.action_code == RM_ACT_RADIO_MEAS_REQ) {
sprintf(pstr(s), "\nrmid=%x, meas_type=%s\n",
prm->rmid, rm_type_req_name(prm->q.m_type));
} else if (prm->q.action_code == RM_ACT_NB_REP_REQ) {
sprintf(pstr(s), "\nrmid=%x, action=neighbor_req\n",
prm->rmid);
} else
sprintf(pstr(s), "\nrmid=%x, action=unknown\n",
prm->rmid);
if (psta)
sprintf(pstr(s), "aid=%d, mac="MAC_FMT"\n",
psta->phl_sta->aid, MAC_ARG(psta->phl_sta->mac_addr));
sprintf(pstr(s), "clock=%d, state=%s, rpt=%u/%u\n",
(int)ATOMIC_READ(&prm->pclock->counter),
rm_state_name(prm->state), prm->p.rpt, prm->q.rpt);
}
static void rm_dbg_list_meas(_adapter *padapter, char *s)
{
int meas_amount;
struct rm_obj *prm;
struct sta_info *psta;
struct rm_priv *prmpriv = &padapter->rmpriv;
_queue *queue = &prmpriv->rm_queue;
_list *plist, *phead;
unsigned long sp_flags;
sprintf(pstr(s), "\n");
_rtw_spinlock_irq(&queue->lock, &sp_flags);
phead = get_list_head(queue);
plist = get_next(phead);
meas_amount = 0;
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
prm = LIST_CONTAINOR(plist, struct rm_obj, list);
meas_amount++;
plist = get_next(plist);
psta = prm->psta;
sprintf(pstr(s), "=========================================\n");
rm_dbg_show_meas(prm, s);
}
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
sprintf(pstr(s), "=========================================\n");
if (meas_amount==0) {
sprintf(pstr(s), "No Activate measurement\n");
sprintf(pstr(s), "=========================================\n");
}
if (prmpriv->prm_sel == NULL)
sprintf(pstr(s), "\nNo inActivate measurement\n");
else {
sprintf(pstr(s), "\ninActivate measurement\n");
rm_dbg_show_meas((struct rm_obj *)prmpriv->prm_sel, s);
}
}
#endif /* RM_SUPPORT_IWPRIV_DBG */
int verify_bcn_req(_adapter *padapter, struct sta_info *psta)
{
char *bssid = NULL;
char ssid[] = "RealKungFu";
u8 op_class = 0;
u8 ch = 255;
u16 measure_duration = 100;
u8 reporting_detaial = 0;
u8 n_ap_ch_rpt = 6;
u8 measure_mode = bcn_req_active;
u8 req[] = {1,2,3};
u8 req_len = sizeof(req);
static RT_OPERATING_CLASS US[] = {
/* 0, OP_CLASS_NULL */ //{ 0, 0, {}},
/* 1, OP_CLASS_1 */ {115, 4, {36, 40, 44, 48}},
/* 2, OP_CLASS_2 */ {118, 4, {52, 56, 60, 64}},
/* 3, OP_CLASS_3 */ {124, 4, {149, 153, 157, 161}},
/* 4, OP_CLASS_4 */ {121, 11, {100, 104, 108, 112, 116, 120, 124,
128, 132, 136, 140}},
/* 5, OP_CLASS_5 */ {125, 5, {149, 153, 157, 161, 165}},
/* 6, OP_CLASS_12 */ { 81, 11, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
};
rm_send_bcn_reqs(padapter, psta->phl_sta->mac_addr, op_class, ch,
measure_duration, measure_mode, bssid, ssid,
reporting_detaial, n_ap_ch_rpt, US, req_len, req);
return 0;
}
void rm_dbg_cmd(_adapter *padapter, char *s)
{
unsigned val;
char *paid;
struct sta_info *psta=NULL;
#if (RM_SUPPORT_IWPRIV_DBG)
if (_rtw_memcmp(s, "help", 4)) {
rm_dbg_help(padapter, s);
} else if (_rtw_memcmp(s, "send_bcn_req", 12)) {
/* rtwpriv wls1 rrm send_bcn_req aid=1 */
paid = strstr(s, "aid=");
if (paid) { /* find sta_info according to aid */
paid += 4; /* skip aid= */
sscanf(paid, "%u", &val); /* aid=x */
psta = rm_get_sta(padapter, val, NULL);
if (psta)
verify_bcn_req(padapter, psta);
}
} else if (_rtw_memcmp(s, "list_sta", 8)) {
rm_dbg_list_sta(padapter, s);
} else if (_rtw_memcmp(s, "list_meas", 9)) {
rm_dbg_list_meas(padapter, s);
} else if (_rtw_memcmp(s, "add_meas", 8)) {
rm_dbg_add_meas(padapter, s);
} else if (_rtw_memcmp(s, "del_meas", 8)) {
rm_dbg_del_meas(padapter, s);
} else if (_rtw_memcmp(s, "activate", 8)) {
rm_dbg_activate_meas(padapter, s);
} else if (_rtw_memcmp(s, "run_meas", 8)) {
rm_dbg_run_meas(padapter, s);
} else if (_rtw_memcmp(s, "nb", 2)) {
paid = strstr(s, "aid=");
if (paid) { /* find sta_info according to aid */
paid += 4; /* skip aid= */
sscanf(paid, "%u", &val); /* aid=x */
psta = rm_get_sta(padapter, val, NULL);
if (psta)
rm_add_nb_req(padapter, psta);
}
}
#else
sprintf(pstr(s), "\n");
sprintf(pstr(s), "rrm debug command was disabled\n");
#endif
}
#endif /* CONFIG_RTW_80211K */
|
2301_81045437/rtl8852be
|
core/rtw_rm.c
|
C
|
agpl-3.0
| 67,040
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#ifdef CONFIG_RTW_80211K
#include "rtw_rm_fsm.h"
#include "rtw_rm_util.h"
struct fsm_state {
u8 *name;
int(*fsm_func)(struct rm_obj *prm, enum RM_EV_ID evid);
};
static void rm_state_initial(struct rm_obj *prm);
static void rm_state_goto(struct rm_obj *prm, enum RM_STATE rm_state);
static void rm_state_run(struct rm_obj *prm, enum RM_EV_ID evid);
static struct rm_event *rm_dequeue_ev(_queue *queue);
static struct rm_obj *rm_dequeue_rm(_queue *queue);
void rm_timer_callback(void *data)
{
int i;
_adapter *padapter = (_adapter *)data;
struct rm_priv *prmpriv = &padapter->rmpriv;
struct rm_clock *pclock;
/* deal with clock */
for (i=0;i<RM_TIMER_NUM;i++) {
pclock = &prmpriv->clock[i];
if (pclock->prm == NULL
||(ATOMIC_READ(&(pclock->counter)) == 0))
continue;
ATOMIC_DEC(&(pclock->counter));
if (ATOMIC_READ(&(pclock->counter)) == 0)
rm_post_event(pclock->prm->psta->padapter,
pclock->prm->rmid, prmpriv->clock[i].evid);
}
_set_timer(&prmpriv->rm_timer, CLOCK_UNIT);
}
int rtw_init_rm(_adapter *padapter)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
RTW_INFO("RM: %s\n",__func__);
_rtw_init_queue(&(prmpriv->rm_queue));
_rtw_init_queue(&(prmpriv->ev_queue));
/* bit 0-7 */
prmpriv->rm_en_cap_def[0] = 0
| BIT(RM_LINK_MEAS_CAP_EN)
| BIT(RM_NB_REP_CAP_EN)
/*| BIT(RM_PARAL_MEAS_CAP_EN)*/
| BIT(RM_REPEAT_MEAS_CAP_EN)
| BIT(RM_BCN_PASSIVE_MEAS_CAP_EN)
| BIT(RM_BCN_ACTIVE_MEAS_CAP_EN)
| BIT(RM_BCN_TABLE_MEAS_CAP_EN)
/*| BIT(RM_BCN_MEAS_REP_COND_CAP_EN)*/;
/* bit 8-15 */
prmpriv->rm_en_cap_def[1] = 0
/*| BIT(RM_FRAME_MEAS_CAP_EN - 8)*/
#ifdef CONFIG_RTW_ACS
| BIT(RM_CH_LOAD_CAP_EN - 8)
| BIT(RM_NOISE_HISTO_CAP_EN - 8)
#endif
/*| BIT(RM_STATIS_MEAS_CAP_EN - 8)*/
/*| BIT(RM_LCI_MEAS_CAP_EN - 8)*/
/*| BIT(RM_LCI_AMIMUTH_CAP_EN - 8)*/
/*| BIT(RM_TRANS_STREAM_CAT_MEAS_CAP_EN - 8)*/
/*| BIT(RM_TRIG_TRANS_STREAM_CAT_MEAS_CAP_EN - 8)*/;
/* bit 16-23 */
prmpriv->rm_en_cap_def[2] = 0
/*| BIT(RM_AP_CH_REP_CAP_EN - 16)*/
/*| BIT(RM_RM_MIB_CAP_EN - 16)*/
/*| BIT(RM_OP_CH_MAX_MEAS_DUR0 - 16)*/
/*| BIT(RM_OP_CH_MAX_MEAS_DUR1 - 16)*/
/*| BIT(RM_OP_CH_MAX_MEAS_DUR2 - 16)*/
/*| BIT(RM_NONOP_CH_MAX_MEAS_DUR0 - 16)*/
/*| BIT(RM_NONOP_CH_MAX_MEAS_DUR1 - 16)*/
/*| BIT(RM_NONOP_CH_MAX_MEAS_DUR2 - 16)*/;
/* bit 24-31 */
prmpriv->rm_en_cap_def[3] = 0
/*| BIT(RM_MEAS_PILOT_CAP0 - 24)*/
/*| BIT(RM_MEAS_PILOT_CAP1 - 24)*/
/*| BIT(RM_MEAS_PILOT_CAP2 - 24)*/
/*| BIT(RM_MEAS_PILOT_TRANS_INFO_CAP_EN - 24)*/
/*| BIT(RM_NB_REP_TSF_OFFSET_CAP_EN - 24)*/
| BIT(RM_RCPI_MEAS_CAP_EN - 24)
| BIT(RM_RSNI_MEAS_CAP_EN - 24)
/*| BIT(RM_BSS_AVG_ACCESS_DELAY_CAP_EN - 24)*/;
/* bit 32-39 */
prmpriv->rm_en_cap_def[4] = 0
/*| BIT(RM_BSS_AVG_ACCESS_DELAY_CAP_EN - 32)*/
/*| BIT(RM_AVALB_ADMIS_CAPACITY_CAP_EN - 32)*/
/*| BIT(RM_ANT_CAP_EN - 32)*/;
prmpriv->enable = _TRUE;
prmpriv->meas_token = 1;
/* clock timer */
rtw_init_timer(&prmpriv->rm_timer,
rm_timer_callback, padapter);
_set_timer(&prmpriv->rm_timer, CLOCK_UNIT);
return _SUCCESS;
}
int rtw_deinit_rm(_adapter *padapter)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
struct rm_obj *prm;
struct rm_event *pev;
RTW_INFO("RM: %s\n",__func__);
prmpriv->enable = _FALSE;
_cancel_timer_ex(&prmpriv->rm_timer);
/* free all events and measurements */
while((pev = rm_dequeue_ev(&prmpriv->ev_queue)) != NULL)
rtw_mfree((void *)pev, sizeof(struct rm_event));
while((prm = rm_dequeue_rm(&prmpriv->rm_queue)) != NULL)
rm_state_run(prm, RM_EV_cancel);
_rtw_deinit_queue(&(prmpriv->rm_queue));
_rtw_deinit_queue(&(prmpriv->ev_queue));
return _SUCCESS;
}
int rtw_free_rm_priv(_adapter *padapter)
{
return rtw_deinit_rm(padapter);
}
static int rm_enqueue_ev(_queue *queue, struct rm_event *obj, bool to_head)
{
unsigned long sp_flags;
if (obj == NULL)
return _FAIL;
_rtw_spinlock_irq(&queue->lock, &sp_flags);
if (to_head)
rtw_list_insert_head(&obj->list, &queue->queue);
else
rtw_list_insert_tail(&obj->list, &queue->queue);
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
return _SUCCESS;
}
static void rm_set_clock(struct rm_obj *prm, u32 ms, enum RM_EV_ID evid)
{
ATOMIC_SET(&(prm->pclock->counter), (ms/CLOCK_UNIT));
prm->pclock->evid = evid;
}
static struct rm_clock *rm_alloc_clock(_adapter *padapter, struct rm_obj *prm)
{
int i;
struct rm_priv *prmpriv = &padapter->rmpriv;
struct rm_clock *pclock = NULL;
for (i=0;i<RM_TIMER_NUM;i++) {
pclock = &prmpriv->clock[i];
if (pclock->prm == NULL) {
pclock->prm = prm;
ATOMIC_SET(&(pclock->counter), 0);
pclock->evid = RM_EV_max;
break;
}
}
return pclock;
}
static void rm_cancel_clock(struct rm_obj *prm)
{
ATOMIC_SET(&(prm->pclock->counter), 0);
prm->pclock->evid = RM_EV_max;
}
static void rm_free_clock(struct rm_clock *pclock)
{
pclock->prm = NULL;
ATOMIC_SET(&(pclock->counter), 0);
pclock->evid = RM_EV_max;
}
static int is_list_linked(const struct list_head *head)
{
return head->prev != NULL;
}
void rm_free_rmobj(struct rm_obj *prm)
{
if (is_list_linked(&prm->list))
rtw_list_delete(&prm->list);
if (prm->q.pssid)
rtw_mfree(prm->q.pssid, strlen(prm->q.pssid)+1);
if (prm->q.opt.bcn.req_start)
rtw_mfree(prm->q.opt.bcn.req_start,
prm->q.opt.bcn.req_len);
if (prm->pclock)
rm_free_clock(prm->pclock);
rtw_mfree((void *)prm, sizeof(struct rm_obj));
}
struct rm_obj *rm_alloc_rmobj(_adapter *padapter)
{
struct rm_obj *prm;
prm = (struct rm_obj *)rtw_malloc(sizeof(struct rm_obj));
if (prm == NULL)
return NULL;
_rtw_memset(prm, 0, sizeof(struct rm_obj));
/* alloc timer */
if ((prm->pclock = rm_alloc_clock(padapter, prm)) == NULL) {
rm_free_rmobj(prm);
return NULL;
}
return prm;
}
int rm_enqueue_rmobj(_adapter *padapter, struct rm_obj *prm, bool to_head)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
_queue *queue = &prmpriv->rm_queue;
unsigned long sp_flags;
if (prm == NULL)
return _FAIL;
_rtw_spinlock_irq(&queue->lock, &sp_flags);
if (to_head)
rtw_list_insert_head(&prm->list, &queue->queue);
else
rtw_list_insert_tail(&prm->list, &queue->queue);
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
rm_state_initial(prm);
return _SUCCESS;
}
static struct rm_obj *rm_dequeue_rm(_queue *queue)
{
struct rm_obj *prm;
unsigned long sp_flags;
_rtw_spinlock_irq(&queue->lock, &sp_flags);
if (rtw_is_list_empty(&(queue->queue)))
prm = NULL;
else {
prm = LIST_CONTAINOR(get_next(&(queue->queue)),
struct rm_obj, list);
/* rtw_list_delete(&prm->list); */
}
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
return prm;
}
static struct rm_event *rm_dequeue_ev(_queue *queue)
{
struct rm_event *ev;
unsigned long sp_flags;
_rtw_spinlock_irq(&queue->lock, &sp_flags);
if (rtw_is_list_empty(&(queue->queue)))
ev = NULL;
else {
ev = LIST_CONTAINOR(get_next(&(queue->queue)),
struct rm_event, list);
rtw_list_delete(&ev->list);
}
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
return ev;
}
static struct rm_obj *_rm_get_rmobj(_queue *queue, u32 rmid)
{
_list *phead, *plist;
struct rm_obj *prm = NULL;
unsigned long sp_flags;
if (rmid == 0)
return NULL;
_rtw_spinlock_irq(&queue->lock, &sp_flags);
phead = get_list_head(queue);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
prm = LIST_CONTAINOR(plist, struct rm_obj, list);
if (rmid == (prm->rmid)) {
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
return prm;
}
plist = get_next(plist);
}
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
return NULL;
}
struct sta_info *rm_get_psta(_adapter *padapter, u32 rmid)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
struct rm_obj *prm;
prm = _rm_get_rmobj(&prmpriv->rm_queue, rmid);
if (prm)
return prm->psta;
return NULL;
}
struct rm_obj *rm_get_rmobj(_adapter *padapter, u32 rmid)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
return _rm_get_rmobj(&prmpriv->rm_queue, rmid);
}
u8 rtw_rm_post_envent_cmd(_adapter *padapter, u32 rmid, u8 evid)
{
struct cmd_obj *pcmd;
struct rm_event *pev;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
u8 res = _SUCCESS;
pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (pcmd == NULL) {
res = _FAIL;
goto exit;
}
pcmd->padapter = padapter;
pev = (struct rm_event*)rtw_zmalloc(sizeof(struct rm_event));
if (pev == NULL) {
rtw_mfree((u8 *) pcmd, sizeof(struct cmd_obj));
res = _FAIL;
goto exit;
}
pev->rmid = rmid;
pev->evid = evid;
init_h2fwcmd_w_parm_no_rsp(pcmd, pev, CMD_RM_POST_EVENT);
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
exit:
return res;
}
int rm_post_event(_adapter *padapter, u32 rmid, enum RM_EV_ID evid)
{
if (padapter->rmpriv.enable == _FALSE)
return _FALSE;
RTW_INFO("RM: post asyn %s to rmid=%x\n", rm_event_name(evid), rmid);
rtw_rm_post_envent_cmd(padapter, rmid, evid);
return _SUCCESS;
}
int _rm_post_event(_adapter *padapter, u32 rmid, enum RM_EV_ID evid)
{
struct rm_priv *prmpriv = &padapter->rmpriv;
struct rm_event *pev;
if (evid >= RM_EV_max || rmid == 0)
return _FALSE;
pev = (struct rm_event *)rtw_malloc(sizeof(struct rm_event));
if (pev == NULL)
return _FALSE;
pev->rmid = rmid;
pev->evid = evid;
RTW_INFO("RM: post sync %s to rmid=%x\n", rm_event_name(evid), rmid);
rm_enqueue_ev(&prmpriv->ev_queue, pev, _FALSE);
return _SUCCESS;
}
static void rm_bcast_aid_handler(_adapter *padapter, struct rm_event *pev)
{
_list *phead, *plist;
_queue *queue = &padapter->rmpriv.rm_queue;
struct rm_obj *prm;
unsigned long sp_flags;
_rtw_spinlock_irq(&queue->lock, &sp_flags);
phead = get_list_head(queue);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
prm = LIST_CONTAINOR(plist, struct rm_obj, list);
plist = get_next(plist);
if (RM_GET_AID(pev->rmid) == RM_GET_AID(prm->rmid)) {
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
rm_state_run(prm, pev->evid);
_rtw_spinlock_irq(&queue->lock, &sp_flags);
}
}
_rtw_spinunlock_irq(&queue->lock, &sp_flags);
return;
}
/* main handler of RM (Resource Management) */
void rm_handler(_adapter *padapter, struct rm_event *pe)
{
int i;
struct rm_priv *prmpriv = &padapter->rmpriv;
struct rm_obj *prm;
struct rm_event *pev;
/* dequeue event */
while((pev = rm_dequeue_ev(&prmpriv->ev_queue)) != NULL)
{
if (RM_IS_ID_FOR_ALL(pev->rmid)) {
/* apply to all aid mateched measurement */
rm_bcast_aid_handler(padapter, pev);
rtw_mfree((void *)pev, sizeof(struct rm_event));
continue;
}
/* retrieve rmobj */
prm = _rm_get_rmobj(&prmpriv->rm_queue, pev->rmid);
if (prm == NULL) {
RTW_ERR("RM: rmid=%x event=%s doesn't find rm obj\n",
pev->rmid, rm_event_name(pev->evid));
rtw_mfree((void *)pev, sizeof(struct rm_event));
return;
}
/* run state machine */
rm_state_run(prm, pev->evid);
rtw_mfree((void *)pev, sizeof(struct rm_event));
}
}
static int rm_issue_meas_req(struct rm_obj *prm)
{
switch (prm->q.action_code) {
case RM_ACT_RADIO_MEAS_REQ:
switch (prm->q.m_type) {
case bcn_req:
case ch_load_req:
case noise_histo_req:
issue_radio_meas_req(prm);
break;
default:
break;
} /* meas_type */
break;
case RM_ACT_NB_REP_REQ:
/* issue neighbor request */
issue_nb_req(prm);
break;
case RM_ACT_LINK_MEAS_REQ:
issue_link_meas_req(prm);
break;
default:
return _FALSE;
} /* action_code */
return _SUCCESS;
}
/*
* RM state machine
*/
static int rm_state_idle(struct rm_obj *prm, enum RM_EV_ID evid)
{
_adapter *padapter = prm->psta->padapter;
u8 val8;
u32 val32;
prm->p.category = RTW_WLAN_CATEGORY_RADIO_MEAS;
switch (evid) {
case RM_EV_state_in:
switch (prm->q.action_code) {
case RM_ACT_RADIO_MEAS_REQ:
/* copy attrib from meas_req to meas_rep */
prm->p.action_code = RM_ACT_RADIO_MEAS_REP;
prm->p.diag_token = prm->q.diag_token;
prm->p.e_id = _MEAS_RSP_IE_;
prm->p.m_token = prm->q.m_token;
prm->p.m_type = prm->q.m_type;
prm->p.rpt = prm->q.rpt;
prm->p.ch_num = prm->q.ch_num;
prm->p.op_class = prm->q.op_class;
if (prm->q.m_type == ch_load_req
|| prm->q.m_type == noise_histo_req) {
/*
* phydm measure current ch periodically
* scan current ch is not necessary
*/
val8 = padapter->mlmeextpriv.chandef.chan;
if (prm->q.ch_num == val8)
prm->poll_mode = 1;
}
RTW_INFO("RM: rmid=%x %s switch in repeat=%u\n",
prm->rmid, rm_type_req_name(prm->q.m_type),
prm->q.rpt);
break;
case RM_ACT_NB_REP_REQ:
prm->p.action_code = RM_ACT_NB_REP_RESP;
RTW_INFO("RM: rmid=%x Neighbor request switch in\n",
prm->rmid);
break;
case RM_ACT_LINK_MEAS_REQ:
prm->p.diag_token = prm->q.diag_token;
prm->p.action_code = RM_ACT_LINK_MEAS_REP;
RTW_INFO("RM: rmid=%x Link meas switch in\n",
prm->rmid);
break;
default:
prm->p.action_code = prm->q.action_code;
rm_set_rep_mode(prm, MEAS_REP_MOD_INCAP);
RTW_INFO("RM: rmid=%x recv unknown action %d\n",
prm->rmid,prm->p.action_code);
break;
} /* switch() */
if (prm->rmid & RM_MASTER) {
if (rm_issue_meas_req(prm) == _SUCCESS)
rm_state_goto(prm, RM_ST_WAIT_MEAS);
else
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
} else {
rm_state_goto(prm, RM_ST_DO_MEAS);
return _SUCCESS;
}
if (prm->p.m_mode) {
issue_null_reply(prm);
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
if (prm->q.rand_intvl) {
#if 0 /*GEORGIA_TODO_REDEFINE_IO*/
/* get low tsf to generate random interval */
val32 = rtw_read32(padapter, REG_TSFTR);
#endif
val32 = rtw_hal_get_ltsf(padapter);
val32 = val32 % prm->q.rand_intvl;
RTW_INFO("RM: rmid=%x rand_intval=%d, rand=%d\n",
prm->rmid, (int)prm->q.rand_intvl,val32);
rm_set_clock(prm, prm->q.rand_intvl,
RM_EV_delay_timer_expire);
return _SUCCESS;
}
break;
case RM_EV_delay_timer_expire:
rm_state_goto(prm, RM_ST_DO_MEAS);
break;
case RM_EV_cancel:
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_state_out:
rm_cancel_clock(prm);
break;
default:
break;
}
return _SUCCESS;
}
/* we do the measuring */
static int rm_state_do_meas(struct rm_obj *prm, enum RM_EV_ID evid)
{
_adapter *padapter = prm->psta->padapter;
u8 val8;
u64 val64;
switch (evid) {
case RM_EV_state_in:
if (prm->q.action_code == RM_ACT_RADIO_MEAS_REQ) {
switch (prm->q.m_type) {
case bcn_req:
if (prm->q.m_mode == bcn_req_bcn_table) {
RTW_INFO("RM: rmid=%x Beacon table\n",
prm->rmid);
rm_get_chset(prm);
_rm_post_event(padapter, prm->rmid,
RM_EV_survey_done);
return _SUCCESS;
}
break;
case ch_load_req:
case noise_histo_req:
if (prm->poll_mode)
_rm_post_event(padapter, prm->rmid,
RM_EV_survey_done);
return _SUCCESS;
default:
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
if (!ready_for_scan(prm)) {
prm->wait_busy = RM_BUSY_TRAFFIC_TIMES;
RTW_INFO("RM: wait busy traffic - %d\n",
prm->wait_busy);
rm_set_clock(prm, RM_WAIT_BUSY_TIMEOUT,
RM_EV_busy_timer_expire);
return _SUCCESS;
}
} else if (prm->q.action_code == RM_ACT_LINK_MEAS_REQ) {
; /* do nothing */
rm_state_goto(prm, RM_ST_SEND_REPORT);
return _SUCCESS;
}
_rm_post_event(padapter, prm->rmid, RM_EV_start_meas);
break;
case RM_EV_start_meas:
if (prm->q.action_code == RM_ACT_RADIO_MEAS_REQ) {
/* resotre measurement start time */
prm->meas_start_time = rtw_hal_get_tsftr_by_port(padapter
, rtw_hal_get_port(padapter));
switch (prm->q.m_type) {
case bcn_req:
val8 = 1; /* Enable free run counter */
rtw_hal_set_hwreg(padapter,
HW_VAR_FREECNT, &val8);
rm_sitesurvey(prm);
break;
case ch_load_req:
case noise_histo_req:
rm_sitesurvey(prm);
break;
default:
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
break;
}
}
/* handle measurement timeout */
rm_set_clock(prm, RM_MEAS_TIMEOUT, RM_EV_meas_timer_expire);
break;
case RM_EV_survey_done:
if (prm->q.action_code == RM_ACT_RADIO_MEAS_REQ) {
switch (prm->q.m_type) {
case bcn_req:
rm_cancel_clock(prm);
rm_state_goto(prm, RM_ST_SEND_REPORT);
return _SUCCESS;
case ch_load_req:
case noise_histo_req:
retrieve_radio_meas_result(prm);
if (rm_radio_meas_report_cond(prm) == _SUCCESS)
rm_state_goto(prm, RM_ST_SEND_REPORT);
else
rm_set_clock(prm, RM_COND_INTVL,
RM_EV_retry_timer_expire);
break;
default:
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
}
break;
case RM_EV_meas_timer_expire:
RTW_INFO("RM: rmid=%x measurement timeount\n",prm->rmid);
rm_set_rep_mode(prm, MEAS_REP_MOD_REFUSE);
issue_null_reply(prm);
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_busy_timer_expire:
if (!ready_for_scan(prm) && prm->wait_busy--) {
RTW_INFO("RM: wait busy - %d\n",prm->wait_busy);
rm_set_clock(prm, RM_WAIT_BUSY_TIMEOUT,
RM_EV_busy_timer_expire);
break;
}
else if (prm->wait_busy <= 0) {
RTW_INFO("RM: wait busy timeout\n");
rm_set_rep_mode(prm, MEAS_REP_MOD_REFUSE);
issue_null_reply(prm);
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
_rm_post_event(padapter, prm->rmid, RM_EV_start_meas);
break;
case RM_EV_request_timer_expire:
rm_set_rep_mode(prm, MEAS_REP_MOD_REFUSE);
issue_null_reply(prm);
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_retry_timer_expire:
/* expired due to meas condition mismatch, meas again */
_rm_post_event(padapter, prm->rmid, RM_EV_start_meas);
break;
case RM_EV_cancel:
rm_set_rep_mode(prm, MEAS_REP_MOD_REFUSE);
issue_null_reply(prm);
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_state_out:
rm_cancel_clock(prm);
/* resotre measurement end time */
prm->meas_end_time = rtw_hal_get_tsftr_by_port(padapter
, rtw_hal_get_port(padapter));
val8 = 0; /* Disable free run counter */
rtw_hal_set_hwreg(padapter, HW_VAR_FREECNT, &val8);
break;
default:
break;
}
return _SUCCESS;
}
static int rm_state_wait_meas(struct rm_obj *prm, enum RM_EV_ID evid)
{
u8 val8;
u64 val64;
switch (evid) {
case RM_EV_state_in:
/* we create meas_req, waiting for peer report */
rm_set_clock(prm, RM_REQ_TIMEOUT,
RM_EV_request_timer_expire);
break;
case RM_EV_recv_rep:
rm_state_goto(prm, RM_ST_RECV_REPORT);
break;
case RM_EV_request_timer_expire:
case RM_EV_cancel:
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_state_out:
rm_cancel_clock(prm);
break;
default:
break;
}
return _SUCCESS;
}
static int rm_state_send_report(struct rm_obj *prm, enum RM_EV_ID evid)
{
u8 val8;
switch (evid) {
case RM_EV_state_in:
/* we have to issue report */
if (prm->q.action_code == RM_ACT_RADIO_MEAS_REQ) {
switch (prm->q.m_type) {
case bcn_req:
issue_beacon_rep(prm);
break;
case ch_load_req:
case noise_histo_req:
issue_radio_meas_rep(prm);
break;
default:
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
} else if (prm->q.action_code == RM_ACT_LINK_MEAS_REQ) {
issue_link_meas_rep(prm);
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
} else {
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
/* check repeat */
if (prm->p.rpt) {
RTW_INFO("RM: rmid=%x repeat=%u/%u\n",
prm->rmid, prm->p.rpt,
prm->q.rpt);
prm->p.rpt--;
/*
* we recv meas_req,
* delay for a wihile and than meas again
*/
if (prm->poll_mode)
rm_set_clock(prm, RM_REPT_POLL_INTVL,
RM_EV_repeat_delay_expire);
else
rm_set_clock(prm, RM_REPT_SCAN_INTVL,
RM_EV_repeat_delay_expire);
return _SUCCESS;
}
/* we are done */
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_repeat_delay_expire:
rm_state_goto(prm, RM_ST_DO_MEAS);
break;
case RM_EV_cancel:
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_state_out:
rm_cancel_clock(prm);
break;
default:
break;
}
return _SUCCESS;
}
static int rm_state_recv_report(struct rm_obj *prm, enum RM_EV_ID evid)
{
u8 val8;
switch (evid) {
case RM_EV_state_in:
/* we issue meas_req, got peer's meas report */
switch (prm->p.action_code) {
case RM_ACT_RADIO_MEAS_REP:
/* check refuse, incapable and repeat */
val8 = prm->p.m_mode;
if (val8) {
RTW_INFO("RM: rmid=%x peer reject (%s repeat=%d)\n",
prm->rmid,
val8|MEAS_REP_MOD_INCAP?"INCAP":
val8|MEAS_REP_MOD_REFUSE?"REFUSE":
val8|MEAS_REP_MOD_LATE?"LATE":"",
prm->p.rpt);
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
break;
case RM_ACT_NB_REP_RESP:
/* report to upper layer if needing */
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
default:
rm_state_goto(prm, RM_ST_END);
return _SUCCESS;
}
/* check repeat */
if (prm->p.rpt) {
RTW_INFO("RM: rmid=%x repeat=%u/%u\n",
prm->rmid, prm->p.rpt,
prm->q.rpt);
prm->p.rpt--;
/* waitting more report */
rm_state_goto(prm, RM_ST_WAIT_MEAS);
break;
}
/* we are done */
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_cancel:
rm_state_goto(prm, RM_ST_END);
break;
case RM_EV_state_out:
rm_cancel_clock(prm);
break;
default:
break;
}
return _SUCCESS;
}
static int rm_state_end(struct rm_obj *prm, enum RM_EV_ID evid)
{
switch (evid) {
case RM_EV_state_in:
_rm_post_event(prm->psta->padapter, prm->rmid, RM_EV_state_out);
break;
case RM_EV_cancel:
case RM_EV_state_out:
default:
rm_free_rmobj(prm);
break;
}
return _SUCCESS;
}
struct fsm_state rm_fsm[] = {
{"RM_ST_IDLE", rm_state_idle},
{"RM_ST_DO_MEAS", rm_state_do_meas},
{"RM_ST_WAIT_MEAS", rm_state_wait_meas},
{"RM_ST_SEND_REPORT", rm_state_send_report},
{"RM_ST_RECV_REPORT", rm_state_recv_report},
{"RM_ST_END", rm_state_end}
};
char *rm_state_name(enum RM_STATE state)
{
return rm_fsm[state].name;
}
char *rm_event_name(enum RM_EV_ID evid)
{
switch(evid) {
case RM_EV_state_in:
return "RM_EV_state_in";
case RM_EV_busy_timer_expire:
return "RM_EV_busy_timer_expire";
case RM_EV_delay_timer_expire:
return "RM_EV_delay_timer_expire";
case RM_EV_meas_timer_expire:
return "RM_EV_meas_timer_expire";
case RM_EV_repeat_delay_expire:
return "RM_EV_repeat_delay_expire";
case RM_EV_retry_timer_expire:
return "RM_EV_retry_timer_expire";
case RM_EV_request_timer_expire:
return "RM_EV_request_timer_expire";
case RM_EV_wait_report:
return "RM_EV_wait_report";
case RM_EV_start_meas:
return "RM_EV_start_meas";
case RM_EV_survey_done:
return "RM_EV_survey_done";
case RM_EV_recv_rep:
return "RM_EV_recv_report";
case RM_EV_cancel:
return "RM_EV_cancel";
case RM_EV_state_out:
return "RM_EV_state_out";
case RM_EV_max:
return "RM_EV_max";
default:
return "RM_EV_unknown";
}
return "UNKNOWN";
}
static void rm_state_initial(struct rm_obj *prm)
{
prm->state = RM_ST_IDLE;
RTW_INFO("\n");
RTW_INFO("RM: rmid=%x %-18s -> %s\n",prm->rmid,
"new measurement", rm_fsm[prm->state].name);
rm_post_event(prm->psta->padapter, prm->rmid, RM_EV_state_in);
}
static void rm_state_run(struct rm_obj *prm, enum RM_EV_ID evid)
{
RTW_INFO("RM: rmid=%x %-18s %s\n",prm->rmid,
rm_fsm[prm->state].name,rm_event_name(evid));
rm_fsm[prm->state].fsm_func(prm, evid);
}
static void rm_state_goto(struct rm_obj *prm, enum RM_STATE rm_state)
{
if (prm->state == rm_state)
return;
rm_state_run(prm, RM_EV_state_out);
RTW_INFO("\n");
RTW_INFO("RM: rmid=%x %-18s -> %s\n",prm->rmid,
rm_fsm[prm->state].name, rm_fsm[rm_state].name);
prm->state = rm_state;
rm_state_run(prm, RM_EV_state_in);
}
#endif /* CONFIG_RTW_80211K */
|
2301_81045437/rtl8852be
|
core/rtw_rm_fsm.c
|
C
|
agpl-3.0
| 24,277
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#ifdef CONFIG_RTW_80211K
#include "rtw_rm_fsm.h"
#include "rtw_rm_util.h"
/* 802.11-2012 Table E-1 Operationg classes in United States */
static RT_OPERATING_CLASS RTW_OP_CLASS_US[] = {
/* 0, OP_CLASS_NULL */ { 0, 0, {}},
/* 1, OP_CLASS_1 */ {115, 4, {36, 40, 44, 48}},
/* 2, OP_CLASS_2 */ {118, 4, {52, 56, 60, 64}},
/* 3, OP_CLASS_3 */ {124, 4, {149, 153, 157, 161}},
/* 4, OP_CLASS_4 */ {121, 11, {100, 104, 108, 112, 116, 120, 124,
128, 132, 136, 140}},
/* 5, OP_CLASS_5 */ {125, 5, {149, 153, 157, 161, 165}},
/* 6, OP_CLASS_12 */ { 81, 11, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}
};
u8 rm_get_ch_set(
struct rtw_ieee80211_channel *pch_set, u8 op_class, u8 ch_num)
{
int i,j,sz;
u8 ch_amount = 0;
sz = sizeof(RTW_OP_CLASS_US)/sizeof(struct _RT_OPERATING_CLASS);
if (ch_num != 0) {
pch_set[0].hw_value = ch_num;
ch_amount = 1;
RTW_INFO("RM: meas_ch->hw_value = %u\n", pch_set->hw_value);
goto done;
}
for (i = 0; i < sz; i++) {
if (RTW_OP_CLASS_US[i].global_op_class == op_class) {
for (j = 0; j < RTW_OP_CLASS_US[i].Len; j++) {
pch_set[j].hw_value =
RTW_OP_CLASS_US[i].Channel[j];
RTW_INFO("RM: meas_ch[%d].hw_value = %u\n",
j, pch_set[j].hw_value);
}
ch_amount = RTW_OP_CLASS_US[i].Len;
break;
}
}
done:
return ch_amount;
}
u8 rm_get_ch_set_from_bcn_req_opt(
struct rtw_ieee80211_channel *pch_set, struct bcn_req_opt *opt)
{
int i,j,k,sz;
struct _RT_OPERATING_CLASS *ap_ch_rpt;
u8 ch_amount = 0;
k = 0;
for (i = 0; i < opt->ap_ch_rpt_num; i++) {
if (opt->ap_ch_rpt[i] == NULL)
break;
ap_ch_rpt = opt->ap_ch_rpt[i];
for (j = 0; j < ap_ch_rpt->Len; j++) {
pch_set[k].hw_value =
ap_ch_rpt->Channel[j];
RTW_INFO("RM: meas_ch[%d].hw_value = %u\n",
j, pch_set[k].hw_value);
k++;
}
}
return k;
}
u8 rm_get_oper_class_via_ch(u8 ch)
{
int i,j,sz;
sz = sizeof(RTW_OP_CLASS_US)/sizeof(struct _RT_OPERATING_CLASS);
for (i = 0; i < sz; i++) {
for (j = 0; j < RTW_OP_CLASS_US[i].Len; j++) {
if ( ch == RTW_OP_CLASS_US[i].Channel[j]) {
RTW_INFO("RM: ch %u in oper_calss %u\n",
ch, RTW_OP_CLASS_US[i].global_op_class);
return RTW_OP_CLASS_US[i].global_op_class;
break;
}
}
}
return 0;
}
int is_wildcard_bssid(u8 *bssid)
{
int i;
u8 val8 = 0xff;
for (i=0;i<6;i++)
val8 &= bssid[i];
if (val8 == 0xff)
return _SUCCESS;
return _FALSE;
}
u8 translate_dbm_to_rcpi(s8 SignalPower)
{
/* RCPI = Int{(Power in dBm + 110)*2} for 0dBm > Power > -110dBm
* 0 : power <= -110.0 dBm
* 1 : power = -109.5 dBm
* 2 : power = -109.0 dBm
*/
return (SignalPower + 110)*2;
}
u8 translate_percentage_to_rcpi(u32 SignalStrengthIndex)
{
/* Translate to dBm (x=y-100) */
return translate_dbm_to_rcpi(SignalStrengthIndex - 100);
}
u8 rm_get_bcn_rcpi(struct rm_obj *prm, struct wlan_network *pnetwork)
{
return translate_percentage_to_rcpi(
pnetwork->network.PhyInfo.SignalStrength);
}
u8 rm_get_frame_rsni(struct rm_obj *prm, union recv_frame *pframe)
{
int i;
u8 val8 = 0, snr;
struct dvobj_priv *dvobj = adapter_to_dvobj(prm->psta->padapter);
u8 rf_path = GET_HAL_RFPATH_NUM(dvobj);
#if 0
if (IS_CCK_RATE((hw_rate_to_m_rate(pframe->u.hdr.attrib.data_rate))))
val8 = 255;
else {
snr = 0;
for (i = 0; i < rf_path; i++)
snr += pframe->u.hdr.attrib.phy_info.rx_snr[i];
snr = snr / rf_path;
val8 = (u8)(snr + 10)*2;
}
#endif
return val8;
}
u8 rm_get_bcn_rsni(struct rm_obj *prm, struct wlan_network *pnetwork)
{
int i;
u8 val8, snr;
struct dvobj_priv *dvobj = adapter_to_dvobj(prm->psta->padapter);
u8 rf_path = GET_HAL_RFPATH_NUM(dvobj);
if (pnetwork->network.PhyInfo.is_cck_rate) {
/* current HW doesn't have CCK RSNI */
/* 255 indicates RSNI is unavailable */
val8 = 255;
} else {
snr = 0;
for (i = 0; i < rf_path; i++) {
snr += pnetwork->network.PhyInfo.rx_snr[i];
}
snr = snr / rf_path;
val8 = (u8)(snr + 10)*2;
}
return val8;
}
/* output: pwr (unit dBm) */
int rm_get_tx_power(_adapter *adapter, enum rf_path path, enum MGN_RATE rate, s8 *pwr)
{
#if 0 /*GEORGIA_TODO_FIXIT*/
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct hal_spec_t *hal_spec = GET_HAL_SPEC(dvobj);
HAL_DATA_TYPE *hal_data = GET_PHL_COM(dvobj);
int tx_num, band, bw, ch, n, rs;
u8 base;
s8 limt_offset = 127; /* max value of s8 */
s8 rate_offset;
s8 powr_offset;
int rate_pos;
band = hal_data->current_band_type;
bw = hal_data->current_channel_bw;
ch = hal_data->current_channel;
if (!HAL_SPEC_CHK_RF_PATH(hal_spec, band, path))
return -1;
if (HAL_IsLegalChannel(adapter, ch) == _FALSE) {
RTW_INFO("Illegal channel!!\n");
return -2;
}
*pwr = phy_get_tx_power_final_absolute_value(adapter, path, rate, bw, ch);
#endif
return 0;
}
u8 rm_gen_dialog_token(_adapter *padapter)
{
struct rm_priv *prmpriv = &(padapter->rmpriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
do {
pmlmeinfo->dialogToken++;
} while (pmlmeinfo->dialogToken == 0);
return pmlmeinfo->dialogToken;
}
u8 rm_gen_meas_token(_adapter *padapter)
{
struct rm_priv *prmpriv = &(padapter->rmpriv);
do {
prmpriv->meas_token++;
} while (prmpriv->meas_token == 0);
return prmpriv->meas_token;
}
u32 rm_gen_rmid(_adapter *padapter, struct rm_obj *prm, u8 role)
{
u32 rmid;
if (prm->psta == NULL)
goto err;
if (prm->q.diag_token == 0)
goto err;
rmid = prm->psta->phl_sta->aid << 16
| prm->q.diag_token << 8
| role;
return rmid;
err:
RTW_ERR("RM: unable to gen rmid\n");
return 0;
}
int rm_get_rx_sensitivity(_adapter *adapter, enum channel_width bw, enum MGN_RATE rate, s8 *pwr)
{
s8 rx_sensitivity = -110;
switch(rate) {
case MGN_1M:
rx_sensitivity= -101;
break;
case MGN_2M:
rx_sensitivity= -98;
break;
case MGN_5_5M:
rx_sensitivity= -92;
break;
case MGN_11M:
rx_sensitivity= -89;
break;
case MGN_6M:
case MGN_9M:
case MGN_12M:
rx_sensitivity = -92;
break;
case MGN_18M:
rx_sensitivity = -90;
break;
case MGN_24M:
rx_sensitivity = -88;
break;
case MGN_36M:
rx_sensitivity = -84;
break;
case MGN_48M:
rx_sensitivity = -79;
break;
case MGN_54M:
rx_sensitivity = -78;
break;
case MGN_MCS0:
case MGN_MCS8:
case MGN_MCS16:
case MGN_MCS24:
case MGN_VHT1SS_MCS0:
case MGN_VHT2SS_MCS0:
case MGN_VHT3SS_MCS0:
case MGN_VHT4SS_MCS0:
/* BW20 BPSK 1/2 */
rx_sensitivity = -82;
break;
case MGN_MCS1:
case MGN_MCS9:
case MGN_MCS17:
case MGN_MCS25:
case MGN_VHT1SS_MCS1:
case MGN_VHT2SS_MCS1:
case MGN_VHT3SS_MCS1:
case MGN_VHT4SS_MCS1:
/* BW20 QPSK 1/2 */
rx_sensitivity = -79;
break;
case MGN_MCS2:
case MGN_MCS10:
case MGN_MCS18:
case MGN_MCS26:
case MGN_VHT1SS_MCS2:
case MGN_VHT2SS_MCS2:
case MGN_VHT3SS_MCS2:
case MGN_VHT4SS_MCS2:
/* BW20 QPSK 3/4 */
rx_sensitivity = -77;
break;
case MGN_MCS3:
case MGN_MCS11:
case MGN_MCS19:
case MGN_MCS27:
case MGN_VHT1SS_MCS3:
case MGN_VHT2SS_MCS3:
case MGN_VHT3SS_MCS3:
case MGN_VHT4SS_MCS3:
/* BW20 16-QAM 1/2 */
rx_sensitivity = -74;
break;
case MGN_MCS4:
case MGN_MCS12:
case MGN_MCS20:
case MGN_MCS28:
case MGN_VHT1SS_MCS4:
case MGN_VHT2SS_MCS4:
case MGN_VHT3SS_MCS4:
case MGN_VHT4SS_MCS4:
/* BW20 16-QAM 3/4 */
rx_sensitivity = -70;
break;
case MGN_MCS5:
case MGN_MCS13:
case MGN_MCS21:
case MGN_MCS29:
case MGN_VHT1SS_MCS5:
case MGN_VHT2SS_MCS5:
case MGN_VHT3SS_MCS5:
case MGN_VHT4SS_MCS5:
/* BW20 64-QAM 2/3 */
rx_sensitivity = -66;
break;
case MGN_MCS6:
case MGN_MCS14:
case MGN_MCS22:
case MGN_MCS30:
case MGN_VHT1SS_MCS6:
case MGN_VHT2SS_MCS6:
case MGN_VHT3SS_MCS6:
case MGN_VHT4SS_MCS6:
/* BW20 64-QAM 3/4 */
rx_sensitivity = -65;
break;
case MGN_MCS7:
case MGN_MCS15:
case MGN_MCS23:
case MGN_MCS31:
case MGN_VHT1SS_MCS7:
case MGN_VHT2SS_MCS7:
case MGN_VHT3SS_MCS7:
case MGN_VHT4SS_MCS7:
/* BW20 64-QAM 5/6 */
rx_sensitivity = -64;
break;
case MGN_VHT1SS_MCS8:
case MGN_VHT2SS_MCS8:
case MGN_VHT3SS_MCS8:
case MGN_VHT4SS_MCS8:
/* BW20 256-QAM 3/4 */
rx_sensitivity = -59;
break;
case MGN_VHT1SS_MCS9:
case MGN_VHT2SS_MCS9:
case MGN_VHT3SS_MCS9:
case MGN_VHT4SS_MCS9:
/* BW20 256-QAM 5/6 */
rx_sensitivity = -57;
break;
default:
return -1;
break;
}
switch(bw) {
case CHANNEL_WIDTH_20:
break;
case CHANNEL_WIDTH_40:
rx_sensitivity -= 3;
break;
case CHANNEL_WIDTH_80:
rx_sensitivity -= 6;
break;
case CHANNEL_WIDTH_160:
rx_sensitivity -= 9;
break;
case CHANNEL_WIDTH_5:
case CHANNEL_WIDTH_10:
case CHANNEL_WIDTH_80_80:
default:
return -1;
break;
}
*pwr = rx_sensitivity;
return 0;
}
/* output: path_a max tx power in dBm */
int rm_get_path_a_max_tx_power(_adapter *adapter, s8 *path_a)
{
#if 0 /*GEORGIA_TODO_FIXIT*/
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct hal_spec_t *hal_spec = GET_HAL_SPEC(dvobj);
HAL_DATA_TYPE *hal_data = GET_PHL_COM(dvobj);
int path, tx_num, band, bw, ch, n, rs;
u8 rate_num;
s8 max_pwr[RF_PATH_MAX], pwr;
band = hal_data->current_band_type;
bw = hal_data->current_channel_bw;
ch = hal_data->current_channel;
for (path = 0; path < RF_PATH_MAX; path++) {
if (!HAL_SPEC_CHK_RF_PATH(hal_spec, band, path))
break;
max_pwr[path] = -127; /* min value of s8 */
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: [%s][%c]\n", band_str(band), rf_path_char(path));
#endif
for (rs = 0; rs < RATE_SECTION_NUM; rs++) {
tx_num = rate_section_to_tx_num(rs);
if (tx_num >= hal_spec->tx_nss_num)
continue;
if (band == BAND_ON_5G && IS_CCK_RATE_SECTION(rs))
continue;
if (IS_VHT_RATE_SECTION(rs) && !IS_HARDWARE_TYPE_JAGUAR_ALL(adapter))
continue;
rate_num = rate_section_rate_num(rs);
/* get power by rate in db */
for (n = rate_num - 1; n >= 0; n--) {
pwr = phy_get_tx_power_final_absolute_value(adapter, path, rates_by_sections[rs].rates[n], bw, ch);
max_pwr[path] = MAX(max_pwr[path], pwr);
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: %9s = %2d\n",
MGN_RATE_STR(rates_by_sections[rs].rates[n]), pwr);
#endif
}
}
}
#if (RM_MORE_DBG_MSG)
RTW_INFO("RM: path_a max_pwr=%ddBm\n", max_pwr[0]);
#endif
*path_a = max_pwr[0];
#endif
return 0;
}
#endif /* CONFIG_RTW_80211K */
|
2301_81045437/rtl8852be
|
core/rtw_rm_util.c
|
C
|
agpl-3.0
| 10,909
|
/******************************************************************************
*
* Copyright(c) 2019 - 2020 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
/*rtw_mlme.c*/
void rtw_init_sitesurvey_parm(_adapter *padapter, struct sitesurvey_parm *pparm)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
_rtw_memset(pparm, 0, sizeof(struct sitesurvey_parm));
pparm->scan_mode = pmlmepriv->scan_mode;
}
#ifdef CONFIG_SET_SCAN_DENY_TIMER
inline bool rtw_is_scan_deny(_adapter *adapter)
{
struct mlme_priv *mlmepriv = &adapter->mlmepriv;
return (ATOMIC_READ(&mlmepriv->set_scan_deny) != 0) ? _TRUE : _FALSE;
}
inline void rtw_clear_scan_deny(_adapter *adapter)
{
struct mlme_priv *mlmepriv = &adapter->mlmepriv;
ATOMIC_SET(&mlmepriv->set_scan_deny, 0);
if (0)
RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
}
void rtw_set_scan_deny_timer_hdl(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
rtw_clear_scan_deny(adapter);
}
void rtw_set_scan_deny(_adapter *adapter, u32 ms)
{
struct mlme_priv *mlmepriv = &adapter->mlmepriv;
if (0)
RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
ATOMIC_SET(&mlmepriv->set_scan_deny, 1);
_set_timer(&mlmepriv->set_scan_deny_timer, ms);
}
#endif
void rtw_drv_scan_by_self(_adapter *padapter, u8 reason)
{
struct sitesurvey_parm parm;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int i;
#if 1
u8 ssc_chk;
ssc_chk = rtw_sitesurvey_condition_check(padapter, _FALSE);
if( ssc_chk == SS_DENY_BUSY_TRAFFIC) {
#ifdef CONFIG_LAYER2_ROAMING
if (rtw_chk_roam_flags(padapter, RTW_ROAM_ACTIVE) && pmlmepriv->need_to_roam == _TRUE) {
RTW_INFO(FUNC_ADPT_FMT" need to roam, don't care BusyTraffic\n", FUNC_ADPT_ARG(padapter));
} else
#endif
{
RTW_INFO(FUNC_ADPT_FMT" exit BusyTraffic\n", FUNC_ADPT_ARG(padapter));
goto exit;
}
} else if (ssc_chk != SS_ALLOW) {
goto exit;
}
if (!rtw_is_adapter_up(padapter))
goto exit;
#else
if (rtw_is_scan_deny(padapter))
goto exit;
if (!rtw_is_adapter_up(padapter))
goto exit;
if (rtw_mi_busy_traffic_check(padapter)) {
#ifdef CONFIG_LAYER2_ROAMING
if (rtw_chk_roam_flags(padapter, RTW_ROAM_ACTIVE) && pmlmepriv->need_to_roam == _TRUE) {
RTW_INFO("need to roam, don't care BusyTraffic\n");
} else
#endif
{
RTW_INFO(FUNC_ADPT_FMT" exit BusyTraffic\n", FUNC_ADPT_ARG(padapter));
goto exit;
}
}
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) && check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
RTW_INFO(FUNC_ADPT_FMT" WIFI_AP_STATE && WIFI_UNDER_WPS\n", FUNC_ADPT_ARG(padapter));
goto exit;
}
if (check_fwstate(pmlmepriv, (WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING)) == _TRUE) {
RTW_INFO(FUNC_ADPT_FMT" WIFI_UNDER_SURVEY|WIFI_UNDER_LINKING\n", FUNC_ADPT_ARG(padapter));
goto exit;
}
#ifdef CONFIG_CONCURRENT_MODE
if (rtw_mi_buddy_check_fwstate(padapter, (WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING | WIFI_UNDER_WPS))) {
RTW_INFO(FUNC_ADPT_FMT", but buddy_intf is under scanning or linking or wps_phase\n", FUNC_ADPT_ARG(padapter));
goto exit;
}
#endif
#endif
RTW_INFO(FUNC_ADPT_FMT" reason:0x%02x\n", FUNC_ADPT_ARG(padapter), reason);
/* only for 20/40 BSS */
if (reason == RTW_AUTO_SCAN_REASON_2040_BSS) {
rtw_init_sitesurvey_parm(padapter, &parm);
for (i=0;i<14;i++) {
parm.ch[i].hw_value = i + 1;
parm.ch[i].flags = RTW_IEEE80211_CHAN_PASSIVE_SCAN;
}
parm.ch_num = 14;
rtw_sitesurvey_cmd(padapter, &parm);
goto exit;
}
#ifdef CONFIG_RTW_MBO
#if defined(CONFIG_RTW_WNM) || defined(CONFIG_RTW_80211K)
if ((reason == RTW_AUTO_SCAN_REASON_ROAM)
&& (rtw_roam_nb_scan_list_set(padapter, &parm)))
goto exit;
#endif
#endif
rtw_sitesurvey_cmd(padapter, NULL);
exit:
return;
}
#ifdef CONFIG_RTW_ACS
u8 rtw_set_acs_sitesurvey(_adapter *adapter)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
struct sitesurvey_parm parm;
u8 uch;
u8 ch_num = 0;
int i;
enum band_type band;
u8 (*center_chs_num)(u8) = NULL;
u8 (*center_chs)(u8, u8) = NULL;
u8 ret = _FAIL;
if (!rtw_mi_get_ch_setting_union(adapter, &uch, NULL, NULL))
goto exit;
_rtw_memset(&parm, 0, sizeof(struct sitesurvey_parm));
parm.scan_mode = RTW_PHL_SCAN_PASSIVE;
parm.bw = CHANNEL_WIDTH_20;
parm.acs = 1;
for (band = BAND_ON_24G; band < BAND_MAX; band++) {
if (band == BAND_ON_24G) {
center_chs_num = center_chs_2g_num;
center_chs = center_chs_2g;
} else
#ifdef CONFIG_IEEE80211_BAND_5GHZ
if (band == BAND_ON_5G) {
center_chs_num = center_chs_5g_num;
center_chs = center_chs_5g;
} else
#endif
{
center_chs_num = NULL;
center_chs = NULL;
}
if (!center_chs_num || !center_chs)
continue;
if (rfctl->ch_sel_within_same_band) {
if (rtw_is_2g_ch(uch) && band != BAND_ON_24G)
continue;
#ifdef CONFIG_IEEE80211_BAND_5GHZ
if (rtw_is_5g_ch(uch) && band != BAND_ON_5G)
continue;
#endif
}
ch_num = center_chs_num(CHANNEL_WIDTH_20);
for (i = 0; i < ch_num && parm.ch_num < RTW_CHANNEL_SCAN_AMOUNT; i++) {
parm.ch[parm.ch_num].hw_value = center_chs(CHANNEL_WIDTH_20, i);
parm.ch[parm.ch_num].flags = RTW_IEEE80211_CHAN_PASSIVE_SCAN;
parm.ch_num++;
}
}
ret = rtw_sitesurvey_cmd(adapter, &parm);
exit:
return ret;
}
#endif /* CONFIG_RTW_ACS */
static u32 _rtw_wait_scan_done(_adapter *adapter, u32 timeout_ms)
{
systime start;
u32 pass_ms;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
u8 abort_timeout = false;
start = rtw_get_current_time();
while ((rtw_cfg80211_get_is_roch(adapter) == _TRUE || check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY))
&& rtw_get_passing_time_ms(start) <= timeout_ms) {
if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
break;
RTW_INFO(FUNC_NDEV_FMT"fw_state=WIFI_UNDER_SURVEY!\n", FUNC_NDEV_ARG(adapter->pnetdev));
rtw_msleep_os(20);
abort_timeout = true;
}
if (_TRUE == abort_timeout && check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)) {
if (!RTW_CANNOT_RUN(adapter_to_dvobj(adapter)))
RTW_ERR(FUNC_NDEV_FMT"waiting for scan_abort time out!\n",
FUNC_NDEV_ARG(adapter->pnetdev));
pmlmeext->scan_abort_to = _TRUE;
#ifdef CONFIG_PLATFORM_MSTAR
/*_clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY);*/
/*set_survey_timer(pmlmeext, 0);*/
mlme_set_scan_to_timer(pmlmepriv, 50);
#endif
rtw_indicate_scan_done(adapter, _TRUE);
}
pmlmeext->scan_abort = _FALSE;
RTW_INFO(FUNC_ADPT_FMT "- %s....scan_abort:%d\n",
FUNC_ADPT_ARG(adapter), __func__, pmlmeext->scan_abort);
pass_ms = rtw_get_passing_time_ms(start);
RTW_INFO("%s scan timeout value:%d ms, total take:%d ms\n",
__func__, timeout_ms, pass_ms);
return pass_ms;
}
/*
* timeout_ms > 0:rtw_scan_abort_timeout , = 0:rtw_scan_wait_completed
*/
u32 rtw_scan_abort(_adapter *adapter, u32 timeout_ms)
{
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
u32 pass_ms = 0;
if (rtw_cfg80211_get_is_roch(adapter) == _TRUE || check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)) {
pmlmeext->scan_abort = _TRUE;
RTW_INFO(FUNC_ADPT_FMT "- %s....scan_abort:%d\n",
FUNC_ADPT_ARG(adapter), __func__, pmlmeext->scan_abort);
rtw_sctx_init(&pmlmeext->sitesurvey_res.sctx, timeout_ms);
#ifdef CONFIG_CMD_SCAN
if (pmlmeext->sitesurvey_res.scan_param)
psts = rtw_phl_cmd_scan_cancel(adapter_to_dvobj(adapter)->phl,
pmlmeext->sitesurvey_res.scan_param);
#else
psts = rtw_phl_scan_cancel(adapter_to_dvobj(adapter)->phl);
#endif
if (psts == RTW_PHL_STATUS_SUCCESS)
rtw_sctx_wait(&pmlmeext->sitesurvey_res.sctx, __func__);
pass_ms = _rtw_wait_scan_done(adapter, timeout_ms);
}
return pass_ms;
}
void rtw_scan_abort_no_wait(_adapter *adapter)
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
#ifdef CONFIG_CMD_SCAN
if (pmlmeext->sitesurvey_res.scan_param)
rtw_phl_cmd_scan_cancel(adapter_to_dvobj(adapter)->phl,
pmlmeext->sitesurvey_res.scan_param);
#else
rtw_phl_scan_cancel(adapter_to_dvobj(adapter)->phl);
#endif
}
/*
* rtw_scan_timeout_handler - Timeout/Faliure handler for CMD SiteSurvey
* @adapter: pointer to _adapter structure
*/
void rtw_scan_timeout_handler(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
RTW_INFO(FUNC_ADPT_FMT" fw_state=%x\n", FUNC_ADPT_ARG(adapter), get_fwstate(pmlmepriv));
rtw_scan_abort_no_wait(adapter);
#if 0
_rtw_spinlock_bh(&pmlmepriv->lock);
_clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY);
_rtw_spinunlock_bh(&pmlmepriv->lock);
#ifdef CONFIG_IOCTL_CFG80211
rtw_cfg80211_surveydone_event_callback(adapter);
#endif /* CONFIG_IOCTL_CFG80211 */
rtw_indicate_scan_done(adapter, _TRUE);
#endif
}
static inline bool _rtw_scan_abort_check(_adapter *adapter, const char *caller)
{
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct submit_ctx *sctx = &pmlmeext->sitesurvey_res.sctx;
RTW_INFO(FUNC_ADPT_FMT "- %s....scan_abort:%d\n",
FUNC_ADPT_ARG(adapter), __func__, pmlmeext->scan_abort);
if (pmlmeext->scan_abort == _FALSE)
return _FALSE;
if (pmlmeext->scan_abort_to) {
RTW_ERR("%s scan abort timeout\n", caller);
rtw_warn_on(1);
}
_cancel_timer_ex(&pmlmepriv->scan_to_timer);
pmlmeext->scan_abort = _FALSE;
pmlmeext->scan_abort_to = _FALSE;
if (sctx) {
RTW_INFO("%s scan abort .....(%d ms)\n", caller, rtw_get_passing_time_ms(sctx->submit_time));
rtw_sctx_done(&sctx);
}
return _TRUE;
}
static struct wlan_network *alloc_network(struct mlme_priv *pmlmepriv) /* (_queue *free_queue) */
{
struct wlan_network *pnetwork;
pnetwork = _rtw_alloc_network(pmlmepriv);
return pnetwork;
}
static void update_current_network(_adapter *adapter, WLAN_BSSID_EX *pnetwork)
{
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) && (is_same_network(&(pmlmepriv->cur_network.network), pnetwork))) {
/* if(pmlmepriv->cur_network.network.IELength<= pnetwork->IELength) */
{
rtw_update_network(&(pmlmepriv->cur_network.network), pnetwork, adapter, _TRUE);
rtw_update_protection(adapter, (pmlmepriv->cur_network.network.IEs) + sizeof(NDIS_802_11_FIXED_IEs),
pmlmepriv->cur_network.network.IELength);
}
}
}
/*Caller must hold pmlmepriv->lock first.*/
static bool update_scanned_network(_adapter *adapter, WLAN_BSSID_EX *target)
{
_list *plist, *phead;
u32 bssid_ex_sz;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(adapter->wdinfo);
#endif /* CONFIG_P2P */
_queue *queue = &(pmlmepriv->scanned_queue);
struct wlan_network *pnetwork = NULL;
struct wlan_network *choice = NULL;
int target_find = 0;
bool update_ie = _FALSE;
_rtw_spinlock_bh(&queue->lock);
phead = get_list_head(queue);
plist = get_next(phead);
#if 0
RTW_INFO("%s => ssid:%s , rssi:%ld , ss:%d\n",
__func__, target->Ssid.Ssid, target->PhyInfo.rssi, target->PhyInfo.SignalStrength);
#endif
while (1) {
if (rtw_end_of_queue_search(phead, plist) == _TRUE)
break;
pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
#ifdef CONFIG_P2P
if (_rtw_memcmp(pnetwork->network.MacAddress, target->MacAddress, ETH_ALEN) &&
_rtw_memcmp(pnetwork->network.Ssid.Ssid, "DIRECT-", 7) &&
rtw_get_p2p_ie(pnetwork->network.IEs + _FIXED_IE_LENGTH_,
pnetwork->network.IELength - _FIXED_IE_LENGTH_,
NULL, NULL)) {
target_find = 1;
break;
}
#endif
if (is_same_network(&(pnetwork->network), target)) {
target_find = 1;
break;
}
if (rtw_roam_flags(adapter)) {
/* TODO: don't select netowrk in the same ess as choice if it's new enough*/
}
if (pnetwork->fixed) {
plist = get_next(plist);
continue;
}
#ifdef CONFIG_RSSI_PRIORITY
if ((choice == NULL) || (pnetwork->network.PhyInfo.SignalStrength < choice->network.PhyInfo.SignalStrength))
#ifdef CONFIG_RTW_MESH
if (!MLME_IS_MESH(adapter) || !MLME_IS_ASOC(adapter)
|| !rtw_bss_is_same_mbss(&pmlmepriv->cur_network.network, &pnetwork->network))
#endif
choice = pnetwork;
#else
if (choice == NULL || rtw_time_after(choice->last_scanned, pnetwork->last_scanned))
#ifdef CONFIG_RTW_MESH
if (!MLME_IS_MESH(adapter) || !MLME_IS_ASOC(adapter)
|| !rtw_bss_is_same_mbss(&pmlmepriv->cur_network.network, &pnetwork->network))
#endif
choice = pnetwork;
#endif
plist = get_next(plist);
}
/* If we didn't find a match, then get a new network slot to initialize
* with this beacon's information */
/* if (rtw_end_of_queue_search(phead,plist)== _TRUE) { */
if (!target_find) {
if (_rtw_queue_empty(&(pmlmepriv->free_bss_pool)) == _TRUE) {
/* If there are no more slots, expire the choice */
/* list_del_init(&choice->list); */
pnetwork = choice;
if (pnetwork == NULL)
goto unlock_scan_queue;
#ifdef CONFIG_RSSI_PRIORITY
RTW_DBG("%s => ssid:%s ,bssid:"MAC_FMT" will be deleted from scanned_queue (rssi:%d , ss:%d)\n",
__func__, pnetwork->network.Ssid.Ssid, MAC_ARG(pnetwork->network.MacAddress),
pnetwork->network.PhyInfo.rssi, pnetwork->network.PhyInfo.SignalStrength);
#else
RTW_DBG("%s => ssid:%s ,bssid:"MAC_FMT" will be deleted from scanned_queue\n",
__func__, pnetwork->network.Ssid.Ssid, MAC_ARG(pnetwork->network.MacAddress));
#endif
_rtw_memcpy(&(pnetwork->network), target, get_WLAN_BSSID_EX_sz(target));
/* pnetwork->last_scanned = rtw_get_current_time(); */
/* variable initialize */
pnetwork->fixed = _FALSE;
pnetwork->last_scanned = rtw_get_current_time();
#if defined(CONFIG_RTW_MESH) && CONFIG_RTW_MESH_ACNODE_PREVENT
pnetwork->acnode_stime = 0;
pnetwork->acnode_notify_etime = 0;
#endif
pnetwork->network_type = 0;
pnetwork->aid = 0;
pnetwork->join_res = 0;
/* bss info not receving from the right channel */
if (pnetwork->network.PhyInfo.SignalQuality == 101)
pnetwork->network.PhyInfo.SignalQuality = 0;
} else {
/* Otherwise just pull from the free list */
pnetwork = alloc_network(pmlmepriv); /* will update scan_time */
if (pnetwork == NULL)
goto unlock_scan_queue;
bssid_ex_sz = get_WLAN_BSSID_EX_sz(target);
target->Length = bssid_ex_sz;
_rtw_memcpy(&(pnetwork->network), target, bssid_ex_sz);
pnetwork->last_scanned = rtw_get_current_time();
/* bss info not receving from the right channel */
if (pnetwork->network.PhyInfo.SignalQuality == 101)
pnetwork->network.PhyInfo.SignalQuality = 0;
rtw_list_insert_tail(&(pnetwork->list), &(queue->queue));
}
} else {
/* we have an entry and we are going to update it. But this entry may
* be already expired. In this case we do the same as we found a new
* net and call the new_net handler
*/
#if defined(CONFIG_RTW_MESH) && CONFIG_RTW_MESH_ACNODE_PREVENT
systime last_scanned = pnetwork->last_scanned;
#endif
pnetwork->last_scanned = rtw_get_current_time();
/* target.Reserved[0]==BSS_TYPE_BCN, means that scanned network is a bcn frame. */
if ((pnetwork->network.IELength > target->IELength) && (target->Reserved[0] == BSS_TYPE_BCN))
update_ie = _FALSE;
if (MLME_IS_MESH(adapter)
/* probe resp(3) > beacon(1) > probe req(2) */
|| (target->Reserved[0] != BSS_TYPE_PROB_REQ
&& target->Reserved[0] >= pnetwork->network.Reserved[0])
)
update_ie = _TRUE;
else
update_ie = _FALSE;
#if defined(CONFIG_RTW_MESH) && CONFIG_RTW_MESH_ACNODE_PREVENT
if (!MLME_IS_MESH(adapter) || !MLME_IS_ASOC(adapter)
|| pnetwork->network.Configuration.DSConfig != target->Configuration.DSConfig
|| rtw_get_passing_time_ms(last_scanned) > adapter->mesh_cfg.peer_sel_policy.scanr_exp_ms
|| !rtw_bss_is_same_mbss(&pnetwork->network, target)
) {
pnetwork->acnode_stime = 0;
pnetwork->acnode_notify_etime = 0;
}
#endif
rtw_update_network(&(pnetwork->network), target, adapter, update_ie);
}
#if defined(CONFIG_RTW_MESH) && CONFIG_RTW_MESH_ACNODE_PREVENT
if (MLME_IS_MESH(adapter) && MLME_IS_ASOC(adapter))
rtw_mesh_update_scanned_acnode_status(adapter, pnetwork);
#endif
unlock_scan_queue:
_rtw_spinunlock_bh(&queue->lock);
#ifdef CONFIG_RTW_MESH
if (pnetwork && MLME_IS_MESH(adapter)
&& check_fwstate(pmlmepriv, WIFI_ASOC_STATE)
&& !check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)
)
rtw_chk_candidate_peer_notify(adapter, pnetwork);
#endif
return update_ie;
}
static void add_network(_adapter *adapter, WLAN_BSSID_EX *pnetwork)
{
bool update_ie;
/* _queue *queue = &(pmlmepriv->scanned_queue); */
/* _rtw_spinlock_bh(&queue->lock); */
#if defined(CONFIG_P2P) && defined(CONFIG_P2P_REMOVE_GROUP_INFO)
if (adapter->registrypriv.wifi_spec == 0)
rtw_bss_ex_del_p2p_attr(pnetwork, P2P_ATTR_GROUP_INFO);
#endif
#ifdef CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST
if (adapter->registrypriv.ignore_go_in_scan) {
if(rtw_chk_p2p_wildcard_ssid(pnetwork) == _SUCCESS ||
rtw_chk_p2p_ie(pnetwork) == _SUCCESS)
return;
}
/*100 was follow n & ac IC setting SignalStrength rang was 0~100*/
if(adapter->registrypriv->ignore_low_rssi_in_scan != 0xff &&
pnetwork->PhyInfo.rssi < (adapter->registrypriv->ignore_low_rssi_in_scan - 100))
return;
#endif /*CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST*/
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
rtw_bss_ex_del_wfd_ie(pnetwork);
/* Wi-Fi driver will update the current network if the scan result of the connected AP be updated by scan. */
update_ie = update_scanned_network(adapter, pnetwork);
if (update_ie)
update_current_network(adapter, pnetwork);
/* _rtw_spinunlock_bh(&queue->lock); */
}
void rtw_survey_event_callback(_adapter *adapter, u8 *pbuf)
{
u32 len;
u8 val8;
WLAN_BSSID_EX *pnetwork;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
pnetwork = (WLAN_BSSID_EX *)pbuf;
len = get_WLAN_BSSID_EX_sz(pnetwork);
if (len > (sizeof(WLAN_BSSID_EX))) {
return;
}
#ifdef CONFIG_RTW_80211K
val8 = 0;
rtw_hal_get_hwreg(adapter, HW_VAR_FREECNT, &val8);
/* use TSF if no free run counter */
if (val8==0)
pnetwork->PhyInfo.free_cnt = (u32)rtw_hal_get_tsftr_by_port(
adapter, rtw_hal_get_port(adapter));
#endif
if (pnetwork->InfrastructureMode == Ndis802_11Infrastructure) {
if (MLME_IS_SCAN(adapter)) {
adapter->mlmeextpriv.sitesurvey_res.activate_ch_cnt
+= rtw_process_beacon_hint(adapter, pnetwork);
}
}
_rtw_spinlock_bh(&pmlmepriv->lock);
/* update IBSS_network 's timestamp */
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == _TRUE) {
if (_rtw_memcmp(&(pmlmepriv->cur_network.network.MacAddress), pnetwork->MacAddress, ETH_ALEN)) {
struct wlan_network *ibss_wlan = NULL;
_rtw_memcpy(pmlmepriv->cur_network.network.IEs, pnetwork->IEs, 8);
_rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
ibss_wlan = _rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->MacAddress);
if (ibss_wlan) {
_rtw_memcpy(ibss_wlan->network.IEs , pnetwork->IEs, 8);
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
goto exit;
}
_rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
}
}
/* lock pmlmepriv->lock when you accessing network_q */
if ((check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) == _FALSE) {
if (pnetwork->Ssid.Ssid[0] == 0)
pnetwork->Ssid.SsidLength = 0;
add_network(adapter, pnetwork);
}
exit:
_rtw_spinunlock_bh(&pmlmepriv->lock);
return;
}
void rtw_surveydone_event_callback(_adapter *adapter, u8 *pbuf)
{
struct surveydone_event *parm = (struct surveydone_event *)pbuf;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
_rtw_spinlock_bh(&pmlmepriv->lock);
if (pmlmepriv->wps_probe_req_ie) {
u32 free_len = pmlmepriv->wps_probe_req_ie_len;
pmlmepriv->wps_probe_req_ie_len = 0;
rtw_mfree(pmlmepriv->wps_probe_req_ie, free_len);
pmlmepriv->wps_probe_req_ie = NULL;
}
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _FALSE) {
RTW_INFO(FUNC_ADPT_FMT" fw_state:0x%x\n", FUNC_ADPT_ARG(adapter), get_fwstate(pmlmepriv));
/* rtw_warn_on(1); */
}
_clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY);
_rtw_spinunlock_bh(&pmlmepriv->lock);
_cancel_timer_ex(&pmlmepriv->scan_to_timer);
_rtw_spinlock_bh(&pmlmepriv->lock);
#ifdef CONFIG_SIGNAL_STAT_PROCESS
rtw_set_signal_stat_timer(&adapter->recvinfo);
#endif
if (pmlmepriv->to_join == _TRUE) {
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE)) {
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
set_fwstate(pmlmepriv, WIFI_UNDER_LINKING);
if (rtw_select_and_join_from_scanned_queue(pmlmepriv) == _SUCCESS) {
/*_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);*/
set_assoc_timer(pmlmepriv, MAX_JOIN_TIMEOUT);
}
else {
WLAN_BSSID_EX *pdev_network = &(adapter->registrypriv.dev_network);
u8 *pibss = adapter->registrypriv.dev_network.MacAddress;
/* pmlmepriv->fw_state ^= WIFI_UNDER_SURVEY; */ /* because don't set assoc_timer */
_clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY);
_rtw_memset(&pdev_network->Ssid, 0, sizeof(NDIS_802_11_SSID));
_rtw_memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
rtw_update_registrypriv_dev_network(adapter);
rtw_generate_random_ibss(pibss);
/*pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;*/
init_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
if (rtw_create_ibss_cmd(adapter, 0) != _SUCCESS)
RTW_ERR("rtw_create_ibss_cmd FAIL\n");
pmlmepriv->to_join = _FALSE;
}
}
} else {
int s_ret;
set_fwstate(pmlmepriv, WIFI_UNDER_LINKING);
pmlmepriv->to_join = _FALSE;
s_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);
if (_SUCCESS == s_ret) {
/*_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);*/
set_assoc_timer(pmlmepriv, MAX_JOIN_TIMEOUT);
} else if (s_ret == 2) { /* there is no need to wait for join */
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
rtw_indicate_connect(adapter);
} else {
RTW_INFO("try_to_join, but select scanning queue fail, to_roam:%d\n", rtw_to_roam(adapter));
if (rtw_to_roam(adapter) != 0) {
struct sitesurvey_parm scan_parm;
u8 ssc_chk = rtw_sitesurvey_condition_check(adapter, _FALSE);
rtw_init_sitesurvey_parm(adapter, &scan_parm);
_rtw_memcpy(&scan_parm.ssid[0], &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
scan_parm.ssid_num = 1;
if (rtw_dec_to_roam(adapter) == 0
|| (ssc_chk != SS_ALLOW && ssc_chk != SS_DENY_BUSY_TRAFFIC)
|| _SUCCESS != rtw_sitesurvey_cmd(adapter, &scan_parm)
) {
rtw_set_to_roam(adapter, 0);
if (MLME_IS_ASOC(adapter) == _TRUE)
rtw_free_assoc_resources(adapter, _TRUE);
rtw_indicate_disconnect(adapter, 0, _FALSE);
} else
pmlmepriv->to_join = _TRUE;
} else
rtw_indicate_disconnect(adapter, 0, _FALSE);
_clr_fwstate_(pmlmepriv, WIFI_UNDER_LINKING);
}
}
} else {
if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)
#if (defined(CONFIG_RTW_WNM) && defined(CONFIG_RTW_80211R))
|| rtw_wnm_btm_roam_triggered(adapter)
#endif
) {
if (MLME_IS_STA(adapter)
&& check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) {
if (rtw_select_roaming_candidate(pmlmepriv) == _SUCCESS) {
#ifdef CONFIG_RTW_80211R
rtw_ft_start_roam(adapter,
(u8 *)pmlmepriv->roam_network->network.MacAddress);
#else
receive_disconnect(adapter, pmlmepriv->cur_network.network.MacAddress
, WLAN_REASON_ACTIVE_ROAM, _FALSE);
#endif
}
}
}
}
RTW_INFO("scan complete in %dms\n",rtw_get_passing_time_ms(pmlmepriv->scan_start_time));
_rtw_spinunlock_bh(&pmlmepriv->lock);
#ifdef CONFIG_P2P_PS
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
p2p_ps_wk_cmd(adapter, P2P_PS_SCAN_DONE, 0);
#endif /* CONFIG_P2P_PS */
rtw_mi_os_xmit_schedule(adapter);
#ifdef CONFIG_DRVEXT_MODULE_WSC
drvext_surveydone_callback(&adapter->drvextpriv);
#endif
#ifdef DBG_CONFIG_ERROR_DETECT
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
if (pmlmeext->sitesurvey_res.bss_cnt == 0) {
/* rtw_hal_sreset_reset(adapter); */
}
}
#endif
#ifdef CONFIG_IOCTL_CFG80211
rtw_cfg80211_surveydone_event_callback(adapter);
#endif /* CONFIG_IOCTL_CFG80211 */
rtw_indicate_scan_done(adapter, pmlmeext->scan_abort);
#if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_IOCTL_CFG80211)
rtw_cfg80211_indicate_scan_done_for_buddy(adapter, _FALSE);
#endif
if (parm->activate_ch_cnt) {
#ifdef CONFIG_IOCTL_CFG80211
struct get_chplan_resp *chplan;
if (rtw_get_chplan_cmd(adapter, RTW_CMDF_DIRECTLY, &chplan) != _SUCCESS
|| rtw_regd_change_complete_async(adapter_to_wiphy(adapter), chplan) != _SUCCESS)
rtw_warn_on(1);
#endif
op_class_pref_apply_regulatory(adapter, REG_BEACON_HINT);
rtw_nlrtw_reg_beacon_hint_event(adapter);
}
#ifdef CONFIG_RTW_MESH
#if CONFIG_RTW_MESH_OFFCH_CAND
if (rtw_mesh_offch_candidate_accepted(adapter)) {
u8 ch;
ch = rtw_mesh_select_operating_ch(adapter);
if (ch && pmlmepriv->cur_network.network.Configuration.DSConfig != ch) {
u8 ifbmp = rtw_mi_get_ap_mesh_ifbmp(adapter);
if (ifbmp) {
/* switch to selected channel */
rtw_change_bss_chbw_cmd(adapter, RTW_CMDF_DIRECTLY, ifbmp, 0, ch, REQ_BW_ORI, REQ_OFFSET_NONE);
issue_probereq_ex(adapter, &pmlmepriv->cur_network.network.mesh_id, NULL, 0, 0, 0, 0);
} else
rtw_warn_on(1);
}
}
#endif
#endif /* CONFIG_RTW_MESH */
#ifdef CONFIG_RTW_ACS
if (parm->acs) {
u8 ifbmp = rtw_mi_get_ap_mesh_ifbmp(adapter);
if (ifbmp)
rtw_change_bss_chbw_cmd(adapter, RTW_CMDF_DIRECTLY, ifbmp, 0, REQ_CH_INT_INFO, REQ_BW_ORI, REQ_OFFSET_NONE);
}
#endif
}
u8 _rtw_sitesurvey_condition_check(const char *caller, _adapter *adapter, bool check_sc_interval)
{
u8 ss_condition = SS_ALLOW;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct registry_priv *registry_par = &adapter->registrypriv;
#ifdef CONFIG_MP_INCLUDED
if (rtw_mp_mode_check(adapter)) {
RTW_INFO("%s ("ADPT_FMT") MP mode block Scan request\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_MP_MODE;
goto _exit;
}
#endif
#ifdef DBG_LA_MODE
if(registry_par->la_mode_en == 1 && MLME_IS_ASOC(adapter)) {
RTW_INFO("%s ("ADPT_FMT") LA debug mode block Scan request\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_LA_MODE;
goto _exit;
}
#endif
#ifdef CONFIG_IOCTL_CFG80211
if (adapter_wdev_data(adapter)->block_scan == _TRUE) {
RTW_INFO("%s ("ADPT_FMT") wdev_priv.block_scan is set\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_BLOCK_SCAN;
goto _exit;
}
#endif
if (adapter_to_dvobj(adapter)->scan_deny == _TRUE) {
RTW_INFO("%s ("ADPT_FMT") tpt mode, scan deny!\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_BLOCK_SCAN;
goto _exit;
}
if (rtw_is_scan_deny(adapter)) {
RTW_INFO("%s ("ADPT_FMT") : scan deny\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_BY_DRV;
goto _exit;
}
#if 0 /*GEORGIA_TODO_FIXIT*/
if (adapter_to_rfctl(adapter)->adaptivity_en
&& rtw_hal_get_phy_edcca_flag(adapter)
&& rtw_is_2g_ch(GET_PHL_COM(adapter_to_dvobj(adapter))->current_channel)) {
RTW_WARN(FUNC_ADPT_FMT": Adaptivity block scan! (ch=%u)\n",
FUNC_ADPT_ARG(adapter),
GET_PHL_COM(adapter_to_dvobj(adapter))->current_channel);
ss_condition = SS_DENY_ADAPTIVITY;
goto _exit;
}
#endif
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)){
if(check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
RTW_INFO("%s ("ADPT_FMT") : scan abort!! AP mode process WPS\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_SELF_AP_UNDER_WPS;
goto _exit;
} else if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE) {
RTW_INFO("%s ("ADPT_FMT") : scan abort!!AP mode under linking (fwstate=0x%x)\n",
caller, ADPT_ARG(adapter), pmlmepriv->fw_state);
ss_condition = SS_DENY_SELF_AP_UNDER_LINKING;
goto _exit;
} else if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE) {
RTW_INFO("%s ("ADPT_FMT") : scan abort!!AP mode under survey (fwstate=0x%x)\n",
caller, ADPT_ARG(adapter), pmlmepriv->fw_state);
ss_condition = SS_DENY_SELF_AP_UNDER_SURVEY;
goto _exit;
}
} else {
if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE) {
RTW_INFO("%s ("ADPT_FMT") : scan abort!!STA mode under linking (fwstate=0x%x)\n",
caller, ADPT_ARG(adapter), pmlmepriv->fw_state);
ss_condition = SS_DENY_SELF_STA_UNDER_LINKING;
goto _exit;
} else if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE) {
RTW_INFO("%s ("ADPT_FMT") : scan abort!!STA mode under survey (fwstate=0x%x)\n",
caller, ADPT_ARG(adapter), pmlmepriv->fw_state);
ss_condition = SS_DENY_SELF_STA_UNDER_SURVEY;
goto _exit;
}
}
#ifdef CONFIG_CONCURRENT_MODE
if (rtw_mi_buddy_check_fwstate(adapter, WIFI_UNDER_LINKING | WIFI_UNDER_WPS)) {
RTW_INFO("%s ("ADPT_FMT") : scan abort!! buddy_intf under linking or wps\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_BUDDY_UNDER_LINK_WPS;
goto _exit;
} else if (rtw_mi_buddy_check_fwstate(adapter, WIFI_UNDER_SURVEY)) {
RTW_INFO("%s ("ADPT_FMT") : scan abort!! buddy_intf under survey\n", caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_BUDDY_UNDER_SURVEY;
goto _exit;
}
#endif /* CONFIG_CONCURRENT_MODE */
#ifdef RTW_BUSY_DENY_SCAN
/*
* busy traffic check
* Rules:
* 1. If (scan interval <= BUSY_TRAFFIC_SCAN_DENY_PERIOD) always allow
* scan, otherwise goto rule 2.
* 2. Deny scan if any interface is busy, otherwise allow scan.
*/
if (pmlmepriv->lastscantime
&& (rtw_get_passing_time_ms(pmlmepriv->lastscantime) >
registry_par->scan_interval_thr)
&& rtw_mi_busy_traffic_check(adapter)) {
RTW_WARN("%s ("ADPT_FMT") : scan abort!! BusyTraffic\n",
caller, ADPT_ARG(adapter));
ss_condition = SS_DENY_BUSY_TRAFFIC;
goto _exit;
}
#endif /* RTW_BUSY_DENY_SCAN */
_exit:
return ss_condition;
}
/*rtw_mlme_ext.c*/
void sitesurvey_set_offch_state(_adapter *adapter, u8 scan_state)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
_rtw_mutex_lock_interruptible(&rfctl->offch_mutex);
switch (scan_state) {
case SCAN_DISABLE:
case SCAN_BACK_OP:
rfctl->offch_state = OFFCHS_NONE;
break;
case SCAN_START:
case SCAN_LEAVING_OP:
rfctl->offch_state = OFFCHS_LEAVING_OP;
break;
case SCAN_ENTER:
case SCAN_LEAVE_OP:
rfctl->offch_state = OFFCHS_LEAVE_OP;
break;
case SCAN_COMPLETE:
case SCAN_BACKING_OP:
rfctl->offch_state = OFFCHS_BACKING_OP;
break;
default:
break;
}
_rtw_mutex_unlock(&rfctl->offch_mutex);
}
static u8 rtw_scan_sparse(_adapter *adapter, struct rtw_ieee80211_channel *ch, u8 ch_num)
{
/* interval larger than this is treated as backgroud scan */
#ifndef RTW_SCAN_SPARSE_BG_INTERVAL_MS
#define RTW_SCAN_SPARSE_BG_INTERVAL_MS 12000
#endif
#ifndef RTW_SCAN_SPARSE_CH_NUM_MIRACAST
#define RTW_SCAN_SPARSE_CH_NUM_MIRACAST 1
#endif
#ifndef RTW_SCAN_SPARSE_CH_NUM_BG
#define RTW_SCAN_SPARSE_CH_NUM_BG 4
#endif
#define SCAN_SPARSE_CH_NUM_INVALID 255
static u8 token = 255;
u32 interval;
bool busy_traffic = _FALSE;
bool miracast_enabled = _FALSE;
bool bg_scan = _FALSE;
u8 max_allow_ch = SCAN_SPARSE_CH_NUM_INVALID;
u8 scan_division_num;
u8 ret_num = ch_num;
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
if (mlmeext->last_scan_time == 0)
mlmeext->last_scan_time = rtw_get_current_time();
interval = rtw_get_passing_time_ms(mlmeext->last_scan_time);
if (rtw_mi_busy_traffic_check(adapter))
busy_traffic = _TRUE;
if (rtw_mi_check_miracast_enabled(adapter))
miracast_enabled = _TRUE;
if (interval > RTW_SCAN_SPARSE_BG_INTERVAL_MS)
bg_scan = _TRUE;
/* max_allow_ch by conditions*/
#if RTW_SCAN_SPARSE_MIRACAST
if (miracast_enabled == _TRUE && busy_traffic == _TRUE)
max_allow_ch = rtw_min(max_allow_ch, RTW_SCAN_SPARSE_CH_NUM_MIRACAST);
#endif
#if RTW_SCAN_SPARSE_BG
if (bg_scan == _TRUE)
max_allow_ch = rtw_min(max_allow_ch, RTW_SCAN_SPARSE_CH_NUM_BG);
#endif
if (max_allow_ch != SCAN_SPARSE_CH_NUM_INVALID) {
int i;
int k = 0;
scan_division_num = (ch_num / max_allow_ch) + ((ch_num % max_allow_ch) ? 1 : 0);
token = (token + 1) % scan_division_num;
if (0)
RTW_INFO("scan_division_num:%u, token:%u\n", scan_division_num, token);
for (i = 0; i < ch_num; i++) {
if (ch[i].hw_value && (i % scan_division_num) == token
) {
if (i != k)
_rtw_memcpy(&ch[k], &ch[i], sizeof(struct rtw_ieee80211_channel));
k++;
}
}
_rtw_memset(&ch[k], 0, sizeof(struct rtw_ieee80211_channel));
ret_num = k;
mlmeext->last_scan_time = rtw_get_current_time();
}
return ret_num;
}
static int rtw_scan_ch_decision(_adapter *padapter, struct rtw_ieee80211_channel *out,
u32 out_num, struct rtw_ieee80211_channel *in, u32 in_num, bool no_sparse)
{
int i, j;
int set_idx;
u8 chan;
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
struct registry_priv *regsty = dvobj_to_regsty(adapter_to_dvobj(padapter));
/* clear first */
_rtw_memset(out, 0, sizeof(struct rtw_ieee80211_channel) * out_num);
/* acquire channels from in */
j = 0;
for (i = 0; i < in_num; i++) {
if (0)
RTW_INFO(FUNC_ADPT_FMT" "CHAN_FMT"\n", FUNC_ADPT_ARG(padapter), CHAN_ARG(&in[i]));
if (!in[i].hw_value || (in[i].flags & RTW_IEEE80211_CHAN_DISABLED))
continue;
if (rtw_mlme_band_check(padapter, in[i].hw_value) == _FALSE)
continue;
set_idx = rtw_chset_search_ch(rfctl->channel_set, in[i].hw_value);
if (set_idx >= 0) {
if (j >= out_num) {
RTW_PRINT(FUNC_ADPT_FMT" out_num:%u not enough\n",
FUNC_ADPT_ARG(padapter), out_num);
break;
}
_rtw_memcpy(&out[j], &in[i], sizeof(struct rtw_ieee80211_channel));
if (rfctl->channel_set[set_idx].flags & (RTW_CHF_NO_IR | RTW_CHF_DFS))
out[j].flags |= RTW_IEEE80211_CHAN_PASSIVE_SCAN;
j++;
}
if (j >= out_num)
break;
}
/* if out is empty, use channel_set as default */
if (j == 0) {
for (i = 0; i < rfctl->max_chan_nums; i++) {
chan = rfctl->channel_set[i].ChannelNum;
if (rtw_mlme_band_check(padapter, chan) == _TRUE) {
if (rtw_mlme_ignore_chan(padapter, chan) == _TRUE)
continue;
if (0)
RTW_INFO(FUNC_ADPT_FMT" ch:%u\n", FUNC_ADPT_ARG(padapter), chan);
if (j >= out_num) {
RTW_PRINT(FUNC_ADPT_FMT" out_num:%u not enough\n",
FUNC_ADPT_ARG(padapter), out_num);
break;
}
out[j].hw_value = chan;
if (rfctl->channel_set[i].flags & (RTW_CHF_NO_IR | RTW_CHF_DFS))
out[j].flags |= RTW_IEEE80211_CHAN_PASSIVE_SCAN;
j++;
}
}
}
if (!no_sparse
&& !regsty->wifi_spec
&& j > 6 /* assume ch_num > 6 is normal scan */
) {
/* scan_sparse */
j = rtw_scan_sparse(padapter, out, j);
}
return j;
}
#ifdef CONFIG_SCAN_BACKOP
u8 rtw_scan_backop_decision(_adapter *adapter)
{
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct mi_state mstate;
u8 backop_flags = 0;
rtw_mi_status(adapter, &mstate);
if ((MSTATE_STA_LD_NUM(&mstate) && mlmeext_chk_scan_backop_flags_sta(mlmeext, SS_BACKOP_EN))
|| (MSTATE_STA_NUM(&mstate) && mlmeext_chk_scan_backop_flags_sta(mlmeext, SS_BACKOP_EN_NL)))
backop_flags |= mlmeext_scan_backop_flags_sta(mlmeext);
#ifdef CONFIG_AP_MODE
if ((MSTATE_AP_LD_NUM(&mstate) && mlmeext_chk_scan_backop_flags_ap(mlmeext, SS_BACKOP_EN))
|| (MSTATE_AP_NUM(&mstate) && mlmeext_chk_scan_backop_flags_ap(mlmeext, SS_BACKOP_EN_NL)))
backop_flags |= mlmeext_scan_backop_flags_ap(mlmeext);
#endif
#ifdef CONFIG_RTW_MESH
if ((MSTATE_MESH_LD_NUM(&mstate) && mlmeext_chk_scan_backop_flags_mesh(mlmeext, SS_BACKOP_EN))
|| (MSTATE_MESH_NUM(&mstate) && mlmeext_chk_scan_backop_flags_mesh(mlmeext, SS_BACKOP_EN_NL)))
backop_flags |= mlmeext_scan_backop_flags_mesh(mlmeext);
#endif
return backop_flags;
}
#endif
#if 0 /*#ifndef CONFIG_PHL_ARCH*/
void survey_timer_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct cmd_obj *cmd;
struct sitesurvey_parm *psurveyPara;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
if (mlmeext_scan_state(pmlmeext) > SCAN_DISABLE) {
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL) {
rtw_warn_on(1);
goto exit;
}
cmd->padapter = padapter;
psurveyPara = (struct sitesurvey_parm *)rtw_zmalloc(sizeof(struct sitesurvey_parm));
if (psurveyPara == NULL) {
rtw_warn_on(1);
rtw_mfree((unsigned char *)cmd, sizeof(struct cmd_obj));
goto exit;
}
init_h2fwcmd_w_parm_no_rsp(cmd, psurveyPara, CMD_SITE_SURVEY);
rtw_enqueue_cmd(pcmdpriv, cmd);
}
exit:
return;
}
static const char *const _scan_state_str[] = {
"SCAN_DISABLE",
"SCAN_START",
"SCAN_PS_ANNC_WAIT",
"SCAN_ENTER",
"SCAN_PROCESS",
"SCAN_BACKING_OP",
"SCAN_BACK_OP",
"SCAN_LEAVING_OP",
"SCAN_LEAVE_OP",
"SCAN_SW_ANTDIV_BL",
"SCAN_TO_P2P_LISTEN",
"SCAN_P2P_LISTEN",
"SCAN_COMPLETE",
"SCAN_STATE_MAX",
};
void rtw_survey_cmd_callback(_adapter *padapter , struct cmd_obj *pcmd)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (pcmd->res == H2C_DROPPED) {
/* TODO: cancel timer and do timeout handler directly... */
/* need to make timeout handlerOS independent */
mlme_set_scan_to_timer(pmlmepriv, 1);
} else if (pcmd->res != H2C_SUCCESS) {
mlme_set_scan_to_timer(pmlmepriv, 1);
}
/* free cmd */
rtw_free_cmd_obj(pcmd);
}
const char *scan_state_str(u8 state)
{
state = (state >= SCAN_STATE_MAX) ? SCAN_STATE_MAX : state;
return _scan_state_str[state];
}
static bool scan_abort_hdl(_adapter *adapter)
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct ss_res *ss = &pmlmeext->sitesurvey_res;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
#endif
bool ret = _FALSE;
if (pmlmeext->scan_abort == _TRUE) {
#ifdef CONFIG_P2P
if (!rtw_p2p_chk_state(&adapter->wdinfo, P2P_STATE_NONE)) {
rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_MAX);
ss->channel_idx = 3;
RTW_INFO("%s idx:%d, cnt:%u\n", __FUNCTION__
, ss->channel_idx
, pwdinfo->find_phase_state_exchange_cnt
);
} else
#endif
{
ss->channel_idx = ss->ch_num;
RTW_INFO("%s idx:%d\n", __FUNCTION__
, ss->channel_idx
);
}
pmlmeext->scan_abort = _FALSE;
ret = _TRUE;
}
return ret;
}
static void sitesurvey_res_reset(_adapter *adapter, struct sitesurvey_parm *parm)
{
struct ss_res *ss = &adapter->mlmeextpriv.sitesurvey_res;
RT_CHANNEL_INFO *chset = adapter_to_chset(adapter);
int i;
ss->bss_cnt = 0;
ss->activate_ch_cnt = 0;
ss->channel_idx = 0;
ss->force_ssid_scan = 0;
ss->igi_scan = 0;
ss->igi_before_scan = 0;
#ifdef CONFIG_SCAN_BACKOP
ss->scan_cnt = 0;
#endif
#if defined(CONFIG_ANTENNA_DIVERSITY) || defined(DBG_SCAN_SW_ANTDIV_BL)
ss->is_sw_antdiv_bl_scan = 0;
#endif
ss->ssid_num = 0;
for (i = 0; i < RTW_SSID_SCAN_AMOUNT; i++) {
if (parm->ssid[i].SsidLength) {
_rtw_memcpy(ss->ssid[i].Ssid, parm->ssid[i].Ssid, IW_ESSID_MAX_SIZE);
ss->ssid[i].SsidLength = parm->ssid[i].SsidLength;
ss->ssid_num++;
} else
ss->ssid[i].SsidLength = 0;
}
ss->ch_num = rtw_scan_ch_decision(adapter
, ss->ch, RTW_CHANNEL_SCAN_AMOUNT
, parm->ch, parm->ch_num
, parm->acs
);
for (i = 0; i < MAX_CHANNEL_NUM; i++)
chset[i].hidden_bss_cnt = 0;
ss->bw = parm->bw;
ss->igi = parm->igi;
ss->token = parm->token;
ss->duration = parm->duration;
ss->scan_mode = parm->scan_mode;
ss->token = parm->token;
ss->acs = parm->acs;
}
static u8 sitesurvey_pick_ch_behavior(_adapter *padapter, u8 *ch,
enum rtw_phl_scan_type *type)
{
u8 next_state;
u8 scan_ch = 0;
enum rtw_phl_scan_type stype = RTW_PHL_SCAN_PASSIVE;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct ss_res *ss = &pmlmeext->sitesurvey_res;
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
int ch_set_idx;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
#endif
#ifdef CONFIG_SCAN_BACKOP
u8 backop_flags = 0;
#endif
/* handle scan abort request */
scan_abort_hdl(padapter);
#ifdef CONFIG_P2P
if (pwdinfo->rx_invitereq_info.scan_op_ch_only || pwdinfo->p2p_info.scan_op_ch_only) {
if (pwdinfo->rx_invitereq_info.scan_op_ch_only)
scan_ch = pwdinfo->rx_invitereq_info.operation_ch[ss->channel_idx];
else
scan_ch = pwdinfo->p2p_info.operation_ch[ss->channel_idx];
stype = RTW_PHL_SCAN_ACTIVE;
} else if (rtw_p2p_findphase_ex_is_social(pwdinfo)) {
/*
* Commented by Albert 2011/06/03
* The driver is in the find phase, it should go through the social channel.
*/
scan_ch = pwdinfo->social_chan[ss->channel_idx];
ch_set_idx = rtw_chset_search_ch(rfctl->channel_set, scan_ch);
if (ch_set_idx >= 0)
stype = rfctl->channel_set[ch_set_idx].flags & RTW_CHF_NO_IR ? RTW_PHL_SCAN_PASSIVE : RTW_PHL_SCAN_ACTIVE;
else
stype = RTW_PHL_SCAN_ACTIVE;
} else
#endif /* CONFIG_P2P */
{
struct rtw_ieee80211_channel *ch;
#ifdef CONFIG_SCAN_BACKOP
backop_flags = rtw_scan_backop_decision(padapter);
#endif
#ifdef CONFIG_SCAN_BACKOP
if (!(backop_flags && ss->scan_cnt >= ss->scan_cnt_max))
#endif
{
#ifdef CONFIG_RTW_WIFI_HAL
if (adapter_to_dvobj(padapter)->nodfs) {
while (ss->channel_idx < ss->ch_num && rtw_chset_is_dfs_ch(rfctl->channel_set, ss->ch[ss->channel_idx].hw_value))
ss->channel_idx++;
} else
#endif
if (ss->channel_idx != 0 && ss->force_ssid_scan == 0
&& pmlmeext->sitesurvey_res.ssid_num
&& (ss->ch[ss->channel_idx - 1].flags & RTW_IEEE80211_CHAN_PASSIVE_SCAN)
) {
ch_set_idx = rtw_chset_search_ch(rfctl->channel_set, ss->ch[ss->channel_idx - 1].hw_value);
if (ch_set_idx != -1 && rfctl->channel_set[ch_set_idx].hidden_bss_cnt
&& (!IS_DFS_SLAVE_WITH_RD(rfctl)
|| rtw_rfctl_dfs_domain_unknown(rfctl)
|| !CH_IS_NON_OCP(&rfctl->channel_set[ch_set_idx]))
) {
ss->channel_idx--;
ss->force_ssid_scan = 1;
}
} else
ss->force_ssid_scan = 0;
}
if (ss->channel_idx < ss->ch_num) {
ch = &ss->ch[ss->channel_idx];
scan_ch = ch->hw_value;
#if defined(CONFIG_RTW_ACS) && defined(CONFIG_RTW_ACS_DBG)
if (IS_ACS_ENABLE(padapter) && rtw_is_acs_passiv_scan(padapter))
stype = RTW_PHL_SCAN_PASSIVE;
else
#endif /*CONFIG_RTW_ACS*/
stype = (ch->flags & RTW_IEEE80211_CHAN_PASSIVE_SCAN) ? RTW_PHL_SCAN_PASSIVE : RTW_PHL_SCAN_ACTIVE;
}
}
if (scan_ch != 0) {
next_state = SCAN_PROCESS;
#ifdef CONFIG_SCAN_BACKOP
if (backop_flags) {
if (ss->scan_cnt < ss->scan_cnt_max)
ss->scan_cnt++;
else {
mlmeext_assign_scan_backop_flags(pmlmeext, backop_flags);
next_state = SCAN_BACKING_OP;
}
}
#endif
} else if (rtw_p2p_findphase_ex_is_needed(pwdinfo)) {
/* go p2p listen */
next_state = SCAN_TO_P2P_LISTEN;
#ifdef CONFIG_ANTENNA_DIVERSITY
} else if (rtw_hal_antdiv_before_linked(padapter)) {
/* go sw antdiv before link */
next_state = SCAN_SW_ANTDIV_BL;
#endif
} else {
next_state = SCAN_COMPLETE;
#if defined(DBG_SCAN_SW_ANTDIV_BL)
{
/* for SCAN_SW_ANTDIV_BL state testing */
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
int i;
bool is_linked = _FALSE;
for (i = 0; i < dvobj->iface_nums; i++) {
if (rtw_linked_check(dvobj->padapters[i]))
is_linked = _TRUE;
}
if (!is_linked) {
static bool fake_sw_antdiv_bl_state = 0;
if (fake_sw_antdiv_bl_state == 0) {
next_state = SCAN_SW_ANTDIV_BL;
fake_sw_antdiv_bl_state = 1;
} else
fake_sw_antdiv_bl_state = 0;
}
}
#endif /* defined(DBG_SCAN_SW_ANTDIV_BL) */
}
#ifdef CONFIG_SCAN_BACKOP
if (next_state != SCAN_PROCESS)
ss->scan_cnt = 0;
#endif
#ifdef DBG_FIXED_CHAN
if (pmlmeext->fixed_chan != 0xff && next_state == SCAN_PROCESS)
scan_ch = pmlmeext->fixed_chan;
#endif
if (ch)
*ch = scan_ch;
if (type)
*type = stype;
return next_state;
}
void site_survey(_adapter *padapter, u8 survey_channel,
enum rtw_phl_scan_type ScanType)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct ss_res *ss = &pmlmeext->sitesurvey_res;
u8 ssid_scan = 0;
#ifdef CONFIG_P2P
#ifndef CONFIG_IOCTL_CFG80211
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif
#endif
if (survey_channel != 0) {
set_channel_bwmode(padapter,
survey_channel,
CHAN_OFFSET_NO_EXT,
CHANNEL_WIDTH_20,
_FALSE);
if (ScanType == RTW_PHL_SCAN_PASSIVE && ss->force_ssid_scan)
ssid_scan = 1;
else if (ScanType == RTW_PHL_SCAN_ACTIVE) {
#ifdef CONFIG_P2P
#ifdef CONFIG_IOCTL_CFG80211
if (rtw_cfg80211_is_p2p_scan(padapter))
#else
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_SCAN)
|| rtw_p2p_chk_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH))
#endif
{
issue_probereq_p2p(padapter, NULL);
issue_probereq_p2p(padapter, NULL);
issue_probereq_p2p(padapter, NULL);
} else
#endif /* CONFIG_P2P */
{
if (pmlmeext->sitesurvey_res.scan_mode == RTW_PHL_SCAN_ACTIVE) {
/* IOT issue, When wifi_spec is not set, send one probe req without WPS IE. */
if (padapter->registrypriv.wifi_spec)
issue_probereq(padapter, NULL, NULL);
else
issue_probereq_ex(padapter, NULL, NULL, 0, 0, 0, 0);
issue_probereq(padapter, NULL, NULL);
}
ssid_scan = 1;
}
}
if (ssid_scan) {
int i;
for (i = 0; i < RTW_SSID_SCAN_AMOUNT; i++) {
if (pmlmeext->sitesurvey_res.ssid[i].SsidLength) {
/* IOT issue, When wifi_spec is not set, send one probe req without WPS IE. */
if (padapter->registrypriv.wifi_spec)
issue_probereq(padapter, &(pmlmeext->sitesurvey_res.ssid[i]), NULL);
else
issue_probereq_ex(padapter, &(pmlmeext->sitesurvey_res.ssid[i]), NULL, 0, 0, 0, 0);
issue_probereq(padapter, &(pmlmeext->sitesurvey_res.ssid[i]), NULL);
}
}
}
} else {
/* channel number is 0 or this channel is not valid. */
rtw_warn_on(1);
}
return;
}
void survey_done_set_ch_bw(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
u8 cur_channel = 0;
u8 cur_bwmode;
u8 cur_ch_offset;
if (rtw_mi_get_ch_setting_union(padapter, &cur_channel, &cur_bwmode, &cur_ch_offset) != 0) {
if (0)
RTW_INFO(FUNC_ADPT_FMT" back to linked/linking union - ch:%u, bw:%u, offset:%u\n",
FUNC_ADPT_ARG(padapter), cur_channel, cur_bwmode, cur_ch_offset);
} else {
#ifdef CONFIG_P2P
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
_adapter *iface;
int i;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (!iface)
continue;
#ifdef CONFIG_IOCTL_CFG80211
if (iface->wdinfo.driver_interface == DRIVER_CFG80211 && !adapter_wdev_data(iface)->p2p_enabled)
continue;
#endif
if (rtw_p2p_chk_state(&iface->wdinfo, P2P_STATE_LISTEN)) {
cur_channel = iface->wdinfo.listen_channel;
cur_bwmode = CHANNEL_WIDTH_20;
cur_ch_offset = CHAN_OFFSET_NO_EXT;
if (0)
RTW_INFO(FUNC_ADPT_FMT" back to "ADPT_FMT"'s listen ch - ch:%u, bw:%u, offset:%u\n",
FUNC_ADPT_ARG(padapter), ADPT_ARG(iface), cur_channel, cur_bwmode, cur_ch_offset);
break;
}
}
#endif /* CONFIG_P2P */
if (cur_channel == 0) {
cur_channel = pmlmeext->chandef.chan;
cur_bwmode = pmlmeext->chandef.bw;
cur_ch_offset = pmlmeext->chandef.offset;
if (0)
RTW_INFO(FUNC_ADPT_FMT" back to ch:%u, bw:%u, offset:%u\n",
FUNC_ADPT_ARG(padapter), cur_channel, cur_bwmode, cur_ch_offset);
}
}
set_channel_bwmode(padapter, cur_channel, cur_ch_offset, cur_bwmode, _FALSE);
}
void sitesurvey_set_igi(_adapter *adapter)
{
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct ss_res *ss = &mlmeext->sitesurvey_res;
u8 igi;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
#endif
switch (mlmeext_scan_state(mlmeext)) {
case SCAN_ENTER:
#ifdef CONFIG_P2P
#ifdef CONFIG_IOCTL_CFG80211
if (pwdinfo->driver_interface == DRIVER_CFG80211 && rtw_cfg80211_is_p2p_scan(adapter))
igi = 0x30;
else
#endif /* CONFIG_IOCTL_CFG80211 */
if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
igi = 0x28;
else
#endif /* CONFIG_P2P */
if (ss->igi)
igi = ss->igi;
else
#if defined(CONFIG_RTW_ACS) && defined(CONFIG_RTW_ACS_DBG)
if (IS_ACS_ENABLE(adapter) && rtw_is_acs_igi_valid(adapter))
igi = rtw_acs_get_adv_igi(adapter);
else
#endif /*CONFIG_RTW_ACS*/
igi = 0x1e;
/* record IGI status */
ss->igi_scan = igi;
rtw_hal_get_phydm_var(adapter, HAL_PHYDM_IGI, &ss->igi_before_scan, NULL);
/* disable DIG and set IGI for scan */
rtw_hal_set_phydm_var(adapter, HAL_PHYDM_IGI, &igi, _FALSE);
break;
case SCAN_COMPLETE:
case SCAN_TO_P2P_LISTEN:
/* enable DIG and restore IGI */
igi = 0xff;
rtw_hal_set_phydm_var(adapter, HAL_PHYDM_IGI, &igi, _FALSE);
break;
#ifdef CONFIG_SCAN_BACKOP
case SCAN_BACKING_OP:
/* write IGI for op channel when DIG is not enabled */
rtw_hal_set_phydm_var(adapter, HAL_PHYDM_IGI_W, &ss->igi_before_scan, _FALSE);
break;
case SCAN_LEAVE_OP:
/* write IGI for scan when DIG is not enabled */
rtw_hal_set_phydm_var(adapter, HAL_PHYDM_IGI_W, &ss->igi_scan, _FALSE);
break;
#endif /* CONFIG_SCAN_BACKOP */
default:
rtw_warn_on(1);
break;
}
}
void sitesurvey_set_msr(_adapter *adapter, bool enter)
{
u8 network_type;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (enter) {
/* set MSR to no link state */
network_type = _HW_STATE_NOLINK_;
} else {
network_type = pmlmeinfo->state & 0x3;
}
}
u8 sitesurvey_cmd_hdl(_adapter *padapter, u8 *pbuf)
{
struct sitesurvey_parm *pparm = (struct sitesurvey_parm *)pbuf;
#ifdef DBG_CHECK_FW_PS_STATE
struct dvobj_priv *dvobj = padapter->dvobj;
struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
#endif
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct ss_res *ss = &pmlmeext->sitesurvey_res;
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
#endif
u8 val8;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
#endif
#ifdef DBG_CHECK_FW_PS_STATE
if (rtw_fw_ps_state(padapter) == _FAIL) {
RTW_INFO("scan without leave 32k\n");
pdbgpriv->dbg_scan_pwr_state_cnt++;
}
#endif /* DBG_CHECK_FW_PS_STATE */
/* increase channel idx */
if (mlmeext_chk_scan_state(pmlmeext, SCAN_PROCESS))
ss->channel_idx++;
/* update scan state to next state (assigned by previous cmd hdl) */
if (mlmeext_scan_state(pmlmeext) != mlmeext_scan_next_state(pmlmeext))
mlmeext_set_scan_state(pmlmeext, mlmeext_scan_next_state(pmlmeext));
operation_by_state:
switch (mlmeext_scan_state(pmlmeext)) {
case SCAN_DISABLE:
/*
* SW parameter initialization
*/
sitesurvey_res_reset(padapter, pparm);
mlmeext_set_scan_state(pmlmeext, SCAN_START);
goto operation_by_state;
case SCAN_START:
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
if ((pwdev_priv->pno_mac_addr[0] != 0xFF)
&& (MLME_IS_STA(padapter))
&& (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _FALSE)) {
u16 seq_num;
rtw_hal_pno_random_gen_mac_addr(padapter);
rtw_hal_set_hw_mac_addr(padapter, pwdev_priv->pno_mac_addr);
get_random_bytes(&seq_num, 2);
pwdev_priv->pno_scan_seq_num = seq_num & 0xFFF;
RTW_INFO("%s pno_scan_seq_num %d\n", __func__,
pwdev_priv->pno_scan_seq_num);
}
#endif
/*
* prepare to leave operating channel
*/
/* apply rx ampdu setting */
if (ss->rx_ampdu_accept != RX_AMPDU_ACCEPT_INVALID
|| ss->rx_ampdu_size != RX_AMPDU_SIZE_INVALID)
rtw_rx_ampdu_apply(padapter);
/* clear HW TX queue before scan */
rtw_hal_set_hwreg(padapter, HW_VAR_CHECK_TXBUF, 0);
rtw_hal_macid_sleep_all_used(padapter);
/* power save state announcement */
if (rtw_ps_annc(padapter, 1)) {
mlmeext_set_scan_state(pmlmeext, SCAN_PS_ANNC_WAIT);
mlmeext_set_scan_next_state(pmlmeext, SCAN_ENTER);
set_survey_timer(pmlmeext, 50); /* delay 50ms to protect nulldata(1) */
} else {
mlmeext_set_scan_state(pmlmeext, SCAN_ENTER);
goto operation_by_state;
}
break;
case SCAN_ENTER:
/*
* HW register and DM setting for enter scan
*/
rtw_phydm_ability_backup(padapter);
sitesurvey_set_igi(padapter);
/* config dynamic functions for off channel */
rtw_phydm_func_for_offchannel(padapter);
/* set network type to no link state */
sitesurvey_set_msr(padapter, _TRUE);
val8 = 1; /* under site survey */
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
mlmeext_set_scan_state(pmlmeext, SCAN_PROCESS);
goto operation_by_state;
case SCAN_PROCESS: {
u8 scan_ch;
enum rtw_phl_scan_type stype;
u8 next_state;
u32 scan_ms;
#ifdef CONFIG_RTW_ACS
if (IS_ACS_ENABLE(padapter))
rtw_acs_get_rst(padapter);
#endif
next_state = sitesurvey_pick_ch_behavior(padapter, &scan_ch, &stype);
if (next_state != SCAN_PROCESS) {
mlmeext_set_scan_state(pmlmeext, next_state);
goto operation_by_state;
}
/* still SCAN_PROCESS state */
#ifdef DBG_SITESURVEY
#ifdef CONFIG_P2P
RTW_INFO(FUNC_ADPT_FMT" %s ch:%u (cnt:%u,idx:%d) at %dms, %c%c%c%c\n"
, FUNC_ADPT_ARG(padapter)
, mlmeext_scan_state_str(pmlmeext)
, scan_ch
, pwdinfo->find_phase_state_exchange_cnt, ss->channel_idx
, rtw_get_passing_time_ms(padapter->mlmepriv.scan_start_time)
, stype ? 'A' : 'P', ss->scan_mode ? 'A' : 'P'
, ss->ssid[0].SsidLength ? 'S' : ' '
, ss->force_ssid_scan ? 'F' : ' '
);
#else
RTW_INFO(FUNC_ADPT_FMT" %s ch:%u (idx:%d) at %dms, %c%c%c%c\n"
, FUNC_ADPT_ARG(padapter)
, mlmeext_scan_state_str(pmlmeext)
, scan_ch
, ss->channel_idx
, rtw_get_passing_time_ms(padapter->mlmepriv.scan_start_time)
, stype ? 'A' : 'P', ss->scan_mode ? 'A' : 'P'
, ss->ssid[0].SsidLength ? 'S' : ' '
, ss->force_ssid_scan ? 'F' : ' '
);
#endif /* CONFIG_P2P */
#endif /*DBG_SITESURVEY*/
#ifdef DBG_FIXED_CHAN
if (pmlmeext->fixed_chan != 0xff)
RTW_INFO(FUNC_ADPT_FMT" fixed_chan:%u\n", pmlmeext->fixed_chan);
#endif
site_survey(padapter, scan_ch, stype);
#if defined(CONFIG_ATMEL_RC_PATCH)
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
scan_ms = 20;
else
scan_ms = 40;
#else
#if defined(CONFIG_RTW_ACS) && defined(CONFIG_RTW_ACS_DBG)
if (IS_ACS_ENABLE(padapter) && rtw_is_acs_st_valid(padapter))
scan_ms = rtw_acs_get_adv_st(padapter);
else
#endif /*CONFIG_RTW_ACS*/
scan_ms = ss->scan_ch_ms;
#endif
#if defined(CONFIG_ANTENNA_DIVERSITY) || defined(DBG_SCAN_SW_ANTDIV_BL)
if (ss->is_sw_antdiv_bl_scan)
scan_ms = scan_ms / 2;
#endif
#ifdef CONFIG_RTW_ACS
if (IS_ACS_ENABLE(padapter)) {
if (pparm->token)
rtw_acs_trigger(padapter, scan_ms, scan_ch, NHM_PID_IEEE_11K_HIGH);
else
rtw_acs_trigger(padapter, scan_ms, scan_ch, NHM_PID_ACS);
}
#endif
set_survey_timer(pmlmeext, scan_ms);
break;
}
#ifdef CONFIG_SCAN_BACKOP
case SCAN_BACKING_OP: {
u8 back_ch, back_bw, back_ch_offset;
u8 need_ch_setting_union = _TRUE;
if (need_ch_setting_union) {
if (rtw_mi_get_ch_setting_union(padapter, &back_ch, &back_bw, &back_ch_offset) == 0) {
rtw_warn_on(1);
back_ch = pmlmeext->chandef.chan;
back_bw = pmlmeext->chandef.bw;
back_ch_offset = pmlmeext->chandef.offset;
}
}
#ifdef DBG_SITESURVEY
RTW_INFO(FUNC_ADPT_FMT" %s ch:%u, bw:%u, offset:%u at %dms\n"
, FUNC_ADPT_ARG(padapter)
, mlmeext_scan_state_str(pmlmeext)
, back_ch, back_bw, back_ch_offset
, rtw_get_passing_time_ms(padapter->mlmepriv.scan_start_time)
);
#endif /*DBG_SITESURVEY*/
set_channel_bwmode(padapter, back_ch, back_ch_offset, back_bw, _FALSE);
sitesurvey_set_msr(padapter, _FALSE);
val8 = 0; /* survey done */
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
if (mlmeext_chk_scan_backop_flags(pmlmeext, SS_BACKOP_PS_ANNC)) {
sitesurvey_set_igi(padapter);
rtw_hal_macid_wakeup_all_used(padapter);
rtw_ps_annc(padapter, 0);
}
mlmeext_set_scan_state(pmlmeext, SCAN_BACK_OP);
ss->backop_time = rtw_get_current_time();
if (mlmeext_chk_scan_backop_flags(pmlmeext, SS_BACKOP_TX_RESUME))
rtw_mi_os_xmit_schedule(padapter);
goto operation_by_state;
}
case SCAN_BACK_OP:
if (rtw_get_passing_time_ms(ss->backop_time) >= ss->backop_ms
|| pmlmeext->scan_abort
) {
mlmeext_set_scan_state(pmlmeext, SCAN_LEAVING_OP);
goto operation_by_state;
}
set_survey_timer(pmlmeext, 50);
break;
case SCAN_LEAVING_OP:
/*
* prepare to leave operating channel
*/
/* clear HW TX queue before scan */
rtw_hal_set_hwreg(padapter, HW_VAR_CHECK_TXBUF, 0);
rtw_hal_macid_sleep_all_used(padapter);
if (mlmeext_chk_scan_backop_flags(pmlmeext, SS_BACKOP_PS_ANNC)
&& rtw_ps_annc(padapter, 1)
) {
mlmeext_set_scan_state(pmlmeext, SCAN_PS_ANNC_WAIT);
mlmeext_set_scan_next_state(pmlmeext, SCAN_LEAVE_OP);
set_survey_timer(pmlmeext, 50); /* delay 50ms to protect nulldata(1) */
} else {
mlmeext_set_scan_state(pmlmeext, SCAN_LEAVE_OP);
goto operation_by_state;
}
break;
case SCAN_LEAVE_OP:
/*
* HW register and DM setting for enter scan
*/
if (mlmeext_chk_scan_backop_flags(pmlmeext, SS_BACKOP_PS_ANNC))
sitesurvey_set_igi(padapter);
sitesurvey_set_msr(padapter, _TRUE);
val8 = 1; /* under site survey */
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
mlmeext_set_scan_state(pmlmeext, SCAN_PROCESS);
goto operation_by_state;
#endif /* CONFIG_SCAN_BACKOP */
#if defined(CONFIG_ANTENNA_DIVERSITY) || defined(DBG_SCAN_SW_ANTDIV_BL)
case SCAN_SW_ANTDIV_BL:
/*
* 20100721
* For SW antenna diversity before link, it needs to switch to another antenna and scan again.
* It compares the scan result and select better one to do connection.
*/
ss->bss_cnt = 0;
ss->channel_idx = 0;
ss->is_sw_antdiv_bl_scan = 1;
mlmeext_set_scan_next_state(pmlmeext, SCAN_PROCESS);
set_survey_timer(pmlmeext, ss->scan_ch_ms);
break;
#endif
#ifdef CONFIG_P2P
case SCAN_TO_P2P_LISTEN:
/*
* Set the P2P State to the listen state of find phase
* and set the current channel to the listen channel
*/
set_channel_bwmode(padapter,
pwdinfo->listen_channel,
CHAN_OFFSET_NO_EXT,
CHANNEL_WIDTH_20,
_FALSE);
rtw_p2p_set_state(pwdinfo, P2P_STATE_FIND_PHASE_LISTEN);
/* turn on phy-dynamic functions */
rtw_phydm_ability_restore(padapter);
sitesurvey_set_igi(padapter);
mlmeext_set_scan_state(pmlmeext, SCAN_P2P_LISTEN);
_set_timer(&pwdinfo->find_phase_timer, (u32)((u32)pwdinfo->listen_dwell * 100));
break;
case SCAN_P2P_LISTEN:
mlmeext_set_scan_state(pmlmeext, SCAN_PROCESS);
ss->channel_idx = 0;
goto operation_by_state;
#endif /* CONFIG_P2P */
case SCAN_COMPLETE:
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
rtw_hal_set_hw_mac_addr(padapter, adapter_mac_addr(padapter));
#endif
#ifdef CONFIG_P2P
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_SCAN)
|| rtw_p2p_chk_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH)
) {
#ifdef CONFIG_CONCURRENT_MODE
if (pwdinfo->driver_interface == DRIVER_WEXT) {
if (rtw_mi_check_status(padapter, MI_LINKED))
_set_timer(&pwdinfo->ap_p2p_switch_timer, 500);
}
#endif
rtw_p2p_set_state(pwdinfo, rtw_p2p_pre_state(pwdinfo));
}
rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_NONE);
#endif /* CONFIG_P2P */
/* switch channel */
survey_done_set_ch_bw(padapter);
sitesurvey_set_msr(padapter, _FALSE);
val8 = 0; /* survey done */
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
/* turn on phy-dynamic functions */
rtw_phydm_ability_restore(padapter);
sitesurvey_set_igi(padapter);
rtw_hal_macid_wakeup_all_used(padapter);
rtw_ps_annc(padapter, 0);
/* apply rx ampdu setting */
rtw_rx_ampdu_apply(padapter);
mlmeext_set_scan_state(pmlmeext, SCAN_DISABLE);
report_surveydone_event(padapter, ss->acs);
#ifdef CONFIG_RTW_ACS
if (IS_ACS_ENABLE(padapter))
rtw_acs_select_best_chan(padapter);
#endif
issue_action_BSSCoexistPacket(padapter);
issue_action_BSSCoexistPacket(padapter);
issue_action_BSSCoexistPacket(padapter);
#ifdef CONFIG_RTW_80211K
if (ss->token)
rm_post_event(padapter, ss->token, RM_EV_survey_done);
#endif /* CONFIG_RTW_80211K */
break;
}
return H2C_SUCCESS;
}
#else
u8 sitesurvey_cmd_hdl(_adapter *padapter, u8 *pbuf)
{
RTW_ERR("%s executed??\n", __func__);
rtw_warn_on(1);
return 0;
}
void rtw_survey_cmd_callback(_adapter *padapter, struct cmd_obj *pcmd)
{
RTW_ERR("%s executed??\n", __func__);
rtw_warn_on(1);
}
/* remain on channel priv */
#define ROCH_CH_READY 0x1
struct scan_priv {
_adapter *padapter;
/* for remain on channel callback */
struct wireless_dev *wdev;
struct ieee80211_channel channel;
u8 channel_type;
unsigned int duration;
u64 cookie;
u8 restore_ch;
u8 roch_step;
#ifdef CONFIG_RTW_80211K
u32 rrm_token; /* 80211k use it to identify caller */
#endif
};
#ifdef CONFIG_CMD_SCAN
static struct rtw_phl_scan_param *_alloc_phl_param(_adapter *adapter, u8 scan_ch_num)
{
struct rtw_phl_scan_param *phl_param = NULL;
struct scan_priv *scan_priv = NULL;
if (scan_ch_num == 0) {
RTW_ERR("%s scan_ch_num = 0\n", __func__);
goto _err_exit;
}
/*create mem of PHL Scan parameter*/
phl_param = rtw_zmalloc(sizeof(*phl_param));
if (phl_param == NULL) {
RTW_ERR("%s alloc phl_param fail\n", __func__);
goto _err_exit;
}
scan_priv = rtw_zmalloc(sizeof(*scan_priv));
if (scan_priv == NULL) {
RTW_ERR("%s alloc scan_priv fail\n", __func__);
goto _err_scanpriv;
}
scan_priv->padapter = adapter;
phl_param->priv = scan_priv;
phl_param->wifi_role = adapter->phl_role;
phl_param->back_op_mode = SCAN_BKOP_NONE;
phl_param->ch_sz = sizeof(struct phl_scan_channel) * (scan_ch_num + 1);
phl_param->ch = rtw_zmalloc(phl_param->ch_sz);
if (phl_param->ch == NULL) {
RTW_ERR("%s: alloc phl scan ch fail\n", __func__);
goto _err_param_ch;
}
return phl_param;
_err_param_ch:
if (scan_priv)
rtw_mfree(scan_priv, sizeof(*scan_priv));
_err_scanpriv:
if (phl_param)
rtw_mfree(phl_param, sizeof(*phl_param));
_err_exit:
rtw_warn_on(1);
return phl_param;
}
static u8 _free_phl_param(_adapter *adapter, struct rtw_phl_scan_param *phl_param)
{
u8 res = _FAIL;
if (!phl_param)
return res;
if (phl_param->ch)
rtw_mfree(phl_param->ch, phl_param->ch_sz);
if (phl_param->priv)
rtw_mfree(phl_param->priv, sizeof(struct scan_priv));
rtw_mfree(phl_param, sizeof(struct rtw_phl_scan_param));
res = _SUCCESS;
return res;
}
#endif /*CONFIG_CMD_SCAN*/
static int scan_issue_pbreq_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
NDIS_802_11_SSID ssid;
int i;
/* active scan behavior */
if (padapter->registrypriv.wifi_spec)
issue_probereq(padapter, NULL, NULL);
else
issue_probereq_ex(padapter, NULL, NULL, 0, 0, 0, 0);
issue_probereq(padapter, NULL, NULL);
for (i = 0; i < param->ssid_num; i++) {
if (param->ssid[i].ssid_len == 0)
continue;
ssid.SsidLength = param->ssid[i].ssid_len;
_rtw_memcpy(ssid.Ssid, ¶m->ssid[i].ssid, ssid.SsidLength);
/* IOT issue,
* Send one probe req without WPS IE,
* when not wifi_spec
*/
if (padapter->registrypriv.wifi_spec)
issue_probereq(padapter, &ssid, NULL);
else
issue_probereq_ex(padapter, &ssid, NULL, 0, 0, 0, 0);
issue_probereq(padapter, &ssid, NULL);
}
return 0;
}
static int scan_complete_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
bool acs = _FALSE;
int ret = _FAIL;
if (!rtw_is_adapter_up(padapter))
goto _exit;
mlmeext_set_scan_state(pmlmeext, SCAN_DISABLE);
report_surveydone_event(padapter, acs, RTW_CMDF_DIRECTLY);
ret = _SUCCESS;
_exit:
RTW_INFO(FUNC_ADPT_FMT" takes %d ms to scan %d/%d channels\n",
FUNC_ADPT_ARG(padapter), param->total_scan_time,
#ifdef CONFIG_CMD_SCAN
param->ch_idx,
#else
param->ch_idx + 1,
#endif
param->ch_num);
_rtw_scan_abort_check(padapter, __func__);
#ifdef CONFIG_CMD_SCAN
_free_phl_param(padapter, param);
pmlmeext->sitesurvey_res.scan_param = NULL;
#else
rtw_mfree(scan_priv, sizeof(*scan_priv));
#endif
return ret;
}
static int scan_start_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
pmlmeext->sitesurvey_res.bss_cnt = 0;
pmlmeext->sitesurvey_res.activate_ch_cnt = 0;
//TODO remove
mlmeext_set_scan_state(pmlmeext, SCAN_PROCESS);
#ifdef CONFIG_CMD_SCAN
pmlmeext->sitesurvey_res.scan_param = param;
#endif
return 0;
}
#ifdef CONFIG_P2P
static int scan_issue_p2p_pbreq_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
issue_probereq_p2p(padapter, NULL);
issue_probereq_p2p(padapter, NULL);
issue_probereq_p2p(padapter, NULL);
return 0;
}
#endif
static int scan_ch_ready_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
RTW_INFO("%s ch:%d\n", __func__, param->scan_ch->channel);
return 0;
}
static inline void _ps_announce(_adapter *adapter, bool ps)
{
RTW_INFO(FUNC_ADPT_FMT" issue_null(%d)\n", FUNC_ADPT_ARG(adapter), ps);
if (MLME_IS_STA(adapter)) {
if (is_client_associated_to_ap(adapter) == _TRUE) {
/*issue_nulldata(adapter, NULL, ps, 3, 500);*/
issue_nulldata(adapter, NULL, ps, 1, 0);
}
}
#ifdef CONFIG_RTW_MESH
else if (MLME_IS_MESH(adapter)) {
rtw_mesh_ps_annc(adapter, ps);
}
#endif
}
u8 scan_issu_null_data_cb(void *priv, u8 ridx, bool ps)
{
#ifdef CONFIG_CMD_SCAN
struct dvobj_priv *obj = (struct dvobj_priv *)priv;
#else
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
struct dvobj_priv *obj = adapter_to_dvobj(padapter);
#endif
_adapter *iface = NULL;
if (ridx >= CONFIG_IFACE_NUMBER) {
RTW_ERR("%s ridx:%d invalid\n", __func__, ridx);
rtw_warn_on(1);
goto _error;
}
iface = obj->padapters[ridx];
if (!rtw_is_adapter_up(iface))
goto _error;
_ps_announce(iface, ps);
return _SUCCESS;
_error:
return _FAIL;
}
static struct rtw_phl_scan_ops scan_ops_cb = {
.scan_start = scan_start_cb,
.scan_ch_ready = scan_ch_ready_cb,
.scan_complete = scan_complete_cb,
.scan_issue_pbreq = scan_issue_pbreq_cb,
.scan_issue_null_data = scan_issu_null_data_cb
};
#ifdef CONFIG_P2P
static struct rtw_phl_scan_ops scan_ops_p2p_cb = {
.scan_start = scan_start_cb,
.scan_ch_ready = scan_ch_ready_cb,
.scan_complete = scan_complete_cb,
.scan_issue_pbreq = scan_issue_p2p_pbreq_cb,
.scan_issue_null_data = scan_issu_null_data_cb
};
#endif
#ifdef CONFIG_RTW_80211K
static int scan_complete_rrm_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
int ret = _FAIL;
if (!rtw_is_adapter_up(padapter))
goto _exit;
mlmeext_set_scan_state(pmlmeext, SCAN_DISABLE);
_rtw_spinlock_bh(&pmlmepriv->lock);
_clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY);
_rtw_spinunlock_bh(&pmlmepriv->lock);
/* inform RRM scan complete */
rm_post_event(padapter, scan_priv->rrm_token, RM_EV_survey_done);
ret = _SUCCESS;
_exit:
RTW_INFO(FUNC_ADPT_FMT" takes %d ms to scan %d/%d channels\n",
FUNC_ADPT_ARG(padapter), param->total_scan_time,
param->ch_idx + 1, param->ch_num);
_rtw_scan_abort_check(padapter, __func__);
#ifdef CONFIG_CMD_SCAN
_free_phl_param(padapter, param);
pmlmeext->sitesurvey_res.scan_param = NULL;
#else
rtw_mfree(scan_priv, sizeof(*scan_priv));
#endif
return ret;
}
static struct rtw_phl_scan_ops scan_ops_rrm_cb = {
.scan_start = scan_start_cb,
.scan_ch_ready = scan_ch_ready_cb,
.scan_complete = scan_complete_rrm_cb,
.scan_issue_pbreq = scan_issue_pbreq_cb,
.scan_issue_null_data = scan_issu_null_data_cb
};
#endif /* CONFIG_RTW_80211K */
#define SCANNING_TIMEOUT_EX 2000
static u32 rtw_scan_timeout_decision(_adapter *padapter)
{
u32 back_op_times= 0;
u8 max_chan_num;
u16 scan_ms;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct ss_res *ss = &pmlmeext->sitesurvey_res;
if (is_supported_5g(padapter->registrypriv.band_type)
&& is_supported_24g(padapter->registrypriv.band_type))
max_chan_num = MAX_CHANNEL_NUM_2G_5G;/* dual band */
else
max_chan_num = MAX_CHANNEL_NUM_2G;/*single band*/
#ifdef CONFIG_SCAN_BACKOP
/* delay 50ms to protect nulldata(1) */
if (rtw_scan_backop_decision(padapter))
back_op_times = (max_chan_num / ss->scan_cnt_max) * (ss->backop_ms + 50);
#endif
if (ss->duration)
scan_ms = ss->duration;
else
#if defined(CONFIG_RTW_ACS) && defined(CONFIG_RTW_ACS_DBG)
if (IS_ACS_ENABLE(padapter) && rtw_is_acs_st_valid(padapter))
scan_ms = rtw_acs_get_adv_st(padapter);
else
#endif /*CONFIG_RTW_ACS*/
scan_ms = ss->scan_ch_ms;
ss->scan_timeout_ms = (scan_ms * max_chan_num) + back_op_times + SCANNING_TIMEOUT_EX;
#ifdef DBG_SITESURVEY
RTW_INFO("%s , scan_timeout_ms = %d (ms), scan_ms=%d (ms), \
back_op_times=%d (ms), ss->duration=%d (ms)\n" \
, __func__, ss->scan_timeout_ms, scan_ms, back_op_times, ss->duration);
#endif /*DBG_SITESURVEY*/
return ss->scan_timeout_ms;
}
/*
rtw_sitesurvey_cmd(~)
### NOTE:#### (!!!!)
MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock
*/
#ifdef CONFIG_CMD_SCAN
static void scan_channel_list_filled(_adapter *padapter,
struct rtw_phl_scan_param *phl_param, struct sitesurvey_parm *param)
{
struct phl_scan_channel *phl_ch = phl_param->ch;
u8 i = 0;
for (i = 0; i < param->ch_num; i++) {
phl_ch[i].channel = param->ch[i].hw_value;
phl_ch[i].scan_mode = NORMAL_SCAN_MODE;
phl_ch[i].bw = param->bw;
phl_ch[i].duration = param->duration;
if (param->ch[i].flags & RTW_IEEE80211_CHAN_PASSIVE_SCAN)
phl_ch[i].type = RTW_PHL_SCAN_PASSIVE;
else
phl_ch[i].type = RTW_PHL_SCAN_ACTIVE;
}
phl_param->ch_num = param->ch_num;
}
#ifdef RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN
/*
* Count extended active scan time(ms) and add time to
* struct mlme_ext_priv.sitesurvey_res.scan_timeout_ms.
*
* Return extended active scan time which unit is ms.
*/
static u32 _scan_ext_act_time_count(struct _ADAPTER *a,
struct rtw_phl_scan_param *scan)
{
struct ss_res *ss = &a->mlmeextpriv.sitesurvey_res;
u16 ext_time = 0;
int i;
for (i = 0; i < scan->ch_num; i++) {
if (scan->ch[i].ext_act_scan == EXT_ACT_SCAN_ENABLE)
ext_time += scan->ext_act_scan_period;
}
#ifdef DBG_SITESURVEY
RTW_PRINT(FUNC_ADPT_FMT ": Add extend active scan time %u ms to total "
"scan time (from %u to %u)\n",
FUNC_ADPT_ARG(a), ext_time, ss->scan_timeout_ms,
ext_time + ss->scan_timeout_ms);
#endif /* DBG_SITESURVEY */
ss->scan_timeout_ms += ext_time;
return ext_time;
}
#endif /* RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN */
u8 rtw_sitesurvey_cmd(_adapter *padapter, struct sitesurvey_parm *pparm)
{
u8 res = _FAIL;
u8 i;
u32 scan_timeout_ms;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct rtw_phl_scan_param *phl_param = NULL;
struct rtw_ieee80211_channel ch[RTW_CHANNEL_SCAN_AMOUNT] = {0};
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct sitesurvey_parm *tmp_parm = NULL;
struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
struct ss_res *ss = &mlmeext->sitesurvey_res;
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
#ifdef CONFIG_RTW_80211K
struct scan_priv *scan_priv = NULL;
#endif
if (pparm == NULL) {
tmp_parm = rtw_zmalloc(sizeof(struct sitesurvey_parm));
if (tmp_parm == NULL) {
RTW_ERR("%s alloc tmp_parm fail\n", __func__);
goto _err_exit;
}
rtw_init_sitesurvey_parm(padapter, tmp_parm);
pparm = tmp_parm;
}
/* backup original ch list */
_rtw_memcpy(ch, pparm->ch,
sizeof(struct rtw_ieee80211_channel) * pparm->ch_num);
/* modify ch list according to chanel plan */
pparm->ch_num = rtw_scan_ch_decision(padapter,
pparm->ch, RTW_CHANNEL_SCAN_AMOUNT,
ch, pparm->ch_num, pparm->acs);
if (pparm->duration == 0)
pparm->duration = ss->scan_ch_ms; /* ms */
/*create mem of PHL Scan parameter*/
phl_param = _alloc_phl_param(padapter, pparm->ch_num);
if (phl_param == NULL) {
RTW_ERR("%s alloc phl_param fail\n", __func__);
goto _err_param;
}
/* STEP_1 transfer to rtw channel list to phl channel list */
scan_channel_list_filled(padapter, phl_param, pparm);
/* STEP_2 copy the ssid info to phl param */
phl_param->ssid_num = rtw_min(pparm->ssid_num, SCAN_SSID_AMOUNT);
for (i = 0; i < phl_param->ssid_num; ++i) {
phl_param->ssid[i].ssid_len = pparm->ssid[i].SsidLength;
_rtw_memcpy(&phl_param->ssid[i].ssid, &pparm->ssid[i].Ssid, phl_param->ssid[i].ssid_len);
}
#ifdef RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN
/* STEP_2.1 set EXT_ACT_SCAN_ENABLE for hidden AP scan */
if (phl_param->ssid[0].ssid_len) {
phl_param->ext_act_scan_period = RTW_EXTEND_ACTIVE_SCAN_PERIOD;
for (i = 0; i < phl_param->ch_num; i++) {
int chset_idx;
chset_idx = rtw_chset_search_ch(rfctl->channel_set,
phl_param->ch[i].channel);
if (chset_idx < 0) {
RTW_ERR(FUNC_ADPT_FMT ": cann't find ch %u in chset!\n",
FUNC_ADPT_ARG(padapter), phl_param->ch[i].channel);
continue;
}
if ((phl_param->ch[i].type == RTW_PHL_SCAN_PASSIVE)
&& (!IS_DFS_SLAVE_WITH_RD(rfctl)
|| rtw_rfctl_dfs_domain_unknown(rfctl)
|| !CH_IS_NON_OCP(&rfctl->channel_set[chset_idx])))
phl_param->ch[i].ext_act_scan = EXT_ACT_SCAN_ENABLE;
}
}
#endif /* RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN */
/* STEP_3 set ops according to scan_type */
switch (pparm->scan_type) {
#ifdef CONFIG_P2P
case RTW_SCAN_P2P:
phl_param->ops = &scan_ops_p2p_cb;
break;
#endif
#ifdef CONFIG_RTW_80211K
case RTW_SCAN_RRM:
phl_param->ops = &scan_ops_rrm_cb;
scan_priv = (struct scan_priv *)phl_param->priv;
scan_priv->rrm_token = pparm->rrm_token;
ss->token = pparm->rrm_token;
break;
#endif
case RTW_SCAN_NORMAL:
default:
phl_param->ops = &scan_ops_cb;
#ifdef CONFIG_SCAN_BACKOP
if (rtw_scan_backop_decision(padapter)) {
phl_param->back_op_ch_dur_ms = ss->backop_ms;
phl_param->back_op_mode = SCAN_BKOP_CNT;
phl_param->back_op_ch_cnt = ss->scan_cnt_max;
} else {
phl_param->back_op_mode = SCAN_BKOP_NONE;
}
#else
phl_param->back_op_mode = SCAN_BKOP_NONE;
#endif /* CONFIG_SCAN_BACKOP */
break;
}
/* STEP_4 reset variables for each scan */
for (i = 0; i < MAX_CHANNEL_NUM; i++)
rfctl->channel_set[i].hidden_bss_cnt = 0;
set_fwstate(pmlmepriv, WIFI_UNDER_SURVEY);
if(rtw_phl_cmd_scan_request(dvobj->phl, phl_param, true) != RTW_PHL_STATUS_SUCCESS) {
RTW_ERR("%s request scam_cmd failed\n", __func__);
_clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY);
goto _err_req_param;
}
pmlmeext->sitesurvey_res.scan_param = phl_param;
rtw_free_network_queue(padapter, _FALSE);
pmlmepriv->scan_start_time = rtw_get_current_time();
scan_timeout_ms = rtw_scan_timeout_decision(padapter);
#ifdef RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN
scan_timeout_ms += _scan_ext_act_time_count(padapter, phl_param);
#endif /* RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN */
mlme_set_scan_to_timer(pmlmepriv,scan_timeout_ms);
rtw_led_control(padapter, LED_CTL_SITE_SURVEY);
if (tmp_parm)
rtw_mfree(tmp_parm, sizeof(*tmp_parm));
res = _SUCCESS;
return res;
_err_req_param:
_free_phl_param(padapter, phl_param);
_err_param:
if (tmp_parm)
rtw_mfree(tmp_parm, sizeof(*tmp_parm));
_err_exit:
rtw_warn_on(1);
return res;
}
#else /*!CONFIG_CMD_SCAN*/
/**
* prepare phl_channel list according to SCAN type
*
*/
static int scan_channel_list_preparation(_adapter *padapter,
struct rtw_phl_scan_param *dst, struct sitesurvey_parm *src)
{
struct phl_scan_channel *phl_ch = NULL;
int phl_ch_sz = 0;
int i;
phl_ch_sz = sizeof(struct phl_scan_channel) * (src->ch_num + 1);
phl_ch = rtw_malloc(phl_ch_sz);
if (phl_ch == NULL) {
RTW_ERR("scan: alloc phl scan ch fail\n");
return -1;
}
_rtw_memset(phl_ch, 0, phl_ch_sz);
i = 0;
while (i < src->ch_num) {
phl_ch[i].channel = src->ch[i].hw_value;
phl_ch[i].scan_mode = NORMAL_SCAN_MODE;
phl_ch[i].bw = src->bw;
phl_ch[i].duration = src->duration;
if (src->ch[i].flags & RTW_IEEE80211_CHAN_PASSIVE_SCAN) {
phl_ch[i].type = RTW_PHL_SCAN_PASSIVE;
} else {
phl_ch[i].type = RTW_PHL_SCAN_ACTIVE;
/* reduce scan time in active channel */
if (src->scan_type == RTW_SCAN_NORMAL)
phl_ch[i].duration = src->duration >> 1;
}
i++;
}
dst->ch = phl_ch;
dst->ch_sz = phl_ch_sz;
dst->ch_num = src->ch_num;
return 0;
}
u32 rtw_site_survey_fsm(_adapter *padapter, struct cmd_obj *pcmd)
{
u32 res = RTW_PHL_STATUS_FAILURE;
struct scan_priv *scan_priv;
struct rtw_phl_scan_param *phl_param;
struct sitesurvey_parm *rtw_param;
struct rtw_ieee80211_channel ch[RTW_CHANNEL_SCAN_AMOUNT];
u8 i;
scan_priv = rtw_malloc(sizeof(*scan_priv));
if (scan_priv == NULL) {
RTW_ERR("scan: %s alloc scan_priv fail\n", __func__);
return RTW_PHL_STATUS_FAILURE;
}
_rtw_memset(scan_priv, 0, sizeof(*scan_priv));
scan_priv->padapter = padapter;
rtw_param = (struct sitesurvey_parm *)pcmd->parmbuf;
if (rtw_param->duration == 0)
rtw_param->duration = SURVEY_TO; /* ms */
/* backup original ch list */
_rtw_memcpy(ch, rtw_param->ch,
sizeof(struct rtw_ieee80211_channel) *
rtw_param->ch_num);
/* modify ch list according to chanel plan */
rtw_param->ch_num = rtw_scan_ch_decision(padapter,
rtw_param->ch, RTW_CHANNEL_SCAN_AMOUNT,
ch, rtw_param->ch_num, rtw_param->acs);
phl_param = rtw_malloc(sizeof(*phl_param));
if (phl_param == NULL) {
RTW_ERR("scan: %s alloc param fail\n", __func__);
if (scan_priv)
rtw_mfree(scan_priv, sizeof(*scan_priv));
return RTW_PHL_STATUS_FAILURE;
}
_rtw_memset(phl_param, 0, sizeof(*phl_param));
/* transfer to rtw channel list to phl channel list */
scan_channel_list_preparation(padapter, phl_param, rtw_param);
/* copy the ssid info to phl param */
phl_param->ssid_num = rtw_min(rtw_param->ssid_num, SCAN_SSID_AMOUNT);
for (i = 0; i < phl_param->ssid_num; ++i) {
phl_param->ssid[i].ssid_len = rtw_param->ssid[i].SsidLength;
_rtw_memcpy(&phl_param->ssid[i].ssid, &rtw_param->ssid[i].Ssid, phl_param->ssid[i].ssid_len);
}
switch (rtw_param->scan_type) {
#ifdef CONFIG_P2P
case RTW_SCAN_P2P:
phl_param->ops = &scan_ops_p2p_cb;
break;
#endif
#ifdef CONFIG_RTW_80211K
case RTW_SCAN_RRM:
phl_param->ops = &scan_ops_rrm_cb;
if (rtw_param->ch_num > 13) {
phl_param->back_op_mode = SCAN_BKOP_CNT;
phl_param->back_op_ch_cnt = 3;
}
break;
#endif
case RTW_SCAN_NORMAL:
default:
phl_param->ops = &scan_ops_cb;
phl_param->back_op_mode = SCAN_BKOP_CNT;
phl_param->back_op_ch_cnt = 3;
break;
}
phl_param->priv = scan_priv;
phl_param->wifi_role = padapter->phl_role;
res = rtw_phl_scan_request(adapter_to_dvobj(padapter)->phl, phl_param, TO_TAIL);
rtw_mfree(phl_param->ch, phl_param->ch_sz);
rtw_mfree(phl_param, sizeof(*phl_param));
return res;
}
u8 rtw_sitesurvey_cmd(_adapter *padapter, struct sitesurvey_parm *pparm)
{
u8 res = _FAIL;
struct cmd_obj *cmd;
struct sitesurvey_parm *psurveyPara;
struct cmd_priv *pcmdpriv = &adapter_to_dvobj(padapter)->cmdpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
#ifdef CONFIG_LPS
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 0);
#endif
#ifdef CONFIG_P2P_PS
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
p2p_ps_wk_cmd(padapter, P2P_PS_SCAN, 1);
#endif /* CONFIG_P2P_PS */
cmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
if (cmd == NULL)
return _FAIL;
cmd->padapter = padapter;
psurveyPara = (struct sitesurvey_parm *)rtw_zmalloc(sizeof(struct sitesurvey_parm));
if (psurveyPara == NULL) {
rtw_mfree((unsigned char *) cmd, sizeof(struct cmd_obj));
return _FAIL;
}
if (pparm)
_rtw_memcpy(psurveyPara, pparm, sizeof(struct sitesurvey_parm));
else
psurveyPara->scan_mode = pmlmepriv->scan_mode;
rtw_free_network_queue(padapter, _FALSE);
init_h2fwcmd_w_parm_no_rsp(cmd, psurveyPara, CMD_SITE_SURVEY);
set_fwstate(pmlmepriv, WIFI_UNDER_SURVEY);
res = rtw_enqueue_cmd(pcmdpriv, cmd);
if (res == _SUCCESS) {
u32 scan_timeout_ms;
pmlmepriv->scan_start_time = rtw_get_current_time();
scan_timeout_ms = rtw_scan_timeout_decision(padapter);
mlme_set_scan_to_timer(pmlmepriv,scan_timeout_ms);
rtw_led_control(padapter, LED_CTL_SITE_SURVEY);
} else {
_clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY);
}
return res;
}
#endif/*CONFIG_CMD_SCAN*/
/* inform caller phl_scan are ready on remain channel */
static int roch_ready_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
struct cfg80211_roch_info *pcfg80211_rochinfo =
&padapter->cfg80211_rochinfo;
RTW_INFO("%s cookie:0x%llx\n", __func__,
pcfg80211_rochinfo->remain_on_ch_cookie);
if ((scan_priv->roch_step & ROCH_CH_READY))
return 0;
scan_priv->roch_step |= ROCH_CH_READY;
rtw_cfg80211_ready_on_channel(
scan_priv->wdev,
scan_priv->cookie,
&scan_priv->channel,
scan_priv->channel_type,
scan_priv->duration,
GFP_KERNEL);
return 0;
}
static int roch_off_ch_tx_cb(void *priv,
struct rtw_phl_scan_param *param, void *data)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
struct dvobj_priv *dvobj = adapter_to_dvobj(scan_priv->padapter);
#ifdef CONFIG_CMD_SCAN
RTW_ERR("CMD_SCAN call %s\n", __func__);
rtw_warn_on(1);
#else
phl_cmd_complete_job(dvobj->phl, (struct phl_cmd_job *)data);
#endif
return 0;
}
#ifdef CONFIG_P2P
static int p2p_roch_complete_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
int ret = _FAIL;
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
struct cfg80211_roch_info *pcfg80211_rochinfo =
&padapter->cfg80211_rochinfo;
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
if (!rtw_is_adapter_up(padapter))
goto _exit;
mlmeext_set_scan_state(&padapter->mlmeextpriv, SCAN_DISABLE);
/* roch_ready() and roch_complete() MUST be a PAIR
* otherwise will caurse wpa_supplicant hang!!!
* This case may happen when someone cancel remain on ch
* before it really start. (called roch_ready()).
*/
if (!(scan_priv->roch_step & ROCH_CH_READY))
roch_ready_cb(priv, param);
#ifndef CONFIG_CMD_SCAN
rtw_back_opch(padapter);
#endif
#ifdef CONFIG_DEBUG_CFG80211
RTW_INFO("%s, role=%d\n", __func__, rtw_p2p_role(pwdinfo));
#endif
rtw_cfg80211_set_is_roch(padapter, _FALSE);
pcfg80211_rochinfo->ro_ch_wdev = NULL;
rtw_cfg80211_set_last_ro_ch_time(padapter);
ret = _SUCCESS;
_exit:
/* callback to cfg80211 */
rtw_cfg80211_remain_on_channel_expired(scan_priv->wdev
, scan_priv->cookie
, &scan_priv->channel
, scan_priv->channel_type, GFP_KERNEL);
RTW_INFO("cfg80211_remain_on_channel_expired cookie:0x%llx\n"
, pcfg80211_rochinfo->remain_on_ch_cookie);
RTW_INFO(FUNC_ADPT_FMT" takes %d ms to scan %d/%d channels\n",
FUNC_ADPT_ARG(padapter), param->total_scan_time,
#ifdef CONFIG_CMD_SCAN
param->ch_idx,
#else
param->ch_idx + 1,
#endif
param->ch_num);
_rtw_scan_abort_check(padapter, __func__);
#ifdef CONFIG_CMD_SCAN
_free_phl_param(padapter, param);
padapter->mlmeextpriv.sitesurvey_res.scan_param = NULL;
#else
rtw_mfree(scan_priv, sizeof(*scan_priv));
#endif
return ret;
}
static int p2p_roch_start_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
struct cfg80211_roch_info *pcfg80211_rochinfo;
pcfg80211_rochinfo = &padapter->cfg80211_rochinfo;
//TODO remove
mlmeext_set_scan_state(&padapter->mlmeextpriv, SCAN_PROCESS);
rtw_cfg80211_set_is_roch(padapter, _TRUE);
pcfg80211_rochinfo->ro_ch_wdev = scan_priv->wdev;
pcfg80211_rochinfo->remain_on_ch_cookie = scan_priv->cookie;
pcfg80211_rochinfo->duration = scan_priv->duration;
rtw_cfg80211_set_last_ro_ch_time(padapter);
_rtw_memcpy(&pcfg80211_rochinfo->remain_on_ch_channel,
&scan_priv->channel, sizeof(struct ieee80211_channel));
#if (KERNEL_VERSION(3, 8, 0) > LINUX_VERSION_CODE)
pcfg80211_rochinfo->remain_on_ch_type = scan_priv->channel_type;
#endif
pcfg80211_rochinfo->restore_channel = scan_priv->restore_ch;
#ifdef CONFIG_CMD_SCAN
padapter->mlmeextpriv.sitesurvey_res.scan_param = param;
#endif
return 0;
}
#endif
static int roch_start_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
mlmeext_set_scan_state(&padapter->mlmeextpriv, SCAN_PROCESS);
rtw_cfg80211_set_is_roch(padapter, _TRUE);
#ifdef CONFIG_CMD_SCAN
padapter->mlmeextpriv.sitesurvey_res.scan_param = param;
#endif
return 0;
}
static int roch_complete_cb(void *priv, struct rtw_phl_scan_param *param)
{
struct scan_priv *scan_priv = (struct scan_priv *)priv;
_adapter *padapter = scan_priv->padapter;
struct cfg80211_roch_info *pcfg80211_rochinfo =
&padapter->cfg80211_rochinfo;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
int ret = _FAIL;
if (!rtw_is_adapter_up(padapter))
goto _exit;
mlmeext_set_scan_state(pmlmeext, SCAN_DISABLE);
/* roch_ready() and roch_complete() MUST be a PAIR
* otherwise will caurse wpa_supplicant hang!!!
* This case may happen when someone cancel remain on ch
* before it really start. (called roch_ready()).
*/
if (!(scan_priv->roch_step & ROCH_CH_READY))
roch_ready_cb(priv, param);
rtw_cfg80211_set_is_roch(padapter, _FALSE);
ret = _SUCCESS;
_exit:
/* callback to cfg80211 */
rtw_cfg80211_remain_on_channel_expired(scan_priv->wdev
, scan_priv->cookie
, &scan_priv->channel
, scan_priv->channel_type, GFP_KERNEL);
RTW_INFO("cfg80211_remain_on_channel_expired cookie:0x%llx\n"
, pcfg80211_rochinfo->remain_on_ch_cookie);
RTW_INFO(FUNC_ADPT_FMT" takes %d ms to scan %d/%d channels\n",
FUNC_ADPT_ARG(padapter), param->total_scan_time,
#ifdef CONFIG_CMD_SCAN
param->ch_idx,
#else
param->ch_idx + 1,
#endif
param->ch_num);
_rtw_scan_abort_check(padapter, __func__);
#ifdef CONFIG_CMD_SCAN
_free_phl_param(padapter, param);
pmlmeext->sitesurvey_res.scan_param = NULL;
#else
rtw_mfree(scan_priv, sizeof(*scan_priv));
#endif
return ret;
}
#ifdef CONFIG_P2P
/* p2p remain on channel */
static struct rtw_phl_scan_ops p2p_remain_ops_cb = {
.scan_start = p2p_roch_start_cb,
.scan_ch_ready = roch_ready_cb,
.scan_off_ch_tx = roch_off_ch_tx_cb,
.scan_complete = p2p_roch_complete_cb,
.scan_issue_null_data = scan_issu_null_data_cb
};
#endif
/* normal remain on channel */
static struct rtw_phl_scan_ops remain_ops_cb = {
.scan_start = roch_start_cb,
.scan_ch_ready = roch_ready_cb,
.scan_off_ch_tx = roch_off_ch_tx_cb,
.scan_complete = roch_complete_cb,
.scan_issue_null_data = scan_issu_null_data_cb
};
#ifdef CONFIG_IOCTL_CFG80211
static u8 roch_stay_in_cur_chan(_adapter *padapter)
{
int i;
_adapter *iface;
struct mlme_priv *pmlmepriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 rst = _FALSE;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if (iface) {
pmlmepriv = &iface->mlmepriv;
if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING | WIFI_UNDER_WPS | WIFI_UNDER_KEY_HANDSHAKE) == _TRUE) {
RTW_INFO(ADPT_FMT"- WIFI_UNDER_LINKING |WIFI_UNDER_WPS | WIFI_UNDER_KEY_HANDSHAKE (mlme state:0x%x)\n",
ADPT_ARG(iface), get_fwstate(&iface->mlmepriv));
rst = _TRUE;
break;
}
#ifdef CONFIG_AP_MODE
if (MLME_IS_AP(iface) || MLME_IS_MESH(iface)) {
if (rtw_ap_sta_states_check(iface) == _TRUE) {
rst = _TRUE;
break;
}
}
#endif
}
}
return rst;
}
#ifdef CONFIG_CMD_SCAN
u8 rtw_phl_remain_on_ch_cmd(_adapter *padapter,
u64 cookie, struct wireless_dev *wdev,
struct ieee80211_channel *ch, u8 ch_type,
unsigned int duration, struct back_op_param *bkop_parm,
u8 is_p2p)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_phl_scan_param *phl_param = NULL;
struct scan_priv *scan_priv = NULL;
u16 remain_ch;
u8 chan_num;
u8 res = _FAIL;
/* prepare remain channel - check channel */
remain_ch = (u16)ieee80211_frequency_to_channel(ch->center_freq);
if (roch_stay_in_cur_chan(padapter) == _TRUE) { /*???*/
remain_ch = rtw_mi_get_union_chan(padapter);
RTW_INFO(FUNC_ADPT_FMT" stay in union ch:%d\n",
FUNC_ADPT_ARG(padapter), remain_ch);
}
chan_num = 1;
phl_param = _alloc_phl_param(padapter, chan_num);
if (phl_param == NULL) {
RTW_ERR("%s alloc phl_param fail\n", __func__);
goto _err_exit;
}
/*** fill phl parameter - scan_priv ***/
scan_priv = (struct scan_priv *)phl_param->priv;
scan_priv->padapter = padapter;
scan_priv->wdev = wdev;
_rtw_memcpy(&scan_priv->channel, ch, sizeof(*ch));
scan_priv->channel_type = ch_type;
scan_priv->cookie = cookie;
scan_priv->duration = duration;
scan_priv->restore_ch = rtw_get_oper_ch(padapter);
/* fill phl param - chan */
phl_param->ch->channel = remain_ch;
phl_param->ch->duration = duration;
phl_param->ch->scan_mode = P2P_LISTEN_MODE;
phl_param->ch->bw = CHANNEL_WIDTH_20;
phl_param->ch_num = chan_num;
/* fill back op param */
phl_param->back_op_mode = SCAN_BKOP_TIMER;
phl_param->back_op_ch_cnt = 1;
phl_param->back_op_ch_dur_ms = bkop_parm->on_ch_dur;/*op_ch time*/
phl_param->back_op_off_ch_dur_ms = bkop_parm->off_ch_dur;/*ro_ch time*/
phl_param->back_op_off_ch_ext_dur_ms = bkop_parm->off_ch_ext_dur;
#ifdef CONFIG_P2P
/* set ops according to is_p2p */
if (is_p2p)
phl_param->ops = &p2p_remain_ops_cb;
else
#endif
phl_param->ops = &remain_ops_cb;
if(rtw_phl_cmd_scan_request(dvobj->phl, phl_param, true) == RTW_PHL_STATUS_FAILURE) {
RTW_ERR("%s request scam_cmd failed\n", __func__);
goto _err_req_param;
}
RTW_INFO(FUNC_ADPT_FMT" ch:%u duration:%d, cookie:0x%llx\n"
, FUNC_ADPT_ARG(padapter), remain_ch, duration, cookie);
res = _SUCCESS;
return res;
_err_req_param:
_free_phl_param(padapter, phl_param);
_err_exit:
rtw_warn_on(1);
return res;
}
#else
u8 rtw_phl_remain_on_ch_cmd(_adapter *padapter,
u64 cookie, struct wireless_dev *wdev,
struct ieee80211_channel *ch, u8 ch_type,
unsigned int duration, struct back_op_param *bkop_parm,
u8 is_p2p)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_phl_scan_param phl_param;
struct scan_priv *scan_priv;
struct phl_scan_channel phl_ch;
int phl_ch_sz = 0;
u16 remain_ch;
u8 res = _FAIL;
_rtw_memset(&phl_param, 0, sizeof(phl_param));
scan_priv = rtw_malloc(sizeof(*scan_priv));
if (scan_priv == NULL) {
RTW_ERR("scan: %s alloc scan_priv fail\n", __func__);
return res;
}
_rtw_memset(scan_priv, 0, sizeof(*scan_priv));
scan_priv->padapter = padapter;
scan_priv->wdev = wdev;
_rtw_memcpy(&scan_priv->channel, ch, sizeof(*ch));
scan_priv->channel_type = ch_type;
scan_priv->cookie = cookie;
scan_priv->duration = duration;
scan_priv->restore_ch = rtw_get_oper_ch(padapter);
phl_param.priv = scan_priv;
/* check channel */
remain_ch = (u16)ieee80211_frequency_to_channel(ch->center_freq);
if (roch_stay_in_cur_chan(padapter) == _TRUE) {
remain_ch = rtw_mi_get_union_chan(padapter);
RTW_INFO(FUNC_ADPT_FMT" stay in union ch:%d\n",
FUNC_ADPT_ARG(padapter), remain_ch);
}
/* prepare remain channel */
phl_ch_sz = sizeof(struct phl_scan_channel);
_rtw_memset(&phl_ch, 0, phl_ch_sz);
phl_ch.channel = remain_ch;
phl_ch.duration = scan_priv->duration;
phl_ch.scan_mode = NORMAL_SCAN_MODE;
phl_ch.bw = CHANNEL_WIDTH_20;
phl_param.ch = &phl_ch;
phl_param.ch_sz = phl_ch_sz;
phl_param.ch_num = 1;
phl_param.wifi_role = padapter->phl_role;
phl_param.back_op_mode = SCAN_BKOP_TIMER;
phl_param.back_op_ch_dur_ms = bkop_parm->on_ch_dur;
phl_param.back_op_off_ch_dur_ms = bkop_parm->off_ch_dur;
phl_param.back_op_off_ch_ext_dur_ms = bkop_parm->off_ch_ext_dur;
#ifdef CONFIG_P2P
if (is_p2p)
phl_param.ops = &p2p_remain_ops_cb;
else
#endif
phl_param.ops = &remain_ops_cb;
RTW_INFO(FUNC_ADPT_FMT" ch:%u duration:%d, cookie:0x%llx\n"
, FUNC_ADPT_ARG(padapter), phl_ch.channel,
scan_priv->duration, cookie);
/* sent message to request phl scan
* IMMEDIATE imply cancelling previous scan request if has
*/
rtw_phl_scan_request(dvobj->phl, &phl_param, IMMEDIATE);
/* scan_priv will be cancelled in roch_complete_cb */
res = _SUCCESS;
return res;
}
#endif
#endif /*CONFIG_IOCTL_CFG80211*/
#endif /*CONFIG_PHL_ARCH*/
|
2301_81045437/rtl8852be
|
core/rtw_scan.c
|
C
|
agpl-3.0
| 93,389
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_SDIO_C_
#include <drv_types.h> /* struct dvobj_priv and etc. */
#include <drv_types_sdio.h> /* RTW_SDIO_ADDR_CMD52_GEN */
/*
* Description:
* Use SDIO cmd52 or cmd53 to read/write data
*
* Parameters:
* d pointer of device object(struct dvobj_priv)
* addr SDIO address, 17 bits
* buf buffer for I/O
* len length
* write 0:read, 1:write
* cmd52 0:cmd52, 1:cmd53
*
* Return:
* _SUCCESS I/O ok.
* _FAIL I/O fail.
*/
static u8 sdio_io(struct dvobj_priv *d, u32 addr, void *buf, size_t len, u8 write, u8 cmd52)
{
#ifdef DBG_SDIO
#if (DBG_SDIO >= 3)
struct sdio_data *sdio = dvobj_to_sdio(d);
#endif /* DBG_SDIO >= 3 */
#endif /* DBG_SDIO */
u32 addr_drv; /* address with driver defined bit */
int err;
u8 retry = 0;
u8 stop_retry = _FALSE; /* flag for stopping retry or not */
if (dev_is_surprise_removed(d)) {
RTW_ERR("%s: bSurpriseRemoved, skip %s 0x%05x, %zu bytes\n",
__FUNCTION__, write?"write":"read", addr, len);
return _FAIL;
}
addr_drv = addr;
if (cmd52)
addr_drv = RTW_SDIO_ADDR_CMD52_GEN(addr_drv);
do {
if (write)
err = d->intf_ops->write(d, addr_drv, buf, len, 0);
else
err = d->intf_ops->read(d, addr_drv, buf, len, 0);
if (!err) {
if (retry) {
RTW_INFO("%s: Retry %s OK! addr=0x%05x %zu bytes, retry=%u,%u\n",
__FUNCTION__, write?"write":"read",
addr, len, retry, ATOMIC_READ(&d->continual_io_error));
RTW_INFO_DUMP("Data: ", buf, len);
}
rtw_reset_continual_io_error(d);
break;
}
RTW_ERR("%s: %s FAIL! error(%d) addr=0x%05x %zu bytes, retry=%u,%u\n",
__FUNCTION__, write?"write":"read", err, addr, len,
retry, ATOMIC_READ(&d->continual_io_error));
#ifdef DBG_SDIO
#if (DBG_SDIO >= 3)
if (sdio->dbg_enable) {
if (sdio->err_test && sdio->err_test_triggered)
sdio->err_test = 0;
if (sdio->err_stop) {
RTW_ERR("%s: I/O error! Set surprise remove flag ON!\n",
__FUNCTION__);
dev_set_surprise_removed(d);
return _FAIL;
}
}
#endif /* DBG_SDIO >= 3 */
#endif /* DBG_SDIO */
retry++;
stop_retry = rtw_inc_and_chk_continual_io_error(d);
if ((err == -1) || (stop_retry == _TRUE) || (retry > SD_IO_TRY_CNT)) {
/* critical error, unrecoverable */
RTW_ERR("%s: Fatal error! Set surprise remove flag ON! (retry=%u,%u)\n",
__FUNCTION__, retry, ATOMIC_READ(&d->continual_io_error));
dev_set_surprise_removed(d);
return _FAIL;
}
/* WLAN IOREG or SDIO Local */
if ((addr & 0x10000) || !(addr & 0xE000)) {
RTW_WARN("%s: Retry %s addr=0x%05x %zu bytes, retry=%u,%u\n",
__FUNCTION__, write?"write":"read", addr, len,
retry, ATOMIC_READ(&d->continual_io_error));
continue;
}
return _FAIL;
} while (1);
return _SUCCESS;
}
u8 rtw_sdio_read_cmd52(struct dvobj_priv *d, u32 addr, void *buf, size_t len)
{
return sdio_io(d, addr, buf, len, 0, 1);
}
u8 rtw_sdio_read_cmd53(struct dvobj_priv *d, u32 addr, void *buf, size_t len)
{
return sdio_io(d, addr, buf, len, 0, 0);
}
u8 rtw_sdio_write_cmd52(struct dvobj_priv *d, u32 addr, void *buf, size_t len)
{
return sdio_io(d, addr, buf, len, 1, 1);
}
u8 rtw_sdio_write_cmd53(struct dvobj_priv *d, u32 addr, void *buf, size_t len)
{
return sdio_io(d, addr, buf, len, 1, 0);
}
u8 rtw_sdio_f0_read(struct dvobj_priv *d, u32 addr, void *buf, size_t len)
{
int err;
u8 ret;
ret = _SUCCESS;
addr = RTW_SDIO_ADDR_F0_GEN(addr);
err = d->intf_ops->read(d, addr, buf, len, 0);
if (err)
ret = _FAIL;
return ret;
}
/**
* rtw_sdio_cmd53_align_size() - Align size to one CMD53 could complete
* @d struct dvobj_priv*
* @len length to align
*
* Adjust len to align block size, and the new size could be transfered by one
* CMD53.
* If len < block size, it would keep original value, otherwise the value
* would be rounded up by block size.
*
* Return adjusted length.
*/
size_t rtw_sdio_cmd53_align_size(struct dvobj_priv *d, size_t len)
{
u32 blk_sz;
blk_sz = rtw_sdio_get_block_size(d);
if (len <= blk_sz)
return len;
return _RND(len, blk_sz);
}
|
2301_81045437/rtl8852be
|
core/rtw_sdio.c
|
C
|
agpl-3.0
| 4,651
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_SEC_CAM_C_
#include <drv_types.h>
#include <rtw_sec_cam.h>
void invalidate_cam_all(_adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
u8 val8 = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_CAM_INVALID_ALL, &val8);
_rtw_spinlock_bh(&cam_ctl->lock);
rtw_sec_cam_map_clr_all(&cam_ctl->used);
_rtw_memset(dvobj->cam_cache, 0, sizeof(struct sec_cam_ent) * SEC_CAM_ENT_NUM_SW_LIMIT);
_rtw_spinunlock_bh(&cam_ctl->lock);
}
void _clear_cam_entry(_adapter *padapter, u8 entry)
{
unsigned char null_sta[6] = {0};
unsigned char null_key[32] = {0};
rtw_hal_sec_write_cam_ent(padapter, entry, 0, null_sta, null_key);
}
inline void _write_cam(_adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key)
{
#ifdef CONFIG_WRITE_CACHE_ONLY
write_cam_cache(adapter, id , ctrl, mac, key);
#else
rtw_hal_sec_write_cam_ent(adapter, id, ctrl, mac, key);
write_cam_cache(adapter, id , ctrl, mac, key);
#endif
}
inline void write_cam(_adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key)
{
if (ctrl & BIT(9)) {
_write_cam(adapter, id, ctrl, mac, key);
_write_cam(adapter, (id + 1), ctrl | BIT(5), mac, (key + 16));
RTW_INFO_DUMP("key-0: ", key, 16);
RTW_INFO_DUMP("key-1: ", (key + 16), 16);
} else
_write_cam(adapter, id, ctrl, mac, key);
}
inline void clear_cam_entry(_adapter *adapter, u8 id)
{
_clear_cam_entry(adapter, id);
clear_cam_cache(adapter, id);
}
inline void write_cam_from_cache(_adapter *adapter, u8 id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
struct sec_cam_ent cache;
_rtw_spinlock_bh(&cam_ctl->lock);
_rtw_memcpy(&cache, &dvobj->cam_cache[id], sizeof(struct sec_cam_ent));
_rtw_spinunlock_bh(&cam_ctl->lock);
rtw_hal_sec_write_cam_ent(adapter, id, cache.ctrl, cache.mac, cache.key);
}
void write_cam_cache(_adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
_rtw_spinlock_bh(&cam_ctl->lock);
dvobj->cam_cache[id].ctrl = ctrl;
_rtw_memcpy(dvobj->cam_cache[id].mac, mac, ETH_ALEN);
_rtw_memcpy(dvobj->cam_cache[id].key, key, 16);
_rtw_spinunlock_bh(&cam_ctl->lock);
}
void clear_cam_cache(_adapter *adapter, u8 id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
_rtw_spinlock_bh(&cam_ctl->lock);
_rtw_memset(&(dvobj->cam_cache[id]), 0, sizeof(struct sec_cam_ent));
_rtw_spinunlock_bh(&cam_ctl->lock);
}
inline bool _rtw_camctl_chk_cap(_adapter *adapter, u8 cap)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
if (cam_ctl->sec_cap & cap)
return _TRUE;
return _FALSE;
}
inline void _rtw_camctl_set_flags(_adapter *adapter, u32 flags)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
cam_ctl->flags |= flags;
}
inline void rtw_camctl_set_flags(_adapter *adapter, u32 flags)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
_rtw_spinlock_bh(&cam_ctl->lock);
_rtw_camctl_set_flags(adapter, flags);
_rtw_spinunlock_bh(&cam_ctl->lock);
}
inline void _rtw_camctl_clr_flags(_adapter *adapter, u32 flags)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
cam_ctl->flags &= ~flags;
}
inline void rtw_camctl_clr_flags(_adapter *adapter, u32 flags)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
_rtw_spinlock_bh(&cam_ctl->lock);
_rtw_camctl_clr_flags(adapter, flags);
_rtw_spinunlock_bh(&cam_ctl->lock);
}
inline bool _rtw_camctl_chk_flags(_adapter *adapter, u32 flags)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
if (cam_ctl->flags & flags)
return _TRUE;
return _FALSE;
}
void dump_sec_cam_map(void *sel, struct sec_cam_bmp *map, u8 max_num)
{
RTW_PRINT_SEL(sel, "0x%08x\n", map->m0);
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 32)
if (max_num && max_num > 32)
RTW_PRINT_SEL(sel, "0x%08x\n", map->m1);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 64)
if (max_num && max_num > 64)
RTW_PRINT_SEL(sel, "0x%08x\n", map->m2);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 96)
if (max_num && max_num > 96)
RTW_PRINT_SEL(sel, "0x%08x\n", map->m3);
#endif
}
inline bool rtw_sec_camid_is_set(struct sec_cam_bmp *map, u8 id)
{
if (id < 32)
return map->m0 & BIT(id);
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 32)
else if (id < 64)
return map->m1 & BIT(id - 32);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 64)
else if (id < 96)
return map->m2 & BIT(id - 64);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 96)
else if (id < 128)
return map->m3 & BIT(id - 96);
#endif
else
rtw_warn_on(1);
return 0;
}
inline void rtw_sec_cam_map_set(struct sec_cam_bmp *map, u8 id)
{
if (id < 32)
map->m0 |= BIT(id);
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 32)
else if (id < 64)
map->m1 |= BIT(id - 32);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 64)
else if (id < 96)
map->m2 |= BIT(id - 64);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 96)
else if (id < 128)
map->m3 |= BIT(id - 96);
#endif
else
rtw_warn_on(1);
}
inline void rtw_sec_cam_map_clr(struct sec_cam_bmp *map, u8 id)
{
if (id < 32)
map->m0 &= ~BIT(id);
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 32)
else if (id < 64)
map->m1 &= ~BIT(id - 32);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 64)
else if (id < 96)
map->m2 &= ~BIT(id - 64);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 96)
else if (id < 128)
map->m3 &= ~BIT(id - 96);
#endif
else
rtw_warn_on(1);
}
inline void rtw_sec_cam_map_clr_all(struct sec_cam_bmp *map)
{
map->m0 = 0;
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 32)
map->m1 = 0;
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 64)
map->m2 = 0;
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 96)
map->m3 = 0;
#endif
}
inline bool rtw_sec_camid_is_drv_forbid(struct cam_ctl_t *cam_ctl, u8 id)
{
struct sec_cam_bmp forbid_map;
forbid_map.m0 = 0x00000ff0;
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 32)
forbid_map.m1 = 0x00000000;
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 64)
forbid_map.m2 = 0x00000000;
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 96)
forbid_map.m3 = 0x00000000;
#endif
if (id < 32)
return forbid_map.m0 & BIT(id);
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 32)
else if (id < 64)
return forbid_map.m1 & BIT(id - 32);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 64)
else if (id < 96)
return forbid_map.m2 & BIT(id - 64);
#endif
#if (SEC_CAM_ENT_NUM_SW_LIMIT > 96)
else if (id < 128)
return forbid_map.m3 & BIT(id - 96);
#endif
else
rtw_warn_on(1);
return 1;
}
bool _rtw_sec_camid_is_used(struct cam_ctl_t *cam_ctl, u8 id)
{
bool ret = _FALSE;
if (id >= cam_ctl->num) {
rtw_warn_on(1);
goto exit;
}
#if 0 /* for testing */
if (rtw_sec_camid_is_drv_forbid(cam_ctl, id)) {
ret = _TRUE;
goto exit;
}
#endif
ret = rtw_sec_camid_is_set(&cam_ctl->used, id);
exit:
return ret;
}
inline bool rtw_sec_camid_is_used(struct cam_ctl_t *cam_ctl, u8 id)
{
bool ret;
_rtw_spinlock_bh(&cam_ctl->lock);
ret = _rtw_sec_camid_is_used(cam_ctl, id);
_rtw_spinunlock_bh(&cam_ctl->lock);
return ret;
}
u8 rtw_get_sec_camid(_adapter *adapter, u8 max_bk_key_num, u8 *sec_key_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
int i;
u8 sec_cam_num = 0;
_rtw_spinlock_bh(&cam_ctl->lock);
for (i = 0; i < cam_ctl->num; i++) {
if (_rtw_sec_camid_is_used(cam_ctl, i)) {
sec_key_id[sec_cam_num++] = i;
if (sec_cam_num == max_bk_key_num)
break;
}
}
_rtw_spinunlock_bh(&cam_ctl->lock);
return sec_cam_num;
}
inline bool _rtw_camid_is_gk(_adapter *adapter, u8 cam_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
bool ret = _FALSE;
if (cam_id >= cam_ctl->num) {
rtw_warn_on(1);
goto exit;
}
if (_rtw_sec_camid_is_used(cam_ctl, cam_id) == _FALSE)
goto exit;
ret = (dvobj->cam_cache[cam_id].ctrl & BIT6) ? _TRUE : _FALSE;
exit:
return ret;
}
inline bool rtw_camid_is_gk(_adapter *adapter, u8 cam_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
bool ret;
_rtw_spinlock_bh(&cam_ctl->lock);
ret = _rtw_camid_is_gk(adapter, cam_id);
_rtw_spinunlock_bh(&cam_ctl->lock);
return ret;
}
bool cam_cache_chk(_adapter *adapter, u8 id, u8 *addr, s16 kid, s8 gk)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
bool ret = _FALSE;
if (addr && _rtw_memcmp(dvobj->cam_cache[id].mac, addr, ETH_ALEN) == _FALSE)
goto exit;
if (kid >= 0 && kid != (dvobj->cam_cache[id].ctrl & 0x03))
goto exit;
if (gk != -1 && (gk ? _TRUE : _FALSE) != _rtw_camid_is_gk(adapter, id))
goto exit;
ret = _TRUE;
exit:
return ret;
}
s16 _rtw_camid_search(_adapter *adapter, u8 *addr, s16 kid, s8 gk)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
int i;
s16 cam_id = -1;
for (i = 0; i < cam_ctl->num; i++) {
if (cam_cache_chk(adapter, i, addr, kid, gk)) {
cam_id = i;
break;
}
}
if (0) {
if (addr)
RTW_INFO(FUNC_ADPT_FMT" addr:"MAC_FMT" kid:%d, gk:%d, return cam_id:%d\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(addr), kid, gk, cam_id);
else
RTW_INFO(FUNC_ADPT_FMT" addr:%p kid:%d, gk:%d, return cam_id:%d\n"
, FUNC_ADPT_ARG(adapter), addr, kid, gk, cam_id);
}
return cam_id;
}
s16 rtw_camid_search(_adapter *adapter, u8 *addr, s16 kid, s8 gk)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
s16 cam_id = -1;
_rtw_spinlock_bh(&cam_ctl->lock);
cam_id = _rtw_camid_search(adapter, addr, kid, gk);
_rtw_spinunlock_bh(&cam_ctl->lock);
return cam_id;
}
s16 rtw_get_camid(_adapter *adapter, u8 *addr, s16 kid, u8 gk, bool ext_sec)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
int i;
#if 0 /* for testing */
static u8 start_id = 0;
#else
u8 start_id = 0;
#endif
s16 cam_id = -1;
if (addr == NULL) {
RTW_PRINT(FUNC_ADPT_FMT" mac_address is NULL\n"
, FUNC_ADPT_ARG(adapter));
rtw_warn_on(1);
goto _exit;
}
/* find cam entry which has the same addr, kid (, gk bit) */
if (_rtw_camctl_chk_cap(adapter, SEC_CAP_CHK_BMC) == _TRUE)
i = _rtw_camid_search(adapter, addr, kid, gk);
else
i = _rtw_camid_search(adapter, addr, kid, -1);
if (i >= 0) {
cam_id = i;
goto _exit;
}
for (i = 0; i < cam_ctl->num; i++) {
/* bypass default key which is allocated statically */
#if 0//ndef CONFIG_CONCURRENT_MODE
if (((i + start_id) % cam_ctl->num) < 4)
continue;
#endif
if (_rtw_sec_camid_is_used(cam_ctl, ((i + start_id) % cam_ctl->num)) == _FALSE) {
if (ext_sec) {
/* look out continue slot */
if (((i + 1) < cam_ctl->num) &&
(_rtw_sec_camid_is_used(cam_ctl, (((i + 1) + start_id) % cam_ctl->num)) == _FALSE))
break;
else
continue;
} else
break;
}
}
if (i == cam_ctl->num) {
RTW_PRINT(FUNC_ADPT_FMT" %s key with "MAC_FMT" id:%u no room\n"
, FUNC_ADPT_ARG(adapter), gk ? "group" : "pairwise", MAC_ARG(addr), kid);
rtw_warn_on(1);
goto _exit;
}
cam_id = ((i + start_id) % cam_ctl->num);
start_id = ((i + start_id + 1) % cam_ctl->num);
_exit:
return cam_id;
}
s16 rtw_camid_alloc(_adapter *adapter, struct sta_info *sta, u8 kid, u8 gk, bool ext_sec, bool *used)
{
struct mlme_ext_info *mlmeinfo = &adapter->mlmeextpriv.mlmext_info;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
s16 cam_id = -1;
*used = _FALSE;
_rtw_spinlock_bh(&cam_ctl->lock);
if ((((mlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) || ((mlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE))
&& !sta) {
/*
* 1. non-STA mode WEP key
* 2. group TX key
*/
#if 0//ndef CONFIG_CONCURRENT_MODE
/* static alloction to default key by key ID when concurrent is not defined */
if (kid > 3) {
RTW_PRINT(FUNC_ADPT_FMT" group key with invalid key id:%u\n"
, FUNC_ADPT_ARG(adapter), kid);
rtw_warn_on(1);
goto bitmap_handle;
}
cam_id = kid;
#else
u8 *addr = adapter_mac_addr(adapter);
cam_id = rtw_get_camid(adapter, addr, kid, gk, ext_sec);
if (1)
RTW_PRINT(FUNC_ADPT_FMT" group key with "MAC_FMT" assigned cam_id:%u\n"
, FUNC_ADPT_ARG(adapter), MAC_ARG(addr), cam_id);
#endif
} else {
/*
* 1. STA mode WEP key
* 2. STA mode group RX key
* 3. sta key (pairwise, group RX)
*/
u8 *addr = sta ? sta->phl_sta->mac_addr : NULL;
if (!sta) {
if (!(mlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) {
/* bypass STA mode group key setting before connected(ex:WEP) because bssid is not ready */
goto bitmap_handle;
}
addr = get_bssid(&adapter->mlmepriv);/*A2*/
}
cam_id = rtw_get_camid(adapter, addr, kid, gk, ext_sec);
}
bitmap_handle:
if (cam_id >= 0) {
*used = _rtw_sec_camid_is_used(cam_ctl, cam_id);
rtw_sec_cam_map_set(&cam_ctl->used, cam_id);
if (ext_sec)
rtw_sec_cam_map_set(&cam_ctl->used, cam_id + 1);
}
_rtw_spinunlock_bh(&cam_ctl->lock);
return cam_id;
}
void rtw_camid_set(_adapter *adapter, u8 cam_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
_rtw_spinlock_bh(&cam_ctl->lock);
if (cam_id < cam_ctl->num)
rtw_sec_cam_map_set(&cam_ctl->used, cam_id);
_rtw_spinunlock_bh(&cam_ctl->lock);
}
void rtw_camid_free(_adapter *adapter, u8 cam_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
_rtw_spinlock_bh(&cam_ctl->lock);
if (cam_id < cam_ctl->num)
rtw_sec_cam_map_clr(&cam_ctl->used, cam_id);
_rtw_spinunlock_bh(&cam_ctl->lock);
}
/*Must pause TX/RX before use this API*/
inline void rtw_sec_cam_swap(_adapter *adapter, u8 cam_id_a, u8 cam_id_b)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
struct sec_cam_ent cache_a, cache_b;
bool cam_a_used, cam_b_used;
if (1)
RTW_INFO(ADPT_FMT" - sec_cam %d,%d swap\n", ADPT_ARG(adapter), cam_id_a, cam_id_b);
if (cam_id_a == cam_id_b)
return;
/*setp-1. backup org cam_info*/
_rtw_spinlock_bh(&cam_ctl->lock);
cam_a_used = _rtw_sec_camid_is_used(cam_ctl, cam_id_a);
cam_b_used = _rtw_sec_camid_is_used(cam_ctl, cam_id_b);
if (cam_a_used)
_rtw_memcpy(&cache_a, &dvobj->cam_cache[cam_id_a], sizeof(struct sec_cam_ent));
if (cam_b_used)
_rtw_memcpy(&cache_b, &dvobj->cam_cache[cam_id_b], sizeof(struct sec_cam_ent));
_rtw_spinunlock_bh(&cam_ctl->lock);
/*setp-2. clean cam_info*/
if (cam_a_used) {
rtw_camid_free(adapter, cam_id_a);
clear_cam_entry(adapter, cam_id_a);
}
if (cam_b_used) {
rtw_camid_free(adapter, cam_id_b);
clear_cam_entry(adapter, cam_id_b);
}
/*setp-3. set cam_info*/
if (cam_a_used) {
write_cam(adapter, cam_id_b, cache_a.ctrl, cache_a.mac, cache_a.key);
rtw_camid_set(adapter, cam_id_b);
}
if (cam_b_used) {
write_cam(adapter, cam_id_a, cache_b.ctrl, cache_b.mac, cache_b.key);
rtw_camid_set(adapter, cam_id_a);
}
}
s16 rtw_get_empty_cam_entry(_adapter *adapter, u8 start_camid)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
int i;
s16 cam_id = -1;
_rtw_spinlock_bh(&cam_ctl->lock);
for (i = start_camid; i < cam_ctl->num; i++) {
if (_FALSE == _rtw_sec_camid_is_used(cam_ctl, i)) {
cam_id = i;
break;
}
}
_rtw_spinunlock_bh(&cam_ctl->lock);
return cam_id;
}
void rtw_clean_dk_section(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = dvobj_to_sec_camctl(dvobj);
s16 ept_cam_id;
int i;
for (i = 0; i < 4; i++) {
if (rtw_sec_camid_is_used(cam_ctl, i)) {
ept_cam_id = rtw_get_empty_cam_entry(adapter, 4);
if (ept_cam_id > 0)
rtw_sec_cam_swap(adapter, i, ept_cam_id);
}
}
}
void rtw_clean_hw_dk_cam(_adapter *adapter)
{
int i;
for (i = 0; i < 4; i++)
rtw_hal_sec_clr_cam_ent(adapter, i);
/*_clear_cam_entry(adapter, i);*/
}
void flush_all_cam_entry(struct _ADAPTER *a, enum phl_cmd_type cmd_type, u32 cmd_timeout)
{
struct mlme_ext_info *pmlmeinfo = &a->mlmeextpriv.mlmext_info;
struct sta_priv *stapriv = &a->stapriv;
u8 *mac;
struct sta_info *sta;
if (MLME_IS_STA(a)) {
mac = pmlmeinfo->network.MacAddress;
sta = rtw_get_stainfo(stapriv, mac);
if (sta) {
if (sta->state & WIFI_AP_STATE)
/*clear cam when ap free per sta_info*/
RTW_INFO("%s: sta->state(0x%x) is AP, "
"do nothing\n",
__func__, sta->state);
else
rtw_hw_del_all_key(a, sta, cmd_type, cmd_timeout);
} else {
RTW_WARN("%s: cann't find sta for %pM\n", __func__, mac);
rtw_warn_on(1);
}
} else if (MLME_IS_AP(a) || MLME_IS_MESH(a)) {
mac = adapter_mac_addr(a);
sta = rtw_get_stainfo(stapriv, mac);
if (sta)
rtw_hw_del_all_key(a, sta, cmd_type, cmd_timeout);
}
}
#if defined(DBG_CONFIG_ERROR_RESET) && defined(CONFIG_CONCURRENT_MODE)
void rtw_iface_bcmc_sec_cam_map_restore(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = dvobj_to_sec_camctl(dvobj);
int cam_id = -1;
cam_id = rtw_phl_wrole_bcmc_id_get(GET_PHL_INFO(dvobj), adapter->phl_role);
if (cam_id != INVALID_SEC_MAC_CAM_ID)
rtw_sec_cam_map_set(&cam_ctl->used, cam_id);
}
#endif
#ifdef CONFIG_DBG_AX_CAM
/*
1. Mode 0 : no key
2. Mode 1 : unicast 0 - 6
3. Mode 2 : unicast 0 - 1 Group: 2 - 4 BIP: 5 - 6
4. Mode 3 : unicast 0 - 1 Group: 2 - 5 BIP: 6
*/
static enum CAM_KEY_TYPE search_keytype_by_mode(u8 mode, u8 entry_num)
{
enum CAM_KEY_TYPE key_type = KEY_TYPE_NONE;
switch (mode) {
case 0:
key_type = KEY_TYPE_NONE;
break;
case 1:
key_type = KEY_TYPE_UNI;
break;
case 2:
if (entry_num < 2)
key_type = KEY_TYPE_UNI;
else if (entry_num < 5)
key_type = KEY_TYPE_GROUP;
else if (entry_num < 7)
key_type = KEY_TYPE_BIP;
else
key_type = KEY_TYPE_NONE;
break;
case 3:
if (entry_num < 2)
key_type = KEY_TYPE_UNI;
else if (entry_num < 6)
key_type = KEY_TYPE_GROUP;
else if (entry_num < 7)
key_type = KEY_TYPE_BIP;
else
key_type = KEY_TYPE_NONE;
break;
default:
key_type = KEY_TYPE_NONE;
break;
}
return key_type;
}
static const char* enc_algo_to_string[] = {
"RTW_ENC_NONE",
"RTW_ENC_WEP40",
"RTW_ENC_WEP104",
"RTW_ENC_TKIP",
"RTW_ENC_WAPI",
"RTW_ENC_GCMSMS4",
"RTW_ENC_CCMP",
"RTW_ENC_CCMP256",
"RTW_ENC_GCMP",
"RTW_ENC_GCMP256",
"RTW_ENC_BIP_CCMP128",
"RTW_ENC_MAX"
};
static const char* type_to_string[] = {
"unicast",
"multicast",
"BIP",
"NONE"
};
static const char* nettype_to_string[] = {
"NoLink",
"Ad-hoc",
"Infra",
"AP"
};
static u8 get_keyid(u8 num, u8* addr_cam)
{
u8 keyid = 0;
switch (num) {
case 0:
keyid = GET_AX_ADDR_CAM_SEC_ENT0_KEYID(addr_cam);
break;
case 1:
keyid = GET_AX_ADDR_CAM_SEC_ENT1_KEYID(addr_cam);
break;
case 2:
keyid = GET_AX_ADDR_CAM_SEC_ENT2_KEYID(addr_cam);
break;
case 3:
keyid = GET_AX_ADDR_CAM_SEC_ENT3_KEYID(addr_cam);
break;
case 4:
keyid = GET_AX_ADDR_CAM_SEC_ENT4_KEYID(addr_cam);
break;
case 5:
keyid = GET_AX_ADDR_CAM_SEC_ENT5_KEYID(addr_cam);
break;
case 6:
keyid = GET_AX_ADDR_CAM_SEC_ENT6_KEYID(addr_cam);
break;
default:
keyid = 0;
break;
}
return keyid;
}
static u8 get_sec_entry(u8 num, u8* addr_cam)
{
u8 entry = 0;
switch (num) {
case 0:
entry = GET_AX_ADDR_CAM_SEC_ENT0(addr_cam);
break;
case 1:
entry = GET_AX_ADDR_CAM_SEC_ENT1(addr_cam);
break;
case 2:
entry = GET_AX_ADDR_CAM_SEC_ENT2(addr_cam);
break;
case 3:
entry = GET_AX_ADDR_CAM_SEC_ENT3(addr_cam);
break;
case 4:
entry = GET_AX_ADDR_CAM_SEC_ENT4(addr_cam);
break;
case 5:
entry = GET_AX_ADDR_CAM_SEC_ENT5(addr_cam);
break;
case 6:
entry = GET_AX_ADDR_CAM_SEC_ENT6(addr_cam);
break;
default:
entry = 0;
break;
}
return entry;
}
static void dump_cam_info(void* sel, u8 *buf, u32 start, u32 end)
{
int i, j = 1;
for (i = start; i < end; i += 1) {
if (j % 4 == 1)
RTW_PRINT_SEL(sel,"0x%04x", i);
RTW_PRINT_SEL(sel," 0x%08x ", *(u32 *)(buf+ (i*4)));
if ((j++) % 4 == 0)
RTW_PRINT_SEL(sel,"\n");
}
}
static void search_sec_cam_by_entry(struct _ADAPTER *a, u8 num, u8* target_entry)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(a);
void *phl;
u32 sec_tmp_buf = 0;
int i;
phl = GET_PHL_INFO(dvobj);
rtw_phl_write32(phl, INDIRECT_ACCESS_ADDR, (SEC_CAM_BASE_ADDR + num*32));
for (i = 0; i < 5; i++) {
sec_tmp_buf = rtw_phl_read32(phl,INDIRECT_ACCESS_VALUE + i*4);
_rtw_memcpy((target_entry + i*4), &sec_tmp_buf, 4);
}
}
static void search_bssid_cam_by_entry(struct _ADAPTER *a, u8 num, u8* target_entry)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(a);
void *phl;
u32 BSSID_tmp_buf = 0;
int i;
phl = GET_PHL_INFO(dvobj);
rtw_phl_write32(phl, INDIRECT_ACCESS_ADDR, (BSSID_CAM_BASE_ADDR+ num*8));
for (i = 0 ; i < 2; i++) {
BSSID_tmp_buf = rtw_phl_read32(phl,INDIRECT_ACCESS_VALUE + i*4);
_rtw_memcpy((target_entry + i*4), &BSSID_tmp_buf, 4);
}
}
static u8 varify_256_len(u8 enc)
{
u8 hit = _FALSE;
if (enc == 4|| enc == 7|| enc == 9)
hit = _TRUE;
return hit;
}
int get_ax_address_cam(void* sel, struct _ADAPTER *a)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(a);
void *phl;
/*addr cam: 128 entries*/
int loop_num = 128;
/*addr cam: 11 DW but the last one all rsvd*/
u32 addr_tmp_buf = 0;
u8 addr_map[40] = {0};
int i, j;
phl = GET_PHL_INFO(dvobj);
for (i = 0; i < loop_num; i++) {
_rtw_memset(addr_map,0,sizeof(addr_map));
rtw_phl_write32(phl, INDIRECT_ACCESS_ADDR, (ADDR_CAM_BASE_ADDR + i*64));
for (j = 0; j < 10; j++) {
addr_tmp_buf = rtw_phl_read32(phl,INDIRECT_ACCESS_VALUE + j*4);
_rtw_memcpy(&addr_map[j*4], &addr_tmp_buf, 4);
}
RTW_PRINT_SEL(sel, "======= ADDR CAM (%d)DUMP =======\n", i);
dump_cam_info(sel,addr_map,0,10);
RTW_PRINT_SEL(sel, "\n");
}
return 0;
}
int get_ax_sec_cam(void* sel, struct _ADAPTER *a)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(a);
void *phl;
/*security cam: 128 entries*/
int loop_num = 128;
/*security cam: 5 DW*/
u32 sec_tmp_buf = 0;
u8 sec_map[20] = {0};
int i, j;
phl = GET_PHL_INFO(dvobj);
for (i = 0; i < loop_num; i++) {
_rtw_memset(sec_map,0,sizeof(sec_map));
rtw_phl_write32(phl, INDIRECT_ACCESS_ADDR, (SEC_CAM_BASE_ADDR + i*32));
for (j = 0; j < 5; j++) {
sec_tmp_buf = rtw_phl_read32(phl,INDIRECT_ACCESS_VALUE + j*4);
_rtw_memcpy(&sec_map[j*4], &sec_tmp_buf, 4);
}
RTW_PRINT_SEL(sel, "======= sec CAM (%d)DUMP =======\n", i);
dump_cam_info(sel, sec_map, 0, 5);
RTW_PRINT_SEL(sel, "\n");
}
return 0;
}
static void dump_valid_key(void* sel, u8* addr_map, u8* sec_map, u8* bssid_map\
, u8 sec_entry, u8 key_type, u8 keyid)
{
u8 SMA[ETH_ALEN] = {0}, TMA[ETH_ALEN] = {0};
u8 macid = 0, nettype = 0;
macid = GET_AX_ADDR_CAM_MACID(addr_map);
nettype = GET_AX_ADDR_CAM_NET_TYPE(addr_map);
_rtw_memcpy(SMA, &addr_map[8], ETH_ALEN);
_rtw_memcpy(TMA,&addr_map[14], ETH_ALEN);
RTW_PRINT_SEL(sel, "%-5u %s "MAC_FMT" " MAC_FMT" " MAC_FMT\
" %-5u %-5u %s %-7u %-3u %s "KEY_FMT"\n", macid\
, nettype_to_string[nettype], MAC_ARG(SMA), MAC_ARG(TMA)\
, MAC_ARG(&bssid_map[2]), keyid, sec_entry\
, enc_algo_to_string[GET_AX_SEC_CAM_TYPE(sec_map)] \
, GET_AX_SEC_CAM_EXT_KEY(sec_map), GET_AX_SEC_SPP_MODE_(sec_map)\
, type_to_string[key_type], KEY_ARG(&sec_map[4]));
}
static void prepare_to_dump_valid_key(void* sel, struct _ADAPTER *a, u8* addr_map, u8 ent)
{
u8 sec_map[20] = {0};
u8 keyid = 0, sec_entry = 0, key_type = KEY_TYPE_NONE;
u8 bssid_entry;
u8 bssid_map[8] = {0};
u8 enc_algor = 0;
key_type = search_keytype_by_mode(GET_AX_ADDR_CAM_SEC_ENT_MODE(addr_map) ,ent);
sec_entry = get_sec_entry(ent, addr_map);
bssid_entry = GET_AX_ADDR_CAM_BSSID_CAM_IDX(addr_map);
keyid = get_keyid(ent,addr_map);
search_sec_cam_by_entry(a, sec_entry, sec_map);
search_bssid_cam_by_entry(a, bssid_entry, bssid_map);
enc_algor = GET_AX_SEC_CAM_TYPE(sec_map);
if (varify_256_len(enc_algor) == _TRUE) {
dump_valid_key(sel, addr_map, sec_map, bssid_map, sec_entry, key_type, keyid);
search_sec_cam_by_entry(a, sec_entry + 1, sec_map);
dump_valid_key(sel, addr_map, sec_map, bssid_map, sec_entry + 1, key_type, keyid);
} else {
dump_valid_key(sel, addr_map, sec_map, bssid_map, sec_entry, key_type, keyid);
}
}
int get_ax_valid_key(void* sel, struct _ADAPTER *a)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(a);
void *phl;
/*addr cam: 128 entries*/
int loop_num = 128;
/*addr cam: 11 DW but the last one all rsvd*/
u32 addr_tmp_buf = 0;
u8 addr_map[40]= {0};
u8 sec_ent_valid = 0;
u8 macid = 0;
int i, j;
phl = GET_PHL_INFO(dvobj);
RTW_PRINT_SEL(sel, "Dump valid KEY\n");
RTW_PRINT_SEL(sel, "%-5s %-7s %-17s %-17s %-17s %-5s %-5s %-8s %-3s"\
" %-3s %s %s\n", "macid", "NETTYPE", "SMA", "TMA", "BSSID", "keyid"\
, "sec_entry", "enc_algor", "ext_key", "ssp", "key_type", "key");
for (i = 0; i < loop_num; i++) {
_rtw_memset(addr_map,0,sizeof(addr_map));
rtw_phl_write32(phl, INDIRECT_ACCESS_ADDR, (ADDR_CAM_BASE_ADDR + i*64));
for (j = 0; j < 10; j++) {
addr_tmp_buf = rtw_phl_read32(phl,INDIRECT_ACCESS_VALUE + j*4);
_rtw_memcpy(&addr_map[j*4], &addr_tmp_buf, 4);
}
sec_ent_valid = GET_AX_ADDR_CAM_SEC_ENT_VALID(addr_map);
for (j = 0 ;j< 7; j++) {
if (sec_ent_valid & BIT(j))
prepare_to_dump_valid_key(sel, a, addr_map, j);
}
}
return 0;
}
#endif /* CONFIG_DBG_AX_CAM */
|
2301_81045437/rtl8852be
|
core/rtw_sec_cam.c
|
C
|
agpl-3.0
| 26,161
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_SECURITY_C_
#include <drv_types.h>
#include <rtw_swcrypto.h>
static const char *_security_type_str[] = {
"N/A",
"WEP40",
"TKIP",
"TKIP_WM",
"AES",
"WEP104",
"SMS4",
"GCMP",
};
static const char *_security_type_bip_str[] = {
"BIP_CMAC_128",
"BIP_GMAC_128",
"BIP_GMAC_256",
"BIP_CMAC_256",
};
const char *security_type_str(u8 value)
{
#ifdef CONFIG_IEEE80211W
if ((_BIP_MAX_ > value) && (value >= _BIP_CMAC_128_))
return _security_type_bip_str[value & ~_SEC_TYPE_BIT_];
#endif
if (_CCMP_256_ == value)
return "CCMP_256";
if (_GCMP_256_ == value)
return "GCMP_256";
if (_SEC_TYPE_MAX_ > value)
return _security_type_str[value];
return NULL;
}
#ifdef CONFIG_IEEE80211W
u32 security_type_bip_to_gmcs(enum security_type type)
{
switch (type) {
case _BIP_CMAC_128_:
return WPA_CIPHER_BIP_CMAC_128;
case _BIP_GMAC_128_:
return WPA_CIPHER_BIP_GMAC_128;
case _BIP_GMAC_256_:
return WPA_CIPHER_BIP_GMAC_256;
case _BIP_CMAC_256_:
return WPA_CIPHER_BIP_CMAC_256;
default:
return 0;
}
}
#endif
#ifdef DBG_SW_SEC_CNT
#define WEP_SW_ENC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->wep_sw_enc_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->wep_sw_enc_cnt_mc++; \
else \
sec->wep_sw_enc_cnt_uc++; \
} while (0)
#define WEP_SW_DEC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->wep_sw_dec_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->wep_sw_dec_cnt_mc++; \
else \
sec->wep_sw_dec_cnt_uc++; \
} while (0)
#define TKIP_SW_ENC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->tkip_sw_enc_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->tkip_sw_enc_cnt_mc++; \
else \
sec->tkip_sw_enc_cnt_uc++; \
} while (0)
#define TKIP_SW_DEC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->tkip_sw_dec_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->tkip_sw_dec_cnt_mc++; \
else \
sec->tkip_sw_dec_cnt_uc++; \
} while (0)
#define AES_SW_ENC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->aes_sw_enc_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->aes_sw_enc_cnt_mc++; \
else \
sec->aes_sw_enc_cnt_uc++; \
} while (0)
#define AES_SW_DEC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->aes_sw_dec_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->aes_sw_dec_cnt_mc++; \
else \
sec->aes_sw_dec_cnt_uc++; \
} while (0)
#define GCMP_SW_ENC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->gcmp_sw_enc_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->gcmp_sw_enc_cnt_mc++; \
else \
sec->gcmp_sw_enc_cnt_uc++; \
} while (0)
#define GCMP_SW_DEC_CNT_INC(sec, ra) do {\
if (is_broadcast_mac_addr(ra)) \
sec->gcmp_sw_dec_cnt_bc++; \
else if (is_multicast_mac_addr(ra)) \
sec->gcmp_sw_dec_cnt_mc++; \
else \
sec->gcmp_sw_dec_cnt_uc++; \
} while (0)
#else
#define WEP_SW_ENC_CNT_INC(sec, ra)
#define WEP_SW_DEC_CNT_INC(sec, ra)
#define TKIP_SW_ENC_CNT_INC(sec, ra)
#define TKIP_SW_DEC_CNT_INC(sec, ra)
#define AES_SW_ENC_CNT_INC(sec, ra)
#define AES_SW_DEC_CNT_INC(sec, ra)
#define GCMP_SW_ENC_CNT_INC(sec, ra)
#define GCMP_SW_DEC_CNT_INC(sec, ra)
#endif /* DBG_SW_SEC_CNT */
/* *****WEP related***** */
#define CRC32_POLY 0x04c11db7
struct arc4context {
u32 x;
u32 y;
u8 state[256];
};
static void arcfour_init(struct arc4context *parc4ctx, u8 *key, u32 key_len)
{
u32 t, u;
u32 keyindex;
u32 stateindex;
u8 *state;
u32 counter;
state = parc4ctx->state;
parc4ctx->x = 0;
parc4ctx->y = 0;
for (counter = 0; counter < 256; counter++)
state[counter] = (u8)counter;
keyindex = 0;
stateindex = 0;
for (counter = 0; counter < 256; counter++) {
t = state[counter];
stateindex = (stateindex + key[keyindex] + t) & 0xff;
u = state[stateindex];
state[stateindex] = (u8)t;
state[counter] = (u8)u;
if (++keyindex >= key_len)
keyindex = 0;
}
}
static u32 arcfour_byte(struct arc4context *parc4ctx)
{
u32 x;
u32 y;
u32 sx, sy;
u8 *state;
state = parc4ctx->state;
x = (parc4ctx->x + 1) & 0xff;
sx = state[x];
y = (sx + parc4ctx->y) & 0xff;
sy = state[y];
parc4ctx->x = x;
parc4ctx->y = y;
state[y] = (u8)sx;
state[x] = (u8)sy;
return state[(sx + sy) & 0xff];
}
static void arcfour_encrypt(struct arc4context *parc4ctx,
u8 *dest,
u8 *src,
u32 len)
{
u32 i;
for (i = 0; i < len; i++)
dest[i] = src[i] ^ (unsigned char)arcfour_byte(parc4ctx);
}
static sint bcrc32initialized = 0;
static u32 crc32_table[256];
static u8 crc32_reverseBit(u8 data)
{
return (u8)((data << 7) & 0x80) | ((data << 5) & 0x40) | ((data << 3) & 0x20) | ((data << 1) & 0x10) | ((data >> 1) & 0x08) | ((data >> 3) & 0x04) | ((data >> 5) & 0x02) | ((
data >> 7) & 0x01) ;
}
static void crc32_init(void)
{
if (bcrc32initialized == 1)
goto exit;
else {
sint i, j;
u32 c;
u8 *p = (u8 *)&c, *p1;
u8 k;
c = 0x12340000;
for (i = 0; i < 256; ++i) {
k = crc32_reverseBit((u8)i);
for (c = ((u32)k) << 24, j = 8; j > 0; --j)
c = c & 0x80000000 ? (c << 1) ^ CRC32_POLY : (c << 1);
p1 = (u8 *)&crc32_table[i];
p1[0] = crc32_reverseBit(p[3]);
p1[1] = crc32_reverseBit(p[2]);
p1[2] = crc32_reverseBit(p[1]);
p1[3] = crc32_reverseBit(p[0]);
}
bcrc32initialized = 1;
}
exit:
return;
}
static u32 getcrc32(u8 *buf, sint len)
{
u8 *p;
u32 crc;
if (bcrc32initialized == 0)
crc32_init();
crc = 0xffffffff; /* preload shift register, per CRC-32 spec */
for (p = buf; len > 0; ++p, --len)
crc = crc32_table[(crc ^ *p) & 0xff] ^ (crc >> 8);
return ~crc; /* transmit complement, per CRC-32 spec */
}
/*
Need to consider the fragment situation
*/
void rtw_wep_encrypt(_adapter *padapter, u8 *pxmitframe)
{
struct xmit_frame *xf = (struct xmit_frame *)pxmitframe;
struct pkt_attrib *pattrib = &xf->attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct rtw_xmit_req *txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
unsigned char crc[4];
struct arc4context mycontext;
sint curfragnum, length;
u32 keylength;
u8 *pframe, *payload, *iv, *key;
u8 wepkey[16];
if ((pattrib->encrypt != _WEP40_) && (pattrib->encrypt != _WEP104_))
return;
/* start to encrypt each fragment */
keylength = psecuritypriv->dot11DefKeylen[psecuritypriv->dot11PrivacyKeyIndex];
key = psecuritypriv->dot11DefKey[psecuritypriv->dot11PrivacyKeyIndex].skey;
for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
if (!(pmlmeinfo->state & WIFI_FW_AUTH_STATE)) {
txreq = &xf->phl_txreq[curfragnum];
rtw_warn_on(txreq->pkt_cnt != 1);
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
pframe = pkt_list->vir_addr;
length = pkt_list->length - pattrib->hdrlen
- pattrib->iv_len - pattrib->icv_len;
} else {
/* special case for WEP auth */
/* only valid when curfragnum==0 */
rtw_warn_on(pattrib->nr_frags > 1);
pframe = xf->buf_addr + TXDESC_OFFSET;
length = pattrib->last_txcmdsz - pattrib->hdrlen
- pattrib->iv_len - pattrib->icv_len;
}
iv = pframe + pattrib->hdrlen;
_rtw_memcpy(&wepkey[0], iv, 3);
_rtw_memcpy(&wepkey[3], key, keylength);
payload = pframe + pattrib->iv_len + pattrib->hdrlen;
*((u32 *)crc) = cpu_to_le32(getcrc32(payload, length));
arcfour_init(&mycontext, wepkey, 3 + keylength);
arcfour_encrypt(&mycontext, payload, payload, length);
arcfour_encrypt(&mycontext, payload + length, crc, 4);
}
WEP_SW_ENC_CNT_INC(psecuritypriv, pattrib->ra);
}
void rtw_wep_decrypt(_adapter *padapter, u8 *precvframe)
{
/* exclude ICV */
u8 crc[4];
struct arc4context mycontext;
sint length;
u32 keylength;
u8 *pframe, *payload, *iv, wepkey[16];
u8 keyindex;
struct rx_pkt_attrib *prxattrib = &(((union recv_frame *)precvframe)->u.hdr.attrib);
struct security_priv *psecuritypriv = &padapter->securitypriv;
pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
/* start to decrypt recvframe */
if ((prxattrib->encrypt == _WEP40_) || (prxattrib->encrypt == _WEP104_)) {
iv = pframe + prxattrib->hdrlen;
/* keyindex=(iv[3]&0x3); */
keyindex = prxattrib->key_index;
keylength = psecuritypriv->dot11DefKeylen[keyindex];
_rtw_memcpy(&wepkey[0], iv, 3);
/* _rtw_memcpy(&wepkey[3], &psecuritypriv->dot11DefKey[psecuritypriv->dot11PrivacyKeyIndex].skey[0],keylength); */
_rtw_memcpy(&wepkey[3], &psecuritypriv->dot11DefKey[keyindex].skey[0], keylength);
length = ((union recv_frame *)precvframe)->u.hdr.len - prxattrib->hdrlen - prxattrib->iv_len;
payload = pframe + prxattrib->iv_len + prxattrib->hdrlen;
/* decrypt payload include icv */
arcfour_init(&mycontext, wepkey, 3 + keylength);
arcfour_encrypt(&mycontext, payload, payload, length);
/* calculate icv and compare the icv */
*((u32 *)crc) = le32_to_cpu(getcrc32(payload, length - 4));
WEP_SW_DEC_CNT_INC(psecuritypriv, prxattrib->ra);
}
return;
}
/* 3 =====TKIP related===== */
static u32 secmicgetuint32(u8 *p)
/* Convert from Byte[] to Us4Byte32 in a portable way */
{
s32 i;
u32 res = 0;
for (i = 0; i < 4; i++)
res |= ((u32)(*p++)) << (8 * i);
return res;
}
static void secmicputuint32(u8 *p, u32 val)
/* Convert from Us4Byte32 to Byte[] in a portable way */
{
long i;
for (i = 0; i < 4; i++) {
*p++ = (u8)(val & 0xff);
val >>= 8;
}
}
static void secmicclear(struct mic_data *pmicdata)
{
/* Reset the state to the empty message. */
pmicdata->L = pmicdata->K0;
pmicdata->R = pmicdata->K1;
pmicdata->nBytesInM = 0;
pmicdata->M = 0;
}
void rtw_secmicsetkey(struct mic_data *pmicdata, u8 *key)
{
/* Set the key */
pmicdata->K0 = secmicgetuint32(key);
pmicdata->K1 = secmicgetuint32(key + 4);
/* and reset the message */
secmicclear(pmicdata);
}
void rtw_secmicappendbyte(struct mic_data *pmicdata, u8 b)
{
/* Append the byte to our word-sized buffer */
pmicdata->M |= ((unsigned long)b) << (8 * pmicdata->nBytesInM);
pmicdata->nBytesInM++;
/* Process the word if it is full. */
if (pmicdata->nBytesInM >= 4) {
pmicdata->L ^= pmicdata->M;
pmicdata->R ^= ROL32(pmicdata->L, 17);
pmicdata->L += pmicdata->R;
pmicdata->R ^= ((pmicdata->L & 0xff00ff00) >> 8) | ((pmicdata->L & 0x00ff00ff) << 8);
pmicdata->L += pmicdata->R;
pmicdata->R ^= ROL32(pmicdata->L, 3);
pmicdata->L += pmicdata->R;
pmicdata->R ^= ROR32(pmicdata->L, 2);
pmicdata->L += pmicdata->R;
/* Clear the buffer */
pmicdata->M = 0;
pmicdata->nBytesInM = 0;
}
}
void rtw_secmicappend(struct mic_data *pmicdata, u8 *src, u32 nbytes)
{
/* This is simple */
while (nbytes > 0) {
rtw_secmicappendbyte(pmicdata, *src++);
nbytes--;
}
}
void rtw_secgetmic(struct mic_data *pmicdata, u8 *dst)
{
/* Append the minimum padding */
rtw_secmicappendbyte(pmicdata, 0x5a);
rtw_secmicappendbyte(pmicdata, 0);
rtw_secmicappendbyte(pmicdata, 0);
rtw_secmicappendbyte(pmicdata, 0);
rtw_secmicappendbyte(pmicdata, 0);
/* and then zeroes until the length is a multiple of 4 */
while (pmicdata->nBytesInM != 0)
rtw_secmicappendbyte(pmicdata, 0);
/* The appendByte function has already computed the result. */
secmicputuint32(dst, pmicdata->L);
secmicputuint32(dst + 4, pmicdata->R);
/* Reset to the empty message. */
secmicclear(pmicdata);
}
void rtw_seccalctkipmic(u8 *key, u8 *header, u8 *data, u32 data_len, u8 *mic_code, u8 pri)
{
struct mic_data micdata;
u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
rtw_secmicsetkey(&micdata, key);
priority[0] = pri;
/* Michael MIC pseudo header: DA, SA, 3 x 0, Priority */
if (header[1] & 1) { /* ToDS==1 */
rtw_secmicappend(&micdata, &header[16], 6); /* DA */
if (header[1] & 2) /* From Ds==1 */
rtw_secmicappend(&micdata, &header[24], 6);
else
rtw_secmicappend(&micdata, &header[10], 6);
} else { /* ToDS==0 */
rtw_secmicappend(&micdata, &header[4], 6); /* DA */
if (header[1] & 2) /* From Ds==1 */
rtw_secmicappend(&micdata, &header[16], 6);
else
rtw_secmicappend(&micdata, &header[10], 6);
}
rtw_secmicappend(&micdata, &priority[0], 4);
rtw_secmicappend(&micdata, data, data_len);
rtw_secgetmic(&micdata, mic_code);
}
/* macros for extraction/creation of unsigned char/unsigned short values */
#define RotR1(v16) ((((v16) >> 1) & 0x7FFF) ^ (((v16) & 1) << 15))
#define Lo8(v16) ((u8)((v16) & 0x00FF))
#define Hi8(v16) ((u8)(((v16) >> 8) & 0x00FF))
#define Lo16(v32) ((u16)((v32) & 0xFFFF))
#define Hi16(v32) ((u16)(((v32) >> 16) & 0xFFFF))
#define Mk16(hi, lo) ((lo) ^ (((u16)(hi)) << 8))
/* select the Nth 16-bit word of the temporal key unsigned char array TK[] */
#define TK16(N) Mk16(tk[2*(N)+1], tk[2*(N)])
/* S-box lookup: 16 bits --> 16 bits */
#define _S_(v16) (Sbox1[0][Lo8(v16)] ^ Sbox1[1][Hi8(v16)])
/* fixed algorithm "parameters" */
#define PHASE1_LOOP_CNT 8 /* this needs to be "big enough" */
#define TA_SIZE 6 /* 48-bit transmitter address */
#define TK_SIZE 16 /* 128-bit temporal key */
#define P1K_SIZE 10 /* 80-bit Phase1 key */
#define RC4_KEY_SIZE 16 /* 128-bit RC4KEY (104 bits unknown) */
/* 2-unsigned char by 2-unsigned char subset of the full AES S-box table */
static const unsigned short Sbox1[2][256] = /* Sbox for hash (can be in ROM) */
{ {
0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
},
{ /* second half of table is unsigned char-reversed version of first! */
0xA5C6, 0x84F8, 0x99EE, 0x8DF6, 0x0DFF, 0xBDD6, 0xB1DE, 0x5491,
0x5060, 0x0302, 0xA9CE, 0x7D56, 0x19E7, 0x62B5, 0xE64D, 0x9AEC,
0x458F, 0x9D1F, 0x4089, 0x87FA, 0x15EF, 0xEBB2, 0xC98E, 0x0BFB,
0xEC41, 0x67B3, 0xFD5F, 0xEA45, 0xBF23, 0xF753, 0x96E4, 0x5B9B,
0xC275, 0x1CE1, 0xAE3D, 0x6A4C, 0x5A6C, 0x417E, 0x02F5, 0x4F83,
0x5C68, 0xF451, 0x34D1, 0x08F9, 0x93E2, 0x73AB, 0x5362, 0x3F2A,
0x0C08, 0x5295, 0x6546, 0x5E9D, 0x2830, 0xA137, 0x0F0A, 0xB52F,
0x090E, 0x3624, 0x9B1B, 0x3DDF, 0x26CD, 0x694E, 0xCD7F, 0x9FEA,
0x1B12, 0x9E1D, 0x7458, 0x2E34, 0x2D36, 0xB2DC, 0xEEB4, 0xFB5B,
0xF6A4, 0x4D76, 0x61B7, 0xCE7D, 0x7B52, 0x3EDD, 0x715E, 0x9713,
0xF5A6, 0x68B9, 0x0000, 0x2CC1, 0x6040, 0x1FE3, 0xC879, 0xEDB6,
0xBED4, 0x468D, 0xD967, 0x4B72, 0xDE94, 0xD498, 0xE8B0, 0x4A85,
0x6BBB, 0x2AC5, 0xE54F, 0x16ED, 0xC586, 0xD79A, 0x5566, 0x9411,
0xCF8A, 0x10E9, 0x0604, 0x81FE, 0xF0A0, 0x4478, 0xBA25, 0xE34B,
0xF3A2, 0xFE5D, 0xC080, 0x8A05, 0xAD3F, 0xBC21, 0x4870, 0x04F1,
0xDF63, 0xC177, 0x75AF, 0x6342, 0x3020, 0x1AE5, 0x0EFD, 0x6DBF,
0x4C81, 0x1418, 0x3526, 0x2FC3, 0xE1BE, 0xA235, 0xCC88, 0x392E,
0x5793, 0xF255, 0x82FC, 0x477A, 0xACC8, 0xE7BA, 0x2B32, 0x95E6,
0xA0C0, 0x9819, 0xD19E, 0x7FA3, 0x6644, 0x7E54, 0xAB3B, 0x830B,
0xCA8C, 0x29C7, 0xD36B, 0x3C28, 0x79A7, 0xE2BC, 0x1D16, 0x76AD,
0x3BDB, 0x5664, 0x4E74, 0x1E14, 0xDB92, 0x0A0C, 0x6C48, 0xE4B8,
0x5D9F, 0x6EBD, 0xEF43, 0xA6C4, 0xA839, 0xA431, 0x37D3, 0x8BF2,
0x32D5, 0x438B, 0x596E, 0xB7DA, 0x8C01, 0x64B1, 0xD29C, 0xE049,
0xB4D8, 0xFAAC, 0x07F3, 0x25CF, 0xAFCA, 0x8EF4, 0xE947, 0x1810,
0xD56F, 0x88F0, 0x6F4A, 0x725C, 0x2438, 0xF157, 0xC773, 0x5197,
0x23CB, 0x7CA1, 0x9CE8, 0x213E, 0xDD96, 0xDC61, 0x860D, 0x850F,
0x90E0, 0x427C, 0xC471, 0xAACC, 0xD890, 0x0506, 0x01F7, 0x121C,
0xA3C2, 0x5F6A, 0xF9AE, 0xD069, 0x9117, 0x5899, 0x273A, 0xB927,
0x38D9, 0x13EB, 0xB32B, 0x3322, 0xBBD2, 0x70A9, 0x8907, 0xA733,
0xB62D, 0x223C, 0x9215, 0x20C9, 0x4987, 0xFFAA, 0x7850, 0x7AA5,
0x8F03, 0xF859, 0x8009, 0x171A, 0xDA65, 0x31D7, 0xC684, 0xB8D0,
0xC382, 0xB029, 0x775A, 0x111E, 0xCB7B, 0xFCA8, 0xD66D, 0x3A2C,
}
};
/*
**********************************************************************
* Routine: Phase 1 -- generate P1K, given TA, TK, IV32
*
* Inputs:
* tk[] = temporal key [128 bits]
* ta[] = transmitter's MAC address [ 48 bits]
* iv32 = upper 32 bits of IV [ 32 bits]
* Output:
* p1k[] = Phase 1 key [ 80 bits]
*
* Note:
* This function only needs to be called every 2**16 packets,
* although in theory it could be called every packet.
*
**********************************************************************
*/
static void phase1(u16 *p1k, const u8 *tk, const u8 *ta, u32 iv32)
{
sint i;
/* Initialize the 80 bits of P1K[] from IV32 and TA[0..5] */
p1k[0] = Lo16(iv32);
p1k[1] = Hi16(iv32);
p1k[2] = Mk16(ta[1], ta[0]); /* use TA[] as little-endian */
p1k[3] = Mk16(ta[3], ta[2]);
p1k[4] = Mk16(ta[5], ta[4]);
/* Now compute an unbalanced Feistel cipher with 80-bit block */
/* size on the 80-bit block P1K[], using the 128-bit key TK[] */
for (i = 0; i < PHASE1_LOOP_CNT ; i++) {
/* Each add operation here is mod 2**16 */
p1k[0] += _S_(p1k[4] ^ TK16((i & 1) + 0));
p1k[1] += _S_(p1k[0] ^ TK16((i & 1) + 2));
p1k[2] += _S_(p1k[1] ^ TK16((i & 1) + 4));
p1k[3] += _S_(p1k[2] ^ TK16((i & 1) + 6));
p1k[4] += _S_(p1k[3] ^ TK16((i & 1) + 0));
p1k[4] += (unsigned short)i; /* avoid "slide attacks" */
}
}
/*
**********************************************************************
* Routine: Phase 2 -- generate RC4KEY, given TK, P1K, IV16
*
* Inputs:
* tk[] = Temporal key [128 bits]
* p1k[] = Phase 1 output key [ 80 bits]
* iv16 = low 16 bits of IV counter [ 16 bits]
* Output:
* rc4key[] = the key used to encrypt the packet [128 bits]
*
* Note:
* The value {TA,IV32,IV16} for Phase1/Phase2 must be unique
* across all packets using the same key TK value. Then, for a
* given value of TK[], this TKIP48 construction guarantees that
* the final RC4KEY value is unique across all packets.
*
* Suggested implementation optimization: if PPK[] is "overlaid"
* appropriately on RC4KEY[], there is no need for the final
* for loop below that copies the PPK[] result into RC4KEY[].
*
**********************************************************************
*/
static void phase2(u8 *rc4key, const u8 *tk, const u16 *p1k, u16 iv16)
{
sint i;
u16 PPK[6]; /* temporary key for mixing */
/* Note: all adds in the PPK[] equations below are mod 2**16 */
for (i = 0; i < 5; i++)
PPK[i] = p1k[i]; /* first, copy P1K to PPK */
PPK[5] = p1k[4] + iv16; /* next, add in IV16 */
/* Bijective non-linear mixing of the 96 bits of PPK[0..5] */
PPK[0] += _S_(PPK[5] ^ TK16(0)); /* Mix key in each "round" */
PPK[1] += _S_(PPK[0] ^ TK16(1));
PPK[2] += _S_(PPK[1] ^ TK16(2));
PPK[3] += _S_(PPK[2] ^ TK16(3));
PPK[4] += _S_(PPK[3] ^ TK16(4));
PPK[5] += _S_(PPK[4] ^ TK16(5)); /* Total # S-box lookups == 6 */
/* Final sweep: bijective, "linear". Rotates kill LSB correlations */
PPK[0] += RotR1(PPK[5] ^ TK16(6));
PPK[1] += RotR1(PPK[0] ^ TK16(7)); /* Use all of TK[] in Phase2 */
PPK[2] += RotR1(PPK[1]);
PPK[3] += RotR1(PPK[2]);
PPK[4] += RotR1(PPK[3]);
PPK[5] += RotR1(PPK[4]);
/* Note: At this point, for a given key TK[0..15], the 96-bit output */
/* value PPK[0..5] is guaranteed to be unique, as a function */
/* of the 96-bit "input" value {TA,IV32,IV16}. That is, P1K */
/* is now a keyed permutation of {TA,IV32,IV16}. */
/* Set RC4KEY[0..3], which includes "cleartext" portion of RC4 key */
rc4key[0] = Hi8(iv16); /* RC4KEY[0..2] is the WEP IV */
rc4key[1] = (Hi8(iv16) | 0x20) & 0x7F; /* Help avoid weak (FMS) keys */
rc4key[2] = Lo8(iv16);
rc4key[3] = Lo8((PPK[5] ^ TK16(0)) >> 1);
/* Copy 96 bits of PPK[0..5] to RC4KEY[4..15] (little-endian) */
for (i = 0; i < 6; i++) {
rc4key[4 + 2 * i] = Lo8(PPK[i]);
rc4key[5 + 2 * i] = Hi8(PPK[i]);
}
}
/* The hlen isn't include the IV */
u32 rtw_tkip_encrypt(_adapter *padapter, u8 *pxmitframe)
{
struct xmit_frame *xf = (struct xmit_frame *)pxmitframe;
struct pkt_attrib *pattrib = &xf->attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct rtw_xmit_req *txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
u16 pnl;
u32 pnh;
u8 rc4key[16];
u8 ttkey[16];
u8 crc[4];
struct arc4context mycontext;
sint curfragnum, length;
u32 prwskeylen;
u8 *pframe, *payload, *iv, *prwskey;
union pn48 dot11txpn;
if (pattrib->encrypt != _TKIP_)
return _SUCCESS;
/* start to encrypt each fragment */
if (IS_MCAST(pattrib->ra))
prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
else
prwskey = pattrib->dot118021x_UncstKey.skey;
prwskeylen = 16;
for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
txreq = &xf->phl_txreq[curfragnum];
rtw_warn_on(txreq->pkt_cnt != 1);
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
pframe = pkt_list->vir_addr;
length = pkt_list->length - pattrib->hdrlen
- pattrib->iv_len - pattrib->icv_len;
iv = pframe + pattrib->hdrlen;
payload = pframe + pattrib->iv_len + pattrib->hdrlen;
GET_TKIP_PN(iv, dot11txpn);
pnl = (u16)(dot11txpn.val);
pnh = (u32)(dot11txpn.val >> 16);
phase1((u16 *)&ttkey[0], prwskey, &pattrib->ta[0], pnh);
phase2(&rc4key[0], prwskey, (u16 *)&ttkey[0], pnl);
*((u32 *)crc) = cpu_to_le32(getcrc32(payload, length));
arcfour_init(&mycontext, rc4key, 16);
arcfour_encrypt(&mycontext, payload, payload, length);
arcfour_encrypt(&mycontext, payload + length, crc, 4);
}
TKIP_SW_ENC_CNT_INC(psecuritypriv, pattrib->ra);
return _SUCCESS;
}
/* The hlen isn't include the IV */
u32 rtw_tkip_decrypt(_adapter *padapter, u8 *precvframe)
{
/* exclude ICV */
u16 pnl;
u32 pnh;
u8 rc4key[16];
u8 ttkey[16];
u8 crc[4];
struct arc4context mycontext;
sint length;
u32 prwskeylen;
u8 *pframe, *payload, *iv, *prwskey;
union pn48 dot11txpn;
struct sta_info *stainfo;
struct rx_pkt_attrib *prxattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
u32 res = _SUCCESS;
pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
/* 4 start to decrypt recvframe */
if (prxattrib->encrypt == _TKIP_) {
stainfo = rtw_get_stainfo(&padapter->stapriv , &prxattrib->ta[0]);
if (stainfo != NULL) {
if (IS_MCAST(prxattrib->ra)) {
static systime start = 0;
static u32 no_gkey_bc_cnt = 0;
static u32 no_gkey_mc_cnt = 0;
if (psecuritypriv->binstallGrpkey == _FALSE) {
res = _FAIL;
if (start == 0)
start = rtw_get_current_time();
if (is_broadcast_mac_addr(prxattrib->ra))
no_gkey_bc_cnt++;
else
no_gkey_mc_cnt++;
if (rtw_get_passing_time_ms(start) > 1000) {
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = rtw_get_current_time();
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
}
goto exit;
}
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" gkey installed. no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = 0;
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
/* RTW_INFO("rx bc/mc packets, to perform sw rtw_tkip_decrypt\n"); */
/* prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey; */
prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
prwskeylen = 16;
} else {
prwskey = &stainfo->dot118021x_UncstKey.skey[0];
prwskeylen = 16;
}
iv = pframe + prxattrib->hdrlen;
payload = pframe + prxattrib->iv_len + prxattrib->hdrlen;
length = ((union recv_frame *)precvframe)->u.hdr.len - prxattrib->hdrlen - prxattrib->iv_len;
GET_TKIP_PN(iv, dot11txpn);
pnl = (u16)(dot11txpn.val);
pnh = (u32)(dot11txpn.val >> 16);
phase1((u16 *)&ttkey[0], prwskey, &prxattrib->ta[0], pnh);
phase2(&rc4key[0], prwskey, (unsigned short *)&ttkey[0], pnl);
/* 4 decrypt payload include icv */
arcfour_init(&mycontext, rc4key, 16);
arcfour_encrypt(&mycontext, payload, payload, length);
*((u32 *)crc) = le32_to_cpu(getcrc32(payload, length - 4));
if (crc[3] != payload[length - 1] || crc[2] != payload[length - 2] || crc[1] != payload[length - 3] || crc[0] != payload[length - 4]) {
res = _FAIL;
}
TKIP_SW_DEC_CNT_INC(psecuritypriv, prxattrib->ra);
} else {
res = _FAIL;
}
}
exit:
return res;
}
/* 3 =====AES related===== */
#if (NEW_CRYPTO == 0)
#define MAX_MSG_SIZE 2048
/*****************************/
/******** SBOX Table *********/
/*****************************/
static u8 sbox_table[256] = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};
/*****************************/
/**** Function Prototypes ****/
/*****************************/
static void bitwise_xor(u8 *ina, u8 *inb, u8 *out);
static void construct_mic_iv(
u8 *mic_header1,
sint qc_exists,
sint a4_exists,
u8 *mpdu,
uint payload_length,
u8 *pn_vector,
uint frtype);/* add for CONFIG_IEEE80211W, none 11w also can use */
static void construct_mic_header1(
u8 *mic_header1,
sint header_length,
u8 *mpdu,
uint frtype);/* add for CONFIG_IEEE80211W, none 11w also can use */
static void construct_mic_header2(
u8 *mic_header2,
u8 *mpdu,
sint a4_exists,
sint qc_exists);
static void construct_ctr_preload(
u8 *ctr_preload,
sint a4_exists,
sint qc_exists,
u8 *mpdu,
u8 *pn_vector,
sint c,
uint frtype);/* add for CONFIG_IEEE80211W, none 11w also can use */
static void xor_128(u8 *a, u8 *b, u8 *out);
static void xor_32(u8 *a, u8 *b, u8 *out);
static u8 sbox(u8 a);
static void next_key(u8 *key, sint round);
static void byte_sub(u8 *in, u8 *out);
static void shift_row(u8 *in, u8 *out);
static void mix_column(u8 *in, u8 *out);
static void aes128k128d(u8 *key, u8 *data, u8 *ciphertext);
/****************************************/
/* aes128k128d() */
/* Performs a 128 bit AES encrypt with */
/* 128 bit data. */
/****************************************/
static void xor_128(u8 *a, u8 *b, u8 *out)
{
sint i;
for (i = 0; i < 16; i++)
out[i] = a[i] ^ b[i];
}
static void xor_32(u8 *a, u8 *b, u8 *out)
{
sint i;
for (i = 0; i < 4; i++)
out[i] = a[i] ^ b[i];
}
static u8 sbox(u8 a)
{
return sbox_table[(sint)a];
}
static void next_key(u8 *key, sint round)
{
u8 rcon;
u8 sbox_key[4];
u8 rcon_table[12] = {
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x1b, 0x36, 0x36, 0x36
};
sbox_key[0] = sbox(key[13]);
sbox_key[1] = sbox(key[14]);
sbox_key[2] = sbox(key[15]);
sbox_key[3] = sbox(key[12]);
rcon = rcon_table[round];
xor_32(&key[0], sbox_key, &key[0]);
key[0] = key[0] ^ rcon;
xor_32(&key[4], &key[0], &key[4]);
xor_32(&key[8], &key[4], &key[8]);
xor_32(&key[12], &key[8], &key[12]);
}
static void byte_sub(u8 *in, u8 *out)
{
sint i;
for (i = 0; i < 16; i++)
out[i] = sbox(in[i]);
}
static void shift_row(u8 *in, u8 *out)
{
out[0] = in[0];
out[1] = in[5];
out[2] = in[10];
out[3] = in[15];
out[4] = in[4];
out[5] = in[9];
out[6] = in[14];
out[7] = in[3];
out[8] = in[8];
out[9] = in[13];
out[10] = in[2];
out[11] = in[7];
out[12] = in[12];
out[13] = in[1];
out[14] = in[6];
out[15] = in[11];
}
static void mix_column(u8 *in, u8 *out)
{
sint i;
u8 add1b[4];
u8 add1bf7[4];
u8 rotl[4];
u8 swap_halfs[4];
u8 andf7[4];
u8 rotr[4];
u8 temp[4];
u8 tempb[4];
for (i = 0 ; i < 4; i++) {
if ((in[i] & 0x80) == 0x80)
add1b[i] = 0x1b;
else
add1b[i] = 0x00;
}
swap_halfs[0] = in[2]; /* Swap halfs */
swap_halfs[1] = in[3];
swap_halfs[2] = in[0];
swap_halfs[3] = in[1];
rotl[0] = in[3]; /* Rotate left 8 bits */
rotl[1] = in[0];
rotl[2] = in[1];
rotl[3] = in[2];
andf7[0] = in[0] & 0x7f;
andf7[1] = in[1] & 0x7f;
andf7[2] = in[2] & 0x7f;
andf7[3] = in[3] & 0x7f;
for (i = 3; i > 0; i--) { /* logical shift left 1 bit */
andf7[i] = andf7[i] << 1;
if ((andf7[i - 1] & 0x80) == 0x80)
andf7[i] = (andf7[i] | 0x01);
}
andf7[0] = andf7[0] << 1;
andf7[0] = andf7[0] & 0xfe;
xor_32(add1b, andf7, add1bf7);
xor_32(in, add1bf7, rotr);
temp[0] = rotr[0]; /* Rotate right 8 bits */
rotr[0] = rotr[1];
rotr[1] = rotr[2];
rotr[2] = rotr[3];
rotr[3] = temp[0];
xor_32(add1bf7, rotr, temp);
xor_32(swap_halfs, rotl, tempb);
xor_32(temp, tempb, out);
}
static void aes128k128d(u8 *key, u8 *data, u8 *ciphertext)
{
sint round;
sint i;
u8 intermediatea[16];
u8 intermediateb[16];
u8 round_key[16];
for (i = 0; i < 16; i++)
round_key[i] = key[i];
for (round = 0; round < 11; round++) {
if (round == 0) {
xor_128(round_key, data, ciphertext);
next_key(round_key, round);
} else if (round == 10) {
byte_sub(ciphertext, intermediatea);
shift_row(intermediatea, intermediateb);
xor_128(intermediateb, round_key, ciphertext);
} else { /* 1 - 9 */
byte_sub(ciphertext, intermediatea);
shift_row(intermediatea, intermediateb);
mix_column(&intermediateb[0], &intermediatea[0]);
mix_column(&intermediateb[4], &intermediatea[4]);
mix_column(&intermediateb[8], &intermediatea[8]);
mix_column(&intermediateb[12], &intermediatea[12]);
xor_128(intermediatea, round_key, ciphertext);
next_key(round_key, round);
}
}
}
/************************************************/
/* construct_mic_iv() */
/* Builds the MIC IV from header fields and PN */
/* Baron think the function is construct CCM */
/* nonce */
/************************************************/
static void construct_mic_iv(
u8 *mic_iv,
sint qc_exists,
sint a4_exists,
u8 *mpdu,
uint payload_length,
u8 *pn_vector,
uint frtype/* add for CONFIG_IEEE80211W, none 11w also can use */
)
{
sint i;
mic_iv[0] = 0x59;
if (qc_exists && a4_exists)
mic_iv[1] = mpdu[30] & 0x0f; /* QoS_TC */
if (qc_exists && !a4_exists)
mic_iv[1] = mpdu[24] & 0x0f; /* mute bits 7-4 */
if (!qc_exists)
mic_iv[1] = 0x00;
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
/* 802.11w management frame should set management bit(4) */
if (frtype == WIFI_MGT_TYPE)
mic_iv[1] |= BIT(4);
#endif
for (i = 2; i < 8; i++)
mic_iv[i] = mpdu[i + 8]; /* mic_iv[2:7] = A2[0:5] = mpdu[10:15] */
#ifdef CONSISTENT_PN_ORDER
for (i = 8; i < 14; i++)
mic_iv[i] = pn_vector[i - 8]; /* mic_iv[8:13] = PN[0:5] */
#else
for (i = 8; i < 14; i++)
mic_iv[i] = pn_vector[13 - i]; /* mic_iv[8:13] = PN[5:0] */
#endif
mic_iv[14] = (unsigned char)(payload_length / 256);
mic_iv[15] = (unsigned char)(payload_length % 256);
}
/************************************************/
/* construct_mic_header1() */
/* Builds the first MIC header block from */
/* header fields. */
/* Build AAD SC,A1,A2 */
/************************************************/
static void construct_mic_header1(
u8 *mic_header1,
sint header_length,
u8 *mpdu,
uint frtype/* add for CONFIG_IEEE80211W, none 11w also can use */
)
{
mic_header1[0] = (u8)((header_length - 2) / 256);
mic_header1[1] = (u8)((header_length - 2) % 256);
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
/* 802.11w management frame don't AND subtype bits 4,5,6 of frame control field */
if (frtype == WIFI_MGT_TYPE)
mic_header1[2] = mpdu[0];
else
#endif
mic_header1[2] = mpdu[0] & 0xcf; /* Mute CF poll & CF ack bits */
mic_header1[3] = mpdu[1] & 0xc7; /* Mute retry, more data and pwr mgt bits */
mic_header1[4] = mpdu[4]; /* A1 */
mic_header1[5] = mpdu[5];
mic_header1[6] = mpdu[6];
mic_header1[7] = mpdu[7];
mic_header1[8] = mpdu[8];
mic_header1[9] = mpdu[9];
mic_header1[10] = mpdu[10]; /* A2 */
mic_header1[11] = mpdu[11];
mic_header1[12] = mpdu[12];
mic_header1[13] = mpdu[13];
mic_header1[14] = mpdu[14];
mic_header1[15] = mpdu[15];
}
/************************************************/
/* construct_mic_header2() */
/* Builds the last MIC header block from */
/* header fields. */
/************************************************/
static void construct_mic_header2(
u8 *mic_header2,
u8 *mpdu,
sint a4_exists,
sint qc_exists
)
{
sint i;
for (i = 0; i < 16; i++)
mic_header2[i] = 0x00;
mic_header2[0] = mpdu[16]; /* A3 */
mic_header2[1] = mpdu[17];
mic_header2[2] = mpdu[18];
mic_header2[3] = mpdu[19];
mic_header2[4] = mpdu[20];
mic_header2[5] = mpdu[21];
/* mic_header2[6] = mpdu[22] & 0xf0; SC */
mic_header2[6] = 0x00;
mic_header2[7] = 0x00; /* mpdu[23]; */
if (!qc_exists && a4_exists) {
for (i = 0; i < 6; i++)
mic_header2[8 + i] = mpdu[24 + i]; /* A4 */
}
if (qc_exists && !a4_exists) {
mic_header2[8] = mpdu[24] & 0x0f; /* mute bits 15 - 4 */
mic_header2[9] = mpdu[25] & 0x00;
}
if (qc_exists && a4_exists) {
for (i = 0; i < 6; i++)
mic_header2[8 + i] = mpdu[24 + i]; /* A4 */
mic_header2[14] = mpdu[30] & 0x0f;
mic_header2[15] = mpdu[31] & 0x00;
}
}
/************************************************/
/* construct_mic_header2() */
/* Builds the last MIC header block from */
/* header fields. */
/* Baron think the function is construct CCM */
/* nonce */
/************************************************/
static void construct_ctr_preload(
u8 *ctr_preload,
sint a4_exists,
sint qc_exists,
u8 *mpdu,
u8 *pn_vector,
sint c,
uint frtype /* add for CONFIG_IEEE80211W, none 11w also can use */
)
{
sint i = 0;
for (i = 0; i < 16; i++)
ctr_preload[i] = 0x00;
i = 0;
ctr_preload[0] = 0x01; /* flag */
if (qc_exists && a4_exists)
ctr_preload[1] = mpdu[30] & 0x0f; /* QoC_Control */
if (qc_exists && !a4_exists)
ctr_preload[1] = mpdu[24] & 0x0f;
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
/* 802.11w management frame should set management bit(4) */
if (frtype == WIFI_MGT_TYPE)
ctr_preload[1] |= BIT(4);
#endif
for (i = 2; i < 8; i++)
ctr_preload[i] = mpdu[i + 8]; /* ctr_preload[2:7] = A2[0:5] = mpdu[10:15] */
#ifdef CONSISTENT_PN_ORDER
for (i = 8; i < 14; i++)
ctr_preload[i] = pn_vector[i - 8]; /* ctr_preload[8:13] = PN[0:5] */
#else
for (i = 8; i < 14; i++)
ctr_preload[i] = pn_vector[13 - i]; /* ctr_preload[8:13] = PN[5:0] */
#endif
ctr_preload[14] = (unsigned char)(c / 256); /* Ctr */
ctr_preload[15] = (unsigned char)(c % 256);
}
/************************************/
/* bitwise_xor() */
/* A 128 bit, bitwise exclusive or */
/************************************/
static void bitwise_xor(u8 *ina, u8 *inb, u8 *out)
{
sint i;
for (i = 0; i < 16; i++)
out[i] = ina[i] ^ inb[i];
}
static sint aes_cipher(u8 *key, uint hdrlen,
u8 *pframe, uint plen)
{
/* static unsigned char message[MAX_MSG_SIZE]; */
uint qc_exists, a4_exists, i, j, payload_remainder,
num_blocks, payload_index;
u8 pn_vector[6];
u8 mic_iv[16];
u8 mic_header1[16];
u8 mic_header2[16];
u8 ctr_preload[16];
/* Intermediate Buffers */
u8 chain_buffer[16];
u8 aes_out[16];
u8 padded_buffer[16];
u8 mic[8];
/* uint offset = 0; */
uint frtype = GetFrameType(pframe);
uint frsubtype = get_frame_sub_type(pframe);
frsubtype = frsubtype >> 4;
_rtw_memset((void *)mic_iv, 0, 16);
_rtw_memset((void *)mic_header1, 0, 16);
_rtw_memset((void *)mic_header2, 0, 16);
_rtw_memset((void *)ctr_preload, 0, 16);
_rtw_memset((void *)chain_buffer, 0, 16);
_rtw_memset((void *)aes_out, 0, 16);
_rtw_memset((void *)padded_buffer, 0, 16);
if ((hdrlen == WLAN_HDR_A3_LEN) || (hdrlen == WLAN_HDR_A3_QOS_LEN))
a4_exists = 0;
else
a4_exists = 1;
if (
((frtype | frsubtype) == WIFI_DATA_CFACK) ||
((frtype | frsubtype) == WIFI_DATA_CFPOLL) ||
((frtype | frsubtype) == WIFI_DATA_CFACKPOLL)) {
qc_exists = 1;
if (hdrlen != WLAN_HDR_A3_QOS_LEN && hdrlen != WLAN_HDR_A4_QOS_LEN)
hdrlen += 2;
}
/* add for CONFIG_IEEE80211W, none 11w also can use */
else if ((frtype == WIFI_DATA) &&
((frsubtype == 0x08) ||
(frsubtype == 0x09) ||
(frsubtype == 0x0a) ||
(frsubtype == 0x0b))) {
if (hdrlen != WLAN_HDR_A3_QOS_LEN && hdrlen != WLAN_HDR_A4_QOS_LEN)
hdrlen += 2;
qc_exists = 1;
} else
qc_exists = 0;
pn_vector[0] = pframe[hdrlen];
pn_vector[1] = pframe[hdrlen + 1];
pn_vector[2] = pframe[hdrlen + 4];
pn_vector[3] = pframe[hdrlen + 5];
pn_vector[4] = pframe[hdrlen + 6];
pn_vector[5] = pframe[hdrlen + 7];
construct_mic_iv(
mic_iv,
qc_exists,
a4_exists,
pframe, /* message, */
plen,
pn_vector,
frtype /* add for CONFIG_IEEE80211W, none 11w also can use */
);
construct_mic_header1(
mic_header1,
hdrlen,
pframe, /* message */
frtype /* add for CONFIG_IEEE80211W, none 11w also can use */
);
construct_mic_header2(
mic_header2,
pframe, /* message, */
a4_exists,
qc_exists
);
payload_remainder = plen % 16;
num_blocks = plen / 16;
/* Find start of payload */
payload_index = (hdrlen + 8);
/* Calculate MIC */
aes128k128d(key, mic_iv, aes_out);
bitwise_xor(aes_out, mic_header1, chain_buffer);
aes128k128d(key, chain_buffer, aes_out);
bitwise_xor(aes_out, mic_header2, chain_buffer);
aes128k128d(key, chain_buffer, aes_out);
for (i = 0; i < num_blocks; i++) {
bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);/* bitwise_xor(aes_out, &message[payload_index], chain_buffer); */
payload_index += 16;
aes128k128d(key, chain_buffer, aes_out);
}
/* Add on the final payload block if it needs padding */
if (payload_remainder > 0) {
for (j = 0; j < 16; j++)
padded_buffer[j] = 0x00;
for (j = 0; j < payload_remainder; j++) {
padded_buffer[j] = pframe[payload_index++];/* padded_buffer[j] = message[payload_index++]; */
}
bitwise_xor(aes_out, padded_buffer, chain_buffer);
aes128k128d(key, chain_buffer, aes_out);
}
for (j = 0 ; j < 8; j++)
mic[j] = aes_out[j];
/* Insert MIC into payload */
for (j = 0; j < 8; j++)
pframe[payload_index + j] = mic[j]; /* message[payload_index+j] = mic[j]; */
payload_index = hdrlen + 8;
for (i = 0; i < num_blocks; i++) {
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
pframe, /* message, */
pn_vector,
i + 1,
frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);/* bitwise_xor(aes_out, &message[payload_index], chain_buffer); */
for (j = 0; j < 16; j++)
pframe[payload_index++] = chain_buffer[j];/* for (j=0; j<16;j++) message[payload_index++] = chain_buffer[j]; */
}
if (payload_remainder > 0) { /* If there is a short final block, then pad it,*/
/* encrypt it and copy the unpadded part back */
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
pframe, /* message, */
pn_vector,
num_blocks + 1,
frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
for (j = 0; j < 16; j++)
padded_buffer[j] = 0x00;
for (j = 0; j < payload_remainder; j++) {
padded_buffer[j] = pframe[payload_index + j]; /* padded_buffer[j] = message[payload_index+j]; */
}
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, padded_buffer, chain_buffer);
for (j = 0; j < payload_remainder; j++)
pframe[payload_index++] = chain_buffer[j];/* for (j=0; j<payload_remainder;j++) message[payload_index++] = chain_buffer[j]; */
}
/* Encrypt the MIC */
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
pframe, /* message, */
pn_vector,
0,
frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
for (j = 0; j < 16; j++)
padded_buffer[j] = 0x00;
for (j = 0; j < 8; j++) {
padded_buffer[j] = pframe[j + hdrlen + 8 + plen]; /* padded_buffer[j] = message[j+hdrlen+8+plen]; */
}
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, padded_buffer, chain_buffer);
for (j = 0; j < 8; j++)
pframe[payload_index++] = chain_buffer[j];/* for (j=0; j<8;j++) message[payload_index++] = chain_buffer[j]; */
return _SUCCESS;
}
#endif /* (NEW_CRYPTO == 0) */
#if 0 //RTW_PHL_TX: mark un-finished codes for reading
u32 rtw_core_aes_encrypt(_adapter *padapter, u8 *pxmitframe)
{
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pxframe = (struct xmit_frame *)pxmitframe;
sint curfragnum;
u32 prwskeylen;
u8 *pwlanhdr, *payload;
u8 *prwskey;
u8 hw_hdr_offset = 0;
u32 res = _SUCCESS;
if (((struct xmit_frame *)pxmitframe)->buf_addr == NULL)
return _FAIL;
pwlanhdr = pxframe->wlhdr[0];
payload = pxframe->pkt->data + pxframe->attrib.pkt_hdrlen - RTW_SZ_LLC;
/* start to encrypt each fragment */
if ((pxframe->attrib.encrypt == _AES_) ||
(pxframe->attrib.encrypt == _CCMP_256_)) {
if (IS_MCAST(pxframe->attrib.ra))
prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
else {
prwskey = pxframe->attrib.psta->dot118021x_UncstKey.skey;
}
#ifdef CONFIG_TDLS
{
/* Swencryption */
struct sta_info *ptdls_sta;
ptdls_sta = rtw_get_stainfo(&padapter->stapriv, pxframe->attrib.dst);
if ((ptdls_sta != NULL) && (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)) {
RTW_INFO("[%s] for tdls link\n", __FUNCTION__);
prwskey = &ptdls_sta->tpk.tk[0];
}
}
#endif /* CONFIG_TDLS */
prwskeylen = (pxframe->attrib.encrypt == _CCMP_256_) ? 32 : 16;
for (curfragnum = 0; curfragnum < pxframe->attrib.nr_frags; curfragnum++) {
u8 *pdata = pxframe->pkt->data + pxframe->attrib.pkt_hdrlen - RTW_SZ_LLC + curfragnum*pxframe->attrib.frag_datalen;
if ((curfragnum + 1) == pxframe->attrib.nr_frags) { /* the last fragment */
u32 ls_datelen = pxframe->pkt->len - curfragnum*pxframe->attrib.frag_datalen;
_rtw_core_ccmp_encrypt(prwskey, prwskeylen,
pxframe->attrib.hdrlen, pxframe->wlhdr[curfragnum], ls_datelen, pdata);
} else {
_rtw_core_ccmp_encrypt(prwskey, prwskeylen,
pxframe->attrib.hdrlen, pxframe->wlhdr[curfragnum], pxframe->attrib.frag_datalen, pdata);
}
}
AES_SW_ENC_CNT_INC(psecuritypriv, pxframe->attrib.ra);
}
return res;
}
#endif
u32 rtw_aes_encrypt(_adapter *padapter, u8 *pxmitframe)
{
struct xmit_frame *xf = (struct xmit_frame *)pxmitframe;
struct pkt_attrib *pattrib = &xf->attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct rtw_xmit_req *txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
sint curfragnum, plen;
u32 prwskeylen;
u8 *pframe;
u8 *prwskey;
if ((pattrib->encrypt != _AES_) && (pattrib->encrypt != _CCMP_256_))
return _SUCCESS;
/* start to encrypt each fragment */
if (IS_MCAST(pattrib->ra))
prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
else
prwskey = pattrib->dot118021x_UncstKey.skey;
#ifdef CONFIG_TDLS
{
/* Swencryption */
struct sta_info *ptdls_sta;
ptdls_sta = rtw_get_stainfo(&padapter->stapriv, &pattrib->dst[0]);
if ((ptdls_sta != NULL) && (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)) {
RTW_INFO("[%s] for tdls link\n", __FUNCTION__);
prwskey = &ptdls_sta->tpk.tk[0];
}
}
#endif /* CONFIG_TDLS */
prwskeylen = (pattrib->encrypt == _CCMP_256_) ? 32 : 16;
for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
txreq = &xf->phl_txreq[curfragnum];
rtw_warn_on(txreq->pkt_cnt != 1);
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
pframe = pkt_list->vir_addr;
plen = pkt_list->length - pattrib->hdrlen
- pattrib->iv_len - pattrib->icv_len;
_rtw_ccmp_encrypt(padapter, prwskey, prwskeylen, pattrib->hdrlen,
pframe, plen);
}
AES_SW_ENC_CNT_INC(psecuritypriv, pattrib->ra);
return _SUCCESS;
}
#if (NEW_CRYPTO == 0)
static sint aes_decipher(u8 *key, uint hdrlen,
u8 *pframe, uint plen)
{
static u8 message[MAX_MSG_SIZE];
uint qc_exists, a4_exists, i, j, payload_remainder,
num_blocks, payload_index;
sint res = _SUCCESS;
u8 pn_vector[6];
u8 mic_iv[16];
u8 mic_header1[16];
u8 mic_header2[16];
u8 ctr_preload[16];
/* Intermediate Buffers */
u8 chain_buffer[16];
u8 aes_out[16];
u8 padded_buffer[16];
u8 mic[8];
/* uint offset = 0; */
uint frtype = GetFrameType(pframe);
uint frsubtype = get_frame_sub_type(pframe);
frsubtype = frsubtype >> 4;
_rtw_memset((void *)mic_iv, 0, 16);
_rtw_memset((void *)mic_header1, 0, 16);
_rtw_memset((void *)mic_header2, 0, 16);
_rtw_memset((void *)ctr_preload, 0, 16);
_rtw_memset((void *)chain_buffer, 0, 16);
_rtw_memset((void *)aes_out, 0, 16);
_rtw_memset((void *)padded_buffer, 0, 16);
/* start to decrypt the payload */
num_blocks = (plen - 8) / 16; /* (plen including LLC, payload_length and mic ) */
payload_remainder = (plen - 8) % 16;
pn_vector[0] = pframe[hdrlen];
pn_vector[1] = pframe[hdrlen + 1];
pn_vector[2] = pframe[hdrlen + 4];
pn_vector[3] = pframe[hdrlen + 5];
pn_vector[4] = pframe[hdrlen + 6];
pn_vector[5] = pframe[hdrlen + 7];
if ((hdrlen == WLAN_HDR_A3_LEN) || (hdrlen == WLAN_HDR_A3_QOS_LEN))
a4_exists = 0;
else
a4_exists = 1;
if (
((frtype | frsubtype) == WIFI_DATA_CFACK) ||
((frtype | frsubtype) == WIFI_DATA_CFPOLL) ||
((frtype | frsubtype) == WIFI_DATA_CFACKPOLL)) {
qc_exists = 1;
if (hdrlen != WLAN_HDR_A3_QOS_LEN && hdrlen != WLAN_HDR_A4_QOS_LEN)
hdrlen += 2;
} /* only for data packet . add for CONFIG_IEEE80211W, none 11w also can use */
else if ((frtype == WIFI_DATA) &&
((frsubtype == 0x08) ||
(frsubtype == 0x09) ||
(frsubtype == 0x0a) ||
(frsubtype == 0x0b))) {
if (hdrlen != WLAN_HDR_A3_QOS_LEN && hdrlen != WLAN_HDR_A4_QOS_LEN)
hdrlen += 2;
qc_exists = 1;
} else
qc_exists = 0;
/* now, decrypt pframe with hdrlen offset and plen long */
payload_index = hdrlen + 8; /* 8 is for extiv */
for (i = 0; i < num_blocks; i++) {
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
pframe,
pn_vector,
i + 1,
frtype /* add for CONFIG_IEEE80211W, none 11w also can use */
);
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);
for (j = 0; j < 16; j++)
pframe[payload_index++] = chain_buffer[j];
}
if (payload_remainder > 0) { /* If there is a short final block, then pad it,*/
/* encrypt it and copy the unpadded part back */
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
pframe,
pn_vector,
num_blocks + 1,
frtype /* add for CONFIG_IEEE80211W, none 11w also can use */
);
for (j = 0; j < 16; j++)
padded_buffer[j] = 0x00;
for (j = 0; j < payload_remainder; j++)
padded_buffer[j] = pframe[payload_index + j];
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, padded_buffer, chain_buffer);
for (j = 0; j < payload_remainder; j++)
pframe[payload_index++] = chain_buffer[j];
}
/* start to calculate the mic */
if ((hdrlen + plen + 8) <= MAX_MSG_SIZE)
_rtw_memcpy((void *)message, pframe, (hdrlen + plen + 8)); /* 8 is for ext iv len */
pn_vector[0] = pframe[hdrlen];
pn_vector[1] = pframe[hdrlen + 1];
pn_vector[2] = pframe[hdrlen + 4];
pn_vector[3] = pframe[hdrlen + 5];
pn_vector[4] = pframe[hdrlen + 6];
pn_vector[5] = pframe[hdrlen + 7];
construct_mic_iv(
mic_iv,
qc_exists,
a4_exists,
message,
plen - 8,
pn_vector,
frtype /* add for CONFIG_IEEE80211W, none 11w also can use */
);
construct_mic_header1(
mic_header1,
hdrlen,
message,
frtype /* add for CONFIG_IEEE80211W, none 11w also can use */
);
construct_mic_header2(
mic_header2,
message,
a4_exists,
qc_exists
);
payload_remainder = (plen - 8) % 16;
num_blocks = (plen - 8) / 16;
/* Find start of payload */
payload_index = (hdrlen + 8);
/* Calculate MIC */
aes128k128d(key, mic_iv, aes_out);
bitwise_xor(aes_out, mic_header1, chain_buffer);
aes128k128d(key, chain_buffer, aes_out);
bitwise_xor(aes_out, mic_header2, chain_buffer);
aes128k128d(key, chain_buffer, aes_out);
for (i = 0; i < num_blocks; i++) {
bitwise_xor(aes_out, &message[payload_index], chain_buffer);
payload_index += 16;
aes128k128d(key, chain_buffer, aes_out);
}
/* Add on the final payload block if it needs padding */
if (payload_remainder > 0) {
for (j = 0; j < 16; j++)
padded_buffer[j] = 0x00;
for (j = 0; j < payload_remainder; j++)
padded_buffer[j] = message[payload_index++];
bitwise_xor(aes_out, padded_buffer, chain_buffer);
aes128k128d(key, chain_buffer, aes_out);
}
for (j = 0 ; j < 8; j++)
mic[j] = aes_out[j];
/* Insert MIC into payload */
for (j = 0; j < 8; j++)
message[payload_index + j] = mic[j];
payload_index = hdrlen + 8;
for (i = 0; i < num_blocks; i++) {
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
message,
pn_vector,
i + 1,
frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, &message[payload_index], chain_buffer);
for (j = 0; j < 16; j++)
message[payload_index++] = chain_buffer[j];
}
if (payload_remainder > 0) { /* If there is a short final block, then pad it,*/
/* encrypt it and copy the unpadded part back */
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
message,
pn_vector,
num_blocks + 1,
frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
for (j = 0; j < 16; j++)
padded_buffer[j] = 0x00;
for (j = 0; j < payload_remainder; j++)
padded_buffer[j] = message[payload_index + j];
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, padded_buffer, chain_buffer);
for (j = 0; j < payload_remainder; j++)
message[payload_index++] = chain_buffer[j];
}
/* Encrypt the MIC */
construct_ctr_preload(
ctr_preload,
a4_exists,
qc_exists,
message,
pn_vector,
0,
frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
for (j = 0; j < 16; j++)
padded_buffer[j] = 0x00;
for (j = 0; j < 8; j++)
padded_buffer[j] = message[j + hdrlen + 8 + plen - 8];
aes128k128d(key, ctr_preload, aes_out);
bitwise_xor(aes_out, padded_buffer, chain_buffer);
for (j = 0; j < 8; j++)
message[payload_index++] = chain_buffer[j];
/* compare the mic */
for (i = 0; i < 8; i++) {
if (pframe[hdrlen + 8 + plen - 8 + i] != message[hdrlen + 8 + plen - 8 + i]) {
RTW_INFO("aes_decipher:mic check error mic[%d]: pframe(%x) != message(%x)\n",
i, pframe[hdrlen + 8 + plen - 8 + i], message[hdrlen + 8 + plen - 8 + i]);
res = _FAIL;
}
}
return res;
}
#endif /* (NEW_CRYPTO == 0) */
#if NEW_CRYPTO
u32 rtw_aes_decrypt(_adapter *padapter, u8 *precvframe)
{
struct sta_info *stainfo;
struct rx_pkt_attrib *prxattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
u8 *pframe;
u8 *prwskey;
u32 res = _SUCCESS;
pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
/* start to encrypt each fragment */
if ((prxattrib->encrypt == _AES_) ||
(prxattrib->encrypt == _CCMP_256_)) {
stainfo = rtw_get_stainfo(&padapter->stapriv, &prxattrib->ta[0]);
if (stainfo != NULL) {
if (IS_MCAST(prxattrib->ra)) {
static systime start = 0;
static u32 no_gkey_bc_cnt = 0;
static u32 no_gkey_mc_cnt = 0;
if ((!MLME_IS_MESH(padapter) && psecuritypriv->binstallGrpkey == _FALSE)
#ifdef CONFIG_RTW_MESH
|| !(stainfo->gtk_bmp | BIT(prxattrib->key_index))
#endif
) {
res = _FAIL;
if (start == 0)
start = rtw_get_current_time();
if (is_broadcast_mac_addr(prxattrib->ra))
no_gkey_bc_cnt++;
else
no_gkey_mc_cnt++;
if (rtw_get_passing_time_ms(start) > 1000) {
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = rtw_get_current_time();
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
}
goto exit;
}
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" gkey installed. no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = 0;
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
/* TODO: multiple GK? */
prwskey = &stainfo->gtk.skey[0];
} else
#endif
{
prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
if (psecuritypriv->dot118021XGrpKeyid != prxattrib->key_index) {
RTW_DBG("not match packet_index=%d, install_index=%d\n"
, prxattrib->key_index, psecuritypriv->dot118021XGrpKeyid);
res = _FAIL;
goto exit;
}
}
} else
prwskey = &stainfo->dot118021x_UncstKey.skey[0];
res = _rtw_ccmp_decrypt(padapter, prwskey,
prxattrib->encrypt == _CCMP_256_ ? 32 : 16,
prxattrib->hdrlen, pframe,
((union recv_frame *)precvframe)->u.hdr.len);
AES_SW_DEC_CNT_INC(psecuritypriv, prxattrib->ra);
} else {
res = _FAIL;
}
}
exit:
return res;
}
#else
u32 rtw_aes_decrypt(_adapter *padapter, u8 *precvframe)
{
/* exclude ICV */
/*static*/
/* unsigned char message[MAX_MSG_SIZE]; */
/* Intermediate Buffers */
sint length;
u8 *pframe, *prwskey; /* , *payload,*iv */
struct sta_info *stainfo;
struct rx_pkt_attrib *prxattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
u32 res = _SUCCESS;
pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
/* 4 start to encrypt each fragment */
if ((prxattrib->encrypt == _AES_)) {
stainfo = rtw_get_stainfo(&padapter->stapriv , &prxattrib->ta[0]);
if (stainfo != NULL) {
if (IS_MCAST(prxattrib->ra)) {
static systime start = 0;
static u32 no_gkey_bc_cnt = 0;
static u32 no_gkey_mc_cnt = 0;
/* RTW_INFO("rx bc/mc packets, to perform sw rtw_aes_decrypt\n"); */
/* prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey; */
if ((!MLME_IS_MESH(padapter) && psecuritypriv->binstallGrpkey == _FALSE)
#ifdef CONFIG_RTW_MESH
|| !(stainfo->gtk_bmp | BIT(prxattrib->key_index))
#endif
) {
res = _FAIL;
if (start == 0)
start = rtw_get_current_time();
if (is_broadcast_mac_addr(prxattrib->ra))
no_gkey_bc_cnt++;
else
no_gkey_mc_cnt++;
if (rtw_get_passing_time_ms(start) > 1000) {
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = rtw_get_current_time();
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
}
goto exit;
}
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" gkey installed. no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = 0;
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
/* TODO: multiple GK? */
prwskey = &stainfo->gtk.skey[0];
} else
#endif
{
prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
if (psecuritypriv->dot118021XGrpKeyid != prxattrib->key_index) {
RTW_DBG("not match packet_index=%d, install_index=%d\n"
, prxattrib->key_index, psecuritypriv->dot118021XGrpKeyid);
res = _FAIL;
goto exit;
}
}
} else
prwskey = &stainfo->dot118021x_UncstKey.skey[0];
length = ((union recv_frame *)precvframe)->u.hdr.len - prxattrib->hdrlen - prxattrib->iv_len;
#if 0
/* add for CONFIG_IEEE80211W, debug */
if (0)
printk("@@@@@@@@@@@@@@@@@@ length=%d, prxattrib->hdrlen=%d, prxattrib->pkt_len=%d\n"
, length, prxattrib->hdrlen, prxattrib->pkt_len);
if (0) {
int no;
/* test print PSK */
printk("PSK key below:\n");
for (no = 0; no < 16; no++)
printk(" %02x ", prwskey[no]);
printk("\n");
}
if (0) {
int no;
/* test print PSK */
printk("frame:\n");
for (no = 0; no < prxattrib->pkt_len; no++)
printk(" %02x ", pframe[no]);
printk("\n");
}
#endif
res = aes_decipher(prwskey, prxattrib->hdrlen, pframe, length);
AES_SW_DEC_CNT_INC(psecuritypriv, prxattrib->ra);
} else {
res = _FAIL;
}
}
exit:
return res;
}
#endif
#ifdef CONFIG_RTW_MESH_AEK
/* for AES-SIV, wrapper to ase_siv_encrypt and aes_siv_decrypt */
int rtw_aes_siv_encrypt(const u8 *key, size_t key_len, const u8 *pw,
size_t pwlen, size_t num_elem,
const u8 *addr[], const size_t *len, u8 *out)
{
return _aes_siv_encrypt(key, key_len, pw, pwlen,
num_elem, addr, len, out);
}
int rtw_aes_siv_decrypt(const u8 *key, size_t key_len, const u8 *iv_crypt, size_t iv_c_len,
size_t num_elem, const u8 *addr[], const size_t *len, u8 *out)
{
return _aes_siv_decrypt(key, key_len, iv_crypt,
iv_c_len, num_elem, addr, len, out);
}
#endif /* CONFIG_RTW_MESH_AEK */
#ifdef CONFIG_TDLS
void wpa_tdls_generate_tpk(_adapter *padapter, void *sta)
{
struct sta_info *psta = (struct sta_info *)sta;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
_tdls_generate_tpk(psta, adapter_mac_addr(padapter), get_bssid(pmlmepriv));
}
/**
* wpa_tdls_ftie_mic - Calculate TDLS FTIE MIC
* @kck: TPK-KCK
* @lnkid: Pointer to the beginning of Link Identifier IE
* @rsnie: Pointer to the beginning of RSN IE used for handshake
* @timeoutie: Pointer to the beginning of Timeout IE used for handshake
* @ftie: Pointer to the beginning of FT IE
* @mic: Pointer for writing MIC
*
* Calculate MIC for TDLS frame.
*/
int wpa_tdls_ftie_mic(u8 *kck, u8 trans_seq,
u8 *lnkid, u8 *rsnie, u8 *timeoutie, u8 *ftie,
u8 *mic)
{
u8 *buf, *pos;
struct wpa_tdls_ftie *_ftie;
struct wpa_tdls_lnkid *_lnkid;
int ret;
int len = 2 * ETH_ALEN + 1 + 2 + lnkid[1] + 2 + rsnie[1] +
2 + timeoutie[1] + 2 + ftie[1];
buf = rtw_zmalloc(len);
if (!buf) {
RTW_INFO("TDLS: No memory for MIC calculation\n");
return -1;
}
pos = buf;
_lnkid = (struct wpa_tdls_lnkid *) lnkid;
/* 1) TDLS initiator STA MAC address */
_rtw_memcpy(pos, _lnkid->init_sta, ETH_ALEN);
pos += ETH_ALEN;
/* 2) TDLS responder STA MAC address */
_rtw_memcpy(pos, _lnkid->resp_sta, ETH_ALEN);
pos += ETH_ALEN;
/* 3) Transaction Sequence number */
*pos++ = trans_seq;
/* 4) Link Identifier IE */
_rtw_memcpy(pos, lnkid, 2 + lnkid[1]);
pos += 2 + lnkid[1];
/* 5) RSN IE */
_rtw_memcpy(pos, rsnie, 2 + rsnie[1]);
pos += 2 + rsnie[1];
/* 6) Timeout Interval IE */
_rtw_memcpy(pos, timeoutie, 2 + timeoutie[1]);
pos += 2 + timeoutie[1];
/* 7) FTIE, with the MIC field of the FTIE set to 0 */
_rtw_memcpy(pos, ftie, 2 + ftie[1]);
_ftie = (struct wpa_tdls_ftie *) pos;
_rtw_memset(_ftie->mic, 0, TDLS_MIC_LEN);
pos += 2 + ftie[1];
/* ret = omac1_aes_128(kck, buf, pos - buf, mic); */
ret = _bip_ccmp_protect(kck, 16, buf, pos - buf, mic);
rtw_mfree(buf, len);
return ret;
}
/**
* wpa_tdls_teardown_ftie_mic - Calculate TDLS TEARDOWN FTIE MIC
* @kck: TPK-KCK
* @lnkid: Pointer to the beginning of Link Identifier IE
* @reason: Reason code of TDLS Teardown
* @dialog_token: Dialog token that was used in the MIC calculation for TPK Handshake Message 3
* @trans_seq: Transaction Sequence number (1 octet) which shall be set to the value 4
* @ftie: Pointer to the beginning of FT IE
* @mic: Pointer for writing MIC
*
* Calculate MIC for TDLS TEARDOWN frame according to Section 10.22.5 in IEEE 802.11 - 2012.
*/
int wpa_tdls_teardown_ftie_mic(u8 *kck, u8 *lnkid, u16 reason,
u8 dialog_token, u8 trans_seq, u8 *ftie, u8 *mic)
{
u8 *buf, *pos;
struct wpa_tdls_ftie *_ftie;
int ret;
int len = 2 + lnkid[1] + 2 + 1 + 1 + 2 + ftie[1];
buf = rtw_zmalloc(len);
if (!buf) {
RTW_INFO("TDLS: No memory for MIC calculation\n");
return -1;
}
pos = buf;
/* 1) Link Identifier IE */
_rtw_memcpy(pos, lnkid, 2 + lnkid[1]);
pos += 2 + lnkid[1];
/* 2) Reason Code */
_rtw_memcpy(pos, (u8 *)&reason, 2);
pos += 2;
/* 3) Dialog Token */
*pos++ = dialog_token;
/* 4) Transaction Sequence number */
*pos++ = trans_seq;
/* 5) FTIE, with the MIC field of the FTIE set to 0 */
_rtw_memcpy(pos, ftie, 2 + ftie[1]);
_ftie = (struct wpa_tdls_ftie *) pos;
_rtw_memset(_ftie->mic, 0, TDLS_MIC_LEN);
pos += 2 + ftie[1];
/* ret = omac1_aes_128(kck, buf, pos - buf, mic); */
ret = _bip_ccmp_protect(kck, 16, buf, pos - buf, mic);
rtw_mfree(buf, len);
return ret;
}
int tdls_verify_mic(u8 *kck, u8 trans_seq,
u8 *lnkid, u8 *rsnie, u8 *timeoutie, u8 *ftie)
{
u8 *buf, *pos;
int len;
u8 mic[16];
int ret;
u8 *rx_ftie, *tmp_ftie;
if (lnkid == NULL || rsnie == NULL ||
timeoutie == NULL || ftie == NULL)
return _FAIL;
len = 2 * ETH_ALEN + 1 + 2 + 18 + 2 + *(rsnie + 1) + 2 + *(timeoutie + 1) + 2 + *(ftie + 1);
buf = rtw_zmalloc(len);
if (buf == NULL)
return _FAIL;
pos = buf;
/* 1) TDLS initiator STA MAC address */
_rtw_memcpy(pos, lnkid + ETH_ALEN + 2, ETH_ALEN);
pos += ETH_ALEN;
/* 2) TDLS responder STA MAC address */
_rtw_memcpy(pos, lnkid + 2 * ETH_ALEN + 2, ETH_ALEN);
pos += ETH_ALEN;
/* 3) Transaction Sequence number */
*pos++ = trans_seq;
/* 4) Link Identifier IE */
_rtw_memcpy(pos, lnkid, 2 + 18);
pos += 2 + 18;
/* 5) RSN IE */
_rtw_memcpy(pos, rsnie, 2 + *(rsnie + 1));
pos += 2 + *(rsnie + 1);
/* 6) Timeout Interval IE */
_rtw_memcpy(pos, timeoutie, 2 + *(timeoutie + 1));
pos += 2 + *(timeoutie + 1);
/* 7) FTIE, with the MIC field of the FTIE set to 0 */
_rtw_memcpy(pos, ftie, 2 + *(ftie + 1));
pos += 2;
tmp_ftie = (u8 *)(pos + 2);
_rtw_memset(tmp_ftie, 0, 16);
pos += *(ftie + 1);
/* ret = omac1_aes_128(kck, buf, pos - buf, mic); */
ret = _bip_ccmp_protect(kck, 16, buf, pos - buf, mic);
rtw_mfree(buf, len);
if (ret == _FAIL)
return _FAIL;
rx_ftie = ftie + 4;
if (_rtw_memcmp2(mic, rx_ftie, 16) == 0) {
/* Valid MIC */
return _SUCCESS;
}
/* Invalid MIC */
RTW_INFO("[%s] Invalid MIC\n", __FUNCTION__);
return _FAIL;
}
#endif /* CONFIG_TDLS */
/* Restore HW wep key setting according to key_mask */
void rtw_sec_restore_wep_key(_adapter *adapter)
{
struct security_priv *securitypriv = &(adapter->securitypriv);
sint keyid;
if ((_WEP40_ == securitypriv->dot11PrivacyAlgrthm) || (_WEP104_ == securitypriv->dot11PrivacyAlgrthm)) {
for (keyid = 0; keyid < 4; keyid++) {
if (securitypriv->key_mask & BIT(keyid)) {
if (keyid == securitypriv->dot11PrivacyKeyIndex)
rtw_set_key(adapter, securitypriv, keyid, 1, _FALSE);
else
rtw_set_key(adapter, securitypriv, keyid, 0, _FALSE);
}
}
}
}
u8 rtw_handle_tkip_countermeasure(_adapter *adapter, const char *caller)
{
struct security_priv *securitypriv = &(adapter->securitypriv);
u8 status = _SUCCESS;
if (securitypriv->btkip_countermeasure == _TRUE) {
u32 passing_ms = rtw_get_passing_time_ms(securitypriv->btkip_countermeasure_time);
if (passing_ms > 60 * 1000) {
RTW_PRINT("%s("ADPT_FMT") countermeasure time:%ds > 60s\n",
caller, ADPT_ARG(adapter), passing_ms / 1000);
securitypriv->btkip_countermeasure = _FALSE;
securitypriv->btkip_countermeasure_time = 0;
} else {
RTW_PRINT("%s("ADPT_FMT") countermeasure time:%ds < 60s\n",
caller, ADPT_ARG(adapter), passing_ms / 1000);
status = _FAIL;
}
}
return status;
}
#ifdef CONFIG_WOWLAN
u16 rtw_cal_crc16(u8 data, u16 crc)
{
u8 shift_in, data_bit;
u8 crc_bit4, crc_bit11, crc_bit15;
u16 crc_result;
int index;
for (index = 0; index < 8; index++) {
crc_bit15 = ((crc & BIT15) ? 1 : 0);
data_bit = (data & (BIT0 << index) ? 1 : 0);
shift_in = crc_bit15 ^ data_bit;
/*printf("crc_bit15=%d, DataBit=%d, shift_in=%d\n",
* crc_bit15, data_bit, shift_in);*/
crc_result = crc << 1;
if (shift_in == 0)
crc_result &= (~BIT0);
else
crc_result |= BIT0;
/*printf("CRC =%x\n",CRC_Result);*/
crc_bit11 = ((crc & BIT11) ? 1 : 0) ^ shift_in;
if (crc_bit11 == 0)
crc_result &= (~BIT12);
else
crc_result |= BIT12;
/*printf("bit12 CRC =%x\n",CRC_Result);*/
crc_bit4 = ((crc & BIT4) ? 1 : 0) ^ shift_in;
if (crc_bit4 == 0)
crc_result &= (~BIT5);
else
crc_result |= BIT5;
/* printf("bit5 CRC =%x\n",CRC_Result); */
/* repeat using the last result*/
crc = crc_result;
}
return crc;
}
/*
* function name :rtw_calc_crc
*
* input: char* pattern , pattern size
*
*/
u16 rtw_calc_crc(u8 *pdata, int length)
{
u16 crc = 0xffff;
int i;
for (i = 0; i < length; i++)
crc = rtw_cal_crc16(pdata[i], crc);
/* get 1' complement */
crc = ~crc;
return crc;
}
#endif /*CONFIG_WOWLAN*/
u32 rtw_calc_crc32(u8 *data, size_t len)
{
size_t i;
u32 crc = 0xFFFFFFFF;
if (bcrc32initialized == 0)
crc32_init();
for (i = 0; i < len; i++)
crc = crc32_table[(crc ^ data[i]) & 0xff] ^ (crc >> 8);
/* return 1' complement */
return ~crc;
}
/**
* rtw_gcmp_encrypt -
* @padapter:
* @pxmitframe:
*
*/
u32 rtw_gcmp_encrypt(_adapter *padapter, u8 *pxmitframe)
{
struct xmit_frame *xf = (struct xmit_frame *)pxmitframe;
struct pkt_attrib *pattrib = &xf->attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct rtw_xmit_req *txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
sint curfragnum, plen;
u32 prwskeylen;
u8 *pframe = NULL;
u8 *prwskey = NULL;
u8 hw_hdr_offset = 0;
if ((pattrib->encrypt != _GCMP_) && (pattrib->encrypt != _GCMP_256_))
return _SUCCESS;
/* start to encrypt each fragment */
if (IS_MCAST(pattrib->ra))
prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
else
prwskey = pattrib->dot118021x_UncstKey.skey;
prwskeylen = (pattrib->encrypt == _GCMP_256_) ? 32 : 16;
for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
txreq = &xf->phl_txreq[curfragnum];
rtw_warn_on(txreq->pkt_cnt != 1);
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
pframe = pkt_list->vir_addr;
plen = pkt_list->length - pattrib->hdrlen
- pattrib->iv_len - pattrib->icv_len;
_rtw_gcmp_encrypt(padapter, prwskey, prwskeylen, pattrib->hdrlen,
pframe, plen);
}
GCMP_SW_ENC_CNT_INC(psecuritypriv, pattrib->ra);
return _SUCCESS;
}
u32 rtw_gcmp_decrypt(_adapter *padapter, u8 *precvframe)
{
u32 prwskeylen;
u8 * pframe,*prwskey;
struct sta_info *stainfo;
struct rx_pkt_attrib *prxattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
u32 res = _SUCCESS;
pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
if ((prxattrib->encrypt == _GCMP_) ||
(prxattrib->encrypt == _GCMP_256_)) {
stainfo = rtw_get_stainfo(&padapter->stapriv, &prxattrib->ta[0]);
if (stainfo != NULL) {
if (IS_MCAST(prxattrib->ra)) {
static systime start = 0;
static u32 no_gkey_bc_cnt = 0;
static u32 no_gkey_mc_cnt = 0;
if ((!MLME_IS_MESH(padapter) && psecuritypriv->binstallGrpkey == _FALSE)
#ifdef CONFIG_RTW_MESH
|| !(stainfo->gtk_bmp | BIT(prxattrib->key_index))
#endif
) {
res = _FAIL;
if (start == 0)
start = rtw_get_current_time();
if (is_broadcast_mac_addr(prxattrib->ra))
no_gkey_bc_cnt++;
else
no_gkey_mc_cnt++;
if (rtw_get_passing_time_ms(start) > 1000) {
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = rtw_get_current_time();
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
}
goto exit;
}
if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
RTW_PRINT(FUNC_ADPT_FMT" gkey installed. no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
FUNC_ADPT_ARG(padapter), no_gkey_bc_cnt, no_gkey_mc_cnt);
}
start = 0;
no_gkey_bc_cnt = 0;
no_gkey_mc_cnt = 0;
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
/* TODO: multiple GK? */
prwskey = &stainfo->gtk.skey[0];
} else
#endif
{
prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
if (psecuritypriv->dot118021XGrpKeyid != prxattrib->key_index) {
RTW_DBG("not match packet_index=%d, install_index=%d\n"
, prxattrib->key_index, psecuritypriv->dot118021XGrpKeyid);
res = _FAIL;
goto exit;
}
}
} else
prwskey = &stainfo->dot118021x_UncstKey.skey[0];
res = _rtw_gcmp_decrypt(padapter, prwskey,
prxattrib->encrypt == _GCMP_256_ ? 32 : 16,
prxattrib->hdrlen, pframe,
((union recv_frame *)precvframe)->u.hdr.len);
GCMP_SW_DEC_CNT_INC(psecuritypriv, prxattrib->ra);
} else {
res = _FAIL;
}
}
exit:
return res;
}
#ifdef CONFIG_IEEE80211W
u8 rtw_calculate_bip_mic(enum security_type gmcs, u8 *whdr_pos, s32 len,
const u8 *key, const u8 *data, size_t data_len, u8 *mic)
{
u8 res = _SUCCESS;
if (gmcs == _BIP_CMAC_128_) {
if (_bip_ccmp_protect(key, 16, data, data_len, mic) == _FALSE) {
res = _FAIL;
RTW_ERR("%s : _bip_ccmp_protect(128) fail!", __func__);
}
} else if (gmcs == _BIP_CMAC_256_) {
if (_bip_ccmp_protect(key, 32, data, data_len, mic) == _FALSE) {
res = _FAIL;
RTW_ERR("%s : _bip_ccmp_protect(256) fail!", __func__);
}
} else if (gmcs == _BIP_GMAC_128_) {
if (_bip_gcmp_protect(whdr_pos, len, key, 16,
data, data_len, mic) == _FALSE) {
res = _FAIL;
RTW_ERR("%s : _bip_gcmp_protect(128) fail!", __func__);
}
} else if (gmcs == _BIP_GMAC_256_) {
if (_bip_gcmp_protect(whdr_pos, len, key, 32,
data, data_len, mic) == _FALSE) {
res = _FAIL;
RTW_ERR("%s : _bip_gcmp_protect(256) fail!", __func__);
}
} else {
res = _FAIL;
RTW_ERR("%s : unsupport dot11wCipher !\n", __func__);
}
return res;
}
u32 rtw_bip_verify(enum security_type gmcs, u16 pkt_len,
u8 *whdr_pos, sint flen, const u8 *key, u16 keyid, u64 *ipn,
u8 *precvframe)
{
u8 * BIP_AAD,*mme;
u32 res = _FAIL;
uint len, ori_len;
u16 pkt_keyid = 0;
u64 pkt_ipn = 0;
struct rtw_ieee80211_hdr *pwlanhdr;
u8 mic[16];
u8 mic_len, mme_offset;
struct rx_pkt_attrib *prxattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
mic_len = (gmcs == _BIP_CMAC_128_) ? 8 : 16;
if (flen < WLAN_HDR_A3_LEN || flen - WLAN_HDR_A3_LEN < mic_len)
return RTW_RX_HANDLED;
mme_offset = (mic_len == 8) ? 18 : 26;
mme = whdr_pos + flen - mme_offset;
if (*mme != _MME_IE_)
return RTW_RX_HANDLED;
/* copy key index */
_rtw_memcpy(&pkt_keyid, mme + 2, 2);
pkt_keyid = le16_to_cpu(pkt_keyid);
if (pkt_keyid != keyid) {
RTW_INFO("BIP key index error!\n");
return _FAIL;
}
/* save packet number */
_rtw_memcpy(&pkt_ipn, mme + 4, 6);
pkt_ipn = le64_to_cpu(pkt_ipn);
/* BIP packet number should bigger than previous BIP packet */
if (pkt_ipn <= *ipn) { /* wrap around? */
RTW_INFO("replay BIP packet\n");
return _FAIL;
}
/*HW decrtped case*/
if (prxattrib->bdecrypted) {
/*Need to record IPN value */
*ipn = pkt_ipn;
return _SUCCESS;
}
ori_len = flen - WLAN_HDR_A3_LEN + BIP_AAD_SIZE;
BIP_AAD = rtw_zmalloc(ori_len);
if (BIP_AAD == NULL) {
RTW_INFO("BIP AAD allocate fail\n");
return _FAIL;
}
/* mapping to wlan header */
pwlanhdr = (struct rtw_ieee80211_hdr *)whdr_pos;
/* save the frame body + MME (w/o mic) */
_rtw_memcpy(BIP_AAD + BIP_AAD_SIZE,
whdr_pos + WLAN_HDR_A3_LEN,
flen - WLAN_HDR_A3_LEN - mic_len);
/* conscruct AAD, copy frame control field */
_rtw_memcpy(BIP_AAD, &pwlanhdr->frame_ctl, 2);
ClearRetry(BIP_AAD);
ClearPwrMgt(BIP_AAD);
ClearMData(BIP_AAD);
/* conscruct AAD, copy address 1 to address 3 */
_rtw_memcpy(BIP_AAD + 2, pwlanhdr->addr1, 18);
if (rtw_calculate_bip_mic(gmcs, whdr_pos,
pkt_len, key, BIP_AAD, ori_len, mic) == _FAIL)
goto BIP_exit;
/* MIC field should be last 8 bytes of packet (packet without FCS) */
if (_rtw_memcmp(mic, whdr_pos + flen - mic_len, mic_len)) {
*ipn = pkt_ipn;
res = _SUCCESS;
} else
RTW_INFO("BIP MIC error!\n");
#if 0
/* management packet content */
{
int pp;
RTW_INFO("pkt: ");
RTW_INFO_DUMP("", whdr_pos, flen);
RTW_INFO("\n");
/* BIP AAD + management frame body + MME(MIC is zero) */
RTW_INFO("AAD+PKT: ");
RTW_INFO_DUMP("", BIP_AAD, ori_len);
RTW_INFO("\n");
/* show the MIC result */
RTW_INFO("mic: ");
RTW_INFO_DUMP("", mic, mic_len);
RTW_INFO("\n");
}
#endif
BIP_exit:
rtw_mfree(BIP_AAD, ori_len);
return res;
}
#endif /* CONFIG_IEEE80211W */
u8 rtw_iv_to_pn(u8 *iv, u8 *pn, u8 *key_id, u32 enc_algo)
{
/* iv and pn must be Little Endian format */
switch (enc_algo) {
case _TKIP_:
*(pn) = *(iv + 2);
*(pn + 1) = *(iv);
break;
case _AES_:
case _GCMP_:
case _CCMP_256_:
case _GCMP_256_:
*(pn) = *(iv);
*(pn + 1) = *(iv + 1);
break;
default:
return _FAIL;
}
*(pn + 2) = *(iv + 4);
*(pn + 3) = *(iv + 5);
*(pn + 4) = *(iv + 6);
*(pn + 5) = *(iv + 7);
if (key_id)
*key_id = *(iv + 3) >> 6;
return _SUCCESS;
}
u8 rtw_pn_to_iv(u8 *pn, u8 *iv, u8 key_id, u32 enc_algo)
{
/* iv and pn must be Little Endian format */
switch (enc_algo) {
case _TKIP_:
*(iv) = *(pn + 1);
*(iv + 1) = (*(pn + 1) | 0x20) & 0x7F;
*(iv + 2) = *(pn);
break;
case _AES_:
case _GCMP_:
case _CCMP_256_:
case _GCMP_256_:
*(iv) = *(pn);
*(iv + 1) = *(pn + 1);
*(iv + 2) = 0;
break;
default:
return _FAIL;
}
*(iv + 3) = BIT(5) | ((key_id & 0x3) << 6);
*(iv + 4) = *(pn + 2);
*(iv + 5) = *(pn + 3);
*(iv + 6) = *(pn + 4);
*(iv + 7) = *(pn + 5);
return _SUCCESS;
}
|
2301_81045437/rtl8852be
|
core/rtw_security.c
|
C
|
agpl-3.0
| 78,170
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#include <rtw_sreset.h>
void sreset_init_value(_adapter *padapter)
{
#if defined(DBG_CONFIG_ERROR_DETECT)
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(dvobj);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
_rtw_mutex_init(&psrtpriv->silentreset_mutex);
psrtpriv->silent_reset_inprogress = _FALSE;
psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;
psrtpriv->last_tx_time = 0;
psrtpriv->last_tx_complete_time = 0;
#endif
}
void sreset_reset_value(_adapter *padapter)
{
#if defined(DBG_CONFIG_ERROR_DETECT)
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(dvobj);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;
psrtpriv->last_tx_time = 0;
psrtpriv->last_tx_complete_time = 0;
#endif
}
u8 sreset_get_wifi_status(_adapter *padapter)
{
#if defined(DBG_CONFIG_ERROR_DETECT)
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(dvobj);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
u8 status = WIFI_STATUS_SUCCESS;
u32 val32 = 0;
if (psrtpriv->silent_reset_inprogress == _TRUE)
return status;
#if 0 /*GEORGIA_TODO_REDEFINE_IO*/
val32 = rtw_read32(padapter, REG_TXDMA_STATUS);
#else
val32 = rtw_hal_get_dma_statu(padapter);
#endif
if (val32 == 0xeaeaeaea)
psrtpriv->Wifi_Error_Status = WIFI_IF_NOT_EXIST;
else if (val32 != 0) {
RTW_INFO("txdmastatu(%x)\n", val32);
psrtpriv->Wifi_Error_Status = WIFI_MAC_TXDMA_ERROR;
}
if (WIFI_STATUS_SUCCESS != psrtpriv->Wifi_Error_Status) {
RTW_INFO("==>%s error_status(0x%x)\n", __FUNCTION__, psrtpriv->Wifi_Error_Status);
status = (psrtpriv->Wifi_Error_Status & (~(USB_READ_PORT_FAIL | USB_WRITE_PORT_FAIL)));
}
RTW_INFO("==> %s wifi_status(0x%x)\n", __FUNCTION__, status);
/* status restore */
psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;
return status;
#else
return WIFI_STATUS_SUCCESS;
#endif
}
void sreset_set_wifi_error_status(_adapter *padapter, u32 status)
{
#if defined(DBG_CONFIG_ERROR_DETECT)
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(dvobj);
pHalData->srestpriv.Wifi_Error_Status = status;
#endif
}
void sreset_set_trigger_point(_adapter *padapter, s32 tgp)
{
#if defined(DBG_CONFIG_ERROR_DETECT)
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(dvobj);
pHalData->srestpriv.dbg_trigger_point = tgp;
#endif
}
bool sreset_inprogress(_adapter *padapter)
{
#if defined(DBG_CONFIG_ERROR_RESET)
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
HAL_DATA_TYPE *pHalData = GET_PHL_COM(dvobj);
return pHalData->srestpriv.silent_reset_inprogress;
#else
return _FALSE;
#endif
}
void sreset_restore_security_station(_adapter *padapter)
{
struct mlme_priv *mlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta;
struct mlme_ext_info *pmlmeinfo = &padapter->mlmeextpriv.mlmext_info;
rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, NULL);
if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) ||
(padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
psta = rtw_get_stainfo(pstapriv, get_bssid(mlmepriv));
if (psta == NULL) {
/* DEBUG_ERR( ("Set wpa_set_encryption: Obtain Sta_info fail\n")); */
} else {
/* pairwise key */
rtw_setstakey_cmd(padapter, psta, UNICAST_KEY, _FALSE);
/* group key */
rtw_set_key(padapter, &padapter->securitypriv, padapter->securitypriv.dot118021XGrpKeyid, 0, _FALSE);
}
}
}
void sreset_restore_network_station(_adapter *padapter)
{
struct mlme_priv *mlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 do_rfk = _FALSE;
rtw_setopmode_cmd(padapter, Ndis802_11Infrastructure, RTW_CMDF_DIRECTLY);
{
u8 threshold;
#ifdef CONFIG_USB_HCI
/* TH=1 => means that invalidate usb rx aggregation */
/* TH=0 => means that validate usb rx aggregation, use init value. */
#ifdef CONFIG_80211N_HT
if (mlmepriv->htpriv.ht_option) {
if (padapter->registrypriv.wifi_spec == 1)
threshold = 1;
else
threshold = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
} else {
threshold = 1;
rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
}
#endif /* CONFIG_80211N_HT */
#endif
}
do_rfk = _TRUE;
set_channel_bwmode(padapter,
pmlmeext->chandef.chan,
pmlmeext->chandef.offset,
pmlmeext->chandef.bw,
do_rfk);
rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, pmlmeinfo->network.MacAddress);
{
u8 join_type = 0;
rtw_hal_rcr_set_chk_bssid(padapter, MLME_STA_CONNECTING);
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
}
rtw_set_hw_after_join(padapter, 1);
/* restore Sequence No. */
rtw_hal_set_hwreg(padapter, HW_VAR_RESTORE_HW_SEQ, 0);
sreset_restore_security_station(padapter);
}
void sreset_restore_network_status(_adapter *padapter)
{
struct mlme_priv *mlmepriv = &padapter->mlmepriv;
if (MLME_IS_STA(padapter)) {
RTW_INFO(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_STATION_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
sreset_restore_network_station(padapter);
} else if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter)) {
RTW_INFO(FUNC_ADPT_FMT" %s\n", FUNC_ADPT_ARG(padapter), MLME_IS_AP(padapter) ? "AP" : "MESH");
rtw_ap_restore_network(padapter);
} else if (MLME_IS_ADHOC(padapter))
RTW_INFO(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_ADHOC_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
else
RTW_INFO(FUNC_ADPT_FMT" fwstate:0x%08x - ???\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
}
void sreset_stop_adapter(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
if (padapter == NULL)
return;
RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
rtw_netif_stop_queue(padapter->pnetdev);
rtw_cancel_all_timer(padapter);
/* TODO: OS and HCI independent */
#if defined(CONFIG_USB_HCI)
rtw_tasklet_kill(&pxmitpriv->xmit_tasklet);
#endif
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY))
rtw_scan_abort(padapter, 0);
if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) {
rtw_set_to_roam(padapter, 0);
rtw_join_timeout_handler(padapter);
}
}
void sreset_start_adapter(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
if (padapter == NULL)
return;
RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE))
sreset_restore_network_status(padapter);
/* TODO: OS and HCI independent */
#if defined(CONFIG_USB_HCI)
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
#endif
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
if (is_primary_adapter(padapter))
_set_timer(&adapter_to_dvobj(padapter)->dynamic_chk_timer, 2000);
#endif
rtw_netif_wake_queue(padapter->pnetdev);
}
void sreset_reset(_adapter *padapter)
{
#ifdef DBG_CONFIG_ERROR_RESET
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
systime start = rtw_get_current_time();
struct dvobj_priv *psdpriv = padapter->dvobj;
HAL_DATA_TYPE *pHalData = GET_PHL_COM(psdpriv);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
RTW_INFO("%s\n", __FUNCTION__);
psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;
#ifdef CONFIG_LPS
rtw_set_ps_mode(padapter, PM_PS_MODE_ACTIVE, 0, 0, "SRESET");
#endif/* #ifdef CONFIG_LPS */
_enter_pwrlock(&pwrpriv->lock);
psrtpriv->silent_reset_inprogress = _TRUE;
pwrpriv->change_rfpwrstate = rf_off;
rtw_mi_sreset_adapter_hdl(padapter, _FALSE);/*sreset_stop_adapter*/
#ifdef CONFIG_IPS
_ips_enter(padapter);
_ips_leave(padapter);
#endif
#ifdef CONFIG_CONCURRENT_MODE
rtw_mi_ap_info_restore(padapter);
#endif
rtw_mi_sreset_adapter_hdl(padapter, _TRUE);/*sreset_start_adapter*/
psrtpriv->silent_reset_inprogress = _FALSE;
_exit_pwrlock(&pwrpriv->lock);
RTW_INFO("%s done in %d ms\n", __FUNCTION__, rtw_get_passing_time_ms(start));
pdbgpriv->dbg_sreset_cnt++;
psrtpriv->self_dect_fw = _FALSE;
psrtpriv->rx_cnt = 0;
#endif
}
|
2301_81045437/rtl8852be
|
core/rtw_sreset.c
|
C
|
agpl-3.0
| 9,089
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_STA_MGT_C_
#include <drv_types.h>
bool test_st_match_rule(_adapter *adapter, u8 *local_naddr, u8 *local_port, u8 *remote_naddr, u8 *remote_port)
{
if (ntohs(*((u16 *)local_port)) == 5001 || ntohs(*((u16 *)remote_port)) == 5001)
return _TRUE;
return _FALSE;
}
struct st_register test_st_reg = {
.s_proto = 0x06,
.rule = test_st_match_rule,
};
inline void rtw_st_ctl_init(struct st_ctl_t *st_ctl)
{
_rtw_memset(st_ctl->reg, 0 , sizeof(struct st_register) * SESSION_TRACKER_REG_ID_NUM);
_rtw_init_queue(&st_ctl->tracker_q);
}
inline void rtw_st_ctl_clear_tracker_q(struct st_ctl_t *st_ctl)
{
_list *plist, *phead;
struct session_tracker *st;
_rtw_spinlock_bh(&st_ctl->tracker_q.lock);
phead = &st_ctl->tracker_q.queue;
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
st = LIST_CONTAINOR(plist, struct session_tracker, list);
plist = get_next(plist);
rtw_list_delete(&st->list);
rtw_mfree((u8 *)st, sizeof(struct session_tracker));
}
_rtw_spinunlock_bh(&st_ctl->tracker_q.lock);
}
inline void rtw_st_ctl_deinit(struct st_ctl_t *st_ctl)
{
rtw_st_ctl_clear_tracker_q(st_ctl);
_rtw_deinit_queue(&st_ctl->tracker_q);
}
inline void rtw_st_ctl_register(struct st_ctl_t *st_ctl, u8 st_reg_id, struct st_register *reg)
{
if (st_reg_id >= SESSION_TRACKER_REG_ID_NUM) {
rtw_warn_on(1);
return;
}
st_ctl->reg[st_reg_id].s_proto = reg->s_proto;
st_ctl->reg[st_reg_id].rule = reg->rule;
}
inline void rtw_st_ctl_unregister(struct st_ctl_t *st_ctl, u8 st_reg_id)
{
int i;
if (st_reg_id >= SESSION_TRACKER_REG_ID_NUM) {
rtw_warn_on(1);
return;
}
st_ctl->reg[st_reg_id].s_proto = 0;
st_ctl->reg[st_reg_id].rule = NULL;
/* clear tracker queue if no session trecker registered */
for (i = 0; i < SESSION_TRACKER_REG_ID_NUM; i++)
if (st_ctl->reg[i].s_proto != 0)
break;
if (i >= SESSION_TRACKER_REG_ID_NUM)
rtw_st_ctl_clear_tracker_q(st_ctl);
}
inline bool rtw_st_ctl_chk_reg_s_proto(struct st_ctl_t *st_ctl, u8 s_proto)
{
bool ret = _FALSE;
int i;
for (i = 0; i < SESSION_TRACKER_REG_ID_NUM; i++) {
if (st_ctl->reg[i].s_proto == s_proto) {
ret = _TRUE;
break;
}
}
return ret;
}
inline bool rtw_st_ctl_chk_reg_rule(struct st_ctl_t *st_ctl, _adapter *adapter, u8 *local_naddr, u8 *local_port, u8 *remote_naddr, u8 *remote_port)
{
bool ret = _FALSE;
int i;
st_match_rule rule;
for (i = 0; i < SESSION_TRACKER_REG_ID_NUM; i++) {
rule = st_ctl->reg[i].rule;
if (rule && rule(adapter, local_naddr, local_port, remote_naddr, remote_port) == _TRUE) {
ret = _TRUE;
break;
}
}
return ret;
}
void rtw_st_ctl_rx(struct sta_info *sta, u8 *ehdr_pos)
{
_adapter *adapter = sta->padapter;
struct ethhdr *etherhdr = (struct ethhdr *)ehdr_pos;
if (ntohs(etherhdr->h_proto) == ETH_P_IP) {
u8 *ip = ehdr_pos + ETH_HLEN;
if (GET_IPV4_PROTOCOL(ip) == 0x06 /* TCP */
&& rtw_st_ctl_chk_reg_s_proto(&sta->st_ctl, 0x06) == _TRUE
) {
u8 *tcp = ip + GET_IPV4_IHL(ip) * 4;
if (rtw_st_ctl_chk_reg_rule(&sta->st_ctl, adapter, IPV4_DST(ip), TCP_DST(tcp), IPV4_SRC(ip), TCP_SRC(tcp)) == _TRUE) {
if (GET_TCP_SYN(tcp) && GET_TCP_ACK(tcp)) {
session_tracker_add_cmd(adapter, sta
, IPV4_DST(ip), TCP_DST(tcp)
, IPV4_SRC(ip), TCP_SRC(tcp));
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" local:"IP_FMT":"PORT_FMT", remote:"IP_FMT":"PORT_FMT" SYN-ACK\n"
, FUNC_ADPT_ARG(adapter)
, IP_ARG(IPV4_DST(ip)), PORT_ARG(TCP_DST(tcp))
, IP_ARG(IPV4_SRC(ip)), PORT_ARG(TCP_SRC(tcp)));
}
if (GET_TCP_FIN(tcp)) {
session_tracker_del_cmd(adapter, sta
, IPV4_DST(ip), TCP_DST(tcp)
, IPV4_SRC(ip), TCP_SRC(tcp));
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" local:"IP_FMT":"PORT_FMT", remote:"IP_FMT":"PORT_FMT" FIN\n"
, FUNC_ADPT_ARG(adapter)
, IP_ARG(IPV4_DST(ip)), PORT_ARG(TCP_DST(tcp))
, IP_ARG(IPV4_SRC(ip)), PORT_ARG(TCP_SRC(tcp)));
}
}
}
}
}
#define SESSION_TRACKER_FMT IP_FMT":"PORT_FMT" "IP_FMT":"PORT_FMT" %u %d"
#define SESSION_TRACKER_ARG(st) IP_ARG(&(st)->local_naddr), PORT_ARG(&(st)->local_port), IP_ARG(&(st)->remote_naddr), PORT_ARG(&(st)->remote_port), (st)->status, rtw_get_passing_time_ms((st)->set_time)
void dump_st_ctl(void *sel, struct st_ctl_t *st_ctl)
{
int i;
_list *plist, *phead;
struct session_tracker *st;
if (!DBG_SESSION_TRACKER)
return;
for (i = 0; i < SESSION_TRACKER_REG_ID_NUM; i++)
RTW_PRINT_SEL(sel, "reg%d: %u %p\n", i, st_ctl->reg[i].s_proto, st_ctl->reg[i].rule);
_rtw_spinlock_bh(&st_ctl->tracker_q.lock);
phead = &st_ctl->tracker_q.queue;
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
st = LIST_CONTAINOR(plist, struct session_tracker, list);
plist = get_next(plist);
RTW_PRINT_SEL(sel, SESSION_TRACKER_FMT"\n", SESSION_TRACKER_ARG(st));
}
_rtw_spinunlock_bh(&st_ctl->tracker_q.lock);
}
void _rtw_init_stainfo(struct sta_info *psta);
void _rtw_init_stainfo(struct sta_info *psta)
{
_rtw_memset((u8 *)psta, 0, sizeof(struct sta_info));
_rtw_spinlock_init(&psta->lock);
_rtw_init_listhead(&psta->list);
_rtw_init_listhead(&psta->hash_list);
/* _rtw_init_listhead(&psta->asoc_list); */
/* _rtw_init_listhead(&psta->sleep_list); */
/* _rtw_init_listhead(&psta->wakeup_list); */
_rtw_init_queue(&psta->sleep_q);
_rtw_init_sta_xmit_priv(&psta->sta_xmitpriv);
_rtw_init_sta_recv_priv(&psta->sta_recvpriv);
#ifdef CONFIG_AP_MODE
_rtw_init_listhead(&psta->asoc_list);
_rtw_init_listhead(&psta->auth_list);
psta->bpairwise_key_installed = _FALSE;
#ifdef CONFIG_RTW_80211R_AP
rtw_ft_peer_info_init(psta);
#endif
#ifdef CONFIG_RTW_80211R
psta->ft_pairwise_key_installed = _FALSE;
#endif
#endif /* CONFIG_AP_MODE */
rtw_st_ctl_init(&psta->st_ctl);
}
u32 _rtw_init_sta_priv(struct sta_priv *pstapriv)
{
_adapter *adapter = container_of(pstapriv, _adapter, stapriv);
/* struct macid_ctl_t *macid_ctl = adapter_to_macidctl(adapter); */
struct sta_info *psta;
s32 i;
u32 ret = _FAIL;
pstapriv->padapter = adapter;
pstapriv->pallocated_stainfo_buf = rtw_zvmalloc(
sizeof(struct sta_info) * NUM_STA + MEM_ALIGNMENT_OFFSET);
if (!pstapriv->pallocated_stainfo_buf)
goto exit;
pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf;
if ((SIZE_PTR)pstapriv->pstainfo_buf & MEM_ALIGNMENT_PADDING)
pstapriv->pstainfo_buf += MEM_ALIGNMENT_OFFSET -
((SIZE_PTR)pstapriv->pstainfo_buf & MEM_ALIGNMENT_PADDING);
_rtw_init_queue(&pstapriv->free_sta_queue);
_rtw_spinlock_init(&pstapriv->sta_hash_lock);
/* _rtw_init_queue(&pstapriv->asoc_q); */
pstapriv->asoc_sta_count = 0;
_rtw_init_queue(&pstapriv->sleep_q);
_rtw_init_queue(&pstapriv->wakeup_q);
psta = (struct sta_info *)(pstapriv->pstainfo_buf);
for (i = 0; i < NUM_STA; i++) {
_rtw_init_stainfo(psta);
_rtw_init_listhead(&(pstapriv->sta_hash[i]));
rtw_list_insert_tail(&psta->list, get_list_head(&pstapriv->free_sta_queue));
psta++;
}
pstapriv->adhoc_expire_to = 4; /* 4 * 2 = 8 sec */
#ifdef CONFIG_AP_MODE
pstapriv->max_aid = rtw_phl_get_macid_max_num(
GET_PHL_INFO(adapter_to_dvobj(pstapriv->padapter)));
pstapriv->rr_aid = 0;
pstapriv->started_aid = 1;
pstapriv->sta_aid = rtw_zmalloc(pstapriv->max_aid * sizeof(struct sta_info *));
if (!pstapriv->sta_aid)
goto exit;
pstapriv->aid_bmp_len = AID_BMP_LEN(pstapriv->max_aid);
pstapriv->sta_dz_bitmap = rtw_zmalloc(pstapriv->aid_bmp_len);
if (!pstapriv->sta_dz_bitmap)
goto exit;
pstapriv->tim_bitmap = rtw_zmalloc(pstapriv->aid_bmp_len);
if (!pstapriv->tim_bitmap)
goto exit;
_rtw_init_listhead(&pstapriv->asoc_list);
_rtw_init_listhead(&pstapriv->auth_list);
_rtw_spinlock_init(&pstapriv->asoc_list_lock);
_rtw_spinlock_init(&pstapriv->auth_list_lock);
pstapriv->asoc_list_cnt = 0;
pstapriv->auth_list_cnt = 0;
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
pstapriv->tbtx_asoc_list_cnt = 0;
#endif
pstapriv->auth_to = 3; /* 3*2 = 6 sec */
pstapriv->assoc_to = 3;
/* pstapriv->expire_to = 900; */ /* 900*2 = 1800 sec = 30 min, expire after no any traffic. */
/* pstapriv->expire_to = 30; */ /* 30*2 = 60 sec = 1 min, expire after no any traffic. */
#ifdef CONFIG_ACTIVE_KEEP_ALIVE_CHECK
pstapriv->expire_to = 3; /* 3*2 = 6 sec */
#else
pstapriv->expire_to = 60;/* 60*2 = 120 sec = 2 min, expire after no any traffic. */
#endif
#ifdef CONFIG_ATMEL_RC_PATCH
_rtw_memset(pstapriv->atmel_rc_pattern, 0, ETH_ALEN);
#endif
pstapriv->max_num_sta = NUM_STA;
#endif
#if CONFIG_RTW_MACADDR_ACL
for (i = 0; i < RTW_ACL_PERIOD_NUM; i++)
rtw_macaddr_acl_init(adapter, i);
#endif
#if CONFIG_RTW_PRE_LINK_STA
rtw_pre_link_sta_ctl_init(pstapriv);
#endif
#if defined(DBG_ROAMING_TEST)
rtw_set_rx_chk_limit(adapter,1);
#elif defined(CONFIG_ACTIVE_KEEP_ALIVE_CHECK) && !defined(CONFIG_LPS_LCLK_WD_TIMER)
rtw_set_rx_chk_limit(adapter,4);
#else
rtw_set_rx_chk_limit(adapter,8);
#endif
ret = _SUCCESS;
exit:
if (ret != _SUCCESS) {
if (pstapriv->pallocated_stainfo_buf)
rtw_vmfree(pstapriv->pallocated_stainfo_buf,
sizeof(struct sta_info) * NUM_STA + MEM_ALIGNMENT_OFFSET);
#ifdef CONFIG_AP_MODE
if (pstapriv->sta_aid)
rtw_mfree(pstapriv->sta_aid, pstapriv->max_aid * sizeof(struct sta_info *));
if (pstapriv->sta_dz_bitmap)
rtw_mfree(pstapriv->sta_dz_bitmap, pstapriv->aid_bmp_len);
#endif
}
return ret;
}
inline int rtw_stainfo_offset(struct sta_priv *stapriv, struct sta_info *sta)
{
int offset = (((u8 *)sta) - stapriv->pstainfo_buf) / sizeof(struct sta_info);
if (!stainfo_offset_valid(offset))
RTW_INFO("%s invalid offset(%d), out of range!!!", __func__, offset);
return offset;
}
inline struct sta_info *rtw_get_stainfo_by_offset(struct sta_priv *stapriv, int offset)
{
if (!stainfo_offset_valid(offset))
RTW_INFO("%s invalid offset(%d), out of range!!!", __func__, offset);
return (struct sta_info *)(stapriv->pstainfo_buf + offset * sizeof(struct sta_info));
}
void _rtw_free_sta_xmit_priv_lock(struct sta_xmit_priv *psta_xmitpriv);
void _rtw_free_sta_xmit_priv_lock(struct sta_xmit_priv *psta_xmitpriv)
{
_rtw_spinlock_free(&psta_xmitpriv->lock);
_rtw_spinlock_free(&(psta_xmitpriv->be_q.sta_pending.lock));
_rtw_spinlock_free(&(psta_xmitpriv->bk_q.sta_pending.lock));
_rtw_spinlock_free(&(psta_xmitpriv->vi_q.sta_pending.lock));
_rtw_spinlock_free(&(psta_xmitpriv->vo_q.sta_pending.lock));
}
static void _rtw_free_sta_recv_priv_lock(struct sta_recv_priv *psta_recvpriv)
{
_rtw_spinlock_free(&psta_recvpriv->lock);
_rtw_spinlock_free(&(psta_recvpriv->defrag_q.lock));
}
void rtw_mfree_stainfo(struct sta_info *psta);
void rtw_mfree_stainfo(struct sta_info *psta)
{
if (&psta->lock != NULL)
_rtw_spinlock_free(&psta->lock);
_rtw_free_sta_xmit_priv_lock(&psta->sta_xmitpriv);
_rtw_free_sta_recv_priv_lock(&psta->sta_recvpriv);
}
/* this function is used to free the memory of lock || sema for all stainfos */
void rtw_mfree_all_stainfo(struct sta_priv *pstapriv);
void rtw_mfree_all_stainfo(struct sta_priv *pstapriv)
{
_list *plist, *phead;
struct sta_info *psta = NULL;
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
phead = get_list_head(&pstapriv->free_sta_queue);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info , list);
plist = get_next(plist);
rtw_mfree_stainfo(psta);
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
}
void rtw_mfree_sta_priv_lock(struct sta_priv *pstapriv);
void rtw_mfree_sta_priv_lock(struct sta_priv *pstapriv)
{
rtw_mfree_all_stainfo(pstapriv); /* be done before free sta_hash_lock */
_rtw_spinlock_free(&pstapriv->free_sta_queue.lock);
_rtw_spinlock_free(&pstapriv->sta_hash_lock);
_rtw_spinlock_free(&pstapriv->wakeup_q.lock);
_rtw_spinlock_free(&pstapriv->sleep_q.lock);
#ifdef CONFIG_AP_MODE
_rtw_spinlock_free(&pstapriv->asoc_list_lock);
_rtw_spinlock_free(&pstapriv->auth_list_lock);
#endif
}
u32 _rtw_free_sta_priv(struct sta_priv *pstapriv)
{
int index;
if (pstapriv) {
#ifdef CONFIG_RECV_REORDERING_CTRL
_list *phead, *plist;
struct sta_info *psta = NULL;
struct recv_reorder_ctrl *preorder_ctrl;
/* delete all reordering_ctrl_timer */
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < NUM_STA; index++) {
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
int i;
psta = LIST_CONTAINOR(plist, struct sta_info , hash_list);
plist = get_next(plist);
for (i = 0; i < 16 ; i++) {
preorder_ctrl = &psta->recvreorder_ctrl[i];
_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
/*===============================*/
#endif
rtw_mfree_sta_priv_lock(pstapriv);
#if CONFIG_RTW_MACADDR_ACL
for (index = 0; index < RTW_ACL_PERIOD_NUM; index++)
rtw_macaddr_acl_deinit(pstapriv->padapter, index);
#endif
#if CONFIG_RTW_PRE_LINK_STA
rtw_pre_link_sta_ctl_deinit(pstapriv);
#endif
if (pstapriv->pallocated_stainfo_buf)
rtw_vmfree(pstapriv->pallocated_stainfo_buf,
sizeof(struct sta_info) * NUM_STA + MEM_ALIGNMENT_OFFSET);
#ifdef CONFIG_AP_MODE
if (pstapriv->sta_aid)
rtw_mfree(pstapriv->sta_aid, pstapriv->max_aid * sizeof(struct sta_info *));
if (pstapriv->sta_dz_bitmap)
rtw_mfree(pstapriv->sta_dz_bitmap, pstapriv->aid_bmp_len);
if (pstapriv->tim_bitmap)
rtw_mfree(pstapriv->tim_bitmap, pstapriv->aid_bmp_len);
#endif
}
return _SUCCESS;
}
#if defined(CONFIG_80211N_HT) && defined(CONFIG_RECV_REORDERING_CTRL)
static void rtw_init_recv_timer(struct recv_reorder_ctrl *preorder_ctrl)
{
_adapter *padapter = preorder_ctrl->padapter;
rtw_init_timer(&(preorder_ctrl->reordering_ctrl_timer), rtw_reordering_ctrl_timeout_handler, preorder_ctrl);
}
#endif
/* struct sta_info *rtw_alloc_stainfo(_queue *pfree_sta_queue, unsigned char *hwaddr) */
static struct sta_info *_rtw_alloc_core_stainfo(struct sta_priv *pstapriv,
const u8 *hwaddr)
{
s32 index;
_list *phash_list;
struct sta_info *psta;
_queue *pfree_sta_queue;
struct recv_reorder_ctrl *preorder_ctrl;
struct rtw_wifi_role_t *phl_role = pstapriv->padapter->phl_role;
int i = 0;
u16 wRxSeqInitialValue = 0xffff;
pfree_sta_queue = &pstapriv->free_sta_queue;
/* _rtw_spinlock_bh(&(pfree_sta_queue->lock)); */
_rtw_spinlock_bh(&(pstapriv->sta_hash_lock));
if (_rtw_queue_empty(pfree_sta_queue) == _TRUE) {
/* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock));*/
psta = NULL;
} else {
psta = LIST_CONTAINOR(get_next(&pfree_sta_queue->queue), struct sta_info, list);
rtw_list_delete(&(psta->list));
/* _rtw_spinunlock_bh(&(pfree_sta_queue->lock)); */
_rtw_init_stainfo(psta);
psta->padapter = pstapriv->padapter;
/*
for sta mode, due to self sta info & AP sta info are the same sta info
using self hash index for sta mode, or bmc sta will not found self sta
*/
switch (phl_role->type) {
case PHL_RTYPE_NONE:
case PHL_RTYPE_STATION:
case PHL_RTYPE_ADHOC:
case PHL_RTYPE_P2P_DEVICE:
case PHL_RTYPE_P2P_GC:
index = wifi_mac_hash(phl_role->mac_addr);
break;
default:
index = wifi_mac_hash(hwaddr);
break;
}
if (index >= NUM_STA) {
psta = NULL;
goto exit;
}
phash_list = &(pstapriv->sta_hash[index]);
/* _rtw_spinlock_bh(&(pstapriv->sta_hash_lock)); */
rtw_list_insert_tail(&psta->hash_list, phash_list);
pstapriv->asoc_sta_count++;
/* _rtw_spinunlock_bh(&(pstapriv->sta_hash_lock)); */
/* Commented by Albert 2009/08/13
* For the SMC router, the sequence number of first packet of WPS handshake will be 0.
* In this case, this packet will be dropped by recv_decache function if we use the 0x00 as the default value for tid_rxseq variable.
* So, we initialize the tid_rxseq variable as the 0xffff. */
for (i = 0; i < 16; i++) {
_rtw_memcpy(&psta->sta_recvpriv.rxcache.tid_rxseq[i], &wRxSeqInitialValue, 2);
_rtw_memcpy(&psta->sta_recvpriv.bmc_tid_rxseq[i], &wRxSeqInitialValue, 2);
_rtw_memset(&psta->sta_recvpriv.rxcache.iv[i], 0, sizeof(psta->sta_recvpriv.rxcache.iv[i]));
}
rtw_init_timer(&psta->addba_retry_timer, addba_timer_hdl, psta);
#ifdef CONFIG_IEEE80211W
rtw_init_timer(&psta->dot11w_expire_timer, sa_query_timer_hdl, psta);
#endif /* CONFIG_IEEE80211W */
#ifdef CONFIG_TDLS
rtw_init_tdls_timer(pstapriv->padapter, psta);
#endif /* CONFIG_TDLS */
/* for A-MPDU Rx reordering buffer control */
for (i = 0; i < 16 ; i++) {
preorder_ctrl = &psta->recvreorder_ctrl[i];
preorder_ctrl->padapter = pstapriv->padapter;
preorder_ctrl->tid = i;
preorder_ctrl->enable = _FALSE;
preorder_ctrl->indicate_seq = 0xffff;
#ifdef DBG_RX_SEQ
RTW_INFO("DBG_RX_SEQ "FUNC_ADPT_FMT" tid:%u SN_CLEAR indicate_seq:%d\n"
, FUNC_ADPT_ARG(pstapriv->padapter), i, preorder_ctrl->indicate_seq);
#endif
preorder_ctrl->ampdu_size = RX_AMPDU_SIZE_INVALID;
#ifdef CONFIG_RECV_REORDERING_CTRL
/* preorder_ctrl->wsize_b = (NR_RECVBUFF-2); */
preorder_ctrl->wsize_b = 64;/* 64; */
_rtw_init_queue(&preorder_ctrl->pending_recvframe_queue);
rtw_init_recv_timer(preorder_ctrl);
#endif
rtw_clear_bit(RTW_RECV_ACK_OR_TIMEOUT, &preorder_ctrl->rec_abba_rsp_ack);
}
ATOMIC_SET(&psta->keytrack, 0);
/* ToDo: need to API to init hal_sta->ra_info->rssi_stat.rssi */
#if 0
psta->phl_sta->rssi_stat.rssi = (-1);
psta->phl_sta->rssi_stat.rssi_cck = (-1);
psta->phl_sta->rssi_stat.rssi_ofdm = (-1);
#endif
#ifdef CONFIG_ATMEL_RC_PATCH
psta->flag_atmel_rc = 0;
#endif
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
psta->tbtx_enable = _FALSE;
#endif
/* init for the sequence number of received management frame */
psta->RxMgmtFrameSeqNum = 0xffff;
_rtw_memset(&psta->sta_stats, 0, sizeof(struct stainfo_stats));
psta->tx_q_enable = 0;
_rtw_init_queue(&psta->tx_queue);
_init_workitem(&psta->tx_q_work, rtw_xmit_dequeue_callback, NULL);
}
exit:
_rtw_spinunlock_bh(&(pstapriv->sta_hash_lock));
if (psta)
rtw_mi_update_iface_status(&(pstapriv->padapter->mlmepriv), 0);
return psta;
}
static void _rtw_alloc_phl_stainfo(struct sta_info *sta, struct sta_priv *stapriv, const u8 *hwaddr)
{
enum rtw_phl_status pstatus = RTW_PHL_STATUS_SUCCESS;
void *phl = GET_PHL_INFO(adapter_to_dvobj(stapriv->padapter));
struct rtw_wifi_role_t *wrole = stapriv->padapter->phl_role;
bool alloc = _TRUE, only_hw = _FALSE;
if (sta != NULL) {
/* Do not use this function in interrupt context */
pstatus = rtw_phl_cmd_alloc_stainfo(phl, &sta->phl_sta,
(u8 *)hwaddr, wrole,
alloc, only_hw,
PHL_CMD_DIRECTLY, 0);
if (sta->phl_sta) {
rtw_dump_phl_sta_info(RTW_DBGDUMP, sta);
} else {
RTW_ERR(FUNC_ADPT_FMT ": fail to alloc PHL sta "
"for " MAC_FMT " (status=%d)!\n",
FUNC_ADPT_ARG(stapriv->padapter),
MAC_ARG(hwaddr),
pstatus);
}
}
}
struct sta_info *rtw_alloc_stainfo(struct sta_priv *stapriv, const u8 *hwaddr)
{
struct sta_info *sta;
/* can use in interrupt context */
sta = _rtw_alloc_core_stainfo(stapriv, hwaddr);
/* can not use in interrupt context */
_rtw_alloc_phl_stainfo(sta, stapriv, hwaddr);
return sta;
}
struct sta_info *rtw_alloc_stainfo_sw(struct sta_priv *stapriv, const u8 *hwaddr)
{
struct sta_info *sta;
/* can use in interrupt context */
sta = _rtw_alloc_core_stainfo(stapriv, hwaddr);
if (sta != NULL) {
sta->phl_sta = rtw_phl_alloc_stainfo_sw(
GET_PHL_INFO(adapter_to_dvobj(stapriv->padapter)),
(u8 *)hwaddr, stapriv->padapter->phl_role);
if (sta->phl_sta) {
rtw_dump_phl_sta_info(RTW_DBGDUMP, sta);
} else {
RTW_ERR(FUNC_ADPT_FMT ": fail to alloc PHL sta "
"for " MAC_FMT " !\n",
FUNC_ADPT_ARG(stapriv->padapter),
MAC_ARG(hwaddr));
}
}
return sta;
}
u32 rtw_alloc_stainfo_hw(struct sta_priv *stapriv, struct sta_info *psta)
{
enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
void *phl = GET_PHL_INFO(adapter_to_dvobj(stapriv->padapter));
struct rtw_wifi_role_t *wrole = stapriv->padapter->phl_role;
bool alloc = _TRUE, only_hw = _TRUE;
if ((psta != NULL) && (psta->phl_sta != NULL) && (psta->phl_sta->active == _FALSE))
status = rtw_phl_cmd_alloc_stainfo(phl, &psta->phl_sta,
(u8 *)psta->phl_sta->mac_addr,
wrole, alloc, only_hw,
PHL_CMD_DIRECTLY, 0);
return (status == RTW_PHL_STATUS_SUCCESS) ? _SUCCESS : _FAIL;
}
/* using pstapriv->sta_hash_lock to protect */
u32 static _rtw_free_core_stainfo(_adapter *padapter , struct sta_info *psta)
{
int i;
_queue *pfree_sta_queue;
struct recv_reorder_ctrl *preorder_ctrl;
struct sta_xmit_priv *pstaxmitpriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct hw_xmit *phwxmit;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
int pending_qcnt[4];
u8 is_pre_link_sta = _FALSE;
if (psta == NULL)
goto exit;
#if defined(CONFIG_CORE_TXSC) && defined(USE_ONE_WLHDR)
/* free shortcut entry wlhdr buffer */
for (i = 0; i < CORE_TXSC_ENTRY_NUM; i++) {
if (psta->txsc_entry_cache[i].txsc_wlhdr) {
rtw_mfree(psta->txsc_entry_cache[i].txsc_wlhdr, CORE_TXSC_WLHDR_SIZE);
psta->txsc_entry_cache[i].txsc_wlhdr = NULL;
}
}
#endif
#ifdef CONFIG_RTW_80211K
rm_post_event(padapter, RM_ID_FOR_ALL(psta->phl_sta->aid), RM_EV_cancel);
#endif
#if CONFIG_RTW_PRE_LINK_STA
is_pre_link_sta = rtw_is_pre_link_sta(pstapriv, psta->phl_sta->mac_addr);
if (is_pre_link_sta == _FALSE) {
_rtw_spinlock_bh(&(pstapriv->sta_hash_lock));
rtw_list_delete(&psta->hash_list);
pstapriv->asoc_sta_count--;
_rtw_spinunlock_bh(&(pstapriv->sta_hash_lock));
rtw_mi_update_iface_status(&(padapter->mlmepriv), 0);
} else {
_rtw_spinlock_bh(&psta->lock);
psta->state = WIFI_FW_PRE_LINK;
_rtw_spinunlock_bh(&psta->lock);
}
#else
_rtw_spinlock_bh(&(pstapriv->sta_hash_lock));
rtw_list_delete(&psta->hash_list);
pstapriv->asoc_sta_count--;
_rtw_spinunlock_bh(&(pstapriv->sta_hash_lock));
rtw_mi_update_iface_status(&(padapter->mlmepriv), 0);
#endif
_rtw_spinlock_bh(&psta->lock);
psta->state &= ~WIFI_ASOC_STATE;
_rtw_spinunlock_bh(&psta->lock);
pfree_sta_queue = &pstapriv->free_sta_queue;
pstaxmitpriv = &psta->sta_xmitpriv;
/* rtw_list_delete(&psta->sleep_list); */
/* rtw_list_delete(&psta->wakeup_list); */
rtw_free_xmitframe_queue(pxmitpriv, &psta->tx_queue);
_rtw_deinit_queue(&psta->tx_queue);
_rtw_spinlock_bh(&pxmitpriv->lock);
rtw_free_xmitframe_queue(pxmitpriv, &psta->sleep_q);
psta->sleepq_len = 0;
/* vo */
/* _rtw_spinlock_bh(&(pxmitpriv->vo_pending.lock)); */
rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vo_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->vo_q.tx_pending));
phwxmit = pxmitpriv->hwxmits;
phwxmit->accnt -= pstaxmitpriv->vo_q.qcnt;
pending_qcnt[0] = pstaxmitpriv->vo_q.qcnt;
pstaxmitpriv->vo_q.qcnt = 0;
/* _rtw_spinunlock_bh(&(pxmitpriv->vo_pending.lock)); */
/* vi */
/* _rtw_spinlock_bh(&(pxmitpriv->vi_pending.lock)); */
rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vi_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->vi_q.tx_pending));
phwxmit = pxmitpriv->hwxmits + 1;
phwxmit->accnt -= pstaxmitpriv->vi_q.qcnt;
pending_qcnt[1] = pstaxmitpriv->vi_q.qcnt;
pstaxmitpriv->vi_q.qcnt = 0;
/* _rtw_spinunlock_bh(&(pxmitpriv->vi_pending.lock)); */
/* be */
/* _rtw_spinlock_bh(&(pxmitpriv->be_pending.lock)); */
rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->be_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
phwxmit = pxmitpriv->hwxmits + 2;
phwxmit->accnt -= pstaxmitpriv->be_q.qcnt;
pending_qcnt[2] = pstaxmitpriv->be_q.qcnt;
pstaxmitpriv->be_q.qcnt = 0;
/* _rtw_spinunlock_bh(&(pxmitpriv->be_pending.lock)); */
/* bk */
/* _rtw_spinlock_bh(&(pxmitpriv->bk_pending.lock)); */
rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->bk_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->bk_q.tx_pending));
phwxmit = pxmitpriv->hwxmits + 3;
phwxmit->accnt -= pstaxmitpriv->bk_q.qcnt;
pending_qcnt[3] = pstaxmitpriv->bk_q.qcnt;
pstaxmitpriv->bk_q.qcnt = 0;
/* _rtw_spinunlock_bh(&(pxmitpriv->bk_pending.lock)); */
rtw_os_wake_queue_at_free_stainfo(padapter, pending_qcnt);
_rtw_spinunlock_bh(&pxmitpriv->lock);
/* re-init sta_info; 20061114 */ /* will be init in alloc_stainfo */
/* _rtw_init_sta_xmit_priv(&psta->sta_xmitpriv); */
/* _rtw_init_sta_recv_priv(&psta->sta_recvpriv); */
#ifdef CONFIG_IEEE80211W
_cancel_timer_ex(&psta->dot11w_expire_timer);
#endif /* CONFIG_IEEE80211W */
_cancel_timer_ex(&psta->addba_retry_timer);
#ifdef CONFIG_TDLS
psta->tdls_sta_state = TDLS_STATE_NONE;
#endif /* CONFIG_TDLS */
/* for A-MPDU Rx reordering buffer control, cancel reordering_ctrl_timer */
for (i = 0; i < 16 ; i++) {
preorder_ctrl = &psta->recvreorder_ctrl[i];
rtw_clear_bit(RTW_RECV_ACK_OR_TIMEOUT, &preorder_ctrl->rec_abba_rsp_ack);
#ifdef CONFIG_RECV_REORDERING_CTRL
_list *phead, *plist;
union recv_frame *prframe;
_queue *ppending_recvframe_queue;
_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);
ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
_rtw_spinlock_bh(&ppending_recvframe_queue->lock);
phead = get_list_head(ppending_recvframe_queue);
plist = get_next(phead);
while (!rtw_is_list_empty(phead)) {
prframe = LIST_CONTAINOR(plist, union recv_frame, u);
plist = get_next(plist);
rtw_list_delete(&(prframe->u.hdr.list));
rtw_free_recvframe(prframe);
}
_rtw_spinunlock_bh(&ppending_recvframe_queue->lock);
#endif /*CONFIG_RECV_REORDERING_CTRL*/
}
/* CVE-2020-24586, clear defrag queue */
{
_list *phead, *plist;
_queue *pfree_sta_queue, *pdefrag_q = &psta->sta_recvpriv.defrag_q;
union recv_frame *prframe;
_rtw_spinlock_bh(&pdefrag_q->lock);
phead = get_list_head(pdefrag_q);
plist = get_next(phead);
while (!rtw_is_list_empty(phead)) {
prframe = LIST_CONTAINOR(plist, union recv_frame, u);
plist = get_next(plist);
rtw_list_delete(&(prframe->u.hdr.list));
rtw_free_recvframe(prframe);
}
_rtw_spinunlock_bh(&pdefrag_q->lock);
}
#ifdef CONFIG_AP_MODE
/*
_rtw_spinlock_bh(&pstapriv->asoc_list_lock);
rtw_list_delete(&psta->asoc_list);
_rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
*/
_rtw_spinlock_bh(&pstapriv->auth_list_lock);
if (!rtw_is_list_empty(&psta->auth_list)) {
rtw_list_delete(&psta->auth_list);
pstapriv->auth_list_cnt--;
}
_rtw_spinunlock_bh(&pstapriv->auth_list_lock);
psta->expire_to = 0;
#ifdef CONFIG_ATMEL_RC_PATCH
psta->flag_atmel_rc = 0;
#endif
psta->sleepq_ac_len = 0;
psta->qos_info = 0;
psta->max_sp_len = 0;
psta->uapsd_bk = 0;
psta->uapsd_be = 0;
psta->uapsd_vi = 0;
psta->uapsd_vo = 0;
psta->has_legacy_ac = 0;
#ifdef CONFIG_NATIVEAP_MLME
if (pmlmeinfo->state == _HW_STATE_AP_) {
rtw_tim_map_clear(padapter, pstapriv->sta_dz_bitmap, psta->phl_sta->aid);
rtw_tim_map_clear(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
/* rtw_indicate_sta_disassoc_event(padapter, psta); */
if ((psta->phl_sta->aid > 0) && (pstapriv->sta_aid[psta->phl_sta->aid - 1] == psta)) {
pstapriv->sta_aid[psta->phl_sta->aid - 1] = NULL;
psta->phl_sta->aid = 0;
}
}
#endif /* CONFIG_NATIVEAP_MLME */
#if !defined(CONFIG_ACTIVE_KEEP_ALIVE_CHECK) && defined(CONFIG_80211N_HT)
psta->under_exist_checking = 0;
#endif
#ifdef CONFIG_RTW_80211R_AP
rtw_ft_peer_info_free(psta);
#endif
#endif /* CONFIG_AP_MODE */
rtw_st_ctl_deinit(&psta->st_ctl);
if (is_pre_link_sta == _FALSE) {
_rtw_spinlock_free(&psta->lock);
/* _rtw_spinlock_bh(&(pfree_sta_queue->lock)); */
_rtw_spinlock_bh(&(pstapriv->sta_hash_lock));
rtw_list_insert_tail(&psta->list, get_list_head(pfree_sta_queue));
_rtw_spinunlock_bh(&(pstapriv->sta_hash_lock));
/* _rtw_spinunlock_bh(&(pfree_sta_queue->lock)); */
}
exit:
return _SUCCESS;
}
static void _rtw_free_phl_stainfo(_adapter *adapter, struct sta_info *sta, u8 only_free_sw)
{
void *phl = GET_PHL_INFO(adapter_to_dvobj(adapter));
enum rtw_phl_status pstaus = RTW_PHL_STATUS_SUCCESS;
u8 hwaddr[ETH_ALEN] = {0};
bool alloc = _FALSE, only_hw = _FALSE;
if (sta != NULL) {
_rtw_memcpy(hwaddr, sta->phl_sta->mac_addr, ETH_ALEN);
if (only_free_sw)
pstaus = rtw_phl_free_stainfo_sw(phl, sta->phl_sta);
else
pstaus = rtw_phl_cmd_alloc_stainfo(phl, &sta->phl_sta,
sta->phl_sta->mac_addr,
adapter->phl_role,
alloc, only_hw,
PHL_CMD_DIRECTLY, 0);
if (pstaus != RTW_PHL_STATUS_SUCCESS)
RTW_ERR(FUNC_ADPT_FMT ": fail to free PHL sta "
"for " MAC_FMT " (status=%d)!\n",
FUNC_ADPT_ARG(adapter),
MAC_ARG(hwaddr),
pstaus);
else
/* free stainfo success, set pointer to NULL */
sta->phl_sta = NULL;
}
}
u32 rtw_free_stainfo(_adapter *padapter, struct sta_info *psta)
{
_rtw_free_core_stainfo(padapter, psta);
_rtw_free_phl_stainfo(padapter, psta, _FALSE);
return _SUCCESS;
}
u32 rtw_free_stainfo_sw(_adapter *padapter, struct sta_info *psta)
{
_rtw_free_core_stainfo(padapter, psta);
_rtw_free_phl_stainfo(padapter, psta, _TRUE);
return _SUCCESS;
}
/* free all stainfo which in sta_hash[all] */
void rtw_free_all_stainfo(_adapter *padapter)
{
_list *plist, *phead;
s32 index;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *pbcmc_stainfo = rtw_get_bcmc_stainfo(padapter);
u8 free_sta_num = 0;
char free_sta_list[NUM_STA];
int stainfo_offset;
if (pstapriv->asoc_sta_count == 1)
goto exit;
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < NUM_STA; index++) {
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info , hash_list);
plist = get_next(plist);
if (pbcmc_stainfo != psta) {
#if CONFIG_RTW_PRE_LINK_STA
if (rtw_is_pre_link_sta(pstapriv, psta->phl_sta->mac_addr) == _FALSE)
#endif
rtw_list_delete(&psta->hash_list);
stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
if (stainfo_offset_valid(stainfo_offset))
free_sta_list[free_sta_num++] = stainfo_offset;
}
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < free_sta_num; index++) {
psta = rtw_get_stainfo_by_offset(pstapriv, free_sta_list[index]);
rtw_free_stainfo(padapter , psta);
}
exit:
return;
}
/* any station allocated can be searched by hash list */
struct sta_info *rtw_get_stainfo(struct sta_priv *pstapriv, const u8 *hwaddr)
{
_list *plist, *phead;
struct sta_info *psta = NULL;
struct rtw_phl_stainfo_t *phl_sta_self = NULL;
void *phl = GET_PHL_INFO(adapter_to_dvobj(pstapriv->padapter));
struct rtw_wifi_role_t *phl_role;
u32 index;
if (hwaddr == NULL)
return NULL;
if (pstapriv->padapter->phl_role == NULL) {
RTW_ERR(FUNC_ADPT_FMT" phl_role == NULL\n", FUNC_ADPT_ARG(pstapriv->padapter));
rtw_warn_on(1);
return NULL;
}
phl_role = pstapriv->padapter->phl_role;
/* if addr is bcmc addr, return self phl_sta */
if (IS_MCAST(hwaddr)) {
phl_sta_self = rtw_phl_get_stainfo_self(phl, phl_role);
if (phl_sta_self == NULL) {
RTW_INFO("%s: get phl sta self fail", __func__);
return NULL;
}
/*
due to using self sta to replace bcmc sta
change index to self hash index
*/
index = wifi_mac_hash(phl_role->mac_addr);
} else {
/*
for sta mode due to self sta info & AP sta info are the same sta info
using self hash index for sta mode, or bmc sta will not found self sta
*/
switch (phl_role->type) {
case PHL_RTYPE_NONE:
case PHL_RTYPE_STATION:
case PHL_RTYPE_ADHOC:
case PHL_RTYPE_P2P_DEVICE:
case PHL_RTYPE_P2P_GC:
index = wifi_mac_hash(phl_role->mac_addr);
break;
default:
index = wifi_mac_hash(hwaddr);
break;
}
}
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
if (psta->phl_sta == NULL) {
psta = NULL;
RTW_ERR("phl_sta of sta is NULL\n");
plist = get_next(plist);
continue;
}
/* if add is bcmc addr, find matched self phl_sta, and return */
if (IS_MCAST(hwaddr) && psta->phl_sta == phl_sta_self)
break;
/* if add is not bcmc addr, compare mac_addr */
if ((_rtw_memcmp(psta->phl_sta->mac_addr, hwaddr, ETH_ALEN)) == _TRUE) {
/* if found the matched address */
break;
}
psta = NULL;
plist = get_next(plist);
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
return psta;
}
u32 rtw_free_self_stainfo(_adapter *adapter)
{
struct sta_info *sta = NULL;
struct sta_priv *stapriv = &adapter->stapriv;
sta = rtw_get_stainfo(stapriv, adapter->phl_role->mac_addr);
if (sta != NULL) {
_rtw_free_core_stainfo(adapter, sta);
_rtw_free_phl_stainfo(adapter, sta, _FALSE);
}
return _SUCCESS;
}
u32 rtw_init_self_stainfo(_adapter *padapter)
{
struct sta_info *psta;
struct tx_servq *ptxservq;
u32 res = _SUCCESS;
struct sta_priv *pstapriv = &padapter->stapriv;
psta = rtw_get_stainfo(pstapriv, padapter->phl_role->mac_addr);
if (psta == NULL) {
psta = rtw_alloc_stainfo(pstapriv, padapter->phl_role->mac_addr);
if (psta == NULL) {
RTW_ERR("%s alloc self sta fail\n", __func__);
res = _FAIL;
goto exit;
}
}
exit:
return res;
}
struct sta_info *rtw_get_bcmc_stainfo(_adapter *padapter)
{
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
psta = rtw_get_stainfo(pstapriv, bc_addr);
return psta;
}
#ifdef CONFIG_AP_MODE
u16 rtw_aid_alloc(_adapter *adapter, struct sta_info *sta)
{
struct sta_priv *stapriv = &adapter->stapriv;
u16 aid, i, used_cnt = 0;
for (i = 0; i < stapriv->max_aid; i++) {
aid = ((i + stapriv->started_aid - 1) % stapriv->max_aid) + 1;
if (stapriv->sta_aid[aid - 1] == NULL)
break;
if (++used_cnt >= stapriv->max_num_sta)
break;
}
/* check for aid limit and assoc limit */
if (i >= stapriv->max_aid || used_cnt >= stapriv->max_num_sta)
aid = 0;
sta->phl_sta->aid = aid;
if (aid) {
stapriv->sta_aid[aid - 1] = sta;
if (stapriv->rr_aid)
stapriv->started_aid = (aid % stapriv->max_aid) + 1;
}
return aid;
}
void dump_aid_status(void *sel, _adapter *adapter)
{
struct sta_priv *stapriv = &adapter->stapriv;
u8 *aid_bmp;
u16 i, used_cnt = 0;
aid_bmp = rtw_zmalloc(stapriv->aid_bmp_len);
if (!aid_bmp)
return;
for (i = 1; i <= stapriv->max_aid; i++) {
if (stapriv->sta_aid[i - 1]) {
aid_bmp[i / 8] |= BIT(i % 8);
++used_cnt;
}
}
RTW_PRINT_SEL(sel, "used_cnt:%u/%u\n", used_cnt, stapriv->max_aid);
RTW_MAP_DUMP_SEL(sel, "aid_map:", aid_bmp, stapriv->aid_bmp_len);
RTW_PRINT_SEL(sel, "\n");
RTW_PRINT_SEL(sel, "%-2s %-11s\n", "rr", "started_aid");
RTW_PRINT_SEL(sel, "%2d %11d\n", stapriv->rr_aid, stapriv->started_aid);
rtw_mfree(aid_bmp, stapriv->aid_bmp_len);
}
#endif /* CONFIG_AP_MODE */
#if CONFIG_RTW_MACADDR_ACL
const char *const _acl_period_str[RTW_ACL_PERIOD_NUM] = {
"DEV",
"BSS",
};
const char *const _acl_mode_str[RTW_ACL_MODE_MAX] = {
"DISABLED",
"ACCEPT_UNLESS_LISTED",
"DENY_UNLESS_LISTED",
};
u8 _rtw_access_ctrl(_adapter *adapter, u8 period, const u8 *mac_addr)
{
u8 res = _TRUE;
_list *list, *head;
struct rtw_wlan_acl_node *acl_node;
u8 match = _FALSE;
struct sta_priv *stapriv = &adapter->stapriv;
struct wlan_acl_pool *acl;
_queue *acl_node_q;
if (period >= RTW_ACL_PERIOD_NUM) {
rtw_warn_on(1);
goto exit;
}
acl = &stapriv->acl_list[period];
acl_node_q = &acl->acl_node_q;
if (acl->mode != RTW_ACL_MODE_ACCEPT_UNLESS_LISTED
&& acl->mode != RTW_ACL_MODE_DENY_UNLESS_LISTED)
goto exit;
_rtw_spinlock_bh(&(acl_node_q->lock));
head = get_list_head(acl_node_q);
list = get_next(head);
while (rtw_end_of_queue_search(head, list) == _FALSE) {
acl_node = LIST_CONTAINOR(list, struct rtw_wlan_acl_node, list);
list = get_next(list);
if (_rtw_memcmp(acl_node->addr, mac_addr, ETH_ALEN)) {
if (acl_node->valid == _TRUE) {
match = _TRUE;
break;
}
}
}
_rtw_spinunlock_bh(&(acl_node_q->lock));
if (acl->mode == RTW_ACL_MODE_ACCEPT_UNLESS_LISTED)
res = (match == _TRUE) ? _FALSE : _TRUE;
else /* RTW_ACL_MODE_DENY_UNLESS_LISTED */
res = (match == _TRUE) ? _TRUE : _FALSE;
exit:
return res;
}
u8 rtw_access_ctrl(_adapter *adapter, const u8 *mac_addr)
{
int i;
for (i = 0; i < RTW_ACL_PERIOD_NUM; i++)
if (_rtw_access_ctrl(adapter, i, mac_addr) == _FALSE)
return _FALSE;
return _TRUE;
}
void dump_macaddr_acl(void *sel, _adapter *adapter)
{
struct sta_priv *stapriv = &adapter->stapriv;
struct wlan_acl_pool *acl;
int i, j;
for (j = 0; j < RTW_ACL_PERIOD_NUM; j++) {
RTW_PRINT_SEL(sel, "period:%s(%d)\n", acl_period_str(j), j);
acl = &stapriv->acl_list[j];
RTW_PRINT_SEL(sel, "mode:%s(%d)\n", acl_mode_str(acl->mode), acl->mode);
RTW_PRINT_SEL(sel, "num:%d/%d\n", acl->num, NUM_ACL);
for (i = 0; i < NUM_ACL; i++) {
if (acl->aclnode[i].valid == _FALSE)
continue;
RTW_PRINT_SEL(sel, MAC_FMT"\n", MAC_ARG(acl->aclnode[i].addr));
}
RTW_PRINT_SEL(sel, "\n");
}
}
#endif /* CONFIG_RTW_MACADDR_ACL */
#if CONFIG_RTW_PRE_LINK_STA
bool rtw_is_pre_link_sta(struct sta_priv *stapriv, u8 *addr)
{
struct pre_link_sta_ctl_t *pre_link_sta_ctl = &stapriv->pre_link_sta_ctl;
struct sta_info *sta = NULL;
u8 exist = _FALSE;
int i;
_rtw_spinlock_bh(&(pre_link_sta_ctl->lock));
for (i = 0; i < RTW_PRE_LINK_STA_NUM; i++) {
if (pre_link_sta_ctl->node[i].valid == _TRUE
&& _rtw_memcmp(pre_link_sta_ctl->node[i].addr, addr, ETH_ALEN) == _TRUE
) {
exist = _TRUE;
break;
}
}
_rtw_spinunlock_bh(&(pre_link_sta_ctl->lock));
return exist;
}
#endif
#if CONFIG_RTW_PRE_LINK_STA
struct sta_info *rtw_pre_link_sta_add(struct sta_priv *stapriv, u8 *hwaddr)
{
struct pre_link_sta_ctl_t *pre_link_sta_ctl = &stapriv->pre_link_sta_ctl;
struct pre_link_sta_node_t *node = NULL;
struct sta_info *sta = NULL;
u8 exist = _FALSE;
int i;
if (rtw_check_invalid_mac_address(hwaddr, _FALSE) == _TRUE)
goto exit;
_rtw_spinlock_bh(&(pre_link_sta_ctl->lock));
for (i = 0; i < RTW_PRE_LINK_STA_NUM; i++) {
if (pre_link_sta_ctl->node[i].valid == _TRUE
&& _rtw_memcmp(pre_link_sta_ctl->node[i].addr, hwaddr, ETH_ALEN) == _TRUE
) {
node = &pre_link_sta_ctl->node[i];
exist = _TRUE;
break;
}
if (node == NULL && pre_link_sta_ctl->node[i].valid == _FALSE)
node = &pre_link_sta_ctl->node[i];
}
if (exist == _FALSE && node) {
_rtw_memcpy(node->addr, hwaddr, ETH_ALEN);
node->valid = _TRUE;
pre_link_sta_ctl->num++;
}
_rtw_spinunlock_bh(&(pre_link_sta_ctl->lock));
if (node == NULL)
goto exit;
sta = rtw_alloc_stainfo(stapriv, hwaddr);
if (!sta)
goto exit;
sta->state = WIFI_FW_PRE_LINK;
exit:
return sta;
}
void rtw_pre_link_sta_del(struct sta_priv *stapriv, u8 *hwaddr)
{
struct pre_link_sta_ctl_t *pre_link_sta_ctl = &stapriv->pre_link_sta_ctl;
struct pre_link_sta_node_t *node = NULL;
struct sta_info *sta = NULL;
u8 exist = _FALSE;
int i;
if (rtw_check_invalid_mac_address(hwaddr, _FALSE) == _TRUE)
goto exit;
_rtw_spinlock_bh(&(pre_link_sta_ctl->lock));
for (i = 0; i < RTW_PRE_LINK_STA_NUM; i++) {
if (pre_link_sta_ctl->node[i].valid == _TRUE
&& _rtw_memcmp(pre_link_sta_ctl->node[i].addr, hwaddr, ETH_ALEN) == _TRUE
) {
node = &pre_link_sta_ctl->node[i];
exist = _TRUE;
break;
}
}
if (exist == _TRUE && node) {
node->valid = _FALSE;
pre_link_sta_ctl->num--;
}
_rtw_spinunlock_bh(&(pre_link_sta_ctl->lock));
if (exist == _FALSE)
goto exit;
sta = rtw_get_stainfo(stapriv, hwaddr);
if (!sta)
goto exit;
if (sta->state == WIFI_FW_PRE_LINK)
rtw_free_stainfo(stapriv->padapter, sta);
exit:
return;
}
void rtw_pre_link_sta_ctl_reset(struct sta_priv *stapriv)
{
struct pre_link_sta_ctl_t *pre_link_sta_ctl = &stapriv->pre_link_sta_ctl;
struct pre_link_sta_node_t *node = NULL;
struct sta_info *sta = NULL;
int i, j = 0;
u8 addrs[RTW_PRE_LINK_STA_NUM][ETH_ALEN];
_rtw_memset(addrs, 0, RTW_PRE_LINK_STA_NUM * ETH_ALEN);
_rtw_spinlock_bh(&(pre_link_sta_ctl->lock));
for (i = 0; i < RTW_PRE_LINK_STA_NUM; i++) {
if (pre_link_sta_ctl->node[i].valid == _FALSE)
continue;
_rtw_memcpy(&(addrs[j][0]), pre_link_sta_ctl->node[i].addr, ETH_ALEN);
pre_link_sta_ctl->node[i].valid = _FALSE;
pre_link_sta_ctl->num--;
j++;
}
_rtw_spinunlock_bh(&(pre_link_sta_ctl->lock));
for (i = 0; i < j; i++) {
sta = rtw_get_stainfo(stapriv, &(addrs[i][0]));
if (!sta)
continue;
if (sta->state == WIFI_FW_PRE_LINK)
rtw_free_stainfo(stapriv->padapter, sta);
}
}
void rtw_pre_link_sta_ctl_init(struct sta_priv *stapriv)
{
struct pre_link_sta_ctl_t *pre_link_sta_ctl = &stapriv->pre_link_sta_ctl;
int i;
_rtw_spinlock_init(&pre_link_sta_ctl->lock);
pre_link_sta_ctl->num = 0;
for (i = 0; i < RTW_PRE_LINK_STA_NUM; i++)
pre_link_sta_ctl->node[i].valid = _FALSE;
}
void rtw_pre_link_sta_ctl_deinit(struct sta_priv *stapriv)
{
struct pre_link_sta_ctl_t *pre_link_sta_ctl = &stapriv->pre_link_sta_ctl;
int i;
rtw_pre_link_sta_ctl_reset(stapriv);
_rtw_spinlock_free(&pre_link_sta_ctl->lock);
}
void dump_pre_link_sta_ctl(void *sel, struct sta_priv *stapriv)
{
struct pre_link_sta_ctl_t *pre_link_sta_ctl = &stapriv->pre_link_sta_ctl;
int i;
RTW_PRINT_SEL(sel, "num:%d/%d\n", pre_link_sta_ctl->num, RTW_PRE_LINK_STA_NUM);
for (i = 0; i < RTW_PRE_LINK_STA_NUM; i++) {
if (pre_link_sta_ctl->node[i].valid == _FALSE)
continue;
RTW_PRINT_SEL(sel, MAC_FMT"\n", MAC_ARG(pre_link_sta_ctl->node[i].addr));
}
}
#endif /* CONFIG_RTW_PRE_LINK_STA */
|
2301_81045437/rtl8852be
|
core/rtw_sta_mgt.c
|
C
|
agpl-3.0
| 42,418
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#include <aes.h>
#include <aes_siv.h>
#include <aes_wrap.h>
#include <sha256.h>
#include <wlancrypto_wrap.h>
#if 0 //RTW_PHL_TX: mark un-finished codes for reading
int _rtw_core_ccmp_encrypt(u8 *key, u32 key_len, uint hdrlen, u8 *phdr, uint datalen, u8 *pdata)
{
u8 *enc = NULL;
size_t enc_len = 0;
if (key_len == 16) { /* 128 bits */
core_ccmp_encrypt(key,
hdrlen, phdr,
datalen, pdata,
(hdrlen == 26) ? (phdr + hdrlen - 2) : NULL,
NULL, 0, &enc_len);
} else if (key_len == 32) { /* 256 bits */
core_ccmp_256_encrypt(key,
hdrlen, phdr,
datalen, pdata,
(hdrlen == 26) ? (phdr + hdrlen - 2) : NULL,
NULL, 0, &enc_len);
}
return _SUCCESS;
}
#endif
/**
* rtw_ccmp_encrypt -
* @key: the temporal key
* @hdrlen: mac header length
* @frame: the frame including the mac header, pn and payload
* @plen: payload length, i.e., length of the plain text, without PN and MIC
*/
int _rtw_ccmp_encrypt(_adapter *padapter, u8 *key, u32 key_len, uint hdrlen, u8 *frame, uint plen)
{
u8 *enc = NULL;
size_t enc_len = 0;
if (key_len == 16) { /* 128 bits */
enc = ccmp_encrypt(padapter, key,
frame,
hdrlen + plen,
hdrlen,
(hdrlen == 26) ? (frame + hdrlen - 2) : NULL,
NULL, 0, &enc_len);
} else if (key_len == 32) { /* 256 bits */
enc = ccmp_256_encrypt(padapter, key,
frame,
hdrlen + plen,
hdrlen,
(hdrlen == 26) ? (frame + hdrlen - 2) : NULL,
NULL, 0, &enc_len);
}
if (enc == NULL) {
RTW_INFO("Failed to encrypt CCMP(%u) frame", key_len);
return _FAIL;
}
/* Copy @enc back to @frame and free @enc */
_rtw_memcpy(frame, enc, enc_len);
rtw_mfree(enc, enc_len + AES_BLOCK_SIZE);
return _SUCCESS;
}
/**
* rtw_ccmp_decrypt -
* @key: the temporal key
* @hdrlen: length of the mac header
* @frame: the raw frame (@hdrlen + PN + enc_data + MIC)
* @plen: length of the frame (@hdrlen + PN + enc_data + MIC)
*/
int _rtw_ccmp_decrypt(_adapter * padapter, u8 *key, u32 key_len, uint hdrlen, u8 *frame,
uint plen)
{
u8 *plain = NULL;
size_t plain_len = 0;
const struct ieee80211_hdr *hdr;
hdr = (const struct ieee80211_hdr *)frame;
if (key_len == 16) { /* 128 bits */
plain = ccmp_decrypt(padapter, key,
hdr,
frame + hdrlen, /* PN + enc_data + MIC */
plen - hdrlen, /* PN + enc_data + MIC */
&plain_len);
} else if (key_len == 32) { /* 256 bits */
plain = ccmp_256_decrypt(padapter, key,
hdr,
frame + hdrlen, /* PN + enc_data + MIC */
plen - hdrlen, /* PN + enc_data + MIC */
&plain_len);
}
if (plain == NULL) {
RTW_INFO("Failed to decrypt CCMP(%u) frame", key_len);
return _FAIL;
}
/* Copy @plain back to @frame and free @plain */
_rtw_memcpy(frame + hdrlen + 8, plain, plain_len);
rtw_mfree(plain, plen - hdrlen + AES_BLOCK_SIZE);
RTW_DBG_DUMP("ccmp_decrypt(): decrypted frame\n",
frame, hdrlen + 8 + plen);
return _SUCCESS;
}
#ifdef CONFIG_RTW_MESH_AEK
/* wrapper to ase_siv_encrypt and aes_siv_decrypt */
int _aes_siv_encrypt(const u8 *key, size_t key_len,
const u8 *pw, size_t pwlen,
size_t num_elem, const u8 *addr[], const size_t *len, u8 *out)
{
return aes_siv_encrypt(key, key_len, pw, pwlen, num_elem, addr, len, out);
}
int _aes_siv_decrypt(const u8 *key, size_t key_len,
const u8 *iv_crypt, size_t iv_c_len,
size_t num_elem, const u8 *addr[], const size_t *len, u8 *out)
{
return aes_siv_decrypt(key, key_len, iv_crypt, iv_c_len, num_elem, addr, len, out);
}
#endif
/**
* _rtw_gcmp_encrypt -
* @key: the temporal key
* @hdrlen: mac header length
* @frame: the frame including the mac header, pn and payload
* @plen: payload length, i.e., length of the plain text, without PN and MIC
*/
int _rtw_gcmp_encrypt(_adapter * padapter, u8 *key, u32 key_len, uint hdrlen, u8 *frame, uint plen)
{
u8 *enc = NULL;
size_t enc_len = 0;
enc = gcmp_encrypt(padapter, key, key_len,
frame,
hdrlen + plen,
hdrlen,
(hdrlen == 26) ? (frame + hdrlen - 2) : NULL,
NULL, 0, &enc_len);
if (enc == NULL) {
RTW_INFO("Failed to encrypt GCMP frame");
return _FAIL;
}
/* Copy @enc back to @frame and free @enc */
_rtw_memcpy(frame, enc, enc_len);
rtw_mfree(enc, enc_len + AES_BLOCK_SIZE);
return _SUCCESS;
}
/**
* _rtw_gcmp_decrypt -
* @key: the temporal key
* @hdrlen: length of the mac header
* @frame: the raw frame (@hdrlen + PN + enc_data + MIC)
* @plen: length of the frame (@hdrlen + PN + enc_data + MIC)
*/
int _rtw_gcmp_decrypt(_adapter *padapter, u8 *key, u32 key_len, uint hdrlen, u8 *frame, uint plen)
{
u8 *plain = NULL;
size_t plain_len = 0;
const struct ieee80211_hdr *hdr;
hdr = (const struct ieee80211_hdr *)frame;
plain = gcmp_decrypt(padapter, key, key_len,
hdr,
frame + hdrlen, /* PN + enc_data + MIC */
plen - hdrlen, /* PN + enc_data + MIC */
&plain_len);
if (plain == NULL) {
RTW_INFO("Failed to decrypt GCMP(%u) frame", key_len);
return _FAIL;
}
/* Copy @plain back to @frame and free @plain */
_rtw_memcpy(frame + hdrlen + 8, plain, plain_len);
rtw_mfree(plain, plen - hdrlen + AES_BLOCK_SIZE);
RTW_DBG_DUMP("gcmp_decipher(): decrypted frame\n",
frame, hdrlen + 8 + plen);
return _SUCCESS;
}
#if defined(CONFIG_IEEE80211W) | defined(CONFIG_TDLS)
u8 _bip_ccmp_protect(const u8 *key, size_t key_len,
const u8 *data, size_t data_len, u8 *mic)
{
u8 res = _SUCCESS;
if (key_len == 16) {
if (omac1_aes_128(key, data, data_len, mic)) {
res = _FAIL;
RTW_ERR("%s : omac1_aes_128 fail!", __func__);
}
} else if (key_len == 32) {
if (omac1_aes_256(key, data, data_len, mic)) {
res = _FAIL;
RTW_ERR("%s : omac1_aes_256 fail!", __func__);
}
} else {
RTW_ERR("%s : key_len not match!", __func__);
res = _FAIL;
}
return res;
}
u8 _bip_gcmp_protect(u8 *whdr_pos, size_t len,
const u8 *key, size_t key_len,
const u8 *data, size_t data_len, u8 *mic)
{
u8 res = _SUCCESS;
u32 mic_len = 16;
u8 nonce[12], *npos;
const u8 *gcmp_ipn;
gcmp_ipn = whdr_pos + len - mic_len - 6;
/* Nonce: A2 | IPN */
_rtw_memcpy(nonce, get_addr2_ptr(whdr_pos), ETH_ALEN);
npos = nonce + ETH_ALEN;
*npos++ = gcmp_ipn[5];
*npos++ = gcmp_ipn[4];
*npos++ = gcmp_ipn[3];
*npos++ = gcmp_ipn[2];
*npos++ = gcmp_ipn[1];
*npos++ = gcmp_ipn[0];
if (aes_gmac(key, key_len, nonce, sizeof(nonce),
data, data_len, mic)) {
res = _FAIL;
RTW_ERR("%s : aes_gmac fail!", __func__);
}
return res;
}
#endif /* CONFIG_IEEE80211W */
#ifdef CONFIG_TDLS
void _tdls_generate_tpk(void *sta, const u8 *own_addr, const u8 *bssid)
{
struct sta_info *psta = (struct sta_info *)sta;
u8 *SNonce = psta->SNonce;
u8 *ANonce = psta->ANonce;
u8 key_input[SHA256_MAC_LEN];
const u8 *nonce[2];
size_t len[2];
u8 data[3 * ETH_ALEN];
/* IEEE Std 802.11z-2010 8.5.9.1:
* TPK-Key-Input = SHA-256(min(SNonce, ANonce) || max(SNonce, ANonce))
*/
len[0] = 32;
len[1] = 32;
if (_rtw_memcmp2(SNonce, ANonce, 32) < 0) {
nonce[0] = SNonce;
nonce[1] = ANonce;
} else {
nonce[0] = ANonce;
nonce[1] = SNonce;
}
sha256_vector(2, nonce, len, key_input);
/*
* TPK = KDF-Hash-Length(TPK-Key-Input, "TDLS PMK",
* min(MAC_I, MAC_R) || max(MAC_I, MAC_R) || BSSID)
*/
if (_rtw_memcmp2(own_addr, psta->phl_sta->mac_addr, ETH_ALEN) < 0) {
_rtw_memcpy(data, own_addr, ETH_ALEN);
_rtw_memcpy(data + ETH_ALEN, psta->phl_sta->mac_addr, ETH_ALEN);
} else {
_rtw_memcpy(data, psta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(data + ETH_ALEN, own_addr, ETH_ALEN);
}
_rtw_memcpy(data + 2 * ETH_ALEN, bssid, ETH_ALEN);
sha256_prf(key_input, SHA256_MAC_LEN, "TDLS PMK", data, sizeof(data), (u8 *)&psta->tpk, sizeof(psta->tpk));
}
#endif /* CONFIG_TDLS */
|
2301_81045437/rtl8852be
|
core/rtw_swcrypto.c
|
C
|
agpl-3.0
| 8,265
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_TDLS_C_
#include <drv_types.h>
#ifdef CONFIG_TDLS
#define ONE_SEC 1000 /* 1000 ms */
extern unsigned char MCS_rate_2R[16];
extern unsigned char MCS_rate_1R[16];
inline void rtw_tdls_set_link_established(_adapter *adapter, bool en)
{
adapter->tdlsinfo.link_established = en;
rtw_mi_update_iface_status(&(adapter->mlmepriv), 0);
}
void rtw_reset_tdls_info(_adapter *padapter)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
ptdlsinfo->ap_prohibited = _FALSE;
/* For TDLS channel switch, currently we only allow it to work in wifi logo test mode */
if (padapter->registrypriv.wifi_spec == 1)
ptdlsinfo->ch_switch_prohibited = _FALSE;
else
ptdlsinfo->ch_switch_prohibited = _TRUE;
rtw_tdls_set_link_established(padapter, _FALSE);
ptdlsinfo->sta_cnt = 0;
ptdlsinfo->sta_maximum = _FALSE;
#ifdef CONFIG_TDLS_CH_SW
ptdlsinfo->chsw_info.ch_sw_state = TDLS_STATE_NONE;
ATOMIC_SET(&ptdlsinfo->chsw_info.chsw_on, _FALSE);
ptdlsinfo->chsw_info.off_ch_num = 0;
ptdlsinfo->chsw_info.ch_offset = CHAN_OFFSET_NO_EXT;
ptdlsinfo->chsw_info.cur_time = 0;
ptdlsinfo->chsw_info.delay_switch_back = _FALSE;
ptdlsinfo->chsw_info.dump_stack = _FALSE;
#endif
ptdlsinfo->ch_sensing = 0;
ptdlsinfo->watchdog_count = 0;
ptdlsinfo->dev_discovered = _FALSE;
#ifdef CONFIG_WFD
ptdlsinfo->wfd_info = &padapter->wfd_info;
#endif
ptdlsinfo->tdls_sctx = NULL;
}
int rtw_init_tdls_info(_adapter *padapter)
{
int res = _SUCCESS;
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
rtw_reset_tdls_info(padapter);
#ifdef CONFIG_TDLS_DRIVER_SETUP
ptdlsinfo->driver_setup = _TRUE;
#else
ptdlsinfo->driver_setup = _FALSE;
#endif /* CONFIG_TDLS_DRIVER_SETUP */
_rtw_spinlock_init(&ptdlsinfo->cmd_lock);
_rtw_spinlock_init(&ptdlsinfo->hdl_lock);
return res;
}
void rtw_free_tdls_info(struct tdls_info *ptdlsinfo)
{
_rtw_spinlock_free(&ptdlsinfo->cmd_lock);
_rtw_spinlock_free(&ptdlsinfo->hdl_lock);
_rtw_memset(ptdlsinfo, 0, sizeof(struct tdls_info));
}
void rtw_free_all_tdls_sta(_adapter *padapter, u8 enqueue_cmd)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
_list *plist, *phead;
s32 index;
struct sta_info *psta = NULL;
struct sta_info *ptdls_sta[NUM_STA];
u8 empty_hwaddr[ETH_ALEN] = { 0x00 };
_rtw_memset(ptdls_sta, 0x00, sizeof(ptdls_sta));
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < NUM_STA; index++) {
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
if (psta->tdls_sta_state != TDLS_STATE_NONE)
ptdls_sta[index] = psta;
}
}
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
for (index = 0; index < NUM_STA; index++) {
if (ptdls_sta[index]) {
struct TDLSoption_param tdls_param;
psta = ptdls_sta[index];
RTW_INFO("Do tear down to "MAC_FMT" by enqueue_cmd = %d\n", MAC_ARG(psta->phl_sta->mac_addr), enqueue_cmd);
_rtw_memcpy(&(tdls_param.addr), psta->phl_sta->mac_addr, ETH_ALEN);
tdls_param.option = TDLS_TEARDOWN_STA_NO_WAIT;
tdls_hdl(padapter, (unsigned char *)&(tdls_param));
rtw_tdls_teardown_pre_hdl(padapter, psta);
if (enqueue_cmd == _TRUE)
rtw_tdls_cmd(padapter, psta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
else
{
tdls_param.option = TDLS_TEARDOWN_STA_LOCALLY_POST;
tdls_hdl(padapter, (unsigned char *)&(tdls_param));
}
}
}
}
int check_ap_tdls_prohibited(u8 *pframe, u8 pkt_len)
{
u8 tdls_prohibited_bit = 0x40; /* bit(38); TDLS_prohibited */
if (pkt_len < 5)
return _FALSE;
pframe += 4;
if ((*pframe) & tdls_prohibited_bit)
return _TRUE;
return _FALSE;
}
int check_ap_tdls_ch_switching_prohibited(u8 *pframe, u8 pkt_len)
{
u8 tdls_ch_swithcing_prohibited_bit = 0x80; /* bit(39); TDLS_channel_switching prohibited */
if (pkt_len < 5)
return _FALSE;
pframe += 4;
if ((*pframe) & tdls_ch_swithcing_prohibited_bit)
return _TRUE;
return _FALSE;
}
u8 rtw_is_tdls_enabled(_adapter *padapter)
{
return padapter->registrypriv.en_tdls;
}
void rtw_set_tdls_enable(_adapter *padapter, u8 enable)
{
padapter->registrypriv.en_tdls = enable;
RTW_INFO("%s: en_tdls = %d\n", __func__, rtw_is_tdls_enabled(padapter));
}
void rtw_enable_tdls_func(_adapter *padapter)
{
if (rtw_is_tdls_enabled(padapter) == _TRUE)
return;
rtw_set_tdls_enable(padapter, _TRUE);
}
void rtw_disable_tdls_func(_adapter *padapter, u8 enqueue_cmd)
{
if (rtw_is_tdls_enabled(padapter) == _FALSE)
return;
rtw_free_all_tdls_sta(padapter, enqueue_cmd);
rtw_tdls_cmd(padapter, NULL, TDLS_RS_RCR);
rtw_reset_tdls_info(padapter);
rtw_set_tdls_enable(padapter, _FALSE);
}
u8 rtw_is_tdls_sta_existed(_adapter *padapter)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta;
int i = 0;
_list *plist, *phead;
u8 ret = _FALSE;
if (rtw_is_tdls_enabled(padapter) == _FALSE)
return _FALSE;
_rtw_spinlock_bh(&pstapriv->sta_hash_lock);
for (i = 0; i < NUM_STA; i++) {
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
plist = get_next(plist);
if (psta->tdls_sta_state != TDLS_STATE_NONE) {
ret = _TRUE;
goto Exit;
}
}
}
Exit:
_rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
return ret;
}
u8 rtw_tdls_is_setup_allowed(_adapter *padapter)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
if (is_client_associated_to_ap(padapter) == _FALSE)
return _FALSE;
if (ptdlsinfo->ap_prohibited == _TRUE)
return _FALSE;
return _TRUE;
}
#ifdef CONFIG_TDLS_CH_SW
u8 rtw_tdls_is_chsw_allowed(_adapter *padapter)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
if (ptdlsinfo->ch_switch_prohibited == _TRUE)
return _FALSE;
if (padapter->registrypriv.wifi_spec == 0)
return _FALSE;
return _TRUE;
}
#endif
int _issue_nulldata_to_TDLS_peer_STA(_adapter *padapter, unsigned char *da, unsigned int power_mode, int wait_ms)
{
int ret = _FAIL;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl, *qc;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->hdrlen += 2;
pattrib->qos_en = _TRUE;
pattrib->eosp = 1;
pattrib->ack_policy = 0;
pattrib->mdata = 0;
pattrib->retry_ctrl = _FALSE;
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
if (power_mode)
SetPwrMgt(fctrl);
qc = (unsigned short *)(pframe + pattrib->hdrlen - 2);
SetPriority(qc, 7); /* Set priority to VO */
SetEOSP(qc, pattrib->eosp);
SetAckpolicy(qc, pattrib->ack_policy);
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_QOS_DATA_NULL);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr_qos);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
pattrib->last_txcmdsz = pattrib->pktlen;
if (wait_ms)
ret = dump_mgntframe_and_wait_ack_timeout(padapter, pmgntframe, wait_ms);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
/*
*wait_ms == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
*wait_ms > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
*try_cnt means the maximal TX count to try
*/
int issue_nulldata_to_TDLS_peer_STA(_adapter *padapter, unsigned char *da, unsigned int power_mode, int try_cnt, int wait_ms)
{
int ret;
int i = 0;
systime start = rtw_get_current_time();
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
#if 0
psta = rtw_get_stainfo(&padapter->stapriv, da);
if (psta) {
if (power_mode)
rtw_hal_macid_sleep(padapter, psta->phl_sta->macid);
else
rtw_hal_macid_wakeup(padapter, psta->phl_sta->macid);
} else {
RTW_INFO(FUNC_ADPT_FMT ": Can't find sta info for " MAC_FMT ", skip macid %s!!\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(da), power_mode ? "sleep" : "wakeup");
rtw_warn_on(1);
}
#endif
do {
ret = _issue_nulldata_to_TDLS_peer_STA(padapter, da, power_mode, wait_ms);
i++;
if (RTW_CANNOT_RUN(adapter_to_dvobj(padapter)))
break;
if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
rtw_msleep_os(wait_ms);
} while ((i < try_cnt) && (ret == _FAIL || wait_ms == 0));
if (ret != _FAIL) {
ret = _SUCCESS;
#ifndef DBG_XMIT_ACK
goto exit;
#endif
}
if (try_cnt && wait_ms) {
if (da)
RTW_INFO(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
else
RTW_INFO(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
}
exit:
return ret;
}
/* TDLS encryption(if needed) will always be CCMP */
void rtw_tdls_set_key(_adapter *padapter, struct sta_info *ptdls_sta)
{
ptdls_sta->dot118021XPrivacy = _AES_;
rtw_setstakey_cmd(padapter, ptdls_sta, TDLS_KEY, _TRUE);
}
#ifdef CONFIG_80211N_HT
void rtw_tdls_process_ht_cap(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
u8 max_AMPDU_len, min_MPDU_spacing;
u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, cur_beamform_cap = 0;
/* Save HT capabilities in the sta object */
_rtw_memset(&ptdls_sta->htpriv.ht_cap, 0, sizeof(struct rtw_ieee80211_ht_cap));
if (data && Length >= sizeof(struct rtw_ieee80211_ht_cap)) {
ptdls_sta->flags |= WLAN_STA_HT;
ptdls_sta->flags |= WLAN_STA_WME;
_rtw_memcpy(&ptdls_sta->htpriv.ht_cap, data, sizeof(struct rtw_ieee80211_ht_cap));
} else {
ptdls_sta->flags &= ~WLAN_STA_HT;
return;
}
if (ptdls_sta->flags & WLAN_STA_HT) {
if (padapter->registrypriv.ht_enable == _TRUE && is_supported_ht(padapter->registrypriv.wireless_mode) ) {
ptdls_sta->htpriv.ht_option = _TRUE;
ptdls_sta->qos_option = _TRUE;
} else {
ptdls_sta->htpriv.ht_option = _FALSE;
ptdls_sta->qos_option = _FALSE;
}
}
/* HT related cap */
if (ptdls_sta->htpriv.ht_option) {
/* Check if sta supports rx ampdu */
if (padapter->registrypriv.ampdu_enable == 1)
ptdls_sta->htpriv.ampdu_enable = _TRUE;
/* AMPDU Parameters field */
/* Get MIN of MAX AMPDU Length Exp */
if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3) > (data[2] & 0x3))
max_AMPDU_len = (data[2] & 0x3);
else
max_AMPDU_len = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3);
/* Get MAX of MIN MPDU Start Spacing */
if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) > (data[2] & 0x1c))
min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c);
else
min_MPDU_spacing = (data[2] & 0x1c);
ptdls_sta->htpriv.rx_ampdu_min_spacing = max_AMPDU_len | min_MPDU_spacing;
/* Check if sta support s Short GI 20M */
if ((phtpriv->sgi_20m == _TRUE) && (ptdls_sta->htpriv.ht_cap.cap_info & cpu_to_le16(IEEE80211_HT_CAP_SGI_20)))
ptdls_sta->htpriv.sgi_20m = _TRUE;
/* Check if sta support s Short GI 40M */
if ((phtpriv->sgi_40m == _TRUE) && (ptdls_sta->htpriv.ht_cap.cap_info & cpu_to_le16(IEEE80211_HT_CAP_SGI_40)))
ptdls_sta->htpriv.sgi_40m = _TRUE;
/* Bwmode would still followed AP's setting */
if (ptdls_sta->htpriv.ht_cap.cap_info & cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH)) {
if (padapter->mlmeextpriv.chandef.bw >= CHANNEL_WIDTH_40)
ptdls_sta->phl_sta->chandef.bw = CHANNEL_WIDTH_40;
ptdls_sta->htpriv.ch_offset = padapter->mlmeextpriv.chandef.offset;
}
/* Config LDPC Coding Capability */
if (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX) && GET_HT_CAP_ELE_LDPC_CAP(data)) {
SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX));
RTW_INFO("Enable HT Tx LDPC!\n");
}
ptdls_sta->htpriv.ldpc_cap = cur_ldpc_cap;
/* Config STBC setting */
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) && GET_HT_CAP_ELE_RX_STBC(data)) {
SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX));
RTW_INFO("Enable HT Tx STBC!\n");
}
ptdls_sta->htpriv.stbc_cap = cur_stbc_cap;
#ifdef CONFIG_BEAMFORMING
/* Config Tx beamforming setting */
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP(data))
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP(data))
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
ptdls_sta->htpriv.beamform_cap = cur_beamform_cap;
if (cur_beamform_cap)
RTW_INFO("Client HT Beamforming Cap = 0x%02X\n", cur_beamform_cap);
#endif /* CONFIG_BEAMFORMING */
}
}
u8 *rtw_tdls_set_ht_cap(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
rtw_ht_use_default_setting(padapter);
if (padapter->registrypriv.wifi_spec == 1) {
padapter->mlmepriv.htpriv.sgi_20m = _FALSE;
padapter->mlmepriv.htpriv.sgi_40m = _FALSE;
}
rtw_restructure_ht_ie(padapter, NULL, pframe, 0, &(pattrib->pktlen), padapter->mlmeextpriv.chandef.chan, NULL);
return pframe + pattrib->pktlen;
}
#endif
#ifdef CONFIG_80211AC_VHT
void rtw_tdls_process_vht_cap(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, tx_nss = 0;
u16 cur_beamform_cap = 0;
u8 *pcap_mcs;
_rtw_memset(&ptdls_sta->vhtpriv, 0, sizeof(struct vht_priv));
if (data && Length == 12) {
ptdls_sta->flags |= WLAN_STA_VHT;
_rtw_memcpy(ptdls_sta->vhtpriv.vht_cap, data, 12);
#if 0
if (elems.vht_op_mode_notify && elems.vht_op_mode_notify_len == 1)
_rtw_memcpy(&pstat->vhtpriv.vht_op_mode_notify, elems.vht_op_mode_notify, 1);
else /* for Frame without Operating Mode notify ie; default: 80M */
pstat->vhtpriv.vht_op_mode_notify = CHANNEL_WIDTH_80;
#else
ptdls_sta->vhtpriv.vht_op_mode_notify = CHANNEL_WIDTH_80;
#endif
} else {
ptdls_sta->flags &= ~WLAN_STA_VHT;
return;
}
if (ptdls_sta->flags & WLAN_STA_VHT) {
if (REGSTY_IS_11AC_ENABLE(&padapter->registrypriv)
&& is_supported_vht(padapter->registrypriv.wireless_mode)
&& RFCTL_REG_EN_11AC(rfctl)
) {
ptdls_sta->vhtpriv.vht_option = _TRUE;
/* ToDo: need to API to inform hal_sta->ra_info.is_vht_enable */
#if 0
ptdls_sta->phl_sta->ra_info.is_vht_enable = _TRUE;
#endif
}
else
ptdls_sta->vhtpriv.vht_option = _FALSE;
}
/* B4 Rx LDPC */
if (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX) &&
GET_VHT_CAPABILITY_ELE_RX_LDPC(data)) {
SET_FLAG(cur_ldpc_cap, (LDPC_VHT_ENABLE_TX | LDPC_VHT_CAP_TX));
RTW_INFO("Current VHT LDPC Setting = %02X\n", cur_ldpc_cap);
}
ptdls_sta->vhtpriv.ldpc_cap = cur_ldpc_cap;
/* B5 Short GI for 80 MHz */
ptdls_sta->vhtpriv.sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI80M(data) & pvhtpriv->sgi_80m) ? _TRUE : _FALSE;
/* B8 B9 B10 Rx STBC */
if (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX) &&
GET_VHT_CAPABILITY_ELE_RX_STBC(data)) {
SET_FLAG(cur_stbc_cap, (STBC_VHT_ENABLE_TX | STBC_VHT_CAP_TX));
RTW_INFO("Current VHT STBC Setting = %02X\n", cur_stbc_cap);
}
ptdls_sta->vhtpriv.stbc_cap = cur_stbc_cap;
#ifdef CONFIG_BEAMFORMING
/* B11 SU Beamformer Capable, the target supports Beamformer and we are Beamformee */
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE) &&
GET_VHT_CAPABILITY_ELE_SU_BFEE(data))
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
/* B12 SU Beamformee Capable, the target supports Beamformee and we are Beamformer */
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE) &&
GET_VHT_CAPABILITY_ELE_SU_BFER(data))
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
ptdls_sta->vhtpriv.beamform_cap = cur_beamform_cap;
/* ToDo: need to API to inform hal_sta->bf_info.vht_beamform_cap */
#if 0
ptdls_sta->phl_sta->bf_info.vht_beamform_cap = cur_beamform_cap;
#endif
if (cur_beamform_cap)
RTW_INFO("Current VHT Beamforming Setting = %02X\n", cur_beamform_cap);
#endif /*CONFIG_BEAMFORMING*/
/* B23 B24 B25 Maximum A-MPDU Length Exponent */
ptdls_sta->vhtpriv.ampdu_len = GET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(data);
pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(data);
tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
rtw_vht_nss_to_mcsmap(tx_nss, ptdls_sta->vhtpriv.vht_mcs_map, pcap_mcs);
ptdls_sta->vhtpriv.vht_highest_rate = rtw_get_vht_highest_rate(ptdls_sta->vhtpriv.vht_mcs_map);
}
void rtw_tdls_process_vht_operation(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct registry_priv *regsty = adapter_to_regsty(padapter);
u8 operation_bw = 0;
if (GET_VHT_OPERATION_ELE_CHL_WIDTH(data) >= 1) {
operation_bw = CHANNEL_WIDTH_80;
if (rtw_hw_is_bw_support(adapter_to_dvobj(padapter), operation_bw) && REGSTY_IS_BW_5G_SUPPORT(regsty, operation_bw)
&& (operation_bw <= pmlmeext->chandef.bw))
ptdls_sta->phl_sta->chandef.bw = operation_bw;
else
ptdls_sta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
} else
ptdls_sta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
}
void rtw_tdls_process_vht_op_mode_notify(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct registry_priv *regsty = adapter_to_regsty(padapter);
u8 target_bw;
u8 target_rxss, current_rxss;
if (pvhtpriv->vht_option == _FALSE)
return;
target_bw = GET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(data);
target_rxss = (GET_VHT_OPERATING_MODE_FIELD_RX_NSS(data) + 1);
if (rtw_hw_is_bw_support(adapter_to_dvobj(padapter), target_bw) && REGSTY_IS_BW_5G_SUPPORT(regsty, target_bw)
&& (target_bw <= pmlmeext->chandef.bw))
ptdls_sta->phl_sta->chandef.bw = target_bw;
else
ptdls_sta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
current_rxss = rtw_vht_mcsmap_to_nss(ptdls_sta->vhtpriv.vht_mcs_map);
if (target_rxss != current_rxss) {
u8 vht_mcs_map[2] = {};
rtw_vht_nss_to_mcsmap(target_rxss, vht_mcs_map, ptdls_sta->vhtpriv.vht_mcs_map);
_rtw_memcpy(ptdls_sta->vhtpriv.vht_mcs_map, vht_mcs_map, 2);
}
}
u8 *rtw_tdls_set_aid(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
return rtw_set_ie(pframe, EID_AID, 2, (u8 *)&(padapter->mlmepriv.cur_network.aid), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_vht_cap(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
u32 ie_len = 0;
rtw_vht_get_real_setting(padapter);
ie_len = rtw_build_vht_cap_ie(padapter, pframe);
pattrib->pktlen += ie_len;
return pframe + ie_len;
}
u8 *rtw_tdls_set_vht_operation(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib, u8 channel)
{
u32 ie_len = 0;
ie_len = rtw_build_vht_operation_ie(padapter, pframe, channel);
pattrib->pktlen += ie_len;
return pframe + ie_len;
}
u8 *rtw_tdls_set_vht_op_mode_notify(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib, u8 bw)
{
u32 ie_len = 0;
ie_len = rtw_build_vht_op_mode_notify_ie(padapter, pframe, bw);
pattrib->pktlen += ie_len;
return pframe + ie_len;
}
#endif
u8 *rtw_tdls_set_sup_ch(_adapter *adapter, u8 *pframe, struct pkt_attrib *pattrib)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
u8 sup_ch[30 * 2] = {0x00}, ch_set_idx = 0, sup_ch_idx = 2;
while (ch_set_idx < rfctl->max_chan_nums && rfctl->channel_set[ch_set_idx].ChannelNum != 0) {
if (rfctl->channel_set[ch_set_idx].ChannelNum <= 14) {
/* TODO: fix 2.4G supported channel when channel doesn't start from 1 and continuous */
sup_ch[0] = 1; /* First channel number */
sup_ch[1] = rfctl->channel_set[ch_set_idx].ChannelNum; /* Number of channel */
} else {
sup_ch[sup_ch_idx++] = rfctl->channel_set[ch_set_idx].ChannelNum;
sup_ch[sup_ch_idx++] = 1;
}
ch_set_idx++;
}
return rtw_set_ie(pframe, _SUPPORTED_CH_IE_, sup_ch_idx, sup_ch, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_rsnie(struct tdls_txmgmt *ptxmgmt, u8 *pframe, struct pkt_attrib *pattrib, int init, struct sta_info *ptdls_sta)
{
u8 *p = NULL;
int len = 0;
if (ptxmgmt->len > 0)
p = rtw_get_ie(ptxmgmt->buf, _RSN_IE_2_, &len, ptxmgmt->len);
if (p != NULL)
return rtw_set_ie(pframe, _RSN_IE_2_, len, p + 2, &(pattrib->pktlen));
else if (init == _TRUE)
return rtw_set_ie(pframe, _RSN_IE_2_, sizeof(TDLS_RSNIE), TDLS_RSNIE, &(pattrib->pktlen));
else
return rtw_set_ie(pframe, _RSN_IE_2_, sizeof(ptdls_sta->TDLS_RSNIE), ptdls_sta->TDLS_RSNIE, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_ext_cap(u8 *pframe, struct pkt_attrib *pattrib)
{
return rtw_set_ie(pframe, WLAN_EID_EXT_CAP , sizeof(TDLS_EXT_CAPIE), TDLS_EXT_CAPIE, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_qos_cap(u8 *pframe, struct pkt_attrib *pattrib)
{
return rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, sizeof(TDLS_WMMIE), TDLS_WMMIE, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_ftie(struct tdls_txmgmt *ptxmgmt, u8 *pframe, struct pkt_attrib *pattrib, u8 *ANonce, u8 *SNonce)
{
struct wpa_tdls_ftie FTIE = {0};
u8 *p = NULL;
int len = 0;
if (ptxmgmt->len > 0)
p = rtw_get_ie(ptxmgmt->buf, _FTIE_, &len, ptxmgmt->len);
if (p != NULL)
return rtw_set_ie(pframe, _FTIE_, len, p + 2, &(pattrib->pktlen));
else {
if (ANonce != NULL)
_rtw_memcpy(FTIE.Anonce, ANonce, WPA_NONCE_LEN);
if (SNonce != NULL)
_rtw_memcpy(FTIE.Snonce, SNonce, WPA_NONCE_LEN);
return rtw_set_ie(pframe, _FTIE_, TDLS_FTIE_DATA_LEN,
(u8 *)FTIE.data, &(pattrib->pktlen));
}
}
u8 *rtw_tdls_set_timeout_interval(struct tdls_txmgmt *ptxmgmt, u8 *pframe, struct pkt_attrib *pattrib, int init, struct sta_info *ptdls_sta)
{
u8 timeout_itvl[5]; /* set timeout interval to maximum value */
u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
u8 *p = NULL;
int len = 0;
if (ptxmgmt->len > 0)
p = rtw_get_ie(ptxmgmt->buf, _TIMEOUT_ITVL_IE_, &len, ptxmgmt->len);
if (p != NULL)
return rtw_set_ie(pframe, _TIMEOUT_ITVL_IE_, len, p + 2, &(pattrib->pktlen));
else {
/* Timeout interval */
timeout_itvl[0] = 0x02;
if (init == _TRUE)
_rtw_memcpy(timeout_itvl + 1, &timeout_interval, 4);
else
_rtw_memcpy(timeout_itvl + 1, (u8 *)(&ptdls_sta->TDLS_PeerKey_Lifetime), 4);
return rtw_set_ie(pframe, _TIMEOUT_ITVL_IE_, 5, timeout_itvl, &(pattrib->pktlen));
}
}
u8 *rtw_tdls_set_bss_coexist(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
u8 iedata = 0;
if (padapter->mlmepriv.num_FortyMHzIntolerant > 0)
iedata |= BIT(2); /* 20 MHz BSS Width Request */
/* Information Bit should be set by TDLS test plan 5.9 */
iedata |= BIT(0);
return rtw_set_ie(pframe, EID_BSSCoexistence, 1, &iedata, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_payload_type(u8 *pframe, struct pkt_attrib *pattrib)
{
u8 payload_type = 0x02;
return rtw_set_fixed_ie(pframe, 1, &(payload_type), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_category(u8 *pframe, struct pkt_attrib *pattrib, u8 category)
{
return rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_action(u8 *pframe, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt)
{
return rtw_set_fixed_ie(pframe, 1, &(ptxmgmt->action_code), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_status_code(u8 *pframe, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt)
{
return rtw_set_fixed_ie(pframe, 2, (u8 *)&(ptxmgmt->status_code), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_dialog(u8 *pframe, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt)
{
u8 dialogtoken = 1;
if (ptxmgmt->dialog_token)
return rtw_set_fixed_ie(pframe, 1, &(ptxmgmt->dialog_token), &(pattrib->pktlen));
else
return rtw_set_fixed_ie(pframe, 1, &(dialogtoken), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_reg_class(u8 *pframe, struct pkt_attrib *pattrib, struct sta_info *ptdls_sta)
{
u8 reg_class = 22;
return rtw_set_fixed_ie(pframe, 1, &(reg_class), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_second_channel_offset(u8 *pframe, struct pkt_attrib *pattrib, u8 ch_offset)
{
return rtw_set_ie(pframe, EID_SecondaryChnlOffset , 1, &ch_offset, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_capability(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
u8 cap_from_ie[2] = {0};
_rtw_memcpy(cap_from_ie, rtw_get_capability_from_ie(pmlmeinfo->network.IEs), 2);
return rtw_set_fixed_ie(pframe, 2, cap_from_ie, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_supported_rate(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
u8 bssrate[NDIS_802_11_LENGTH_RATES_EX];
int bssrate_len = 0;
u8 more_supportedrates = 0;
rtw_set_supported_rate(bssrate,
(padapter->registrypriv.wireless_mode == WIRELESS_MODE_MAX) ? padapter->mlmeextpriv.cur_wireless_mode : padapter->registrypriv.wireless_mode,
GET_WIFI_ROLE_CURRENT_CH(padapter));
bssrate_len = rtw_get_rateset_len(bssrate);
if (bssrate_len > 8) {
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , 8, bssrate, &(pattrib->pktlen));
more_supportedrates = 1;
} else
pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , bssrate_len , bssrate, &(pattrib->pktlen));
/* extended supported rates */
if (more_supportedrates == 1)
pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_ , (bssrate_len - 8), (bssrate + 8), &(pattrib->pktlen));
return pframe;
}
u8 *rtw_tdls_set_sup_reg_class(u8 *pframe, struct pkt_attrib *pattrib)
{
return rtw_set_ie(pframe, _SRC_IE_ , sizeof(TDLS_SRC), TDLS_SRC, &(pattrib->pktlen));
}
u8 *rtw_tdls_set_linkid(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib, u8 init)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 link_id_addr[18] = {0};
_rtw_memcpy(link_id_addr, get_my_bssid(&(pmlmeinfo->network)), 6);
if (init == _TRUE) {
_rtw_memcpy((link_id_addr + 6), pattrib->src, 6);
_rtw_memcpy((link_id_addr + 12), pattrib->dst, 6);
} else {
_rtw_memcpy((link_id_addr + 6), pattrib->dst, 6);
_rtw_memcpy((link_id_addr + 12), pattrib->src, 6);
}
return rtw_set_ie(pframe, _LINK_ID_IE_, 18, link_id_addr, &(pattrib->pktlen));
}
#ifdef CONFIG_TDLS_CH_SW
u8 *rtw_tdls_set_target_ch(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
u8 target_ch = 1;
if (padapter->tdlsinfo.chsw_info.off_ch_num)
return rtw_set_fixed_ie(pframe, 1, &(padapter->tdlsinfo.chsw_info.off_ch_num), &(pattrib->pktlen));
else
return rtw_set_fixed_ie(pframe, 1, &(target_ch), &(pattrib->pktlen));
}
u8 *rtw_tdls_set_ch_sw(u8 *pframe, struct pkt_attrib *pattrib, struct sta_info *ptdls_sta)
{
u8 ch_switch_timing[4] = {0};
u16 switch_time = (ptdls_sta->ch_switch_time >= TDLS_CH_SWITCH_TIME * 1000) ?
ptdls_sta->ch_switch_time : TDLS_CH_SWITCH_TIME;
u16 switch_timeout = (ptdls_sta->ch_switch_timeout >= TDLS_CH_SWITCH_TIMEOUT * 1000) ?
ptdls_sta->ch_switch_timeout : TDLS_CH_SWITCH_TIMEOUT;
_rtw_memcpy(ch_switch_timing, &switch_time, 2);
_rtw_memcpy(ch_switch_timing + 2, &switch_timeout, 2);
return rtw_set_ie(pframe, _CH_SWITCH_TIMING_, 4, ch_switch_timing, &(pattrib->pktlen));
}
void rtw_tdls_set_ch_sw_oper_control(_adapter *padapter, u8 enable)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct rtw_phl_com_t *phl_com = GET_PHL_COM(dvobj);
if (enable == _TRUE) {
#ifdef CONFIG_TDLS_CH_SW_V2
phl_com->ch_switch_offload = _TRUE;
#endif
#ifdef CONFIG_TDLS_CH_SW_BY_DRV
phl_com->ch_switch_offload = _FALSE;
#endif
}
else
phl_com->ch_switch_offload = _FALSE;
if (ATOMIC_READ(&padapter->tdlsinfo.chsw_info.chsw_on) != enable)
ATOMIC_SET(&padapter->tdlsinfo.chsw_info.chsw_on, enable);
rtw_hal_set_hwreg(padapter, HW_VAR_TDLS_BCN_EARLY_C2H_RPT, &enable);
RTW_INFO("[TDLS] %s Bcn Early C2H Report\n", (enable == _TRUE) ? "Start" : "Stop");
}
void rtw_tdls_ch_sw_back_to_base_chnl(_adapter *padapter)
{
struct mlme_priv *pmlmepriv;
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
pmlmepriv = &padapter->mlmepriv;
if ((ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE) &&
(padapter->mlmeextpriv.chandef.chan != rtw_get_oper_ch(padapter)))
rtw_tdls_cmd(padapter, pchsw_info->addr, TDLS_CH_SW_TO_BASE_CHNL_UNSOLICITED);
}
static void rtw_tdls_chsw_oper_init(_adapter *padapter, u32 timeout_ms)
{
struct submit_ctx *chsw_sctx = &padapter->tdlsinfo.chsw_info.chsw_sctx;
rtw_sctx_init(chsw_sctx, timeout_ms);
}
static int rtw_tdls_chsw_oper_wait(_adapter *padapter)
{
struct submit_ctx *chsw_sctx = &padapter->tdlsinfo.chsw_info.chsw_sctx;
return rtw_sctx_wait(chsw_sctx, __func__);
}
void rtw_tdls_chsw_oper_done(_adapter *padapter)
{
struct submit_ctx *chsw_sctx = &padapter->tdlsinfo.chsw_info.chsw_sctx;
rtw_sctx_done(&chsw_sctx);
}
s32 rtw_tdls_do_ch_sw(_adapter *padapter, struct sta_info *ptdls_sta, u8 chnl_type, u8 channel, u8 channel_offset, u16 bwmode, u16 ch_switch_time)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 center_ch, chnl_offset80 = CHAN_OFFSET_NO_EXT;
u32 ch_sw_time_start, ch_sw_time_spent, wait_time;
u8 take_care_iqk;
s32 ret = _FAIL;
ch_sw_time_start = rtw_systime_to_ms(rtw_get_current_time());
/* set mac_id sleep before channel switch */
rtw_hal_macid_sleep(padapter, ptdls_sta->phl_sta->macid);
#if defined(CONFIG_TDLS_CH_SW_BY_DRV) || defined(CONFIG_TDLS_CH_SW_V2)
set_channel_bwmode(padapter, channel, channel_offset, bwmode, _FALSE);
ret = _SUCCESS;
#else
rtw_tdls_chsw_oper_init(padapter, TDLS_CH_SWITCH_OPER_OFFLOAD_TIMEOUT);
#if 0 /*GEORGIA_TODO_FIXIT*/
/* channel switch IOs offload to FW */
if (rtw_hal_ch_sw_oper_offload(padapter, channel, channel_offset, bwmode) == _SUCCESS) {
if (rtw_tdls_chsw_oper_wait(padapter) == _SUCCESS) {
/* set channel and bw related variables in driver */
_rtw_mutex_lock_interruptible(&(dvobj->setch_mutex));
rtw_set_oper_ch(padapter, channel);
rtw_set_oper_choffset(padapter, channel_offset);
rtw_set_oper_bw(padapter, bwmode);
center_ch = rtw_phl_get_center_ch(channel, bwmode, channel_offset);
pHalData->current_channel = center_ch;
pHalData->CurrentCenterFrequencyIndex1 = center_ch;
pHalData->current_channel_bw = bwmode;
pHalData->nCur40MhzPrimeSC = channel_offset;
if (bwmode == CHANNEL_WIDTH_80) {
if (center_ch > channel)
chnl_offset80 = CHAN_OFFSET_UPPER;
else if (center_ch < channel)
chnl_offset80 = CHAN_OFFSET_LOWER;
else
chnl_offset80 = CHAN_OFFSET_NO_EXT;
}
pHalData->nCur80MhzPrimeSC = chnl_offset80;
pHalData->CurrentCenterFrequencyIndex1 = center_ch;
_rtw_mutex_unlock(&(dvobj->setch_mutex));
rtw_hal_get_hwreg(padapter, HW_VAR_CH_SW_NEED_TO_TAKE_CARE_IQK_INFO, &take_care_iqk);
if (take_care_iqk == _TRUE)
rtw_hal_ch_sw_iqk_info_restore(padapter, CH_SW_USE_CASE_TDLS);
ret = _SUCCESS;
} else
RTW_INFO("[TDLS] chsw oper wait fail !!\n");
}
#endif
#endif
if (ret == _SUCCESS) {
ch_sw_time_spent = rtw_systime_to_ms(rtw_get_current_time()) - ch_sw_time_start;
if (chnl_type == TDLS_CH_SW_OFF_CHNL) {
if ((u32)ch_switch_time / 1000 > ch_sw_time_spent)
wait_time = (u32)ch_switch_time / 1000 - ch_sw_time_spent;
else
wait_time = 0;
if (wait_time > 0)
rtw_msleep_os(wait_time);
}
}
/* set mac_id wakeup after channel switch */
rtw_hal_macid_wakeup(padapter, ptdls_sta->phl_sta->macid);
return ret;
}
#endif
u8 *rtw_tdls_set_wmm_params(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 wmm_param_ele[24] = {0};
if (&pmlmeinfo->WMM_param) {
_rtw_memcpy(wmm_param_ele, WMM_PARA_OUI, 6);
if (_rtw_memcmp(&pmlmeinfo->WMM_param, &wmm_param_ele[6], 18) == _TRUE)
/* Use default WMM Param */
_rtw_memcpy(wmm_param_ele + 6, (u8 *)&TDLS_WMM_PARAM_IE, sizeof(TDLS_WMM_PARAM_IE));
else
_rtw_memcpy(wmm_param_ele + 6, (u8 *)&pmlmeinfo->WMM_param, sizeof(pmlmeinfo->WMM_param));
return rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 24, wmm_param_ele, &(pattrib->pktlen));
} else
return pframe;
}
#ifdef CONFIG_WFD
void rtw_tdls_process_wfd_ie(struct tdls_info *ptdlsinfo, u8 *ptr, u8 length)
{
u8 *wfd_ie;
u32 wfd_ielen = 0;
_adapter *adapter = tdls_info_to_adapter(ptdlsinfo);
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
if (!rtw_hw_chk_wl_func(dvobj, WL_FUNC_MIRACAST))
return;
/* Try to get the TCP port information when receiving the negotiation response. */
wfd_ie = rtw_get_wfd_ie(ptr, length, NULL, &wfd_ielen);
while (wfd_ie) {
u8 *attr_content;
u32 attr_contentlen = 0;
int i;
RTW_INFO("[%s] WFD IE Found!!\n", __FUNCTION__);
attr_content = rtw_get_wfd_attr_content(wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, NULL, &attr_contentlen);
if (attr_content && attr_contentlen) {
ptdlsinfo->wfd_info->peer_rtsp_ctrlport = RTW_GET_BE16(attr_content + 2);
RTW_INFO("[%s] Peer PORT NUM = %d\n", __FUNCTION__, ptdlsinfo->wfd_info->peer_rtsp_ctrlport);
}
attr_content = rtw_get_wfd_attr_content(wfd_ie, wfd_ielen, WFD_ATTR_LOCAL_IP_ADDR, NULL, &attr_contentlen);
if (attr_content && attr_contentlen) {
_rtw_memcpy(ptdlsinfo->wfd_info->peer_ip_address, (attr_content + 1), 4);
RTW_INFO("[%s] Peer IP = %02u.%02u.%02u.%02u\n", __FUNCTION__,
ptdlsinfo->wfd_info->peer_ip_address[0], ptdlsinfo->wfd_info->peer_ip_address[1],
ptdlsinfo->wfd_info->peer_ip_address[2], ptdlsinfo->wfd_info->peer_ip_address[3]);
}
wfd_ie = rtw_get_wfd_ie(wfd_ie + wfd_ielen, (ptr + length) - (wfd_ie + wfd_ielen), NULL, &wfd_ielen);
}
}
int issue_tunneled_probe_req(_adapter *padapter)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
u8 baddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
struct tdls_txmgmt txmgmt;
int ret = _FAIL;
RTW_INFO("[%s]\n", __FUNCTION__);
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.action_code = TUNNELED_PROBE_REQ;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, baddr, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
int issue_tunneled_probe_rsp(_adapter *padapter, union recv_frame *precv_frame)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct tdls_txmgmt txmgmt;
int ret = _FAIL;
RTW_INFO("[%s]\n", __FUNCTION__);
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.action_code = TUNNELED_PROBE_RSP;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, precv_frame->u.hdr.attrib.src, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
#endif /* CONFIG_WFD */
int issue_tdls_setup_req(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, int wait_ack)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *ptdls_sta = NULL;
int ret = _FAIL;
/* Retry timer should be set at least 301 sec, using TPK_count counting 301 times. */
u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
if (rtw_tdls_is_setup_allowed(padapter) == _FALSE)
goto exit;
if (IS_MCAST(ptxmgmt->peer))
goto exit;
ptdls_sta = rtw_get_stainfo(pstapriv, ptxmgmt->peer);
if (ptdlsinfo->sta_maximum == _TRUE) {
if (ptdls_sta == NULL)
goto exit;
else if (!(ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE))
goto exit;
}
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
if (ptdls_sta == NULL) {
ptdls_sta = rtw_alloc_stainfo(pstapriv, ptxmgmt->peer);
if (ptdls_sta == NULL) {
RTW_INFO("[%s] rtw_alloc_stainfo fail\n", __FUNCTION__);
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
ptdlsinfo->sta_cnt++;
}
ptxmgmt->action_code = TDLS_SETUP_REQUEST;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
if (ptdlsinfo->sta_cnt == MAX_ALLOWED_TDLS_STA_NUM)
ptdlsinfo->sta_maximum = _TRUE;
ptdls_sta->tdls_sta_state |= TDLS_RESPONDER_STATE;
if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
ptdls_sta->TDLS_PeerKey_Lifetime = timeout_interval;
_set_timer(&ptdls_sta->handshake_timer, TDLS_HANDSHAKE_TIME);
}
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
int _issue_tdls_teardown(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta, u8 wait_ack)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct sta_priv *pstapriv = &padapter->stapriv;
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
ptxmgmt->action_code = TDLS_TEARDOWN;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
rtw_mi_set_scan_deny(padapter, 550);
rtw_mi_scan_abort(padapter, _TRUE);
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
if (ptxmgmt->status_code == _RSON_TDLS_TEAR_UN_RSN_)
_rtw_memcpy(pattrib->ra, ptxmgmt->peer, ETH_ALEN);
else
_rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
if (rtw_tdls_is_driver_setup(padapter) == _TRUE)
if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)
if (pattrib->encrypt)
_cancel_timer_ex(&ptdls_sta->TPK_timer);
if (wait_ack)
ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
int issue_tdls_teardown(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, u8 wait_ack)
{
struct sta_info *ptdls_sta = NULL;
int ret = _FAIL;
ptdls_sta = rtw_get_stainfo(&(padapter->stapriv), ptxmgmt->peer);
if (ptdls_sta == NULL) {
RTW_INFO("No tdls_sta for tearing down\n");
goto exit;
}
ret = _issue_tdls_teardown(padapter, ptxmgmt, ptdls_sta, wait_ack);
if ((ptxmgmt->status_code == _RSON_TDLS_TEAR_UN_RSN_) && (ret == _FAIL)) {
/* Change status code and send teardown again via AP */
ptxmgmt->status_code = _RSON_TDLS_TEAR_TOOFAR_;
ret = _issue_tdls_teardown(padapter, ptxmgmt, ptdls_sta, wait_ack);
}
if (rtw_tdls_is_driver_setup(padapter)) {
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptxmgmt->peer, TDLS_TEARDOWN_STA_LOCALLY_POST);
}
exit:
return ret;
}
int issue_tdls_dis_req(_adapter *padapter, struct tdls_txmgmt *ptxmgmt)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
ptxmgmt->action_code = TDLS_DISCOVERY_REQUEST;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
RTW_INFO("issue tdls dis req\n");
ret = _SUCCESS;
exit:
return ret;
}
int issue_tdls_setup_rsp(_adapter *padapter, struct tdls_txmgmt *ptxmgmt)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
ptxmgmt->action_code = TDLS_SETUP_RESPONSE;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, get_bssid(&(padapter->mlmepriv)), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
int issue_tdls_setup_cfm(_adapter *padapter, struct tdls_txmgmt *ptxmgmt)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
ptxmgmt->action_code = TDLS_SETUP_CONFIRM;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, get_bssid(&padapter->mlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
/* TDLS Discovery Response frame is a management action frame */
int issue_tdls_dis_rsp(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, u8 privacy)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
/* unicast probe request frame */
_rtw_memcpy(pwlanhdr->addr1, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->dst, pwlanhdr->addr1, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->src, pwlanhdr->addr2, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_bssid(&padapter->mlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ra, pwlanhdr->addr3, ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
rtw_build_tdls_dis_rsp_ies(padapter, pmgntframe, pframe, ptxmgmt, privacy);
pattrib->nr_frags = 1;
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
int issue_tdls_peer_traffic_rsp(_adapter *padapter, struct sta_info *ptdls_sta, struct tdls_txmgmt *ptxmgmt)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
ptxmgmt->action_code = TDLS_PEER_TRAFFIC_RESPONSE;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
int issue_tdls_peer_traffic_indication(_adapter *padapter, struct sta_info *ptdls_sta)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct tdls_txmgmt txmgmt;
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.action_code = TDLS_PEER_TRAFFIC_INDICATION;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
/* PTI frame's priority should be AC_VO */
pattrib->priority = 7;
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
#ifdef CONFIG_TDLS_CH_SW
int issue_tdls_ch_switch_req(_adapter *padapter, struct sta_info *ptdls_sta)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct tdls_txmgmt txmgmt;
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
goto exit;
}
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.action_code = TDLS_CHANNEL_SWITCH_REQUEST;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
exit:
return ret;
}
int issue_tdls_ch_switch_rsp(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, int wait_ack)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
int ret = _FAIL;
RTW_INFO("[TDLS] %s\n", __FUNCTION__);
if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
goto exit;
}
ptxmgmt->action_code = TDLS_CHANNEL_SWITCH_RESPONSE;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
goto exit;
pattrib = &pmgntframe->attrib;
pmgntframe->frame_tag = DATA_FRAMETAG;
pattrib->ether_type = 0x890d;
_rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pattrib->ra, ptxmgmt->peer, ETH_ALEN);
_rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
update_tdls_attrib(padapter, pattrib);
pattrib->qsel = pattrib->priority;
/*
_rtw_spinlock_bh(&pxmitpriv->lock);
if(xmitframe_enqueue_for_tdls_sleeping_sta(padapter, pmgntframe)==_TRUE){
_rtw_spinunlock_bh(&pxmitpriv->lock);
return _FALSE;
}
*/
if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pmgntframe);
goto exit;
}
if (wait_ack)
ret = dump_mgntframe_and_wait_ack_timeout(padapter, pmgntframe, 10);
else {
dump_mgntframe(padapter, pmgntframe);
ret = _SUCCESS;
}
exit:
return ret;
}
#endif
int On_TDLS_Dis_Rsp(_adapter *padapter, union recv_frame *precv_frame)
{
struct sta_info *ptdls_sta = NULL, *psta = rtw_get_stainfo(&(padapter->stapriv), get_bssid(&(padapter->mlmepriv)));
u8 *ptr = precv_frame->u.hdr.rx_data, *psa;
struct rx_pkt_attrib *pattrib = &(precv_frame->u.hdr.attrib);
struct tdls_info *ptdlsinfo = &(padapter->tdlsinfo);
u8 empty_addr[ETH_ALEN] = { 0x00 };
int rssi = 0;
struct tdls_txmgmt txmgmt;
int ret = _SUCCESS;
if (psta)
rssi = psta->phl_sta->rssi_stat.rssi;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
/* WFDTDLS: for sigma test, not to setup direct link automatically */
ptdlsinfo->dev_discovered = _TRUE;
psa = get_sa(ptr);
ptdls_sta = rtw_get_stainfo(&(padapter->stapriv), psa);
if (ptdls_sta != NULL)
ptdls_sta->sta_stats.rx_tdls_disc_rsp_pkts++;
#ifdef CONFIG_TDLS_AUTOSETUP
if (ptdls_sta != NULL) {
/* Record the tdls sta with lowest signal strength */
if (ptdlsinfo->sta_maximum == _TRUE && ptdls_sta->alive_count >= 1) {
if (_rtw_memcmp(ptdlsinfo->ss_record.macaddr, empty_addr, ETH_ALEN)) {
_rtw_memcpy(ptdlsinfo->ss_record.macaddr, psa, ETH_ALEN);
ptdlsinfo->ss_record.RxPWDBAll = pattrib->phy_info.rx_pwdb_all;
} else {
if (ptdlsinfo->ss_record.RxPWDBAll < pattrib->phy_info.rx_pwdb_all) {
_rtw_memcpy(ptdlsinfo->ss_record.macaddr, psa, ETH_ALEN);
ptdlsinfo->ss_record.RxPWDBAll = pattrib->phy_info.rx_pwdb_all;
}
}
}
} else {
if (ptdlsinfo->sta_maximum == _TRUE) {
if (_rtw_memcmp(ptdlsinfo->ss_record.macaddr, empty_addr, ETH_ALEN)) {
/* All traffics are busy, do not set up another direct link. */
ret = _FAIL;
goto exit;
} else {
if (pattrib->phy_info.rx_pwdb_all > ptdlsinfo->ss_record.RxPWDBAll) {
_rtw_memcpy(txmgmt.peer, ptdlsinfo->ss_record.macaddr, ETH_ALEN);
/* issue_tdls_teardown(padapter, ptdlsinfo->ss_record.macaddr, _FALSE); */
} else {
ret = _FAIL;
goto exit;
}
}
}
if (pattrib->phy_info.rx_pwdb_all + TDLS_SIGNAL_THRESH >= rssi) {
RTW_INFO("pattrib->RxPWDBAll=%d, pdmpriv->undecorated_smoothed_pwdb=%d\n", pattrib->phy_info.rx_pwdb_all, rssi);
_rtw_memcpy(txmgmt.peer, psa, ETH_ALEN);
issue_tdls_setup_req(padapter, &txmgmt, _FALSE);
}
}
exit:
#endif /* CONFIG_TDLS_AUTOSETUP */
return ret;
}
sint On_TDLS_Setup_Req(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
u8 *psa, *pmyid;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *ptr = precv_frame->u.hdr.rx_data;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
u8 *prsnie, *ppairwise_cipher;
u8 i, k;
u8 ccmp_included = 0, rsnie_included = 0;
u16 j, pairwise_count;
u8 SNonce[32];
u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
sint parsing_length; /* Frame body length, without icv_len */
PNDIS_802_11_VARIABLE_IEs pIE;
u8 FIXED_IE = 5;
unsigned char supportRate[16];
int supportRateNum = 0;
struct tdls_txmgmt txmgmt;
if (rtw_tdls_is_setup_allowed(padapter) == _FALSE)
goto exit;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
psa = get_sa(ptr);
if (ptdlsinfo->sta_maximum == _TRUE) {
if (ptdls_sta == NULL)
goto exit;
else if (!(ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE))
goto exit;
}
pmyid = adapter_mac_addr(padapter);
ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
- prx_pkt_attrib->hdrlen
- prx_pkt_attrib->iv_len
- prx_pkt_attrib->icv_len
- LLC_HEADER_SIZE
- ETH_TYPE_LEN
- PAYLOAD_TYPE_LEN;
if (ptdls_sta == NULL) {
ptdls_sta = rtw_alloc_stainfo(pstapriv, psa);
if (ptdls_sta == NULL)
goto exit;
ptdlsinfo->sta_cnt++;
}
else {
if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) {
/* If the direct link is already set up */
/* Process as re-setup after tear down */
RTW_INFO("re-setup a direct link\n");
}
/* Already receiving TDLS setup request */
else if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE) {
RTW_INFO("receive duplicated TDLS setup request frame in handshaking\n");
goto exit;
}
/* When receiving and sending setup_req to the same link at the same time */
/* STA with higher MAC_addr would be initiator */
else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE) {
RTW_INFO("receive setup_req after sending setup_req\n");
for (i = 0; i < 6; i++) {
if (*(pmyid + i) == *(psa + i)) {
} else if (*(pmyid + i) > *(psa + i)) {
ptdls_sta->tdls_sta_state = TDLS_INITIATOR_STATE;
break;
} else if (*(pmyid + i) < *(psa + i))
goto exit;
}
}
}
if (ptdls_sta) {
txmgmt.dialog_token = *(ptr + 2); /* Copy dialog token */
txmgmt.status_code = _STATS_SUCCESSFUL_;
/* Parsing information element */
for (j = FIXED_IE; j < parsing_length;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
switch (pIE->ElementID) {
case _SUPPORTEDRATES_IE_:
_rtw_memcpy(supportRate, pIE->data, pIE->Length);
supportRateNum = pIE->Length;
break;
case WLAN_EID_COUNTRY:
break;
case _EXT_SUPPORTEDRATES_IE_:
if (supportRateNum < sizeof(supportRate)) {
_rtw_memcpy(supportRate + supportRateNum, pIE->data, pIE->Length);
supportRateNum += pIE->Length;
}
break;
case _SUPPORTED_CH_IE_:
break;
case _RSN_IE_2_:
rsnie_included = 1;
if (prx_pkt_attrib->encrypt) {
prsnie = (u8 *)pIE;
/* Check CCMP pairwise_cipher presence. */
ppairwise_cipher = prsnie + 10;
_rtw_memcpy(ptdls_sta->TDLS_RSNIE, pIE->data, pIE->Length);
pairwise_count = *(u16 *)(ppairwise_cipher - 2);
for (k = 0; k < pairwise_count; k++) {
if (_rtw_memcmp(ppairwise_cipher + 4 * k, RSN_CIPHER_SUITE_CCMP, 4) == _TRUE)
ccmp_included = 1;
}
if (ccmp_included == 0)
txmgmt.status_code = _STATS_INVALID_RSNIE_;
}
break;
case WLAN_EID_EXT_CAP:
break;
case _VENDOR_SPECIFIC_IE_:
break;
case _FTIE_:
if (prx_pkt_attrib->encrypt)
_rtw_memcpy(SNonce, (ptr + j + 52), 32);
break;
case _TIMEOUT_ITVL_IE_:
if (prx_pkt_attrib->encrypt)
timeout_interval = cpu_to_le32(*(u32 *)(ptr + j + 3));
break;
case _RIC_Descriptor_IE_:
break;
#ifdef CONFIG_80211N_HT
case _HT_CAPABILITY_IE_:
rtw_tdls_process_ht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
break;
#endif
#ifdef CONFIG_80211AC_VHT
case EID_AID:
break;
case EID_VHTCapability:
rtw_tdls_process_vht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
break;
#endif
case EID_BSSCoexistence:
break;
case _LINK_ID_IE_:
if (_rtw_memcmp(get_bssid(pmlmepriv), pIE->data, 6) == _FALSE)
txmgmt.status_code = _STATS_NOT_IN_SAME_BSS_;
break;
default:
break;
}
j += (pIE->Length + 2);
}
/* Check status code */
/* If responder STA has/hasn't security on AP, but request hasn't/has RSNIE, it should reject */
if (txmgmt.status_code == _STATS_SUCCESSFUL_) {
if (rsnie_included && prx_pkt_attrib->encrypt == 0)
txmgmt.status_code = _STATS_SEC_DISABLED_;
else if (rsnie_included == 0 && prx_pkt_attrib->encrypt)
txmgmt.status_code = _STATS_INVALID_PARAMETERS_;
#ifdef CONFIG_WFD
/* WFD test plan version 0.18.2 test item 5.1.5 */
/* SoUT does not use TDLS if AP uses weak security */
if (padapter->wdinfo.wfd_tdls_enable && (rsnie_included && prx_pkt_attrib->encrypt != _AES_))
txmgmt.status_code = _STATS_SEC_DISABLED_;
#endif /* CONFIG_WFD */
}
ptdls_sta->tdls_sta_state |= TDLS_INITIATOR_STATE;
if (prx_pkt_attrib->encrypt) {
_rtw_memcpy(ptdls_sta->SNonce, SNonce, 32);
if (timeout_interval <= 300)
ptdls_sta->TDLS_PeerKey_Lifetime = TDLS_TPK_RESEND_COUNT;
else
ptdls_sta->TDLS_PeerKey_Lifetime = timeout_interval;
}
/* Update station supportRate */
ptdls_sta->bssratelen = supportRateNum;
_rtw_memcpy(ptdls_sta->bssrateset, supportRate, supportRateNum);
/* -2: AP + BC/MC sta, -4: default key */
if (ptdlsinfo->sta_cnt == MAX_ALLOWED_TDLS_STA_NUM)
ptdlsinfo->sta_maximum = _TRUE;
#ifdef CONFIG_WFD
rtw_tdls_process_wfd_ie(ptdlsinfo, ptr + FIXED_IE, parsing_length);
#endif
} else
goto exit;
_rtw_memcpy(txmgmt.peer, prx_pkt_attrib->src, ETH_ALEN);
if (rtw_tdls_is_driver_setup(padapter)) {
issue_tdls_setup_rsp(padapter, &txmgmt);
if (txmgmt.status_code == _STATS_SUCCESSFUL_)
_set_timer(&ptdls_sta->handshake_timer, TDLS_HANDSHAKE_TIME);
else {
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
}
}
exit:
return _SUCCESS;
}
int On_TDLS_Setup_Rsp(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
u8 *psa;
u16 status_code = 0;
sint parsing_length; /* Frame body length, without icv_len */
PNDIS_802_11_VARIABLE_IEs pIE;
u8 FIXED_IE = 7;
u8 ANonce[32];
u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL, *ppairwise_cipher = NULL;
u16 pairwise_count, j, k;
u8 verify_ccmp = 0;
unsigned char supportRate[16];
int supportRateNum = 0;
struct tdls_txmgmt txmgmt;
int ret = _SUCCESS;
u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
psa = get_sa(ptr);
ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
- prx_pkt_attrib->hdrlen
- prx_pkt_attrib->iv_len
- prx_pkt_attrib->icv_len
- LLC_HEADER_SIZE
- ETH_TYPE_LEN
- PAYLOAD_TYPE_LEN;
_rtw_memcpy(&status_code, ptr + 2, 2);
if (status_code != 0) {
RTW_INFO("[TDLS] %s status_code = %d, free_tdls_sta\n", __FUNCTION__, status_code);
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
ret = _FAIL;
goto exit;
}
status_code = 0;
/* parsing information element */
for (j = FIXED_IE; j < parsing_length;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
switch (pIE->ElementID) {
case _SUPPORTEDRATES_IE_:
_rtw_memcpy(supportRate, pIE->data, pIE->Length);
supportRateNum = pIE->Length;
break;
case WLAN_EID_COUNTRY:
break;
case _EXT_SUPPORTEDRATES_IE_:
if (supportRateNum < sizeof(supportRate)) {
_rtw_memcpy(supportRate + supportRateNum, pIE->data, pIE->Length);
supportRateNum += pIE->Length;
}
break;
case _SUPPORTED_CH_IE_:
break;
case _RSN_IE_2_:
prsnie = (u8 *)pIE;
/* Check CCMP pairwise_cipher presence. */
ppairwise_cipher = prsnie + 10;
_rtw_memcpy(&pairwise_count, (u16 *)(ppairwise_cipher - 2), 2);
for (k = 0; k < pairwise_count; k++) {
if (_rtw_memcmp(ppairwise_cipher + 4 * k, RSN_CIPHER_SUITE_CCMP, 4) == _TRUE)
verify_ccmp = 1;
}
case WLAN_EID_EXT_CAP:
break;
case _VENDOR_SPECIFIC_IE_:
if (_rtw_memcmp((u8 *)pIE + 2, WMM_INFO_OUI, 6) == _TRUE) {
/* WMM Info ID and OUI */
if ((pregistrypriv->wmm_enable == _TRUE) || (padapter->mlmepriv.htpriv.ht_option == _TRUE))
ptdls_sta->qos_option = _TRUE;
}
break;
case _FTIE_:
pftie = (u8 *)pIE;
_rtw_memcpy(ANonce, (ptr + j + 20), 32);
break;
case _TIMEOUT_ITVL_IE_:
ptimeout_ie = (u8 *)pIE;
timeout_interval = cpu_to_le32(*(u32 *)(ptimeout_ie + 3));
break;
case _RIC_Descriptor_IE_:
break;
#ifdef CONFIG_80211N_HT
case _HT_CAPABILITY_IE_:
rtw_tdls_process_ht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
break;
#endif
#ifdef CONFIG_80211AC_VHT
case EID_AID:
/* todo in the future if necessary */
break;
case EID_VHTCapability:
rtw_tdls_process_vht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
break;
case EID_OpModeNotification:
rtw_tdls_process_vht_op_mode_notify(padapter, ptdls_sta, pIE->data, pIE->Length);
break;
#endif
case EID_BSSCoexistence:
break;
case _LINK_ID_IE_:
plinkid_ie = (u8 *)pIE;
break;
default:
break;
}
j += (pIE->Length + 2);
}
ptdls_sta->bssratelen = supportRateNum;
_rtw_memcpy(ptdls_sta->bssrateset, supportRate, supportRateNum);
_rtw_memcpy(ptdls_sta->ANonce, ANonce, 32);
#ifdef CONFIG_WFD
rtw_tdls_process_wfd_ie(ptdlsinfo, ptr + FIXED_IE, parsing_length);
#endif
if (prx_pkt_attrib->encrypt) {
if (verify_ccmp == 1) {
txmgmt.status_code = _STATS_SUCCESSFUL_;
if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
wpa_tdls_generate_tpk(padapter, ptdls_sta);
if (tdls_verify_mic(ptdls_sta->tpk.kck, 2, plinkid_ie, prsnie, ptimeout_ie, pftie) == _FAIL) {
RTW_INFO("[TDLS] %s tdls_verify_mic fail, free_tdls_sta\n", __FUNCTION__);
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
ret = _FAIL;
goto exit;
}
ptdls_sta->TDLS_PeerKey_Lifetime = timeout_interval;
}
} else
txmgmt.status_code = _STATS_INVALID_RSNIE_;
} else
txmgmt.status_code = _STATS_SUCCESSFUL_;
if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
_rtw_memcpy(txmgmt.peer, prx_pkt_attrib->src, ETH_ALEN);
issue_tdls_setup_cfm(padapter, &txmgmt);
if (txmgmt.status_code == _STATS_SUCCESSFUL_) {
rtw_tdls_set_link_established(padapter, _TRUE);
if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE) {
ptdls_sta->tdls_sta_state |= TDLS_LINKED_STATE;
ptdls_sta->state |= WIFI_ASOC_STATE;
_cancel_timer_ex(&ptdls_sta->handshake_timer);
}
if (prx_pkt_attrib->encrypt)
rtw_tdls_set_key(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_ESTABLISHED);
}
}
exit:
if (rtw_tdls_is_driver_setup(padapter) == _TRUE)
return ret;
else
return _SUCCESS;
}
int On_TDLS_Setup_Cfm(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
u8 *psa;
u16 status_code = 0;
sint parsing_length;
PNDIS_802_11_VARIABLE_IEs pIE;
u8 FIXED_IE = 5;
u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL, *ppairwise_cipher = NULL;
u16 j, pairwise_count;
int ret = _SUCCESS;
psa = get_sa(ptr);
ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
- prx_pkt_attrib->hdrlen
- prx_pkt_attrib->iv_len
- prx_pkt_attrib->icv_len
- LLC_HEADER_SIZE
- ETH_TYPE_LEN
- PAYLOAD_TYPE_LEN;
_rtw_memcpy(&status_code, ptr + 2, 2);
if (status_code != 0) {
RTW_INFO("[%s] status_code = %d\n, free_tdls_sta", __FUNCTION__, status_code);
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
ret = _FAIL;
goto exit;
}
/* Parsing information element */
for (j = FIXED_IE; j < parsing_length;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
switch (pIE->ElementID) {
case _RSN_IE_2_:
prsnie = (u8 *)pIE;
break;
case _VENDOR_SPECIFIC_IE_:
if (_rtw_memcmp((u8 *)pIE + 2, WMM_PARA_OUI, 6) == _TRUE) {
/* WMM Parameter ID and OUI */
ptdls_sta->qos_option = _TRUE;
}
break;
case _FTIE_:
pftie = (u8 *)pIE;
break;
case _TIMEOUT_ITVL_IE_:
ptimeout_ie = (u8 *)pIE;
break;
#ifdef CONFIG_80211N_HT
case _HT_EXTRA_INFO_IE_:
break;
#endif
#ifdef CONFIG_80211AC_VHT
case EID_VHTOperation:
rtw_tdls_process_vht_operation(padapter, ptdls_sta, pIE->data, pIE->Length);
break;
case EID_OpModeNotification:
rtw_tdls_process_vht_op_mode_notify(padapter, ptdls_sta, pIE->data, pIE->Length);
break;
#endif
case _LINK_ID_IE_:
plinkid_ie = (u8 *)pIE;
break;
default:
break;
}
j += (pIE->Length + 2);
}
if (prx_pkt_attrib->encrypt) {
/* Verify mic in FTIE MIC field */
if (rtw_tdls_is_driver_setup(padapter) &&
(tdls_verify_mic(ptdls_sta->tpk.kck, 3, plinkid_ie, prsnie, ptimeout_ie, pftie) == _FAIL)) {
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
ret = _FAIL;
goto exit;
}
}
if (rtw_tdls_is_driver_setup(padapter)) {
rtw_tdls_set_link_established(padapter, _TRUE);
if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE) {
ptdls_sta->tdls_sta_state |= TDLS_LINKED_STATE;
ptdls_sta->state |= WIFI_ASOC_STATE;
_cancel_timer_ex(&ptdls_sta->handshake_timer);
}
if (prx_pkt_attrib->encrypt) {
rtw_tdls_set_key(padapter, ptdls_sta);
/* Start TPK timer */
ptdls_sta->TPK_count = 0;
_set_timer(&ptdls_sta->TPK_timer, ONE_SEC);
}
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_ESTABLISHED);
}
exit:
return ret;
}
int On_TDLS_Dis_Req(_adapter *padapter, union recv_frame *precv_frame)
{
struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta_ap;
u8 *ptr = precv_frame->u.hdr.rx_data;
sint parsing_length; /* Frame body length, without icv_len */
PNDIS_802_11_VARIABLE_IEs pIE;
u8 FIXED_IE = 3, *dst;
u16 j;
struct tdls_txmgmt txmgmt;
int ret = _SUCCESS;
if (rtw_tdls_is_driver_setup(padapter) == _FALSE)
goto exit;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
txmgmt.dialog_token = *(ptr + 2);
_rtw_memcpy(&txmgmt.peer, precv_frame->u.hdr.attrib.src, ETH_ALEN);
txmgmt.action_code = TDLS_DISCOVERY_RESPONSE;
parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
- prx_pkt_attrib->hdrlen
- prx_pkt_attrib->iv_len
- prx_pkt_attrib->icv_len
- LLC_HEADER_SIZE
- ETH_TYPE_LEN
- PAYLOAD_TYPE_LEN;
/* Parsing information element */
for (j = FIXED_IE; j < parsing_length;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
switch (pIE->ElementID) {
case _LINK_ID_IE_:
psta_ap = rtw_get_stainfo(pstapriv, pIE->data);
if (psta_ap == NULL)
goto exit;
dst = pIE->data + 12;
if (MacAddr_isBcst(dst) == _FALSE && (_rtw_memcmp(adapter_mac_addr(padapter), dst, ETH_ALEN) == _FALSE))
goto exit;
break;
default:
break;
}
j += (pIE->Length + 2);
}
issue_tdls_dis_rsp(padapter, &txmgmt, prx_pkt_attrib->privacy);
exit:
return ret;
}
int On_TDLS_Teardown(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_priv *pstapriv = &padapter->stapriv;
u8 reason;
reason = *(ptr + prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN + 2);
RTW_INFO("[TDLS] %s Reason code(%d)\n", __FUNCTION__, reason);
if (rtw_tdls_is_driver_setup(padapter)) {
rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
}
return _SUCCESS;
}
#if 0
u8 TDLS_check_ch_state(uint state)
{
if (state & TDLS_CH_SWITCH_ON_STATE &&
state & TDLS_PEER_AT_OFF_STATE) {
if (state & TDLS_PEER_SLEEP_STATE)
return 2; /* U-APSD + ch. switch */
else
return 1; /* ch. switch */
} else
return 0;
}
#endif
int On_TDLS_Peer_Traffic_Indication(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
u8 *ptr = precv_frame->u.hdr.rx_data;
struct tdls_txmgmt txmgmt;
ptr += pattrib->hdrlen + pattrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
txmgmt.dialog_token = *(ptr + 2);
issue_tdls_peer_traffic_rsp(padapter, ptdls_sta, &txmgmt);
/* issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta->phl_sta->mac_addr, 0, 0, 0); */
return _SUCCESS;
}
/* We process buffered data for 1. U-APSD, 2. ch. switch, 3. U-APSD + ch. switch here */
int On_TDLS_Peer_Traffic_Rsp(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 wmmps_ac = 0;
/* u8 state=TDLS_check_ch_state(ptdls_sta->tdls_sta_state); */
int i;
ptdls_sta->sta_stats.rx_data_pkts++;
ptdls_sta->tdls_sta_state &= ~(TDLS_WAIT_PTR_STATE);
/* Check 4-AC queue bit */
if (ptdls_sta->uapsd_vo || ptdls_sta->uapsd_vi || ptdls_sta->uapsd_be || ptdls_sta->uapsd_bk)
wmmps_ac = 1;
/* If it's a direct link and have buffered frame */
if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) {
if (wmmps_ac) {
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
_rtw_spinlock_bh(&ptdls_sta->sleep_q.lock);
xmitframe_phead = get_list_head(&ptdls_sta->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
/* transmit buffered frames */
while (rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
xmitframe_plist = get_next(xmitframe_plist);
rtw_list_delete(&pxmitframe->list);
ptdls_sta->sleepq_len--;
ptdls_sta->sleepq_ac_len--;
if (ptdls_sta->sleepq_len > 0) {
pxmitframe->attrib.mdata = 1;
pxmitframe->attrib.eosp = 0;
} else {
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.eosp = 1;
}
pxmitframe->attrib.triggered = 1;
rtw_intf_xmitframe_enqueue(padapter, pxmitframe);
}
if (ptdls_sta->sleepq_len == 0)
RTW_INFO("no buffered packets for tdls to xmit\n");
else {
RTW_INFO("error!psta->sleepq_len=%d\n", ptdls_sta->sleepq_len);
ptdls_sta->sleepq_len = 0;
}
_rtw_spinunlock_bh(&ptdls_sta->sleep_q.lock);
}
}
return _SUCCESS;
}
#ifdef CONFIG_TDLS_CH_SW
sint On_TDLS_Ch_Switch_Req(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
sint parsing_length;
PNDIS_802_11_VARIABLE_IEs pIE;
u8 FIXED_IE = 4;
u16 j;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
u8 zaddr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
u16 switch_time = TDLS_CH_SWITCH_TIME * 1000, switch_timeout = TDLS_CH_SWITCH_TIMEOUT * 1000;
u8 take_care_iqk;
if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
return _FAIL;
}
ptdls_sta->ch_switch_time = switch_time;
ptdls_sta->ch_switch_timeout = switch_timeout;
ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
- prx_pkt_attrib->hdrlen
- prx_pkt_attrib->iv_len
- prx_pkt_attrib->icv_len
- LLC_HEADER_SIZE
- ETH_TYPE_LEN
- PAYLOAD_TYPE_LEN;
pchsw_info->off_ch_num = *(ptr + 2);
if ((*(ptr + 2) == 2) && (rtw_hw_is_band_support(adapter_to_dvobj(padapter), BAND_ON_5G)))
pchsw_info->off_ch_num = 44;
if (pchsw_info->off_ch_num != pmlmeext->chandef.chan)
pchsw_info->delay_switch_back = _FALSE;
/* Parsing information element */
for (j = FIXED_IE; j < parsing_length;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
switch (pIE->ElementID) {
case EID_SecondaryChnlOffset:
switch (*(pIE->data)) {
case IEEE80211_SCA:
pchsw_info->ch_offset = CHAN_OFFSET_UPPER;
break;
case IEEE80211_SCB:
pchsw_info->ch_offset = CHAN_OFFSET_LOWER;
break;
default:/*IEEE80211_SCN*/
pchsw_info->ch_offset = CHAN_OFFSET_NO_EXT;
break;
}
break;
case _LINK_ID_IE_:
break;
case _CH_SWITCH_TIMING_:
ptdls_sta->ch_switch_time = (RTW_GET_LE16(pIE->data) >= TDLS_CH_SWITCH_TIME * 1000) ?
RTW_GET_LE16(pIE->data) : TDLS_CH_SWITCH_TIME * 1000;
ptdls_sta->ch_switch_timeout = (RTW_GET_LE16(pIE->data + 2) >= TDLS_CH_SWITCH_TIMEOUT * 1000) ?
RTW_GET_LE16(pIE->data + 2) : TDLS_CH_SWITCH_TIMEOUT * 1000;
RTW_INFO("[TDLS] %s ch_switch_time:%d, ch_switch_timeout:%d\n"
, __FUNCTION__, RTW_GET_LE16(pIE->data), RTW_GET_LE16(pIE->data + 2));
default:
break;
}
j += (pIE->Length + 2);
}
rtw_hal_get_hwreg(padapter, HW_VAR_CH_SW_NEED_TO_TAKE_CARE_IQK_INFO, &take_care_iqk);
if (take_care_iqk == _TRUE) {
u8 central_chnl;
u8 bw_mode;
bw_mode = (pchsw_info->ch_offset) ? CHANNEL_WIDTH_40 : CHANNEL_WIDTH_20;
central_chnl = rtw_phl_get_center_ch(pchsw_info->off_ch_num, bw_mode, pchsw_info->ch_offset);
if (rtw_hal_ch_sw_iqk_info_search(padapter, central_chnl, bw_mode) < 0) {
if (!(pchsw_info->ch_sw_state & TDLS_CH_SWITCH_PREPARE_STATE))
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_PREPARE);
return _FAIL;
}
}
/* cancel ch sw monitor timer for responder */
if (!(pchsw_info->ch_sw_state & TDLS_CH_SW_INITIATOR_STATE))
_cancel_timer_ex(&ptdls_sta->ch_sw_monitor_timer);
if (_rtw_memcmp(pchsw_info->addr, zaddr, ETH_ALEN) == _TRUE)
_rtw_memcpy(pchsw_info->addr, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
if (ATOMIC_READ(&pchsw_info->chsw_on) == _FALSE)
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_START);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_RESP);
return _SUCCESS;
}
sint On_TDLS_Ch_Switch_Rsp(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
{
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *ptr = precv_frame->u.hdr.rx_data;
struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
sint parsing_length;
PNDIS_802_11_VARIABLE_IEs pIE;
u8 FIXED_IE = 4;
u16 status_code, j, switch_time, switch_timeout;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
int ret = _SUCCESS;
if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
return _SUCCESS;
}
/* If we receive Unsolicited TDLS Channel Switch Response when channel switch is running, */
/* we will go back to base channel and terminate this channel switch procedure */
if (ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE) {
if (pmlmeext->chandef.chan != rtw_get_oper_ch(padapter)) {
RTW_INFO("[TDLS] Rx unsolicited channel switch response\n");
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_TO_BASE_CHNL);
goto exit;
}
}
ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
- prx_pkt_attrib->hdrlen
- prx_pkt_attrib->iv_len
- prx_pkt_attrib->icv_len
- LLC_HEADER_SIZE
- ETH_TYPE_LEN
- PAYLOAD_TYPE_LEN;
_rtw_memcpy(&status_code, ptr + 2, 2);
if (status_code != 0) {
RTW_INFO("[TDLS] %s status_code:%d\n", __func__, status_code);
pchsw_info->ch_sw_state &= ~(TDLS_CH_SW_INITIATOR_STATE);
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_END);
ret = _FAIL;
goto exit;
}
/* Parsing information element */
for (j = FIXED_IE; j < parsing_length;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
switch (pIE->ElementID) {
case _LINK_ID_IE_:
break;
case _CH_SWITCH_TIMING_:
_rtw_memcpy(&switch_time, pIE->data, 2);
if (switch_time > ptdls_sta->ch_switch_time)
_rtw_memcpy(&ptdls_sta->ch_switch_time, &switch_time, 2);
_rtw_memcpy(&switch_timeout, pIE->data + 2, 2);
if (switch_timeout > ptdls_sta->ch_switch_timeout)
_rtw_memcpy(&ptdls_sta->ch_switch_timeout, &switch_timeout, 2);
break;
default:
break;
}
j += (pIE->Length + 2);
}
if ((pmlmeext->chandef.chan == rtw_get_oper_ch(padapter)) &&
(pchsw_info->ch_sw_state & TDLS_WAIT_CH_RSP_STATE)) {
if (ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE)
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_TO_OFF_CHNL);
}
exit:
return ret;
}
#endif /* CONFIG_TDLS_CH_SW */
#ifdef CONFIG_WFD
void wfd_ie_tdls(_adapter *padapter, u8 *pframe, u32 *pktlen)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info *pwfd_info = padapter->tdlsinfo.wfd_info;
u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
u32 wfdielen = 0;
u16 v16 = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_MIRACAST))
return;
/* WFD OUI */
wfdielen = 0;
wfdie[wfdielen++] = 0x50;
wfdie[wfdielen++] = 0x6F;
wfdie[wfdielen++] = 0x9A;
wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
/*
* Commented by Albert 20110825
* According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
* 1. WFD Device Information
* 2. Associated BSSID ( Optional )
* 3. Local IP Adress ( Optional )
*/
/* WFD Device Information ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value1: */
/* WFD device information */
/* available for WFD session + Preferred TDLS + WSD ( WFD Service Discovery ) */
v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL
| WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_WSD;
RTW_PUT_BE16(wfdie + wfdielen, v16);
wfdielen += 2;
/* Value2: */
/* Session Management Control Port */
/* Default TCP port for RTSP messages is 554 */
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->tdls_rtsp_ctrlport);
wfdielen += 2;
/* Value3: */
/* WFD Device Maximum Throughput */
/* 300Mbps is the maximum throughput */
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
/* Associated BSSID ATTR */
/* Type: */
wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
/* Value: */
/* Associated BSSID */
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
_rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
else
_rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
/* Local IP Address ATTR */
wfdie[wfdielen++] = WFD_ATTR_LOCAL_IP_ADDR;
/* Length: */
/* Note: In the WFD specification, the size of length field is 2. */
RTW_PUT_BE16(wfdie + wfdielen, 0x0005);
wfdielen += 2;
/* Version: */
/* 0x01: Version1;IPv4 */
wfdie[wfdielen++] = 0x01;
/* IPv4 Address */
_rtw_memcpy(wfdie + wfdielen, pwfd_info->ip_address, 4);
wfdielen += 4;
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, pktlen);
}
#endif /* CONFIG_WFD */
void rtw_build_tdls_setup_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct pkt_attrib *pattrib = &pxmitframe->attrib;
int i = 0 ;
u32 time;
u8 *pframe_head;
/* SNonce */
if (pattrib->encrypt) {
for (i = 0; i < 8; i++) {
time = rtw_get_current_time();
_rtw_memcpy(&ptdls_sta->SNonce[4 * i], (u8 *)&time, 4);
}
}
pframe_head = pframe; /* For rtw_tdls_set_ht_cap() */
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_capability(padapter, pframe, pattrib);
pframe = rtw_tdls_set_supported_rate(padapter, pframe, pattrib);
pframe = rtw_tdls_set_sup_ch(padapter, pframe, pattrib);
pframe = rtw_tdls_set_sup_reg_class(pframe, pattrib);
if (pattrib->encrypt)
pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
pframe = rtw_tdls_set_ext_cap(pframe, pattrib);
if (pattrib->encrypt) {
pframe = rtw_tdls_set_ftie(ptxmgmt
, pframe
, pattrib
, NULL
, ptdls_sta->SNonce);
pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
}
#ifdef CONFIG_80211N_HT
/* Sup_reg_classes(optional) */
if (pregistrypriv->ht_enable == _TRUE)
pframe = rtw_tdls_set_ht_cap(padapter, pframe_head, pattrib);
#endif
pframe = rtw_tdls_set_bss_coexist(padapter, pframe, pattrib);
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
if ((pregistrypriv->wmm_enable == _TRUE) || (padapter->mlmepriv.htpriv.ht_option == _TRUE))
pframe = rtw_tdls_set_qos_cap(pframe, pattrib);
#ifdef CONFIG_80211AC_VHT
if ((padapter->mlmepriv.htpriv.ht_option == _TRUE) && (pmlmeext->chandef.chan > 14)
&& REGSTY_IS_11AC_ENABLE(pregistrypriv)
&& is_supported_vht(pregistrypriv->wireless_mode)
&& RFCTL_REG_EN_11AC(rfctl)
) {
pframe = rtw_tdls_set_aid(padapter, pframe, pattrib);
pframe = rtw_tdls_set_vht_cap(padapter, pframe, pattrib);
}
#endif
#ifdef CONFIG_WFD
if (padapter->wdinfo.wfd_tdls_enable == 1)
wfd_ie_tdls(padapter, pframe, &(pattrib->pktlen));
#endif
}
void rtw_build_tdls_setup_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 k; /* for random ANonce */
u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL;
u32 time;
u8 *pframe_head;
if (pattrib->encrypt) {
for (k = 0; k < 8; k++) {
time = rtw_get_current_time();
_rtw_memcpy(&ptdls_sta->ANonce[4 * k], (u8 *)&time, 4);
}
}
pframe_head = pframe;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
if (ptxmgmt->status_code != 0) {
RTW_INFO("[%s] status_code:%04x\n", __FUNCTION__, ptxmgmt->status_code);
return;
}
pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_capability(padapter, pframe, pattrib);
pframe = rtw_tdls_set_supported_rate(padapter, pframe, pattrib);
pframe = rtw_tdls_set_sup_ch(padapter, pframe, pattrib);
pframe = rtw_tdls_set_sup_reg_class(pframe, pattrib);
if (pattrib->encrypt) {
prsnie = pframe;
pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _FALSE, ptdls_sta);
}
pframe = rtw_tdls_set_ext_cap(pframe, pattrib);
if (pattrib->encrypt) {
if (rtw_tdls_is_driver_setup(padapter) == _TRUE)
wpa_tdls_generate_tpk(padapter, ptdls_sta);
pftie = pframe;
pftie_mic = pframe + 4;
pframe = rtw_tdls_set_ftie(ptxmgmt
, pframe
, pattrib
, ptdls_sta->ANonce
, ptdls_sta->SNonce);
ptimeout_ie = pframe;
pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _FALSE, ptdls_sta);
}
#ifdef CONFIG_80211N_HT
/* Sup_reg_classes(optional) */
if (pregistrypriv->ht_enable == _TRUE)
pframe = rtw_tdls_set_ht_cap(padapter, pframe_head, pattrib);
#endif
pframe = rtw_tdls_set_bss_coexist(padapter, pframe, pattrib);
plinkid_ie = pframe;
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
/* Fill FTIE mic */
if (pattrib->encrypt && rtw_tdls_is_driver_setup(padapter) == _TRUE)
wpa_tdls_ftie_mic(ptdls_sta->tpk.kck, 2, plinkid_ie, prsnie, ptimeout_ie, pftie, pftie_mic);
if ((pregistrypriv->wmm_enable == _TRUE) || (padapter->mlmepriv.htpriv.ht_option == _TRUE))
pframe = rtw_tdls_set_qos_cap(pframe, pattrib);
#ifdef CONFIG_80211AC_VHT
if ((padapter->mlmepriv.htpriv.ht_option == _TRUE) && (pmlmeext->chandef.chan > 14)
&& REGSTY_IS_11AC_ENABLE(pregistrypriv)
&& is_supported_vht(pregistrypriv->wireless_mode)
&& RFCTL_REG_EN_11AC(rfctl)
) {
pframe = rtw_tdls_set_aid(padapter, pframe, pattrib);
pframe = rtw_tdls_set_vht_cap(padapter, pframe, pattrib);
pframe = rtw_tdls_set_vht_op_mode_notify(padapter, pframe, pattrib, pmlmeext->chandef.bw);
}
#endif
#ifdef CONFIG_WFD
if (padapter->wdinfo.wfd_tdls_enable)
wfd_ie_tdls(padapter, pframe, &(pattrib->pktlen));
#endif
}
void rtw_build_tdls_setup_cfm_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct pkt_attrib *pattrib = &pxmitframe->attrib;
unsigned int ie_len;
unsigned char *p;
u8 wmm_param_ele[24] = {0};
u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
if (ptxmgmt->status_code != 0)
return;
if (pattrib->encrypt) {
prsnie = pframe;
pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
}
if (pattrib->encrypt) {
pftie = pframe;
pftie_mic = pframe + 4;
pframe = rtw_tdls_set_ftie(ptxmgmt
, pframe
, pattrib
, ptdls_sta->ANonce
, ptdls_sta->SNonce);
ptimeout_ie = pframe;
pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
/* Start TPK timer */
ptdls_sta->TPK_count = 0;
_set_timer(&ptdls_sta->TPK_timer, ONE_SEC);
}
}
/* HT operation; todo */
plinkid_ie = pframe;
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
if (pattrib->encrypt && (rtw_tdls_is_driver_setup(padapter) == _TRUE))
wpa_tdls_ftie_mic(ptdls_sta->tpk.kck, 3, plinkid_ie, prsnie, ptimeout_ie, pftie, pftie_mic);
if (ptdls_sta->qos_option == _TRUE)
pframe = rtw_tdls_set_wmm_params(padapter, pframe, pattrib);
#ifdef CONFIG_80211AC_VHT
if ((padapter->mlmepriv.htpriv.ht_option == _TRUE)
&& (ptdls_sta->vhtpriv.vht_option == _TRUE) && (pmlmeext->chandef.chan > 14)
&& REGSTY_IS_11AC_ENABLE(pregistrypriv)
&& is_supported_vht(pregistrypriv->wireless_mode)
&& RFCTL_REG_EN_11AC(rfctl)
) {
pframe = rtw_tdls_set_vht_operation(padapter, pframe, pattrib, pmlmeext->chandef.chan);
pframe = rtw_tdls_set_vht_op_mode_notify(padapter, pframe, pattrib, pmlmeext->chandef.bw);
}
#endif
}
void rtw_build_tdls_teardown_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 *pftie = NULL, *pftie_mic = NULL, *plinkid_ie = NULL;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
if (pattrib->encrypt) {
pftie = pframe;
pftie_mic = pframe + 4;
pframe = rtw_tdls_set_ftie(ptxmgmt
, pframe
, pattrib
, ptdls_sta->ANonce
, ptdls_sta->SNonce);
}
plinkid_ie = pframe;
if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
if (pattrib->encrypt && (rtw_tdls_is_driver_setup(padapter) == _TRUE))
wpa_tdls_teardown_ftie_mic(ptdls_sta->tpk.kck, plinkid_ie, ptxmgmt->status_code, 1, 4, pftie, pftie_mic);
}
void rtw_build_tdls_dis_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
}
void rtw_build_tdls_dis_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, u8 privacy)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 *pframe_head, pktlen_index;
pktlen_index = pattrib->pktlen;
pframe_head = pframe;
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_PUBLIC);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_capability(padapter, pframe, pattrib);
pframe = rtw_tdls_set_supported_rate(padapter, pframe, pattrib);
pframe = rtw_tdls_set_sup_ch(padapter, pframe, pattrib);
if (privacy)
pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _TRUE, NULL);
pframe = rtw_tdls_set_ext_cap(pframe, pattrib);
if (privacy) {
pframe = rtw_tdls_set_ftie(ptxmgmt, pframe, pattrib, NULL, NULL);
pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _TRUE, NULL);
}
#ifdef CONFIG_80211N_HT
if (pregistrypriv->ht_enable == _TRUE)
pframe = rtw_tdls_set_ht_cap(padapter, pframe_head - pktlen_index, pattrib);
#endif
pframe = rtw_tdls_set_bss_coexist(padapter, pframe, pattrib);
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
}
void rtw_build_tdls_peer_traffic_indication_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 AC_queue = 0;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
/* PTI control */
/* PU buffer status */
if (ptdls_sta->uapsd_bk & BIT(1))
AC_queue = BIT(0);
if (ptdls_sta->uapsd_be & BIT(1))
AC_queue = BIT(1);
if (ptdls_sta->uapsd_vi & BIT(1))
AC_queue = BIT(2);
if (ptdls_sta->uapsd_vo & BIT(1))
AC_queue = BIT(3);
pframe = rtw_set_ie(pframe, _PTI_BUFFER_STATUS_, 1, &AC_queue, &(pattrib->pktlen));
}
void rtw_build_tdls_peer_traffic_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
}
#ifdef CONFIG_TDLS_CH_SW
void rtw_build_tdls_ch_switch_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct sta_priv *pstapriv = &padapter->stapriv;
u16 switch_time = TDLS_CH_SWITCH_TIME * 1000, switch_timeout = TDLS_CH_SWITCH_TIMEOUT * 1000;
ptdls_sta->ch_switch_time = switch_time;
ptdls_sta->ch_switch_timeout = switch_timeout;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_target_ch(padapter, pframe, pattrib);
pframe = rtw_tdls_set_reg_class(pframe, pattrib, ptdls_sta);
if (ptdlsinfo->chsw_info.ch_offset != CHAN_OFFSET_NO_EXT) {
switch (ptdlsinfo->chsw_info.ch_offset) {
case CHAN_OFFSET_UPPER:
pframe = rtw_tdls_set_second_channel_offset(pframe, pattrib, IEEE80211_SCA);
break;
case CHAN_OFFSET_LOWER:
pframe = rtw_tdls_set_second_channel_offset(pframe, pattrib, IEEE80211_SCB);
break;
}
}
if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
pframe = rtw_tdls_set_ch_sw(pframe, pattrib, ptdls_sta);
}
void rtw_build_tdls_ch_switch_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct sta_priv *pstapriv = &padapter->stapriv;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
pframe = rtw_tdls_set_ch_sw(pframe, pattrib, ptdls_sta);
}
#endif
#ifdef CONFIG_WFD
void rtw_build_tunneled_probe_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe)
{
u8 i;
_adapter *iface = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct wifidirect_info *pwdinfo;
u8 category = RTW_WLAN_CATEGORY_P2P;
u8 WFA_OUI[3] = { 0x50, 0x6f, 0x9a};
u8 probe_req = 4;
u8 wfdielen = 0;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 3, WFA_OUI, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(probe_req), &(pattrib->pktlen));
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
pwdinfo = &iface->wdinfo;
if (pwdinfo->wfd_tdls_enable) {
wfdielen = build_probe_req_wfd_ie(pwdinfo, pframe);
pframe += wfdielen;
pattrib->pktlen += wfdielen;
}
}
}
}
void rtw_build_tunneled_probe_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe)
{
u8 i;
_adapter *iface = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct wifidirect_info *pwdinfo;
u8 category = RTW_WLAN_CATEGORY_P2P;
u8 WFA_OUI[3] = { 0x50, 0x6f, 0x9a};
u8 probe_rsp = 5;
u8 wfdielen = 0;
pframe = rtw_tdls_set_payload_type(pframe, pattrib);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 3, WFA_OUI, &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(probe_rsp), &(pattrib->pktlen));
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
pwdinfo = &iface->wdinfo;
if (pwdinfo->wfd_tdls_enable) {
wfdielen = build_probe_resp_wfd_ie(pwdinfo, pframe, 1);
pframe += wfdielen;
pattrib->pktlen += wfdielen;
}
}
}
}
#endif /* CONFIG_WFD */
void _tdls_tpk_timer_hdl(void *FunctionContext)
{
struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
struct tdls_txmgmt txmgmt;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
ptdls_sta->TPK_count++;
/* TPK_timer expired in a second */
/* Retry timer should set at least 301 sec. */
if (ptdls_sta->TPK_count >= (ptdls_sta->TDLS_PeerKey_Lifetime - 3)) {
RTW_INFO("[TDLS] %s, Re-Setup TDLS link with "MAC_FMT" since TPK lifetime expires!\n",
__FUNCTION__, MAC_ARG(ptdls_sta->phl_sta->mac_addr));
ptdls_sta->TPK_count = 0;
_rtw_memcpy(txmgmt.peer, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
issue_tdls_setup_req(ptdls_sta->padapter, &txmgmt, _FALSE);
}
_set_timer(&ptdls_sta->TPK_timer, ONE_SEC);
}
#ifdef CONFIG_TDLS_CH_SW
void _tdls_ch_switch_timer_hdl(void *FunctionContext)
{
struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
_adapter *padapter = ptdls_sta->padapter;
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_END_TO_BASE_CHNL);
RTW_INFO("[TDLS] %s, can't get traffic from op_ch:%d\n", __func__, rtw_get_oper_ch(padapter));
}
void _tdls_delay_timer_hdl(void *FunctionContext)
{
struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
_adapter *padapter = ptdls_sta->padapter;
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
RTW_INFO("[TDLS] %s, op_ch:%d, tdls_state:0x%08x\n", __func__, rtw_get_oper_ch(padapter), ptdls_sta->tdls_sta_state);
pchsw_info->delay_switch_back = _TRUE;
}
void _tdls_stay_on_base_chnl_timer_hdl(void *FunctionContext)
{
struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
_adapter *padapter = ptdls_sta->padapter;
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
if (ptdls_sta != NULL) {
issue_tdls_ch_switch_req(padapter, ptdls_sta);
pchsw_info->ch_sw_state |= TDLS_WAIT_CH_RSP_STATE;
}
}
void _tdls_ch_switch_monitor_timer_hdl(void *FunctionContext)
{
struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
_adapter *padapter = ptdls_sta->padapter;
struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_CH_SW_END);
RTW_INFO("[TDLS] %s, does not receive ch sw req\n", __func__);
}
#endif
void _tdls_handshake_timer_hdl(void *FunctionContext)
{
struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
_adapter *padapter = NULL;
struct tdls_txmgmt txmgmt;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
_rtw_memcpy(txmgmt.peer, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
txmgmt.status_code = _RSON_TDLS_TEAR_UN_RSN_;
if (ptdls_sta != NULL) {
padapter = ptdls_sta->padapter;
RTW_INFO("[TDLS] Handshake time out\n");
if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA);
else
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA_LOCALLY);
}
}
void _tdls_pti_timer_hdl(void *FunctionContext)
{
struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
_adapter *padapter = NULL;
struct tdls_txmgmt txmgmt;
_rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
_rtw_memcpy(txmgmt.peer, ptdls_sta->phl_sta->mac_addr, ETH_ALEN);
txmgmt.status_code = _RSON_TDLS_TEAR_TOOFAR_;
if (ptdls_sta != NULL) {
padapter = ptdls_sta->padapter;
if (ptdls_sta->tdls_sta_state & TDLS_WAIT_PTR_STATE) {
RTW_INFO("[TDLS] Doesn't receive PTR from peer dev:"MAC_FMT"; "
"Send TDLS Tear Down\n", MAC_ARG(ptdls_sta->phl_sta->mac_addr));
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_TEARDOWN_STA);
}
}
}
void rtw_init_tdls_timer(_adapter *padapter, struct sta_info *psta)
{
psta->padapter = padapter;
rtw_init_timer(&psta->TPK_timer, _tdls_tpk_timer_hdl, psta);
#ifdef CONFIG_TDLS_CH_SW
rtw_init_timer(&psta->ch_sw_timer, _tdls_ch_switch_timer_hdl, psta);
rtw_init_timer(&psta->delay_timer, _tdls_delay_timer_hdl, psta);
rtw_init_timer(&psta->stay_on_base_chnl_timer, _tdls_stay_on_base_chnl_timer_hdl, psta);
rtw_init_timer(&psta->ch_sw_monitor_timer, _tdls_ch_switch_monitor_timer_hdl, psta);
#endif
rtw_init_timer(&psta->handshake_timer, _tdls_handshake_timer_hdl, psta);
rtw_init_timer(&psta->pti_timer, _tdls_pti_timer_hdl, psta);
}
void rtw_cancel_tdls_timer(struct sta_info *psta)
{
_cancel_timer_ex(&psta->TPK_timer);
#ifdef CONFIG_TDLS_CH_SW
_cancel_timer_ex(&psta->ch_sw_timer);
_cancel_timer_ex(&psta->delay_timer);
_cancel_timer_ex(&psta->stay_on_base_chnl_timer);
_cancel_timer_ex(&psta->ch_sw_monitor_timer);
#endif
_cancel_timer_ex(&psta->handshake_timer);
_cancel_timer_ex(&psta->pti_timer);
}
void rtw_tdls_teardown_pre_hdl(_adapter *padapter, struct sta_info *psta)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
struct sta_priv *pstapriv = &padapter->stapriv;
rtw_cancel_tdls_timer(psta);
_rtw_spinlock_bh(&(pstapriv->sta_hash_lock));
if (ptdlsinfo->sta_cnt != 0)
ptdlsinfo->sta_cnt--;
_rtw_spinunlock_bh(&(pstapriv->sta_hash_lock));
if (ptdlsinfo->sta_cnt < MAX_ALLOWED_TDLS_STA_NUM) {
ptdlsinfo->sta_maximum = _FALSE;
_rtw_memset(&ptdlsinfo->ss_record, 0x00, sizeof(struct tdls_ss_record));
}
if (ptdlsinfo->sta_cnt == 0)
rtw_tdls_set_link_established(padapter, _FALSE);
else
RTW_INFO("Remain tdls sta:%02x\n", ptdlsinfo->sta_cnt);
}
void rtw_tdls_teardown_post_hdl(_adapter *padapter, struct sta_info *psta, u8 enqueue_cmd)
{
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
/* Clear cam */
rtw_clearstakey_cmd(padapter, psta, enqueue_cmd);
/* Update sta media status */
if (enqueue_cmd)
rtw_sta_media_status_rpt_cmd(padapter, psta, 0);
else
rtw_sta_media_status_rpt(padapter, psta, 0);
/* Set RCR if necessary */
if (ptdlsinfo->sta_cnt == 0) {
if (enqueue_cmd)
rtw_tdls_cmd(padapter, NULL, TDLS_RS_RCR);
else
rtw_hal_rcr_set_chk_bssid(padapter, MLME_TDLS_NOLINK);
}
/* Free tdls sta info */
rtw_free_stainfo(padapter, psta);
}
int rtw_tdls_is_driver_setup(_adapter *padapter)
{
return padapter->tdlsinfo.driver_setup;
}
const char *rtw_tdls_action_txt(enum TDLS_ACTION_FIELD action)
{
switch (action) {
case TDLS_SETUP_REQUEST:
return "TDLS_SETUP_REQUEST";
case TDLS_SETUP_RESPONSE:
return "TDLS_SETUP_RESPONSE";
case TDLS_SETUP_CONFIRM:
return "TDLS_SETUP_CONFIRM";
case TDLS_TEARDOWN:
return "TDLS_TEARDOWN";
case TDLS_PEER_TRAFFIC_INDICATION:
return "TDLS_PEER_TRAFFIC_INDICATION";
case TDLS_CHANNEL_SWITCH_REQUEST:
return "TDLS_CHANNEL_SWITCH_REQUEST";
case TDLS_CHANNEL_SWITCH_RESPONSE:
return "TDLS_CHANNEL_SWITCH_RESPONSE";
case TDLS_PEER_PSM_REQUEST:
return "TDLS_PEER_PSM_REQUEST";
case TDLS_PEER_PSM_RESPONSE:
return "TDLS_PEER_PSM_RESPONSE";
case TDLS_PEER_TRAFFIC_RESPONSE:
return "TDLS_PEER_TRAFFIC_RESPONSE";
case TDLS_DISCOVERY_REQUEST:
return "TDLS_DISCOVERY_REQUEST";
case TDLS_DISCOVERY_RESPONSE:
return "TDLS_DISCOVERY_RESPONSE";
default:
return "UNKNOWN";
}
}
#endif /* CONFIG_TDLS */
|
2301_81045437/rtl8852be
|
core/rtw_tdls.c
|
C
|
agpl-3.0
| 109,856
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_TRX_C_
#include <drv_types.h> /* struct dvobj_priv and etc. */
#ifdef RTW_PHL_TX
s32 rtw_core_tx_mgmt(_adapter *padapter, struct xmit_frame *pxframe)
{
pxframe->xftype = RTW_TX_DRV_MGMT;
#ifdef RTW_PHL_DBG_CMD
core_add_record(padapter, REC_TX_MGMT, pxframe);
#endif
if(core_tx_prepare_phl(padapter, pxframe) == FAIL)
return _FAIL;
if (core_tx_call_phl(padapter, pxframe, NULL) == FAIL)
return _FAIL;
return _SUCCESS;
}
#endif
#ifdef CONFIG_DRV_FAKE_AP
int rtw_fakeap_tx(struct _ADAPTER*, struct xmit_frame*);
#endif /* CONFIG_DRV_FAKE_AP */
/*rtw_hal_mgnt_xmit*/
s32 rtw_mgnt_xmit(_adapter *adapter, struct xmit_frame *pmgntframe)
{
s32 ret = _FAIL;
update_mgntframe_attrib_addr(adapter, pmgntframe);
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
if ((!MLME_IS_MESH(adapter) && SEC_IS_BIP_KEY_INSTALLED(&adapter->securitypriv) == _TRUE)
#ifdef CONFIG_RTW_MESH
|| (MLME_IS_MESH(adapter) && adapter->mesh_info.mesh_auth_id)
#endif
)
rtw_mgmt_xmitframe_coalesce(adapter, pmgntframe->pkt, pmgntframe);
#endif
#ifdef CONFIG_DRV_FAKE_AP
#ifndef RTW_PHL_TEST_FPGA
if (rtw_fakeap_tx(adapter, pmgntframe) == _SUCCESS)
return _SUCCESS;
#endif
#endif /* CONFIG_DRV_FAKE_AP */
ret = rtw_core_tx_mgmt(adapter, pmgntframe);
return ret;
}
struct lite_data_buf *rtw_alloc_litedatabuf(struct trx_data_buf_q *data_buf_q)
{
struct lite_data_buf *litedatabuf = NULL;
_list *list, *head;
_queue *free_litedatabuf_q = &data_buf_q->free_data_buf_queue;
unsigned long sp_flags;
/* RTW_INFO("+rtw_alloc_litexmitbuf\n"); */
_rtw_spinlock_irq(&free_litedatabuf_q->lock, &sp_flags);
if (_rtw_queue_empty(free_litedatabuf_q) == _TRUE)
litedatabuf = NULL;
else {
head = get_list_head(free_litedatabuf_q);
list = get_next(head);
litedatabuf = LIST_CONTAINOR(list,
struct lite_data_buf, list);
rtw_list_delete(&(litedatabuf->list));
}
if (litedatabuf != NULL) {
data_buf_q->free_data_buf_cnt--;
if (litedatabuf->sctx) {
RTW_INFO("%s plitexmitbuf->sctx is not NULL\n",
__func__);
rtw_sctx_done_err(&litedatabuf->sctx,
RTW_SCTX_DONE_BUF_ALLOC);
}
}
_rtw_spinunlock_irq(&free_litedatabuf_q->lock, &sp_flags);
return litedatabuf;
}
s32 rtw_free_litedatabuf(struct trx_data_buf_q *data_buf_q,
struct lite_data_buf *lite_data_buf)
{
_queue *free_litedatabuf_q = &data_buf_q->free_data_buf_queue;
unsigned long sp_flags;
/* RTW_INFO("+rtw_free_litexmitbuf\n"); */
if (data_buf_q == NULL)
return _FAIL;
if (lite_data_buf == NULL)
return _FAIL;
lite_data_buf->pbuf = NULL;
lite_data_buf->phl_buf_ptr = NULL;
#ifdef CONFIG_USB_HCI
lite_data_buf->dataurb = NULL;
#endif
if (lite_data_buf->sctx) {
RTW_INFO("%s lite_data_buf->sctx is not NULL\n", __func__);
rtw_sctx_done_err(&lite_data_buf->sctx, RTW_SCTX_DONE_BUF_FREE);
return _FAIL;
}
_rtw_spinlock_irq(&free_litedatabuf_q->lock, &sp_flags);
rtw_list_delete(&lite_data_buf->list);
rtw_list_insert_tail(&(lite_data_buf->list),
get_list_head(free_litedatabuf_q));
data_buf_q->free_data_buf_cnt++;
_rtw_spinunlock_irq(&free_litedatabuf_q->lock, &sp_flags);
return _SUCCESS;
}
|
2301_81045437/rtl8852be
|
core/rtw_trx.c
|
C
|
agpl-3.0
| 3,804
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_TRX_PCI_C_
#include <drv_types.h> /* struct dvobj_priv and etc. */
static void rtw_mi_pci_tasklets_kill(_adapter *padapter)
{
int i;
_adapter *iface;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
rtw_tasklet_kill(&(padapter->xmitpriv.xmit_tasklet));
}
}
}
#if 0 /*def CONFIG_TX_AMSDU*/
static s32 xmitframe_amsdu_direct(_adapter *padapter,
struct xmit_frame *pxmitframe)
{
struct xmit_buf *pxmitbuf = pxmitframe->pxmitbuf;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
s32 res = _SUCCESS;
res = rtw_xmitframe_coalesce_amsdu(padapter, pxmitframe, NULL);
if (res == _SUCCESS) {
#ifdef CONFIG_XMIT_THREAD_MODE
enqueue_pending_xmitbuf(pxmitpriv, pxmitframe->pxmitbuf);
#else
res = rtw_hal_dump_xframe(padapter, pxmitframe);
#endif
} else {
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
rtw_free_xmitframe(pxmitpriv, pxmitframe);
}
return res;
}
#endif
/********************************xmit section*****************************/
static void pci_xmit_tasklet(_adapter *padapter)
{
#ifdef CONFIG_TX_AMSDU_SW_MODE
core_tx_amsdu_tasklet(padapter);
#endif
}
s32 pci_init_xmit_priv(_adapter *adapter)
{
s32 ret = _SUCCESS;
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
_rtw_spinlock_init(&dvobj_to_pci(dvobj)->irq_th_lock);
rtw_tasklet_init(&pxmitpriv->xmit_tasklet,
(void(*)(unsigned long))pci_xmit_tasklet,
(unsigned long)adapter);
return ret;
}
void pci_free_xmit_priv(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
_rtw_spinlock_free(&dvobj_to_pci(dvobj)->irq_th_lock);
}
static s32 pci_xmit_direct(_adapter *adapter, struct xmit_frame *pxmitframe)
{
s32 res = _SUCCESS;
#if 0
#ifdef CONFIG_XMIT_THREAD_MODE
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
#endif
res = rtw_xmitframe_coalesce(adapter, pxmitframe->pkt, pxmitframe);
if (res == _SUCCESS) {
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
enqueue_pending_xmitbuf(pxmitpriv, pxmitframe->pxmitbuf);
#else
pci_dump_xframe(adapter, pxmitframe);
#endif
}
#endif
return res;
}
static s32 pci_data_xmit(_adapter *adapter, struct xmit_frame *pxmitframe)
{
s32 res;
#if 0 /*CONFIG_CORE_XMITBUF*/
struct xmit_buf *pxmitbuf = NULL;
#endif
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
#ifdef CONFIG_TX_AMSDU
int tx_amsdu = adapter->tx_amsdu;
u8 amsdu_timeout = 0;
#endif
_rtw_spinlock_bh(&pxmitpriv->lock);
if (rtw_txframes_sta_ac_pending(adapter, pattrib) > 0)
goto enqueue;
#ifndef CONFIG_XMIT_THREAD_MODE
if (rtw_hal_pci_check_enough_txdesc(GET_PHL_COM(dvobj), pattrib->qsel) == _FALSE)
goto enqueue;
if (rtw_xmit_ac_blocked(adapter) == _TRUE)
goto enqueue;
#endif
if (DEV_STA_LG_NUM(adapter->dvobj))
goto enqueue;
#ifdef CONFIG_TX_AMSDU
if (MLME_IS_STA(adapter) &&
check_amsdu_tx_support(adapter)) {
if (IS_AMSDU_AMPDU_VALID(pattrib))
goto enqueue;
}
#endif
#if 0 /*CONFIG_CORE_XMITBUF*/
pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
if (pxmitbuf == NULL)
goto enqueue;
_rtw_spinunlock_bh(&pxmitpriv->lock);
pxmitframe->pxmitbuf = pxmitbuf;
pxmitframe->buf_addr = pxmitbuf->pbuf;
pxmitbuf->priv_data = pxmitframe;
#else
_rtw_spinunlock_bh(&pxmitpriv->lock);
#endif
if (pci_xmit_direct(adapter, pxmitframe) != _SUCCESS) {
#if 0 /*CONFIG_CORE_XMITBUF*/
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
#endif
rtw_free_xmitframe(pxmitpriv, pxmitframe);
}
return _TRUE;
enqueue:
res = rtw_xmitframe_enqueue(adapter, pxmitframe);
#ifdef CONFIG_TX_AMSDU
if(res == _SUCCESS && tx_amsdu == 2)
{
amsdu_timeout = rtw_amsdu_get_timer_status(adapter, pattrib->priority);
if(amsdu_timeout == RTW_AMSDU_TIMER_SETTING)
{
rtw_amsdu_cancel_timer(adapter, pattrib->priority);
rtw_amsdu_set_timer_status(adapter, pattrib->priority,
RTW_AMSDU_TIMER_UNSET);
}
}
#endif
_rtw_spinunlock_bh(&pxmitpriv->lock);
if (res != _SUCCESS) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
pxmitpriv->tx_drop++;
return _TRUE;
}
#ifdef CONFIG_TX_AMSDU
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
#endif
return _FALSE;
}
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
/*
* Description
* Transmit xmitbuf to hardware tx fifo
*
* Return
* _SUCCESS ok
* _FAIL something error
*/
s32 pci_xmit_buf_handler(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct xmit_priv *pxmitpriv;
struct xmit_buf *pxmitbuf;
struct xmit_frame *pxmitframe;
s32 ret;
pxmitpriv = &adapter->xmitpriv;
ret = _rtw_down_sema(&pxmitpriv->xmit_sema);
if (ret == _FAIL) {
RTW_ERR("%s: down XmitBufSema fail!\n", __FUNCTION__);
return _FAIL;
}
if (RTW_CANNOT_RUN(dvobj)) {
RTW_INFO("%s: bDriverStopped(%s) bSurpriseRemoved(%s)!\n"
, __func__
, dev_is_drv_stopped(dvobj) ? "True" : "False"
, dev_is_surprise_removed(dvobj) ? "True" : "False");
return _FAIL;
}
if (check_pending_xmitbuf(pxmitpriv) == _FALSE)
return _SUCCESS;
#ifdef CONFIG_LPS_LCLK
ret = rtw_register_tx_alive(adapter);
if (ret != _SUCCESS) {
RTW_INFO("%s: wait to leave LPS_LCLK\n", __FUNCTION__);
return _SUCCESS;
}
#endif
do {
pxmitbuf = select_and_dequeue_pending_xmitbuf(adapter);
if (pxmitbuf == NULL)
break;
pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data;
if (rtw_hal_pci_check_enough_txdesc(GET_PHL_COM(dvobj),
pxmitframe->attrib.qsel) == _FALSE) {
enqueue_pending_xmitbuf_to_head(pxmitpriv, pxmitbuf);
break;
}
pci_dump_xframe(adapter, pxmitframe);
} while (1);
return _SUCCESS;
}
#endif
s32 pci_xmitframe_enqueue(_adapter *adapter,
struct xmit_frame *pxmitframe)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
s32 err;
err = rtw_xmitframe_enqueue(adapter, pxmitframe);
if (err != _SUCCESS) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
pxmitpriv->tx_drop++;
} else {
if (rtw_hal_pci_check_enough_txdesc(GET_PHL_COM(dvobj),
pxmitframe->attrib.qsel) == _TRUE)
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
}
return err;
}
/******************************** recv section*******************************/
s32 pci_init_recv_priv(struct dvobj_priv *dvobj)
{
s32 ret = _SUCCESS;
return ret;
}
void pci_free_recv_priv(struct dvobj_priv *dvobj)
{
}
struct rtw_intf_ops pci_ops = {
.init_xmit_priv = pci_init_xmit_priv,
.free_xmit_priv = pci_free_xmit_priv,
.data_xmit = pci_data_xmit,
.xmitframe_enqueue = pci_xmitframe_enqueue,
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
.xmit_buf_handler = pci_xmit_buf_handler
#endif
.init_recv_priv = pci_init_recv_priv,
.free_recv_priv = pci_free_recv_priv,
};
|
2301_81045437/rtl8852be
|
core/rtw_trx_pci.c
|
C
|
agpl-3.0
| 7,566
|
/******************************************************************************
*
* Copyright(c) 2015 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_TRX_SDIO_C_
#include <drv_types.h> /* struct dvobj_priv and etc. */
#include <drv_types_sdio.h> /* RTW_SDIO_ADDR_CMD52_GEN */
#include <rtw_sdio.h>
#define CONFIG_NEW_SDIO_WP_FUNC
#ifdef CONFIG_NEW_SDIO_WP_FUNC
/*
* Description:
* Write to TX FIFO
* Align write size to block size,
* and check enough FIFO size to write.
*
* Parameters:
* addr not use
* cnt size to write
* mem struct xmit_buf*
*
* Return:
* _SUCCESS(1) Success
* _FAIL(0) Fail
*/
static u32 rtw_sdio_xmit(struct dvobj_priv *d, u32 txaddr, u32 cnt, u8 *mem)
{
u32 txsize;
u32 ret = _FAIL;
cnt = _RND4(cnt);
/* align size to guarantee I/O would be done in one command */
txsize = rtw_sdio_cmd53_align_size(d, cnt);
ret = rtw_sdio_write_cmd53(d, txaddr, mem, txsize);
/*GEORGIA_TODO_FIXIT_MOVE_TO_CALLER*/
/*rtw_sctx_done_err(&xmitbuf->sctx,
(_FAIL == ret) ? RTW_SCTX_DONE_WRITE_PORT_ERR : RTW_SCTX_DONE_SUCCESS);*/
exit :
return ret;
}
#else
static u32 rtw_sdio_xmit(struct dvobj_priv *d, u32 txaddr, u32 cnt, u8 *mem)
{
s32 err;
u32 txaddr;
cnt = _RND4(cnt);
cnt = rtw_sdio_cmd53_align_size(d, cnt);
err = sd_write(d, txaddr, cnt, mem);
/*GEORGIA_TODO_FIXIT_MOVE_TO_CALLER*/
/*rtw_sctx_done_err(&xmitbuf->sctx,
err ? RTW_SCTX_DONE_WRITE_PORT_ERR : RTW_SCTX_DONE_SUCCESS);*/
if (err) {
RTW_ERR("%s, error=%d\n", __func__, err);
return _FAIL;
}
return _SUCCESS;
}
#endif
/********************************xmit section*******************************/
#ifdef CONFIG_TX_AMSDU_SW_MODE
static void sdio_xmit_tasklet(_adapter *padapter)
{
core_tx_amsdu_tasklet(padapter);
}
#endif
s32 sdio_init_xmit_priv(_adapter *adapter)
{
#ifdef CONFIG_TX_AMSDU_SW_MODE
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
rtw_tasklet_init(&xmitpriv->xmit_tasklet,
(void(*)(unsigned long))sdio_xmit_tasklet,
(unsigned long)adapter);
#endif
return _SUCCESS;
}
void sdio_free_xmit_priv(_adapter *adapter)
{
#if 0 /*CONFIG_CORE_XMITBUF*/
struct xmit_priv *pxmitpriv;
struct xmit_buf *pxmitbuf;
_queue *pqueue;
_list *plist, *phead;
_list tmplist;
pxmitpriv = &adapter->xmitpriv;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
phead = get_list_head(pqueue);
_rtw_init_listhead(&tmplist);
_rtw_spinlock_bh(&pqueue->lock);
if (_rtw_queue_empty(pqueue) == _FALSE) {
/*
* Insert tmplist to end of queue, and delete phead
* then tmplist become head of queue.
*/
rtw_list_insert_tail(&tmplist, phead);
rtw_list_delete(phead);
}
_rtw_spinunlock_bh(&pqueue->lock);
phead = &tmplist;
while (rtw_is_list_empty(phead) == _FALSE) {
plist = get_next(phead);
rtw_list_delete(plist);
pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
rtw_free_xmitframe(pxmitpriv, (struct xmit_frame *)pxmitbuf->priv_data);
pxmitbuf->priv_data = NULL;
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
}
#endif
}
/*
* Description:
* Handle xmitframe(packet) come from rtw_xmit()
*
* Return:
* _TRUE handle packet directly, maybe ok or drop
* _FALSE enqueue, temporary can't transmit packets to hardware
*/
s32 sdio_data_xmit(_adapter *adapter, struct xmit_frame *pxmitframe)
{
struct xmit_priv *pxmitpriv;
s32 err;
pxmitframe->attrib.qsel = pxmitframe->attrib.priority;
pxmitpriv = &adapter->xmitpriv;
#ifdef CONFIG_80211N_HT
if ((pxmitframe->frame_tag == DATA_FRAMETAG)
&& (pxmitframe->attrib.ether_type != 0x0806)
&& (pxmitframe->attrib.ether_type != 0x888e)
&& (pxmitframe->attrib.dhcp_pkt != 1)) {
rtw_issue_addbareq_cmd(adapter, pxmitframe, _TRUE);
}
#endif /* CONFIG_80211N_HT */
_rtw_spinlock_bh(&pxmitpriv->lock);
err = rtw_xmitframe_enqueue(adapter, pxmitframe);
_rtw_spinunlock_bh(&pxmitpriv->lock);
if (err != _SUCCESS) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
pxmitpriv->tx_drop++;
return _TRUE;
}
#ifdef CONFIG_SDIO_TX_TASKLET
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
#else
_rtw_up_sema(&pxmitpriv->SdioXmitSema);
#endif
return _FALSE;
}
/*
* Description:
* Aggregation packets and send to hardware
*
* Return:
* 0 Success
* -1 Hardware resource(TX FIFO) not ready
* -2 Software resource(xmitbuf) not ready
*/
/*SDIO bus-agg*/
static s32 _sdio_xmit_xmitframes(_adapter *adapter, struct xmit_priv *pxmitpriv)
{
s32 err = 0;
return err;
}
/*
* Description
* Transmit xmitframe from queue
*
* Return
* _SUCCESS ok
* _FAIL something error
*/
static s32 _sdio_xmit_frame_handler(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
s32 ret;
ret = _rtw_down_sema(&pxmitpriv->SdioXmitSema);
if (_FAIL == ret) {
RTW_ERR("%s: down sema fail!\n", __FUNCTION__);
return _FAIL;
}
next:
if (RTW_CANNOT_RUN(dvobj)) {
RTW_DBG(FUNC_ADPT_FMT "- bDriverStopped(%s) bSurpriseRemoved(%s)\n",
FUNC_ADPT_ARG(adapter),
dev_is_drv_stopped(dvobj) ? "True" : "False",
dev_is_surprise_removed(dvobj) ? "True" : "False");
return _FAIL;
}
_rtw_spinlock_bh(&pxmitpriv->lock);
ret = rtw_txframes_pending(adapter);
_rtw_spinunlock_bh(&pxmitpriv->lock);
/* All queues are empty! */
if (ret == 0)
return _SUCCESS;
/* Dequeue frame and agg-tx then enqueue pending xmitbuf-queue */
ret = _sdio_xmit_xmitframes(adapter, pxmitpriv);
if (ret == -2) {
/* here sleep 1ms will cause big TP loss of TX */
/* from 50+ to 40+ */
if (adapter->registrypriv.wifi_spec)
rtw_msleep_os(1);
else
#ifdef CONFIG_REDUCE_TX_CPU_LOADING
rtw_msleep_os(1);
#else
rtw_yield_os();
#endif
goto next;
}
_rtw_spinlock_bh(&pxmitpriv->lock);
ret = rtw_txframes_pending(adapter);
_rtw_spinunlock_bh(&pxmitpriv->lock);
if (ret == 1)
goto next;
return _SUCCESS;
}
thread_return _sdio_xmit_frame_thread(thread_context context)
{
s32 ret;
_adapter *adapter;
struct xmit_priv *pxmitpriv;
u8 thread_name[20] = {0};
ret = _SUCCESS;
adapter = (_adapter *)context;
pxmitpriv = &adapter->xmitpriv;
rtw_sprintf(thread_name, 20, "RTWHALXT-"ADPT_FMT, ADPT_ARG(adapter));
rtw_thread_enter(thread_name);
RTW_INFO("start "FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
do {
ret = _sdio_xmit_frame_handler(adapter);
flush_signals_thread();
} while (_SUCCESS == ret);
RTW_INFO(FUNC_ADPT_FMT " Exit\n", FUNC_ADPT_ARG(adapter));
rtw_thread_wait_stop();
return 0;
}
u8 sdio_start_xmit_frame_thread(_adapter *adapter)
{
u8 _status = _SUCCESS;
#ifndef CONFIG_SDIO_TX_TASKLET
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
if (xmitpriv->SdioXmitThread == NULL) {
RTW_INFO(FUNC_ADPT_FMT " start RTWHALXT\n", FUNC_ADPT_ARG(adapter));
xmitpriv->SdioXmitThread = rtw_thread_start(_sdio_xmit_frame_thread, adapter, "RTWHALXT");
if (xmitpriv->SdioXmitThread == NULL) {
RTW_ERR("%s: start _sdio_xmit_frame_thread FAIL!!\n", __FUNCTION__);
_status = _FAIL;
}
}
#endif /* !CONFIG_SDIO_TX_TASKLET */
return _status;
}
void sdio_cancel_xmit_frame_thread(_adapter *adapter)
{
#ifndef CONFIG_SDIO_TX_TASKLET
struct xmit_priv *xmitpriv = &adapter->xmitpriv;
/* stop xmit_buf_thread */
if (xmitpriv->SdioXmitThread) {
_rtw_up_sema(&xmitpriv->SdioXmitSema);
rtw_thread_stop(xmitpriv->SdioXmitThread);
xmitpriv->SdioXmitThread = NULL;
}
#endif /* !CONFIG_SDIO_TX_TASKLET */
}
s32 sdio_dequeue_xmit(_adapter *adapter)
{
#if 0
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(adapter);
struct xmit_buf *pxmitbuf;
u32 polling_num = 0;
u32 txaddr = 0;
#ifdef CONFIG_SDIO_TX_ENABLE_AVAL_INT
#endif
pxmitbuf = select_and_dequeue_pending_xmitbuf(adapter);
if (pxmitbuf == NULL)
return _TRUE;
#ifdef CONFIG_SDIO_TX_ENABLE_AVAL_INT
query_free_page:
/* Total number of page is NOT available, so update current FIFO status*/
u8 bUpdatePageNum = _FALSE;
if (!bUpdatePageNum) {
HalQueryTxBufferStatus8821CSdio(adapter);
bUpdatePageNum = _TRUE;
goto query_free_page;
} else {
bUpdatePageNum = _FALSE;
enqueue_pending_xmitbuf_to_head(pxmitpriv, pxmitbuf);
return _TRUE;
}
#endif
if (_TRUE == rtw_is_xmit_blocked(adapter)) {
enqueue_pending_xmitbuf_to_head(pxmitpriv, pxmitbuf);
/*rtw_msleep_os(1);*/
return _FALSE;
}
/* check if hardware tx fifo page is enough */
while (rtw_halmac_sdio_tx_allowed(pdvobjpriv, pxmitbuf->pdata, pxmitbuf->len)) {
if (RTW_CANNOT_RUN(adapter_to_dvobj(adapter))) {
RTW_INFO("%s: bSurpriseRemoved(write port)\n", __func__);
goto free_xmitbuf;
}
polling_num++;
/* Only polling (0x7F / 10) times here, since rtw_halmac_sdio_tx_allowed() has polled 10 times within */
if ((polling_num % 6) == 0) {
enqueue_pending_xmitbuf_to_head(pxmitpriv, pxmitbuf);
rtw_msleep_os(1);
return _FALSE;
}
}
#ifdef CONFIG_CHECK_LEAVE_LPS
#ifdef CONFIG_LPS_CHK_BY_TP
if (!adapter_to_pwrctl(adapter)->lps_chk_by_tp)
#endif
traffic_check_for_leave_lps(adapter, _TRUE, pxmitbuf->agg_num);
#endif
if (_TRUE == rtw_is_xmit_blocked(adapter)) {
enqueue_pending_xmitbuf_to_head(pxmitpriv, pxmitbuf);
/*rtw_msleep_os(1);*/
return _FALSE;
}
/*sdio_write_port(adapter, pxmitbuf->len, (u8 *)pxmitbuf);*/
txaddr = rtw_hal_sdio_get_tx_addr(GET_PHL_COM(pdvobjpriv),
pxmitbuf->pdata, pxmitbuf->len);
rtw_sdio_xmit(adapter, txaddr, pxmitbuf->len, (u8 *)pxmitbuf);
free_xmitbuf:
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
#ifdef CONFIG_SDIO_TX_TASKLET
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
#endif
#endif
return _FALSE;
}
/*
* Description
* Transmit xmitbuf to hardware tx fifo
*
* Return
* _SUCCESS ok
* _FAIL something error
*/
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
s32 sdio_xmit_buf_handler(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct xmit_priv *pxmitpriv;
u8 queue_empty, queue_pending;
s32 ret;
pxmitpriv = &adapter->xmitpriv;
ret = _rtw_down_sema(&pxmitpriv->xmit_sema);
if (_FAIL == ret) {
RTW_ERR("%s: down SdioXmitBufSema fail!\n", __FUNCTION__);
return _FAIL;
}
if (RTW_CANNOT_RUN(dvobj)) {
RTW_DBG(FUNC_ADPT_FMT "- bDriverStopped(%s) bSurpriseRemoved(%s)\n",
FUNC_ADPT_ARG(adapter),
dev_is_drv_stopped(dvobj) ? "True" : "False",
dev_is_surprise_removed(dvobj) ? "True" : "False");
return _FAIL;
}
if (rtw_mi_check_pending_xmitbuf(adapter) == 0)
return _SUCCESS;
#ifdef CONFIG_LPS_LCLK
ret = rtw_register_tx_alive(adapter);
if (ret != _SUCCESS)
return _SUCCESS;
#endif
do {
queue_empty = rtw_mi_sdio_dequeue_xmit(adapter);
} while (!queue_empty);
#ifdef CONFIG_LPS_LCLK
rtw_unregister_tx_alive(adapter);
#endif
return _SUCCESS;
}
#endif
/*
* Description:
* Enqueue xmitframe
*
* Return:
* _TRUE enqueue ok
* _FALSE fail
*/
s32 sdio_xmitframe_enqueue(_adapter *adapter, struct xmit_frame *pxmitframe)
{
struct xmit_priv *pxmitpriv;
s32 ret;
pxmitpriv = &adapter->xmitpriv;
ret = rtw_xmitframe_enqueue(adapter, pxmitframe);
if (ret != _SUCCESS) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
pxmitpriv->tx_drop++;
return _FALSE;
}
#ifdef CONFIG_SDIO_TX_TASKLET
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
#else /* !CONFIG_SDIO_TX_TASKLET */
_rtw_up_sema(&pxmitpriv->SdioXmitSema);
#endif /* !CONFIG_SDIO_TX_TASKLET */
return _TRUE;
}
/******************************** recv section******************************/
static s32 sdio_recv_hdl(_adapter *adapter)
{
return _SUCCESS;
}
s32 sdio_init_recv_priv(struct dvobj_priv *dvobj)
{
s32 res = _SUCCESS;
return res;
}
/*
* Free recv private variable of hardware dependent
* 1. recv buf
* 2. recv tasklet
*/
void sdio_free_recv_priv(struct dvobj_priv *dvobj)
{
}
struct rtw_intf_ops sdio_ops = {
.read = rtw_sdio_raw_read,
.write = rtw_sdio_raw_write,
/****************** data path *****************/
/****************** xmit *********************/
.init_xmit_priv = sdio_init_xmit_priv,
.free_xmit_priv = sdio_free_xmit_priv,
.data_xmit = sdio_data_xmit,
.xmitframe_enqueue = sdio_xmitframe_enqueue,
.start_xmit_frame_thread = sdio_start_xmit_frame_thread,
.cancel_xmit_frame_thread = sdio_cancel_xmit_frame_thread,
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
.xmit_buf_handler = sdio_xmit_buf_handler,
#endif
/****************** recv *********************/
.init_recv_priv = sdio_init_recv_priv,
.free_recv_priv = sdio_free_recv_priv,
#ifdef CONFIG_RECV_THREAD_MODE
.recv_hdl = sdio_recv_hdl,
#endif
};
|
2301_81045437/rtl8852be
|
core/rtw_trx_sdio.c
|
C
|
agpl-3.0
| 12,983
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_TRX_USB_C_
#include <drv_types.h> /* struct dvobj_priv and etc. */
/********************************xmit section*******************************/
#ifdef CONFIG_USB_TX_AGGREGATION
#define IDEA_CONDITION 1 /* check all packets before enqueue */
static s32 usb_xmitframe_process(_adapter *padapter,
struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
return _TRUE;
}
#else /* CONFIG_USB_TX_AGGREGATION */
static s32 usb_xmitframe_process(_adapter *padapter,
struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
return _TRUE;
}
#endif
static void usb_xmit_tasklet(_adapter *padapter)
{
#ifdef CONFIG_TX_AMSDU_SW_MODE
core_tx_amsdu_tasklet(padapter);
#endif
}
s32 usb_init_xmit_priv(_adapter *adapter)
{
s32 ret = _SUCCESS;
struct xmit_priv *pxmitpriv = &adapter->xmitpriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
rtw_tasklet_init(&pxmitpriv->xmit_tasklet,
(void(*)(unsigned long))usb_xmit_tasklet,
(unsigned long)adapter);
return _SUCCESS;
}
void usb_free_xmit_priv(_adapter *adapter)
{
}
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
/*
* Description
* Transmit xmitbuf to hardware tx fifo
*
* Return
* _SUCCESS ok
* _FAIL something error
*/
s32 usb_xmit_buf_handler(_adapter *adapter)
{
return _SUCCESS;
}
#endif /* CONFIG_XMIT_THREAD_MODE */
s32 usb_xmitframe_enqueue(_adapter *adapter, struct xmit_frame *pxmitframe)
{
return _SUCCESS;
}
/******************************** recv section*******************************/
int usb_init_recv_priv(struct dvobj_priv *dvobj)
{
int res = _SUCCESS;
return res;
}
void usb_free_recv_priv(struct dvobj_priv *dvobj)
{
}
struct rtw_intf_ops usb_ops = {
.init_xmit_priv = usb_init_xmit_priv,
.free_xmit_priv = usb_free_xmit_priv,
.xmitframe_enqueue = usb_xmitframe_enqueue,
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
.xmit_buf_handler = usb_xmit_buf_handler,
#endif
.init_recv_priv = usb_init_recv_priv,
.free_recv_priv = usb_free_recv_priv,
};
|
2301_81045437/rtl8852be
|
core/rtw_trx_usb.c
|
C
|
agpl-3.0
| 2,621
|
/******************************************************************************
*
* Copyright(c) 2007 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_VHT_C
#include <drv_types.h>
#ifdef CONFIG_80211AC_VHT
const u16 _vht_max_mpdu_len[] = {
3895,
7991,
11454,
0,
};
const u8 _vht_sup_ch_width_set_to_bw_cap[] = {
BW_CAP_80M,
BW_CAP_80M | BW_CAP_160M,
BW_CAP_80M | BW_CAP_160M | BW_CAP_80_80M,
0,
};
const char *const _vht_sup_ch_width_set_str[] = {
"80MHz",
"160MHz",
"160MHz & 80+80MHz",
"BW-RSVD",
};
void dump_vht_cap_ie_content(void *sel, const u8 *buf, u32 buf_len)
{
if (buf_len != VHT_CAP_IE_LEN) {
RTW_PRINT_SEL(sel, "Invalid VHT capability IE len:%d != %d\n", buf_len, VHT_CAP_IE_LEN);
return;
}
RTW_PRINT_SEL(sel, "cap_info:%02x %02x %02x %02x: MAX_MPDU_LEN:%u %s%s%s%s%s RX-STBC:%u MAX_AMPDU_LEN:%u\n"
, *(buf), *(buf + 1), *(buf + 2), *(buf + 3)
, vht_max_mpdu_len(GET_VHT_CAPABILITY_ELE_MAX_MPDU_LENGTH(buf))
, vht_sup_ch_width_set_str(GET_VHT_CAPABILITY_ELE_CHL_WIDTH(buf))
, GET_VHT_CAPABILITY_ELE_RX_LDPC(buf) ? " RX-LDPC" : ""
, GET_VHT_CAPABILITY_ELE_SHORT_GI80M(buf) ? " SGI-80" : ""
, GET_VHT_CAPABILITY_ELE_SHORT_GI160M(buf) ? " SGI-160" : ""
, GET_VHT_CAPABILITY_ELE_TX_STBC(buf) ? " TX-STBC" : ""
, GET_VHT_CAPABILITY_ELE_RX_STBC(buf)
, VHT_MAX_AMPDU_LEN(GET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(buf))
);
}
void dump_vht_cap_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *vht_cap_ie;
sint vht_cap_ielen;
vht_cap_ie = rtw_get_ie(ie, WLAN_EID_VHT_CAPABILITY, &vht_cap_ielen, ie_len);
if (!ie || vht_cap_ie != ie)
return;
dump_vht_cap_ie_content(sel, vht_cap_ie + 2, vht_cap_ielen);
}
const char *const _vht_op_ch_width_str[] = {
"20 or 40MHz",
"80MHz",
"160MHz",
"80+80MHz",
"BW-RSVD",
};
void dump_vht_op_ie_content(void *sel, const u8 *buf, u32 buf_len)
{
if (buf_len != VHT_OP_IE_LEN) {
RTW_PRINT_SEL(sel, "Invalid VHT operation IE len:%d != %d\n", buf_len, VHT_OP_IE_LEN);
return;
}
RTW_PRINT_SEL(sel, "\tVHT Operation Info:\n");
RTW_PRINT_SEL(sel, "\tChannel Width: %u\n"
, GET_VHT_OPERATION_ELE_CHL_WIDTH(buf));
RTW_PRINT_SEL(sel, "\tCenter Frequency Channel for 80 and 160 MHz Operation: %u\n"
, GET_VHT_OPERATION_ELE_CENTER_FREQ1(buf));
RTW_PRINT_SEL(sel, "\tCenter Frequency Channel for 80+80 MHz Operation: %u\n"
, GET_VHT_OPERATION_ELE_CENTER_FREQ2(buf));
RTW_PRINT_SEL(sel, "\tVHT Basic MCS Set: 0x%04x\n"
, GET_VHT_OPERATION_ELE_BASIC_MCS_SET(buf));
}
void dump_vht_op_ie(void *sel, const u8 *ie, u32 ie_len)
{
const u8 *vht_op_ie;
sint vht_op_ielen;
vht_op_ie = rtw_get_ie(ie, WLAN_EID_VHT_OPERATION, &vht_op_ielen, ie_len);
if (!ie || vht_op_ie != ie)
return;
dump_vht_op_ie_content(sel, vht_op_ie + 2, vht_op_ielen);
}
/* 20/40/80, ShortGI, MCS Rate */
const u16 VHT_MCS_DATA_RATE[3][2][30] = {
{ {
13, 26, 39, 52, 78, 104, 117, 130, 156, 156,
26, 52, 78, 104, 156, 208, 234, 260, 312, 312,
39, 78, 117, 156, 234, 312, 351, 390, 468, 520
}, /* Long GI, 20MHz */
{
14, 29, 43, 58, 87, 116, 130, 144, 173, 173,
29, 58, 87, 116, 173, 231, 260, 289, 347, 347,
43, 87, 130, 173, 260, 347, 390, 433, 520, 578
}
}, /* Short GI, 20MHz */
{ {
27, 54, 81, 108, 162, 216, 243, 270, 324, 360,
54, 108, 162, 216, 324, 432, 486, 540, 648, 720,
81, 162, 243, 324, 486, 648, 729, 810, 972, 1080
}, /* Long GI, 40MHz */
{
30, 60, 90, 120, 180, 240, 270, 300, 360, 400,
60, 120, 180, 240, 360, 480, 540, 600, 720, 800,
90, 180, 270, 360, 540, 720, 810, 900, 1080, 1200
}
}, /* Short GI, 40MHz */
{ {
59, 117, 176, 234, 351, 468, 527, 585, 702, 780,
117, 234, 351, 468, 702, 936, 1053, 1170, 1404, 1560,
176, 351, 527, 702, 1053, 1404, 1580, 1755, 2106, 2340
}, /* Long GI, 80MHz */
{
65, 130, 195, 260, 390, 520, 585, 650, 780, 867,
130, 260, 390, 520, 780, 1040, 1170, 1300, 1560, 1734,
195, 390, 585, 780, 1170, 1560, 1755, 1950, 2340, 2600
}
} /* Short GI, 80MHz */
};
u8 rtw_get_vht_highest_rate(u8 *pvht_mcs_map)
{
u8 i, j;
u8 bit_map;
u8 vht_mcs_rate = 0;
for (i = 0; i < 2; i++) {
if (pvht_mcs_map[i] != 0xff) {
for (j = 0; j < 8; j += 2) {
bit_map = (pvht_mcs_map[i] >> j) & 3;
if (bit_map != 3)
vht_mcs_rate = MGN_VHT1SS_MCS7 + 10 * j / 2 + i * 40 + bit_map; /* VHT rate indications begin from 0x90 */
}
}
}
/* RTW_INFO("HighestVHTMCSRate is %x\n", vht_mcs_rate); */
return vht_mcs_rate;
}
u8 rtw_vht_mcsmap_to_nss(u8 *pvht_mcs_map)
{
u8 i, j;
u8 bit_map;
u8 nss = 0;
for (i = 0; i < 2; i++) {
if (pvht_mcs_map[i] != 0xff) {
for (j = 0; j < 8; j += 2) {
bit_map = (pvht_mcs_map[i] >> j) & 3;
if (bit_map != 3)
nss++;
}
}
}
/* RTW_INFO("%s : %dSS\n", __FUNCTION__, nss); */
return nss;
}
void rtw_vht_nss_to_mcsmap(u8 nss, u8 *target_mcs_map, u8 *cur_mcs_map)
{
u8 i, j;
u8 cur_rate, target_rate;
for (i = 0; i < 2; i++) {
target_mcs_map[i] = 0;
for (j = 0; j < 8; j += 2) {
cur_rate = (cur_mcs_map[i] >> j) & 3;
if (cur_rate == 3) /* 0x3 indicates not supported that num of SS */
target_rate = 3;
else if (nss <= ((j / 2) + i * 4))
target_rate = 3;
else
target_rate = cur_rate;
target_mcs_map[i] |= (target_rate << j);
}
}
/* RTW_INFO("%s : %dSS\n", __FUNCTION__, nss); */
}
u16 rtw_vht_mcs_to_data_rate(u8 bw, u8 short_GI, u8 vht_mcs_rate)
{
if (vht_mcs_rate > MGN_VHT3SS_MCS9)
vht_mcs_rate = MGN_VHT3SS_MCS9;
/* RTW_INFO("bw=%d, short_GI=%d, ((vht_mcs_rate - MGN_VHT1SS_MCS0)&0x3f)=%d\n", bw, short_GI, ((vht_mcs_rate - MGN_VHT1SS_MCS0)&0x3f)); */
return VHT_MCS_DATA_RATE[bw][short_GI][((vht_mcs_rate - MGN_VHT1SS_MCS0) & 0x3f)];
}
/* Initialized vhtpriv by PHL default setting */
void rtw_vht_get_dft_setting(_adapter *padapter,
struct protocol_cap_t *dft_proto_cap, struct role_cap_t *dft_cap)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
BOOLEAN bHwLDPCSupport = _FALSE, bHwSTBCSupport = _FALSE;
u8 stbc_rx = 0;
#ifdef CONFIG_BEAMFORMING
BOOLEAN bHwSupportBeamformer = _FALSE, bHwSupportBeamformee = _FALSE;
u8 mu_bfer, mu_bfee;
#endif /* CONFIG_BEAMFORMING */
u8 tx_nss, rx_nss;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
/* Short GI */
pvhtpriv->sgi_80m = ((dft_proto_cap->sgi_80)
&& rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_80M)
&& TEST_FLAG(pregistrypriv->short_gi, BIT2));
pvhtpriv->sgi_160m = ((dft_proto_cap->sgi_160)
&& rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_160M)
&& TEST_FLAG(pregistrypriv->short_gi, BIT3));
/* LDPC */
bHwLDPCSupport = (dft_proto_cap->vht_ldpc) ? _TRUE : _FALSE;
if (bHwLDPCSupport) {
if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT0))
SET_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX);
}
bHwLDPCSupport = (dft_cap->tx_vht_ldpc) ? _TRUE : _FALSE;
if (bHwLDPCSupport) {
if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT1))
SET_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX);
}
if (pvhtpriv->ldpc_cap)
RTW_INFO("[VHT] Support LDPC = 0x%02X\n", pvhtpriv->ldpc_cap);
/* STBC */
if (dft_proto_cap->stbc_vht_tx)
SET_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX);
if (dft_proto_cap->stbc_vht_rx)
SET_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX);
if (pvhtpriv->stbc_cap)
RTW_INFO("[VHT] Support STBC = 0x%02X\n", pvhtpriv->stbc_cap);
/* Beamforming setting */
#ifdef CONFIG_BEAMFORMING
/* only enable beamforming in STA client mode */
if (MLME_IS_STA(padapter) && !MLME_IS_GC(padapter)
&& !MLME_IS_ADHOC(padapter)
&& !MLME_IS_MESH(padapter))
{
bHwSupportBeamformer = (dft_proto_cap->vht_su_bfmr) ? _TRUE : _FALSE;
bHwSupportBeamformee = (dft_proto_cap->vht_su_bfme) ? _TRUE : _FALSE;
mu_bfer = (dft_proto_cap->vht_mu_bfmr) ? _TRUE : _FALSE;
mu_bfee = (dft_proto_cap->vht_mu_bfme) ? _TRUE : _FALSE;
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT0) && bHwSupportBeamformer) {
#ifdef CONFIG_CONCURRENT_MODE
if ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
RTW_INFO("[VHT] CONCURRENT AP Support Beamformer\n");
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT(2))
&& (_TRUE == mu_bfer)) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO AP\n");
}
pvhtpriv->num_snd_dim = dft_proto_cap->num_snd_dim;
} else
RTW_INFO("[VHT] CONCURRENT not AP ;not allow Support Beamformer\n");
#else
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
RTW_INFO("[VHT] Support Beamformer\n");
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT(2))
&& (_TRUE == mu_bfer)
&& ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE)) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO AP\n");
}
#endif
}
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT1) && bHwSupportBeamformee) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
RTW_INFO("[VHT] Support Beamformee\n");
pvhtpriv->bfme_sts = dft_proto_cap->bfme_sts;
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT(3))
&& (_TRUE == mu_bfee)
&& ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO STA\n");
}
}
}
#endif /* CONFIG_BEAMFORMING */
/* We don't support these features, and PHL doesn't define */
pvhtpriv->txop_ps = 0;
pvhtpriv->htc_vht = 1;
pvhtpriv->link_adap_cap = 0;
pvhtpriv->tx_ant_pattern= 0;
pvhtpriv->rx_ant_pattern= 0;
pvhtpriv->ext_nss_bw = 0;
pvhtpriv->ampdu_len = pregistrypriv->ampdu_factor;
pvhtpriv->max_mpdu_len = dft_proto_cap->max_amsdu_len;
tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
rx_nss = GET_HAL_RX_NSS(adapter_to_dvobj(padapter));
/* for now, vhtpriv.vht_mcs_map comes from RX NSS */
rtw_vht_nss_to_mcsmap(rx_nss, pvhtpriv->vht_mcs_map, pregistrypriv->vht_rx_mcs_map);
pvhtpriv->vht_highest_rate = rtw_get_vht_highest_rate(pvhtpriv->vht_mcs_map);
}
/* Initialized vhtpriv by adapter real setting */
void rtw_vht_get_real_setting(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
#ifdef CONFIG_BEAMFORMING
BOOLEAN bHwSupportBeamformer = _FALSE, bHwSupportBeamformee = _FALSE;
u8 mu_bfer, mu_bfee;
#endif /* CONFIG_BEAMFORMING */
u8 tx_nss, rx_nss;
u8 rf_type = 0;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *proto_cap = &(wrole->proto_role_cap);
struct role_cap_t *cap = &(wrole->cap);
/* Short GI */
pvhtpriv->sgi_80m = ((proto_cap->sgi_80)
&& rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_80M)
&& TEST_FLAG(pregistrypriv->short_gi, BIT2));
pvhtpriv->sgi_160m = ((proto_cap->sgi_160)
&& rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_160M)
&& TEST_FLAG(pregistrypriv->short_gi, BIT3));
/* LDPC support */
if (proto_cap->vht_ldpc)
SET_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX);
if (cap->tx_vht_ldpc)
SET_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX);
if (pvhtpriv->ldpc_cap)
RTW_INFO("[VHT] Support LDPC = 0x%02X\n", pvhtpriv->ldpc_cap);
/* STBC */
if (proto_cap->stbc_vht_tx)
SET_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX);
if (proto_cap->stbc_vht_rx) {
SET_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX);
pvhtpriv->rx_stbc_nss = proto_cap->stbc_vht_rx;
}
if (pvhtpriv->stbc_cap)
RTW_INFO("[VHT] Support STBC = 0x%02X\n", pvhtpriv->stbc_cap);
/* Beamforming setting */
CLEAR_FLAGS(pvhtpriv->beamform_cap);
#ifdef CONFIG_BEAMFORMING
if (proto_cap->vht_su_bfmr) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
RTW_INFO("[VHT] HAL Support Beamformer\n");
if (proto_cap->vht_mu_bfmr) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO AP\n");
}
}
if (proto_cap->vht_su_bfme) {
u8 bfme_sts = 0;
rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMEE_CAP, (u8 *)&bfme_sts);
pvhtpriv->bfme_sts = bfme_sts;
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
RTW_INFO("[VHT] HAL Support Beamformee\n");
if (proto_cap->vht_mu_bfme) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO STA\n");
}
}
#endif
/* ToDo: check bfee flow will move change role type and modify wifi_role->proto_role_cap */
#if 0
#ifdef CONFIG_BEAMFORMING
/* only enable beamforming in STA client mode */
if (MLME_IS_STA(padapter) && !MLME_IS_GC(padapter)
&& !MLME_IS_ADHOC(padapter)
&& !MLME_IS_MESH(padapter))
{
rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMER,
(u8 *)&bHwSupportBeamformer);
rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMEE,
(u8 *)&bHwSupportBeamformee);
mu_bfer = _FALSE;
mu_bfee = _FALSE;
rtw_hal_get_def_var(padapter, HAL_DEF_VHT_MU_BEAMFORMER, &mu_bfer);
rtw_hal_get_def_var(padapter, HAL_DEF_VHT_MU_BEAMFORMEE, &mu_bfee);
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT0) && bHwSupportBeamformer) {
#ifdef CONFIG_CONCURRENT_MODE
if ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE) {
u8 num_snd_dim = 0;
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
RTW_INFO("[VHT] CONCURRENT AP Support Beamformer\n");
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT(2))
&& (_TRUE == mu_bfer)) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO AP\n");
}
rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMER_CAP, (u8 *)&num_snd_dim);
pvhtpriv->num_snd_dim = num_snd_dim;
} else
RTW_INFO("[VHT] CONCURRENT not AP ;not allow Support Beamformer\n");
#else
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
RTW_INFO("[VHT] Support Beamformer\n");
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT(2))
&& (_TRUE == mu_bfer)
&& ((pmlmeinfo->state & 0x03) == WIFI_FW_AP_STATE)) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO AP\n");
}
#endif
}
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT1) && bHwSupportBeamformee) {
u8 bfme_sts = 0;
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
RTW_INFO("[VHT] Support Beamformee\n");
rtw_hal_get_def_var(padapter, HAL_DEF_BEAMFORMEE_CAP, (u8 *)&bfme_sts);
pvhtpriv->bfme_sts = bfme_sts;
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT(3))
&& (_TRUE == mu_bfee)
&& ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)) {
SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE);
RTW_INFO("[VHT] Support MU-MIMO STA\n");
}
}
}
#endif /* CONFIG_BEAMFORMING */
#endif
/* We don't support these features, and PHL doesn't define */
pvhtpriv->txop_ps = 0;
pvhtpriv->htc_vht = 1;
pvhtpriv->link_adap_cap = 0;
pvhtpriv->tx_ant_pattern= 0;
pvhtpriv->rx_ant_pattern= 0;
pvhtpriv->ext_nss_bw = 0;
pvhtpriv->ampdu_len = pregistrypriv->ampdu_factor;
pvhtpriv->max_mpdu_len = proto_cap->max_amsdu_len;
tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
rx_nss = GET_HAL_RX_NSS(adapter_to_dvobj(padapter));
/* for now, vhtpriv.vht_mcs_map comes from RX NSS */
rtw_vht_nss_to_mcsmap(rx_nss, pvhtpriv->vht_mcs_map, pregistrypriv->vht_rx_mcs_map);
pvhtpriv->vht_highest_rate = rtw_get_vht_highest_rate(pvhtpriv->vht_mcs_map);
}
u64 rtw_vht_mcs_map_to_bitmap(u8 *mcs_map, u8 nss)
{
u8 i, j, tmp;
u64 bitmap = 0;
u8 bits_nss = nss * 2;
for (i = j = 0; i < bits_nss; i += 2, j += 10) {
/* every two bits means single sptial stream */
tmp = (mcs_map[i / 8] >> i) & 3;
switch (tmp) {
case 2:
bitmap = bitmap | (0x03ff << j);
break;
case 1:
bitmap = bitmap | (0x01ff << j);
break;
case 0:
bitmap = bitmap | (0x00ff << j);
break;
default:
break;
}
}
RTW_INFO("vht_mcs_map=%02x %02x, nss=%u => bitmap=%016llx\n"
, mcs_map[0], mcs_map[1], nss, bitmap);
return bitmap;
}
#ifdef CONFIG_BEAMFORMING
void update_sta_vht_info_apmode_bf_cap(_adapter *padapter, struct sta_info *psta)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct vht_priv *pvhtpriv_ap = &pmlmepriv->vhtpriv;
struct vht_priv *pvhtpriv_sta = &psta->vhtpriv;
u16 cur_beamform_cap = 0;
/* B11 SU Beamformer Capable, the target supports Beamformer and we are Beamformee */
if (TEST_FLAG(pvhtpriv_ap->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE) &&
GET_VHT_CAPABILITY_ELE_SU_BFEE(pvhtpriv_sta->vht_cap)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
/*Shift to BEAMFORMING_VHT_BEAMFORMER_STS_CAP*/
SET_FLAG(cur_beamform_cap, GET_VHT_CAPABILITY_ELE_SU_BFEE_STS_CAP(pvhtpriv_sta->vht_cap) << 8);
}
/* B12 SU Beamformee Capable, the target supports Beamformee and we are Beamformer */
if (TEST_FLAG(pvhtpriv_ap->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE) &&
GET_VHT_CAPABILITY_ELE_SU_BFER(pvhtpriv_sta->vht_cap)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
/*Shit to BEAMFORMING_VHT_BEAMFORMEE_SOUND_DIM*/
SET_FLAG(cur_beamform_cap, GET_VHT_CAPABILITY_ELE_SU_BFER_SOUND_DIM_NUM(pvhtpriv_sta->vht_cap) << 12);
}
if (cur_beamform_cap)
RTW_INFO("Current STA(%d) VHT Beamforming Setting = %02X\n", psta->phl_sta->aid, cur_beamform_cap);
pvhtpriv_sta->beamform_cap = cur_beamform_cap;
/* ToDo: need to API to inform hal_sta->bf_info.vht_beamform_cap */
#if 0
psta->phl_sta->bf_info.vht_beamform_cap = cur_beamform_cap;
#endif
}
#endif
void update_sta_vht_info_apmode(_adapter *padapter, void *sta)
{
struct sta_info *psta = (struct sta_info *)sta;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct vht_priv *pvhtpriv_ap = &pmlmepriv->vhtpriv;
struct vht_priv *pvhtpriv_sta = &psta->vhtpriv;
struct rtw_phl_stainfo_t *phl_sta = psta->phl_sta;
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *proto_role_cap = &(wrole->proto_role_cap);
u8 cur_ldpc_cap = 0, cur_stbc_cap = 0;
s8 bw_mode = -1;
u8 *pcap_mcs;
if (pvhtpriv_sta->vht_option == _FALSE)
return;
if (pvhtpriv_sta->op_present) {
switch (GET_VHT_OPERATION_ELE_CHL_WIDTH(pvhtpriv_sta->vht_op)) {
case 1: /* 80MHz */
case 2: /* 160MHz */
case 3: /* 80+80 */
bw_mode = CHANNEL_WIDTH_80; /* only support up to 80MHz for now */
break;
}
}
if (pvhtpriv_sta->notify_present)
bw_mode = GET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(&pvhtpriv_sta->vht_op_mode_notify);
else if (MLME_IS_AP(padapter)) {
/* for VHT client without Operating Mode Notify IE; minimal 80MHz */
if (bw_mode < CHANNEL_WIDTH_80)
bw_mode = CHANNEL_WIDTH_80;
}
if (bw_mode != -1)
psta->phl_sta->chandef.bw = bw_mode; /* update bw_mode only if get value from VHT IEs */
/* ToDo: need to API to inform hal_sta->ra_info.is_vht_enable */
/* psta->phl_sta->ra_info.is_vht_enable = _TRUE; */
/* B4 Rx LDPC */
if (TEST_FLAG(pvhtpriv_ap->ldpc_cap, LDPC_VHT_ENABLE_TX) &&
GET_VHT_CAPABILITY_ELE_RX_LDPC(pvhtpriv_sta->vht_cap)) {
SET_FLAG(cur_ldpc_cap, (LDPC_VHT_ENABLE_TX | LDPC_VHT_CAP_TX));
RTW_INFO("Current STA(%d) VHT LDPC = %02X\n", psta->phl_sta->aid, cur_ldpc_cap);
}
pvhtpriv_sta->ldpc_cap = cur_ldpc_cap;
if (psta->phl_sta->chandef.bw > pmlmeext->chandef.bw)
psta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
if (psta->phl_sta->chandef.bw == CHANNEL_WIDTH_80) {
/* B5 Short GI for 80 MHz */
pvhtpriv_sta->sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI80M(pvhtpriv_sta->vht_cap) & pvhtpriv_ap->sgi_80m) ? _TRUE : _FALSE;
/* RTW_INFO("Current STA ShortGI80MHz = %d\n", pvhtpriv_sta->sgi_80m); */
} else if (psta->phl_sta->chandef.bw >= CHANNEL_WIDTH_160) {
/* B5 Short GI for 80 MHz */
pvhtpriv_sta->sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI160M(pvhtpriv_sta->vht_cap) & pvhtpriv_ap->sgi_80m) ? _TRUE : _FALSE;
/* RTW_INFO("Current STA ShortGI160MHz = %d\n", pvhtpriv_sta->sgi_80m); */
}
/* B8 B9 B10 Rx STBC */
if (TEST_FLAG(pvhtpriv_ap->stbc_cap, STBC_VHT_ENABLE_TX) &&
GET_VHT_CAPABILITY_ELE_RX_STBC(pvhtpriv_sta->vht_cap)) {
SET_FLAG(cur_stbc_cap, (STBC_VHT_ENABLE_TX | STBC_VHT_CAP_TX));
RTW_INFO("Current STA(%d) VHT STBC = %02X\n", psta->phl_sta->aid, cur_stbc_cap);
phl_sta->asoc_cap.stbc_vht_rx =
proto_role_cap->stbc_vht_tx ?
GET_VHT_CAPABILITY_ELE_RX_STBC(pvhtpriv_sta->vht_cap) : 0;
}
pvhtpriv_sta->stbc_cap = cur_stbc_cap;
phl_sta->asoc_cap.stbc_vht_tx =
GET_VHT_CAPABILITY_ELE_TX_STBC(pvhtpriv_sta->vht_cap);
#ifdef CONFIG_BEAMFORMING
update_sta_vht_info_apmode_bf_cap(padapter, psta);
#endif
/* B23 B24 B25 Maximum A-MPDU Length Exponent */
pvhtpriv_sta->ampdu_len = GET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(pvhtpriv_sta->vht_cap);
pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(pvhtpriv_sta->vht_cap);
_rtw_memcpy(pvhtpriv_sta->vht_mcs_map, pcap_mcs, 2);
pvhtpriv_sta->vht_highest_rate = rtw_get_vht_highest_rate(pvhtpriv_sta->vht_mcs_map);
}
void update_hw_vht_param(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 ht_AMPDU_len;
ht_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
if (pvhtpriv->ampdu_len > ht_AMPDU_len)
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&pvhtpriv->ampdu_len));
}
#ifdef ROKU_PRIVATE
u8 VHT_get_ss_from_map(u8 *vht_mcs_map)
{
u8 i, j;
u8 ss = 0;
for (i = 0; i < 2; i++) {
if (vht_mcs_map[i] != 0xff) {
for (j = 0; j < 8; j += 2) {
if (((vht_mcs_map[i] >> j) & 0x03) == 0x03)
break;
ss++;
}
}
}
return ss;
}
void VHT_caps_handler_infra_ap(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv_infra_ap *pvhtpriv = &pmlmepriv->vhtpriv_infra_ap;
u8 cur_stbc_cap_infra_ap = 0;
u16 cur_beamform_cap_infra_ap = 0;
u8 *pcap_mcs;
u8 *pcap_mcs_tx;
u8 Rx_ss = 0, Tx_ss = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pIE == NULL)
return;
pmlmeinfo->ht_vht_received |= BIT(1);
pvhtpriv->ldpc_cap_infra_ap = GET_VHT_CAPABILITY_ELE_RX_LDPC(pIE->data);
if (GET_VHT_CAPABILITY_ELE_RX_STBC(pIE->data))
SET_FLAG(cur_stbc_cap_infra_ap, STBC_VHT_ENABLE_RX);
if (GET_VHT_CAPABILITY_ELE_TX_STBC(pIE->data))
SET_FLAG(cur_stbc_cap_infra_ap, STBC_VHT_ENABLE_TX);
pvhtpriv->stbc_cap_infra_ap = cur_stbc_cap_infra_ap;
/*store ap info for channel bandwidth*/
pvhtpriv->channel_width_infra_ap = GET_VHT_CAPABILITY_ELE_CHL_WIDTH(pIE->data);
/*check B11: SU Beamformer Capable and B12: SU Beamformee B19: MU Beamformer B20:MU Beamformee*/
if (GET_VHT_CAPABILITY_ELE_SU_BFER(pIE->data))
SET_FLAG(cur_beamform_cap_infra_ap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
if (GET_VHT_CAPABILITY_ELE_SU_BFEE(pIE->data))
SET_FLAG(cur_beamform_cap_infra_ap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
if (GET_VHT_CAPABILITY_ELE_MU_BFER(pIE->data))
SET_FLAG(cur_beamform_cap_infra_ap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE);
if (GET_VHT_CAPABILITY_ELE_MU_BFEE(pIE->data))
SET_FLAG(cur_beamform_cap_infra_ap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE);
pvhtpriv->beamform_cap_infra_ap = cur_beamform_cap_infra_ap;
/*store information about vht_mcs_set*/
pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(pIE->data);
pcap_mcs_tx = GET_VHT_CAPABILITY_ELE_TX_MCS(pIE->data);
_rtw_memcpy(pvhtpriv->vht_mcs_map_infra_ap, pcap_mcs, 2);
_rtw_memcpy(pvhtpriv->vht_mcs_map_tx_infra_ap, pcap_mcs_tx, 2);
Rx_ss = VHT_get_ss_from_map(pvhtpriv->vht_mcs_map_infra_ap);
Tx_ss = VHT_get_ss_from_map(pvhtpriv->vht_mcs_map_tx_infra_ap);
if (Rx_ss >= Tx_ss) {
pvhtpriv->number_of_streams_infra_ap = Rx_ss;
} else{
pvhtpriv->number_of_streams_infra_ap = Tx_ss;
}
}
#endif /* ROKU_PRIVATE */
void VHT_caps_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta = NULL;
struct rtw_phl_stainfo_t *phl_sta = NULL;
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *proto_role_cap = &(wrole->proto_role_cap);
u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, rx_nss = 0;
u16 cur_beamform_cap = 0;
u8 *pcap_mcs;
if (pIE == NULL)
return;
if (pvhtpriv->vht_option == _FALSE)
return;
psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
if (psta == NULL)
return;
phl_sta = psta->phl_sta;
pmlmeinfo->VHT_enable = 1;
/* B4 Rx LDPC */
if (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX) &&
GET_VHT_CAPABILITY_ELE_RX_LDPC(pIE->data)) {
SET_FLAG(cur_ldpc_cap, (LDPC_VHT_ENABLE_TX | LDPC_VHT_CAP_TX));
RTW_INFO("Current VHT LDPC Setting = %02X\n", cur_ldpc_cap);
phl_sta->asoc_cap.vht_ldpc = 1;
}
pvhtpriv->ldpc_cap = cur_ldpc_cap;
/* B5 Short GI for 80 MHz */
pvhtpriv->sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI80M(pIE->data) & pvhtpriv->sgi_80m) ? _TRUE : _FALSE;
/* RTW_INFO("Current ShortGI80MHz = %d\n", pvhtpriv->sgi_80m); */
/* B8 B9 B10 Rx STBC */
if (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX) &&
GET_VHT_CAPABILITY_ELE_RX_STBC(pIE->data)) {
SET_FLAG(cur_stbc_cap, (STBC_VHT_ENABLE_TX | STBC_VHT_CAP_TX));
RTW_INFO("Current VHT STBC Setting = %02X\n", cur_stbc_cap);
phl_sta->asoc_cap.stbc_vht_rx =
proto_role_cap->stbc_vht_tx ?
GET_VHT_CAPABILITY_ELE_RX_STBC(pIE->data) : 0;
}
pvhtpriv->stbc_cap = cur_stbc_cap;
phl_sta->asoc_cap.stbc_vht_tx = GET_VHT_CAPABILITY_ELE_TX_STBC(pIE->data);
phl_sta->asoc_cap.vht_su_bfmr = GET_VHT_CAPABILITY_ELE_SU_BFER(pIE->data);
phl_sta->asoc_cap.vht_su_bfme = GET_VHT_CAPABILITY_ELE_SU_BFEE(pIE->data);
phl_sta->asoc_cap.vht_mu_bfmr = GET_VHT_CAPABILITY_ELE_MU_BFER(pIE->data);
phl_sta->asoc_cap.bfme_sts = GET_VHT_CAPABILITY_ELE_SU_BFEE_STS_CAP(pIE->data);
phl_sta->asoc_cap.num_snd_dim = GET_VHT_CAPABILITY_ELE_SU_BFER_SOUND_DIM_NUM(pIE->data);
RTW_INFO("%s: VHT STA assoc_cap:\n", __func__);
RTW_INFO("- SU BFer: %d\n", phl_sta->asoc_cap.vht_su_bfmr);
RTW_INFO("- SU BFee: %d\n", phl_sta->asoc_cap.vht_su_bfme);
RTW_INFO("- MU BFer: %d\n", phl_sta->asoc_cap.vht_mu_bfmr);
RTW_INFO("- BFee STS: %d\n", phl_sta->asoc_cap.bfme_sts);
RTW_INFO("- BFer SND DIM number: %d\n", phl_sta->asoc_cap.num_snd_dim);
#ifdef CONFIG_BEAMFORMING
/*
* B11 SU Beamformer Capable,
* the target supports Beamformer and we are Beamformee
*/
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE)
&& GET_VHT_CAPABILITY_ELE_SU_BFER(pIE->data)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
/* Shift to BEAMFORMING_VHT_BEAMFORMEE_STS_CAP */
SET_FLAG(cur_beamform_cap, GET_VHT_CAPABILITY_ELE_SU_BFEE_STS_CAP(pIE->data) << 8);
/*
* B19 MU Beamformer Capable,
* the target supports Beamformer and we are Beamformee
*/
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE)
&& GET_VHT_CAPABILITY_ELE_MU_BFER(pIE->data))
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE);
}
/*
* B12 SU Beamformee Capable,
* the target supports Beamformee and we are Beamformer
*/
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE)
&& GET_VHT_CAPABILITY_ELE_SU_BFEE(pIE->data)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
/* Shit to BEAMFORMING_VHT_BEAMFORMER_SOUND_DIM */
SET_FLAG(cur_beamform_cap, GET_VHT_CAPABILITY_ELE_SU_BFER_SOUND_DIM_NUM(pIE->data) << 12);
/*
* B20 MU Beamformee Capable,
* the target supports Beamformee and we are Beamformer
*/
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE)
&& GET_VHT_CAPABILITY_ELE_MU_BFEE(pIE->data))
SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE);
}
pvhtpriv->beamform_cap = cur_beamform_cap;
RTW_INFO("Current VHT Beamforming Setting=0x%04X\n", cur_beamform_cap);
#endif /* CONFIG_BEAMFORMING */
/* B0 B1 Maximum MPDU Length */
pvhtpriv->max_mpdu_len = GET_VHT_CAPABILITY_ELE_MAX_MPDU_LENGTH(pIE->data);
/* B23 B24 B25 Maximum A-MPDU Length Exponent */
pvhtpriv->ampdu_len = GET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(pIE->data);
pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(pIE->data);
rx_nss = GET_HAL_RX_NSS(adapter_to_dvobj(padapter));
rtw_vht_nss_to_mcsmap(rx_nss, pvhtpriv->vht_mcs_map, pcap_mcs);
pvhtpriv->vht_highest_rate = rtw_get_vht_highest_rate(pvhtpriv->vht_mcs_map);
}
void VHT_operation_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
if (pIE == NULL)
return;
if (pvhtpriv->vht_option == _FALSE)
return;
if (pIE->Length != VHT_OP_IE_LEN) {
RTW_WARN("%s: unexpected IE length(%u)!\n",
__func__, pIE->Length);
}
pvhtpriv->op_present = 1;
_rtw_memcpy(pvhtpriv->vht_op, pIE->data,
pIE->Length > VHT_OP_IE_LEN ? VHT_OP_IE_LEN : pIE->Length);
}
void rtw_process_vht_op_mode_notify(_adapter *padapter, u8 *pframe, void *sta)
{
struct sta_info *psta = (struct sta_info *)sta;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct registry_priv *regsty = adapter_to_regsty(padapter);
u8 target_bw;
u8 target_rxss, current_rxss;
u8 update_ra = _FALSE;
u8 tx_nss = 0;
if (pvhtpriv->vht_option == _FALSE)
return;
target_bw = GET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(pframe);
tx_nss = GET_HAL_TX_NSS(adapter_to_dvobj(padapter));
target_rxss = rtw_min(tx_nss, (GET_VHT_OPERATING_MODE_FIELD_RX_NSS(pframe) + 1));
if (target_bw != psta->phl_sta->chandef.bw) {
if (rtw_hw_is_bw_support(adapter_to_dvobj(padapter), target_bw)
&& REGSTY_IS_BW_5G_SUPPORT(regsty, target_bw)
) {
update_ra = _TRUE;
psta->phl_sta->chandef.bw = target_bw;
}
}
current_rxss = rtw_vht_mcsmap_to_nss(psta->vhtpriv.vht_mcs_map);
if (target_rxss != current_rxss) {
u8 vht_mcs_map[2] = {};
update_ra = _TRUE;
rtw_vht_nss_to_mcsmap(target_rxss, vht_mcs_map, psta->vhtpriv.vht_mcs_map);
_rtw_memcpy(psta->vhtpriv.vht_mcs_map, vht_mcs_map, 2);
update_sta_ra_info(padapter, psta);
}
if (update_ra) {
rtw_phl_cmd_change_stainfo(adapter_to_dvobj(padapter)->phl,
psta->phl_sta,
STA_CHG_RAMASK,
NULL,
0,
PHL_CMD_NO_WAIT,
0);
}
}
u32 rtw_build_vht_operation_ie(_adapter *padapter, u8 *pbuf, u8 channel)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
/* struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; */
u8 ChnlWidth, center_freq, bw_mode;
u32 len = 0;
u8 operation[5];
_rtw_memset(operation, 0, 5);
bw_mode = REGSTY_BW_5G(pregistrypriv); /* TODO: control op bw with other info */
if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_80M | BW_CAP_160M)
&& REGSTY_BW_5G(pregistrypriv) >= CHANNEL_WIDTH_80
) {
center_freq = rtw_phl_get_center_ch(channel, get_highest_bw_cap(bw_mode), CHAN_OFFSET_UPPER);
ChnlWidth = 1;
} else {
center_freq = 0;
ChnlWidth = 0;
}
SET_VHT_OPERATION_ELE_CHL_WIDTH(operation, ChnlWidth);
/* center frequency */
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ1(operation, center_freq);/* Todo: need to set correct center channel */
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ2(operation, 0);
_rtw_memcpy(operation + 3, pvhtpriv->vht_mcs_map, 2);
rtw_set_ie(pbuf, EID_VHTOperation, 5, operation, &len);
return len;
}
u32 rtw_build_vht_op_mode_notify_ie(_adapter *padapter, u8 *pbuf, u8 bw)
{
/* struct registry_priv *pregistrypriv = &padapter->registrypriv; */
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
u32 len = 0;
u8 opmode = 0;
u8 chnl_width, rx_nss;
chnl_width = bw;
rx_nss = rtw_vht_mcsmap_to_nss(pvhtpriv->vht_mcs_map);
SET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(&opmode, chnl_width);
SET_VHT_OPERATING_MODE_FIELD_RX_NSS(&opmode, (rx_nss - 1));
SET_VHT_OPERATING_MODE_FIELD_RX_NSS_TYPE(&opmode, 0); /* Todo */
pvhtpriv->vht_op_mode_notify = opmode;
pbuf = rtw_set_ie(pbuf, EID_OpModeNotification, 1, &opmode, &len);
return len;
}
u32 rtw_build_vht_cap_ie(_adapter *padapter, u8 *pbuf)
{
u8 bw;
u16 HighestRate;
u8 *pcap, *pcap_mcs;
u32 len = 0;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
pcap = pvhtpriv->vht_cap;
_rtw_memset(pcap, 0, 32);
/*
* VHT Capabilities Information field : B0 to B31
*/
/* B0 B1 Maximum MPDU Length */
SET_VHT_CAPABILITY_ELE_MAX_MPDU_LENGTH(pcap, pvhtpriv->max_mpdu_len);
/* B2 B3 Supported Channel Width Set */
if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_160M) && REGSTY_IS_BW_5G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_160)) {
if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_80_80M) && REGSTY_IS_BW_5G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_80_80)) {
SET_VHT_CAPABILITY_ELE_CHL_WIDTH(pcap, 2);
RTW_INFO("[VHT] Declare supporting 160MHz and 80+80MHz\n");
} else {
SET_VHT_CAPABILITY_ELE_CHL_WIDTH(pcap, 1);
RTW_INFO("[VHT] Declare supporting 160MHz\n");
}
} else
SET_VHT_CAPABILITY_ELE_CHL_WIDTH(pcap, 0);
/* B4 Rx LDPC */
if (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX)) {
SET_VHT_CAPABILITY_ELE_RX_LDPC(pcap, 1);
RTW_INFO("[VHT] Declare supporting RX LDPC\n");
}
/* B5 ShortGI for 80MHz */
SET_VHT_CAPABILITY_ELE_SHORT_GI80M(pcap, pvhtpriv->sgi_80m ? 1 : 0);
if (pvhtpriv->sgi_80m)
RTW_INFO("[VHT] Declare supporting SGI 80MHz\n");
/* B6 Short GI for 160 and 80+80 MHz */
SET_VHT_CAPABILITY_ELE_SHORT_GI160M(pcap, pvhtpriv->sgi_160m ? 1 : 0);
if (pvhtpriv->sgi_160m) {
RTW_INFO("[VHT] Declare supporting SGI 160MHz and 80+80MHz\n");
}
/* B7 Tx STBC */
if (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX)) {
SET_VHT_CAPABILITY_ELE_TX_STBC(pcap, 1);
RTW_INFO("[VHT] Declare supporting TX STBC\n");
}
/* B8 B9 B10 Rx STBC */
if (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX)) {
SET_VHT_CAPABILITY_ELE_RX_STBC(pcap, pvhtpriv->rx_stbc_nss);
RTW_INFO("[VHT] Declare supporting RX STBC = %d\n", pvhtpriv->rx_stbc_nss);
}
#ifdef CONFIG_BEAMFORMING
/* B11 SU Beamformer Capable */
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE)) {
SET_VHT_CAPABILITY_ELE_SU_BFER(pcap, 1);
RTW_INFO("[VHT] Declare supporting SU Beamformer\n");
/* B16 17 18 Number of Sounding Dimensions */
SET_VHT_CAPABILITY_ELE_SOUNDING_DIMENSIONS(pcap, pvhtpriv->num_snd_dim);
/* B19 MU Beamformer Capable */
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE)) {
SET_VHT_CAPABILITY_ELE_MU_BFER(pcap, 1);
RTW_INFO("[VHT] Declare supporting MU Beamformer\n");
}
}
/* B12 SU Beamformee Capable */
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE)) {
u8 bfme_sts = pvhtpriv->bfme_sts;
SET_VHT_CAPABILITY_ELE_SU_BFEE(pcap, 1);
RTW_INFO("[VHT] Declare supporting SU Beamformee\n");
/* IOT action suggested by Yu Chen 2017/3/3 */
if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_BROADCOM) &&
!pvhtpriv->ap_bf_cap.is_mu_bfer &&
pvhtpriv->ap_bf_cap.su_sound_dim == 2)
bfme_sts = (bfme_sts >= 2 ? 2 : bfme_sts);
/* B13 14 15 Beamformee STS Capability */
SET_VHT_CAPABILITY_ELE_SU_BFEE_STS_CAP(pcap, bfme_sts);
/* B20 MU Beamformee Capable */
if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE)) {
SET_VHT_CAPABILITY_ELE_MU_BFEE(pcap, 1);
RTW_INFO("[VHT] Declare supporting MU Beamformee\n");
}
}
#endif/*CONFIG_BEAMFORMING*/
/* B21 VHT TXOP PS */
if (pvhtpriv->txop_ps) {
SET_VHT_CAPABILITY_ELE_TXOP_PS(pcap, 1);
RTW_INFO("[VHT] Declare supporting VHT TXOP power save\n");
}
/* B22 +HTC-VHT Capable */
if (pvhtpriv->htc_vht) {
SET_VHT_CAPABILITY_ELE_HTC_VHT(pcap, 1);
RTW_INFO("[VHT] Declare supporting VHT variant HT Control\n");
}
/* B23 24 25 Maximum A-MPDU Length Exponent */
SET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(pcap, pvhtpriv->ampdu_len);
RTW_INFO("[VHT] Declare supporting RX A-MPDU Length Exponent = %u\n", pvhtpriv->ampdu_len);
/* B26 27 VHT Link Adaptation Capable */
if (pvhtpriv->link_adap_cap) {
SET_VHT_CAPABILITY_ELE_LINK_ADAPTION(pcap, 1);
RTW_INFO("[VHT] Declare supporting link adaptation using VHT variant HT Control\n");
}
/* B28 Rx Antenna Pattern Consistency */
if (pvhtpriv->rx_ant_pattern) {
SET_VHT_CAPABILITY_ELE_RX_ANT_PATTERN(pcap, 1);
RTW_INFO("[VHT] Declare supporting RX Antenna Pattern Consistency\n");
}
/* B29 Tx Antenna Pattern Consistency */
if (pvhtpriv->tx_ant_pattern) {
SET_VHT_CAPABILITY_ELE_TX_ANT_PATTERN(pcap, 1);
RTW_INFO("[VHT] Declare supporting TX Antenna Pattern Consistency\n");
}
/* B30 B31 Extended NSS BW Support */
SET_VHT_CAPABILITY_ELE_EXT_NSS_BW(pcap, pvhtpriv->ext_nss_bw);
/*
* Supported VHT-MCS and NSS Set : 8 bytes
*/
pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(pcap);
_rtw_memcpy(pcap_mcs, pvhtpriv->vht_mcs_map, 2);
pcap_mcs = GET_VHT_CAPABILITY_ELE_TX_MCS(pcap);
_rtw_memcpy(pcap_mcs, pvhtpriv->vht_mcs_map, 2);
/* find the largest bw supported by both registry and hal */
bw = rtw_hw_largest_bw(adapter_to_dvobj(padapter), REGSTY_BW_5G(pregistrypriv));
HighestRate = VHT_MCS_DATA_RATE[bw][pvhtpriv->sgi_80m][((pvhtpriv->vht_highest_rate - MGN_VHT1SS_MCS0) & 0x3f)];
HighestRate = (HighestRate + 1) >> 1;
SET_VHT_CAPABILITY_ELE_MCS_RX_HIGHEST_RATE(pcap, HighestRate); /* indicate we support highest rx rate is 600Mbps. */
SET_VHT_CAPABILITY_ELE_MCS_TX_HIGHEST_RATE(pcap, HighestRate); /* indicate we support highest tx rate is 600Mbps. */
pbuf = rtw_set_ie(pbuf, EID_VHTCapability, 12, pcap, &len);
return len;
}
u32 rtw_restructure_vht_ie(_adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, struct country_chplan *req_chplan)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
RT_CHANNEL_INFO *chset = rfctl->channel_set;
u32 ielen;
u8 max_bw;
u8 oper_ch, oper_bw = CHANNEL_WIDTH_20, oper_offset = CHAN_OFFSET_NO_EXT;
u8 *out_vht_op_ie, *ht_op_ie, *vht_cap_ie, *vht_op_ie;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
rtw_vht_get_real_setting(padapter);
ht_op_ie = rtw_get_ie(in_ie + 12, WLAN_EID_HT_OPERATION, &ielen, in_len - 12);
if (!ht_op_ie || ielen != HT_OP_IE_LEN)
goto exit;
vht_cap_ie = rtw_get_ie(in_ie + 12, EID_VHTCapability, &ielen, in_len - 12);
if (!vht_cap_ie || ielen != VHT_CAP_IE_LEN)
goto exit;
vht_op_ie = rtw_get_ie(in_ie + 12, EID_VHTOperation, &ielen, in_len - 12);
if (!vht_op_ie || ielen != VHT_OP_IE_LEN)
goto exit;
/* VHT Capabilities element */
*pout_len += rtw_build_vht_cap_ie(padapter, out_ie + *pout_len);
/* VHT Operation element */
out_vht_op_ie = out_ie + *pout_len;
rtw_set_ie(out_vht_op_ie, EID_VHTOperation, VHT_OP_IE_LEN, vht_op_ie + 2 , pout_len);
/* get primary channel from HT_OP_IE */
oper_ch = GET_HT_OP_ELE_PRI_CHL(ht_op_ie + 2);
/* find the largest bw supported by both registry and hal */
max_bw = rtw_hw_largest_bw(adapter_to_dvobj(padapter), REGSTY_BW_5G(pregistrypriv));
if (max_bw >= CHANNEL_WIDTH_40) {
/* get bw offset form HT_OP_IE */
if (GET_HT_OP_ELE_STA_CHL_WIDTH(ht_op_ie + 2)) {
switch (GET_HT_OP_ELE_2ND_CHL_OFFSET(ht_op_ie + 2)) {
case IEEE80211_SCA:
oper_bw = CHANNEL_WIDTH_40;
oper_offset = CHAN_OFFSET_UPPER;
break;
case IEEE80211_SCB:
oper_bw = CHANNEL_WIDTH_40;
oper_offset = CHAN_OFFSET_LOWER;
break;
}
}
if (oper_bw == CHANNEL_WIDTH_40) {
switch (GET_VHT_OPERATION_ELE_CHL_WIDTH(vht_op_ie + 2)) {
case 1: /* 80MHz */
case 2: /* 160MHz */
case 3: /* 80+80 */
oper_bw = CHANNEL_WIDTH_80; /* only support up to 80MHz for now */
break;
}
oper_bw = rtw_min(oper_bw, max_bw);
/* try downgrage bw to fit in channel plan setting */
while ((req_chplan && !rtw_country_chplan_is_chbw_valid(req_chplan, BAND_ON_5G, oper_ch, oper_bw, oper_offset, 1, 1, pregistrypriv))
|| (!req_chplan && !rtw_chset_is_chbw_valid(chset, oper_ch, oper_bw, oper_offset, 1, 1))
|| (IS_DFS_SLAVE_WITH_RD(rfctl)
&& !rtw_rfctl_dfs_domain_unknown(rfctl)
&& rtw_chset_is_chbw_non_ocp(chset, oper_ch, oper_bw, oper_offset))
) {
oper_bw--;
if (oper_bw == CHANNEL_WIDTH_20) {
oper_offset = CHAN_OFFSET_NO_EXT;
break;
}
}
}
}
rtw_warn_on(req_chplan && !rtw_country_chplan_is_chbw_valid(req_chplan, BAND_ON_5G, oper_ch, oper_bw, oper_offset, 1, 1, pregistrypriv));
rtw_warn_on(!req_chplan && !rtw_chset_is_chbw_valid(chset, oper_ch, oper_bw, oper_offset, 1, 1));
if (IS_DFS_SLAVE_WITH_RD(rfctl) && !rtw_rfctl_dfs_domain_unknown(rfctl))
rtw_warn_on(rtw_chset_is_chbw_non_ocp(chset, oper_ch, oper_bw, oper_offset));
/* update VHT_OP_IE */
if (oper_bw < CHANNEL_WIDTH_80) {
SET_VHT_OPERATION_ELE_CHL_WIDTH(out_vht_op_ie + 2, 0);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ1(out_vht_op_ie + 2, 0);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ2(out_vht_op_ie + 2, 0);
} else if (oper_bw == CHANNEL_WIDTH_80) {
u8 cch = rtw_phl_get_center_ch(oper_ch, oper_bw, oper_offset);
SET_VHT_OPERATION_ELE_CHL_WIDTH(out_vht_op_ie + 2, 1);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ1(out_vht_op_ie + 2, cch);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ2(out_vht_op_ie + 2, 0);
} else {
RTW_ERR(FUNC_ADPT_FMT" unsupported BW:%u\n", FUNC_ADPT_ARG(padapter), oper_bw);
rtw_warn_on(1);
}
/* Operating Mode Notification element */
*pout_len += rtw_build_vht_op_mode_notify_ie(padapter, out_ie + *pout_len, oper_bw);
pvhtpriv->vht_option = _TRUE;
exit:
return pvhtpriv->vht_option;
}
void VHTOnAssocRsp(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 ht_AMPDU_len;
RTW_INFO("%s\n", __FUNCTION__);
if (!pmlmeinfo->HT_enable)
return;
if (!pmlmeinfo->VHT_enable)
return;
ht_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
if (pvhtpriv->ampdu_len > ht_AMPDU_len)
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&pvhtpriv->ampdu_len));
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MAX_TIME, (u8 *)(&pvhtpriv->vht_highest_rate));
}
void rtw_vht_ies_attach(_adapter *padapter, WLAN_BSSID_EX *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 cap_len, operation_len;
uint len = 0;
sint ie_len = 0;
u8 *p = NULL;
p = rtw_get_ie(pnetwork->IEs + _BEACON_IE_OFFSET_, EID_VHTCapability, &ie_len,
(pnetwork->IELength - _BEACON_IE_OFFSET_));
if (p && ie_len > 0)
return;
rtw_vht_get_real_setting(padapter);
/* VHT Operation mode notifiy bit in Extended IE (127) */
rtw_add_ext_cap_info(pmlmepriv->ext_capab_ie_data, &(pmlmepriv->ext_capab_ie_len), OP_MODE_NOTIFICATION);
rtw_update_ext_cap_ie(pmlmepriv->ext_capab_ie_data, pmlmepriv->ext_capab_ie_len, pnetwork->IEs \
, &(pnetwork->IELength), _BEACON_IE_OFFSET_);
/* VHT Capabilities element */
cap_len = rtw_build_vht_cap_ie(padapter, pnetwork->IEs + pnetwork->IELength);
pnetwork->IELength += cap_len;
/* VHT Operation element */
operation_len = rtw_build_vht_operation_ie(padapter, pnetwork->IEs + pnetwork->IELength,
pnetwork->Configuration.DSConfig);
pnetwork->IELength += operation_len;
rtw_check_for_vht20(padapter, pnetwork->IEs + _BEACON_IE_OFFSET_, pnetwork->IELength - _BEACON_IE_OFFSET_);
pmlmepriv->vhtpriv.vht_option = _TRUE;
}
void rtw_vht_ies_detach(_adapter *padapter, WLAN_BSSID_EX *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
rtw_remove_ext_cap_info(pmlmepriv->ext_capab_ie_data, &(pmlmepriv->ext_capab_ie_len), OP_MODE_NOTIFICATION);
rtw_update_ext_cap_ie(pmlmepriv->ext_capab_ie_data, pmlmepriv->ext_capab_ie_len, pnetwork->IEs \
, &(pnetwork->IELength), _BEACON_IE_OFFSET_);
rtw_remove_bcn_ie(padapter, pnetwork, EID_VHTCapability);
rtw_remove_bcn_ie(padapter, pnetwork, EID_VHTOperation);
rtw_remove_bcn_ie(padapter, pnetwork, EID_VHTTransmitPower);
pmlmepriv->vhtpriv.vht_option = _FALSE;
}
void rtw_check_for_vht20(_adapter *adapter, u8 *ies, int ies_len)
{
u8 ht_ch, ht_bw, ht_offset;
u8 vht_ch, vht_bw, vht_offset;
rtw_ies_get_chbw(ies, ies_len, &ht_ch, &ht_bw, &ht_offset, 1, 0);
rtw_ies_get_chbw(ies, ies_len, &vht_ch, &vht_bw, &vht_offset, 1, 1);
if (ht_bw == CHANNEL_WIDTH_20 && vht_bw >= CHANNEL_WIDTH_80) {
u8 *vht_op_ie;
int vht_op_ielen;
RTW_INFO(FUNC_ADPT_FMT" vht80 is not allowed without ht40\n", FUNC_ADPT_ARG(adapter));
vht_op_ie = rtw_get_ie(ies, EID_VHTOperation, &vht_op_ielen, ies_len);
if (vht_op_ie && vht_op_ielen) {
RTW_INFO(FUNC_ADPT_FMT" switch to vht20\n", FUNC_ADPT_ARG(adapter));
SET_VHT_OPERATION_ELE_CHL_WIDTH(vht_op_ie + 2, 0);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ1(vht_op_ie + 2, 0);
SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ2(vht_op_ie + 2, 0);
}
}
}
/* We need to update the (mlmepriv->vhtpriv) */
void rtw_update_drv_vht_cap(_adapter *padapter, u8 *vht_cap_ie)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct vht_priv *pvhtpriv = &(pmlmepriv->vhtpriv);
struct registry_priv *pregpriv = &padapter->registrypriv;
s32 ie_len = 0;
u32 rx_packet_offset, max_recvbuf_sz, available_mpdu_sz;
u8 cap_val;
u8 *pvht_cap;
/* Initialize VHT capability element */
rtw_vht_get_real_setting(padapter);
RTW_INFO("Don't setting VHT capability IE from hostap, builded by driver temporarily\n");
rtw_build_vht_cap_ie(padapter, vht_cap_ie);
}
void rtw_check_vht_ies(_adapter *padapter, WLAN_BSSID_EX *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct vht_priv *pvhtpriv = &(pmlmepriv->vhtpriv);
u32 ie_len;
u32 ies_len = pnetwork->IELength - _BEACON_IE_OFFSET_;
u8 *ies = pnetwork->IEs + _BEACON_IE_OFFSET_;
u8 *vht_cap_ie, *vht_op_ie;
vht_cap_ie = rtw_get_ie(ies, EID_VHTCapability, &ie_len, ies_len);
vht_op_ie = rtw_get_ie(ies, EID_VHTOperation, &ie_len, ies_len);
rtw_update_drv_vht_cap(padapter, vht_cap_ie);
rtw_add_ext_cap_info(pmlmepriv->ext_capab_ie_data, &(pmlmepriv->ext_capab_ie_len), OP_MODE_NOTIFICATION);
rtw_update_ext_cap_ie(pmlmepriv->ext_capab_ie_data, pmlmepriv->ext_capab_ie_len, pnetwork->IEs \
, &(pnetwork->IELength), _BEACON_IE_OFFSET_);
/* Backup these two VHT IEs from hostapd/wpa_supplicant for restore usage */
if (vht_cap_ie != NULL)
_rtw_memcpy(pvhtpriv->vht_cap_ie_backup, vht_cap_ie + 2, VHT_CAP_IE_LEN);
if (vht_op_ie != NULL)
_rtw_memcpy(pvhtpriv->vht_op_ie_backup, vht_op_ie + 2, VHT_OP_IE_LEN);
/* TODO : We don't handle this IE like before, so remove it */
rtw_remove_bcn_ie(padapter, pnetwork, EID_VHTTransmitPower);
}
void rtw_reattach_vht_ies(_adapter *padapter, WLAN_BSSID_EX *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct vht_priv *pvhtpriv = &(pmlmepriv->vhtpriv);
u8 *vht_cap_ie = pnetwork->IEs + pnetwork->IELength;
u8 *vht_op_ie;
RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
if (pnetwork->IEs != NULL) {
vht_op_ie = rtw_set_ie(vht_cap_ie, EID_VHTCapability, VHT_CAP_IE_LEN,
pvhtpriv->vht_cap_ie_backup, &(pnetwork->IELength));
rtw_set_ie(vht_op_ie, EID_VHTOperation, VHT_OP_IE_LEN,
pvhtpriv->vht_op_ie_backup, &(pnetwork->IELength));
rtw_add_ext_cap_info(pmlmepriv->ext_capab_ie_data, &(pmlmepriv->ext_capab_ie_len), OP_MODE_NOTIFICATION);
rtw_update_ext_cap_ie(pmlmepriv->ext_capab_ie_data, pmlmepriv->ext_capab_ie_len, pnetwork->IEs \
, &(pnetwork->IELength), _BEACON_IE_OFFSET_);
}
pmlmepriv->vhtpriv.vht_option = _TRUE;
}
#endif /* CONFIG_80211AC_VHT */
|
2301_81045437/rtl8852be
|
core/rtw_vht.c
|
C
|
agpl-3.0
| 49,200
|
/******************************************************************************
*
* Copyright(c) 2016 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifdef CONFIG_WAPI_SUPPORT
#include <linux/unistd.h>
#include <linux/etherdevice.h>
#include <drv_types.h>
#include <rtw_wapi.h>
u32 wapi_debug_component =
/* WAPI_INIT |
* WAPI_API |
* WAPI_TX |
* WAPI_RX | */
WAPI_ERR ; /* always open err flags on */
void WapiFreeAllStaInfo(_adapter *padapter)
{
PRT_WAPI_T pWapiInfo;
PRT_WAPI_STA_INFO pWapiStaInfo;
PRT_WAPI_BKID pWapiBkid;
WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
pWapiInfo = &padapter->wapiInfo;
/* Pust to Idle List */
rtw_wapi_return_all_sta_info(padapter);
/* Sta Info List */
while (!list_empty(&(pWapiInfo->wapiSTAIdleList))) {
pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAIdleList.next, RT_WAPI_STA_INFO, list);
list_del_init(&pWapiStaInfo->list);
}
/* BKID List */
while (!list_empty(&(pWapiInfo->wapiBKIDIdleList))) {
pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDIdleList.next, RT_WAPI_BKID, list);
list_del_init(&pWapiBkid->list);
}
WAPI_TRACE(WAPI_INIT, "<=========== %s\n", __FUNCTION__);
return;
}
void WapiSetIE(_adapter *padapter)
{
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
/* PRT_WAPI_BKID pWapiBkid; */
u16 protocolVer = 1;
u16 akmCnt = 1;
u16 suiteCnt = 1;
u16 capability = 0;
u8 OUI[3];
OUI[0] = 0x00;
OUI[1] = 0x14;
OUI[2] = 0x72;
pWapiInfo->wapiIELength = 0;
/* protocol version */
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &protocolVer, 2);
pWapiInfo->wapiIELength += 2;
/* akm */
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &akmCnt, 2);
pWapiInfo->wapiIELength += 2;
if (pWapiInfo->bWapiPSK) {
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
pWapiInfo->wapiIELength += 3;
pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x2;
pWapiInfo->wapiIELength += 1;
} else {
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
pWapiInfo->wapiIELength += 3;
pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x1;
pWapiInfo->wapiIELength += 1;
}
/* usk */
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &suiteCnt, 2);
pWapiInfo->wapiIELength += 2;
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
pWapiInfo->wapiIELength += 3;
pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x1;
pWapiInfo->wapiIELength += 1;
/* msk */
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
pWapiInfo->wapiIELength += 3;
pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x1;
pWapiInfo->wapiIELength += 1;
/* Capbility */
_rtw_memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &capability, 2);
pWapiInfo->wapiIELength += 2;
}
/* PN1 > PN2, return 1,
* else return 0.
*/
u32 WapiComparePN(u8 *PN1, u8 *PN2)
{
char i;
if ((NULL == PN1) || (NULL == PN2))
return 1;
/* overflow case */
if ((PN2[15] - PN1[15]) & 0x80)
return 1;
for (i = 16; i > 0; i--) {
if (PN1[i - 1] == PN2[i - 1])
continue;
else if (PN1[i - 1] > PN2[i - 1])
return 1;
else
return 0;
}
return 0;
}
u8
WapiGetEntryForCamWrite(_adapter *padapter, u8 *pMacAddr, u8 KID, BOOLEAN IsMsk)
{
PRT_WAPI_T pWapiInfo = NULL;
/* PRT_WAPI_CAM_ENTRY pEntry=NULL; */
u8 i = 0;
u8 ret = 0xff;
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
pWapiInfo = &padapter->wapiInfo;
/* exist? */
for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
if (pWapiInfo->wapiCamEntry[i].IsUsed
&& (_rtw_memcmp(pMacAddr, pWapiInfo->wapiCamEntry[i].PeerMacAddr, ETH_ALEN) == _TRUE)
&& pWapiInfo->wapiCamEntry[i].keyidx == KID
&& pWapiInfo->wapiCamEntry[i].type == IsMsk) {
ret = pWapiInfo->wapiCamEntry[i].entry_idx; /* cover it */
break;
}
}
if (i == WAPI_CAM_ENTRY_NUM) { /* not found */
for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
if (pWapiInfo->wapiCamEntry[i].IsUsed == 0) {
pWapiInfo->wapiCamEntry[i].IsUsed = 1;
pWapiInfo->wapiCamEntry[i].type = IsMsk;
pWapiInfo->wapiCamEntry[i].keyidx = KID;
_rtw_memcpy(pWapiInfo->wapiCamEntry[i].PeerMacAddr, pMacAddr, ETH_ALEN);
ret = pWapiInfo->wapiCamEntry[i].entry_idx;
break;
}
}
}
WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
return ret;
/*
if(RTIsListEmpty(&pWapiInfo->wapiCamIdleList)) {
return 0;
}
pEntry = (PRT_WAPI_CAM_ENTRY)RTRemoveHeadList(&pWapiInfo->wapiCamIdleList);
RTInsertTailList(&pWapiInfo->wapiCamUsedList, &pEntry->list);
return pEntry->entry_idx;*/
}
u8 WapiGetEntryForCamClear(_adapter *padapter, u8 *pPeerMac, u8 keyid, u8 IsMsk)
{
PRT_WAPI_T pWapiInfo = NULL;
u8 i = 0;
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
pWapiInfo = &padapter->wapiInfo;
for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
if (pWapiInfo->wapiCamEntry[i].IsUsed
&& (_rtw_memcmp(pPeerMac, pWapiInfo->wapiCamEntry[i].PeerMacAddr, ETH_ALEN) == _TRUE)
&& pWapiInfo->wapiCamEntry[i].keyidx == keyid
&& pWapiInfo->wapiCamEntry[i].type == IsMsk) {
pWapiInfo->wapiCamEntry[i].IsUsed = 0;
pWapiInfo->wapiCamEntry[i].keyidx = 2;
_rtw_memset(pWapiInfo->wapiCamEntry[i].PeerMacAddr, 0, ETH_ALEN);
WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
return pWapiInfo->wapiCamEntry[i].entry_idx;
}
}
WAPI_TRACE(WAPI_API, "<====WapiGetReturnCamEntry(), No this cam entry.\n");
return 0xff;
/*
if(RTIsListEmpty(&pWapiInfo->wapiCamUsedList)) {
return FALSE;
}
pList = &pWapiInfo->wapiCamUsedList;
while(pList->Flink != &pWapiInfo->wapiCamUsedList)
{
pEntry = (PRT_WAPI_CAM_ENTRY)pList->Flink;
if(PlatformCompareMemory(pPeerMac,pEntry->PeerMacAddr, ETHER_ADDRLEN)== 0
&& keyid == pEntry->keyidx)
{
RTRemoveEntryList(pList);
RTInsertHeadList(&pWapiInfo->wapiCamIdleList, pList);
return pEntry->entry_idx;
}
pList = pList->Flink;
}
return 0;
*/
}
void
WapiResetAllCamEntry(_adapter *padapter)
{
PRT_WAPI_T pWapiInfo;
int i;
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
pWapiInfo = &padapter->wapiInfo;
for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
_rtw_memset(pWapiInfo->wapiCamEntry[i].PeerMacAddr, 0, ETH_ALEN);
pWapiInfo->wapiCamEntry[i].IsUsed = 0;
pWapiInfo->wapiCamEntry[i].keyidx = 2; /* invalid */
pWapiInfo->wapiCamEntry[i].entry_idx = 4 + i * 2;
}
WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
return;
}
u8 WapiWriteOneCamEntry(
_adapter *padapter,
u8 *pMacAddr,
u8 KeyId,
u8 EntryId,
u8 EncAlg,
u8 bGroupKey,
u8 *pKey
)
{
u8 retVal = 0;
u16 usConfig = 0;
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
if (EntryId >= 32) {
WAPI_TRACE(WAPI_ERR, "<=== CamAddOneEntry(): ulKeyId exceed!\n");
return retVal;
}
usConfig = usConfig | (0x01 << 15) | ((u16)(EncAlg) << 2) | (KeyId);
if (EncAlg == _SMS4_) {
if (bGroupKey == 1)
usConfig |= (0x01 << 6);
if ((EntryId % 2) == 1) /* ==0 sec key; == 1mic key */
usConfig |= (0x01 << 5);
}
write_cam(padapter, EntryId, usConfig, pMacAddr, pKey);
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
return 1;
}
void rtw_wapi_init(_adapter *padapter)
{
PRT_WAPI_T pWapiInfo;
int i;
WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
RT_ASSERT_RET(padapter);
if (!padapter->WapiSupport) {
WAPI_TRACE(WAPI_INIT, "<========== %s, WAPI not supported!\n", __FUNCTION__);
return;
}
pWapiInfo = &padapter->wapiInfo;
pWapiInfo->bWapiEnable = false;
/* Init BKID List */
INIT_LIST_HEAD(&pWapiInfo->wapiBKIDIdleList);
INIT_LIST_HEAD(&pWapiInfo->wapiBKIDStoreList);
for (i = 0; i < WAPI_MAX_BKID_NUM; i++)
list_add_tail(&pWapiInfo->wapiBKID[i].list, &pWapiInfo->wapiBKIDIdleList);
/* Init STA List */
INIT_LIST_HEAD(&pWapiInfo->wapiSTAIdleList);
INIT_LIST_HEAD(&pWapiInfo->wapiSTAUsedList);
for (i = 0; i < WAPI_MAX_STAINFO_NUM; i++)
list_add_tail(&pWapiInfo->wapiSta[i].list, &pWapiInfo->wapiSTAIdleList);
for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
pWapiInfo->wapiCamEntry[i].IsUsed = 0;
pWapiInfo->wapiCamEntry[i].keyidx = 2; /* invalid */
pWapiInfo->wapiCamEntry[i].entry_idx = 4 + i * 2;
}
WAPI_TRACE(WAPI_INIT, "<========== %s\n", __FUNCTION__);
}
void rtw_wapi_free(_adapter *padapter)
{
WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
RT_ASSERT_RET(padapter);
if (!padapter->WapiSupport) {
WAPI_TRACE(WAPI_INIT, "<========== %s, WAPI not supported!\n", __FUNCTION__);
return;
}
WapiFreeAllStaInfo(padapter);
WAPI_TRACE(WAPI_INIT, "<========== %s\n", __FUNCTION__);
}
void rtw_wapi_disable_tx(_adapter *padapter)
{
WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
RT_ASSERT_RET(padapter);
if (!padapter->WapiSupport) {
WAPI_TRACE(WAPI_INIT, "<========== %s, WAPI not supported!\n", __FUNCTION__);
return;
}
padapter->wapiInfo.wapiTxMsk.bTxEnable = false;
padapter->wapiInfo.wapiTxMsk.bSet = false;
WAPI_TRACE(WAPI_INIT, "<========== %s\n", __FUNCTION__);
}
u8 rtw_wapi_is_wai_packet(_adapter *padapter, u8 *pkt_data)
{
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
PRT_WAPI_STA_INFO pWapiSta = NULL;
u8 WaiPkt = 0, *pTaddr, bFind = false;
u8 Offset_TypeWAI = 0 ; /* (mac header len + llc length) */
WAPI_TRACE(WAPI_TX | WAPI_RX, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return 0;
}
Offset_TypeWAI = 24 + 6 ;
/* YJ,add,091103. Data frame may also have skb->data[30]=0x88 and skb->data[31]=0xb4. */
if ((pkt_data[1] & 0x40) != 0) {
/* RTW_INFO("data is privacy\n"); */
return 0;
}
pTaddr = get_addr2_ptr(pkt_data);
if (list_empty(&pWapiInfo->wapiSTAUsedList))
bFind = false;
else {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_rtw_memcmp(pTaddr, pWapiSta->PeerMacAddr, 6) == _TRUE) {
bFind = true;
break;
}
}
}
WAPI_TRACE(WAPI_TX | WAPI_RX, "%s: bFind=%d pTaddr="MAC_FMT"\n", __FUNCTION__, bFind, MAC_ARG(pTaddr));
if (pkt_data[0] == WIFI_QOS_DATA_TYPE)
Offset_TypeWAI += 2;
/* 88b4? */
if ((pkt_data[Offset_TypeWAI] == 0x88) && (pkt_data[Offset_TypeWAI + 1] == 0xb4)) {
WaiPkt = pkt_data[Offset_TypeWAI + 5];
psecuritypriv->hw_decrypted = _TRUE;
} else
WAPI_TRACE(WAPI_TX | WAPI_RX, "%s(): non wai packet\n", __FUNCTION__);
WAPI_TRACE(WAPI_TX | WAPI_RX, "%s(): Recvd WAI frame. IsWAIPkt(%d)\n", __FUNCTION__, WaiPkt);
return WaiPkt;
}
void rtw_wapi_update_info(_adapter *padapter, union recv_frame *precv_frame)
{
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
struct recv_frame_hdr *precv_hdr;
u8 *ptr;
u8 *pTA;
u8 *pRecvPN;
WAPI_TRACE(WAPI_RX, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_RX, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return;
}
precv_hdr = &precv_frame->u.hdr;
ptr = precv_hdr->rx_data;
if (precv_hdr->attrib.qos == 1)
precv_hdr->UserPriority = GetTid(ptr);
else
precv_hdr->UserPriority = 0;
pTA = get_addr2_ptr(ptr);
_rtw_memcpy((u8 *)precv_hdr->WapiSrcAddr, pTA, 6);
pRecvPN = ptr + precv_hdr->attrib.hdrlen + 2;
_rtw_memcpy((u8 *)precv_hdr->WapiTempPN, pRecvPN, 16);
WAPI_TRACE(WAPI_RX, "<========== %s\n", __FUNCTION__);
}
/****************************************************************************
TRUE-----------------Drop
FALSE---------------- handle
add to support WAPI to N-mode
*****************************************************************************/
u8 rtw_wapi_check_for_drop(
_adapter *padapter,
union recv_frame *precv_frame,
u8 *ehdr_ops
)
{
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
u8 *pLastRecvPN = NULL;
u8 bFind = false;
PRT_WAPI_STA_INFO pWapiSta = NULL;
u8 bDrop = false;
struct recv_frame_hdr *precv_hdr = &precv_frame->u.hdr;
u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
u8 *ptr = ehdr_ops;
int i;
WAPI_TRACE(WAPI_RX, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_RX, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return false;
}
if (precv_hdr->bIsWaiPacket != 0) {
if (precv_hdr->bIsWaiPacket == 0x8) {
RTW_INFO("rtw_wapi_check_for_drop: dump packet\n");
for (i = 0; i < 50; i++) {
RTW_INFO("%02X ", ptr[i]);
if ((i + 1) % 8 == 0)
RTW_INFO("\n");
}
RTW_INFO("\n rtw_wapi_check_for_drop: dump packet\n");
for (i = 0; i < 16; i++) {
if (ptr[i + 27] != 0)
break;
}
if (i == 16) {
WAPI_TRACE(WAPI_RX, "rtw_wapi_check_for_drop: drop with zero BKID\n");
return true;
} else
return false;
} else
return false;
}
if (list_empty(&pWapiInfo->wapiSTAUsedList))
bFind = false;
else {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_rtw_memcmp(precv_hdr->WapiSrcAddr, pWapiSta->PeerMacAddr, ETH_ALEN) == _TRUE) {
bFind = true;
break;
}
}
}
WAPI_TRACE(WAPI_RX, "%s: bFind=%d prxb->WapiSrcAddr="MAC_FMT"\n", __FUNCTION__, bFind, MAC_ARG(precv_hdr->WapiSrcAddr));
if (bFind) {
if (IS_MCAST(precv_hdr->attrib.ra)) {
WAPI_TRACE(WAPI_RX, "rtw_wapi_check_for_drop: multicast case\n");
pLastRecvPN = pWapiSta->lastRxMulticastPN;
} else {
WAPI_TRACE(WAPI_RX, "rtw_wapi_check_for_drop: unicast case\n");
switch (precv_hdr->UserPriority) {
case 0:
case 3:
pLastRecvPN = pWapiSta->lastRxUnicastPNBEQueue;
break;
case 1:
case 2:
pLastRecvPN = pWapiSta->lastRxUnicastPNBKQueue;
break;
case 4:
case 5:
pLastRecvPN = pWapiSta->lastRxUnicastPNVIQueue;
break;
case 6:
case 7:
pLastRecvPN = pWapiSta->lastRxUnicastPNVOQueue;
break;
default:
WAPI_TRACE(WAPI_ERR, "%s: Unknown TID\n", __FUNCTION__);
break;
}
}
if (!WapiComparePN(precv_hdr->WapiTempPN, pLastRecvPN)) {
WAPI_TRACE(WAPI_RX, "%s: Equal PN!!\n", __FUNCTION__);
if (IS_MCAST(precv_hdr->attrib.ra))
_rtw_memcpy(pLastRecvPN, WapiAEMultiCastPNInitialValueSrc, 16);
else
_rtw_memcpy(pLastRecvPN, WapiAEPNInitialValueSrc, 16);
bDrop = true;
} else
_rtw_memcpy(pLastRecvPN, precv_hdr->WapiTempPN, 16);
}
WAPI_TRACE(WAPI_RX, "<========== %s\n", __FUNCTION__);
return bDrop;
}
void rtw_build_probe_resp_wapi_ie(_adapter *padapter, unsigned char *pframe, struct pkt_attrib *pattrib)
{
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
u8 WapiIELength = 0;
WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported!\n", __FUNCTION__);
return;
}
WapiSetIE(padapter);
WapiIELength = pWapiInfo->wapiIELength;
pframe[0] = _WAPI_IE_;
pframe[1] = WapiIELength;
_rtw_memcpy(pframe + 2, pWapiInfo->wapiIE, WapiIELength);
pframe += WapiIELength + 2;
pattrib->pktlen += WapiIELength + 2;
WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
}
void rtw_build_beacon_wapi_ie(_adapter *padapter, unsigned char *pframe, struct pkt_attrib *pattrib)
{
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
u8 WapiIELength = 0;
WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported!\n", __FUNCTION__);
return;
}
WapiSetIE(padapter);
WapiIELength = pWapiInfo->wapiIELength;
pframe[0] = _WAPI_IE_;
pframe[1] = WapiIELength;
_rtw_memcpy(pframe + 2, pWapiInfo->wapiIE, WapiIELength);
pframe += WapiIELength + 2;
pattrib->pktlen += WapiIELength + 2;
WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
}
void rtw_build_assoc_req_wapi_ie(_adapter *padapter, unsigned char *pframe, struct pkt_attrib *pattrib)
{
PRT_WAPI_BKID pWapiBKID;
u16 bkidNum;
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
u8 WapiIELength = 0;
WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported!\n", __FUNCTION__);
return;
}
WapiSetIE(padapter);
WapiIELength = pWapiInfo->wapiIELength;
bkidNum = 0;
if (!list_empty(&(pWapiInfo->wapiBKIDStoreList))) {
list_for_each_entry(pWapiBKID, &pWapiInfo->wapiBKIDStoreList, list) {
bkidNum++;
_rtw_memcpy(pWapiInfo->wapiIE + WapiIELength + 2, pWapiBKID->bkid, 16);
WapiIELength += 16;
}
}
_rtw_memcpy(pWapiInfo->wapiIE + WapiIELength, &bkidNum, 2);
WapiIELength += 2;
pframe[0] = _WAPI_IE_;
pframe[1] = WapiIELength;
_rtw_memcpy(pframe + 2, pWapiInfo->wapiIE, WapiIELength);
pframe += WapiIELength + 2;
pattrib->pktlen += WapiIELength + 2;
WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
}
void rtw_wapi_on_assoc_ok(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
PRT_WAPI_STA_INFO pWapiSta;
u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
/* u8 WapiASUEPNInitialValueSrc[16] = {0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C} ; */
u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return;
}
pWapiSta = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAIdleList.next, RT_WAPI_STA_INFO, list);
list_del_init(&pWapiSta->list);
list_add_tail(&pWapiSta->list, &pWapiInfo->wapiSTAUsedList);
_rtw_memcpy(pWapiSta->PeerMacAddr, padapter->mlmeextpriv.mlmext_info.network.MacAddress, 6);
_rtw_memcpy(pWapiSta->lastRxMulticastPN, WapiAEMultiCastPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPN, WapiAEPNInitialValueSrc, 16);
/* For chenk PN error with Qos Data after s3: add by ylb 20111114 */
_rtw_memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiAEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiAEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiAEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiAEPNInitialValueSrc, 16);
WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
}
void rtw_wapi_return_one_sta_info(_adapter *padapter, u8 *MacAddr)
{
PRT_WAPI_T pWapiInfo;
PRT_WAPI_STA_INFO pWapiStaInfo = NULL;
PRT_WAPI_BKID pWapiBkid = NULL;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
pWapiInfo = &padapter->wapiInfo;
WAPI_TRACE(WAPI_API, "==========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return;
}
if (MLME_IS_STA(padapter)) {
while (!list_empty(&(pWapiInfo->wapiBKIDStoreList))) {
pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDStoreList.next, RT_WAPI_BKID, list);
list_del_init(&pWapiBkid->list);
_rtw_memset(pWapiBkid->bkid, 0, 16);
list_add_tail(&pWapiBkid->list, &pWapiInfo->wapiBKIDIdleList);
}
}
WAPI_TRACE(WAPI_API, " %s: after clear bkid\n", __FUNCTION__);
/* Remove STA info */
if (list_empty(&(pWapiInfo->wapiSTAUsedList))) {
WAPI_TRACE(WAPI_API, " %s: wapiSTAUsedList is null\n", __FUNCTION__);
return;
} else {
WAPI_TRACE(WAPI_API, " %s: wapiSTAUsedList is not null\n", __FUNCTION__);
#if 0
pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry((pWapiInfo->wapiSTAUsedList.next), RT_WAPI_STA_INFO, list);
list_for_each_entry(pWapiStaInfo, &(pWapiInfo->wapiSTAUsedList), list) {
RTW_INFO("MAC Addr %02x-%02x-%02x-%02x-%02x-%02x\n", MacAddr[0], MacAddr[1], MacAddr[2], MacAddr[3], MacAddr[4], MacAddr[5]);
RTW_INFO("peer Addr %02x-%02x-%02x-%02x-%02x-%02x\n", pWapiStaInfo->PeerMacAddr[0], pWapiStaInfo->PeerMacAddr[1], pWapiStaInfo->PeerMacAddr[2], pWapiStaInfo->PeerMacAddr[3],
pWapiStaInfo->PeerMacAddr[4], pWapiStaInfo->PeerMacAddr[5]);
if (pWapiStaInfo == NULL) {
WAPI_TRACE(WAPI_API, " %s: pWapiStaInfo == NULL Case\n", __FUNCTION__);
return;
}
if (pWapiStaInfo->PeerMacAddr == NULL) {
WAPI_TRACE(WAPI_API, " %s: pWapiStaInfo->PeerMacAddr == NULL Case\n", __FUNCTION__);
return;
}
if (MacAddr == NULL) {
WAPI_TRACE(WAPI_API, " %s: MacAddr == NULL Case\n", __FUNCTION__);
return;
}
if (_rtw_memcmp(pWapiStaInfo->PeerMacAddr, MacAddr, ETH_ALEN) == _TRUE) {
pWapiStaInfo->bAuthenticateInProgress = false;
pWapiStaInfo->bSetkeyOk = false;
_rtw_memset(pWapiStaInfo->PeerMacAddr, 0, ETH_ALEN);
list_del_init(&pWapiStaInfo->list);
list_add_tail(&pWapiStaInfo->list, &pWapiInfo->wapiSTAIdleList);
break;
}
}
#endif
while (!list_empty(&(pWapiInfo->wapiSTAUsedList))) {
pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAUsedList.next, RT_WAPI_STA_INFO, list);
RTW_INFO("peer Addr %02x-%02x-%02x-%02x-%02x-%02x\n", pWapiStaInfo->PeerMacAddr[0], pWapiStaInfo->PeerMacAddr[1], pWapiStaInfo->PeerMacAddr[2], pWapiStaInfo->PeerMacAddr[3],
pWapiStaInfo->PeerMacAddr[4], pWapiStaInfo->PeerMacAddr[5]);
list_del_init(&pWapiStaInfo->list);
_rtw_memset(pWapiStaInfo->PeerMacAddr, 0, ETH_ALEN);
pWapiStaInfo->bSetkeyOk = 0;
list_add_tail(&pWapiStaInfo->list, &pWapiInfo->wapiSTAIdleList);
}
}
WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
return;
}
void rtw_wapi_return_all_sta_info(_adapter *padapter)
{
PRT_WAPI_T pWapiInfo;
PRT_WAPI_STA_INFO pWapiStaInfo;
PRT_WAPI_BKID pWapiBkid;
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
pWapiInfo = &padapter->wapiInfo;
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return;
}
/* Sta Info List */
while (!list_empty(&(pWapiInfo->wapiSTAUsedList))) {
pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAUsedList.next, RT_WAPI_STA_INFO, list);
list_del_init(&pWapiStaInfo->list);
_rtw_memset(pWapiStaInfo->PeerMacAddr, 0, ETH_ALEN);
pWapiStaInfo->bSetkeyOk = 0;
list_add_tail(&pWapiStaInfo->list, &pWapiInfo->wapiSTAIdleList);
}
/* BKID List */
while (!list_empty(&(pWapiInfo->wapiBKIDStoreList))) {
pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDStoreList.next, RT_WAPI_BKID, list);
list_del_init(&pWapiBkid->list);
_rtw_memset(pWapiBkid->bkid, 0, 16);
list_add_tail(&pWapiBkid->list, &pWapiInfo->wapiBKIDIdleList);
}
WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
}
void CAM_empty_entry(
_adapter *adapter,
u8 ucIndex
)
{
rtw_hal_set_hwreg(adapter, HW_VAR_CAM_EMPTY_ENTRY, (u8 *)(&ucIndex));
}
void rtw_wapi_clear_cam_entry(_adapter *padapter, u8 *pMacAddr)
{
u8 UcIndex = 0;
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return;
}
UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 0, 0);
if (UcIndex != 0xff) {
/* CAM_mark_invalid(adapter, UcIndex); */
CAM_empty_entry(padapter, UcIndex);
}
UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 1, 0);
if (UcIndex != 0xff) {
/* CAM_mark_invalid(adapter, UcIndex); */
CAM_empty_entry(padapter, UcIndex);
}
UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 0, 1);
if (UcIndex != 0xff) {
/* CAM_mark_invalid(adapter, UcIndex); */
CAM_empty_entry(padapter, UcIndex);
}
UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 1, 1);
if (UcIndex != 0xff) {
/* CAM_mark_invalid(padapter, UcIndex); */
CAM_empty_entry(padapter, UcIndex);
}
WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
}
void rtw_wapi_clear_all_cam_entry(_adapter *padapter)
{
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return;
}
invalidate_cam_all(padapter); /* is this ok? */
WapiResetAllCamEntry(padapter);
WAPI_TRACE(WAPI_API, "<=========== %s\n", __FUNCTION__);
}
void rtw_wapi_set_key(_adapter *padapter, RT_WAPI_KEY *pWapiKey, RT_WAPI_STA_INFO *pWapiSta, u8 bGroupKey)
{
struct setkey_parm *psetkeyparm;
struct set_stakey_parm *psetstakeyparm;
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
u8 *pMacAddr = pWapiSta->PeerMacAddr;
u32 EntryId = 0;
BOOLEAN IsPairWise = false ;
u8 keylen;
WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
WAPI_TRACE(WAPI_API, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
return;
}
psetstakeyparm = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
if (NULL == psetstakeyparm) {
WAPI_TRACE(WAPI_API, "<========== new %s, could not zmalloc psetstakeyparm at line %d\n", __FUNCTION__, __LINE__);
return;
}
psetstakeyparm->algorithm = _SMS4_;
keylen = 16;
_rtw_memcpy(psetstakeyparm->addr, pMacAddr, ETH_ALEN);
_rtw_memcpy(&(psetstakeyparm->key[0]), &pWapiKey->dataKey, keylen);
_rtw_memcpy(&(psetstakeyparm->key[16]), &pWapiKey->micKey, keylen);
psetstakeyparm->keyid = pWapiKey->keyId;
if(bGroupKey) {
/* Group Key */
psetstakeyparm->gk = 1;
WAPI_TRACE(WAPI_API, "new %s: group keyid = %d, gk = %d, algorithm = %d\n", __FUNCTION__, psetstakeyparm->keyid, psetstakeyparm->gk, psetstakeyparm->algorithm);
} else {
/* Pairwise Key */
psetstakeyparm->gk = 0;
WAPI_TRACE(WAPI_API, "new %s: pairwise keyid = %d, gk = %d, algorithm = %d\n", __FUNCTION__, psetstakeyparm->keyid, psetstakeyparm->gk, psetstakeyparm->algorithm);
}
WAPI_DATA(WAPI_API, "new %s: ", psetstakeyparm->key, 32);
#ifdef CONFIG_CMD_DISP
set_stakey_hdl(padapter, psetstakeyparm, PHL_CMD_DIRECTLY, 0);
#else
set_stakey_hdl(padapter, (u8 *)psetstakeyparm);
#endif
rtw_mfree((u8 *) psetstakeyparm, sizeof(struct setkey_parm));
WAPI_TRACE(WAPI_API, "Set Wapi Key :KeyId:%d,EntryId:%d,PairwiseKey:%d.\n", pWapiKey->keyId, EntryId, !bGroupKey);
WAPI_TRACE(WAPI_API, "<=========== %s\n", __FUNCTION__);
}
#if 0
/* YJ,test,091013 */
void wapi_test_set_key(_adapter *padapter, u8 *buf)
{
/*Data: keyType(1) + bTxEnable(1) + bAuthenticator(1) + bUpdate(1) + PeerAddr(6) + DataKey(16) + MicKey(16) + KeyId(1)*/
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
PRT_WAPI_BKID pWapiBkid;
PRT_WAPI_STA_INFO pWapiSta;
u8 data[43];
bool bTxEnable;
bool bUpdate;
bool bAuthenticator;
u8 PeerAddr[6];
u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
u8 WapiASUEPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
WAPI_TRACE(WAPI_INIT, "===========>%s\n", __FUNCTION__);
if (!padapter->WapiSupport)
return;
copy_from_user(data, buf, 43);
bTxEnable = data[1];
bAuthenticator = data[2];
bUpdate = data[3];
_rtw_memcpy(PeerAddr, data + 4, 6);
if (data[0] == 0x3) {
if (!list_empty(&(pWapiInfo->wapiBKIDIdleList))) {
pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDIdleList.next, RT_WAPI_BKID, list);
list_del_init(&pWapiBkid->list);
_rtw_memcpy(pWapiBkid->bkid, data + 10, 16);
WAPI_DATA(WAPI_INIT, "SetKey - BKID", pWapiBkid->bkid, 16);
list_add_tail(&pWapiBkid->list, &pWapiInfo->wapiBKIDStoreList);
}
} else {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_rtw_memcmp(pWapiSta->PeerMacAddr, PeerAddr, 6)) {
pWapiSta->bAuthenticatorInUpdata = false;
switch (data[0]) {
case 1: /* usk */
if (bAuthenticator) { /* authenticator */
_rtw_memcpy(pWapiSta->lastTxUnicastPN, WapiAEPNInitialValueSrc, 16);
if (!bUpdate) { /* first */
WAPI_TRACE(WAPI_INIT, "AE fisrt set usk\n");
pWapiSta->wapiUsk.bSet = true;
_rtw_memcpy(pWapiSta->wapiUsk.dataKey, data + 10, 16);
_rtw_memcpy(pWapiSta->wapiUsk.micKey, data + 26, 16);
pWapiSta->wapiUsk.keyId = *(data + 42);
pWapiSta->wapiUsk.bTxEnable = true;
WAPI_DATA(WAPI_INIT, "SetKey - AE USK Data Key", pWapiSta->wapiUsk.dataKey, 16);
WAPI_DATA(WAPI_INIT, "SetKey - AE USK Mic Key", pWapiSta->wapiUsk.micKey, 16);
} else { /* update */
WAPI_TRACE(WAPI_INIT, "AE update usk\n");
pWapiSta->wapiUskUpdate.bSet = true;
pWapiSta->bAuthenticatorInUpdata = true;
_rtw_memcpy(pWapiSta->wapiUskUpdate.dataKey, data + 10, 16);
_rtw_memcpy(pWapiSta->wapiUskUpdate.micKey, data + 26, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPN, WapiASUEPNInitialValueSrc, 16);
pWapiSta->wapiUskUpdate.keyId = *(data + 42);
pWapiSta->wapiUskUpdate.bTxEnable = true;
}
} else {
if (!bUpdate) {
WAPI_TRACE(WAPI_INIT, "ASUE fisrt set usk\n");
if (bTxEnable) {
pWapiSta->wapiUsk.bTxEnable = true;
_rtw_memcpy(pWapiSta->lastTxUnicastPN, WapiASUEPNInitialValueSrc, 16);
} else {
pWapiSta->wapiUsk.bSet = true;
_rtw_memcpy(pWapiSta->wapiUsk.dataKey, data + 10, 16);
_rtw_memcpy(pWapiSta->wapiUsk.micKey, data + 26, 16);
pWapiSta->wapiUsk.keyId = *(data + 42);
pWapiSta->wapiUsk.bTxEnable = false;
}
} else {
WAPI_TRACE(WAPI_INIT, "ASUE update usk\n");
if (bTxEnable) {
pWapiSta->wapiUskUpdate.bTxEnable = true;
if (pWapiSta->wapiUskUpdate.bSet) {
_rtw_memcpy(pWapiSta->wapiUsk.dataKey, pWapiSta->wapiUskUpdate.dataKey, 16);
_rtw_memcpy(pWapiSta->wapiUsk.micKey, pWapiSta->wapiUskUpdate.micKey, 16);
pWapiSta->wapiUsk.keyId = pWapiSta->wapiUskUpdate.keyId;
_rtw_memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiASUEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPN, WapiASUEPNInitialValueSrc, 16);
pWapiSta->wapiUskUpdate.bTxEnable = false;
pWapiSta->wapiUskUpdate.bSet = false;
}
_rtw_memcpy(pWapiSta->lastTxUnicastPN, WapiASUEPNInitialValueSrc, 16);
} else {
pWapiSta->wapiUskUpdate.bSet = true;
_rtw_memcpy(pWapiSta->wapiUskUpdate.dataKey, data + 10, 16);
_rtw_memcpy(pWapiSta->wapiUskUpdate.micKey, data + 26, 16);
pWapiSta->wapiUskUpdate.keyId = *(data + 42);
pWapiSta->wapiUskUpdate.bTxEnable = false;
}
}
}
break;
case 2: /* msk */
if (bAuthenticator) { /* authenticator */
pWapiInfo->wapiTxMsk.bSet = true;
_rtw_memcpy(pWapiInfo->wapiTxMsk.dataKey, data + 10, 16);
_rtw_memcpy(pWapiInfo->wapiTxMsk.micKey, data + 26, 16);
pWapiInfo->wapiTxMsk.keyId = *(data + 42);
pWapiInfo->wapiTxMsk.bTxEnable = true;
_rtw_memcpy(pWapiInfo->lastTxMulticastPN, WapiAEMultiCastPNInitialValueSrc, 16);
if (!bUpdate) { /* first */
WAPI_TRACE(WAPI_INIT, "AE fisrt set msk\n");
if (!pWapiSta->bSetkeyOk)
pWapiSta->bSetkeyOk = true;
pWapiInfo->bFirstAuthentiateInProgress = false;
} else /* update */
WAPI_TRACE(WAPI_INIT, "AE update msk\n");
WAPI_DATA(WAPI_INIT, "SetKey - AE MSK Data Key", pWapiInfo->wapiTxMsk.dataKey, 16);
WAPI_DATA(WAPI_INIT, "SetKey - AE MSK Mic Key", pWapiInfo->wapiTxMsk.micKey, 16);
} else {
if (!bUpdate) {
WAPI_TRACE(WAPI_INIT, "ASUE fisrt set msk\n");
pWapiSta->wapiMsk.bSet = true;
_rtw_memcpy(pWapiSta->wapiMsk.dataKey, data + 10, 16);
_rtw_memcpy(pWapiSta->wapiMsk.micKey, data + 26, 16);
pWapiSta->wapiMsk.keyId = *(data + 42);
pWapiSta->wapiMsk.bTxEnable = false;
if (!pWapiSta->bSetkeyOk)
pWapiSta->bSetkeyOk = true;
pWapiInfo->bFirstAuthentiateInProgress = false;
WAPI_DATA(WAPI_INIT, "SetKey - ASUE MSK Data Key", pWapiSta->wapiMsk.dataKey, 16);
WAPI_DATA(WAPI_INIT, "SetKey - ASUE MSK Mic Key", pWapiSta->wapiMsk.micKey, 16);
} else {
WAPI_TRACE(WAPI_INIT, "ASUE update msk\n");
pWapiSta->wapiMskUpdate.bSet = true;
_rtw_memcpy(pWapiSta->wapiMskUpdate.dataKey, data + 10, 16);
_rtw_memcpy(pWapiSta->wapiMskUpdate.micKey, data + 26, 16);
pWapiSta->wapiMskUpdate.keyId = *(data + 42);
pWapiSta->wapiMskUpdate.bTxEnable = false;
}
}
break;
default:
WAPI_TRACE(WAPI_ERR, "Unknown Flag\n");
break;
}
}
}
}
WAPI_TRACE(WAPI_INIT, "<===========%s\n", __FUNCTION__);
}
void wapi_test_init(_adapter *padapter)
{
u8 keybuf[100];
u8 mac_addr[ETH_ALEN] = {0x00, 0xe0, 0x4c, 0x72, 0x04, 0x70};
u8 UskDataKey[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
u8 UskMicKey[16] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
u8 UskId = 0;
u8 MskDataKey[16] = {0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f};
u8 MskMicKey[16] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f};
u8 MskId = 0;
WAPI_TRACE(WAPI_INIT, "===========>%s\n", __FUNCTION__);
/* Enable Wapi */
WAPI_TRACE(WAPI_INIT, "%s: Enable wapi!!!!\n", __FUNCTION__);
padapter->wapiInfo.bWapiEnable = true;
padapter->pairwise_key_type = KEY_TYPE_SMS4;
ieee->group_key_type = KEY_TYPE_SMS4;
padapter->wapiInfo.extra_prefix_len = WAPI_EXT_LEN;
padapter->wapiInfo.extra_postfix_len = SMS4_MIC_LEN;
/* set usk */
WAPI_TRACE(WAPI_INIT, "%s: Set USK!!!!\n", __FUNCTION__);
_rtw_memset(keybuf, 0, 100);
keybuf[0] = 1; /* set usk */
keybuf[1] = 1; /* enable tx */
keybuf[2] = 1; /* AE */
keybuf[3] = 0; /* not update */
_rtw_memcpy(keybuf + 4, mac_addr, ETH_ALEN);
_rtw_memcpy(keybuf + 10, UskDataKey, 16);
_rtw_memcpy(keybuf + 26, UskMicKey, 16);
keybuf[42] = UskId;
wapi_test_set_key(padapter, keybuf);
_rtw_memset(keybuf, 0, 100);
keybuf[0] = 1; /* set usk */
keybuf[1] = 1; /* enable tx */
keybuf[2] = 0; /* AE */
keybuf[3] = 0; /* not update */
_rtw_memcpy(keybuf + 4, mac_addr, ETH_ALEN);
_rtw_memcpy(keybuf + 10, UskDataKey, 16);
_rtw_memcpy(keybuf + 26, UskMicKey, 16);
keybuf[42] = UskId;
wapi_test_set_key(padapter, keybuf);
/* set msk */
WAPI_TRACE(WAPI_INIT, "%s: Set MSK!!!!\n", __FUNCTION__);
_rtw_memset(keybuf, 0, 100);
keybuf[0] = 2; /* set msk */
keybuf[1] = 1; /* Enable TX */
keybuf[2] = 1; /* AE */
keybuf[3] = 0; /* not update */
_rtw_memcpy(keybuf + 4, mac_addr, ETH_ALEN);
_rtw_memcpy(keybuf + 10, MskDataKey, 16);
_rtw_memcpy(keybuf + 26, MskMicKey, 16);
keybuf[42] = MskId;
wapi_test_set_key(padapter, keybuf);
_rtw_memset(keybuf, 0, 100);
keybuf[0] = 2; /* set msk */
keybuf[1] = 1; /* Enable TX */
keybuf[2] = 0; /* AE */
keybuf[3] = 0; /* not update */
_rtw_memcpy(keybuf + 4, mac_addr, ETH_ALEN);
_rtw_memcpy(keybuf + 10, MskDataKey, 16);
_rtw_memcpy(keybuf + 26, MskMicKey, 16);
keybuf[42] = MskId;
wapi_test_set_key(padapter, keybuf);
WAPI_TRACE(WAPI_INIT, "<===========%s\n", __FUNCTION__);
}
#endif
void rtw_wapi_get_iv(_adapter *padapter, u8 *pRA, u8 *IV)
{
PWLAN_HEADER_WAPI_EXTENSION pWapiExt = NULL;
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
bool bPNOverflow = false;
bool bFindMatchPeer = false;
PRT_WAPI_STA_INFO pWapiSta = NULL;
pWapiExt = (PWLAN_HEADER_WAPI_EXTENSION)IV;
WAPI_DATA(WAPI_RX, "wapi_get_iv: pra", pRA, 6);
if (IS_MCAST(pRA)) {
if (!pWapiInfo->wapiTxMsk.bTxEnable) {
WAPI_TRACE(WAPI_ERR, "%s: bTxEnable = 0!!\n", __FUNCTION__);
return;
}
if (pWapiInfo->wapiTxMsk.keyId <= 1) {
pWapiExt->KeyIdx = pWapiInfo->wapiTxMsk.keyId;
pWapiExt->Reserved = 0;
bPNOverflow = WapiIncreasePN(pWapiInfo->lastTxMulticastPN, 1);
_rtw_memcpy(pWapiExt->PN, pWapiInfo->lastTxMulticastPN, 16);
}
} else {
if (list_empty(&pWapiInfo->wapiSTAUsedList)) {
WAPI_TRACE(WAPI_RX, "rtw_wapi_get_iv: list is empty\n");
_rtw_memset(IV, 10, 18);
return;
} else {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
WAPI_DATA(WAPI_RX, "rtw_wapi_get_iv: peermacaddr ", pWapiSta->PeerMacAddr, 6);
if (_rtw_memcmp((u8 *)pWapiSta->PeerMacAddr, pRA, 6) == _TRUE) {
bFindMatchPeer = true;
break;
}
}
WAPI_TRACE(WAPI_RX, "bFindMatchPeer: %d\n", bFindMatchPeer);
WAPI_DATA(WAPI_RX, "Addr", pRA, 6);
if (bFindMatchPeer) {
if ((!pWapiSta->wapiUskUpdate.bTxEnable) && (!pWapiSta->wapiUsk.bTxEnable))
return;
if (pWapiSta->wapiUsk.keyId <= 1) {
if (pWapiSta->wapiUskUpdate.bTxEnable)
pWapiExt->KeyIdx = pWapiSta->wapiUskUpdate.keyId;
else
pWapiExt->KeyIdx = pWapiSta->wapiUsk.keyId;
pWapiExt->Reserved = 0;
bPNOverflow = WapiIncreasePN(pWapiSta->lastTxUnicastPN, 2);
_rtw_memcpy(pWapiExt->PN, pWapiSta->lastTxUnicastPN, 16);
}
}
}
}
}
bool rtw_wapi_drop_for_key_absent(_adapter *padapter, u8 *pRA)
{
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
bool bFindMatchPeer = false;
bool bDrop = false;
PRT_WAPI_STA_INFO pWapiSta = NULL;
struct security_priv *psecuritypriv = &padapter->securitypriv;
WAPI_DATA(WAPI_RX, "rtw_wapi_drop_for_key_absent: ra ", pRA, 6);
if (psecuritypriv->dot11PrivacyAlgrthm == _SMS4_) {
if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable))
return true;
if (IS_MCAST(pRA)) {
if (!pWapiInfo->wapiTxMsk.bTxEnable) {
bDrop = true;
WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: multicast key is absent\n");
return bDrop;
}
} else {
if (!list_empty(&pWapiInfo->wapiSTAUsedList)) {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
WAPI_DATA(WAPI_RX, "rtw_wapi_drop_for_key_absent: pWapiSta->PeerMacAddr ", pWapiSta->PeerMacAddr, 6);
if (_rtw_memcmp(pRA, pWapiSta->PeerMacAddr, 6) == _TRUE) {
bFindMatchPeer = true;
break;
}
}
if (bFindMatchPeer) {
if (!pWapiSta->wapiUsk.bTxEnable) {
bDrop = true;
WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: unicast key is absent\n");
return bDrop;
}
} else {
bDrop = true;
WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: no peer find\n");
return bDrop;
}
} else {
bDrop = true;
WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: no sta exist\n");
return bDrop;
}
}
} else
return bDrop;
return bDrop;
}
void rtw_wapi_set_set_encryption(_adapter *padapter, struct ieee_param *param)
{
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
PRT_WAPI_STA_INFO pWapiSta;
u8 WapiASUEPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
if (param->u.crypt.set_tx == 1) {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_rtw_memcmp(pWapiSta->PeerMacAddr, param->sta_addr, 6)) {
_rtw_memcpy(pWapiSta->lastTxUnicastPN, WapiASUEPNInitialValueSrc, 16);
pWapiSta->wapiUsk.bSet = true;
_rtw_memcpy(pWapiSta->wapiUsk.dataKey, param->u.crypt.key, 16);
_rtw_memcpy(pWapiSta->wapiUsk.micKey, param->u.crypt.key + 16, 16);
pWapiSta->wapiUsk.keyId = param->u.crypt.idx;
psecuritypriv->dot11PrivacyKeyIndex = param->u.crypt.idx;
pWapiSta->wapiUsk.bTxEnable = true;
_rtw_memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiAEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiAEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiAEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiAEPNInitialValueSrc, 16);
_rtw_memcpy(pWapiSta->lastRxUnicastPN, WapiAEPNInitialValueSrc, 16);
pWapiSta->wapiUskUpdate.bTxEnable = false;
pWapiSta->wapiUskUpdate.bSet = false;
if (psecuritypriv->sw_encrypt == false || psecuritypriv->sw_decrypt == false) {
/* set unicast key for ASUE */
rtw_wapi_set_key(padapter, &pWapiSta->wapiUsk, pWapiSta, false);
}
}
}
} else {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_rtw_memcmp(pWapiSta->PeerMacAddr, get_bssid(pmlmepriv), 6)) {
pWapiSta->wapiMsk.bSet = true;
_rtw_memcpy(pWapiSta->wapiMsk.dataKey, param->u.crypt.key, 16);
_rtw_memcpy(pWapiSta->wapiMsk.micKey, param->u.crypt.key + 16, 16);
pWapiSta->wapiMsk.keyId = param->u.crypt.idx;
psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
pWapiSta->wapiMsk.bTxEnable = false;
if (!pWapiSta->bSetkeyOk)
pWapiSta->bSetkeyOk = true;
pWapiSta->bAuthenticateInProgress = false;
_rtw_memcpy(pWapiSta->lastRxMulticastPN, WapiAEMultiCastPNInitialValueSrc, 16);
if (psecuritypriv->sw_decrypt == false) {
/* set rx broadcast key for ASUE */
rtw_wapi_set_key(padapter, &pWapiSta->wapiMsk, pWapiSta, true);
}
}
}
}
}
#endif
|
2301_81045437/rtl8852be
|
core/rtw_wapi.c
|
C
|
agpl-3.0
| 43,404
|
/******************************************************************************
*
* Copyright(c) 2016 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifdef CONFIG_WAPI_SUPPORT
#include <linux/unistd.h>
#include <linux/etherdevice.h>
#include <drv_types.h>
#include <rtw_wapi.h>
#ifdef CONFIG_WAPI_SW_SMS4
#define WAPI_LITTLE_ENDIAN
/* #define BIG_ENDIAN */
#define ENCRYPT 0
#define DECRYPT 1
/**********************************************************
**********************************************************/
const u8 Sbox[256] = {
0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48
};
const u32 CK[32] = {
0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279
};
#define Rotl(_x, _y) (((_x) << (_y)) | ((_x) >> (32 - (_y))))
#define ByteSub(_A) (Sbox[(_A) >> 24 & 0xFF] << 24 | \
Sbox[(_A) >> 16 & 0xFF] << 16 | \
Sbox[(_A) >> 8 & 0xFF] << 8 | \
Sbox[(_A) & 0xFF])
#define L1(_B) ((_B) ^ Rotl(_B, 2) ^ Rotl(_B, 10) ^ Rotl(_B, 18) ^ Rotl(_B, 24))
#define L2(_B) ((_B) ^ Rotl(_B, 13) ^ Rotl(_B, 23))
static void
xor_block(void *dst, void *src1, void *src2)
/* 128-bit xor: *dst = *src1 xor *src2. Pointers must be 32-bit aligned */
{
((u32 *)dst)[0] = ((u32 *)src1)[0] ^ ((u32 *)src2)[0];
((u32 *)dst)[1] = ((u32 *)src1)[1] ^ ((u32 *)src2)[1];
((u32 *)dst)[2] = ((u32 *)src1)[2] ^ ((u32 *)src2)[2];
((u32 *)dst)[3] = ((u32 *)src1)[3] ^ ((u32 *)src2)[3];
}
void SMS4Crypt(u8 *Input, u8 *Output, u32 *rk)
{
u32 r, mid, x0, x1, x2, x3, *p;
p = (u32 *)Input;
x0 = p[0];
x1 = p[1];
x2 = p[2];
x3 = p[3];
#ifdef WAPI_LITTLE_ENDIAN
x0 = Rotl(x0, 16);
x0 = ((x0 & 0x00FF00FF) << 8) | ((x0 & 0xFF00FF00) >> 8);
x1 = Rotl(x1, 16);
x1 = ((x1 & 0x00FF00FF) << 8) | ((x1 & 0xFF00FF00) >> 8);
x2 = Rotl(x2, 16);
x2 = ((x2 & 0x00FF00FF) << 8) | ((x2 & 0xFF00FF00) >> 8);
x3 = Rotl(x3, 16);
x3 = ((x3 & 0x00FF00FF) << 8) | ((x3 & 0xFF00FF00) >> 8);
#endif
for (r = 0; r < 32; r += 4) {
mid = x1 ^ x2 ^ x3 ^ rk[r + 0];
mid = ByteSub(mid);
x0 ^= L1(mid);
mid = x2 ^ x3 ^ x0 ^ rk[r + 1];
mid = ByteSub(mid);
x1 ^= L1(mid);
mid = x3 ^ x0 ^ x1 ^ rk[r + 2];
mid = ByteSub(mid);
x2 ^= L1(mid);
mid = x0 ^ x1 ^ x2 ^ rk[r + 3];
mid = ByteSub(mid);
x3 ^= L1(mid);
}
#ifdef WAPI_LITTLE_ENDIAN
x0 = Rotl(x0, 16);
x0 = ((x0 & 0x00FF00FF) << 8) | ((x0 & 0xFF00FF00) >> 8);
x1 = Rotl(x1, 16);
x1 = ((x1 & 0x00FF00FF) << 8) | ((x1 & 0xFF00FF00) >> 8);
x2 = Rotl(x2, 16);
x2 = ((x2 & 0x00FF00FF) << 8) | ((x2 & 0xFF00FF00) >> 8);
x3 = Rotl(x3, 16);
x3 = ((x3 & 0x00FF00FF) << 8) | ((x3 & 0xFF00FF00) >> 8);
#endif
p = (u32 *)Output;
p[0] = x3;
p[1] = x2;
p[2] = x1;
p[3] = x0;
}
void SMS4KeyExt(u8 *Key, u32 *rk, u32 CryptFlag)
{
u32 r, mid, x0, x1, x2, x3, *p;
p = (u32 *)Key;
x0 = p[0];
x1 = p[1];
x2 = p[2];
x3 = p[3];
#ifdef WAPI_LITTLE_ENDIAN
x0 = Rotl(x0, 16);
x0 = ((x0 & 0xFF00FF) << 8) | ((x0 & 0xFF00FF00) >> 8);
x1 = Rotl(x1, 16);
x1 = ((x1 & 0xFF00FF) << 8) | ((x1 & 0xFF00FF00) >> 8);
x2 = Rotl(x2, 16);
x2 = ((x2 & 0xFF00FF) << 8) | ((x2 & 0xFF00FF00) >> 8);
x3 = Rotl(x3, 16);
x3 = ((x3 & 0xFF00FF) << 8) | ((x3 & 0xFF00FF00) >> 8);
#endif
x0 ^= 0xa3b1bac6;
x1 ^= 0x56aa3350;
x2 ^= 0x677d9197;
x3 ^= 0xb27022dc;
for (r = 0; r < 32; r += 4) {
mid = x1 ^ x2 ^ x3 ^ CK[r + 0];
mid = ByteSub(mid);
rk[r + 0] = x0 ^= L2(mid);
mid = x2 ^ x3 ^ x0 ^ CK[r + 1];
mid = ByteSub(mid);
rk[r + 1] = x1 ^= L2(mid);
mid = x3 ^ x0 ^ x1 ^ CK[r + 2];
mid = ByteSub(mid);
rk[r + 2] = x2 ^= L2(mid);
mid = x0 ^ x1 ^ x2 ^ CK[r + 3];
mid = ByteSub(mid);
rk[r + 3] = x3 ^= L2(mid);
}
if (CryptFlag == DECRYPT) {
for (r = 0; r < 16; r++)
mid = rk[r], rk[r] = rk[31 - r], rk[31 - r] = mid;
}
}
void WapiSMS4Cryption(u8 *Key, u8 *IV, u8 *Input, u16 InputLength,
u8 *Output, u16 *OutputLength, u32 CryptFlag)
{
u32 blockNum, i, j, rk[32];
u16 remainder;
u8 blockIn[16], blockOut[16], tempIV[16], k;
*OutputLength = 0;
remainder = InputLength & 0x0F;
blockNum = InputLength >> 4;
if (remainder != 0)
blockNum++;
else
remainder = 16;
for (k = 0; k < 16; k++)
tempIV[k] = IV[15 - k];
_rtw_memcpy(blockIn, tempIV, 16);
SMS4KeyExt((u8 *)Key, rk, CryptFlag);
for (i = 0; i < blockNum - 1; i++) {
SMS4Crypt((u8 *)blockIn, blockOut, rk);
xor_block(&Output[i * 16], &Input[i * 16], blockOut);
_rtw_memcpy(blockIn, blockOut, 16);
}
*OutputLength = i * 16;
SMS4Crypt((u8 *)blockIn, blockOut, rk);
for (j = 0; j < remainder; j++)
Output[i * 16 + j] = Input[i * 16 + j] ^ blockOut[j];
*OutputLength += remainder;
}
void WapiSMS4Encryption(u8 *Key, u8 *IV, u8 *Input, u16 InputLength,
u8 *Output, u16 *OutputLength)
{
WapiSMS4Cryption(Key, IV, Input, InputLength, Output, OutputLength, ENCRYPT);
}
void WapiSMS4Decryption(u8 *Key, u8 *IV, u8 *Input, u16 InputLength,
u8 *Output, u16 *OutputLength)
{
/* OFB mode: is also ENCRYPT flag */
WapiSMS4Cryption(Key, IV, Input, InputLength, Output, OutputLength, ENCRYPT);
}
void WapiSMS4CalculateMic(u8 *Key, u8 *IV, u8 *Input1, u8 Input1Length,
u8 *Input2, u16 Input2Length, u8 *Output, u8 *OutputLength)
{
u32 blockNum, i, remainder, rk[32];
u8 BlockIn[16], BlockOut[16], TempBlock[16], tempIV[16], k;
*OutputLength = 0;
remainder = Input1Length & 0x0F;
blockNum = Input1Length >> 4;
for (k = 0; k < 16; k++)
tempIV[k] = IV[15 - k];
_rtw_memcpy(BlockIn, tempIV, 16);
SMS4KeyExt((u8 *)Key, rk, ENCRYPT);
SMS4Crypt((u8 *)BlockIn, BlockOut, rk);
for (i = 0; i < blockNum; i++) {
xor_block(BlockIn, (Input1 + i * 16), BlockOut);
SMS4Crypt((u8 *)BlockIn, BlockOut, rk);
}
if (remainder != 0) {
_rtw_memset(TempBlock, 0, 16);
_rtw_memcpy(TempBlock, (Input1 + blockNum * 16), remainder);
xor_block(BlockIn, TempBlock, BlockOut);
SMS4Crypt((u8 *)BlockIn, BlockOut, rk);
}
remainder = Input2Length & 0x0F;
blockNum = Input2Length >> 4;
for (i = 0; i < blockNum; i++) {
xor_block(BlockIn, (Input2 + i * 16), BlockOut);
SMS4Crypt((u8 *)BlockIn, BlockOut, rk);
}
if (remainder != 0) {
_rtw_memset(TempBlock, 0, 16);
_rtw_memcpy(TempBlock, (Input2 + blockNum * 16), remainder);
xor_block(BlockIn, TempBlock, BlockOut);
SMS4Crypt((u8 *)BlockIn, BlockOut, rk);
}
_rtw_memcpy(Output, BlockOut, 16);
*OutputLength = 16;
}
void SecCalculateMicSMS4(
u8 KeyIdx,
u8 *MicKey,
u8 *pHeader,
u8 *pData,
u16 DataLen,
u8 *MicBuffer
)
{
#if 0
struct ieee80211_hdr_3addr_qos *header;
u8 TempBuf[34], TempLen = 32, MicLen, QosOffset, *IV;
u16 *pTemp, fc;
WAPI_TRACE(WAPI_TX | WAPI_RX, "=========>%s\n", __FUNCTION__);
header = (struct ieee80211_hdr_3addr_qos *)pHeader;
_rtw_memset(TempBuf, 0, 34);
_rtw_memcpy(TempBuf, pHeader, 2); /* FrameCtrl */
pTemp = (u16 *)TempBuf;
*pTemp &= 0xc78f; /* bit4,5,6,11,12,13 */
_rtw_memcpy((TempBuf + 2), (pHeader + 4), 12); /* Addr1, Addr2 */
_rtw_memcpy((TempBuf + 14), (pHeader + 22), 2); /* SeqCtrl */
pTemp = (u16 *)(TempBuf + 14);
*pTemp &= 0x000f;
_rtw_memcpy((TempBuf + 16), (pHeader + 16), 6); /* Addr3 */
fc = le16_to_cpu(header->frame_ctl);
if (GetFrDs((u16 *)&fc) && GetToDs((u16 *)&fc)) {
_rtw_memcpy((TempBuf + 22), (pHeader + 24), 6);
QosOffset = 30;
} else {
_rtw_memset((TempBuf + 22), 0, 6);
QosOffset = 24;
}
if ((fc & 0x0088) == 0x0088) {
_rtw_memcpy((TempBuf + 28), (pHeader + QosOffset), 2);
TempLen += 2;
/* IV = pHeader + QosOffset + 2 + SNAP_SIZE + sizeof(u16) + 2; */
IV = pHeader + QosOffset + 2 + 2;
} else {
IV = pHeader + QosOffset + 2;
/* IV = pHeader + QosOffset + SNAP_SIZE + sizeof(u16) + 2; */
}
TempBuf[TempLen - 1] = (u8)(DataLen & 0xff);
TempBuf[TempLen - 2] = (u8)((DataLen & 0xff00) >> 8);
TempBuf[TempLen - 4] = KeyIdx;
WAPI_DATA(WAPI_TX, "CalculateMic - KEY", MicKey, 16);
WAPI_DATA(WAPI_TX, "CalculateMic - IV", IV, 16);
WAPI_DATA(WAPI_TX, "CalculateMic - TempBuf", TempBuf, TempLen);
WAPI_DATA(WAPI_TX, "CalculateMic - pData", pData, DataLen);
WapiSMS4CalculateMic(MicKey, IV, TempBuf, TempLen,
pData, DataLen, MicBuffer, &MicLen);
if (MicLen != 16)
WAPI_TRACE(WAPI_ERR, "%s: MIC Length Error!!\n", __FUNCTION__);
WAPI_TRACE(WAPI_TX | WAPI_RX, "<=========%s\n", __FUNCTION__);
#endif
}
/* AddCount: 1 or 2.
* If overflow, return 1,
* else return 0.
*/
u8 WapiIncreasePN(u8 *PN, u8 AddCount)
{
u8 i;
if (NULL == PN)
return 1;
/* YJ,test,091102 */
/*
if(AddCount == 2){
RTW_INFO("############################%s(): PN[0]=0x%x\n", __FUNCTION__, PN[0]);
if(PN[0] == 0x48){
PN[0] += AddCount;
return 1;
}else{
PN[0] += AddCount;
return 0;
}
}
*/
/* YJ,test,091102,end */
for (i = 0; i < 16; i++) {
if (PN[i] + AddCount <= 0xff) {
PN[i] += AddCount;
return 0;
} else {
PN[i] += AddCount;
AddCount = 1;
}
}
return 1;
}
void WapiGetLastRxUnicastPNForQoSData(
u8 UserPriority,
PRT_WAPI_STA_INFO pWapiStaInfo,
u8 *PNOut
)
{
WAPI_TRACE(WAPI_RX, "===========> %s\n", __FUNCTION__);
switch (UserPriority) {
case 0:
case 3:
_rtw_memcpy(PNOut, pWapiStaInfo->lastRxUnicastPNBEQueue, 16);
break;
case 1:
case 2:
_rtw_memcpy(PNOut, pWapiStaInfo->lastRxUnicastPNBKQueue, 16);
break;
case 4:
case 5:
_rtw_memcpy(PNOut, pWapiStaInfo->lastRxUnicastPNVIQueue, 16);
break;
case 6:
case 7:
_rtw_memcpy(PNOut, pWapiStaInfo->lastRxUnicastPNVOQueue, 16);
break;
default:
WAPI_TRACE(WAPI_ERR, "%s: Unknown TID\n", __FUNCTION__);
break;
}
WAPI_TRACE(WAPI_RX, "<=========== %s\n", __FUNCTION__);
}
void WapiSetLastRxUnicastPNForQoSData(
u8 UserPriority,
u8 *PNIn,
PRT_WAPI_STA_INFO pWapiStaInfo
)
{
WAPI_TRACE(WAPI_RX, "===========> %s\n", __FUNCTION__);
switch (UserPriority) {
case 0:
case 3:
_rtw_memcpy(pWapiStaInfo->lastRxUnicastPNBEQueue, PNIn, 16);
break;
case 1:
case 2:
_rtw_memcpy(pWapiStaInfo->lastRxUnicastPNBKQueue, PNIn, 16);
break;
case 4:
case 5:
_rtw_memcpy(pWapiStaInfo->lastRxUnicastPNVIQueue, PNIn, 16);
break;
case 6:
case 7:
_rtw_memcpy(pWapiStaInfo->lastRxUnicastPNVOQueue, PNIn, 16);
break;
default:
WAPI_TRACE(WAPI_ERR, "%s: Unknown TID\n", __FUNCTION__);
break;
}
WAPI_TRACE(WAPI_RX, "<=========== %s\n", __FUNCTION__);
}
/****************************************************************************
FALSE not RX-Reorder
TRUE do RX Reorder
add to support WAPI to N-mode
*****************************************************************************/
u8 WapiCheckPnInSwDecrypt(
_adapter *padapter,
struct sk_buff *pskb
)
{
u8 ret = false;
#if 0
struct ieee80211_hdr_3addr_qos *header;
u16 fc;
u8 *pDaddr, *pTaddr, *pRaddr;
header = (struct ieee80211_hdr_3addr_qos *)pskb->data;
pTaddr = header->addr2;
pRaddr = header->addr1;
fc = le16_to_cpu(header->frame_ctl);
if (GetToDs(&fc))
pDaddr = header->addr3;
else
pDaddr = header->addr1;
if ((_rtw_memcmp(pRaddr, padapter->pnetdev->dev_addr, ETH_ALEN) == 0)
&& !(pDaddr)
&& (GetFrameType(&fc) == WIFI_QOS_DATA_TYPE))
/* && ieee->pHTInfo->bCurrentHTSupport && */
/* ieee->pHTInfo->bCurRxReorderEnable) */
ret = false;
else
ret = true;
#endif
WAPI_TRACE(WAPI_RX, "%s: return %d\n", __FUNCTION__, ret);
return ret;
}
int SecSMS4HeaderFillIV(_adapter *padapter, u8 *pxmitframe)
{
struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
u8 *frame = ((struct xmit_frame *)pxmitframe)->buf_addr + TXDESC_OFFSET;
u8 *pSecHeader = NULL, *pos = NULL, *pRA = NULL;
u8 bPNOverflow = false, bFindMatchPeer = false, hdr_len = 0;
PWLAN_HEADER_WAPI_EXTENSION pWapiExt = NULL;
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
PRT_WAPI_STA_INFO pWapiSta = NULL;
int ret = 0;
WAPI_TRACE(WAPI_TX, "=========>%s\n", __FUNCTION__);
return ret;
#if 0
hdr_len = sMacHdrLng;
if (GetFrameType(pskb->data) == WIFI_QOS_DATA_TYPE)
hdr_len += 2;
/* hdr_len += SNAP_SIZE + sizeof(u16); */
pos = skb_push(pskb, padapter->wapiInfo.extra_prefix_len);
memmove(pos, pos + padapter->wapiInfo.extra_prefix_len, hdr_len);
pSecHeader = pskb->data + hdr_len;
pWapiExt = (PWLAN_HEADER_WAPI_EXTENSION)pSecHeader;
pRA = pskb->data + 4;
WAPI_DATA(WAPI_TX, "FillIV - Before Fill IV", pskb->data, pskb->len);
/* Address 1 is always receiver's address */
if (IS_MCAST(pRA)) {
if (!pWapiInfo->wapiTxMsk.bTxEnable) {
WAPI_TRACE(WAPI_ERR, "%s: bTxEnable = 0!!\n", __FUNCTION__);
return -2;
}
if (pWapiInfo->wapiTxMsk.keyId <= 1) {
pWapiExt->KeyIdx = pWapiInfo->wapiTxMsk.keyId;
pWapiExt->Reserved = 0;
bPNOverflow = WapiIncreasePN(pWapiInfo->lastTxMulticastPN, 1);
_rtw_memcpy(pWapiExt->PN, pWapiInfo->lastTxMulticastPN, 16);
if (bPNOverflow) {
/* Update MSK Notification. */
WAPI_TRACE(WAPI_ERR, "===============>%s():multicast PN overflow\n", __FUNCTION__);
rtw_wapi_app_event_handler(padapter, NULL, 0, pRA, false, false, true, 0, false);
}
} else {
WAPI_TRACE(WAPI_ERR, "%s: Invalid Wapi Multicast KeyIdx!!\n", __FUNCTION__);
ret = -3;
}
} else {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_rtw_memcmp(pWapiSta->PeerMacAddr, pRA, 6) == _TRUE) {
bFindMatchPeer = true;
break;
}
}
if (bFindMatchPeer) {
if ((!pWapiSta->wapiUskUpdate.bTxEnable) && (!pWapiSta->wapiUsk.bTxEnable)) {
WAPI_TRACE(WAPI_ERR, "%s: bTxEnable = 0!!\n", __FUNCTION__);
return -4;
}
if (pWapiSta->wapiUsk.keyId <= 1) {
if (pWapiSta->wapiUskUpdate.bTxEnable)
pWapiExt->KeyIdx = pWapiSta->wapiUskUpdate.keyId;
else
pWapiExt->KeyIdx = pWapiSta->wapiUsk.keyId;
pWapiExt->Reserved = 0;
bPNOverflow = WapiIncreasePN(pWapiSta->lastTxUnicastPN, 2);
_rtw_memcpy(pWapiExt->PN, pWapiSta->lastTxUnicastPN, 16);
if (bPNOverflow) {
/* Update USK Notification. */
WAPI_TRACE(WAPI_ERR, "===============>%s():unicast PN overflow\n", __FUNCTION__);
rtw_wapi_app_event_handler(padapter, NULL, 0, pWapiSta->PeerMacAddr, false, true, false, 0, false);
}
} else {
WAPI_TRACE(WAPI_ERR, "%s: Invalid Wapi Unicast KeyIdx!!\n", __FUNCTION__);
ret = -5;
}
} else {
WAPI_TRACE(WAPI_ERR, "%s: Can not find Peer Sta "MAC_FMT"!!\n", __FUNCTION__, MAC_ARG(pRA));
ret = -6;
}
}
WAPI_DATA(WAPI_TX, "FillIV - After Fill IV", pskb->data, pskb->len);
WAPI_TRACE(WAPI_TX, "<=========%s\n", __FUNCTION__);
return ret;
#endif
}
/* WAPI SW Enc: must have done Coalesce! */
void SecSWSMS4Encryption(
_adapter *padapter,
u8 *pxmitframe
)
{
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
PRT_WAPI_STA_INFO pWapiSta = NULL;
u8 *pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + TXDESC_SIZE;
struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
u8 *SecPtr = NULL, *pRA, *pMicKey = NULL, *pDataKey = NULL, *pIV = NULL;
u8 IVOffset, DataOffset, bFindMatchPeer = false, KeyIdx = 0, MicBuffer[16];
u16 OutputLength;
WAPI_TRACE(WAPI_TX, "=========>%s\n", __FUNCTION__);
WAPI_TRACE(WAPI_TX, "hdrlen: %d\n", pattrib->hdrlen);
return;
DataOffset = pattrib->hdrlen + pattrib->iv_len;
pRA = pframe + 4;
if (IS_MCAST(pRA)) {
KeyIdx = pWapiInfo->wapiTxMsk.keyId;
pIV = pWapiInfo->lastTxMulticastPN;
pMicKey = pWapiInfo->wapiTxMsk.micKey;
pDataKey = pWapiInfo->wapiTxMsk.dataKey;
} else {
if (!list_empty(&(pWapiInfo->wapiSTAUsedList))) {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_TRUE == _rtw_memcmp(pWapiSta->PeerMacAddr, pRA, 6)) {
bFindMatchPeer = true;
break;
}
}
if (bFindMatchPeer) {
if (pWapiSta->wapiUskUpdate.bTxEnable) {
KeyIdx = pWapiSta->wapiUskUpdate.keyId;
WAPI_TRACE(WAPI_TX, "%s(): Use update USK!! KeyIdx=%d\n", __FUNCTION__, KeyIdx);
pIV = pWapiSta->lastTxUnicastPN;
pMicKey = pWapiSta->wapiUskUpdate.micKey;
pDataKey = pWapiSta->wapiUskUpdate.dataKey;
} else {
KeyIdx = pWapiSta->wapiUsk.keyId;
WAPI_TRACE(WAPI_TX, "%s(): Use USK!! KeyIdx=%d\n", __FUNCTION__, KeyIdx);
pIV = pWapiSta->lastTxUnicastPN;
pMicKey = pWapiSta->wapiUsk.micKey;
pDataKey = pWapiSta->wapiUsk.dataKey;
}
} else {
WAPI_TRACE(WAPI_ERR, "%s: Can not find Peer Sta!!\n", __FUNCTION__);
return;
}
} else {
WAPI_TRACE(WAPI_ERR, "%s: wapiSTAUsedList is empty!!\n", __FUNCTION__);
return;
}
}
SecPtr = pframe;
SecCalculateMicSMS4(KeyIdx, pMicKey, SecPtr, (SecPtr + DataOffset), pattrib->pktlen, MicBuffer);
WAPI_DATA(WAPI_TX, "Encryption - MIC", MicBuffer, padapter->wapiInfo.extra_postfix_len);
_rtw_memcpy(pframe + pattrib->hdrlen + pattrib->iv_len + pattrib->pktlen - pattrib->icv_len,
(u8 *)MicBuffer,
padapter->wapiInfo.extra_postfix_len
);
WapiSMS4Encryption(pDataKey, pIV, (SecPtr + DataOffset), pattrib->pktlen + pattrib->icv_len, (SecPtr + DataOffset), &OutputLength);
WAPI_DATA(WAPI_TX, "Encryption - After SMS4 encryption", pframe, pattrib->hdrlen + pattrib->iv_len + pattrib->pktlen);
WAPI_TRACE(WAPI_TX, "<=========%s\n", __FUNCTION__);
}
u8 SecSWSMS4Decryption(
_adapter *padapter,
u8 *precv_frame,
struct recv_priv *precv_priv
)
{
PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
struct recv_frame_hdr *precv_hdr;
PRT_WAPI_STA_INFO pWapiSta = NULL;
u8 IVOffset, DataOffset, bFindMatchPeer = false, bUseUpdatedKey = false;
u8 KeyIdx, MicBuffer[16], lastRxPNforQoS[16];
u8 *pRA, *pTA, *pMicKey, *pDataKey, *pLastRxPN, *pRecvPN, *pSecData, *pRecvMic, *pos;
u8 TID = 0;
u16 OutputLength, DataLen;
u8 bQosData;
struct sk_buff *pskb;
WAPI_TRACE(WAPI_RX, "=========>%s\n", __FUNCTION__);
return 0;
precv_hdr = &((union recv_frame *)precv_frame)->u.hdr;
pskb = (struct sk_buff *)(precv_hdr->rx_data);
precv_hdr->bWapiCheckPNInDecrypt = WapiCheckPnInSwDecrypt(padapter, pskb);
WAPI_TRACE(WAPI_RX, "=========>%s: check PN %d\n", __FUNCTION__, precv_hdr->bWapiCheckPNInDecrypt);
WAPI_DATA(WAPI_RX, "Decryption - Before decryption", pskb->data, pskb->len);
IVOffset = sMacHdrLng;
bQosData = GetFrameType(pskb->data) == WIFI_QOS_DATA_TYPE;
if (bQosData)
IVOffset += 2;
/* if(GetHTC()) */
/* IVOffset += 4; */
/* IVOffset += SNAP_SIZE + sizeof(u16); */
DataOffset = IVOffset + padapter->wapiInfo.extra_prefix_len;
pRA = pskb->data + 4;
pTA = pskb->data + 10;
KeyIdx = *(pskb->data + IVOffset);
pRecvPN = pskb->data + IVOffset + 2;
pSecData = pskb->data + DataOffset;
DataLen = pskb->len - DataOffset;
pRecvMic = pskb->data + pskb->len - padapter->wapiInfo.extra_postfix_len;
TID = GetTid(pskb->data);
if (!list_empty(&(pWapiInfo->wapiSTAUsedList))) {
list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
if (_TRUE == _rtw_memcmp(pWapiSta->PeerMacAddr, pTA, 6)) {
bFindMatchPeer = true;
break;
}
}
}
if (!bFindMatchPeer) {
WAPI_TRACE(WAPI_ERR, "%s: Can not find Peer Sta "MAC_FMT" for Key Info!!!\n", __FUNCTION__, MAC_ARG(pTA));
return false;
}
if (IS_MCAST(pRA)) {
WAPI_TRACE(WAPI_RX, "%s: Multicast decryption !!!\n", __FUNCTION__);
if (pWapiSta->wapiMsk.keyId == KeyIdx && pWapiSta->wapiMsk.bSet) {
pLastRxPN = pWapiSta->lastRxMulticastPN;
if (!WapiComparePN(pRecvPN, pLastRxPN)) {
WAPI_TRACE(WAPI_ERR, "%s: MSK PN is not larger than last, Dropped!!!\n", __FUNCTION__);
WAPI_DATA(WAPI_ERR, "pRecvPN:", pRecvPN, 16);
WAPI_DATA(WAPI_ERR, "pLastRxPN:", pLastRxPN, 16);
return false;
}
_rtw_memcpy(pLastRxPN, pRecvPN, 16);
pMicKey = pWapiSta->wapiMsk.micKey;
pDataKey = pWapiSta->wapiMsk.dataKey;
} else if (pWapiSta->wapiMskUpdate.keyId == KeyIdx && pWapiSta->wapiMskUpdate.bSet) {
WAPI_TRACE(WAPI_RX, "%s: Use Updated MSK for Decryption !!!\n", __FUNCTION__);
bUseUpdatedKey = true;
_rtw_memcpy(pWapiSta->lastRxMulticastPN, pRecvPN, 16);
pMicKey = pWapiSta->wapiMskUpdate.micKey;
pDataKey = pWapiSta->wapiMskUpdate.dataKey;
} else {
WAPI_TRACE(WAPI_ERR, "%s: Can not find MSK with matched KeyIdx(%d), Dropped !!!\n", __FUNCTION__, KeyIdx);
return false;
}
} else {
WAPI_TRACE(WAPI_RX, "%s: Unicast decryption !!!\n", __FUNCTION__);
if (pWapiSta->wapiUsk.keyId == KeyIdx && pWapiSta->wapiUsk.bSet) {
WAPI_TRACE(WAPI_RX, "%s: Use USK for Decryption!!!\n", __FUNCTION__);
if (precv_hdr->bWapiCheckPNInDecrypt) {
if (GetFrameType(pskb->data) == WIFI_QOS_DATA_TYPE) {
WapiGetLastRxUnicastPNForQoSData(TID, pWapiSta, lastRxPNforQoS);
pLastRxPN = lastRxPNforQoS;
} else
pLastRxPN = pWapiSta->lastRxUnicastPN;
if (!WapiComparePN(pRecvPN, pLastRxPN))
return false;
if (bQosData)
WapiSetLastRxUnicastPNForQoSData(TID, pRecvPN, pWapiSta);
else
_rtw_memcpy(pWapiSta->lastRxUnicastPN, pRecvPN, 16);
} else
_rtw_memcpy(precv_hdr->WapiTempPN, pRecvPN, 16);
if (MLME_IS_STA(padapter)) {
if ((pRecvPN[0] & 0x1) == 0) {
WAPI_TRACE(WAPI_ERR, "%s: Rx USK PN is not odd when Infra STA mode, Dropped !!!\n", __FUNCTION__);
return false;
}
}
pMicKey = pWapiSta->wapiUsk.micKey;
pDataKey = pWapiSta->wapiUsk.dataKey;
} else if (pWapiSta->wapiUskUpdate.keyId == KeyIdx && pWapiSta->wapiUskUpdate.bSet) {
WAPI_TRACE(WAPI_RX, "%s: Use Updated USK for Decryption!!!\n", __FUNCTION__);
if (pWapiSta->bAuthenticatorInUpdata)
bUseUpdatedKey = true;
else
bUseUpdatedKey = false;
if (bQosData)
WapiSetLastRxUnicastPNForQoSData(TID, pRecvPN, pWapiSta);
else
_rtw_memcpy(pWapiSta->lastRxUnicastPN, pRecvPN, 16);
pMicKey = pWapiSta->wapiUskUpdate.micKey;
pDataKey = pWapiSta->wapiUskUpdate.dataKey;
} else {
WAPI_TRACE(WAPI_ERR, "%s: No valid USK!!!KeyIdx=%d pWapiSta->wapiUsk.keyId=%d pWapiSta->wapiUskUpdate.keyId=%d\n", __FUNCTION__, KeyIdx, pWapiSta->wapiUsk.keyId,
pWapiSta->wapiUskUpdate.keyId);
/* dump_buf(pskb->data,pskb->len); */
return false;
}
}
WAPI_DATA(WAPI_RX, "Decryption - DataKey", pDataKey, 16);
WAPI_DATA(WAPI_RX, "Decryption - IV", pRecvPN, 16);
WapiSMS4Decryption(pDataKey, pRecvPN, pSecData, DataLen, pSecData, &OutputLength);
if (OutputLength != DataLen)
WAPI_TRACE(WAPI_ERR, "%s: Output Length Error!!!!\n", __FUNCTION__);
WAPI_DATA(WAPI_RX, "Decryption - After decryption", pskb->data, pskb->len);
DataLen -= padapter->wapiInfo.extra_postfix_len;
SecCalculateMicSMS4(KeyIdx, pMicKey, pskb->data, pSecData, DataLen, MicBuffer);
WAPI_DATA(WAPI_RX, "Decryption - MIC received", pRecvMic, SMS4_MIC_LEN);
WAPI_DATA(WAPI_RX, "Decryption - MIC calculated", MicBuffer, SMS4_MIC_LEN);
if (_TRUE == _rtw_memcmp(MicBuffer, pRecvMic, padapter->wapiInfo.extra_postfix_len)) {
WAPI_TRACE(WAPI_RX, "%s: Check MIC OK!!\n", __FUNCTION__);
if (bUseUpdatedKey) {
/* delete the old key */
if (IS_MCAST(pRA)) {
WAPI_TRACE(WAPI_API, "%s(): AE use new update MSK!!\n", __FUNCTION__);
pWapiSta->wapiMsk.keyId = pWapiSta->wapiMskUpdate.keyId;
_rtw_memcpy(pWapiSta->wapiMsk.dataKey, pWapiSta->wapiMskUpdate.dataKey, 16);
_rtw_memcpy(pWapiSta->wapiMsk.micKey, pWapiSta->wapiMskUpdate.micKey, 16);
pWapiSta->wapiMskUpdate.bTxEnable = pWapiSta->wapiMskUpdate.bSet = false;
} else {
WAPI_TRACE(WAPI_API, "%s(): AE use new update USK!!\n", __FUNCTION__);
pWapiSta->wapiUsk.keyId = pWapiSta->wapiUskUpdate.keyId;
_rtw_memcpy(pWapiSta->wapiUsk.dataKey, pWapiSta->wapiUskUpdate.dataKey, 16);
_rtw_memcpy(pWapiSta->wapiUsk.micKey, pWapiSta->wapiUskUpdate.micKey, 16);
pWapiSta->wapiUskUpdate.bTxEnable = pWapiSta->wapiUskUpdate.bSet = false;
}
}
} else {
WAPI_TRACE(WAPI_ERR, "%s: Check MIC Error, Dropped !!!!\n", __FUNCTION__);
return false;
}
pos = pskb->data;
memmove(pos + padapter->wapiInfo.extra_prefix_len, pos, IVOffset);
skb_pull(pskb, padapter->wapiInfo.extra_prefix_len);
WAPI_TRACE(WAPI_RX, "<=========%s\n", __FUNCTION__);
return true;
}
u32 rtw_sms4_encrypt(_adapter *padapter, u8 *pxmitframe)
{
u8 *pframe;
u32 res = _SUCCESS;
WAPI_TRACE(WAPI_TX, "=========>%s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
WAPI_TRACE(WAPI_TX, "<========== %s, WAPI not supported or enabled!\n", __FUNCTION__);
return _FAIL;
}
if (((struct xmit_frame *)pxmitframe)->buf_addr == NULL)
return _FAIL;
pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + TXDESC_OFFSET;
SecSWSMS4Encryption(padapter, pxmitframe);
WAPI_TRACE(WAPI_TX, "<=========%s\n", __FUNCTION__);
return res;
}
u32 rtw_sms4_decrypt(_adapter *padapter, u8 *precvframe)
{
u8 *pframe;
u32 res = _SUCCESS;
WAPI_TRACE(WAPI_RX, "=========>%s\n", __FUNCTION__);
if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
WAPI_TRACE(WAPI_RX, "<========== %s, WAPI not supported or enabled!\n", __FUNCTION__);
return _FAIL;
}
/* drop packet when hw decrypt fail
* return tempraily */
return _FAIL;
/* pframe=(unsigned char *)((union recv_frame*)precvframe)->u.hdr.rx_data; */
if (false == SecSWSMS4Decryption(padapter, precvframe, &adapter_to_dvobj(padapter)->recvpriv)) {
WAPI_TRACE(WAPI_ERR, "%s():SMS4 decrypt frame error\n", __FUNCTION__);
return _FAIL;
}
WAPI_TRACE(WAPI_RX, "<=========%s\n", __FUNCTION__);
return res;
}
#else
u32 rtw_sms4_encrypt(_adapter *padapter, u8 *pxmitframe)
{
WAPI_TRACE(WAPI_TX, "=========>Dummy %s\n", __FUNCTION__);
WAPI_TRACE(WAPI_TX, "<=========Dummy %s\n", __FUNCTION__);
return _SUCCESS;
}
u32 rtw_sms4_decrypt(_adapter *padapter, u8 *precvframe)
{
WAPI_TRACE(WAPI_RX, "=========>Dummy %s\n", __FUNCTION__);
WAPI_TRACE(WAPI_RX, "<=========Dummy %s\n", __FUNCTION__);
return _SUCCESS;
}
#endif
#endif
|
2301_81045437/rtl8852be
|
core/rtw_wapi_sms4.c
|
C
|
agpl-3.0
| 27,858
|
/******************************************************************************
*
* Copyright(c) 2007 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_WLAN_UTIL_C_
#include <drv_types.h>
unsigned char ARTHEROS_OUI1[] = {0x00, 0x03, 0x7f};
unsigned char ARTHEROS_OUI2[] = {0x00, 0x13, 0x74};
unsigned char BROADCOM_OUI1[] = {0x00, 0x10, 0x18};
unsigned char BROADCOM_OUI2[] = {0x00, 0x0a, 0xf7};
unsigned char BROADCOM_OUI3[] = {0x00, 0x05, 0xb5};
unsigned char CISCO_OUI[] = {0x00, 0x40, 0x96};
unsigned char MARVELL_OUI[] = {0x00, 0x50, 0x43};
unsigned char RALINK_OUI[] = {0x00, 0x0c, 0x43};
unsigned char REALTEK_OUI[] = {0x00, 0xe0, 0x4c};
unsigned char AIRGOCAP_OUI[] = {0x00, 0x0a, 0xf5};
unsigned char REALTEK_96B_IE[] = {0x00, 0xe0, 0x4c, 0x02, 0x01, 0x20};
extern unsigned char RTW_WPA_OUI[];
extern unsigned char WPA_TKIP_CIPHER[4];
extern unsigned char RSN_TKIP_CIPHER[4];
#define R2T_PHY_DELAY (0)
/* #define WAIT_FOR_BCN_TO_MIN (3000) */
#define WAIT_FOR_BCN_TO_MIN (6000)
#define WAIT_FOR_BCN_TO_MAX (20000)
static u8 rtw_basic_rate_cck[4] = {
IEEE80211_CCK_RATE_1MB | IEEE80211_BASIC_RATE_MASK, IEEE80211_CCK_RATE_2MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_CCK_RATE_5MB | IEEE80211_BASIC_RATE_MASK, IEEE80211_CCK_RATE_11MB | IEEE80211_BASIC_RATE_MASK
};
static u8 rtw_basic_rate_ofdm[3] = {
IEEE80211_OFDM_RATE_6MB | IEEE80211_BASIC_RATE_MASK, IEEE80211_OFDM_RATE_12MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_OFDM_RATE_24MB | IEEE80211_BASIC_RATE_MASK
};
static u8 rtw_basic_rate_mix[7] = {
IEEE80211_CCK_RATE_1MB | IEEE80211_BASIC_RATE_MASK, IEEE80211_CCK_RATE_2MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_CCK_RATE_5MB | IEEE80211_BASIC_RATE_MASK, IEEE80211_CCK_RATE_11MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_OFDM_RATE_6MB | IEEE80211_BASIC_RATE_MASK, IEEE80211_OFDM_RATE_12MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_OFDM_RATE_24MB | IEEE80211_BASIC_RATE_MASK
};
extern u8 WIFI_CCKRATES[];
bool rtw_is_cck_rate(u8 rate)
{
int i;
for (i = 0; i < 4; i++)
if ((WIFI_CCKRATES[i] & 0x7F) == (rate & 0x7F))
return 1;
return 0;
}
extern u8 WIFI_OFDMRATES[];
bool rtw_is_ofdm_rate(u8 rate)
{
int i;
for (i = 0; i < 8; i++)
if ((WIFI_OFDMRATES[i] & 0x7F) == (rate & 0x7F))
return 1;
return 0;
}
/* test if rate is defined in rtw_basic_rate_cck */
bool rtw_is_basic_rate_cck(u8 rate)
{
int i;
for (i = 0; i < 4; i++)
if ((rtw_basic_rate_cck[i] & 0x7F) == (rate & 0x7F))
return 1;
return 0;
}
/* test if rate is defined in rtw_basic_rate_ofdm */
bool rtw_is_basic_rate_ofdm(u8 rate)
{
int i;
for (i = 0; i < 3; i++)
if ((rtw_basic_rate_ofdm[i] & 0x7F) == (rate & 0x7F))
return 1;
return 0;
}
/* test if rate is defined in rtw_basic_rate_mix */
bool rtw_is_basic_rate_mix(u8 rate)
{
int i;
for (i = 0; i < 7; i++)
if ((rtw_basic_rate_mix[i] & 0x7F) == (rate & 0x7F))
return 1;
return 0;
}
int cckrates_included(unsigned char *rate, int ratelen)
{
int i;
for (i = 0; i < ratelen; i++) {
if ((((rate[i]) & 0x7f) == 2) || (((rate[i]) & 0x7f) == 4) ||
(((rate[i]) & 0x7f) == 11) || (((rate[i]) & 0x7f) == 22))
return _TRUE;
}
return _FALSE;
}
int cckratesonly_included(unsigned char *rate, int ratelen)
{
int i;
for (i = 0; i < ratelen; i++) {
if ((((rate[i]) & 0x7f) != 2) && (((rate[i]) & 0x7f) != 4) &&
(((rate[i]) & 0x7f) != 11) && (((rate[i]) & 0x7f) != 22))
return _FALSE;
}
return _TRUE;
}
s8 rtw_get_sta_rx_nss(_adapter *adapter, struct sta_info *psta)
{
s8 nss = 1;
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
if (!psta)
return nss;
nss = GET_HAL_RX_NSS(dvobj);
#ifdef CONFIG_80211N_HT
#ifdef CONFIG_80211AC_VHT
#ifdef CONFIG_80211AX_HE
if (psta->hepriv.he_option)
nss = psta->phl_sta->asoc_cap.nss_tx;
else
#endif /* CONFIG_80211AX_HE */
if (psta->vhtpriv.vht_option)
nss = rtw_min(nss, rtw_vht_mcsmap_to_nss(psta->vhtpriv.vht_mcs_map));
else
#endif /* CONFIG_80211AC_VHT */
if (psta->htpriv.ht_option)
nss = rtw_min(nss, rtw_ht_mcsset_to_nss(psta->htpriv.ht_cap.supp_mcs_set));
#endif /*CONFIG_80211N_HT*/
RTW_INFO("%s: %d ss\n", __func__, nss);
return nss;
}
s8 rtw_get_sta_tx_nss(_adapter *adapter, struct sta_info *psta)
{
s8 nss = 1;
if (!psta)
return nss;
nss = GET_HAL_TX_NSS(adapter_to_dvobj(adapter));
#ifdef CONFIG_80211N_HT
#ifdef CONFIG_80211AC_VHT
#ifdef CONFIG_80211AX_HE
if (psta->hepriv.he_option)
nss = psta->phl_sta->asoc_cap.nss_rx;
else
#endif /* CONFIG_80211AX_HE */
if (psta->vhtpriv.vht_option)
nss = rtw_min(nss, rtw_vht_mcsmap_to_nss(psta->vhtpriv.vht_mcs_map));
else
#endif /* CONFIG_80211AC_VHT */
if (psta->htpriv.ht_option)
nss = rtw_min(nss, rtw_ht_mcsset_to_nss(psta->htpriv.ht_cap.supp_mcs_set));
#endif /*CONFIG_80211N_HT*/
RTW_INFO("%s: %d SS\n", __func__, nss);
return nss;
}
unsigned char ratetbl_val_2wifirate(unsigned char rate)
{
unsigned char val = 0;
switch (rate & 0x7f) {
case 0:
val = IEEE80211_CCK_RATE_1MB;
break;
case 1:
val = IEEE80211_CCK_RATE_2MB;
break;
case 2:
val = IEEE80211_CCK_RATE_5MB;
break;
case 3:
val = IEEE80211_CCK_RATE_11MB;
break;
case 4:
val = IEEE80211_OFDM_RATE_6MB;
break;
case 5:
val = IEEE80211_OFDM_RATE_9MB;
break;
case 6:
val = IEEE80211_OFDM_RATE_12MB;
break;
case 7:
val = IEEE80211_OFDM_RATE_18MB;
break;
case 8:
val = IEEE80211_OFDM_RATE_24MB;
break;
case 9:
val = IEEE80211_OFDM_RATE_36MB;
break;
case 10:
val = IEEE80211_OFDM_RATE_48MB;
break;
case 11:
val = IEEE80211_OFDM_RATE_54MB;
break;
}
return val;
}
int is_basicrate(_adapter *padapter, unsigned char rate)
{
int i;
unsigned char val;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
for (i = 0; i < NumRates; i++) {
val = pmlmeext->basicrate[i];
if ((val != 0xff) && (val != 0xfe)) {
if (rate == ratetbl_val_2wifirate(val))
return _TRUE;
}
}
return _FALSE;
}
unsigned int ratetbl2rateset(_adapter *padapter, unsigned char *rateset)
{
int i;
unsigned char rate;
unsigned int len = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
for (i = 0; i < NumRates; i++) {
rate = pmlmeext->datarate[i];
if (rtw_get_oper_ch(padapter) > 14 && rate < _6M_RATE_) /*5G no support CCK rate*/
continue;
switch (rate) {
case 0xff:
return len;
case 0xfe:
continue;
default:
rate = ratetbl_val_2wifirate(rate);
if (is_basicrate(padapter, rate) == _TRUE)
rate |= IEEE80211_BASIC_RATE_MASK;
rateset[len] = rate;
len++;
break;
}
}
return len;
}
void get_rate_set(_adapter *padapter, unsigned char *pbssrate, int *bssrate_len)
{
unsigned char supportedrates[NumRates];
_rtw_memset(supportedrates, 0, NumRates);
*bssrate_len = ratetbl2rateset(padapter, supportedrates);
_rtw_memcpy(pbssrate, supportedrates, *bssrate_len);
}
void set_mcs_rate_by_mask(u8 *mcs_set, u32 mask)
{
u8 mcs_rate_1r = (u8)(mask & 0xff);
u8 mcs_rate_2r = (u8)((mask >> 8) & 0xff);
u8 mcs_rate_3r = (u8)((mask >> 16) & 0xff);
u8 mcs_rate_4r = (u8)((mask >> 24) & 0xff);
mcs_set[0] &= mcs_rate_1r;
mcs_set[1] &= mcs_rate_2r;
mcs_set[2] &= mcs_rate_3r;
mcs_set[3] &= mcs_rate_4r;
}
void UpdateBrateTbl(
_adapter *adapter,
u8 *mBratesOS
)
{
u8 i;
u8 rate;
/* 1M, 2M, 5.5M, 11M, 6M, 12M, 24M are mandatory. */
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
rate = mBratesOS[i] & 0x7f;
switch (rate) {
case IEEE80211_CCK_RATE_1MB:
case IEEE80211_CCK_RATE_2MB:
case IEEE80211_CCK_RATE_5MB:
case IEEE80211_CCK_RATE_11MB:
case IEEE80211_OFDM_RATE_6MB:
case IEEE80211_OFDM_RATE_12MB:
case IEEE80211_OFDM_RATE_24MB:
mBratesOS[i] |= IEEE80211_BASIC_RATE_MASK;
break;
}
}
}
void UpdateBrateTblForSoftAP(u8 *bssrateset, u32 bssratelen)
{
u8 i;
u8 rate;
for (i = 0; i < bssratelen; i++) {
rate = bssrateset[i] & 0x7f;
switch (rate) {
case IEEE80211_CCK_RATE_1MB:
case IEEE80211_CCK_RATE_2MB:
case IEEE80211_CCK_RATE_5MB:
case IEEE80211_CCK_RATE_11MB:
bssrateset[i] |= IEEE80211_BASIC_RATE_MASK;
break;
}
}
}
/*rtw_phl_mr_get_chandef(dvobj->phl, adapter->phl_role, &chandef); => mr union chan*/
/*rtw_phl_get_cur_hal_chdef(adapter->phl_role, &chandef) => hal chan*/
void rtw_get_oper_chdef(_adapter *adapter, struct rtw_chan_def *chandef)
{
if (!adapter->phl_role)
return;
if (rtw_phl_get_cur_hal_chdef(adapter->phl_role, chandef) != RTW_PHL_STATUS_SUCCESS)
RTW_ERR("%s failed\n", __func__);
}
u8 rtw_get_oper_band(_adapter *adapter)
{
struct rtw_chan_def cur_chandef = {0};
rtw_get_oper_chdef(adapter, &cur_chandef);
return cur_chandef.band;
}
u8 rtw_get_oper_ch(_adapter *adapter)
{
struct rtw_chan_def cur_chandef = {0};
rtw_get_oper_chdef(adapter, &cur_chandef);
return cur_chandef.chan;
}
u8 rtw_get_oper_bw(_adapter *adapter)
{
struct rtw_chan_def cur_chandef = {0};
rtw_get_oper_chdef(adapter, &cur_chandef);
return cur_chandef.bw;
}
u8 rtw_get_oper_choffset(_adapter *adapter)
{
struct rtw_chan_def cur_chandef = {0};
rtw_get_oper_chdef(adapter, &cur_chandef);
return cur_chandef.offset;
}
inline systime rtw_get_on_oper_ch_time(_adapter *adapter)
{
return adapter_to_dvobj(adapter)->on_oper_ch_time;
}
inline systime rtw_get_on_cur_ch_time(_adapter *adapter)
{
if (adapter->mlmeextpriv.chandef.chan == rtw_get_oper_ch(adapter))
return adapter_to_dvobj(adapter)->on_oper_ch_time;
else
return 0;
}
void set_channel_bwmode(_adapter *padapter,
unsigned char channel,
unsigned char channel_offset,
unsigned short bwmode,
u8 do_rfk)
{
rtw_hw_set_ch_bw(padapter, channel, (enum channel_width)bwmode,
channel_offset, do_rfk);
}
__inline u8 *get_my_bssid(WLAN_BSSID_EX *pnetwork)
{
return pnetwork->MacAddress;
}
u16 get_beacon_interval(WLAN_BSSID_EX *bss)
{
unsigned short val;
_rtw_memcpy((unsigned char *)&val, rtw_get_beacon_interval_from_ie(bss->IEs), 2);
return le16_to_cpu(val);
}
int is_client_associated_to_ap(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
if (!padapter)
return _FAIL;
pmlmeext = &padapter->mlmeextpriv;
pmlmeinfo = &(pmlmeext->mlmext_info);
if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_STATION_STATE))
return _TRUE;
else
return _FAIL;
}
int is_client_associated_to_ibss(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state & 0x03) == WIFI_FW_ADHOC_STATE))
return _TRUE;
else
return _FAIL;
}
/*GEORGIA_TODO_FIXIT*/
#define GET_H2CCMD_MSRRPT_PARM_OPMODE(__pH2CCmd) LE_BITS_TO_1BYTE(((u8 *)(__pH2CCmd)), 0, 1)
#define GET_H2CCMD_MSRRPT_PARM_ROLE(__pH2CCmd) LE_BITS_TO_1BYTE(((u8 *)(__pH2CCmd)), 4, 4)
int is_IBSS_empty(_adapter *padapter)
{
/* ToDo */
#if 0
int i;
struct macid_ctl_t *macid_ctl = &padapter->dvobj->macid_ctl;
for (i = 0; i < macid_ctl->num; i++) {
if (!rtw_macid_is_used(macid_ctl, i))
continue;
if (!rtw_macid_is_iface_specific(macid_ctl, i, padapter))
continue;
if (!GET_H2CCMD_MSRRPT_PARM_OPMODE(&macid_ctl->h2c_msr[i]))
continue;
if (GET_H2CCMD_MSRRPT_PARM_ROLE(&macid_ctl->h2c_msr[i]) == H2C_MSR_ROLE_ADHOC)
return _FAIL;
}
#endif
return _TRUE;
}
unsigned int decide_wait_for_beacon_timeout(unsigned int bcn_interval)
{
if ((bcn_interval << 2) < WAIT_FOR_BCN_TO_MIN)
return WAIT_FOR_BCN_TO_MIN;
else if ((bcn_interval << 2) > WAIT_FOR_BCN_TO_MAX)
return WAIT_FOR_BCN_TO_MAX;
else
return bcn_interval << 2;
}
#if defined(CONFIG_P2P) && defined(CONFIG_WFD)
void rtw_process_wfd_ie(_adapter *adapter, u8 *wfd_ie, u8 wfd_ielen, const char *tag)
{
struct wifidirect_info *wdinfo = &adapter->wdinfo;
u8 *attr_content;
u32 attr_contentlen = 0;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
return;
RTW_INFO("[%s] Found WFD IE\n", tag);
attr_content = rtw_get_wfd_attr_content(wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, NULL, &attr_contentlen);
if (attr_content && attr_contentlen) {
wdinfo->wfd_info->peer_rtsp_ctrlport = RTW_GET_BE16(attr_content + 2);
RTW_INFO("[%s] Peer PORT NUM = %d\n", tag, wdinfo->wfd_info->peer_rtsp_ctrlport);
}
}
void rtw_process_wfd_ies(_adapter *adapter, u8 *ies, u8 ies_len, const char *tag)
{
u8 *wfd_ie;
u32 wfd_ielen;
if (!rtw_hw_chk_wl_func(adapter_to_dvobj(adapter), WL_FUNC_MIRACAST))
return;
wfd_ie = rtw_get_wfd_ie(ies, ies_len, NULL, &wfd_ielen);
while (wfd_ie) {
rtw_process_wfd_ie(adapter, wfd_ie, wfd_ielen, tag);
wfd_ie = rtw_get_wfd_ie(wfd_ie + wfd_ielen, (ies + ies_len) - (wfd_ie + wfd_ielen), NULL, &wfd_ielen);
}
}
#endif /* defined(CONFIG_P2P) && defined(CONFIG_WFD) */
int WMM_param_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
/* struct registry_priv *pregpriv = &padapter->registrypriv; */
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pmlmepriv->qospriv.qos_option == 0) {
pmlmeinfo->WMM_enable = 0;
return _FALSE;
}
if (_rtw_memcmp(&(pmlmeinfo->WMM_param), (pIE->data + 6), sizeof(struct WMM_para_element)))
return _FALSE;
else
_rtw_memcpy(&(pmlmeinfo->WMM_param), (pIE->data + 6), sizeof(struct WMM_para_element));
pmlmeinfo->WMM_enable = 1;
return _TRUE;
#if 0
if (pregpriv->wifi_spec == 1) {
if (pmlmeinfo->WMM_enable == 1) {
/* todo: compare the parameter set count & decide wheher to update or not */
return _FAIL;
} else {
pmlmeinfo->WMM_enable = 1;
_rtw_rtw_memcpy(&(pmlmeinfo->WMM_param), (pIE->data + 6), sizeof(struct WMM_para_element));
return _TRUE;
}
} else {
pmlmeinfo->WMM_enable = 0;
return _FAIL;
}
#endif
}
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
u8 rtw_is_tbtx_capabilty(u8 *p, u8 len){
int i;
u8 tbtx_cap_ie[8] = {0x00, 0xe0, 0x4c, 0x01, 0x00, 0x00, 0x00, 0x00};
for (i = 0; i < len; i++) {
if (*(p + i) != tbtx_cap_ie[i])
return _FALSE;
else
continue;
}
return _TRUE;
}
#endif
void WMMOnAssocRsp(_adapter *padapter)
{
u8 ACI, ACM, AIFS, ECWMin, ECWMax, aSifsTime;
u8 acm_mask;
u16 TXOP;
u32 acParm, i;
u32 edca[4], inx[4];
u8 ac_be = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
#ifdef CONFIG_WMMPS_STA
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
#endif /* CONFIG_WMMPS_STA */
acm_mask = 0;
if (WIFI_ROLE_IS_ON_5G(padapter) ||
(pmlmeext->cur_wireless_mode & WLAN_MD_11N))
aSifsTime = 16;
else
aSifsTime = 10;
if (pmlmeinfo->WMM_enable == 0) {
padapter->mlmepriv.acm_mask = 0;
AIFS = aSifsTime + (2 * pmlmeinfo->slotTime);
if (pmlmeext->cur_wireless_mode & (WLAN_MD_11G | WLAN_MD_11A)) {
ECWMin = 4;
ECWMax = 10;
} else if (pmlmeext->cur_wireless_mode & WLAN_MD_11B) {
ECWMin = 5;
ECWMax = 10;
} else {
ECWMin = 4;
ECWMax = 10;
}
TXOP = 0;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_hw_set_edca(padapter, 0, acParm);
rtw_hw_set_edca(padapter, 1, acParm);
rtw_hw_set_edca(padapter, 2, acParm);
ECWMin = 2;
ECWMax = 3;
TXOP = 0x2f;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_hw_set_edca(padapter, 3, acParm);
} else {
edca[0] = edca[1] = edca[2] = edca[3] = 0;
for (i = 0; i < 4; i++) {
ACI = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN >> 5) & 0x03;
ACM = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN >> 4) & 0x01;
/* AIFS = AIFSN * slot time + SIFS - r2t phy delay */
AIFS = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN & 0x0f) * pmlmeinfo->slotTime + aSifsTime;
ECWMin = (pmlmeinfo->WMM_param.ac_param[i].CW & 0x0f);
ECWMax = (pmlmeinfo->WMM_param.ac_param[i].CW & 0xf0) >> 4;
TXOP = le16_to_cpu(pmlmeinfo->WMM_param.ac_param[i].TXOP_limit);
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_hw_set_edca(padapter, ACI, acParm);
switch (ACI) {
case 0x0:
acm_mask |= (ACM ? BIT(1) : 0);
edca[XMIT_BE_QUEUE] = acParm;
break;
case 0x1:
/* acm_mask |= (ACM? BIT(0):0); */
edca[XMIT_BK_QUEUE] = acParm;
break;
case 0x2:
acm_mask |= (ACM ? BIT(2) : 0);
edca[XMIT_VI_QUEUE] = acParm;
break;
case 0x3:
acm_mask |= (ACM ? BIT(3) : 0);
edca[XMIT_VO_QUEUE] = acParm;
break;
}
RTW_INFO("WMM(%x): %x, %x\n", ACI, ACM, acParm);
if (i == ac_be) {
padapter->last_edca = acParm;
acParm = rtw_get_turbo_edca(padapter, AIFS, ECWMin, ECWMax, TXOP);
if (acParm) {
rtw_hw_set_edca(padapter, ACI, acParm);
padapter->last_edca = acParm;
}
}
}
if (padapter->registrypriv.acm_method == 1)
rtw_hal_set_hwreg(padapter, HW_VAR_ACM_CTRL, (u8 *)(&acm_mask));
else
padapter->mlmepriv.acm_mask = acm_mask;
inx[0] = 0;
inx[1] = 1;
inx[2] = 2;
inx[3] = 3;
if (pregpriv->wifi_spec == 1) {
u32 j, tmp, change_inx = _FALSE;
/* entry indx: 0->vo, 1->vi, 2->be, 3->bk. */
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 4; j++) {
/* compare CW and AIFS */
if ((edca[j] & 0xFFFF) < (edca[i] & 0xFFFF))
change_inx = _TRUE;
else if ((edca[j] & 0xFFFF) == (edca[i] & 0xFFFF)) {
/* compare TXOP */
if ((edca[j] >> 16) > (edca[i] >> 16))
change_inx = _TRUE;
}
if (change_inx) {
tmp = edca[i];
edca[i] = edca[j];
edca[j] = tmp;
tmp = inx[i];
inx[i] = inx[j];
inx[j] = tmp;
change_inx = _FALSE;
}
}
}
}
for (i = 0; i < 4; i++) {
pxmitpriv->wmm_para_seq[i] = inx[i];
RTW_INFO("wmm_para_seq(%d): %d\n", i, pxmitpriv->wmm_para_seq[i]);
}
#ifdef CONFIG_WMMPS_STA
/* if AP supports UAPSD function, driver must set each uapsd TID to coresponding mac register 0x693 */
if (pmlmeinfo->WMM_param.QoS_info & AP_SUPPORTED_UAPSD) {
pqospriv->uapsd_ap_supported = 1;
rtw_hal_set_hwreg(padapter, HW_VAR_UAPSD_TID, NULL);
}
#endif /* CONFIG_WMMPS_STA */
}
}
static void bwmode_update_check(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
#ifdef CONFIG_80211N_HT
unsigned char new_bwmode;
unsigned char new_ch_offset;
struct HT_info_element *pHT_info;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
u8 cbw40_enable = 0;
if (!pIE)
return;
if (phtpriv->ht_option == _FALSE)
return;
if (pmlmeext->chandef.bw >= CHANNEL_WIDTH_80)
return;
if (pIE->Length > sizeof(struct HT_info_element))
return;
pHT_info = (struct HT_info_element *)pIE->data;
if (rtw_hw_chk_bw_cap(adapter_to_dvobj(padapter), BW_CAP_40M)) {
if (pmlmeext->chandef.chan > 14) {
if (REGSTY_IS_BW_5G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
cbw40_enable = 1;
} else {
if (REGSTY_IS_BW_2G_SUPPORT(pregistrypriv, CHANNEL_WIDTH_40))
cbw40_enable = 1;
}
}
if ((pHT_info->infos[0] & BIT(2)) && cbw40_enable) {
new_bwmode = CHANNEL_WIDTH_40;
switch (pHT_info->infos[0] & 0x3) {
case 1:
new_ch_offset = CHAN_OFFSET_UPPER;
break;
case 3:
new_ch_offset = CHAN_OFFSET_LOWER;
break;
default:
new_bwmode = CHANNEL_WIDTH_20;
new_ch_offset = CHAN_OFFSET_NO_EXT;
break;
}
} else {
new_bwmode = CHANNEL_WIDTH_20;
new_ch_offset = CHAN_OFFSET_NO_EXT;
}
if ((new_bwmode != pmlmeext->chandef.bw || new_ch_offset != pmlmeext->chandef.offset)
&& new_bwmode < pmlmeext->chandef.bw
) {
pmlmeinfo->bwmode_updated = _TRUE;
pmlmeext->chandef.bw = new_bwmode;
pmlmeext->chandef.offset = new_ch_offset;
/* update HT info also */
HT_info_handler(padapter, pIE);
} else
pmlmeinfo->bwmode_updated = _FALSE;
if (_TRUE == pmlmeinfo->bwmode_updated) {
struct sta_info *psta;
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
struct sta_priv *pstapriv = &padapter->stapriv;
/* set_channel_bwmode(padapter, pmlmeext->chandef.chan, pmlmeext->chandef.offset, pmlmeext->chandef.bw); */
/* update ap's stainfo */
psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
if (psta) {
struct ht_priv *phtpriv_sta = &psta->htpriv;
if (phtpriv_sta->ht_option) {
/* bwmode */
psta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
phtpriv_sta->ch_offset = pmlmeext->chandef.offset;
} else {
psta->phl_sta->chandef.bw = CHANNEL_WIDTH_20;
phtpriv_sta->ch_offset = CHAN_OFFSET_NO_EXT;
}
rtw_phl_cmd_change_stainfo(adapter_to_dvobj(padapter)->phl,
psta->phl_sta,
STA_CHG_RAMASK,
NULL,
0,
PHL_CMD_NO_WAIT,
0);
}
/* pmlmeinfo->bwmode_updated = _FALSE; */ /* bwmode_updated done, reset it! */
}
#endif /* CONFIG_80211N_HT */
}
#ifdef ROKU_PRIVATE
void Supported_rate_infra_ap(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
unsigned int i;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pIE == NULL)
return;
for (i = 0 ; i < pIE->Length; i++)
pmlmeinfo->SupportedRates_infra_ap[i] = (pIE->data[i]);
}
void Extended_Supported_rate_infra_ap(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
unsigned int i, j;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pIE == NULL)
return;
if (pIE->Length > 0) {
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
if (pmlmeinfo->SupportedRates_infra_ap[i] == 0)
break;
}
for (j = 0; j < pIE->Length; j++)
pmlmeinfo->SupportedRates_infra_ap[i+j] = (pIE->data[j]);
}
}
void HT_get_ss_from_mcs_set(u8 *mcs_set, u8 *Rx_ss)
{
u8 i, j;
u8 r_ss = 0, t_ss = 0;
for (i = 0; i < 4; i++) {
if ((mcs_set[3-i] & 0xff) != 0x00) {
r_ss = 4-i;
break;
}
}
*Rx_ss = r_ss;
}
void HT_caps_handler_infra_ap(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
unsigned int i;
u8 cur_stbc_cap_infra_ap = 0;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv_infra_ap *phtpriv = &pmlmepriv->htpriv_infra_ap;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pIE == NULL)
return;
pmlmeinfo->ht_vht_received |= BIT(0);
/*copy MCS_SET*/
for (i = 3; i < 19; i++)
phtpriv->MCS_set_infra_ap[i-3] = (pIE->data[i]);
/*get number of stream from mcs set*/
HT_get_ss_from_mcs_set(phtpriv->MCS_set_infra_ap, &phtpriv->Rx_ss_infra_ap);
phtpriv->rx_highest_data_rate_infra_ap = le16_to_cpu(GET_HT_CAP_ELE_RX_HIGHEST_DATA_RATE(pIE->data));
phtpriv->ldpc_cap_infra_ap = GET_HT_CAP_ELE_LDPC_CAP(pIE->data);
if (GET_HT_CAP_ELE_RX_STBC(pIE->data))
SET_FLAG(cur_stbc_cap_infra_ap, STBC_HT_ENABLE_RX);
if (GET_HT_CAP_ELE_TX_STBC(pIE->data))
SET_FLAG(cur_stbc_cap_infra_ap, STBC_HT_ENABLE_TX);
phtpriv->stbc_cap_infra_ap = cur_stbc_cap_infra_ap;
/*store ap info SGI 20m 40m*/
phtpriv->sgi_20m_infra_ap = GET_HT_CAP_ELE_SHORT_GI20M(pIE->data);
phtpriv->sgi_40m_infra_ap = GET_HT_CAP_ELE_SHORT_GI40M(pIE->data);
/*store ap info for supported channel bandwidth*/
phtpriv->channel_width_infra_ap = GET_HT_CAP_ELE_CHL_WIDTH(pIE->data);
}
#endif /* ROKU_PRIVATE */
void HT_caps_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
#ifdef CONFIG_80211N_HT
unsigned int i;
u8 max_AMPDU_len, min_MPDU_spacing;
u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, cur_beamform_cap = 0, rx_nss = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
struct sta_info *sta = NULL;
struct rtw_phl_stainfo_t *phl_sta = NULL;
struct rtw_wifi_role_t *wrole = padapter->phl_role;
struct protocol_cap_t *proto_role_cap = &(wrole->proto_role_cap);
#ifdef CONFIG_DISABLE_MCS13TO15
struct registry_priv *pregistrypriv = &padapter->registrypriv;
#endif
if (pIE == NULL)
return;
if (phtpriv->ht_option == _FALSE)
return;
pmlmeinfo->HT_caps_enable = 1;
for (i = 0; i < (pIE->Length); i++) {
if (i != 2) {
/* Commented by Albert 2010/07/12 */
/* Got the endian issue here. */
pmlmeinfo->HT_caps.u.HT_cap[i] &= (pIE->data[i]);
} else {
/* AMPDU Parameters field */
/* Get MIN of MAX AMPDU Length Exp */
if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3) > (pIE->data[i] & 0x3))
max_AMPDU_len = (pIE->data[i] & 0x3);
else
max_AMPDU_len = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3);
/* Get MAX of MIN MPDU Start Spacing */
if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) > (pIE->data[i] & 0x1c))
min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c);
else
min_MPDU_spacing = (pIE->data[i] & 0x1c);
pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para = max_AMPDU_len | min_MPDU_spacing;
}
}
/* Commented by Albert 2010/07/12 */
/* Have to handle the endian issue after copying. */
/* HT_ext_caps didn't be used yet. */
pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info = le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info);
pmlmeinfo->HT_caps.u.HT_cap_element.HT_ext_caps = le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_ext_caps);
/* update the MCS set */
for (i = 0; i < 16; i++)
pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i];
rx_nss = GET_HAL_RX_NSS(adapter_to_dvobj(padapter));
switch (rx_nss) {
case 1:
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R);
break;
case 2:
#ifdef CONFIG_DISABLE_MCS13TO15
if (pmlmeext->chandef.bw == CHANNEL_WIDTH_40 && pregistrypriv->wifi_spec != 1)
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_2R_13TO15_OFF);
else
#endif
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_2R);
break;
case 3:
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_3R);
break;
case 4:
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_4R);
break;
default:
RTW_WARN("rf_type:%d or tx_nss:%u is not expected\n", GET_HAL_RFPATH(adapter_to_dvobj(padapter)), rx_nss);
}
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
/* Config STBC setting */
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) && GET_HT_CAP_ELE_RX_STBC(pIE->data)) {
SET_FLAG(cur_stbc_cap, STBC_HT_ENABLE_TX);
RTW_INFO("Enable HT Tx STBC !\n");
}
phtpriv->stbc_cap = cur_stbc_cap;
#ifdef CONFIG_BEAMFORMING
/* Config Tx beamforming setting */
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP(pIE->data)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
/* Shift to BEAMFORMING_HT_BEAMFORMEE_CHNL_EST_CAP*/
SET_FLAG(cur_beamform_cap, GET_HT_CAP_TXBF_CHNL_ESTIMATION_NUM_ANTENNAS(pIE->data) << 6);
}
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP(pIE->data)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
/* Shift to BEAMFORMING_HT_BEAMFORMER_STEER_NUM*/
SET_FLAG(cur_beamform_cap, GET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(pIE->data) << 4);
}
phtpriv->beamform_cap = cur_beamform_cap;
if (cur_beamform_cap)
RTW_INFO("AP HT Beamforming Cap = 0x%02X\n", cur_beamform_cap);
#endif /*CONFIG_BEAMFORMING*/
} else {
/*WIFI_STATION_STATEorI_ADHOC_STATE or WIFI_ADHOC_MASTER_STATE*/
sta = rtw_get_stainfo(&padapter->stapriv, pmlmeinfo->network.MacAddress);
if (!sta) {
RTW_ERR(FUNC_ADPT_FMT ": STA(" MAC_FMT ") not found!\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(pmlmeinfo->network.MacAddress));
return;
}
if (!sta->phl_sta) {
RTW_ERR(FUNC_ADPT_FMT ": PHL STA(" MAC_FMT ") not exist!\n",
FUNC_ADPT_ARG(padapter), MAC_ARG(pmlmeinfo->network.MacAddress));
return;
}
phl_sta = sta->phl_sta;
/* Config LDPC Coding Capability */
if (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX) && GET_HT_CAP_ELE_LDPC_CAP(pIE->data)) {
SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX));
RTW_INFO("Enable HT Tx LDPC!\n");
phl_sta->asoc_cap.ht_ldpc = 1;
}
phtpriv->ldpc_cap = cur_ldpc_cap;
/* Config STBC setting */
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) && GET_HT_CAP_ELE_RX_STBC(pIE->data)) {
SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX));
RTW_INFO("Enable HT Tx STBC!\n");
phl_sta->asoc_cap.stbc_ht_rx =
proto_role_cap->stbc_ht_tx ? GET_HT_CAP_ELE_RX_STBC(pIE->data) : 0;
}
phtpriv->stbc_cap = cur_stbc_cap;
phl_sta->asoc_cap.stbc_ht_tx = GET_HT_CAP_ELE_TX_STBC(pIE->data);
#ifdef CONFIG_BEAMFORMING
/* Config beamforming setting */
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP(pIE->data)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
/* Shift to BEAMFORMING_HT_BEAMFORMEE_CHNL_EST_CAP*/
SET_FLAG(cur_beamform_cap, GET_HT_CAP_TXBF_CHNL_ESTIMATION_NUM_ANTENNAS(pIE->data) << 6);
}
if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE) &&
GET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP(pIE->data)) {
SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
/* Shift to BEAMFORMING_HT_BEAMFORMER_STEER_NUM*/
SET_FLAG(cur_beamform_cap, GET_HT_CAP_TXBF_COMP_STEERING_NUM_ANTENNAS(pIE->data) << 4);
}
phtpriv->beamform_cap = cur_beamform_cap;
if (cur_beamform_cap)
RTW_INFO("Client HT Beamforming Cap = 0x%02X\n", cur_beamform_cap);
#endif /*CONFIG_BEAMFORMING*/
}
#endif /* CONFIG_80211N_HT */
}
void HT_info_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
#ifdef CONFIG_80211N_HT
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
if (pIE == NULL)
return;
if (phtpriv->ht_option == _FALSE)
return;
if (pIE->Length > sizeof(struct HT_info_element))
return;
pmlmeinfo->HT_info_enable = 1;
_rtw_memcpy(&(pmlmeinfo->HT_info), pIE->data, pIE->Length);
#endif /* CONFIG_80211N_HT */
return;
}
void HTOnAssocRsp(_adapter *padapter)
{
unsigned char max_AMPDU_len;
unsigned char min_MPDU_spacing;
/* struct registry_priv *pregpriv = &padapter->registrypriv; */
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
RTW_INFO("%s\n", __FUNCTION__);
if ((pmlmeinfo->HT_info_enable) && (pmlmeinfo->HT_caps_enable))
pmlmeinfo->HT_enable = 1;
else {
pmlmeinfo->HT_enable = 0;
/* set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode); */
return;
}
/* handle A-MPDU parameter field */
/*
AMPDU_para [1:0]:Max AMPDU Len => 0:8k , 1:16k, 2:32k, 3:64k
AMPDU_para [4:2]:Min MPDU Start Spacing
*/
max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) >> 2;
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, (u8 *)(&min_MPDU_spacing));
#ifdef CONFIG_80211N_HT
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&max_AMPDU_len));
#endif /* CONFIG_80211N_HT */
#if 0 /* move to rtw_update_ht_cap() */
if ((pregpriv->bw_mode > 0) &&
(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & BIT(1)) &&
(pmlmeinfo->HT_info.infos[0] & BIT(2))) {
/* switch to the 40M Hz mode accoring to the AP */
pmlmeext->cur_bwmode = CHANNEL_WIDTH_40;
switch ((pmlmeinfo->HT_info.infos[0] & 0x3)) {
case IEEE80211_SCA:
pmlmeext->cur_ch_offset = CHAN_OFFSET_UPPER;
break;
case IEEE80211_SCB:
pmlmeext->cur_ch_offset = CHAN_OFFSET_LOWER;
break;
default:
pmlmeext->cur_ch_offset = CHAN_OFFSET_NO_EXT;
break;
}
}
#endif
/* set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode); */
#if 0 /* move to rtw_update_ht_cap() */
/* */
/* Config SM Power Save setting */
/* */
pmlmeinfo->SM_PS = (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info & 0x0C) >> 2;
if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC) {
#if 0
u8 i;
/* update the MCS rates */
for (i = 0; i < 16; i++)
pmlmeinfo->HT_caps.HT_cap_element.MCS_rate[i] &= MCS_rate_1R[i];
#endif
RTW_INFO("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __FUNCTION__);
}
/* */
/* Config current HT Protection mode. */
/* */
pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3;
#endif
}
void ERP_IE_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pIE->Length > 1)
return;
pmlmeinfo->ERP_enable = 1;
_rtw_memcpy(&(pmlmeinfo->ERP_IE), pIE->data, pIE->Length);
}
void VCS_update(_adapter *padapter, struct sta_info *psta)
{
struct registry_priv *pregpriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
switch (pregpriv->vrtl_carrier_sense) { /* 0:off 1:on 2:auto */
case 0: /* off */
psta->rtsen = 0;
psta->cts2self = 0;
break;
case 1: /* on */
if (pregpriv->vcs_type == 1) { /* 1:RTS/CTS 2:CTS to self */
psta->rtsen = 1;
psta->cts2self = 0;
} else {
psta->rtsen = 0;
psta->cts2self = 1;
}
break;
case 2: /* auto */
default:
if (((pmlmeinfo->ERP_enable) && (pmlmeinfo->ERP_IE & BIT(1)))
/*||(pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT)*/
) {
if (pregpriv->vcs_type == 1) {
psta->rtsen = 1;
psta->cts2self = 0;
} else {
psta->rtsen = 0;
psta->cts2self = 1;
}
} else {
psta->rtsen = 0;
psta->cts2self = 0;
}
break;
}
switch (pregpriv->hw_rts_en) { /* 0:disable 1:enable */
case 0:
psta->hw_rts_en = 0;
break;
case 1:
psta->hw_rts_en = 1;
break;
default:
RTW_WARN("%s: unexpected value(%d) for hw_rts_en.\n", __func__, pregpriv->hw_rts_en);
break;
}
}
void update_ldpc_stbc_cap(struct sta_info *psta)
{
#ifdef CONFIG_80211N_HT
#ifdef CONFIG_80211AC_VHT
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif /* CONFIG_80211AX_HE */
if (psta->vhtpriv.vht_option) {
if (TEST_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_ENABLE_TX))
psta->phl_sta->asoc_cap.vht_ldpc = 1;
else
psta->phl_sta->asoc_cap.vht_ldpc = 0;
} else
#endif /* CONFIG_80211AC_VHT */
if (psta->htpriv.ht_option) {
if (TEST_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_ENABLE_TX))
psta->phl_sta->asoc_cap.ht_ldpc = 1;
else
psta->phl_sta->asoc_cap.ht_ldpc = 0;
} else {
psta->phl_sta->asoc_cap.vht_ldpc = 0;
psta->phl_sta->asoc_cap.ht_ldpc = 0;
}
#endif /* CONFIG_80211N_HT */
}
int check_ielen(u8 *start, uint len)
{
int left = len;
u8 *pos = start;
u8 id, elen;
while (left >= 2) {
id = *pos++;
elen = *pos++;
left -= 2;
if (elen > left) {
RTW_ERR("IEEE 802.11 element parse failed (id=%d elen=%d left=%lu)\n",
id, elen, (unsigned long) left);
return _FALSE;
}
if ((id == WLAN_EID_VENDOR_SPECIFIC) && (elen < 3))
return _FALSE;
left -= elen;
pos += elen;
}
if (left)
return _FALSE;
return _TRUE;
}
int validate_beacon_len(u8 *pframe, u32 len)
{
u8 ie_offset = _BEACON_IE_OFFSET_ + sizeof(struct rtw_ieee80211_hdr_3addr);
if (len < ie_offset) {
RTW_ERR("%s: incorrect beacon length(%d)\n", __func__, len);
rtw_warn_on(1);
return _FALSE;
}
if (check_ielen(pframe + ie_offset, len - ie_offset) == _FALSE)
return _FALSE;
return _TRUE;
}
u8 support_rate_ranges[] = {
IEEE80211_CCK_RATE_1MB,
IEEE80211_CCK_RATE_2MB,
IEEE80211_CCK_RATE_5MB,
IEEE80211_CCK_RATE_11MB,
IEEE80211_OFDM_RATE_6MB,
IEEE80211_OFDM_RATE_9MB,
IEEE80211_OFDM_RATE_12MB,
IEEE80211_OFDM_RATE_18MB,
IEEE80211_PBCC_RATE_22MB,
IEEE80211_FREAK_RATE_22_5MB,
IEEE80211_OFDM_RATE_24MB,
IEEE80211_OFDM_RATE_36MB,
IEEE80211_OFDM_RATE_48MB,
IEEE80211_OFDM_RATE_54MB,
};
inline bool match_ranges(u16 EID, u32 value)
{
int i;
int nr_range;
switch (EID) {
case _EXT_SUPPORTEDRATES_IE_:
case _SUPPORTEDRATES_IE_:
nr_range = sizeof(support_rate_ranges)/sizeof(u8);
for (i = 0; i < nr_range; i++) {
/* clear bit7 before searching. */
value &= ~BIT(7);
if (value == support_rate_ranges[i])
return _TRUE;
}
break;
default:
break;
};
return _FALSE;
}
/*
* rtw_validate_value: validate the IE contain.
*
* Input :
* EID : Element ID
* p : IE buffer (without EID & length)
* len : IE length
* return:
* _TRUE : All Values are validated.
* _FALSE : At least one value is NOT validated.
*/
bool rtw_validate_value(u16 EID, u8 *p, u16 len)
{
u8 rate;
u32 i, nr_val;
switch (EID) {
case _EXT_SUPPORTEDRATES_IE_:
case _SUPPORTEDRATES_IE_:
nr_val = len;
for (i=0; i<nr_val; i++) {
rate = *(p+i);
if (match_ranges(EID, rate) == _FALSE)
return _FALSE;
}
break;
default:
break;
};
return _TRUE;
}
bool is_hidden_ssid(char *ssid, int len)
{
return len == 0 || is_all_null(ssid, len) == _TRUE;
}
inline bool hidden_ssid_ap(WLAN_BSSID_EX *snetwork)
{
return ((snetwork->Ssid.SsidLength == 0) ||
is_all_null(snetwork->Ssid.Ssid, snetwork->Ssid.SsidLength) == _TRUE);
}
/*
Get SSID if this ilegal frame(probe resp) comes from a hidden SSID AP.
Update the SSID to the corresponding pnetwork in scan queue.
*/
void rtw_absorb_ssid_ifneed(_adapter *padapter, WLAN_BSSID_EX *bssid, u8 *pframe)
{
struct wlan_network *scanned = NULL;
WLAN_BSSID_EX *snetwork;
u8 ie_offset, *p=NULL, *next_ie=NULL;
u8 *mac;
sint ssid_len_ori;
u32 remain_len = 0;
u8 backupIE[MAX_IE_SZ];
u16 subtype;
mac = get_addr2_ptr(pframe);
subtype = get_frame_sub_type(pframe);
if (subtype == WIFI_BEACON) {
bssid->Reserved[0] = BSS_TYPE_BCN;
ie_offset = _BEACON_IE_OFFSET_;
} else {
/* FIXME : more type */
if (subtype == WIFI_PROBERSP) {
ie_offset = _PROBERSP_IE_OFFSET_;
bssid->Reserved[0] = BSS_TYPE_PROB_RSP;
} else if (subtype == WIFI_PROBEREQ) {
ie_offset = _PROBEREQ_IE_OFFSET_;
bssid->Reserved[0] = BSS_TYPE_PROB_REQ;
} else {
bssid->Reserved[0] = BSS_TYPE_UNDEF;
ie_offset = _FIXED_IE_LENGTH_;
}
}
_rtw_spinlock_bh(&padapter->mlmepriv.scanned_queue.lock);
scanned = _rtw_find_network(&padapter->mlmepriv.scanned_queue, mac);
if (!scanned) {
_rtw_spinunlock_bh(&padapter->mlmepriv.scanned_queue.lock);
return;
}
snetwork = &(scanned->network);
/* scan queue records as Hidden SSID && Input frame is NOT Hidden SSID */
if (hidden_ssid_ap(snetwork) && !hidden_ssid_ap(bssid)) {
p = rtw_get_ie(snetwork->IEs+ie_offset, _SSID_IE_, &ssid_len_ori, snetwork->IELength-ie_offset);
if (!p) {
_rtw_spinunlock_bh(&padapter->mlmepriv.scanned_queue.lock);
return;
}
next_ie = p + 2 + ssid_len_ori;
remain_len = snetwork->IELength - (next_ie - snetwork->IEs);
scanned->network.Ssid.SsidLength = bssid->Ssid.SsidLength;
_rtw_memcpy(scanned->network.Ssid.Ssid, bssid->Ssid.Ssid, bssid->Ssid.SsidLength);
//update pnetwork->ssid, pnetwork->ssidlen
_rtw_memcpy(backupIE, next_ie, remain_len);
*(p+1) = bssid->Ssid.SsidLength;
_rtw_memcpy(p+2, bssid->Ssid.Ssid, bssid->Ssid.SsidLength);
_rtw_memcpy(p+2+bssid->Ssid.SsidLength, backupIE, remain_len);
snetwork->IELength += bssid->Ssid.SsidLength;
}
_rtw_spinunlock_bh(&padapter->mlmepriv.scanned_queue.lock);
}
#ifdef DBG_RX_BCN
void rtw_debug_rx_bcn(_adapter *adapter, u8 *pframe, u32 packet_len)
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *mlmeinfo = &(pmlmeext->mlmext_info);
u16 sn = ((struct rtw_ieee80211_hdr_3addr *)pframe)->seq_ctl >> 4;
u64 tsf, tsf_offset;
u8 dtim_cnt, dtim_period, tim_bmap, tim_pvbit;
update_TSF(pmlmeext, pframe, packet_len);
tsf = pmlmeext->TSFValue;
tsf_offset = rtw_modular64(pmlmeext->TSFValue, (mlmeinfo->bcn_interval * 1024));
/*get TIM IE*/
/*DTIM Count*/
dtim_cnt = pmlmeext->tim[0];
/*DTIM Period*/
dtim_period = pmlmeext->tim[1];
/*Bitmap*/
tim_bmap = pmlmeext->tim[2];
/*Partial VBitmap AID 0 ~ 7*/
tim_pvbit = pmlmeext->tim[3];
RTW_INFO("[BCN] SN-%d, TSF-%lld(us), offset-%lld, bcn_interval-%d DTIM-%d[%d] bitmap-0x%02x-0x%02x\n",
sn, tsf, tsf_offset, mlmeinfo->bcn_interval, dtim_period, dtim_cnt, tim_bmap, tim_pvbit);
}
#endif
/*
* rtw_get_bcn_keys: get beacon keys from recv frame
*
* TODO:
* WLAN_EID_COUNTRY
* WLAN_EID_ERP_INFO
* WLAN_EID_CHANNEL_SWITCH
* WLAN_EID_PWR_CONSTRAINT
*/
int rtw_get_bcn_keys(_adapter *adapter, u8 *pframe, u32 packet_len,
struct beacon_keys *recv_beacon)
{
int left;
u16 capability;
unsigned char *pos;
struct rtw_ieee802_11_elems elems;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
_rtw_memset(recv_beacon, 0, sizeof(*recv_beacon));
/* checking capabilities */
capability = le16_to_cpu(*(unsigned short *)(pframe + WLAN_HDR_A3_LEN + 10));
/* checking IEs */
left = packet_len - sizeof(struct rtw_ieee80211_hdr_3addr) - _BEACON_IE_OFFSET_;
pos = pframe + sizeof(struct rtw_ieee80211_hdr_3addr) + _BEACON_IE_OFFSET_;
if (rtw_ieee802_11_parse_elems(pos, left, &elems, 1) == ParseFailed)
return _FALSE;
if (elems.ht_capabilities) {
if (elems.ht_capabilities_len != 26)
return _FALSE;
}
if (elems.ht_operation) {
if (elems.ht_operation_len != 22)
return _FALSE;
}
if (elems.vht_capabilities) {
if (elems.vht_capabilities_len != 12)
return _FALSE;
}
if (elems.vht_operation) {
if (elems.vht_operation_len != 5)
return _FALSE;
}
if (rtw_ies_get_supported_rate(pos, left, recv_beacon->rate_set, &recv_beacon->rate_num) == _FAIL)
return _FALSE;
if (cckratesonly_included(recv_beacon->rate_set, recv_beacon->rate_num) == _TRUE)
recv_beacon->proto_cap |= PROTO_CAP_11B;
else if (cckrates_included(recv_beacon->rate_set, recv_beacon->rate_num) == _TRUE)
recv_beacon->proto_cap |= PROTO_CAP_11B | PROTO_CAP_11G;
else
recv_beacon->proto_cap |= PROTO_CAP_11G;
if (elems.ht_capabilities && elems.ht_operation)
recv_beacon->proto_cap |= PROTO_CAP_11N;
if (elems.vht_capabilities && elems.vht_operation)
recv_beacon->proto_cap |= PROTO_CAP_11AC;
if (elems.he_capabilities && elems.he_operation)
recv_beacon->proto_cap |= PROTO_CAP_11AX;
/* check bw and channel offset */
rtw_ies_get_chbw(pos, left, &recv_beacon->ch, &recv_beacon->bw, &recv_beacon->offset, 1, 1);
if (!recv_beacon->ch) {
/* we don't find channel IE, so don't check it */
/* RTW_INFO("Oops: %s we don't find channel IE, so don't check it\n", __func__); */
recv_beacon->ch = adapter->mlmeextpriv.chandef.chan;
}
/* checking SSID */
if (elems.ssid) {
if (elems.ssid_len > sizeof(recv_beacon->ssid))
return _FALSE;
_rtw_memcpy(recv_beacon->ssid, elems.ssid, elems.ssid_len);
recv_beacon->ssid_len = elems.ssid_len;
}
/* checking RSN first */
if (elems.rsn_ie && elems.rsn_ie_len) {
recv_beacon->encryp_protocol = ENCRYP_PROTOCOL_RSN;
rtw_parse_wpa2_ie(elems.rsn_ie - 2, elems.rsn_ie_len + 2,
&recv_beacon->group_cipher, &recv_beacon->pairwise_cipher,
NULL, &recv_beacon->akm, NULL, NULL);
}
/* checking WPA secon */
else if (elems.wpa_ie && elems.wpa_ie_len) {
recv_beacon->encryp_protocol = ENCRYP_PROTOCOL_WPA;
rtw_parse_wpa_ie(elems.wpa_ie - 2, elems.wpa_ie_len + 2,
&recv_beacon->group_cipher, &recv_beacon->pairwise_cipher,
&recv_beacon->akm);
} else if (capability & BIT(4))
recv_beacon->encryp_protocol = ENCRYP_PROTOCOL_WEP;
if (elems.tim && elems.tim_len) {
#ifdef DBG_RX_BCN
_rtw_memcpy(pmlmeext->tim, elems.tim, 4);
#endif
pmlmeext->dtim = elems.tim[1];
}
/* checking RTW TBTX */
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
if (elems.tbtx_cap && elems.tbtx_cap_len) {
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (rtw_is_tbtx_capabilty(elems.tbtx_cap, elems.tbtx_cap_len)){
RTW_DBG("AP support TBTX\n");
}
}
#endif
return _TRUE;
}
void rtw_dump_bcn_keys(void *sel, struct beacon_keys *recv_beacon)
{
u8 ssid[IW_ESSID_MAX_SIZE + 1];
_rtw_memcpy(ssid, recv_beacon->ssid, recv_beacon->ssid_len);
ssid[recv_beacon->ssid_len] = '\0';
RTW_PRINT_SEL(sel, "ssid = %s (len = %u)\n", ssid, recv_beacon->ssid_len);
RTW_PRINT_SEL(sel, "ch = %u,%u,%u\n"
, recv_beacon->ch, recv_beacon->bw, recv_beacon->offset);
RTW_PRINT_SEL(sel, "proto_cap = 0x%02x\n", recv_beacon->proto_cap);
RTW_MAP_DUMP_SEL(sel, "rate_set = "
, recv_beacon->rate_set, recv_beacon->rate_num);
RTW_PRINT_SEL(sel, "sec = %d, group = 0x%x, pair = 0x%x, akm = 0x%08x\n"
, recv_beacon->encryp_protocol, recv_beacon->group_cipher
, recv_beacon->pairwise_cipher, recv_beacon->akm);
}
int rtw_check_bcn_info(_adapter *adapter, u8 *pframe, u32 packet_len)
{
#define BCNKEY_VERIFY_PROTO_CAP 0
#define BCNKEY_VERIFY_WHOLE_RATE_SET 0
u8 *pbssid = GetAddr3Ptr(pframe);
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct wlan_network *cur_network = &(adapter->mlmepriv.cur_network);
struct beacon_keys *cur_beacon = &pmlmepriv->cur_beacon_keys;
struct beacon_keys recv_beacon;
int ret = 0;
u8 ifbmp_m = rtw_mi_get_ap_mesh_ifbmp(adapter);
u8 ifbmp_s = rtw_mi_get_ld_sta_ifbmp(adapter);
struct dvobj_priv *d = adapter_to_dvobj(adapter);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
if (is_client_associated_to_ap(adapter) == _FALSE)
goto exit_success;
if (rtw_get_bcn_keys(adapter, pframe, packet_len, &recv_beacon) == _FALSE)
goto exit_success; /* parsing failed => broken IE */
#ifdef DBG_RX_BCN
rtw_debug_rx_bcn(adapter, pframe, packet_len);
#endif
/* hidden ssid, replace with current beacon ssid directly */
if (is_hidden_ssid(recv_beacon.ssid, recv_beacon.ssid_len)) {
_rtw_memcpy(recv_beacon.ssid, cur_beacon->ssid, cur_beacon->ssid_len);
recv_beacon.ssid_len = cur_beacon->ssid_len;
}
#if CONFIG_DFS
if (check_fwstate(pmlmepriv, WIFI_CSA_UPDATE_BEACON)) {
u8 u_ch, u_offset, u_bw;
u8 bcn_ch, bcn_bw, bcn_offset;
struct sta_info *psta = NULL;
struct rtw_chan_def mr_chdef = {0};
struct rtw_chan_def new_chdef = {0};
/* get union ch/bw/offset from chan_ctx */
rtw_phl_mr_get_chandef(d->phl, adapter->phl_role, &mr_chdef);
u_ch = mr_chdef.chan;
u_offset = (u8)mr_chdef.offset;
u_bw = (u8)mr_chdef.bw;
#ifdef DBG_CSA
RTW_INFO("CSA : before update beacon, u_ch=%u, recv_beacon.ch=%u\n", u_ch, recv_beacon.ch);
#endif
if (pmlmepriv->bcn_cnts_after_csa < 5) {
if (u_ch == recv_beacon.ch)
pmlmepriv->bcn_cnts_after_csa += 1;
goto exit_success;
} else
pmlmepriv->bcn_cnts_after_csa = 0;
_rtw_memcpy(cur_beacon, &recv_beacon, sizeof(recv_beacon));
clr_fwstate(pmlmepriv, WIFI_CSA_UPDATE_BEACON);
bcn_ch = recv_beacon.ch;
bcn_bw = recv_beacon.bw;
bcn_offset = recv_beacon.offset;
#ifdef DBG_CSA
RTW_INFO("CSA : after update beacon, recv_beacon.ch=%u, recv_beacon.bw=%u, recv_beacon.offset=%u\n", \
bcn_ch, bcn_bw, bcn_offset);
rtw_dump_bcn_keys(RTW_DBGDUMP, &recv_beacon);
#endif
_cancel_timer_nowait(&pmlmeext->csa_timer);
/* beacon bw/offset is different from CSA IE */
if ((bcn_bw > u_bw) ||
(bcn_offset != u_offset &&
u_offset != CHAN_OFFSET_NO_EXT &&
bcn_offset != CHAN_OFFSET_NO_EXT)) {
pmlmeext->chandef.bw = bcn_bw;
pmlmeext->chandef.offset = bcn_offset;
/* updaet STA mode DSConfig , ap mode will update in rtw_change_bss_chbw_cmd */
pmlmepriv->cur_network.network.Configuration.DSConfig = bcn_ch;
/* update wifi role chandef */
rtw_hw_update_chan_def(adapter);
/* update chanctx */
if (rtw_phl_mr_upt_chandef(d->phl, adapter->phl_role) == RTW_PHL_STATUS_FAILURE)
RTW_ERR("CSA : update chanctx fail\n");
rtw_phl_mr_get_chandef(d->phl, adapter->phl_role, &new_chdef);
rtw_mi_update_union_chan_inf(adapter, new_chdef.chan, (u8)new_chdef.offset, (u8)new_chdef.bw);
#ifdef CONFIG_AP_MODE
if (ifbmp_m) {
rtw_change_bss_chbw_cmd(dvobj_get_primary_adapter(d), 0
, ifbmp_m, 0, new_chdef.chan, REQ_BW_ORI, REQ_OFFSET_NONE);
} else
#endif
{
#ifdef CONFIG_DFS_MASTER
rtw_dfs_rd_en_decision(adapter, MLME_OPCH_SWITCH, ifbmp_s);
#endif
rtw_set_chbw_cmd(adapter, new_chdef.chan, (u8)new_chdef.bw, (u8)new_chdef.offset, 0);
}
RTW_INFO("CSA : after update bw/offset, new_bw=%d, new_offset=%d \n", \
(u8)new_chdef.bw, (u8)new_chdef.offset);
} else {
RTW_INFO("CSA : u_ch=%d, u_bw=%d, u_offset=%d, recv_beacon.ch=%d, recv_beacon.bw=%d, recv_beacon.offset=%d\n"
, u_ch, u_bw, u_offset, bcn_ch, bcn_bw, bcn_offset);
}
/* update RA mask */
psta = rtw_get_stainfo(&adapter->stapriv, get_bssid(&adapter->mlmepriv));
if (psta) {
psta->phl_sta->chandef.bw = pmlmeext->chandef.bw;
rtw_phl_cmd_change_stainfo(GET_PHL_INFO(d),
psta->phl_sta,
STA_CHG_RAMASK,
NULL,
0,
PHL_CMD_NO_WAIT,
0);
}
RTW_INFO("CSA : update beacon done, WIFI_CSA_UPDATE_BEACON is clear\n");
}
#endif /* CONFIG_DFS */
if (_rtw_memcmp(&recv_beacon, cur_beacon, sizeof(recv_beacon)) == _FALSE) {
struct beacon_keys tmp_beacon;
RTW_INFO(FUNC_ADPT_FMT" new beacon occur!!\n", FUNC_ADPT_ARG(adapter));
RTW_INFO(FUNC_ADPT_FMT" cur beacon key:\n", FUNC_ADPT_ARG(adapter));
rtw_dump_bcn_keys(RTW_DBGDUMP, cur_beacon);
RTW_INFO(FUNC_ADPT_FMT" new beacon key:\n", FUNC_ADPT_ARG(adapter));
rtw_dump_bcn_keys(RTW_DBGDUMP, &recv_beacon);
if (!rtw_is_chbw_grouped(cur_beacon->ch, cur_beacon->bw, cur_beacon->offset
, recv_beacon.ch, recv_beacon.bw, recv_beacon.offset))
goto exit;
_rtw_memcpy(&tmp_beacon, cur_beacon, sizeof(tmp_beacon));
/* check fields excluding below */
tmp_beacon.ch = recv_beacon.ch;
tmp_beacon.bw = recv_beacon.bw;
tmp_beacon.offset = recv_beacon.offset;
if (!BCNKEY_VERIFY_PROTO_CAP)
tmp_beacon.proto_cap = recv_beacon.proto_cap;
if (!BCNKEY_VERIFY_WHOLE_RATE_SET) {
tmp_beacon.rate_num = recv_beacon.rate_num;
_rtw_memcpy(tmp_beacon.rate_set, recv_beacon.rate_set, 12);
}
if (_rtw_memcmp(&tmp_beacon, &recv_beacon, sizeof(recv_beacon)) == _FALSE)
goto exit;
_rtw_memcpy(cur_beacon, &recv_beacon, sizeof(recv_beacon));
}
exit_success:
ret = 1;
exit:
return ret;
}
void update_beacon_info(_adapter *padapter, u8 *pframe, uint pkt_len, struct sta_info *psta)
{
unsigned int i;
unsigned int len;
PNDIS_802_11_VARIABLE_IEs pIE;
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
u8 tdls_prohibited[] = { 0x00, 0x00, 0x00, 0x00, 0x10 }; /* bit(38): TDLS_prohibited */
#endif /* CONFIG_TDLS */
len = pkt_len - (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN);
for (i = 0; i < len;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(pframe + (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN) + i);
switch (pIE->ElementID) {
case _VENDOR_SPECIFIC_IE_:
/* to update WMM paramter set while receiving beacon */
if (_rtw_memcmp(pIE->data, WMM_PARA_OUI, 6) && pIE->Length == WLAN_WMM_LEN) /* WMM */
(WMM_param_handler(padapter, pIE)) ? report_wmm_edca_update(padapter) : 0;
break;
case _HT_EXTRA_INFO_IE_: /* HT info */
/* HT_info_handler(padapter, pIE); */
bwmode_update_check(padapter, pIE);
break;
#ifdef CONFIG_80211AC_VHT
case EID_OpModeNotification:
rtw_process_vht_op_mode_notify(padapter, pIE->data, psta);
break;
#endif /* CONFIG_80211AC_VHT */
case _ERPINFO_IE_:
ERP_IE_handler(padapter, pIE);
VCS_update(padapter, psta);
break;
#ifdef CONFIG_TDLS
case WLAN_EID_EXT_CAP:
if (check_ap_tdls_prohibited(pIE->data, pIE->Length) == _TRUE)
ptdlsinfo->ap_prohibited = _TRUE;
if (check_ap_tdls_ch_switching_prohibited(pIE->data, pIE->Length) == _TRUE)
ptdlsinfo->ch_switch_prohibited = _TRUE;
break;
#endif /* CONFIG_TDLS */
#ifdef CONFIG_80211AX_HE
case WLAN_EID_EXTENSION:
if (pIE->data[0] == WLAN_EID_EXTENSION_HE_OPERATION)
HE_operation_handler(padapter, pIE);
else if (pIE->data[0] == WLAN_EID_EXTENSION_HE_MU_EDCA)
HE_mu_edca_handler(padapter, pIE, _FALSE);
break;
#endif
default:
break;
}
i += (pIE->Length + 2);
}
}
#if CONFIG_DFS
void process_csa_ie(_adapter *padapter, u8 *ies, uint ies_len)
{
#ifdef CONFIG_ECSA_PHL
struct core_ecsa_info *ecsa_info = &(padapter->ecsa_info);
struct rtw_phl_ecsa_param *ecsa_param = &(ecsa_info->phl_ecsa_param);
#endif
struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
unsigned int i, j, countdown;
PNDIS_802_11_VARIABLE_IEs pIE, sub_pie;
u8 ch = 0, csa_ch_offset = 0, csa_ch_width = 0, csa_ch_freq_seg0 = 0, csa_ch_freq_seg1 = 0;
u8 csa_switch_cnt = 0, csa_mode = 0;
u8 is_csa_running;
#ifdef DBG_CSA
u8 *p;
u32 ie_len = 0;
p = rtw_get_ie(ies, WLAN_EID_CHANNEL_SWITCH, &ie_len, ies_len);
if (p && ie_len > 0)
RTW_INFO("CSA : %s, CH = %u, count = %u\n",__func__, *(p+2+1), *(p+2+2));
#endif
#ifdef CONFIG_ECSA_PHL
is_csa_running = rtw_mr_is_ecsa_running(padapter);
#else
is_csa_running = (rfctl->csa_chandef.chan > 0) ? _TRUE : _FALSE;
#endif
/* compare with scheduling CSA to block incoming CSA IE */
if (is_csa_running || check_fwstate(pmlmepriv, WIFI_CSA_UPDATE_BEACON))
return;
for (i = 0; i + 1 < ies_len;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(ies + i);
switch (pIE->ElementID) {
case WLAN_EID_CHANNEL_SWITCH:
csa_mode = *(pIE->data);
ch = *(pIE->data + 1);
csa_switch_cnt = *(pIE->data + 2);
RTW_INFO("CSA : mode = %u, ch = %u, switch count = %u\n",
csa_mode, ch, csa_switch_cnt);
break;
case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
csa_ch_offset = *(pIE->data);
break;
case WLAN_EID_WIDE_BANDWIDTH_CHANNEL_SWITCH:
csa_ch_width = *(pIE->data);
csa_ch_freq_seg0 = *(pIE->data+1);
csa_ch_freq_seg1 = *(pIE->data+2);
RTW_INFO("CSA : bw:%02x center_freq_0:%u center_freq_1:%u, ch=%u\n"
, csa_ch_width, csa_ch_freq_seg0, csa_ch_freq_seg1, ch);
break;
case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
for (j=0; j + 1 < pIE->Length;) {
sub_pie = (PNDIS_802_11_VARIABLE_IEs)(ies + i + j + 2);
if (sub_pie->ElementID == WLAN_EID_WIDE_BANDWIDTH_CHANNEL_SWITCH) {
csa_ch_width = *(sub_pie->data);
csa_ch_freq_seg0 = *(sub_pie->data+1);
csa_ch_freq_seg1 = *(sub_pie->data+2);
RTW_INFO("CSA : sub_IE:%02x IE_length:%02x bw:%02x center_freq_0:%u center_freq_1:%u, ch=%u\n"
, sub_pie->ElementID, sub_pie->Length, csa_ch_width, csa_ch_freq_seg0, csa_ch_freq_seg1, ch);
}
j += (sub_pie->Length + 2);
}
break;
default:
break;
}
i += (pIE->Length + 2);
}
/* Doesn't support switch bandwidth/offset in the same channel for now */
if (ch == rtw_mi_get_union_chan(padapter)) {
RTW_ERR("%s : receive the same channel from CSA IE, so ignore it\n", __func__);
return;
}
if (ch != 0) {
#ifdef CONFIG_ECSA_PHL
ecsa_param->ecsa_type = ECSA_TYPE_STA;
ecsa_param->mode = csa_mode;
ecsa_param->count = csa_switch_cnt;
/* ecsa_param.op_class = rfctl->op_class; */ /* TODO : ECSA */
ecsa_param->new_chan_def.band = rtw_phl_get_band_type(ch);
ecsa_param->new_chan_def.chan = ch;
/* The channel width defined in 802.11 spec */
ecsa_info->channel_width = csa_ch_width;
ecsa_param->new_chan_def.offset = csa_ch_offset;
ecsa_param->new_chan_def.center_freq1 = csa_ch_freq_seg0;
ecsa_param->new_chan_def.center_freq2 = csa_ch_freq_seg1;
ecsa_param->flag = 0;
ecsa_param->delay_start_ms = 0;
SET_ECSA_STATE(padapter, ECSA_ST_SW_START);
rtw_trigger_phl_ecsa_start(padapter);
#else
rfctl->csa_mode = csa_mode;
rfctl->csa_switch_cnt = csa_switch_cnt;
rfctl->csa_ch_width = csa_ch_width;
rfctl->csa_chandef.band = rtw_phl_get_band_type(ch);
rfctl->csa_chandef.chan = ch;
rfctl->csa_chandef.offset = csa_ch_offset;
rfctl->csa_chandef.center_freq1= csa_ch_freq_seg0;
rfctl->csa_chandef.center_freq2 = csa_ch_freq_seg1;
countdown = pmlmeinfo->network.Configuration.BeaconPeriod * (csa_switch_cnt+1); /* ms */
RTW_INFO("csa: set countdown timer to %d ms\n", countdown);
_set_timer(&pmlmeext->csa_timer, countdown);
#endif /* CONFIG_ECSA_PHL */
}
}
#endif /* CONFIG_DFS */
#ifdef CONFIG_80211D
bool rtw_iface_accept_country_ie(_adapter *adapter)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
if (!(BIT(adapter->iface_id) & rfctl->country_ie_slave_en_ifbmp))
return 0;
if (!MLME_IS_STA(adapter))
return 0;
if (!MLME_IS_GC(adapter)) {
if (!(rfctl->country_ie_slave_en_role & COUNTRY_IE_SLAVE_EN_ROLE_STA))
return 0;
} else {
if (!(rfctl->country_ie_slave_en_role & COUNTRY_IE_SLAVE_EN_ROLE_GC))
return 0;
}
return 1;
}
void process_country_ie(_adapter *adapter, u8 *ies, uint ies_len)
{
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
if (rfctl->regd_src == REGD_SRC_RTK_PRIV
&& !rtw_rfctl_is_disable_sw_channel_plan(rfctl_to_dvobj(rfctl))
&& !rfctl->csa_chandef.chan /* don't process country ie when under CSA processing */
) {
struct mlme_priv *mlme = &adapter->mlmepriv;
const u8 *ie = NULL;
sint ie_len = 0;
if (rtw_iface_accept_country_ie(adapter)) {
ie = rtw_get_ie(ies, WLAN_EID_COUNTRY, &ie_len, ies_len);
if (ie) {
if (ie_len < 6) {
ie = NULL;
ie_len = 0;
} else
ie_len += 2;
}
}
if (!mlme->recv_country_ie && !ie)
return;
if (mlme->recv_country_ie_len == ie_len
&& _rtw_memcmp(mlme->recv_country_ie, ie, ie_len) == _TRUE)
return;
if (!ie) {
rtw_buf_free(&mlme->recv_country_ie, &mlme->recv_country_ie_len);
rtw_apply_recv_country_ie_cmd(adapter, 0, 0, 0, NULL);
} else {
char ori_alpha2[2] = {0, 0};
if (mlme->recv_country_ie)
_rtw_memcpy(ori_alpha2, mlme->recv_country_ie + 2, 2);
rtw_buf_update(&mlme->recv_country_ie, &mlme->recv_country_ie_len, ie, ie_len);
/* for now only country code is used */
if (_rtw_memcmp(ori_alpha2, mlme->recv_country_ie + 2, 2) == _TRUE)
return;
RTW_INFO(FUNC_ADPT_FMT" country_ie alpha2 changed\n", FUNC_ADPT_ARG(adapter));
rtw_apply_recv_country_ie_cmd(adapter, 0
, mlme->cur_beacon_keys.ch > 14 ? BAND_ON_5G : BAND_ON_24G
, mlme->cur_beacon_keys.ch, mlme->recv_country_ie);
}
}
}
#endif /* CONFIG_80211D */
enum eap_type parsing_eapol_packet(_adapter *padapter, u8 *key_payload, struct sta_info *psta, u8 trx_type)
{
struct security_priv *psecuritypriv = &(padapter->securitypriv);
struct ieee802_1x_hdr *hdr;
struct wpa_eapol_key *key;
u16 key_info, key_data_length;
char *trx_msg = trx_type ? "send" : "recv";
enum eap_type eapol_type;
hdr = (struct ieee802_1x_hdr *) key_payload;
/* WPS - eapol start packet */
if (hdr->type == 1 && hdr->length == 0) {
RTW_INFO("%s eapol start packet\n", trx_msg);
return EAPOL_START;
}
if (hdr->type == 0) { /* WPS - eapol packet */
RTW_INFO("%s eapol packet\n", trx_msg);
return EAPOL_PACKET;
}
key = (struct wpa_eapol_key *) (hdr + 1);
key_info = be16_to_cpu(*((u16 *)(key->key_info)));
key_data_length = be16_to_cpu(*((u16 *)(key->key_data_length)));
if (!(key_info & WPA_KEY_INFO_KEY_TYPE)) { /* WPA group key handshake */
if (key_info & WPA_KEY_INFO_ACK) {
RTW_PRINT("%s eapol packet - WPA Group Key 1/2\n", trx_msg);
eapol_type = EAPOL_WPA_GROUP_KEY_1_2;
} else {
RTW_PRINT("%s eapol packet - WPA Group Key 2/2\n", trx_msg);
eapol_type = EAPOL_WPA_GROUP_KEY_2_2;
/* WPA key-handshake has completed */
if (psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPAPSK)
psta->state &= (~WIFI_UNDER_KEY_HANDSHAKE);
}
} else if (key_info & WPA_KEY_INFO_MIC) {
if (key_data_length == 0) {
RTW_PRINT("%s eapol packet 4/4\n", trx_msg);
eapol_type = EAPOL_4_4;
} else if (key_info & WPA_KEY_INFO_ACK) {
RTW_PRINT("%s eapol packet 3/4\n", trx_msg);
eapol_type = EAPOL_3_4;
} else {
RTW_PRINT("%s eapol packet 2/4\n", trx_msg);
eapol_type = EAPOL_2_4;
}
} else {
RTW_PRINT("%s eapol packet 1/4\n", trx_msg);
eapol_type = EAPOL_1_4;
}
return eapol_type;
}
unsigned int is_ap_in_tkip(_adapter *padapter)
{
u32 i;
PNDIS_802_11_VARIABLE_IEs pIE;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
if (rtw_get_capability((WLAN_BSSID_EX *)cur_network) & WLAN_CAPABILITY_PRIVACY) {
for (i = sizeof(NDIS_802_11_FIXED_IEs); i < pmlmeinfo->network.IELength;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(pmlmeinfo->network.IEs + i);
switch (pIE->ElementID) {
case _VENDOR_SPECIFIC_IE_:
if ((_rtw_memcmp(pIE->data, RTW_WPA_OUI, 4)) && (_rtw_memcmp((pIE->data + 12), WPA_TKIP_CIPHER, 4)))
return _TRUE;
break;
case _RSN_IE_2_:
if (_rtw_memcmp((pIE->data + 8), RSN_TKIP_CIPHER, 4))
return _TRUE;
default:
break;
}
i += (pIE->Length + 2);
}
return _FALSE;
} else
return _FALSE;
}
unsigned int should_forbid_n_rate(_adapter *padapter)
{
u32 i;
PNDIS_802_11_VARIABLE_IEs pIE;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
WLAN_BSSID_EX *cur_network = &pmlmepriv->cur_network.network;
if (rtw_get_capability((WLAN_BSSID_EX *)cur_network) & WLAN_CAPABILITY_PRIVACY) {
for (i = sizeof(NDIS_802_11_FIXED_IEs); i < cur_network->IELength;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(cur_network->IEs + i);
switch (pIE->ElementID) {
case _VENDOR_SPECIFIC_IE_:
if (_rtw_memcmp(pIE->data, RTW_WPA_OUI, 4) &&
((_rtw_memcmp((pIE->data + 12), WPA_CIPHER_SUITE_CCMP, 4)) ||
(_rtw_memcmp((pIE->data + 16), WPA_CIPHER_SUITE_CCMP, 4))))
return _FALSE;
break;
case _RSN_IE_2_:
if ((_rtw_memcmp((pIE->data + 8), RSN_CIPHER_SUITE_CCMP, 4)) ||
(_rtw_memcmp((pIE->data + 12), RSN_CIPHER_SUITE_CCMP, 4)))
return _FALSE;
default:
break;
}
i += (pIE->Length + 2);
}
return _TRUE;
} else
return _FALSE;
}
unsigned int is_ap_in_wep(_adapter *padapter)
{
u32 i;
PNDIS_802_11_VARIABLE_IEs pIE;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
if (rtw_get_capability((WLAN_BSSID_EX *)cur_network) & WLAN_CAPABILITY_PRIVACY) {
for (i = sizeof(NDIS_802_11_FIXED_IEs); i < pmlmeinfo->network.IELength;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(pmlmeinfo->network.IEs + i);
switch (pIE->ElementID) {
case _VENDOR_SPECIFIC_IE_:
if (_rtw_memcmp(pIE->data, RTW_WPA_OUI, 4))
return _FALSE;
break;
case _RSN_IE_2_:
return _FALSE;
default:
break;
}
i += (pIE->Length + 2);
}
return _TRUE;
} else
return _FALSE;
}
int wifirate2_ratetbl_inx(unsigned char rate);
int wifirate2_ratetbl_inx(unsigned char rate)
{
int inx = 0;
rate = rate & 0x7f;
switch (rate) {
case 54*2:
inx = 11;
break;
case 48*2:
inx = 10;
break;
case 36*2:
inx = 9;
break;
case 24*2:
inx = 8;
break;
case 18*2:
inx = 7;
break;
case 12*2:
inx = 6;
break;
case 9*2:
inx = 5;
break;
case 6*2:
inx = 4;
break;
case 11*2:
inx = 3;
break;
case 11:
inx = 2;
break;
case 2*2:
inx = 1;
break;
case 1*2:
inx = 0;
break;
}
return inx;
}
unsigned int update_basic_rate(unsigned char *ptn, unsigned int ptn_sz)
{
unsigned int i, num_of_rate;
unsigned int mask = 0;
num_of_rate = (ptn_sz > NumRates) ? NumRates : ptn_sz;
for (i = 0; i < num_of_rate; i++) {
if ((*(ptn + i)) & 0x80)
mask |= 0x1 << wifirate2_ratetbl_inx(*(ptn + i));
}
return mask;
}
unsigned int update_supported_rate(unsigned char *ptn, unsigned int ptn_sz)
{
unsigned int i, num_of_rate;
unsigned int mask = 0;
num_of_rate = (ptn_sz > NumRates) ? NumRates : ptn_sz;
for (i = 0; i < num_of_rate; i++)
mask |= 0x1 << wifirate2_ratetbl_inx(*(ptn + i));
return mask;
}
int support_short_GI(_adapter *padapter, struct HT_caps_element *pHT_caps, u8 bwmode)
{
unsigned char bit_offset;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (!(pmlmeinfo->HT_enable))
return _FAIL;
bit_offset = (bwmode & CHANNEL_WIDTH_40) ? 6 : 5;
if (pHT_caps->u.HT_cap_element.HT_caps_info & (0x1 << bit_offset))
return _SUCCESS;
else
return _FAIL;
}
unsigned char get_highest_rate_idx(u64 mask)
{
int i;
unsigned char rate_idx = 0;
for (i = 63; i >= 0; i--) {
if ((mask >> i) & 0x01) {
rate_idx = i;
break;
}
}
return rate_idx;
}
unsigned char get_lowest_rate_idx_ex(u64 mask, int start_bit)
{
int i;
unsigned char rate_idx = 0;
for (i = start_bit; i < 64; i++) {
if ((mask >> i) & 0x01) {
rate_idx = i;
break;
}
}
return rate_idx;
}
u8 get_highest_bw_cap(u8 bwmode)
{
u8 hbw = CHANNEL_WIDTH_20;
if (bwmode & BW_CAP_80_80M)
hbw = CHANNEL_WIDTH_80_80;
else if (bwmode & BW_CAP_160M)
hbw = CHANNEL_WIDTH_160;
else if (bwmode & BW_CAP_80M)
hbw = CHANNEL_WIDTH_80;
else if (bwmode & BW_CAP_40M)
hbw = CHANNEL_WIDTH_40;
else if (bwmode & BW_CAP_20M)
hbw = CHANNEL_WIDTH_20;
else if (bwmode & BW_CAP_10M)
hbw = CHANNEL_WIDTH_10;
else if (bwmode & BW_CAP_5M)
hbw = CHANNEL_WIDTH_5;
return hbw;
}
/* Update RRSR and Rate for USERATE */
void update_tx_basic_rate(_adapter *padapter, u8 wirelessmode)
{
NDIS_802_11_RATES_EX supported_rates;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
_rtw_memset(supported_rates, 0, NDIS_802_11_LENGTH_RATES_EX);
/* clear B mod if current channel is in 5G band, avoid tx cck rate in 5G band. */
if (pmlmeext->chandef.chan > 14)
wirelessmode &= ~(WLAN_MD_11B);
if ((wirelessmode & WLAN_MD_11B) && (wirelessmode == WLAN_MD_11B))
_rtw_memcpy(supported_rates, rtw_basic_rate_cck, 4);
else if (wirelessmode & WLAN_MD_11B)
_rtw_memcpy(supported_rates, rtw_basic_rate_mix, 7);
else
_rtw_memcpy(supported_rates, rtw_basic_rate_ofdm, 3);
if (wirelessmode & WLAN_MD_11B)
update_mgnt_tx_rate(padapter, IEEE80211_CCK_RATE_1MB);
else
update_mgnt_tx_rate(padapter, IEEE80211_OFDM_RATE_6MB);
rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, supported_rates);
}
unsigned char check_assoc_AP(u8 *pframe, uint len)
{
unsigned int i;
PNDIS_802_11_VARIABLE_IEs pIE;
for (i = sizeof(NDIS_802_11_FIXED_IEs); i < len;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(pframe + i);
switch (pIE->ElementID) {
case _VENDOR_SPECIFIC_IE_:
if ((_rtw_memcmp(pIE->data, ARTHEROS_OUI1, 3)) || (_rtw_memcmp(pIE->data, ARTHEROS_OUI2, 3))) {
RTW_INFO("link to Artheros AP\n");
return HT_IOT_PEER_ATHEROS;
} else if ((_rtw_memcmp(pIE->data, BROADCOM_OUI1, 3))
|| (_rtw_memcmp(pIE->data, BROADCOM_OUI2, 3))
|| (_rtw_memcmp(pIE->data, BROADCOM_OUI3, 3))) {
RTW_INFO("link to Broadcom AP\n");
return HT_IOT_PEER_BROADCOM;
} else if (_rtw_memcmp(pIE->data, MARVELL_OUI, 3)) {
RTW_INFO("link to Marvell AP\n");
return HT_IOT_PEER_MARVELL;
} else if (_rtw_memcmp(pIE->data, RALINK_OUI, 3)) {
RTW_INFO("link to Ralink AP\n");
return HT_IOT_PEER_RALINK;
} else if (_rtw_memcmp(pIE->data, CISCO_OUI, 3)) {
RTW_INFO("link to Cisco AP\n");
return HT_IOT_PEER_CISCO;
} else if (_rtw_memcmp(pIE->data, REALTEK_OUI, 3)) {
u32 Vender = HT_IOT_PEER_REALTEK;
if (pIE->Length >= 5) {
if (pIE->data[4] == 1) {
/* if(pIE->data[5] & RT_HT_CAP_USE_LONG_PREAMBLE) */
/* bssDesc->BssHT.RT2RT_HT_Mode |= RT_HT_CAP_USE_LONG_PREAMBLE; */
if (pIE->data[5] & RT_HT_CAP_USE_92SE) {
/* bssDesc->BssHT.RT2RT_HT_Mode |= RT_HT_CAP_USE_92SE; */
Vender = HT_IOT_PEER_REALTEK_92SE;
}
}
if (pIE->data[5] & RT_HT_CAP_USE_SOFTAP)
Vender = HT_IOT_PEER_REALTEK_SOFTAP;
if (pIE->data[4] == 2) {
if (pIE->data[6] & RT_HT_CAP_USE_JAGUAR_CBV) {
Vender = HT_IOT_PEER_REALTEK_JAGUAR_CBVAP;
RTW_INFO("link to Realtek JAGUAR_CBVAP\n");
}
if (pIE->data[6] & RT_HT_CAP_USE_JAGUAR_CCV) {
Vender = HT_IOT_PEER_REALTEK_JAGUAR_CCVAP;
RTW_INFO("link to Realtek JAGUAR_CCVAP\n");
}
}
}
RTW_INFO("link to Realtek AP\n");
return Vender;
} else if (_rtw_memcmp(pIE->data, AIRGOCAP_OUI, 3)) {
RTW_INFO("link to Airgo Cap\n");
return HT_IOT_PEER_AIRGO;
} else
break;
default:
break;
}
i += (pIE->Length + 2);
}
RTW_INFO("link to new AP\n");
return HT_IOT_PEER_UNKNOWN;
}
void get_assoc_AP_Vendor(char *vendor, u8 assoc_AP_vendor)
{
switch (assoc_AP_vendor) {
case HT_IOT_PEER_UNKNOWN:
sprintf(vendor, "%s", "unknown");
break;
case HT_IOT_PEER_REALTEK:
case HT_IOT_PEER_REALTEK_92SE:
case HT_IOT_PEER_REALTEK_SOFTAP:
case HT_IOT_PEER_REALTEK_JAGUAR_CBVAP:
case HT_IOT_PEER_REALTEK_JAGUAR_CCVAP:
sprintf(vendor, "%s", "Realtek");
break;
case HT_IOT_PEER_BROADCOM:
sprintf(vendor, "%s", "Broadcom");
break;
case HT_IOT_PEER_MARVELL:
sprintf(vendor, "%s", "Marvell");
break;
case HT_IOT_PEER_RALINK:
sprintf(vendor, "%s", "Ralink");
break;
case HT_IOT_PEER_CISCO:
sprintf(vendor, "%s", "Cisco");
break;
case HT_IOT_PEER_AIRGO:
sprintf(vendor, "%s", "Airgo");
break;
case HT_IOT_PEER_ATHEROS:
sprintf(vendor, "%s", "Atheros");
break;
default:
sprintf(vendor, "%s", "unkown");
break;
}
}
#ifdef CONFIG_RTS_FULL_BW
void rtw_parse_sta_vendor_ie_8812(_adapter *adapter, struct sta_info *sta, u8 *tlv_ies, u16 tlv_ies_len)
{
unsigned char REALTEK_OUI[] = {0x00,0xe0, 0x4c};
u8 *p;
p = rtw_get_ie_ex(tlv_ies, tlv_ies_len, WLAN_EID_VENDOR_SPECIFIC, REALTEK_OUI, 3, NULL, NULL);
if (!p)
goto exit;
else {
if(*(p+1) > 6 ) {
if(*(p+6) != 2)
goto exit;
if(*(p+8) == RT_HT_CAP_USE_JAGUAR_CBV)
sta->vendor_8812 = TRUE;
else if (*(p+8) == RT_HT_CAP_USE_JAGUAR_CCV)
sta->vendor_8812 = TRUE;
}
}
exit:
return;
}
#endif/*CONFIG_RTS_FULL_BW*/
#ifdef CONFIG_80211AC_VHT
void get_vht_bf_cap(u8 *pframe, uint len, struct vht_bf_cap *bf_cap)
{
unsigned int i;
PNDIS_802_11_VARIABLE_IEs pIE;
for (i = sizeof(NDIS_802_11_FIXED_IEs); i < len;) {
pIE = (PNDIS_802_11_VARIABLE_IEs)(pframe + i);
switch (pIE->ElementID) {
case EID_VHTCapability:
bf_cap->is_mu_bfer = GET_VHT_CAPABILITY_ELE_MU_BFER(pIE->data);
bf_cap->su_sound_dim = GET_VHT_CAPABILITY_ELE_SU_BFER_SOUND_DIM_NUM(pIE->data);
break;
default:
break;
}
i += (pIE->Length + 2);
}
}
#endif
void update_capinfo(_adapter *adapter, u16 updateCap)
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
BOOLEAN ShortPreamble;
/* Check preamble mode, 2005.01.06, by rcnjko. */
/* Mark to update preamble value forever, 2008.03.18 by lanhsin */
/* if( pMgntInfo->RegPreambleMode == PREAMBLE_AUTO ) */
{
if (updateCap & cShortPreamble) {
/* Short Preamble */
if (pmlmeinfo->preamble_mode != PREAMBLE_SHORT) { /* PREAMBLE_LONG or PREAMBLE_AUTO */
ShortPreamble = _TRUE;
pmlmeinfo->preamble_mode = PREAMBLE_SHORT;
rtw_hal_set_hwreg(adapter, HW_VAR_ACK_PREAMBLE, (u8 *)&ShortPreamble);
}
} else {
/* Long Preamble */
if (pmlmeinfo->preamble_mode != PREAMBLE_LONG) { /* PREAMBLE_SHORT or PREAMBLE_AUTO */
ShortPreamble = _FALSE;
pmlmeinfo->preamble_mode = PREAMBLE_LONG;
rtw_hal_set_hwreg(adapter, HW_VAR_ACK_PREAMBLE, (u8 *)&ShortPreamble);
}
}
}
if (updateCap & cIBSS) {
/* Filen: See 802.11-2007 p.91 */
pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME;
} else {
/* Filen: See 802.11-2007 p.90 */
if (pmlmeext->cur_wireless_mode & (WLAN_MD_11N | WLAN_MD_11A | WLAN_MD_11AC))
pmlmeinfo->slotTime = SHORT_SLOT_TIME;
else if (pmlmeext->cur_wireless_mode & (WLAN_MD_11G)) {
if ((updateCap & cShortSlotTime) /* && (!(pMgntInfo->pHTInfo->RT2RT_HT_Mode & RT_HT_CAP_USE_LONG_PREAMBLE)) */) {
/* Short Slot Time */
pmlmeinfo->slotTime = SHORT_SLOT_TIME;
} else {
/* Long Slot Time */
pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME;
}
} else {
/* B Mode */
pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME;
}
}
rtw_hal_set_hwreg(adapter, HW_VAR_SLOT_TIME, &pmlmeinfo->slotTime);
}
/*
* set adapter.mlmeextpriv.mlmext_info.HT_enable
* set adapter.mlmeextpriv.cur_wireless_mode
* set SIFS register
* set mgmt tx rate
*/
void update_wireless_mode(_adapter *padapter)
{
int ratelen, network_type = 0;
u32 SIFS_Timer;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
WLAN_BSSID_EX *cur_network = &(pmlmeinfo->network);
unsigned char *rate = cur_network->SupportedRates;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
#endif /* CONFIG_P2P */
ratelen = rtw_get_rateset_len(cur_network->SupportedRates);
if ((pmlmeinfo->HT_info_enable) && (pmlmeinfo->HT_caps_enable))
pmlmeinfo->HT_enable = 1;
if (pmlmeext->chandef.chan > 14) {
if (pmlmeinfo->HE_enable)
network_type = WLAN_MD_11AX;
else if (pmlmeinfo->VHT_enable)
network_type = WLAN_MD_11AC;
else if (pmlmeinfo->HT_enable)
network_type = WLAN_MD_11N;
network_type |= WLAN_MD_11A;
} else {
if (pmlmeinfo->HE_enable)
network_type = WLAN_MD_11AX;
else if (pmlmeinfo->VHT_enable)
network_type = WLAN_MD_11AC;
else if (pmlmeinfo->HT_enable)
network_type = WLAN_MD_11N;
if ((cckratesonly_included(rate, ratelen)) == _TRUE)
network_type |= WLAN_MD_11B;
else if ((cckrates_included(rate, ratelen)) == _TRUE)
network_type |= WLAN_MD_11BG;
else
network_type |= WLAN_MD_11G;
}
pmlmeext->cur_wireless_mode = network_type & padapter->registrypriv.wireless_mode;
/* RTW_INFO("network_type=%02x, padapter->registrypriv.wireless_mode=%02x\n", network_type, padapter->registrypriv.wireless_mode); */
if ((pmlmeext->cur_wireless_mode & WLAN_MD_11B) &&
#ifdef CONFIG_P2P
!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT) &&
!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO) &&
#endif
1)
update_mgnt_tx_rate(padapter, IEEE80211_CCK_RATE_1MB);
else
update_mgnt_tx_rate(padapter, IEEE80211_OFDM_RATE_6MB);
}
void update_sta_basic_rate(struct sta_info *psta, u8 wireless_mode)
{
if (is_supported_tx_cck(wireless_mode)) {
/* Only B, B/G, and B/G/N AP could use CCK rate */
_rtw_memcpy(psta->bssrateset, rtw_basic_rate_cck, 4);
psta->bssratelen = 4;
} else {
_rtw_memcpy(psta->bssrateset, rtw_basic_rate_ofdm, 3);
psta->bssratelen = 3;
}
}
int rtw_ies_get_supported_rate(u8 *ies, uint ies_len, u8 *rate_set, u8 *rate_num)
{
u8 *ie, *p;
unsigned int ie_len;
int i, j;
struct support_rate_handler support_rate_tbl[] = {
{IEEE80211_CCK_RATE_1MB, _FALSE, _FALSE},
{IEEE80211_CCK_RATE_2MB, _FALSE, _FALSE},
{IEEE80211_CCK_RATE_5MB, _FALSE, _FALSE},
{IEEE80211_CCK_RATE_11MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_6MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_9MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_12MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_18MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_24MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_36MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_48MB, _FALSE, _FALSE},
{IEEE80211_OFDM_RATE_54MB, _FALSE, _FALSE},
};
if (!rate_set || !rate_num)
return _FALSE;
*rate_num = 0;
ie = rtw_get_ie(ies, _SUPPORTEDRATES_IE_, &ie_len, ies_len);
if (ie == NULL)
goto ext_rate;
/* get valid supported rates */
for (i = 0; i < 12; i++) {
p = ie + 2;
for (j = 0; j < ie_len; j++) {
if ((*p & ~BIT(7)) == support_rate_tbl[i].rate){
support_rate_tbl[i].existence = _TRUE;
if ((*p) & BIT(7))
support_rate_tbl[i].basic = _TRUE;
}
p++;
}
}
ext_rate:
ie = rtw_get_ie(ies, _EXT_SUPPORTEDRATES_IE_, &ie_len, ies_len);
if (ie) {
/* get valid extended supported rates */
for (i = 0; i < 12; i++) {
p = ie + 2;
for (j = 0; j < ie_len; j++) {
if ((*p & ~BIT(7)) == support_rate_tbl[i].rate){
support_rate_tbl[i].existence = _TRUE;
if ((*p) & BIT(7))
support_rate_tbl[i].basic = _TRUE;
}
p++;
}
}
}
for (i = 0; i < 12; i++){
if (support_rate_tbl[i].existence){
if (support_rate_tbl[i].basic)
rate_set[*rate_num] = support_rate_tbl[i].rate | IEEE80211_BASIC_RATE_MASK;
else
rate_set[*rate_num] = support_rate_tbl[i].rate;
*rate_num += 1;
}
}
if (*rate_num == 0)
return _FAIL;
if (0) {
int i;
for (i = 0; i < *rate_num; i++)
RTW_INFO("rate:0x%02x\n", *(rate_set + i));
}
return _SUCCESS;
}
void process_addba_req(_adapter *padapter, u8 *paddba_req, u8 *addr)
{
struct sta_info *psta;
u16 tid, start_seq, param;
struct sta_priv *pstapriv = &padapter->stapriv;
struct ADDBA_request *preq = (struct ADDBA_request *)paddba_req;
u8 size, accept = _FALSE;
psta = rtw_get_stainfo(pstapriv, addr);
if (!psta)
goto exit;
start_seq = le16_to_cpu(preq->BA_starting_seqctrl) >> 4;
param = le16_to_cpu(preq->BA_para_set);
tid = (param >> 2) & 0x0f;
accept = rtw_rx_ampdu_is_accept(padapter);
if (padapter->fix_rx_ampdu_size != RX_AMPDU_SIZE_INVALID)
size = padapter->fix_rx_ampdu_size;
else {
size = rtw_rx_ampdu_size(padapter);
size = rtw_min(size, rx_ampdu_size_sta_limit(padapter, psta));
}
if (accept == _TRUE)
rtw_addbarsp_cmd(padapter, addr, tid, preq, 0, size, start_seq);
else
rtw_addbarsp_cmd(padapter, addr, tid, preq, 37, size, start_seq);/* reject ADDBA Req */
exit:
return;
}
void rtw_process_bar_frame(_adapter *padapter, union recv_frame *precv_frame)
{
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *pframe = precv_frame->u.hdr.rx_data;
struct sta_info *psta = NULL;
struct recv_reorder_ctrl *preorder_ctrl = NULL;
u8 tid = 0;
u16 start_seq=0;
psta = rtw_get_stainfo(pstapriv, get_addr2_ptr(pframe));
if (psta == NULL)
goto exit;
tid = ((cpu_to_le16((*(u16 *)(pframe + 16))) & 0xf000) >> 12);
preorder_ctrl = &psta->recvreorder_ctrl[tid];
start_seq = ((cpu_to_le16(*(u16 *)(pframe + 18))) >> 4);
preorder_ctrl->indicate_seq = start_seq;
rtw_phl_rx_bar(padapter->dvobj->phl, psta->phl_sta, tid, start_seq);
/* for Debug use */
if (0)
RTW_INFO(FUNC_ADPT_FMT" tid=%d, start_seq=%d\n", FUNC_ADPT_ARG(padapter), tid, start_seq);
exit:
return;
}
void update_TSF(struct mlme_ext_priv *pmlmeext, u8 *pframe, uint len)
{
u8 *pIE;
u32 *pbuf;
pIE = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
pbuf = (u32 *)pIE;
pmlmeext->TSFValue = le32_to_cpu(*(pbuf + 1));
pmlmeext->TSFValue = pmlmeext->TSFValue << 32;
pmlmeext->TSFValue |= le32_to_cpu(*pbuf);
}
#ifdef CONFIG_BCN_RECV_TIME
/* calculate beacon receiving time
1.RxBCNTime(CCK_1M) = [192us(preamble)] + [length of beacon(byte)*8us] + [10us]
2.RxBCNTime(OFDM_6M) = [8us(S) + 8us(L) + 4us(L-SIG)] + [(length of beacon(byte)/3 + 1] *4us] + [10us]
*/
inline u16 _rx_bcn_time_calculate(uint bcn_len, u8 data_rate)
{
u16 rx_bcn_time = 0;/*us*/
if (data_rate == DESC_RATE1M)
rx_bcn_time = 192 + bcn_len * 8 + 10;
else if(data_rate == DESC_RATE6M)
rx_bcn_time = 8 + 8 + 4 + (bcn_len /3 + 1) * 4 + 10;
/*
else
RTW_ERR("%s invalid data rate(0x%02x)\n", __func__, data_rate);
*/
return rx_bcn_time;
}
void rtw_rx_bcn_time_update(_adapter *adapter, uint bcn_len, u8 data_rate)
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
pmlmeext->bcn_rx_time = _rx_bcn_time_calculate(bcn_len, data_rate);
}
#endif
void beacon_timing_control(_adapter *padapter)
{
rtw_hal_bcn_param_setting(padapter);
}
inline void rtw_collect_bcn_info(_adapter *adapter)
{
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
if (!is_client_associated_to_ap(adapter))
return;
pmlmeext->cur_bcn_cnt = pmlmeext->bcn_cnt - pmlmeext->last_bcn_cnt;
pmlmeext->last_bcn_cnt = pmlmeext->bcn_cnt;
/*TODO get offset of bcn's timestamp*/
/*pmlmeext->bcn_timestamp;*/
}
inline bool rtw_bmp_is_set(const u8 *bmp, u8 bmp_len, u8 id)
{
if (id / 8 >= bmp_len)
return 0;
return bmp[id / 8] & BIT(id % 8);
}
inline void rtw_bmp_set(u8 *bmp, u8 bmp_len, u8 id)
{
if (id / 8 < bmp_len)
bmp[id / 8] |= BIT(id % 8);
}
inline void rtw_bmp_clear(u8 *bmp, u8 bmp_len, u8 id)
{
if (id / 8 < bmp_len)
bmp[id / 8] &= ~BIT(id % 8);
}
inline bool rtw_bmp_not_empty(const u8 *bmp, u8 bmp_len)
{
int i;
for (i = 0; i < bmp_len; i++) {
if (bmp[i])
return 1;
}
return 0;
}
inline bool rtw_bmp_not_empty_exclude_bit0(const u8 *bmp, u8 bmp_len)
{
int i;
for (i = 0; i < bmp_len; i++) {
if (i == 0) {
if (bmp[i] & 0xFE)
return 1;
} else {
if (bmp[i])
return 1;
}
}
return 0;
}
#ifdef CONFIG_AP_MODE
/* Check the id be set or not in map , if yes , return a none zero value*/
bool rtw_tim_map_is_set(_adapter *padapter, const u8 *map, u8 id)
{
return rtw_bmp_is_set(map, padapter->stapriv.aid_bmp_len, id);
}
/* Set the id into map array*/
void rtw_tim_map_set(_adapter *padapter, u8 *map, u8 id)
{
rtw_bmp_set(map, padapter->stapriv.aid_bmp_len, id);
}
/* Clear the id from map array*/
void rtw_tim_map_clear(_adapter *padapter, u8 *map, u8 id)
{
rtw_bmp_clear(map, padapter->stapriv.aid_bmp_len, id);
}
/* Check have anyone bit be set , if yes return true*/
bool rtw_tim_map_anyone_be_set(_adapter *padapter, const u8 *map)
{
return rtw_bmp_not_empty(map, padapter->stapriv.aid_bmp_len);
}
/* Check have anyone bit be set exclude bit0 , if yes return true*/
bool rtw_tim_map_anyone_be_set_exclude_aid0(_adapter *padapter, const u8 *map)
{
return rtw_bmp_not_empty_exclude_bit0(map, padapter->stapriv.aid_bmp_len);
}
#endif /* CONFIG_AP_MODE */
_adapter *dvobj_get_unregisterd_adapter(struct dvobj_priv *dvobj)
{
_adapter *adapter = NULL;
int i;
for (i = 0; i < dvobj->iface_nums; i++) {
if (dvobj->padapters[i]->registered == 0)
break;
}
if (i < dvobj->iface_nums)
adapter = dvobj->padapters[i];
return adapter;
}
_adapter *dvobj_get_adapter_by_addr(struct dvobj_priv *dvobj, u8 *addr)
{
_adapter *adapter = NULL;
int i;
for (i = 0; i < dvobj->iface_nums; i++) {
if (_rtw_memcmp(dvobj->padapters[i]->mac_addr, addr, ETH_ALEN) == _TRUE)
break;
}
if (i < dvobj->iface_nums)
adapter = dvobj->padapters[i];
return adapter;
}
#ifdef CONFIG_RTW_MULTI_AP
u8 rtw_get_ch_utilization(_adapter *adapter)
{
#if 0 /* FIXME */
u16 clm = rtw_phydm_clm_ratio(adapter);
u16 nhm = rtw_phydm_nhm_ratio(adapter);
#else
u16 clm = 55;
u16 nhm = 55;
#endif
u16 ch_util;
ch_util = clm / 3 + (2 * (nhm / 3));
/* For Multi-AP, scaling 0-100 to 0-255 */
ch_util = 255 * ch_util / 100;
return (u8)ch_util;
}
void rtw_ch_util_rpt(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
_adapter *iface;
int i, j;
u8 i_rpts = 0;
u8 *ch_util;
u8 **bssid;
u8 threshold = GET_PRIMARY_ADAPTER(adapter)->ch_util_threshold;
u8 need_rpt = 0;
if (threshold == 0)
return;
ch_util = rtw_zmalloc(sizeof(u8) * dvobj->iface_nums);
if (!ch_util)
goto err_out;
bssid = (u8 **)rtw_zmalloc(sizeof(u8 *) * dvobj->iface_nums);
if (!bssid)
goto err_out1;
for (j = 0; j < dvobj->iface_nums; j++) {
*(bssid + j) = (u8 *)rtw_zmalloc(sizeof(u8) * ETH_ALEN);
if (!(*(bssid + j)))
goto err_out2;
}
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && MLME_IS_AP(iface)) {
*(ch_util + i_rpts) = rtw_get_ch_utilization(iface);
_rtw_memcpy(*(bssid + i_rpts), iface->mac_addr, ETH_ALEN);
if (*(ch_util + i_rpts) > threshold)
need_rpt = 1;
i_rpts++;
}
}
if (need_rpt)
rtw_nlrtw_ch_util_rpt(adapter, i_rpts, ch_util, bssid);
rtw_mfree(ch_util, sizeof(u8) * dvobj->iface_nums);
for (i = 0; i < dvobj->iface_nums; i++)
rtw_mfree(*(bssid + i), ETH_ALEN);
rtw_mfree(bssid, sizeof(u8 *) * dvobj->iface_nums);
return;
err_out2:
for (i = 0; i < j; i++)
rtw_mfree(*(bssid + i), sizeof(u8) * ETH_ALEN);
rtw_mfree(bssid, sizeof(sizeof(u8 *) * dvobj->iface_nums));
err_out1:
rtw_mfree(ch_util, sizeof(u8) * dvobj->iface_nums);
err_out:
RTW_INFO("[%s] rtw_zmalloc fail\n", __func__);
}
#endif
|
2301_81045437/rtl8852be
|
core/rtw_wlan_util.c
|
C
|
agpl-3.0
| 84,675
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#ifndef RTW_WNM_DBG
#define RTW_WNM_DBG 0
#endif
#if RTW_WNM_DBG
#define RTW_WNM_INFO(fmt, arg...) \
RTW_INFO(fmt, arg)
#define RTW_WNM_DUMP(str, data, len) \
RTW_INFO_DUMP(str, data, len)
#else
#define RTW_WNM_INFO(fmt, arg...) do {} while (0)
#define RTW_WNM_DUMP(str, data, len) do {} while (0)
#endif
#ifdef CONFIG_RTW_WNM
static u32 wnm_defualt_validity_time = 6000;
static u32 wnm_default_disassoc_time = 5000;
static u32 wnm_disassoc_wait_time = 500;
/* for wifi test, need more validity time to wait scan done */
static u32 wnm_ext_validity_time = 4000;
static u8 wnm_non_pref_ch_oui[] = {0x50, 0x6F, 0x9A, 0x2};
#define rtw_wnm_get_non_pref_ch_oui(p) ((u8 *)(p) + 2)
static void rtw_wmn_btm_cache_update(
_adapter *padapter, struct btm_req_hdr *phdr)
{
struct btm_rpt_cache *pcache = \
&(padapter->mlmepriv.nb_info.btm_cache);
pcache->dialog_token = phdr->dialog_token;
pcache->req_mode = phdr->req_mode;
pcache->disassoc_timer = le16_to_cpu(phdr->disassoc_timer);
if (phdr->validity_interval > 0)
pcache->validity_interval = phdr->validity_interval;
pcache->term_duration.id = phdr->term_duration.id;
pcache->term_duration.len = phdr->term_duration.len;
pcache->term_duration.tsf = le64_to_cpu(phdr->term_duration.tsf);
pcache->term_duration.duration = le16_to_cpu(phdr->term_duration.duration);
RTW_WNM_INFO("%s: req_mode(0x%02x), disassoc_timer(0x%04x), "
"validity_interval(0x%02x %s), tsf(0x%llx), duration(0x%02x)\n",
__func__, pcache->req_mode, pcache->disassoc_timer,
pcache->validity_interval, (!phdr->validity_interval)?
"default":"", pcache->term_duration.tsf,
pcache->term_duration.duration);
if (pcache->validity_interval > 0) {
pcache->validity_time = pcache->validity_interval * 100;
#ifdef CONFIG_RTW_MBO
if (rtw_mbo_wifi_logo_test(padapter))
pcache->validity_time += wnm_ext_validity_time;
#endif
}
if (pcache->disassoc_timer > 0) {
pcache->disassoc_time= pcache->disassoc_timer * 100;
#ifdef CONFIG_RTW_MBO
if (rtw_mbo_wifi_logo_test(padapter))
pcache->disassoc_time += wnm_ext_validity_time;
#endif
}
pcache->req_stime = rtw_get_current_time();
RTW_WNM_INFO("%s: validity_time=%u, disassoc_time=%u\n",
__func__, pcache->validity_time, pcache->disassoc_time);
}
static u8 rtw_wnm_btm_candidate_validity(
struct btm_rpt_cache *pcache, u8 flag)
{
u8 is_validity =_TRUE;
u32 req_validity_time = rtw_get_passing_time_ms(pcache->req_stime);
if ((flag & BIT(0)) && (req_validity_time > pcache->validity_time))
is_validity = _FALSE;
if ((flag & BIT(1)) && (req_validity_time > pcache->disassoc_time))
is_validity = _FALSE;
RTW_WNM_INFO("%s : validity=%u, rtime=%u, vtime=%u. dtime=%u\n",
__func__, is_validity, req_validity_time,
pcache->validity_time, pcache->disassoc_time);
return is_validity;
}
u8 rtw_wmn_btm_rsp_reason_decision(_adapter *padapter, u8* req_mode)
{
struct recv_info *recvinfo = &(padapter->recvinfo);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u8 reason = 0;
if (!rtw_wnm_btm_diff_bss(padapter)) {
/* Reject - No suitable BSS transition candidates */
reason = 7;
goto candidate_remove;
}
#ifdef CONFIG_RTW_80211R
if (rtw_ft_chk_flags(padapter, RTW_FT_BTM_ROAM)) {
/* Accept */
reason = 0;
goto under_survey;
}
#endif
if (((*req_mode) & DISASSOC_IMMINENT) == 0) {
/* Reject - Unspecified reject reason */
reason = 1;
goto candidate_remove;
}
if (recvinfo->signal_strength_data.avg_val >=
pmlmepriv->roam_rssi_threshold) {
reason = 1;
RTW_WNM_INFO("%s : Reject - under high roam rssi(%u, %u) \n",
__func__, recvinfo->signal_strength_data.avg_val,
pmlmepriv->roam_rssi_threshold);
goto candidate_remove;
}
#ifdef CONFIG_RTW_80211R
under_survey:
if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)) {
RTW_WNM_INFO("%s reject due to _FW_UNDER_SURVEY\n", __func__);
reason = 1;
}
#endif
candidate_remove:
if (reason !=0)
rtw_wnm_reset_btm_candidate(&pmlmepriv->nb_info);
return reason;
}
static u32 rtw_wnm_btm_candidates_offset_get(u8* pframe)
{
u32 offset = 0;
if (!pframe)
return 0;
offset += 7;
/* BSS Termination Duration check */
if (wnm_btm_bss_term_inc(pframe))
offset += 12;
/* Session Information URL check*/
if (wnm_btm_ess_disassoc_im(pframe)) {
/*URL length field + URL variable length*/
offset = 1 + *(pframe + offset);
}
RTW_WNM_INFO("%s : hdr offset=%u\n", __func__, offset);
return offset;
}
static void rtw_wnm_btm_req_hdr_parsing(u8* pframe, struct btm_req_hdr *phdr)
{
u8 *pos;
u32 offset = 0;
if (!pframe || !phdr)
return;
_rtw_memset(phdr, 0, sizeof(struct btm_req_hdr));
phdr->dialog_token = wnm_btm_dialog_token(pframe);
phdr->req_mode = wnm_btm_req_mode(pframe);
phdr->disassoc_timer = wnm_btm_disassoc_timer(pframe);
phdr->validity_interval = wnm_btm_valid_interval(pframe);
if (wnm_btm_bss_term_inc(pframe)) {
pos = wnm_btm_term_duration_offset(pframe);
if (*pos == WNM_BTM_TERM_DUR_SUBEID) {
phdr->term_duration.id = *pos;
phdr->term_duration.len = *(pos + 1);
phdr->term_duration.tsf = *((u64*)(pos + 2));
phdr->term_duration.duration= *((u16*)(pos + 10));
} else
RTW_WNM_INFO("%s : invaild BSS Termination Duration"
" content!\n", __func__);
}
RTW_WNM_INFO("WNM: req_mode(0x%02x), disassoc_timer(0x%04x),"
" validity_interval(0x%02x)\n",
phdr->req_mode, phdr->disassoc_timer,
phdr->validity_interval);
if (wnm_btm_bss_term_inc(pframe)) {
RTW_WNM_INFO("WNM: tsf(0x%llx), duration(0x%4x)\n",
phdr->term_duration.tsf,
phdr->term_duration.duration);
}
}
u8 rtw_wnm_btm_reassoc_req(_adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct roam_nb_info *pnb = &(pmlmepriv->nb_info);
u8 breassoc = _FALSE;
if (_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)),
pnb->roam_target_addr, ETH_ALEN)) {
RTW_WNM_INFO("%s : bss "MAC_FMT" found in roam_target "
MAC_FMT"\n", __func__,
MAC_ARG(get_my_bssid(&(pmlmeinfo->network))),
MAC_ARG(pnb->roam_target_addr));
breassoc = _TRUE;
}
return breassoc;
}
void rtw_wnm_roam_scan_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
if (rtw_is_scan_deny(padapter)) {
RTW_WNM_INFO("%s: roam scan would abort by scan_deny!\n",
__func__);
}
#ifdef CONFIG_RTW_80211R
if (rtw_ft_chk_flags(padapter, RTW_FT_BTM_ROAM)) {
pmlmepriv->need_to_roam = _TRUE;
rtw_set_to_roam(padapter,
padapter->registrypriv.max_roaming_times);
RTW_WNM_INFO("%s : enable roaming\n", __func__);
}
rtw_drv_scan_by_self(padapter, RTW_AUTO_SCAN_REASON_ROAM);
#endif
}
static void rtw_wnm_roam_scan(_adapter *padapter)
{
struct roam_nb_info *pnb = &(padapter->mlmepriv.nb_info);
if (rtw_is_scan_deny(padapter)) {
_cancel_timer_ex(&pnb->roam_scan_timer);
_set_timer(&pnb->roam_scan_timer, 1000);
} else
rtw_wnm_roam_scan_hdl((void *)padapter);
}
void rtw_wnm_disassoc_chk_hdl(void *ctx)
{
_adapter *padapter = (_adapter *)ctx;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct roam_nb_info *pnb = &(pmlmepriv->nb_info);
RTW_WNM_INFO("%s : expired\n", __func__);
if (pnb->disassoc_waiting <= 0 ) {
RTW_WNM_INFO("%s : btm roam is interrupted by disassoc\n",
__func__);
return;
}
pnb->disassoc_waiting = _FALSE;
rtw_wnm_roam_scan(padapter);
}
u8 rtw_wnm_try_btm_roam_imnt(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct roam_nb_info *pnb = &(pmlmepriv->nb_info);
struct btm_rpt_cache *pcache = &(pnb->btm_cache);
u8 reason = 0, flag = 0;
if (!rtw_wnm_btm_preference_cap(padapter)) {
RTW_WNM_INFO("%s : no btm candidate can be used!\n",
__func__);
return 1;
}
flag = BIT(0) | BIT(1);
if (!rtw_wnm_btm_candidate_validity(pcache, flag))
return 1;
#ifdef CONFIG_RTW_MBO
if (!rtw_mbo_wifi_logo_test(padapter)
&& !(pcache->req_mode & DISASSOC_IMMINENT)) {
RTW_WNM_INFO("%s : non-disassoc imminet req\n", __func__);
return 1;
}
#endif
RTW_WNM_INFO("%s : disassoc_waiting(%d)\n",
__func__, pnb->disassoc_waiting);
if (pnb->disassoc_waiting) {
_cancel_timer_ex(&pnb->disassoc_chk_timer);
pnb->disassoc_waiting = _FALSE;
rtw_wnm_roam_scan_hdl((void *)padapter);
} else if (!pnb->disassoc_waiting) {
RTW_WNM_INFO("%s : waiting for btm roaming start/finish\n",
__func__);
} else
reason = 1;
return reason;
}
void rtw_wnm_process_btm_req(_adapter *padapter, u8* pframe, u32 frame_len)
{
struct roam_nb_info *pnb = &(padapter->mlmepriv.nb_info);
struct btm_req_hdr req_hdr;
u8 *ptr, reason;
u32 elem_len, offset;
rtw_wnm_btm_req_hdr_parsing(pframe, &req_hdr);
offset = rtw_wnm_btm_candidates_offset_get(pframe);
if (offset == 0)
return;
if ((frame_len - offset) <= 15) {
RTW_INFO("WNM : Reject - "
"no suitable BSS transition candidates!\n");
rtw_wnm_issue_action(padapter,
RTW_WLAN_ACTION_WNM_BTM_RSP, 7, req_hdr.dialog_token);
return;
}
rtw_wmn_btm_cache_update(padapter, &req_hdr);
ptr = (pframe + offset);
elem_len = (frame_len - offset);
rtw_wnm_btm_candidates_survey(padapter, ptr, elem_len, _TRUE);
reason = rtw_wmn_btm_rsp_reason_decision(padapter, &pframe[3]);
#ifdef CONFIG_RTW_MBO
/* for wifi-test; AP2 could power-off when BTM-req received */
if ((reason > 0) && (rtw_mbo_wifi_logo_test(padapter))) {
_rtw_memcpy(pnb->roam_target_addr,
pnb->nb_rpt[0].bssid, ETH_ALEN);
RTW_WNM_INFO("%s : used report 0 as roam_target_addr"
"(reason=%u)\n", __func__, reason);
reason = 0;
pnb->preference_en = _TRUE;
pnb->nb_rpt_valid = _FALSE;
}
#endif
rtw_wnm_issue_action(padapter,
RTW_WLAN_ACTION_WNM_BTM_RSP, reason, req_hdr.dialog_token);
if (reason == 0) {
pnb->disassoc_waiting = _TRUE;
_set_timer(&pnb->disassoc_chk_timer, wnm_disassoc_wait_time);
}
}
void rtw_wnm_reset_btm_candidate(struct roam_nb_info *pnb)
{
pnb->preference_en = _FALSE;
_rtw_memset(pnb->roam_target_addr, 0, ETH_ALEN);
}
void rtw_wnm_reset_btm_cache(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct roam_nb_info *pnb = &(pmlmepriv->nb_info);
struct btm_rpt_cache *pcache = &(pnb->btm_cache);
u8 flag = 0;
flag |= BIT(0);
if (rtw_wnm_btm_candidate_validity(pcache, flag))
return;
rtw_wnm_reset_btm_candidate(pnb);
_rtw_memset(pcache, 0, sizeof(struct btm_rpt_cache));
pcache->validity_time = wnm_defualt_validity_time;
pcache->disassoc_time= wnm_default_disassoc_time;
#ifdef CONFIG_RTW_80211R
if (rtw_ft_chk_flags(padapter, RTW_FT_BTM_ROAM)) {
pmlmepriv->need_to_roam = _FALSE;
rtw_set_to_roam(padapter, 0);
RTW_WNM_INFO("%s : disabled roaming\n", __func__);
}
#endif
}
void rtw_wnm_reset_btm_state(_adapter *padapter)
{
struct roam_nb_info *pnb = &(padapter->mlmepriv.nb_info);
pnb->last_nb_rpt_entries = 0;
pnb->nb_rpt_is_same = _TRUE;
pnb->nb_rpt_valid = _FALSE;
pnb->nb_rpt_ch_list_num = 0;
pnb->disassoc_waiting = -1;
_rtw_memset(&pnb->nb_rpt, 0, sizeof(pnb->nb_rpt));
_rtw_memset(&pnb->nb_rpt_ch_list, 0, sizeof(pnb->nb_rpt_ch_list));
rtw_wnm_reset_btm_cache(padapter);
}
u32 rtw_wnm_btm_rsp_candidates_sz_get(
_adapter *padapter, u8* pframe, u32 frame_len)
{
u32 num = 0, sz = 0;
u8 status;
u8 *ptr;
if (!pframe || (frame_len <= 5))
goto exit;
status = wnm_btm_rsp_status(pframe);
if (((status != 0) && (status != 6)) || (frame_len < 23))
goto exit;
if (status == 0)
num = (frame_len - 5 - ETH_ALEN)/18;
else
num = (frame_len - 5)/18;
sz = sizeof(struct wnm_btm_cant) * num;
exit:
RTW_WNM_INFO("WNM: %u candidates(sz=%u) in BTM rsp\n", num, sz);
return sz;
}
void rtw_wnm_process_btm_rsp(_adapter *padapter,
u8* pframe, u32 frame_len, struct btm_rsp_hdr *prsp)
{
prsp->dialog_token = wnm_btm_dialog_token(pframe);
prsp->status = wnm_btm_rsp_status(pframe);
prsp->termination_delay = wnm_btm_rsp_term_delay(pframe);
if ((pframe == NULL) || (frame_len == 0))
return;
prsp->status = *(pframe + 3);
prsp->termination_delay = *(pframe + 4);
/* no Target BSSID & Candidate in frame */
if (frame_len <= 5)
return;
/* accept */
if ((prsp->status == 0) && (frame_len >= 11))
_rtw_memcpy(prsp->bssid, (pframe + 5), ETH_ALEN);
/* STA BSS Transition Candidate List provided,
and at least one NB report exist */
if (((prsp->status == 0) || (prsp->status == 6)) \
&& (frame_len >= 23)) {
struct wnm_btm_cant cant;
u8 *ptr, *pend;
u32 idx = 0;
ptr = pframe + 5;
if (prsp->status == 0)
ptr += ETH_ALEN;
pend = ptr + frame_len;
prsp->candidates_num = 0;
while (ptr < pend) {
if (*ptr != RTW_WLAN_ACTION_WNM_NB_RPT_ELEM)
break;
_rtw_memset(&cant, 0, sizeof(cant));
cant.nb_rpt.id = *ptr;
cant.nb_rpt.len = *(ptr + 1);
_rtw_memcpy(cant.nb_rpt.bssid, (ptr + 2), ETH_ALEN);
cant.nb_rpt.bss_info = *((u32 *)(ptr + 8));
cant.nb_rpt.reg_class = *(ptr + 12);
cant.nb_rpt.ch_num = *(ptr + 13);
cant.nb_rpt.phy_type= *(ptr + 14);
if (*(ptr + 15) == WNM_BTM_CAND_PREF_SUBEID)
cant.preference = *(ptr + 17);
ptr = ptr + cant.nb_rpt.len + 2;
if (prsp->pcandidates) {
prsp->candidates_num++;
_rtw_memcpy((prsp->pcandidates + \
sizeof(cant) * idx), &cant, sizeof(cant));
}
idx++;
RTW_WNM_INFO("WNM: btm rsp candidate bssid("MAC_FMT
") ,bss_info(0x%04X), reg_class(0x%02X), ch(%d),"
" phy_type(0x%02X), preference(0x%02X)\n",
MAC_ARG(cant.nb_rpt.bssid), cant.nb_rpt.bss_info,
cant.nb_rpt.reg_class, cant.nb_rpt.ch_num,
cant.nb_rpt.phy_type, cant.preference);
if ((prsp->pcandidates) && \
(prsp->candidates_num > 0)) {
RTW_WNM_DUMP("WNM candidates: ", prsp->pcandidates,
(sizeof(struct wnm_btm_cant) * prsp->candidates_num));
}
}
}
}
void rtw_wnm_hdr_init(_adapter *padapter,
struct xmit_frame *pactionframe, u8 *pmac,
u8 action, u8 **pcontent)
{
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct pkt_attrib *pattrib;
struct rtw_ieee80211_hdr *pwlanhdr;
u16 *pfctrl;
u8 category;
pattrib = &(pactionframe->attrib);
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pactionframe->buf_addr, 0,
(WLANHDR_OFFSET + TXDESC_OFFSET));
*pcontent = (u8 *)(pactionframe->buf_addr + TXDESC_OFFSET);
pwlanhdr = (struct rtw_ieee80211_hdr *)(*pcontent);
pfctrl = &(pwlanhdr->frame_ctl);
*(pfctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, pmac, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3,
get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(*pcontent, WIFI_ACTION);
*pcontent += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
category = RTW_WLAN_CATEGORY_WNM;
*pcontent = rtw_set_fixed_ie(*pcontent, 1,
&(category), &(pattrib->pktlen));
*pcontent = rtw_set_fixed_ie(*pcontent, 1,
&(action), &(pattrib->pktlen));
}
void rtw_wnm_build_btm_req_ies(_adapter *padapter,
u8 **pframe, struct pkt_attrib *pattrib,
struct btm_req_hdr *phdr, u8 *purl, u32 url_len,
u8 *pcandidates, u8 candidate_cnt)
{
int i;
*pframe = rtw_set_fixed_ie(*pframe, 1,
&phdr->dialog_token, &(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 1,
&phdr->req_mode, &(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 2,
(u8 *)&phdr->disassoc_timer, &(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 1,
&phdr->validity_interval, &(pattrib->pktlen));
if (phdr->req_mode & BSS_TERMINATION_INCLUDED) {
*pframe = rtw_set_fixed_ie(*pframe, 1,
&phdr->term_duration.id, &(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 1,
&phdr->term_duration.len, &(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 8,
(u8 *)&phdr->term_duration.tsf,
&(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 2,
(u8 *)&phdr->term_duration.duration,
&(pattrib->pktlen));
}
if ((purl != NULL) && (url_len > 0) &&
(phdr->req_mode & ESS_DISASSOC_IMMINENT)) {
*pframe = rtw_set_fixed_ie(*pframe, 1,
(u8 *)&url_len, &(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe,
url_len, purl, &(pattrib->pktlen));
}
if ((pcandidates != NULL) && (candidate_cnt > 0)) {
for (i=0; i<candidate_cnt; i++) {
struct wnm_btm_cant *pcandidate = \
((struct wnm_btm_cant *)pcandidates) + i;
struct nb_rpt_hdr *prpt = &(pcandidate->nb_rpt);
*pframe = rtw_set_fixed_ie(*pframe, 1,
&pcandidate->nb_rpt.id,
&(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 1,
&pcandidate->nb_rpt.len,
&(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, ETH_ALEN,
pcandidate->nb_rpt.bssid,
&(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 4,
(u8 *)&pcandidate->nb_rpt.bss_info,
&(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 1,
&pcandidate->nb_rpt.reg_class,
&(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 1,
&pcandidate->nb_rpt.ch_num,
&(pattrib->pktlen));
*pframe = rtw_set_fixed_ie(*pframe, 1,
&pcandidate->nb_rpt.phy_type,
&(pattrib->pktlen));
*pframe = rtw_set_ie(*pframe, WNM_BTM_CAND_PREF_SUBEID,
1, (u8 *)&pcandidate->preference,
&(pattrib->pktlen));
}
}
#ifdef CONFIG_RTW_MBO
rtw_mbo_build_wnm_btmreq_reason_ies(padapter, pframe, pattrib);
#endif
}
void rtw_wnm_issue_btm_req(_adapter *padapter,
u8 *pmac, struct btm_req_hdr *phdr,
u8 *purl, u32 url_len,
u8 *pcandidates, u8 candidate_cnt)
{
struct roam_nb_info *pnb = &(padapter->mlmepriv.nb_info);
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
u8 action, *pframe, dialog_token = 0;
if (!pmac || is_zero_mac_addr(pmac)
|| is_broadcast_mac_addr(pmac))
return ;
if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
return ;
rtw_wnm_hdr_init(padapter, pmgntframe, pmac,
RTW_WLAN_ACTION_WNM_BTM_REQ, &pframe);
pattrib = &(pmgntframe->attrib);
rtw_wnm_build_btm_req_ies(padapter, &pframe, pattrib,
phdr, purl, url_len, pcandidates, candidate_cnt);
if (0) {
u8 *__p = (u8 *)(pmgntframe->buf_addr + TXDESC_OFFSET);
RTW_WNM_DUMP("WNM BTM REQ :", __p, pattrib->pktlen);
}
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
/* dump_mgntframe_and_wait_ack(padapter, pmgntframe); */
RTW_INFO("WNM: BSS Transition Management Request sent\n");
}
void rtw_wnm_issue_action(_adapter *padapter,
u8 action, u8 reason, u8 dialog)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct xmit_frame *pmgntframe;
struct rtw_ieee80211_hdr *pwlanhdr;
struct pkt_attrib *pattrib;
u8 category, termination_delay, *pframe, dialog_token = 0;
#ifdef CONFIG_RTW_MBO
u8 mbo_trans_rej_res = 1; /* Unspecified reason */
u8 mbo_notif_req_type ;
#endif
u16 *fctrl;
if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
return ;
pattrib = &(pmgntframe->attrib);
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, (WLANHDR_OFFSET + TXDESC_OFFSET));
pframe = (u8 *)(pmgntframe->buf_addr + TXDESC_OFFSET);
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1,
get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2,
adapter_mac_addr(padapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3,
get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
category = RTW_WLAN_CATEGORY_WNM;
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
switch (action) {
case RTW_WLAN_ACTION_WNM_BTM_QUERY:
dialog_token++;
pframe = rtw_set_fixed_ie(pframe, 1,
&(dialog_token), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1,
&(reason), &(pattrib->pktlen));
RTW_INFO("WNM: BSS Transition Management Query sent\n");
break;
case RTW_WLAN_ACTION_WNM_BTM_RSP:
dialog_token = dialog;
termination_delay = 0;
pframe = rtw_set_fixed_ie(pframe, 1,
&(dialog_token), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1,
&(reason), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1,
&(termination_delay),
&(pattrib->pktlen));
if (!reason && !is_zero_mac_addr(
pmlmepriv->nb_info.roam_target_addr)) {
pframe = rtw_set_fixed_ie(pframe, 6,
pmlmepriv->nb_info.roam_target_addr,
&(pattrib->pktlen));
}
#ifdef CONFIG_RTW_MBO
rtw_mbo_build_trans_reject_reason_attr(padapter,
&pframe, pattrib, &mbo_trans_rej_res);
#endif
RTW_INFO("WNM: BSS Transition Management Response"
" sent(reason:%d)\n", reason);
break;
case RTW_WLAN_ACTION_WNM_NOTIF_REQ:
#ifdef CONFIG_RTW_MBO
dialog_token++;
mbo_notif_req_type = WLAN_EID_VENDOR_SPECIFIC;
pframe = rtw_set_fixed_ie(pframe, 1,
&(dialog_token),
&(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1,
&(mbo_notif_req_type),
&(pattrib->pktlen));
rtw_mbo_build_wnm_notification(padapter,
&pframe, pattrib);
RTW_INFO("WNM: Notification request sent\n");
#endif
break;
case RTW_WLAN_ACTION_WNM_NOTIF_RSP:
#ifdef CONFIG_RTW_MBO
dialog_token = dialog;
pframe = rtw_set_fixed_ie(pframe, 1,
&(dialog_token), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1,
&(reason), &(pattrib->pktlen));
RTW_INFO("WNM: Notification Response sent\n");
#endif
break;
default:
goto exit;
}
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
/* dump_mgntframe_and_wait_ack(padapter, pmgntframe); */
exit:
return;
}
/* argument req_ie@cfg80211_roamed()/cfg80211_connect_result()
is association request IEs format. if driver used reassoc-req format,
RSN IE could not be parsed @supplicant process */
void rtw_wnm_update_reassoc_req_ie(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
u32 dup_len, offset;
u8 *pdup;
if (!pmlmepriv->assoc_req || !pmlmepriv->assoc_req_len)
return;
/* total len is assoc req len without Current AP Field*/
dup_len = pmlmepriv->assoc_req_len - ETH_ALEN;
/* offset is a len of 80211 header +
capability(2B) + listen interval(2B) */
offset = sizeof(struct rtw_ieee80211_hdr_3addr) + 4;
pdup = rtw_zmalloc(dup_len);
if (pdup) {
/* remove Current AP Field @reassoc req IE */
_rtw_memcpy(pdup, pmlmepriv->assoc_req, offset);
_rtw_memcpy(pdup + offset,
pmlmepriv->assoc_req + offset + ETH_ALEN,
pmlmepriv->assoc_req_len - offset);
rtw_buf_update(&pmlmepriv->assoc_req,
&pmlmepriv->assoc_req_len, pdup, dup_len);
rtw_mfree(pdup, dup_len);
}
}
#endif /* CONFIG_RTW_WNM */
#if defined(CONFIG_RTW_WNM) || defined(CONFIG_RTW_80211K)
void rtw_roam_nb_info_init(_adapter *padapter)
{
struct roam_nb_info *pnb = &(padapter->mlmepriv.nb_info);
struct btm_rpt_cache *pcache = &(pnb->btm_cache);
_rtw_memset(&pnb->nb_rpt, 0, sizeof(pnb->nb_rpt));
_rtw_memset(&pnb->nb_rpt_ch_list, 0, sizeof(pnb->nb_rpt_ch_list));
_rtw_memset(&pnb->roam_target_addr, 0, ETH_ALEN);
pnb->nb_rpt_valid = _FALSE;
pnb->nb_rpt_ch_list_num = 0;
pnb->preference_en = _FALSE;
pnb->nb_rpt_is_same = _TRUE;
pnb->last_nb_rpt_entries = 0;
pnb->disassoc_waiting = -1;
#ifdef CONFIG_RTW_WNM
pnb->features = 0;
/* pnb->features |= RTW_WNM_FEATURE_BTM_REQ_EN; */
rtw_init_timer(&pnb->roam_scan_timer,
rtw_wnm_roam_scan_hdl,
padapter);
rtw_init_timer(&pnb->disassoc_chk_timer,
rtw_wnm_disassoc_chk_hdl,
padapter);
_rtw_memset(pcache, 0, sizeof(struct btm_rpt_cache));
pcache->validity_time = wnm_defualt_validity_time;
pcache->disassoc_time= wnm_default_disassoc_time ;
#endif
}
u8 rtw_roam_nb_scan_list_set(
_adapter *padapter, struct sitesurvey_parm *pparm)
{
u8 ret = _FALSE;
u32 i;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct roam_nb_info *pnb = &(pmlmepriv->nb_info);
#ifdef CONFIG_RTW_80211R
if (!rtw_chk_roam_flags(padapter, RTW_ROAM_ACTIVE)
&& !rtw_ft_chk_flags(padapter, RTW_FT_BTM_ROAM))
return ret;
#endif
if (!pmlmepriv->need_to_roam)
return ret;
if ((!pmlmepriv->nb_info.nb_rpt_valid) || (!pnb->nb_rpt_ch_list_num))
return ret;
if (!pparm)
return ret;
rtw_init_sitesurvey_parm(padapter, pparm);
if (rtw_roam_busy_scan(padapter, pnb)) {
pparm->ch_num = 1;
pparm->ch[pmlmepriv->ch_cnt].hw_value =
pnb->nb_rpt_ch_list[pmlmepriv->ch_cnt].hw_value;
pmlmepriv->ch_cnt++;
ret = _TRUE;
RTW_WNM_INFO("%s: ch_cnt=%u, (%u)hw_value=%u\n",
__func__, pparm->ch_num, pmlmepriv->ch_cnt,
pparm->ch[pmlmepriv->ch_cnt].hw_value);
if (pmlmepriv->ch_cnt == pnb->nb_rpt_ch_list_num) {
pmlmepriv->nb_info.nb_rpt_valid = _FALSE;
pmlmepriv->ch_cnt = 0;
}
goto set_bssid_list;
}
pparm->ch_num = (pnb->nb_rpt_ch_list_num > RTW_CHANNEL_SCAN_AMOUNT)?
(RTW_CHANNEL_SCAN_AMOUNT):(pnb->nb_rpt_ch_list_num);
for (i=0; i<pparm->ch_num; i++) {
pparm->ch[i].hw_value = pnb->nb_rpt_ch_list[i].hw_value;
pparm->ch[i].flags = RTW_IEEE80211_CHAN_PASSIVE_SCAN;
}
pmlmepriv->nb_info.nb_rpt_valid = _FALSE;
pmlmepriv->ch_cnt = 0;
ret = _TRUE;
set_bssid_list:
rtw_sitesurvey_cmd(padapter, pparm);
return ret;
}
static u8 rtw_wnm_nb_elem_parsing(
u8* pdata, u32 data_len, u8 from_btm,
u32 *nb_rpt_num, u8 *nb_rpt_is_same,
struct roam_nb_info *pnb, struct wnm_btm_cant *pcandidates)
{
u8 bfound = _FALSE, ret = _SUCCESS;
u8 *ptr, *pend, *op;
u32 elem_len, subelem_len, op_len;
u32 i, nb_rpt_entries = 0;
struct nb_rpt_hdr *pie;
struct wnm_btm_cant *pcandidate;
if ((!pdata) || (!pnb))
return _FAIL;
if ((from_btm) && (!pcandidates))
return _FAIL;
ptr = pdata;
pend = ptr + data_len;
elem_len = data_len;
subelem_len = (u32)*(pdata+1);
for (i=0; i < RTW_MAX_NB_RPT_NUM; i++) {
if (((ptr + 7) > pend) || (elem_len < subelem_len))
break;
if (*ptr != RTW_WLAN_ACTION_WNM_NB_RPT_ELEM) {
RTW_WNM_INFO("WNM: end of data(0x%2x)!\n", *ptr);
break;
}
pie = (struct nb_rpt_hdr *)ptr;
if (from_btm) {
op = rtw_get_ie((u8 *)(ptr+15),
WNM_BTM_CAND_PREF_SUBEID,
&op_len, (subelem_len - 15));
}
ptr = (u8 *)(ptr + subelem_len + 2);
elem_len -= (subelem_len +2);
subelem_len = *(ptr+1);
if (from_btm) {
pcandidate = (pcandidates + i);
_rtw_memcpy(&pcandidate->nb_rpt, pie,
sizeof(struct nb_rpt_hdr));
if (op && (op_len !=0)) {
pcandidate->preference = *(op + 2);
bfound = _TRUE;
} else
pcandidate->preference = 0;
RTW_WNM_INFO("WNM: preference check bssid("MAC_FMT
") ,bss_info(0x%04X), reg_class(0x%02X), ch(%d),"
" phy_type(0x%02X), preference(0x%02X)\n",
MAC_ARG(pcandidate->nb_rpt.bssid),
pcandidate->nb_rpt.bss_info,
pcandidate->nb_rpt.reg_class,
pcandidate->nb_rpt.ch_num,
pcandidate->nb_rpt.phy_type,
pcandidate->preference);
} else {
if (_rtw_memcmp(&pnb->nb_rpt[i], pie,
sizeof(struct nb_rpt_hdr)) == _FALSE)
*nb_rpt_is_same = _FALSE;
_rtw_memcpy(&pnb->nb_rpt[i], pie,
sizeof(struct nb_rpt_hdr));
}
nb_rpt_entries++;
}
if (from_btm)
pnb->preference_en = (bfound)?_TRUE:_FALSE;
*nb_rpt_num = nb_rpt_entries;
return ret;
}
/* selection sorting based on preference value
* IN : nb_rpt_entries - candidate num
* IN/OUT : pcandidates - candidate list
* return : TRUE - means pcandidates is updated.
*/
static u8 rtw_wnm_candidates_sorting(
u32 nb_rpt_entries, struct wnm_btm_cant *pcandidates)
{
u8 updated = _FALSE;
u32 i, j, pos;
struct wnm_btm_cant swap;
struct wnm_btm_cant *pcant_1, *pcant_2;
if ((!nb_rpt_entries) || (!pcandidates))
return updated;
for (i=0; i < (nb_rpt_entries - 1); i++) {
pos = i;
for (j=(i + 1); j < nb_rpt_entries; j++) {
pcant_1 = pcandidates+pos;
pcant_2 = pcandidates+j;
if ((pcant_1->preference) < (pcant_2->preference))
pos = j;
}
if (pos != i) {
updated = _TRUE;
_rtw_memcpy(&swap, (pcandidates+i),
sizeof(struct wnm_btm_cant));
_rtw_memcpy((pcandidates+i), (pcandidates+pos),
sizeof(struct wnm_btm_cant));
_rtw_memcpy((pcandidates+pos), &swap,
sizeof(struct wnm_btm_cant));
}
}
return updated;
}
static void rtw_wnm_nb_info_update(
u32 nb_rpt_entries, u8 from_btm,
struct roam_nb_info *pnb,
struct wnm_btm_cant *pcandidates,
u8 *nb_rpt_is_same)
{
u8 is_found;
u32 i, j;
struct wnm_btm_cant *pcand;
if (!pnb)
return;
pnb->nb_rpt_ch_list_num = 0;
for (i=0; i<nb_rpt_entries; i++) {
is_found = _FALSE;
if (from_btm) {
pcand = (pcandidates+i);
if (_rtw_memcmp(&pnb->nb_rpt[i], &pcand->nb_rpt,
sizeof(struct nb_rpt_hdr)) == _FALSE)
*nb_rpt_is_same = _FALSE;
_rtw_memcpy(&pnb->nb_rpt[i], &pcand->nb_rpt,
sizeof(struct nb_rpt_hdr));
}
RTW_WNM_INFO("WNM: bssid(" MAC_FMT
") , bss_info(0x%04X), reg_class(0x%02X),"
" ch_num(%d), phy_type(0x%02X)\n",
MAC_ARG(pnb->nb_rpt[i].bssid), pnb->nb_rpt[i].bss_info,
pnb->nb_rpt[i].reg_class, pnb->nb_rpt[i].ch_num,
pnb->nb_rpt[i].phy_type);
if (pnb->nb_rpt[i].ch_num == 0)
continue;
for (j=0; j<nb_rpt_entries; j++) {
if (pnb->nb_rpt[i].ch_num ==
pnb->nb_rpt_ch_list[j].hw_value) {
is_found = _TRUE;
break;
}
}
if (!is_found) {
pnb->nb_rpt_ch_list[pnb->nb_rpt_ch_list_num].hw_value =\
pnb->nb_rpt[i].ch_num;
pnb->nb_rpt_ch_list_num++;
}
}
}
static void rtw_wnm_btm_candidate_select(_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct roam_nb_info *pnb = &(padapter->mlmepriv.nb_info);
struct wlan_network *pnetwork;
u8 bfound = _FALSE;
u8 ignore_currrent = _FALSE;
u32 i;
#ifdef CONFIG_RTW_80211R
if (rtw_ft_chk_flags(padapter, RTW_FT_BTM_ROAM))
ignore_currrent = _TRUE;
#endif
for (i = 0; i < pnb->last_nb_rpt_entries; i++) {
if (ignore_currrent &&
(_rtw_memcmp(pnb->nb_rpt[i].bssid,\
padapter->mlmepriv.cur_network.network.MacAddress,
ETH_ALEN))) {
RTW_WNM_INFO("WNM : ignore candidate "MAC_FMT
" for it's connected(%u)!\n",
MAC_ARG(pnb->nb_rpt[i].bssid), i);
continue;
}
pnetwork = rtw_find_network(
&(pmlmepriv->scanned_queue),
pnb->nb_rpt[i].bssid);
if (pnetwork) {
bfound = _TRUE;
break;
}
}
if (bfound) {
_rtw_memcpy(pnb->roam_target_addr,
pnb->nb_rpt[i].bssid, ETH_ALEN);
RTW_INFO("WNM : select btm entry(%d) -"
" %s("MAC_FMT", ch:%u) rssi:%d\n"
, i
, pnetwork->network.Ssid.Ssid
, MAC_ARG(pnetwork->network.MacAddress)
, pnetwork->network.Configuration.DSConfig
, (int)pnetwork->network.PhyInfo.rssi);
} else
_rtw_memset(pnb->roam_target_addr,0, ETH_ALEN);
}
u32 rtw_wnm_btm_candidates_survey(
_adapter *padapter, u8* pframe, u32 elem_len, u8 from_btm)
{
struct roam_nb_info *pnb = &(padapter->mlmepriv.nb_info);
struct wnm_btm_cant *pcandidate_list = NULL;
u8 nb_rpt_is_same = _TRUE;
u32 ret = _FAIL;
u32 nb_rpt_entries = 0;
if (from_btm) {
u32 mlen = sizeof(struct wnm_btm_cant) * RTW_MAX_NB_RPT_NUM;
pcandidate_list = (struct wnm_btm_cant *)rtw_malloc(mlen);
if (pcandidate_list == NULL)
goto exit;
}
/*clean the status set last time*/
_rtw_memset(&pnb->nb_rpt_ch_list, 0, sizeof(pnb->nb_rpt_ch_list));
pnb->nb_rpt_valid = _FALSE;
if (!rtw_wnm_nb_elem_parsing(
pframe, elem_len, from_btm,
&nb_rpt_entries, &nb_rpt_is_same,
pnb, pcandidate_list))
goto exit;
if (nb_rpt_entries != 0) {
if ((from_btm) && (rtw_wnm_btm_preference_cap(padapter))) {
rtw_wnm_candidates_sorting(
nb_rpt_entries, pcandidate_list);
}
rtw_wnm_nb_info_update(
nb_rpt_entries, from_btm,
pnb, pcandidate_list, &nb_rpt_is_same);
}
RTW_WNM_INFO("nb_rpt_is_same = %d, nb_rpt_entries = %d,"
" last_nb_rpt_entries = %d\n",
nb_rpt_is_same, nb_rpt_entries,
pnb->last_nb_rpt_entries);
if ((nb_rpt_is_same == _TRUE) &&
(nb_rpt_entries == pnb->last_nb_rpt_entries)) {
pnb->nb_rpt_is_same = _TRUE;
} else {
pnb->nb_rpt_is_same = _FALSE;
pnb->last_nb_rpt_entries = nb_rpt_entries;
}
if ((from_btm) && (nb_rpt_entries != 0))
rtw_wnm_btm_candidate_select(padapter);
pnb->nb_rpt_valid = _TRUE;
ret = _SUCCESS;
exit:
if (from_btm && pcandidate_list) {
rtw_mfree((u8 *)pcandidate_list,
sizeof(struct wnm_btm_cant) * RTW_MAX_NB_RPT_NUM);
}
return ret;
}
void rtw_wnm_process_btm_query(_adapter *padapter, u8* pframe, u32 frame_len)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct nb_rpt_hdr *pie;
u8 *ptr, *pend, *op;
u32 elem_len, subelem_len, op_len;
u32 i, nb_rpt_entries = 0;
if (!pframe || !frame_len)
return;
/* no preferred bss transition candidate list include */
if (wnm_btm_query_reason(pframe) != 0x13)
return;
ptr = pframe + 4;
elem_len = frame_len - 4;
pend = ptr + elem_len;
subelem_len = (u32)*(ptr + 1);
RTW_WNM_DUMP("BTM QUERY :", ptr, elem_len);
for (i = 0; i < RTW_MAX_NB_RPT_NUM; i++) {
if (((ptr + 7) > pend) || (elem_len < subelem_len))
break;
if (*ptr != RTW_WLAN_ACTION_WNM_NB_RPT_ELEM)
break;
pie = (struct nb_rpt_hdr *)ptr;
op = rtw_get_ie((u8 *)(ptr+15), WNM_BTM_CAND_PREF_SUBEID,
&op_len, (subelem_len - 15));
#ifdef CONFIG_RTW_MBO
/* for debug only */
#if 0
if (rtw_mbo_wifi_logo_test(padapter) &&
check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) {
struct mbo_attr_info *pmbo_attr = \
&(pmlmepriv->mbo_attr);
struct mbo_user_btm_req_pkt *puser = \
&(pmbo_attr->user_raw);
struct wnm_btm_cant *puser_cant;
u8 j = 0, idx = 0, found = _FALSE;
for (j = 0; j < RTW_MAX_NB_RPT_NUM; j++) {
puser_cant = &puser->btm_cants[j];
if (_rtw_memcmp(pie->bssid,
puser_cant->nb_rpt.bssid, ETH_ALEN)) {
puser_cant->nb_rpt.bss_info = \
pie->bss_info;
puser_cant->nb_rpt.reg_class = \
pie->reg_class;
puser_cant->nb_rpt.ch_num = \
pie->ch_num;
puser_cant->nb_rpt.phy_type = \
pie->phy_type;
puser_cant->preference = \
*(op + 2);
idx = j;
found = _TRUE;
break;
}
}
if (!found) {
if (puser->candidate_cnt >= RTW_MAX_NB_RPT_NUM)
puser->candidate_cnt = 0;
puser_cant = \
&puser->btm_cants[puser->candidate_cnt];
puser_cant->nb_rpt.id = \
RTW_WLAN_ACTION_WNM_NB_RPT_ELEM;
puser_cant->nb_rpt.len = 0x10;
_rtw_memcpy(puser_cant->nb_rpt.bssid,
pie->bssid, ETH_ALEN);
puser_cant->nb_rpt.bss_info = \
pie->bss_info;
puser_cant->nb_rpt.reg_class = \
pie->reg_class;
puser_cant->nb_rpt.ch_num = \
pie->ch_num;
puser_cant->nb_rpt.phy_type = \
pie->phy_type;
puser_cant->preference = \
*(op + 2);
puser->candidate_cnt++;
}
RTW_WNM_INFO("%s: idx=%u, bssid("MAC_FMT"),"
" bss_info(0x%04X), reg_class(0x%02X),"
" ch(%d), phy_type(0x%02X), preference(0x%02X)\n",
__func__, (found)?idx:puser->candidate_cnt,
MAC_ARG(puser_cant->nb_rpt.bssid),
puser_cant->nb_rpt.bss_info,
puser_cant->nb_rpt.reg_class,
puser_cant->nb_rpt.ch_num,
puser_cant->nb_rpt.phy_type,
puser_cant->preference);
}
#endif
#endif /* end of CONFIG_RTW_MBO */
ptr = (u8 *)(ptr + subelem_len + 2);
elem_len -= (subelem_len +2);
subelem_len = *(ptr+1);
} /* end of for-loop RTW_MAX_NB_RPT_NUM */
}
static u8 *rtw_wnm_non_pref_ch_attr_get(u8 *pie, u32 *plen, u32 limit)
{
const u8 *p = pie;
u32 tmp, i;
if (limit <= 1)
return NULL;
i = 0;
*plen = 0;
while (1) {
if ((*p == _VENDOR_SPECIFIC_IE_) &&
(_rtw_memcmp(rtw_wnm_get_non_pref_ch_oui(p),
wnm_non_pref_ch_oui, 4))) {
*plen = *(p + 1);
return (u8 *)p;
} else {
tmp = *(p + 1);
p += (tmp + 2);
i += (tmp + 2);
}
if (i >= limit)
break;
}
return NULL;
}
void rtw_wnm_process_notification_req(
_adapter *padapter, u8 *pframe, u32 frame_len)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#ifdef CONFIG_RTW_MBO
struct mbo_attr_info *pmbo_attr = &(pmlmepriv->mbo_attr);
struct mbo_user_btm_req_pkt *puser_raw = &(pmbo_attr->user_raw);
#endif
struct wnm_btm_cant *pcant = NULL;
u8 dialog, type;
u8 *psubie;
u8 *ptr = NULL;
u32 left_len, subie_len;
if (!pframe || (frame_len < 5))
return;
/* RTW_WNM_DUMP("notify-req :", pframe, frame_len); */
dialog = *(pframe + 2);
type = *(pframe + 3);
if (type != WLAN_EID_VENDOR_SPECIFIC)
return;
ptr = (pframe + 4);
left_len = (frame_len - 4);
while((psubie = rtw_wnm_non_pref_ch_attr_get(
ptr, &subie_len, left_len)) != NULL) {
/* RTW_WNM_DUMP("notify-req subie :", (psubie + 2), subie_len); */
ptr += (subie_len + 2);
left_len -= (subie_len + 2);
#ifdef CONFIG_RTW_MBO
if (rtw_mbo_wifi_spec_test(padapter) && \
(subie_len > 7)) {
u8 *pload = NULL, *pclass = NULL;
u8 ch_nums = 0;
u8 non_pref_ch = 0;
u8 ch_op_pref = 1, reason = 0;
u32 i, j;
/* nums = sublen - oui_len -
(class_len - op_len - reason_len) */
ch_nums = subie_len - 4 - 3;
if (ch_nums >= RTW_MBO_MAX_CH_LIST_NUM)
ch_nums = RTW_MBO_MAX_CH_LIST_NUM;
/* skip sudid, len, oui */
pclass = (psubie + 6);
ch_op_pref = *(pclass + ch_nums + 1);
reason = *(pclass + ch_nums + 2);
RTW_WNM_INFO("%s : class=0x%02x, operating=0x%02x, "
"reason=0x%02x\n", __func__, *pclass,
ch_op_pref, reason);
for (i = 0; i < ch_nums; i++) {
non_pref_ch = *(pclass + 1 + i);
RTW_WNM_INFO("%s : non-pref ch %u "
"found in notify-req operating 0x%02x\n",
__func__, non_pref_ch, ch_op_pref);
for (j = 0; j < RTW_MAX_NB_RPT_NUM; j++) {
pcant = &puser_raw->btm_cants[j];
if (pcant->nb_rpt.ch_num == non_pref_ch) {
if (ch_op_pref == 0) {
RTW_WNM_INFO("%s : reset "
"preference(%u) for non-preference ch\n",
__func__, pcant->preference);
pcant->preference = 0;
} else {
if (!pcant->preference)
pcant->preference = 64;
}
}
} /* end of for loop RTW_MAX_NB_RPT_NUM */
} /* end of for loop ch_nums*/
}
#endif /* end of CONFIG_RTW_MB*/
} /* end of while loop */
rtw_wnm_issue_action(padapter,
RTW_WLAN_ACTION_WNM_NOTIF_RSP, 0, dialog);
}
#endif /*defined(CONFIG_RTW_WNM) || defined(CONFIG_RTW_80211K) */
|
2301_81045437/rtl8852be
|
core/rtw_wnm.c
|
C
|
agpl-3.0
| 39,208
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_WOW_C_
#include <drv_types.h>
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
#include <linux/inetdevice.h>
#define ETH_TYPE_OFFSET 12
#define PROTOCOL_OFFSET 23
#define IP_OFFSET 30
#define IPv6_OFFSET 38
#define IPv6_PROTOCOL_OFFSET 20
#endif
#ifdef CONFIG_WOWLAN
void rtw_init_wow(_adapter *padapter)
{
struct registry_priv *registry_par = &padapter->registrypriv;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
struct wow_priv *wowpriv = adapter_to_wowlan(padapter);
#ifdef CONFIG_GPIO_WAKEUP
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
void *phl = GET_PHL_INFO(dvobj);
enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
struct rtw_wow_gpio_info *wow_gpio = &wowpriv->wow_gpio;
u8 toggle_pulse = DEV2HST_TOGGLE, gpio_time_unit = 1, gpio_pulse_count = 3, gpio_pulse_period = 10, gpio_pulse_dura = 5;
u8 gpio_pulse_en_a = 0, customer_id = 0, gpio_duration_unit_a = 0, gpio_pulse_count_a = 0, gpio_duration_a = 0, special_reason_a = 0;
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER)
pwrctrlpriv->early_suspend.suspend = NULL;
rtw_register_early_suspend(pwrctrlpriv);
#endif /* CONFIG_HAS_EARLYSUSPEND || CONFIG_ANDROID_POWER */
pwrctrlpriv->wowlan_mode = _FALSE;
pwrctrlpriv->wowlan_ap_mode = _FALSE;
pwrctrlpriv->wowlan_p2p_mode = _FALSE;
pwrctrlpriv->wowlan_in_resume = _FALSE;
pwrctrlpriv->wowlan_last_wake_reason = 0;
#ifdef CONFIG_GPIO_WAKEUP
#ifdef ROKU_PRIVATE
gpio_pulse_en_a = DEV2HST_PULSE;
customer_id = 0x3f;
gpio_duration_unit_a = 1;
gpio_pulse_count_a = 1;
gpio_duration_a = 5;
special_reason_a = 0x21;
#endif /* ROKU_PRIVATE */
/*default low active*/
wow_gpio->gpio_active = HIGH_ACTIVE_DEV2HST;
pwrctrlpriv->hst2dev_high_active = HIGH_ACTIVE_HST2DEV;
wow_gpio->dev2hst_gpio = WAKEUP_GPIO_IDX;
wow_gpio->toggle_pulse = toggle_pulse;
wow_gpio->gpio_time_unit = gpio_time_unit;
wow_gpio->gpio_pulse_dura = gpio_pulse_dura;
wow_gpio->gpio_pulse_period = gpio_pulse_period;
wow_gpio->gpio_pulse_count = gpio_pulse_count;
wow_gpio->customer_id = customer_id;
wow_gpio->gpio_pulse_en_a = gpio_pulse_en_a;
wow_gpio->gpio_duration_unit_a = gpio_duration_unit_a;
wow_gpio->gpio_duration_a = gpio_duration_a;
wow_gpio->special_reason_a = special_reason_a;
wow_gpio->gpio_pulse_count_a = gpio_pulse_count_a;
#ifdef CONFIG_RTW_ONE_PIN_GPIO
wow_gpio->dev2hst_gpio_mode = RTW_AX_SW_IO_MODE_INPUT;
status = rtw_phl_cfg_wow_set_sw_gpio_mode(phl, wow_gpio);
#else
#ifdef CONFIG_WAKEUP_GPIO_INPUT_MODE
wow_gpio->dev2hst_gpio_mode = RTW_AX_SW_IO_MODE_OUTPUT_OD;
#else
wow_gpio->dev2hst_gpio_mode = RTW_AX_SW_IO_MODE_OUTPUT_PP;
#endif /*CONFIG_WAKEUP_GPIO_INPUT_MODE*/
/* switch GPIO to open-drain or push-pull */
status = rtw_phl_cfg_wow_set_sw_gpio_mode(phl, wow_gpio);
wow_gpio->dev2hst_high = wow_gpio->gpio_active == 0 ? 1 : 0;
status = rtw_phl_cfg_wow_sw_gpio_ctrl(phl, wow_gpio);
RTW_INFO("%s: set GPIO_%d %d as default. status=%d\n",
__func__, WAKEUP_GPIO_IDX, wow_gpio->dev2hst_high, status);
#endif /* CONFIG_RTW_ONE_PIN_GPIO */
#endif /* CONFIG_GPIO_WAKEUP */
#ifdef CONFIG_WOWLAN
#ifdef CONFIG_LPS_1T1R
#define WOW_LPS_1T1R_FMT ", WOW_LPS_1T1R=%d"
#define WOW_LPS_1T1R_ARG , pwrctrlpriv->wowlan_lps_1t1r
#else
#define WOW_LPS_1T1R_FMT ""
#define WOW_LPS_1T1R_ARG
#endif
pwrctrlpriv->wowlan_power_mgmt = padapter->registrypriv.wow_power_mgnt;
pwrctrlpriv->wowlan_lps_level = padapter->registrypriv.wow_lps_level;
#ifdef CONFIG_LPS_1T1R
pwrctrlpriv->wowlan_lps_1t1r = padapter->registrypriv.wow_lps_1t1r;
#endif
RTW_INFO("%s: WOW_LPS_mode=%d, WOW_LPS_level=%d"WOW_LPS_1T1R_FMT"\n",
__func__, pwrctrlpriv->wowlan_power_mgmt, pwrctrlpriv->wowlan_lps_level
WOW_LPS_1T1R_ARG
);
if (!(registry_par->wakeup_event & BIT(3)))
rtw_wow_pattern_clean(padapter, RTW_CUSTOMIZED_PATTERN);
rtw_wow_pattern_clean(padapter, RTW_DEFAULT_PATTERN);
#ifdef CONFIG_PNO_SUPPORT
pwrctrlpriv->pno_inited = _FALSE;
pwrctrlpriv->pnlo_info = NULL;
pwrctrlpriv->pscan_info = NULL;
pwrctrlpriv->pno_ssid_list = NULL;
#endif /* CONFIG_PNO_SUPPORT */
_rtw_mutex_init(&pwrctrlpriv->wowlan_pattern_cam_mutex);
pwrctrlpriv->wowlan_aoac_rpt_loc = 0;
#endif /* CONFIG_WOWLAN */
}
void rtw_free_wow(_adapter *adapter)
{
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(adapter);
#ifdef CONFIG_PNO_SUPPORT
if (pwrctrlpriv->pnlo_info != NULL)
printk("****** pnlo_info memory leak********\n");
if (pwrctrlpriv->pscan_info != NULL)
printk("****** pscan_info memory leak********\n");
if (pwrctrlpriv->pno_ssid_list != NULL)
printk("****** pno_ssid_list memory leak********\n");
#endif
_rtw_mutex_free(&pwrctrlpriv->wowlan_pattern_cam_mutex);
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER)
rtw_unregister_early_suspend(pwrctrlpriv);
#endif /* CONFIG_HAS_EARLYSUSPEND || CONFIG_ANDROID_POWER */
}
void rtw_wowlan_set_pattern_cast_type(_adapter *adapter, struct rtw_wowcam_upd_info *wowcam_info)
{
if (is_broadcast_mac_addr(wowcam_info->ptrn))
wowcam_info->bc = 1;
else if (is_multicast_mac_addr(wowcam_info->ptrn))
wowcam_info->mc = 1;
else if (!memcmp(wowcam_info->ptrn, adapter_mac_addr(adapter), ETH_ALEN))
wowcam_info->uc = 1;
}
inline bool _rtw_wow_chk_cap(_adapter *adapter, u8 cap)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct wow_ctl_t *wow_ctl = &dvobj->wow_ctl;
if (wow_ctl->wow_cap & cap)
return _TRUE;
return _FALSE;
}
bool rtw_wowlan_parser_pattern_cmd(u8 *input, char *pattern,
int *pattern_len, char *bit_mask)
{
char *cp = NULL;
size_t len = 0;
int pos = 0, mask_pos = 0, res = 0;
u8 member[2] = {0};
/* To get the pattern string after "=", when we use :
* iwpriv wlanX pattern=XX:XX:..:XX
*/
cp = strchr(input, '=');
if (cp) {
*cp = 0;
cp++;
input = cp;
}
/* To take off the newline character '\n'(0x0a) at the end of pattern string,
* when we use echo xxxx > /proc/xxxx
*/
cp = strchr(input, '\n');
if (cp)
*cp = 0;
while (input) {
cp = strsep((char **)(&input), ":");
if (bit_mask && (strcmp(cp, "-") == 0 ||
strcmp(cp, "xx") == 0 ||
strcmp(cp, "--") == 0)) {
/* skip this byte and leave mask bit unset */
} else {
u8 hex;
if (strlen(cp) != 2) {
RTW_ERR("%s:[ERROR] hex len != 2, input=[%s]\n",
__func__, cp);
goto error;
}
if (hexstr2bin(cp, &hex, 1) < 0) {
RTW_ERR("%s:[ERROR] pattern is invalid, input=[%s]\n",
__func__, cp);
goto error;
}
pattern[pos] = hex;
mask_pos = pos / 8;
if (bit_mask)
bit_mask[mask_pos] |= 1 << (pos % 8);
}
pos++;
}
(*pattern_len) = pos;
return _TRUE;
error:
return _FALSE;
}
u8 rtw_wow_pattern_set(_adapter *adapter, struct rtw_wowcam_upd_info *wowcam_info,
enum pattern_type set_type)
{
struct wow_priv *wowpriv = adapter_to_wowlan(adapter);
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
void *phl = GET_PHL_INFO(dvobj);
enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
u8 cam_idx = MAX_WKFM_CAM_NUM;
rtw_wowlan_set_pattern_cast_type(adapter, wowcam_info);
status = rtw_phl_add_wow_ptrn_info(phl, wowcam_info, &cam_idx);
if (status != RTW_PHL_STATUS_SUCCESS) {
RTW_INFO("Add wow pattern fail(%d)\n", status);
return _FAIL;
}
wowpriv->wow_ptrn_valid[cam_idx] = set_type;
RTW_INFO("wowcam_id: %d, type: %d\n", cam_idx, set_type);
return _SUCCESS;
}
void rtw_wow_pattern_clean(_adapter *adapter, enum pattern_type clean_type)
{
struct wow_priv *wowpriv = adapter_to_wowlan(adapter);
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
void *phl = GET_PHL_INFO(dvobj);
u8 cam_idx;
for (cam_idx = 0; cam_idx < MAX_WKFM_CAM_NUM; cam_idx++) {
if (wowpriv->wow_ptrn_valid[cam_idx] == clean_type) {
rtw_phl_remove_wow_ptrn_info(phl, cam_idx);
wowpriv->wow_ptrn_valid[cam_idx] = RTW_INVALID_PATTERN;
}
}
}
void rtw_set_default_pattern(_adapter *adapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
struct rtw_wowcam_upd_info wowcam_info = {0};
u8 index = 0;
u8 multicast_addr[3] = {0x01, 0x00, 0x5e};
u8 multicast_ip[4] = {0xe0, 0x28, 0x28, 0x2a};
u8 unicast_mask[5] = {0x3f, 0x70, 0x80, 0xc0, 0x03};
u8 icmpv6_mask[7] = {0x00, 0x70, 0x10, 0x00, 0xc0, 0xc0, 0x3f};
u8 multicast_mask[5] = {0x07, 0x70, 0x80, 0xc0, 0x03};
u8 ip_protocol[3] = {0x08, 0x00, 0x45};
u8 ipv6_protocol[3] = {0x86, 0xdd, 0x60};
u8 *target = NULL;
/*TCP/ICMP unicast*/
for (index = 0 ; index < DEFAULT_PATTERN_NUM ; index++) {
_rtw_memset((void *)&wowcam_info, 0, sizeof(wowcam_info));
switch (index) {
case 0:
target = wowcam_info.ptrn;
_rtw_memcpy(target, adapter_mac_addr(adapter), ETH_ALEN);
target += ETH_TYPE_OFFSET;
_rtw_memcpy(target, &ip_protocol, sizeof(ip_protocol));
/* TCP */
target += (PROTOCOL_OFFSET - ETH_TYPE_OFFSET);
_rtw_memset(target, 0x06, 1);
target += (IP_OFFSET - PROTOCOL_OFFSET);
_rtw_memcpy(target, pmlmeinfo->ip_addr, RTW_IP_ADDR_LEN);
_rtw_memcpy(wowcam_info.mask,
&unicast_mask, sizeof(unicast_mask));
wowcam_info.ptrn_len = IP_OFFSET + RTW_IP_ADDR_LEN;
rtw_wow_pattern_set(adapter, &wowcam_info, RTW_DEFAULT_PATTERN);
break;
case 1:
target = wowcam_info.ptrn;
_rtw_memcpy(target, adapter_mac_addr(adapter), ETH_ALEN);
target += ETH_TYPE_OFFSET;
_rtw_memcpy(target, &ip_protocol, sizeof(ip_protocol));
/* ICMP */
target += (PROTOCOL_OFFSET - ETH_TYPE_OFFSET);
_rtw_memset(target, 0x01, 1);
target += (IP_OFFSET - PROTOCOL_OFFSET);
_rtw_memcpy(target, pmlmeinfo->ip_addr, RTW_IP_ADDR_LEN);
_rtw_memcpy(wowcam_info.mask,
&unicast_mask, sizeof(unicast_mask));
wowcam_info.ptrn_len = IP_OFFSET + RTW_IP_ADDR_LEN;
rtw_wow_pattern_set(adapter, &wowcam_info, RTW_DEFAULT_PATTERN);
break;
#ifdef CONFIG_IPV6
case 2:
if (pwrpriv->wowlan_ns_offload_en == _TRUE) {
target = wowcam_info.ptrn;
target += ETH_TYPE_OFFSET;
_rtw_memcpy(target, &ipv6_protocol,
sizeof(ipv6_protocol));
/* ICMPv6 */
target += (IPv6_PROTOCOL_OFFSET -
ETH_TYPE_OFFSET);
_rtw_memset(target, 0x3a, 1);
target += (IPv6_OFFSET - IPv6_PROTOCOL_OFFSET);
_rtw_memcpy(target, pmlmeinfo->ip6_addr,
RTW_IPv6_ADDR_LEN);
_rtw_memcpy(wowcam_info.mask,
&icmpv6_mask, sizeof(icmpv6_mask));
wowcam_info.ptrn_len = IPv6_OFFSET + RTW_IPv6_ADDR_LEN;
rtw_wow_pattern_set(adapter, &wowcam_info,
RTW_DEFAULT_PATTERN);
}
break;
#endif /*CONFIG_IPV6*/
case 3:
target = wowcam_info.ptrn;
_rtw_memcpy(target, &multicast_addr, sizeof(multicast_addr));
target += ETH_TYPE_OFFSET;
_rtw_memcpy(target, &ip_protocol, sizeof(ip_protocol));
/* UDP */
target += (PROTOCOL_OFFSET - ETH_TYPE_OFFSET);
_rtw_memset(target, 0x11, 1);
target += (IP_OFFSET - PROTOCOL_OFFSET);
_rtw_memcpy(target, &multicast_ip, sizeof(multicast_ip));
_rtw_memcpy(wowcam_info.mask,
&multicast_mask, sizeof(multicast_mask));
wowcam_info.ptrn_len = IP_OFFSET + sizeof(multicast_ip);
rtw_wow_pattern_set(adapter, &wowcam_info, RTW_DEFAULT_PATTERN);
break;
default:
break;
}
}
return;
}
void rtw_dump_priv_pattern(_adapter *adapter, u8 idx)
{
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(adapter);
char str_1[128];
char *p_str;
u8 val8 = 0;
int i = 0, j = 0, len = 0, max_len = 0;
RTW_INFO("=========[%d]========\n", idx);
RTW_INFO(">>>priv_pattern_content:\n");
p_str = str_1;
max_len = sizeof(str_1);
for (i = 0 ; i < MAX_WKFM_PATTERN_SIZE / 8 ; i++) {
_rtw_memset(p_str, 0, max_len);
len = 0;
for (j = 0 ; j < 8 ; j++) {
val8 = pwrctl->patterns[idx].content[i * 8 + j];
len += snprintf(p_str + len, max_len - len,
"%02x ", val8);
}
RTW_INFO("%s\n", p_str);
}
RTW_INFO(">>>priv_pattern_mask:\n");
for (i = 0 ; i < MAX_WKFM_SIZE / 8 ; i++) {
_rtw_memset(p_str, 0, max_len);
len = 0;
for (j = 0 ; j < 8 ; j++) {
val8 = pwrctl->patterns[idx].mask[i * 8 + j];
len += snprintf(p_str + len, max_len - len,
"%02x ", val8);
}
RTW_INFO("%s\n", p_str);
}
RTW_INFO(">>>priv_pattern_len:\n");
RTW_INFO("%s: len: %d\n", __func__, pwrctl->patterns[idx].len);
}
void rtw_wow_pattern_sw_dump(_adapter *adapter)
{
int i;
RTW_INFO("********[RTK priv-patterns]*********\n");
for (i = 0 ; i < MAX_WKFM_CAM_NUM; i++)
rtw_dump_priv_pattern(adapter, i);
}
void rtw_get_sec_iv(_adapter *padapter, u8 *pcur_dot11txpn, u8 *StaAddr)
{
struct sta_info *psta;
struct security_priv *psecpriv = &padapter->securitypriv;
_rtw_memset(pcur_dot11txpn, 0, 8);
if (NULL == StaAddr)
return;
psta = rtw_get_stainfo(&padapter->stapriv, StaAddr);
RTW_INFO("%s(): StaAddr: %02x %02x %02x %02x %02x %02x\n",
__func__, StaAddr[0], StaAddr[1], StaAddr[2],
StaAddr[3], StaAddr[4], StaAddr[5]);
if (psta) {
if ((psecpriv->dot11PrivacyAlgrthm == _AES_) ||
(psecpriv->dot11PrivacyAlgrthm == _CCMP_256_))
AES_IV(pcur_dot11txpn, psta->dot11txpn, 0);
else if (psecpriv->dot11PrivacyAlgrthm == _TKIP_)
TKIP_IV(pcur_dot11txpn, psta->dot11txpn, 0);
else if ((psecpriv->dot11PrivacyAlgrthm == _GCMP_) ||
(psecpriv->dot11PrivacyAlgrthm == _GCMP_256_))
GCMP_IV(pcur_dot11txpn, psta->dot11txpn, 0);
}
}
void rtw_construct_remote_control_info(_adapter *adapter,
struct rtw_remote_wake_ctrl_info *ctrl_info)
{
struct security_priv *securitypriv = &adapter->securitypriv;
struct stainfo_rxcache *rxcache = NULL;
struct sta_info *sta = NULL;
u8 gtk_rx_iv[4][IV_LENGTH] = {0};
u8 tid_id = 0;
u8 i = 0;
sta = rtw_get_stainfo(&adapter->stapriv, get_bssid(&adapter->mlmepriv));
if (!sta) {
rtw_warn_on(1);
return;
}
rxcache = &sta->sta_recvpriv.rxcache;
rtw_get_sec_iv(adapter, ctrl_info->ptk_tx_iv, get_bssid(&adapter->mlmepriv));
RTW_INFO("[wow] ptk_tx_iv = " IV_FMT "\n", IV_ARG(ctrl_info->ptk_tx_iv));
ctrl_info->valid_check = REMOTECTRL_INFO_VALID_CHECK;
ctrl_info->symbol_check_en |= REMOTECTRL_INFO_SYMBOL_CHK_PTK |
REMOTECTRL_INFO_SYMBOL_CHK_GTK;
ctrl_info->gtk_key_idx = securitypriv->dot118021XGrpKeyid;
RTW_INFO("[wow] gtk_key_idx = %d\n", ctrl_info->gtk_key_idx);
tid_id = rxcache->last_tid;
_rtw_memcpy(ctrl_info->ptk_rx_iv, rxcache->iv[tid_id], IV_LENGTH);
RTW_INFO("[wow] ptk_rx_iv = " IV_FMT "\n", IV_ARG(ctrl_info->ptk_rx_iv));
for (i = 0; i < 4; i++) {
rtw_pn_to_iv(securitypriv->iv_seq[i], gtk_rx_iv[i], i,
securitypriv->dot118021XGrpPrivacy);
RTW_INFO("[wow] gtk_rx_iv[%u] = " IV_FMT "\n", i, IV_ARG(gtk_rx_iv[i]));
}
_rtw_memcpy(ctrl_info->gtk_rx_iv_idx0, gtk_rx_iv[0], IV_LENGTH);
_rtw_memcpy(ctrl_info->gtk_rx_iv_idx1, gtk_rx_iv[1], IV_LENGTH);
_rtw_memcpy(ctrl_info->gtk_rx_iv_idx2, gtk_rx_iv[2], IV_LENGTH);
_rtw_memcpy(ctrl_info->gtk_rx_iv_idx3, gtk_rx_iv[3], IV_LENGTH);
}
void rtw_wow_lps_level_decide(_adapter *adapter, u8 wow_en)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
if (wow_en) {
pwrpriv->lps_level_bk = pwrpriv->lps_level;
pwrpriv->lps_level = pwrpriv->wowlan_lps_level;
#ifdef CONFIG_LPS_1T1R
pwrpriv->lps_1t1r_bk = pwrpriv->lps_1t1r;
pwrpriv->lps_1t1r = pwrpriv->wowlan_lps_1t1r;
#endif
} else {
pwrpriv->lps_level = pwrpriv->lps_level_bk;
#ifdef CONFIG_LPS_1T1R
pwrpriv->lps_1t1r = pwrpriv->lps_1t1r_bk;
#endif
}
}
int rtw_pm_set_wow_lps(_adapter *padapter, u8 mode)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (mode < PM_PS_MODE_NUM) {
if (pwrctrlpriv->wowlan_power_mgmt != mode)
pwrctrlpriv->wowlan_power_mgmt = mode;
} else
ret = -EINVAL;
return ret;
}
int rtw_pm_set_wow_lps_level(_adapter *padapter, u8 level)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (level < LPS_LEVEL_MAX)
pwrctrlpriv->wowlan_lps_level = level;
else
ret = -EINVAL;
return ret;
}
#ifdef CONFIG_LPS_1T1R
int rtw_pm_set_wow_lps_1t1r(_adapter *padapter, u8 en)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
en = en ? 1 : 0;
pwrctrlpriv->wowlan_lps_1t1r = en;
return ret;
}
#endif /* CONFIG_LPS_1T1R */
#ifdef CONFIG_GTK_OL
void _update_aoac_rpt_phase_0(_adapter *adapter, struct rtw_aoac_report *aoac_info)
{
struct security_priv *securitypriv = &adapter->securitypriv;
struct stainfo_rxcache *rxcache = NULL;
struct sta_info *sta = NULL;
u8 pn[8] = {0};
u8 gtk_key_idx = 0;
u8 i = 0;
/* handle ptk rx iv */
/* This Rx IV has no effect, the driver does not drop unicast packets
* due to different PNs. (Refer to recv_ucast_pn_decache)
*/
sta = rtw_get_stainfo(&adapter->stapriv, get_bssid(&adapter->mlmepriv));
if (sta) {
if (rtw_iv_to_pn(aoac_info->ptk_rx_iv, pn, NULL,
securitypriv->dot11PrivacyAlgrthm)) {
rxcache = &sta->sta_recvpriv.rxcache;
for (i = 0; i < TID_NUM; i++)
_rtw_memcpy(rxcache->iv[i], aoac_info->ptk_rx_iv,
IV_LENGTH);
sta->dot11rxpn.val = RTW_GET_LE64(pn);
RTW_INFO("[wow] ptk_rx_pn = " PN_FMT "\n", PN_ARG(pn));
}
}
/* handle gtk rx iv */
gtk_key_idx = aoac_info->key_idx;
if (rtw_iv_to_pn(aoac_info->gtk_rx_iv[gtk_key_idx], pn, NULL,
securitypriv->dot118021XGrpPrivacy)) {
_rtw_memcpy(securitypriv->iv_seq[gtk_key_idx], pn, 8);
RTW_INFO("[wow] gtk_rx_pn[%u] = " PN_FMT "\n", gtk_key_idx, PN_ARG(pn));
}
}
void _update_aoac_rpt_phase_1(_adapter *adapter, struct rtw_aoac_report *aoac_info)
{
struct security_priv *securitypriv = &adapter->securitypriv;
struct sta_info *sta = NULL;
u8 pn[8] = {0};
u8 gtk_key_idx = 0;
u8 key_len = 0;
u8 i = 0;
/* handle ptk tx iv */
sta = rtw_get_stainfo(&adapter->stapriv, get_bssid(&adapter->mlmepriv));
if (sta) {
if (rtw_iv_to_pn(aoac_info->ptk_tx_iv, pn, NULL,
securitypriv->dot11PrivacyAlgrthm)) {
sta->dot11txpn.val = RTW_GET_LE64(pn);
RTW_INFO("[wow] ptk_tx_pn = " PN_FMT "\n", PN_ARG(pn));
}
}
if (aoac_info->rekey_ok) {
/* update gtk key */
gtk_key_idx = aoac_info->key_idx;
securitypriv->dot118021XGrpKeyid = gtk_key_idx;
switch (securitypriv->dot118021XGrpPrivacy) {
case _TKIP_:
case _AES_:
case _GCMP_:
key_len = 16;
break;
case _GCMP_256_:
case _CCMP_256_:
key_len = 32;
break;
default:
key_len = 0;
}
if (key_len)
_rtw_memcpy(securitypriv->dot118021XGrpKey[gtk_key_idx].skey,
aoac_info->gtk, key_len);
/* update tkip dot118021XGrptxmickey dot118021XGrprxmickey */
if (securitypriv->dot118021XGrpPrivacy == _TKIP_) {
/* The order of the GTK Tx/Rx mic keys in the AOAC report is
* reversed compared to the GTK Tx/Rx mic keys provided by
* wpa_supplicant.
*/
_rtw_memcpy(securitypriv->dot118021XGrptxmickey[gtk_key_idx].skey,
&aoac_info->gtk[24], 8);
_rtw_memcpy(securitypriv->dot118021XGrprxmickey[gtk_key_idx].skey,
&aoac_info->gtk[16], 8);
}
rtw_set_key(adapter, securitypriv, gtk_key_idx, 1, _TRUE);
/* update eapol replay_counter */
_rtw_memcpy(sta->replay_ctr, aoac_info->eapol_key_replay_count,
RTW_REPLAY_CTR_LEN);
} else {
RTW_INFO("[wow] no rekey event\n");
}
for (i = 0; i < 4; i++) {
if (rtw_iv_to_pn(aoac_info->gtk_rx_iv[i], pn, NULL,
securitypriv->dot118021XGrpPrivacy)) {
_rtw_memcpy(securitypriv->iv_seq[i], pn, 8);
RTW_INFO("[wow] gtk_rx_pn[%u] = " PN_FMT "\n", i, PN_ARG(pn));
}
}
}
void rtw_update_gtk_ofld_info(void *drv_priv, struct rtw_aoac_report *aoac_info,
u8 aoac_report_get_ok, u8 rx_ready)
{
struct dvobj_priv *dvobj = (struct dvobj_priv *)drv_priv;
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
if (!rx_ready)
_update_aoac_rpt_phase_0(adapter, aoac_info);
else
_update_aoac_rpt_phase_1(adapter, aoac_info);
}
#endif /* CONFIG_GTK_OL */
#endif /* CONFIG_WOWLAN */
#ifdef CONFIG_PNO_SUPPORT
#define CSCAN_TLV_TYPE_SSID_IE 'S'
#define CIPHER_IE "key_mgmt="
#define CIPHER_NONE "NONE"
#define CIPHER_WPA_PSK "WPA-PSK"
#define CIPHER_WPA_EAP "WPA-EAP IEEE8021X"
/*
* SSIDs list parsing from cscan tlv list
*/
int rtw_parse_ssid_list_tlv(char **list_str, pno_ssid_t *ssid,
int max, int *bytes_left)
{
char *str;
int idx = 0;
if ((list_str == NULL) || (*list_str == NULL) || (*bytes_left < 0)) {
RTW_INFO("%s error paramters\n", __func__);
return -1;
}
str = *list_str;
while (*bytes_left > 0) {
if (str[0] != CSCAN_TLV_TYPE_SSID_IE) {
*list_str = str;
RTW_INFO("nssid=%d left_parse=%d %d\n", idx, *bytes_left, str[0]);
return idx;
}
/* Get proper CSCAN_TLV_TYPE_SSID_IE */
*bytes_left -= 1;
str += 1;
if (str[0] == 0) {
/* Broadcast SSID */
ssid[idx].SSID_len = 0;
_rtw_memset((char *)ssid[idx].SSID, 0x0, WLAN_SSID_MAXLEN);
*bytes_left -= 1;
str += 1;
RTW_INFO("BROADCAST SCAN left=%d\n", *bytes_left);
} else if (str[0] <= WLAN_SSID_MAXLEN) {
/* Get proper SSID size */
ssid[idx].SSID_len = str[0];
*bytes_left -= 1;
str += 1;
/* Get SSID */
if (ssid[idx].SSID_len > *bytes_left) {
RTW_INFO("%s out of memory range len=%d but left=%d\n",
__func__, ssid[idx].SSID_len, *bytes_left);
return -1;
}
_rtw_memcpy((char *)ssid[idx].SSID, str, ssid[idx].SSID_len);
*bytes_left -= ssid[idx].SSID_len;
str += ssid[idx].SSID_len;
RTW_INFO("%s :size=%d left=%d\n",
(char *)ssid[idx].SSID, ssid[idx].SSID_len, *bytes_left);
} else {
RTW_INFO("### SSID size more that %d\n", str[0]);
return -1;
}
if (idx++ > max) {
RTW_INFO("%s number of SSIDs more that %d\n", __func__, idx);
return -1;
}
}
*list_str = str;
return idx;
}
int rtw_parse_cipher_list(struct pno_nlo_info *nlo_info, char *list_str)
{
char *pch, *pnext, *pend;
u8 key_len = 0, index = 0;
pch = list_str;
if (nlo_info == NULL || list_str == NULL) {
RTW_INFO("%s error paramters\n", __func__);
return -1;
}
while (strlen(pch) != 0) {
pnext = strstr(pch, "key_mgmt=");
if (pnext != NULL) {
pch = pnext + strlen(CIPHER_IE);
pend = strstr(pch, "}");
if (strncmp(pch, CIPHER_NONE,
strlen(CIPHER_NONE)) == 0)
nlo_info->ssid_cipher_info[index] = 0x00;
else if (strncmp(pch, CIPHER_WPA_PSK,
strlen(CIPHER_WPA_PSK)) == 0)
nlo_info->ssid_cipher_info[index] = 0x66;
else if (strncmp(pch, CIPHER_WPA_EAP,
strlen(CIPHER_WPA_EAP)) == 0)
nlo_info->ssid_cipher_info[index] = 0x01;
index++;
pch = pend + 1;
} else
break;
}
return 0;
}
int rtw_dev_nlo_info_set(struct pno_nlo_info *nlo_info, pno_ssid_t *ssid,
int num, int pno_time, int pno_repeat, int pno_freq_expo_max)
{
int i = 0;
struct file *fp;
mm_segment_t fs;
loff_t pos = 0;
u8 *source = NULL;
long len = 0;
RTW_INFO("+%s+\n", __func__);
nlo_info->fast_scan_period = pno_time;
nlo_info->ssid_num = num & BIT_LEN_MASK_32(8);
nlo_info->hidden_ssid_num = num & BIT_LEN_MASK_32(8);
nlo_info->slow_scan_period = (pno_time * 2);
nlo_info->fast_scan_iterations = 5;
if (nlo_info->hidden_ssid_num > 8)
nlo_info->hidden_ssid_num = 8;
/* TODO: channel list and probe index is all empty. */
for (i = 0 ; i < num ; i++) {
nlo_info->ssid_length[i]
= ssid[i].SSID_len;
}
/* cipher array */
fp = filp_open("/data/misc/wifi/wpa_supplicant.conf", O_RDONLY, 0644);
if (IS_ERR(fp)) {
RTW_INFO("Error, wpa_supplicant.conf doesn't exist.\n");
RTW_INFO("Error, cipher array using default value.\n");
return 0;
}
len = i_size_read(fp->f_path.dentry->d_inode);
if (len < 0 || len > 2048) {
RTW_INFO("Error, file size is bigger than 2048.\n");
RTW_INFO("Error, cipher array using default value.\n");
return 0;
}
fs = get_fs();
set_fs(KERNEL_DS);
source = rtw_zmalloc(2048);
if (source != NULL) {
len = vfs_read(fp, source, len, &pos);
rtw_parse_cipher_list(nlo_info, source);
rtw_mfree(source, 2048);
}
set_fs(fs);
filp_close(fp, NULL);
RTW_INFO("-%s-\n", __func__);
return 0;
}
int rtw_dev_ssid_list_set(struct pno_ssid_list *pno_ssid_list,
pno_ssid_t *ssid, u8 num)
{
int i = 0;
if (num > MAX_PNO_LIST_COUNT)
num = MAX_PNO_LIST_COUNT;
for (i = 0 ; i < num ; i++) {
_rtw_memcpy(&pno_ssid_list->node[i].SSID,
ssid[i].SSID, ssid[i].SSID_len);
pno_ssid_list->node[i].SSID_len = ssid[i].SSID_len;
}
return 0;
}
int rtw_dev_scan_info_set(_adapter *padapter, pno_ssid_t *ssid,
unsigned char ch, unsigned char ch_offset, unsigned short bw_mode)
{
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
struct pno_scan_info *scan_info = pwrctl->pscan_info;
u8 band = ch <= 14 ? BAND_ON_24G : BAND_ON_5G;
int i;
scan_info->channel_num = MAX_SCAN_LIST_COUNT;
scan_info->orig_ch = ch;
scan_info->orig_bw = bw_mode;
scan_info->orig_40_offset = ch_offset;
for (i = 0 ; i < scan_info->channel_num ; i++) {
if (i < 11)
scan_info->ssid_channel_info[i].active = 1;
else
scan_info->ssid_channel_info[i].active = 0;
scan_info->ssid_channel_info[i].timeout = 100;
scan_info->ssid_channel_info[i].tx_power =
phy_get_tx_power_index_ex(padapter, 0, CCK, MGN_1M, bw_mode, band, i + 1);
scan_info->ssid_channel_info[i].channel = i + 1;
}
RTW_INFO("%s, channel_num: %d, orig_ch: %d, orig_bw: %d orig_40_offset: %d\n",
__func__, scan_info->channel_num, scan_info->orig_ch,
scan_info->orig_bw, scan_info->orig_40_offset);
return 0;
}
int rtw_dev_pno_set(struct net_device *net, pno_ssid_t *ssid, int num,
int pno_time, int pno_repeat, int pno_freq_expo_max)
{
_adapter *padapter = (_adapter *)rtw_netdev_priv(net);
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
int ret = -1;
if (num == 0) {
RTW_INFO("%s, nssid is zero, no need to setup pno ssid list\n", __func__);
return 0;
}
if (pwrctl == NULL) {
RTW_INFO("%s, ERROR: pwrctl is NULL\n", __func__);
return -1;
} else {
pwrctl->pnlo_info =
(pno_nlo_info_t *)rtw_zmalloc(sizeof(pno_nlo_info_t));
pwrctl->pno_ssid_list =
(pno_ssid_list_t *)rtw_zmalloc(sizeof(pno_ssid_list_t));
pwrctl->pscan_info =
(pno_scan_info_t *)rtw_zmalloc(sizeof(pno_scan_info_t));
}
if (pwrctl->pnlo_info == NULL ||
pwrctl->pscan_info == NULL ||
pwrctl->pno_ssid_list == NULL) {
RTW_INFO("%s, ERROR: alloc nlo_info, ssid_list, scan_info fail\n", __func__);
goto failing;
}
pwrctl->wowlan_in_resume = _FALSE;
pwrctl->pno_inited = _TRUE;
/* NLO Info */
ret = rtw_dev_nlo_info_set(pwrctl->pnlo_info, ssid, num,
pno_time, pno_repeat, pno_freq_expo_max);
/* SSID Info */
ret = rtw_dev_ssid_list_set(pwrctl->pno_ssid_list, ssid, num);
/* SCAN Info */
ret = rtw_dev_scan_info_set(padapter, ssid, pmlmeext->chandef.chan,
pmlmeext->chandef.offset, pmlmeext->chandef.bw);
RTW_INFO("+%s num: %d, pno_time: %d, pno_repeat:%d, pno_freq_expo_max:%d+\n",
__func__, num, pno_time, pno_repeat, pno_freq_expo_max);
return 0;
failing:
if (pwrctl->pnlo_info) {
rtw_mfree((u8 *)pwrctl->pnlo_info, sizeof(pno_nlo_info_t));
pwrctl->pnlo_info = NULL;
}
if (pwrctl->pno_ssid_list) {
rtw_mfree((u8 *)pwrctl->pno_ssid_list, sizeof(pno_ssid_list_t));
pwrctl->pno_ssid_list = NULL;
}
if (pwrctl->pscan_info) {
rtw_mfree((u8 *)pwrctl->pscan_info, sizeof(pno_scan_info_t));
pwrctl->pscan_info = NULL;
}
return -1;
}
#ifdef CONFIG_PNO_SET_DEBUG
void rtw_dev_pno_debug(struct net_device *net)
{
_adapter *padapter = (_adapter *)rtw_netdev_priv(net);
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
int i = 0, j = 0;
RTW_INFO("*******NLO_INFO********\n");
RTW_INFO("ssid_num: %d\n", pwrctl->pnlo_info->ssid_num);
RTW_INFO("fast_scan_iterations: %d\n",
pwrctl->pnlo_info->fast_scan_iterations);
RTW_INFO("fast_scan_period: %d\n", pwrctl->pnlo_info->fast_scan_period);
RTW_INFO("slow_scan_period: %d\n", pwrctl->pnlo_info->slow_scan_period);
for (i = 0 ; i < MAX_PNO_LIST_COUNT ; i++) {
RTW_INFO("%d SSID (%s) length (%d) cipher(%x) channel(%d)\n",
i, pwrctl->pno_ssid_list->node[i].SSID, pwrctl->pnlo_info->ssid_length[i],
pwrctl->pnlo_info->ssid_cipher_info[i], pwrctl->pnlo_info->ssid_channel_info[i]);
}
RTW_INFO("******SCAN_INFO******\n");
RTW_INFO("ch_num: %d\n", pwrctl->pscan_info->channel_num);
RTW_INFO("orig_ch: %d\n", pwrctl->pscan_info->orig_ch);
RTW_INFO("orig bw: %d\n", pwrctl->pscan_info->orig_bw);
RTW_INFO("orig 40 offset: %d\n", pwrctl->pscan_info->orig_40_offset);
for (i = 0 ; i < MAX_SCAN_LIST_COUNT ; i++) {
RTW_INFO("[%02d] avtive:%d, timeout:%d, tx_power:%d, ch:%02d\n",
i, pwrctl->pscan_info->ssid_channel_info[i].active,
pwrctl->pscan_info->ssid_channel_info[i].timeout,
pwrctl->pscan_info->ssid_channel_info[i].tx_power,
pwrctl->pscan_info->ssid_channel_info[i].channel);
}
RTW_INFO("*****************\n");
}
#endif /* CONFIG_PNO_SET_DEBUG */
#endif /* CONFIG_PNO_SUPPORT */
|
2301_81045437/rtl8852be
|
core/rtw_wow.c
|
C
|
agpl-3.0
| 29,529
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_XMIT_C_
#include <drv_types.h>
static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
static void _init_txservq(struct tx_servq *ptxservq)
{
_rtw_init_listhead(&ptxservq->tx_pending);
_rtw_init_queue(&ptxservq->sta_pending);
ptxservq->qcnt = 0;
}
void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv)
{
_rtw_memset((unsigned char *)psta_xmitpriv, 0, sizeof(struct sta_xmit_priv));
_rtw_spinlock_init(&psta_xmitpriv->lock);
/* for(i = 0 ; i < MAX_NUMBLKS; i++) */
/* _init_txservq(&(psta_xmitpriv->blk_q[i])); */
_init_txservq(&psta_xmitpriv->be_q);
_init_txservq(&psta_xmitpriv->bk_q);
_init_txservq(&psta_xmitpriv->vi_q);
_init_txservq(&psta_xmitpriv->vo_q);
_rtw_init_listhead(&psta_xmitpriv->legacy_dz);
_rtw_init_listhead(&psta_xmitpriv->apsd);
}
void rtw_init_xmit_block(_adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
_rtw_spinlock_init(&dvobj->xmit_block_lock);
dvobj->xmit_block = XMIT_BLOCK_NONE;
}
void rtw_free_xmit_block(_adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
_rtw_spinlock_free(&dvobj->xmit_block_lock);
}
#ifdef RTW_PHL_TX
u8 alloc_txring(_adapter *padapter)
{
struct xmit_txreq_buf *ptxreq_buf = NULL;
u32 idx, alloc_sz = 0, alloc_sz_txreq = 0;
u8 res = _SUCCESS;
u32 offset_head = (sizeof(struct rtw_xmit_req) * RTW_MAX_FRAG_NUM);
u32 offset_tail = offset_head + (SZ_HEAD_BUF * RTW_MAX_FRAG_NUM);
u32 offset_list = offset_tail + (SZ_TAIL_BUF * RTW_MAX_FRAG_NUM);
PHLTX_ENTER;
alloc_sz = (SZ_TX_RING * RTW_MAX_FRAG_NUM);
alloc_sz_txreq = MAX_TX_RING_NUM * (sizeof(struct xmit_txreq_buf));
RTW_INFO("eric-tx [%s] alloc_sz = %d, alloc_sz_txreq = %d\n", __FUNCTION__, alloc_sz, alloc_sz_txreq);
padapter->pxmit_txreq_buf = rtw_vmalloc(alloc_sz_txreq);
ptxreq_buf = (struct xmit_txreq_buf *)padapter->pxmit_txreq_buf;
_rtw_init_queue(&padapter->free_txreq_queue);
for (idx = 0; idx < MAX_TX_RING_NUM; idx++) {
padapter->tx_pool_ring[idx] = rtw_zmalloc(alloc_sz);
if (!padapter->tx_pool_ring[idx]) {
RTW_ERR("[core] alloc txring fail, plz check.\n");
res = _FAIL;
break;
}
_rtw_init_listhead(&ptxreq_buf->list);
ptxreq_buf->txreq = padapter->tx_pool_ring[idx];
ptxreq_buf->head = padapter->tx_pool_ring[idx] + offset_head;
ptxreq_buf->tail = padapter->tx_pool_ring[idx] + offset_tail;
ptxreq_buf->pkt_list = padapter->tx_pool_ring[idx] + offset_list;
#ifdef USE_PREV_WLHDR_BUF /* CONFIG_CORE_TXSC */
ptxreq_buf->macid = 0xff;
ptxreq_buf->txsc_id = 0xff;
#endif
rtw_list_insert_tail(&(ptxreq_buf->list), &(padapter->free_txreq_queue.queue));
ptxreq_buf++;
}
padapter->free_txreq_cnt = MAX_TX_RING_NUM;
return res;
}
void free_txring(_adapter *padapter)
{
u32 idx, alloc_sz = 0, alloc_sz_txreq = 0;
#ifdef CONFIG_CORE_TXSC
struct rtw_xmit_req *txreq = NULL;
struct xmit_txreq_buf *txreq_buf = NULL;
u8 j;
#endif
PHLTX_ENTER;
alloc_sz = (SZ_TX_RING * RTW_MAX_FRAG_NUM);
alloc_sz_txreq = MAX_TX_RING_NUM * (sizeof(struct xmit_txreq_buf));
RTW_INFO("eric-tx [%s] alloc_sz = %d, alloc_sz_txreq = %d\n", __func__, alloc_sz, alloc_sz_txreq);
for (idx = 0; idx < MAX_TX_RING_NUM; idx++) {
if (padapter->tx_pool_ring[idx]) {
#ifdef CONFIG_CORE_TXSC
txreq = (struct rtw_xmit_req *)padapter->tx_pool_ring[idx];
if (txreq->treq_type == RTW_PHL_TREQ_TYPE_CORE_TXSC) {
txreq_buf = (struct xmit_txreq_buf *)txreq->os_priv;
if (txreq_buf) {
/* CONFGI_TXSC_AMSDU */
for (j = 0; j < txreq_buf->pkt_cnt; j++) {
if (txreq_buf->pkt[j])
rtw_os_pkt_complete(padapter, (void *)txreq_buf->pkt[j]);
}
}
}
#endif
rtw_mfree(padapter->tx_pool_ring[idx], alloc_sz);
}
}
_rtw_spinlock_free(&padapter->free_txreq_queue.lock);
rtw_vmfree(padapter->pxmit_txreq_buf, alloc_sz_txreq);
}
#endif
s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, _adapter *padapter)
{
int i;
#if 0 /*CONFIG_CORE_XMITBUF*/
struct xmit_buf *pxmitbuf;
#endif
struct xmit_frame *pxframe;
sint res = _SUCCESS;
/* MGT_TXREQ_MGT */
u8 *txreq = NULL, *pkt_list = NULL;
#if 0 /*CONFIG_CORE_XMITBUF*/
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 xmitbuf_nr = GET_HAL_XMITBUF_NR(dvobj);
u16 xmitbuf_sz = GET_HAL_XMITBUF_SZ(dvobj);
u8 xmitbuf_ext_nr = GET_HAL_XMITBUF_EXT_NR(dvobj);
u16 xmitbuf_ext_sz = GET_HAL_XMITBUF_EXT_SZ(dvobj);
#endif
/* We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc(). */
/* _rtw_memset((unsigned char *)pxmitpriv, 0, sizeof(struct xmit_priv)); */
_rtw_spinlock_init(&pxmitpriv->lock);
_rtw_spinlock_init(&pxmitpriv->lock_sctx);
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
_rtw_init_sema(&pxmitpriv->xmit_sema, 0);
#endif
/*
Please insert all the queue initializaiton using _rtw_init_queue below
*/
pxmitpriv->adapter = padapter;
/* for(i = 0 ; i < MAX_NUMBLKS; i++) */
/* _rtw_init_queue(&pxmitpriv->blk_strms[i]); */
_rtw_init_queue(&pxmitpriv->be_pending);
_rtw_init_queue(&pxmitpriv->bk_pending);
_rtw_init_queue(&pxmitpriv->vi_pending);
_rtw_init_queue(&pxmitpriv->vo_pending);
_rtw_init_queue(&pxmitpriv->bm_pending);
/* _rtw_init_queue(&pxmitpriv->legacy_dz_queue); */
/* _rtw_init_queue(&pxmitpriv->apsd_queue); */
_rtw_init_queue(&pxmitpriv->free_xmit_queue);
/*
Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME,
and initialize free_xmit_frame below.
Please also apply free_txobj to link_up all the xmit_frames...
*/
pxmitpriv->pallocated_frame_buf = rtw_zvmalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
if (pxmitpriv->pallocated_frame_buf == NULL) {
pxmitpriv->pxmit_frame_buf = NULL;
res = _FAIL;
goto exit;
}
pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4);
/* pxmitpriv->pxmit_frame_buf = pxmitpriv->pallocated_frame_buf + 4 - */
/* ((SIZE_PTR) (pxmitpriv->pallocated_frame_buf) &3); */
pxframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf;
for (i = 0; i < NR_XMITFRAME; i++) {
_rtw_init_listhead(&(pxframe->list));
pxframe->padapter = padapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
#if 0 /*CONFIG_CORE_XMITBUF*/
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
#else
/*alloc buf_addr*/
/*rtw_os_xmit_resource_alloc(padapter, pxframe);*/
#endif
rtw_list_insert_tail(&(pxframe->list), &(pxmitpriv->free_xmit_queue.queue));
pxframe++;
}
pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME;
pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
#if 0 /*CONFIG_CORE_XMITBUF*/
/* init xmit_buf */
_rtw_init_queue(&pxmitpriv->free_xmitbuf_queue);
_rtw_init_queue(&pxmitpriv->pending_xmitbuf_queue);
pxmitpriv->pallocated_xmitbuf = rtw_zvmalloc(xmitbuf_nr * sizeof(struct xmit_buf) + 4);
if (pxmitpriv->pallocated_xmitbuf == NULL) {
res = _FAIL;
goto exit;
}
pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4);
/* pxmitpriv->pxmitbuf = pxmitpriv->pallocated_xmitbuf + 4 - */
/* ((SIZE_PTR) (pxmitpriv->pallocated_xmitbuf) &3); */
pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
for (i = 0; i < xmitbuf_nr; i++) {
_rtw_init_listhead(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_DATA;
/* Tx buf allocation may fail sometimes, so sleep and retry. */
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,
(xmitbuf_sz + SZ_ALIGN_XMITFRAME_EXT), _TRUE);
if (res == _FAIL) {
rtw_msleep_os(10);
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,
(xmitbuf_sz + SZ_ALIGN_XMITFRAME_EXT), _TRUE);
if (res == _FAIL)
goto exit;
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + xmitbuf_sz;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
#endif
pxmitbuf->flags = XMIT_VO_QUEUE;
rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmitbuf_queue.queue));
#ifdef DBG_XMIT_BUF
pxmitbuf->no = i;
#endif
pxmitbuf++;
}
pxmitpriv->free_xmitbuf_cnt = xmitbuf_nr;
#endif
/* init xframe_ext queue, the same count as extbuf */
_rtw_init_queue(&pxmitpriv->free_xframe_ext_queue);
#ifdef CONFIG_LAYER2_ROAMING
_rtw_init_queue(&pxmitpriv->rpkt_queue);
#endif
pxmitpriv->xframe_ext_alloc_addr = rtw_zvmalloc(NR_XMITFRAME_EXT * sizeof(struct xmit_frame) + 4);
if (pxmitpriv->xframe_ext_alloc_addr == NULL) {
pxmitpriv->xframe_ext = NULL;
res = _FAIL;
goto exit;
}
pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4);
pxframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
/* MGT_TXREQ_QMGT */
pxmitpriv->xframe_ext_txreq_alloc_addr = rtw_zmalloc(NR_XMITFRAME_EXT * SZ_MGT_RING);
if (pxmitpriv->xframe_ext_txreq_alloc_addr == NULL) {
pxmitpriv->xframe_ext_txreq = NULL;
res = _FAIL;
goto exit;
}
pxmitpriv->xframe_ext_txreq = pxmitpriv->xframe_ext_txreq_alloc_addr;
txreq = pxmitpriv->xframe_ext_txreq;
pkt_list = pxmitpriv->xframe_ext_txreq + sizeof(struct rtw_xmit_req);
for (i = 0; i < NR_XMITFRAME_EXT; i++) {
_rtw_init_listhead(&(pxframe->list));
pxframe->padapter = padapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
#if 0 /*CONFIG_CORE_XMITBUF*/
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
#else
/*alloc buf_addr*/
rtw_os_xmit_resource_alloc(padapter, pxframe);
#endif
pxframe->ext_tag = 1;
/* MGT_TXREQ_QMGT */
pxframe->phl_txreq = (struct rtw_xmit_req *)txreq;
pxframe->phl_txreq->pkt_list = pkt_list;
rtw_list_insert_tail(&(pxframe->list), &(pxmitpriv->free_xframe_ext_queue.queue));
pxframe++;
/* MGT_TXREQ_QMGT */
txreq += SZ_MGT_RING;
pkt_list += SZ_MGT_RING;
}
pxmitpriv->free_xframe_ext_cnt = NR_XMITFRAME_EXT;
#if 0 /*CONFIG_CORE_XMITBUF*/
/* Init xmit extension buff */
_rtw_init_queue(&pxmitpriv->free_xmit_extbuf_queue);
pxmitpriv->pallocated_xmit_extbuf = rtw_zvmalloc(xmitbuf_ext_nr * sizeof(struct xmit_buf) + 4);
if (pxmitpriv->pallocated_xmit_extbuf == NULL) {
res = _FAIL;
goto exit;
}
pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4);
pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
for (i = 0; i < xmitbuf_ext_nr; i++) {
_rtw_init_listhead(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_MGNT;
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,
xmitbuf_ext_sz + SZ_ALIGN_XMITFRAME_EXT, _TRUE);
if (res == _FAIL) {
res = _FAIL;
goto exit;
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + xmitbuf_ext_sz;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
#endif
rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmit_extbuf_queue.queue));
#ifdef DBG_XMIT_BUF_EXT
pxmitbuf->no = i;
#endif
pxmitbuf++;
}
pxmitpriv->free_xmit_extbuf_cnt = xmitbuf_ext_nr;
/*GEORGIA_TODO_FIXIT_IC_GEN_DEPENDENCE*/
for (i = 0; i < CMDBUF_MAX; i++) {
pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
if (pxmitbuf) {
_rtw_init_listhead(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_CMD;
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,
MAX_CMDBUF_SZ + SZ_ALIGN_XMITFRAME_EXT, _TRUE);
if (res == _FAIL) {
res = _FAIL;
goto exit;
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + MAX_CMDBUF_SZ;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
#endif
pxmitbuf->alloc_sz = MAX_CMDBUF_SZ + SZ_ALIGN_XMITFRAME_EXT;
}
}
#endif
rtw_alloc_hwxmits(padapter);
rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
for (i = 0; i < 4; i++)
pxmitpriv->wmm_para_seq[i] = i;
#ifdef CONFIG_USB_HCI
pxmitpriv->txirp_cnt = 1;
_rtw_init_sema(&(pxmitpriv->tx_retevt), 0);
/* per AC pending irp */
pxmitpriv->beq_cnt = 0;
pxmitpriv->bkq_cnt = 0;
pxmitpriv->viq_cnt = 0;
pxmitpriv->voq_cnt = 0;
#endif
#ifdef CONFIG_XMIT_ACK
pxmitpriv->ack_tx = _FALSE;
_rtw_mutex_init(&pxmitpriv->ack_tx_mutex);
rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0);
#endif
#ifdef CONFIG_TX_AMSDU
rtw_init_timer(&(pxmitpriv->amsdu_vo_timer),
rtw_amsdu_vo_timeout_handler, padapter);
pxmitpriv->amsdu_vo_timeout = RTW_AMSDU_TIMER_UNSET;
rtw_init_timer(&(pxmitpriv->amsdu_vi_timer),
rtw_amsdu_vi_timeout_handler, padapter);
pxmitpriv->amsdu_vi_timeout = RTW_AMSDU_TIMER_UNSET;
rtw_init_timer(&(pxmitpriv->amsdu_be_timer),
rtw_amsdu_be_timeout_handler, padapter);
pxmitpriv->amsdu_be_timeout = RTW_AMSDU_TIMER_UNSET;
rtw_init_timer(&(pxmitpriv->amsdu_bk_timer),
rtw_amsdu_bk_timeout_handler, padapter);
pxmitpriv->amsdu_bk_timeout = RTW_AMSDU_TIMER_UNSET;
pxmitpriv->amsdu_debug_set_timer = 0;
pxmitpriv->amsdu_debug_timeout = 0;
pxmitpriv->amsdu_debug_tasklet = 0;
pxmitpriv->amsdu_debug_enqueue = 0;
pxmitpriv->amsdu_debug_dequeue = 0;
for (i = 0; i < AMSDU_DEBUG_MAX_COUNT; i++)
pxmitpriv->amsdu_debug_coalesce[i] = 0;
#endif
#ifdef DBG_TXBD_DESC_DUMP
pxmitpriv->dump_txbd_desc = 0;
#endif
rtw_init_xmit_block(padapter);
rtw_intf_init_xmit_priv(padapter);
#ifdef RTW_PHL_TX //alloc xmit resource
printk("eric-tx CALL alloc_txring !!!!\n");
if (alloc_txring(padapter) == _FAIL) {
RTW_ERR("[core] alloc_txring fail !!!\n");
res = _FAIL;
goto exit;
}
#endif
#if defined(CONFIG_CORE_TXSC)
_rtw_spinlock_init(&pxmitpriv->txsc_lock);
#endif
exit:
return res;
}
void rtw_mfree_xmit_priv_lock(struct xmit_priv *pxmitpriv)
{
_rtw_spinlock_free(&pxmitpriv->lock);
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
_rtw_free_sema(&pxmitpriv->xmit_sema);
#endif
_rtw_spinlock_free(&pxmitpriv->be_pending.lock);
_rtw_spinlock_free(&pxmitpriv->bk_pending.lock);
_rtw_spinlock_free(&pxmitpriv->vi_pending.lock);
_rtw_spinlock_free(&pxmitpriv->vo_pending.lock);
_rtw_spinlock_free(&pxmitpriv->bm_pending.lock);
/* _rtw_spinlock_free(&pxmitpriv->legacy_dz_queue.lock); */
/* _rtw_spinlock_free(&pxmitpriv->apsd_queue.lock); */
_rtw_spinlock_free(&pxmitpriv->free_xmit_queue.lock);
#if 0 /*CONFIG_CORE_XMITBUF*/
_rtw_spinlock_free(&pxmitpriv->free_xmitbuf_queue.lock);
_rtw_spinlock_free(&pxmitpriv->pending_xmitbuf_queue.lock);
#endif
}
void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv)
{
int i;
_adapter *padapter = pxmitpriv->adapter;
struct xmit_frame *pxmitframe;
#if 0 /*CONFIG_CORE_XMITBUF*/
struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
#endif
#if 0 /*CONFIG_CORE_XMITBUF*/
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
u8 xmitbuf_nr = GET_HAL_XMITBUF_NR(dvobj);
u16 xmitbuf_sz = GET_HAL_XMITBUF_SZ(dvobj);
u8 xmitbuf_ext_nr = GET_HAL_XMITBUF_EXT_NR(dvobj);
u16 xmitbuf_ext_sz = GET_HAL_XMITBUF_EXT_SZ(dvobj);
#endif
rtw_intf_free_xmit_priv(padapter);
rtw_mfree_xmit_priv_lock(pxmitpriv);
if (pxmitpriv->pxmit_frame_buf == NULL)
goto out;
pxmitframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf;
for (i = 0; i < NR_XMITFRAME; i++) {
rtw_os_xmit_complete(padapter, pxmitframe);
/*alloc buf_addr*/
/*rtw_os_xmit_resource_free(padapter, pxmitframe);*/
pxmitframe++;
}
#if 0 /*CONFIG_CORE_XMITBUF*/
for (i = 0; i < xmitbuf_nr; i++) {
rtw_os_xmit_resource_free(padapter, pxmitbuf,
(xmitbuf_sz + SZ_ALIGN_XMITFRAME_EXT), _TRUE);
pxmitbuf++;
}
#endif
if (pxmitpriv->pallocated_frame_buf)
rtw_vmfree(pxmitpriv->pallocated_frame_buf,
NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
#if 0 /*CONFIG_CORE_XMITBUF*/
if (pxmitpriv->pallocated_xmitbuf)
rtw_vmfree(pxmitpriv->pallocated_xmitbuf,
xmitbuf_nr * sizeof(struct xmit_buf) + 4);
#endif
/* free xframe_ext queue, the same count as extbuf */
if (pxmitpriv->xframe_ext == NULL)
goto out;
pxmitframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
for (i = 0; i < NR_XMITFRAME_EXT; i++) {
rtw_os_xmit_complete(padapter, pxmitframe);
/*free buf_addr*/
rtw_os_xmit_resource_free(padapter, pxmitframe);
pxmitframe++;
}
if (pxmitpriv->xframe_ext_alloc_addr)
rtw_vmfree(pxmitpriv->xframe_ext_alloc_addr,
NR_XMITFRAME_EXT * sizeof(struct xmit_frame) + 4);
_rtw_spinlock_free(&pxmitpriv->free_xframe_ext_queue.lock);
if (pxmitpriv->xframe_ext_txreq_alloc_addr)
rtw_mfree(pxmitpriv->xframe_ext_txreq_alloc_addr, NR_XMITFRAME_EXT * SZ_MGT_RING);
#if 0 /*CONFIG_CORE_XMITBUF*/
/* free xmit extension buff */
_rtw_spinlock_free(&pxmitpriv->free_xmit_extbuf_queue.lock);
pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
for (i = 0; i < xmitbuf_ext_nr; i++) {
rtw_os_xmit_resource_free(padapter, pxmitbuf,
(xmitbuf_ext_sz + SZ_ALIGN_XMITFRAME_EXT), _TRUE);
pxmitbuf++;
}
if (pxmitpriv->pallocated_xmit_extbuf)
rtw_vmfree(pxmitpriv->pallocated_xmit_extbuf,
xmitbuf_ext_nr * sizeof(struct xmit_buf) + 4);
for (i = 0; i < CMDBUF_MAX; i++) {
pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
if (pxmitbuf != NULL)
rtw_os_xmit_resource_free(padapter, pxmitbuf, MAX_CMDBUF_SZ + SZ_ALIGN_XMITFRAME_EXT, _TRUE);
}
#endif
rtw_free_hwxmits(padapter);
#ifdef CONFIG_LAYER2_ROAMING
_rtw_spinlock_free(&pxmitpriv->rpkt_queue.lock);
#endif
#ifdef RTW_PHL_TX
free_txring(padapter);
#endif
#ifdef CONFIG_CORE_TXSC
txsc_clear(padapter);
_rtw_spinlock_free(&pxmitpriv->txsc_lock);
#endif
#ifdef CONFIG_XMIT_ACK
_rtw_mutex_free(&pxmitpriv->ack_tx_mutex);
#endif
rtw_free_xmit_block(padapter);
out:
return;
}
u8 rtw_init_lite_xmit_resource(struct dvobj_priv *dvobj)
{
u8 ret = _SUCCESS;
/*YiWei_todo need use correct litexmitbuf_nr urb_nr*/
u32 litexmitbuf_nr = RTW_LITEXMITBUF_NR;
u32 litexmitbuf_ext_nr = RTW_LITEXMITBUF_NR;
struct lite_data_buf *litexmitbuf;
struct trx_data_buf_q *litexmitbuf_q = &dvobj->litexmitbuf_q;
struct trx_data_buf_q *litexmit_extbuf_q = &dvobj->litexmit_extbuf_q;
int i;
#ifdef CONFIG_USB_HCI
struct trx_urb_buf_q *xmit_urb_q = &dvobj->xmit_urb_q;
struct data_urb *xmiturb;
u32 urb_nr = RTW_XMITURB_NR;
#endif
/* init lite_xmit_buf */
_rtw_init_queue(&litexmitbuf_q->free_data_buf_queue);
litexmitbuf_q->alloc_data_buf =
rtw_zvmalloc(litexmitbuf_nr * sizeof(struct lite_data_buf) + 4);
if (litexmitbuf_q->alloc_data_buf == NULL) {
ret = _FAIL;
goto exit;
}
litexmitbuf_q->data_buf =
(u8 *)N_BYTE_ALIGNMENT((SIZE_PTR)(litexmitbuf_q->alloc_data_buf), 4);
litexmitbuf = (struct lite_data_buf *)litexmitbuf_q->data_buf;
for (i = 0; i < litexmitbuf_nr; i++) {
_rtw_init_listhead(&litexmitbuf->list);
rtw_list_insert_tail(&litexmitbuf->list,
&(litexmitbuf_q->free_data_buf_queue.queue));
litexmitbuf++;
}
litexmitbuf_q->free_data_buf_cnt = litexmitbuf_nr;
/* Init lite xmit extension buff */
_rtw_init_queue(&litexmit_extbuf_q->free_data_buf_queue);
litexmit_extbuf_q->alloc_data_buf =
rtw_zvmalloc(litexmitbuf_ext_nr * sizeof(struct lite_data_buf) + 4);
if (litexmit_extbuf_q->alloc_data_buf == NULL) {
ret = _FAIL;
goto exit;
}
litexmit_extbuf_q->data_buf =
(u8 *)N_BYTE_ALIGNMENT((SIZE_PTR)(litexmit_extbuf_q->alloc_data_buf), 4);
litexmitbuf = (struct lite_data_buf *)litexmit_extbuf_q->data_buf;
for (i = 0; i < litexmitbuf_ext_nr; i++) {
_rtw_init_listhead(&litexmitbuf->list);
rtw_list_insert_tail(&litexmitbuf->list,
&(litexmit_extbuf_q->free_data_buf_queue.queue));
litexmitbuf++;
}
litexmit_extbuf_q->free_data_buf_cnt = litexmitbuf_ext_nr;
#ifdef CONFIG_USB_HCI
/* init xmit_urb */
_rtw_init_queue(&xmit_urb_q->free_urb_buf_queue);
xmit_urb_q->alloc_urb_buf =
rtw_zvmalloc(urb_nr * sizeof(struct data_urb) + 4);
if (xmit_urb_q->alloc_urb_buf == NULL) {
ret = _FAIL;
goto exit;
}
xmit_urb_q->urb_buf =
(u8 *)N_BYTE_ALIGNMENT((SIZE_PTR)(xmit_urb_q->alloc_urb_buf), 4);
xmiturb = (struct data_urb *)xmit_urb_q->urb_buf;
for (i = 0; i < urb_nr; i++) {
_rtw_init_listhead(&xmiturb->list);
ret = rtw_os_urb_resource_alloc(xmiturb);
rtw_list_insert_tail(&xmiturb->list,
&(xmit_urb_q->free_urb_buf_queue.queue));
xmiturb++;
}
xmit_urb_q->free_urb_buf_cnt = urb_nr;
#endif
exit:
return ret;
}
void rtw_free_lite_xmit_resource(struct dvobj_priv *dvobj)
{
u8 ret = _SUCCESS;
/*YiWei_todo need use correct litexmitbuf_nr urb_nr*/
u32 litexmitbuf_nr = RTW_LITEXMITBUF_NR;
u32 litexmitbuf_ext_nr = RTW_LITEXMITBUF_NR;
struct trx_data_buf_q *litexmitbuf_q = &dvobj->litexmitbuf_q;
struct trx_data_buf_q *litexmit_extbuf_q = &dvobj->litexmit_extbuf_q;
#ifdef CONFIG_USB_HCI
struct data_urb *xmiturb;
struct trx_urb_buf_q *xmit_urb_q = &dvobj->xmit_urb_q;
u32 urb_nr = RTW_XMITURB_NR;
int i;
#endif
if (litexmitbuf_q->alloc_data_buf)
rtw_vmfree(litexmitbuf_q->alloc_data_buf,
litexmitbuf_nr * sizeof(struct lite_data_buf) + 4);
if (litexmit_extbuf_q->alloc_data_buf)
rtw_vmfree(litexmit_extbuf_q->alloc_data_buf,
litexmitbuf_ext_nr * sizeof(struct lite_data_buf) + 4);
#ifdef CONFIG_USB_HCI
xmiturb = (struct data_urb *)xmit_urb_q->urb_buf;
for (i = 0; i < urb_nr; i++) {
rtw_os_urb_resource_free(xmiturb);
xmiturb++;
}
if (xmit_urb_q->alloc_urb_buf)
rtw_vmfree(xmit_urb_q->alloc_urb_buf,
urb_nr * sizeof(struct data_urb) + 4);
#endif
}
u8 rtw_get_tx_bw_mode(_adapter *adapter, struct sta_info *sta)
{
u8 bw;
bw = sta->phl_sta->chandef.bw;
if (MLME_STATE(adapter) & WIFI_ASOC_STATE) {
if (adapter->mlmeextpriv.chandef.chan <= 14)
bw = rtw_min(bw, ADAPTER_TX_BW_2G(adapter));
else
bw = rtw_min(bw, ADAPTER_TX_BW_5G(adapter));
}
return bw;
}
void rtw_get_adapter_tx_rate_bmp_by_bw(_adapter *adapter, u8 bw, u16 *r_bmp_cck_ofdm, u32 *r_bmp_ht, u64 *r_bmp_vht)
{
/* ToDo */
#if 0
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
u8 fix_bw = 0xFF;
u16 bmp_cck_ofdm = 0;
u32 bmp_ht = 0;
u64 bmp_vht = 0;
int i;
if (adapter->fix_rate != NO_FIX_RATE && adapter->fix_bw != NO_FIX_BW)
fix_bw = adapter->fix_bw;
/* TODO: adapter->fix_rate */
for (i = 0; i < macid_ctl->num; i++) {
if (!rtw_macid_is_used(macid_ctl, i))
continue;
if (!rtw_macid_is_iface_specific(macid_ctl, i, adapter))
continue;
if (bw == CHANNEL_WIDTH_20) /* CCK, OFDM always 20MHz */
bmp_cck_ofdm |= macid_ctl->rate_bmp0[i] & 0x00000FFF;
/* bypass mismatch bandwidth for HT, VHT */
if ((fix_bw != 0xFF && fix_bw != bw) || (fix_bw == 0xFF && macid_ctl->bw[i] != bw))
continue;
if (macid_ctl->vht_en[i])
bmp_vht |= (macid_ctl->rate_bmp0[i] >> 12) | (macid_ctl->rate_bmp1[i] << 20);
else
bmp_ht |= (macid_ctl->rate_bmp0[i] >> 12) | (macid_ctl->rate_bmp1[i] << 20);
}
/* TODO: mlmeext->tx_rate*/
if (r_bmp_cck_ofdm)
*r_bmp_cck_ofdm = bmp_cck_ofdm;
if (r_bmp_ht)
*r_bmp_ht = bmp_ht;
if (r_bmp_vht)
*r_bmp_vht = bmp_vht;
#endif
}
void rtw_get_shared_macid_tx_rate_bmp_by_bw(struct dvobj_priv *dvobj, u8 bw, u16 *r_bmp_cck_ofdm, u32 *r_bmp_ht, u64 *r_bmp_vht)
{
/* ToDo */
#if 0
struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
u16 bmp_cck_ofdm = 0;
u32 bmp_ht = 0;
u64 bmp_vht = 0;
int i;
for (i = 0; i < macid_ctl->num; i++) {
if (!rtw_macid_is_used(macid_ctl, i))
continue;
if (!rtw_macid_is_iface_shared(macid_ctl, i))
continue;
if (bw == CHANNEL_WIDTH_20) /* CCK, OFDM always 20MHz */
bmp_cck_ofdm |= macid_ctl->rate_bmp0[i] & 0x00000FFF;
/* bypass mismatch bandwidth for HT, VHT */
if (macid_ctl->bw[i] != bw)
continue;
if (macid_ctl->vht_en[i])
bmp_vht |= (macid_ctl->rate_bmp0[i] >> 12) | (macid_ctl->rate_bmp1[i] << 20);
else
bmp_ht |= (macid_ctl->rate_bmp0[i] >> 12) | (macid_ctl->rate_bmp1[i] << 20);
}
if (r_bmp_cck_ofdm)
*r_bmp_cck_ofdm = bmp_cck_ofdm;
if (r_bmp_ht)
*r_bmp_ht = bmp_ht;
if (r_bmp_vht)
*r_bmp_vht = bmp_vht;
#endif
}
void rtw_update_tx_rate_bmp(struct dvobj_priv *dvobj)
{
#if 0 /*GEORGIA_TODO_FIXIT*/
struct rf_ctl_t *rf_ctl = dvobj_to_rfctl(dvobj);
_adapter *adapter = dvobj_get_primary_adapter(dvobj);
HAL_DATA_TYPE *hal_data = GET_PHL_COM(dvobj);
u8 bw;
u16 bmp_cck_ofdm, tmp_cck_ofdm;
u32 bmp_ht, tmp_ht, ori_bmp_ht[2];
u64 bmp_vht, tmp_vht, ori_bmp_vht[4];
int i;
for (bw = CHANNEL_WIDTH_20; bw <= CHANNEL_WIDTH_160; bw++) {
/* backup the original ht & vht bmp */
if (bw <= CHANNEL_WIDTH_40)
ori_bmp_ht[bw] = rf_ctl->rate_bmp_ht_by_bw[bw];
if (bw <= CHANNEL_WIDTH_160)
ori_bmp_vht[bw] = rf_ctl->rate_bmp_vht_by_bw[bw];
bmp_cck_ofdm = bmp_ht = bmp_vht = 0;
if (rtw_hw_is_bw_support(dvobj, bw)) {
for (i = 0; i < dvobj->iface_nums; i++) {
if (!dvobj->padapters[i])
continue;
rtw_get_adapter_tx_rate_bmp_by_bw(dvobj->padapters[i], bw, &tmp_cck_ofdm, &tmp_ht, &tmp_vht);
bmp_cck_ofdm |= tmp_cck_ofdm;
bmp_ht |= tmp_ht;
bmp_vht |= tmp_vht;
}
rtw_get_shared_macid_tx_rate_bmp_by_bw(dvobj, bw, &tmp_cck_ofdm, &tmp_ht, &tmp_vht);
bmp_cck_ofdm |= tmp_cck_ofdm;
bmp_ht |= tmp_ht;
bmp_vht |= tmp_vht;
}
if (bw == CHANNEL_WIDTH_20)
rf_ctl->rate_bmp_cck_ofdm = bmp_cck_ofdm;
if (bw <= CHANNEL_WIDTH_40)
rf_ctl->rate_bmp_ht_by_bw[bw] = bmp_ht;
if (bw <= CHANNEL_WIDTH_160)
rf_ctl->rate_bmp_vht_by_bw[bw] = bmp_vht;
}
#if CONFIG_TXPWR_LIMIT
#ifndef DBG_HIGHEST_RATE_BMP_BW_CHANGE
#define DBG_HIGHEST_RATE_BMP_BW_CHANGE 0
#endif
if (hal_data->txpwr_limit_loaded) {
u8 ori_highest_ht_rate_bw_bmp;
u8 ori_highest_vht_rate_bw_bmp;
u8 highest_rate_bw;
u8 highest_rate_bw_bmp;
u8 update_ht_rs = _FALSE;
u8 update_vht_rs = _FALSE;
/* backup the original ht & vht highest bw bmp */
ori_highest_ht_rate_bw_bmp = rf_ctl->highest_ht_rate_bw_bmp;
ori_highest_vht_rate_bw_bmp = rf_ctl->highest_vht_rate_bw_bmp;
highest_rate_bw_bmp = BW_CAP_20M;
highest_rate_bw = CHANNEL_WIDTH_20;
for (bw = CHANNEL_WIDTH_20; bw <= CHANNEL_WIDTH_40; bw++) {
if (rf_ctl->rate_bmp_ht_by_bw[highest_rate_bw] < rf_ctl->rate_bmp_ht_by_bw[bw]) {
highest_rate_bw_bmp = ch_width_to_bw_cap(bw);
highest_rate_bw = bw;
} else if (rf_ctl->rate_bmp_ht_by_bw[highest_rate_bw] == rf_ctl->rate_bmp_ht_by_bw[bw])
highest_rate_bw_bmp |= ch_width_to_bw_cap(bw);
}
rf_ctl->highest_ht_rate_bw_bmp = highest_rate_bw_bmp;
if (ori_highest_ht_rate_bw_bmp != rf_ctl->highest_ht_rate_bw_bmp
|| largest_bit(ori_bmp_ht[highest_rate_bw]) != largest_bit(rf_ctl->rate_bmp_ht_by_bw[highest_rate_bw])
) {
if (DBG_HIGHEST_RATE_BMP_BW_CHANGE) {
RTW_INFO("highest_ht_rate_bw_bmp:0x%02x=>0x%02x\n", ori_highest_ht_rate_bw_bmp, rf_ctl->highest_ht_rate_bw_bmp);
RTW_INFO("rate_bmp_ht_by_bw[%u]:0x%08x=>0x%08x\n", highest_rate_bw, ori_bmp_ht[highest_rate_bw], rf_ctl->rate_bmp_ht_by_bw[highest_rate_bw]);
}
if (rf_ctl->rate_bmp_ht_by_bw[highest_rate_bw])
update_ht_rs = _TRUE;
}
highest_rate_bw_bmp = BW_CAP_20M;
highest_rate_bw = CHANNEL_WIDTH_20;
for (bw = CHANNEL_WIDTH_20; bw <= CHANNEL_WIDTH_160; bw++) {
if (rf_ctl->rate_bmp_vht_by_bw[highest_rate_bw] < rf_ctl->rate_bmp_vht_by_bw[bw]) {
highest_rate_bw_bmp = ch_width_to_bw_cap(bw);
highest_rate_bw = bw;
} else if (rf_ctl->rate_bmp_vht_by_bw[highest_rate_bw] == rf_ctl->rate_bmp_vht_by_bw[bw])
highest_rate_bw_bmp |= ch_width_to_bw_cap(bw);
}
rf_ctl->highest_vht_rate_bw_bmp = highest_rate_bw_bmp;
if (ori_highest_vht_rate_bw_bmp != rf_ctl->highest_vht_rate_bw_bmp
|| largest_bit_64(ori_bmp_vht[highest_rate_bw]) != largest_bit_64(rf_ctl->rate_bmp_vht_by_bw[highest_rate_bw])
) {
if (DBG_HIGHEST_RATE_BMP_BW_CHANGE) {
RTW_INFO("highest_vht_rate_bw_bmp:0x%02x=>0x%02x\n", ori_highest_vht_rate_bw_bmp, rf_ctl->highest_vht_rate_bw_bmp);
RTW_INFO("rate_bmp_vht_by_bw[%u]:0x%016llx=>0x%016llx\n", highest_rate_bw, ori_bmp_vht[highest_rate_bw], rf_ctl->rate_bmp_vht_by_bw[highest_rate_bw]);
}
if (rf_ctl->rate_bmp_vht_by_bw[highest_rate_bw])
update_vht_rs = _TRUE;
}
/* TODO: per rfpath and rate section handling? */
if (update_ht_rs == _TRUE || update_vht_rs == _TRUE)
rtw_hal_set_tx_power_level(dvobj_get_primary_adapter(dvobj), hal_data->current_channel);
}
#endif /* CONFIG_TXPWR_LIMIT */
#endif
}
u8 rtw_get_tx_bw_bmp_of_ht_rate(struct dvobj_priv *dvobj, u8 rate, u8 max_bw)
{
struct rf_ctl_t *rf_ctl = dvobj_to_rfctl(dvobj);
u8 bw;
u8 bw_bmp = 0;
u32 rate_bmp;
if (!IS_HT_RATE(rate)) {
rtw_warn_on(1);
goto exit;
}
rate_bmp = 1 << (rate - MGN_MCS0);
if (max_bw > CHANNEL_WIDTH_40)
max_bw = CHANNEL_WIDTH_40;
for (bw = CHANNEL_WIDTH_20; bw <= max_bw; bw++) {
/* RA may use lower rate for retry */
if (rf_ctl->rate_bmp_ht_by_bw[bw] >= rate_bmp)
bw_bmp |= ch_width_to_bw_cap(bw);
}
exit:
return bw_bmp;
}
u8 rtw_get_tx_bw_bmp_of_vht_rate(struct dvobj_priv *dvobj, u8 rate, u8 max_bw)
{
struct rf_ctl_t *rf_ctl = dvobj_to_rfctl(dvobj);
u8 bw;
u8 bw_bmp = 0;
u64 rate_bmp;
if (!IS_VHT_RATE(rate)) {
rtw_warn_on(1);
goto exit;
}
rate_bmp = BIT_ULL(rate - MGN_VHT1SS_MCS0);
if (max_bw > CHANNEL_WIDTH_160)
max_bw = CHANNEL_WIDTH_160;
for (bw = CHANNEL_WIDTH_20; bw <= max_bw; bw++) {
/* RA may use lower rate for retry */
if (rf_ctl->rate_bmp_vht_by_bw[bw] >= rate_bmp)
bw_bmp |= ch_width_to_bw_cap(bw);
}
exit:
return bw_bmp;
}
s16 rtw_rfctl_get_oper_txpwr_max_mbm(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset, u8 ifbmp_mod, u8 if_op, bool eirp)
{
/* TODO: get maximum txpower of current operating class & channel belongs to this radio */
s16 mbm = 2000;
return mbm;
}
s16 rtw_rfctl_get_reg_max_txpwr_mbm(struct rf_ctl_t *rfctl, u8 ch, u8 bw, u8 offset, bool eirp)
{
/* TODO: get maximum txpower of current operating class & channel belongs to this radio allowed by regulatory */
s16 mbm = 1300;
return mbm;
}
u8 query_ra_short_GI(struct sta_info *psta, u8 bw)
{
u8 sgi = _FALSE, sgi_20m = _FALSE, sgi_40m = _FALSE, sgi_80m = _FALSE;
#ifdef CONFIG_80211N_HT
#ifdef CONFIG_80211AC_VHT
#ifdef CONFIG_80211AX_HE
/* CONFIG_80211AX_HE_TODO */
#endif /* CONFIG_80211AX_HE */
if (psta->vhtpriv.vht_option)
sgi_80m = psta->vhtpriv.sgi_80m;
#endif
sgi_20m = psta->htpriv.sgi_20m;
sgi_40m = psta->htpriv.sgi_40m;
#endif
switch (bw) {
case CHANNEL_WIDTH_80:
sgi = sgi_80m;
break;
case CHANNEL_WIDTH_40:
sgi = sgi_40m;
break;
case CHANNEL_WIDTH_20:
default:
sgi = sgi_20m;
break;
}
return sgi;
}
static void update_attrib_vcs_info(_adapter *padapter, struct xmit_frame *pxmitframe)
{
u32 sz;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
/* struct sta_info *psta = pattrib->psta; */
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
/*
if(pattrib->psta)
{
psta = pattrib->psta;
}
else
{
RTW_INFO("%s, call rtw_get_stainfo()\n", __func__);
psta=rtw_get_stainfo(&padapter->stapriv ,&pattrib->ra[0] );
}
if(psta==NULL)
{
RTW_INFO("%s, psta==NUL\n", __func__);
return;
}
if(!(psta->state &WIFI_ASOC_STATE))
{
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return;
}
*/
if (pattrib->nr_frags != 1)
sz = padapter->xmitpriv.frag_len;
else /* no frag */
sz = pattrib->last_txcmdsz;
/* (1) RTS_Threshold is compared to the MPDU, not MSDU. */
/* (2) If there are more than one frag in this MSDU, only the first frag uses protection frame. */
/* Other fragments are protected by previous fragment. */
/* So we only need to check the length of first fragment. */
if (pmlmeext->cur_wireless_mode < WLAN_MD_11N || padapter->registrypriv.wifi_spec) {
if (sz > padapter->registrypriv.rts_thresh)
pattrib->vcs_mode = RTS_CTS;
else {
if (pattrib->rtsen)
pattrib->vcs_mode = RTS_CTS;
else if (pattrib->cts2self)
pattrib->vcs_mode = CTS_TO_SELF;
else
pattrib->vcs_mode = NONE_VCS;
}
} else {
while (_TRUE) {
#if 0 /* Todo */
/* check IOT action */
if (pHTInfo->IOTAction & HT_IOT_ACT_FORCED_CTS2SELF) {
pattrib->vcs_mode = CTS_TO_SELF;
pattrib->rts_rate = MGN_24M;
break;
} else if (pHTInfo->IOTAction & (HT_IOT_ACT_FORCED_RTS | HT_IOT_ACT_PURE_N_MODE)) {
pattrib->vcs_mode = RTS_CTS;
pattrib->rts_rate = MGN_24M;
break;
}
#endif
/* IOT action */
if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_ATHEROS) && (pattrib->ampdu_en == _TRUE) &&
(padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
pattrib->vcs_mode = CTS_TO_SELF;
break;
}
/* check ERP protection */
if (pattrib->rtsen || pattrib->cts2self) {
if (pattrib->rtsen)
pattrib->vcs_mode = RTS_CTS;
else if (pattrib->cts2self)
pattrib->vcs_mode = CTS_TO_SELF;
break;
}
/* check HT op mode */
if (pattrib->ht_en) {
u8 HTOpMode = pmlmeinfo->HT_protection;
if ((pmlmeext->chandef.bw && (HTOpMode == 2 || HTOpMode == 3)) ||
(!pmlmeext->chandef.bw && HTOpMode == 3)) {
pattrib->vcs_mode = RTS_CTS;
break;
}
}
/* check rts */
if (sz > padapter->registrypriv.rts_thresh) {
pattrib->vcs_mode = RTS_CTS;
break;
}
/* to do list: check MIMO power save condition. */
/* check AMPDU aggregation for TXOP */
if (pattrib->ampdu_en == _TRUE) {
pattrib->vcs_mode = RTS_CTS;
break;
}
pattrib->vcs_mode = NONE_VCS;
break;
}
}
/* for debug : force driver control vrtl_carrier_sense. */
if (padapter->driver_vcs_en == 1) {
/* u8 driver_vcs_en; */ /* Enable=1, Disable=0 driver control vrtl_carrier_sense. */
/* u8 driver_vcs_type; */ /* force 0:disable VCS, 1:RTS-CTS, 2:CTS-to-self when vcs_en=1. */
pattrib->vcs_mode = padapter->driver_vcs_type;
}
}
#ifdef CONFIG_WMMPS_STA
/*
* update_attrib_trigger_frame_info
* For Station mode, if a specific TID of driver setting and an AP support uapsd function, the data
* frame with corresponding TID will be a trigger frame when driver is in wmm power saving mode.
*
* Arguments:
* @padapter: _adapter pointer.
* @pattrib: pkt_attrib pointer.
*
* Auther: Arvin Liu
* Date: 2017/06/05
*/
static void update_attrib_trigger_frame_info(_adapter *padapter, struct pkt_attrib *pattrib)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
u8 trigger_frame_en = 0;
if (MLME_IS_STA(padapter)) {
if ((pwrpriv->pwr_mode == PM_PS_MODE_MIN) || (pwrpriv->pwr_mode == PM_PS_MODE_MAX)) {
if ((pqospriv->uapsd_ap_supported) && ((pqospriv->uapsd_tid & BIT(pattrib->priority)) == _TRUE)) {
trigger_frame_en = 1;
RTW_INFO("[WMMPS]"FUNC_ADPT_FMT": This is a Trigger Frame\n", FUNC_ADPT_ARG(padapter));
}
}
}
pattrib->trigger_frame = trigger_frame_en;
}
#endif /* CONFIG_WMMPS_STA */
static void update_attrib_phy_info(_adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
{
struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
u8 bw;
pattrib->rtsen = psta->rtsen;
pattrib->cts2self = psta->cts2self;
pattrib->hw_rts_en = psta->hw_rts_en;
pattrib->mdata = 0;
pattrib->eosp = 0;
#ifdef CONFIG_80211AX_HE
if (psta->hepriv.he_option == _TRUE)
pattrib->eosp = 1;
#endif
pattrib->triggered = 0;
pattrib->ampdu_spacing = 0;
/* ht_en, init rate, ,bw, ch_offset, sgi */
/* ToDo: Need API to inform hal_sta->ra_info.rate_id */
/* pattrib->raid = psta->phl_sta->ra_info.rate_id; */
bw = rtw_get_tx_bw_mode(padapter, psta);
pattrib->bwmode = rtw_min(bw, mlmeext->chandef.bw);
pattrib->sgi = query_ra_short_GI(psta, pattrib->bwmode);
if (psta->phl_sta->wmode & WLAN_MD_11AX) {
pattrib->ldpc = psta->phl_sta->asoc_cap.he_ldpc;
pattrib->stbc = (psta->phl_sta->asoc_cap.stbc_he_rx > 0) ? 1:0;
} else if (psta->phl_sta->wmode & WLAN_MD_11AC) {
pattrib->ldpc = psta->phl_sta->asoc_cap.vht_ldpc;
pattrib->stbc = (psta->phl_sta->asoc_cap.stbc_vht_rx > 0) ? 1:0;
} else if (psta->phl_sta->wmode & WLAN_MD_11N) {
pattrib->ldpc = psta->phl_sta->asoc_cap.ht_ldpc;
pattrib->stbc = (psta->phl_sta->asoc_cap.stbc_ht_rx > 0) ? 1:0;
} else {
pattrib->ldpc = 0;
pattrib->stbc = 0;
}
#ifdef CONFIG_80211N_HT
if (padapter->registrypriv.ht_enable &&
is_supported_ht(padapter->registrypriv.wireless_mode)) {
pattrib->ht_en = psta->htpriv.ht_option;
pattrib->ch_offset = psta->htpriv.ch_offset;
pattrib->ampdu_en = _FALSE;
if (padapter->driver_ampdu_spacing != 0xFF) /* driver control AMPDU Density for peer sta's rx */
pattrib->ampdu_spacing = padapter->driver_ampdu_spacing;
else
pattrib->ampdu_spacing = psta->htpriv.rx_ampdu_min_spacing;
/* check if enable ampdu */
if (pattrib->ht_en && psta->htpriv.ampdu_enable) {
if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority)) {
pattrib->ampdu_en = _TRUE;
if (psta->htpriv.tx_amsdu_enable == _TRUE)
pattrib->amsdu_ampdu_en = _TRUE;
else
pattrib->amsdu_ampdu_en = _FALSE;
}
}
}
#endif /* CONFIG_80211N_HT */
/* if(pattrib->ht_en && psta->htpriv.ampdu_enable) */
/* { */
/* if(psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority)) */
/* pattrib->ampdu_en = _TRUE; */
/* } */
#ifdef CONFIG_TDLS
if (pattrib->direct_link == _TRUE) {
psta = pattrib->ptdls_sta;
pattrib->raid = psta->phl_sta->ra_info.rate_id;
#ifdef CONFIG_80211N_HT
if (padapter->registrypriv.ht_enable &&
is_supported_ht(padapter->registrypriv.wireless_mode)) {
pattrib->bwmode = rtw_get_tx_bw_mode(padapter, psta);
pattrib->ht_en = psta->htpriv.ht_option;
pattrib->ch_offset = psta->htpriv.ch_offset;
pattrib->sgi = query_ra_short_GI(psta, pattrib->bwmode);
}
#endif /* CONFIG_80211N_HT */
}
#endif /* CONFIG_TDLS */
pattrib->retry_ctrl = _FALSE;
}
static s32 update_attrib_sec_iv_info(_adapter *padapter, struct pkt_attrib *pattrib)
{
struct sta_info *psta = pattrib->psta;
sint bmcast = IS_MCAST(pattrib->ra);
if (!psta)
return _FAIL;
switch (pattrib->encrypt) {
case _WEP40_:
case _WEP104_:
WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
break;
case _TKIP_:
if (bmcast)
TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
break;
case _AES_:
if (bmcast)
AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
AES_IV(pattrib->iv, psta->dot11txpn, 0);
break;
case _GCMP_:
case _GCMP_256_:
if (bmcast)
GCMP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
GCMP_IV(pattrib->iv, psta->dot11txpn, 0);
break;
case _CCMP_256_:
if (bmcast)
GCMP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
GCMP_IV(pattrib->iv, psta->dot11txpn, 0);
break;
#ifdef CONFIG_WAPI_SUPPORT
case _SMS4_:
rtw_wapi_get_iv(padapter, pattrib->ra, pattrib->iv);
break;
#endif
default:
break;
}
return _SUCCESS;
}
static s32 update_attrib_sec_info(_adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta, enum eap_type eapol_type)
{
sint res = _SUCCESS;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
sint bmcast = IS_MCAST(pattrib->ra);
s8 hw_decrypted = _FALSE;
_rtw_memset(pattrib->dot118021x_UncstKey.skey, 0, 16);
_rtw_memset(pattrib->dot11tkiptxmickey.skey, 0, 16);
pattrib->mac_id = psta->phl_sta->macid;
/* Comment by Owen at 2020/05/19
* Issue: RTK STA sends encrypted 4-way 4/4 when AP thinks the 4-way incomplete
* In TCL pressure test, AP may resend 4-way 3/4 with new replay counter in 2 ms.
* In this situation, STA sends unencrypted 4-way 4/4 with old replay counter after more
* than 2 ms, followed by the encrypted 4-way 4/4 with new replay counter. Because the
* AP only accepts unencrypted 4-way 4/4 with a new play counter, and the STA encrypts
* each 4-way 4/4 at this time, the 4-way handshake cannot be completed.
* So we modified that after STA receives unencrypted 4-way 1/4 and 4-way 3/4,
* 4-way 2/4 and 4-way 4/4 sent by STA in the next 100 ms are not encrypted.
*/
if (psta->ieee8021x_blocked == _TRUE ||
((eapol_type == EAPOL_2_4 || eapol_type == EAPOL_4_4) &&
rtw_get_passing_time_ms(psta->resp_nonenc_eapol_key_starttime) <= 100)) {
if (eapol_type == EAPOL_2_4 || eapol_type == EAPOL_4_4)
RTW_INFO("Respond unencrypted eapol key\n");
pattrib->encrypt = 0;
if ((pattrib->ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _FALSE)) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s psta->ieee8021x_blocked == _TRUE, pattrib->ether_type(%04x) != 0x888e\n", __FUNCTION__, pattrib->ether_type);
#endif
res = _FAIL;
goto exit;
}
} else {
GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, bmcast);
#ifdef CONFIG_WAPI_SUPPORT
if (pattrib->ether_type == 0x88B4)
pattrib->encrypt = _NO_PRIVACY_;
#endif
switch (psecuritypriv->dot11AuthAlgrthm) {
case dot11AuthAlgrthm_Open:
case dot11AuthAlgrthm_Shared:
case dot11AuthAlgrthm_Auto:
pattrib->key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex;
break;
case dot11AuthAlgrthm_8021X:
if (bmcast)
pattrib->key_idx = (u8)psecuritypriv->dot118021XGrpKeyid;
else
pattrib->key_idx = 0;
break;
default:
pattrib->key_idx = 0;
break;
}
/* For WPS 1.0 WEP, driver should not encrypt EAPOL Packet for WPS handshake. */
if (((pattrib->encrypt == _WEP40_) || (pattrib->encrypt == _WEP104_)) && (pattrib->ether_type == 0x888e))
pattrib->encrypt = _NO_PRIVACY_;
}
#ifdef CONFIG_TDLS
if (pattrib->direct_link == _TRUE) {
if (pattrib->encrypt > 0)
pattrib->encrypt = _AES_;
}
#endif
switch (pattrib->encrypt) {
case _WEP40_:
case _WEP104_:
pattrib->iv_len = 4;
pattrib->icv_len = 4;
break;
case _TKIP_:
pattrib->iv_len = 8;
pattrib->icv_len = 4;
if (psecuritypriv->busetkipkey == _FAIL) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s psecuritypriv->busetkipkey(%d)==_FAIL drop packet\n", __FUNCTION__, psecuritypriv->busetkipkey);
#endif
res = _FAIL;
goto exit;
}
_rtw_memcpy(pattrib->dot11tkiptxmickey.skey, psta->dot11tkiptxmickey.skey, 16);
break;
case _AES_:
pattrib->iv_len = 8;
pattrib->icv_len = 8;
break;
case _GCMP_:
case _GCMP_256_:
pattrib->iv_len = 8;
pattrib->icv_len = 16;
break;
case _CCMP_256_:
pattrib->iv_len = 8;
pattrib->icv_len = 16;
break;
#ifdef CONFIG_WAPI_SUPPORT
case _SMS4_:
pattrib->iv_len = 18;
pattrib->icv_len = 16;
break;
#endif
default:
pattrib->iv_len = 0;
pattrib->icv_len = 0;
break;
}
if (pattrib->encrypt > 0) {
_rtw_memcpy(pattrib->dot118021x_UncstKey.skey
, psta->dot118021x_UncstKey.skey
, (pattrib->encrypt & _SEC_TYPE_256_) ? 32 : 16);
}
if (!bmcast)
hw_decrypted = psta->hw_decrypted;
else
hw_decrypted = psecuritypriv->hw_decrypted;
if (pattrib->encrypt &&
(padapter->securitypriv.sw_encrypt == _TRUE || hw_decrypted == _FALSE || pattrib->encrypt == _TKIP_)) {
pattrib->bswenc = _TRUE;
} else {
pattrib->bswenc = _FALSE;
}
#if defined(CONFIG_CONCURRENT_MODE)
pattrib->bmc_camid = padapter->securitypriv.dot118021x_bmc_cam_id;
#endif
#ifdef CONFIG_WAPI_SUPPORT
if (pattrib->encrypt == _SMS4_)
pattrib->bswenc = _FALSE;
#endif
if ((pattrib->encrypt) && (eapol_type == EAPOL_4_4))
pattrib->bswenc = _TRUE;
exit:
return res;
}
u8 qos_acm(u8 acm_mask, u8 priority)
{
u8 change_priority = priority;
switch (priority) {
case 0:
case 3:
if (acm_mask & BIT(1))
change_priority = 1;
break;
case 1:
case 2:
break;
case 4:
case 5:
if (acm_mask & BIT(2))
change_priority = 0;
break;
case 6:
case 7:
if (acm_mask & BIT(3))
change_priority = 5;
break;
default:
RTW_INFO("qos_acm(): invalid pattrib->priority: %d!!!\n", priority);
break;
}
return change_priority;
}
/* refer to IEEE802.11-2016 Table R-3; Comply with IETF RFC4594 */
u8 tos_to_up(u8 tos)
{
u8 up = 0;
u8 dscp;
u8 mode = CONFIG_RTW_UP_MAPPING_RULE;
/* tos precedence mapping */
if (mode == 0) {
up = tos >> 5;
return up;
}
/* refer to IEEE802.11-2016 Table R-3;
* DCSP 32(CS4) comply with IETF RFC4594
*/
dscp = (tos >> 2);
if (dscp == 0)
up = 0;
else if (dscp >= 1 && dscp <= 9)
up = 1;
else if (dscp >= 10 && dscp <= 16)
up = 2;
else if (dscp >= 17 && dscp <= 23)
up = 3;
else if (dscp >= 24 && dscp <= 31)
up = 4;
else if (dscp >= 33 && dscp <= 40)
up = 5;
else if ((dscp >= 41 && dscp <= 47) || (dscp == 32))
up = 6;
else if (dscp >= 48 && dscp <= 63)
up = 7;
return up;
}
#if 0 //RTW_PHL_TX: mark un-finished codes for reading
static void set_qos_core(struct xmit_frame *pxframe)
{
s32 UserPriority = 0;
if (!pxframe->pkt)
goto null_pkt;
/* get UserPriority from IP hdr */
if (pxframe->attrib.ether_type == 0x0800) {
struct pkt_file ppktfile;
struct ethhdr etherhdr;
struct iphdr ip_hdr;
_rtw_open_pktfile(pxframe->pkt, &ppktfile);
_rtw_pktfile_read(&ppktfile, (unsigned char *)ðerhdr, ETH_HLEN);
_rtw_pktfile_read(&ppktfile, (u8 *)&ip_hdr, sizeof(ip_hdr));
UserPriority = tos_to_up(ip_hdr.tos);
}
#ifdef CONFIG_ICMP_VOQ
if (pxframe->attrib.icmp_pkt == 1)/*use VO queue to send icmp packet*/
UserPriority = 7;
#endif
#ifdef CONFIG_IP_R_MONITOR
if (pxframe->attrib.ether_type == ETH_P_ARP)
UserPriority = 7;
#endif/*CONFIG_IP_R_MONITOR*/
null_pkt:
pxframe->attrib.priority = UserPriority;
pxframe->attrib.hdrlen = WLAN_HDR_A3_QOS_LEN;
pxframe->attrib.subtype = WIFI_QOS_DATA_TYPE;
}
#endif
static void set_qos(struct sk_buff *pkt, struct pkt_attrib *pattrib)
{
s32 UserPriority = 0;
if (!pkt)
goto null_pkt;
/* get UserPriority from IP hdr */
if (pattrib->ether_type == 0x0800) {
struct pkt_file ppktfile;
struct ethhdr etherhdr;
struct iphdr ip_hdr;
_rtw_open_pktfile(pkt, &ppktfile);
_rtw_pktfile_read(&ppktfile, (unsigned char *)ðerhdr, ETH_HLEN);
_rtw_pktfile_read(&ppktfile, (u8 *)&ip_hdr, sizeof(ip_hdr));
/* UserPriority = (ntohs(ip_hdr.tos) >> 5) & 0x3; */
UserPriority = tos_to_up(ip_hdr.tos);
}
/*
else if (pattrib->ether_type == 0x888e) {
UserPriority = 7;
}
*/
#ifdef CONFIG_ICMP_VOQ
if (pattrib->icmp_pkt == 1)/*use VO queue to send icmp packet*/
UserPriority = 7;
#endif
#ifdef CONFIG_IP_R_MONITOR
if (pattrib->ether_type == ETH_P_ARP)
UserPriority = 7;
#endif/*CONFIG_IP_R_MONITOR*/
null_pkt:
pattrib->priority = UserPriority;
pattrib->hdrlen = XATTRIB_GET_WDS(pattrib) ? WLAN_HDR_A4_QOS_LEN : WLAN_HDR_A3_QOS_LEN;
pattrib->subtype = WIFI_QOS_DATA_TYPE;
}
#ifdef CONFIG_TDLS
u8 rtw_check_tdls_established(_adapter *padapter, struct pkt_attrib *pattrib)
{
pattrib->ptdls_sta = NULL;
pattrib->direct_link = _FALSE;
if (padapter->tdlsinfo.link_established == _TRUE) {
pattrib->ptdls_sta = rtw_get_stainfo(&padapter->stapriv, pattrib->dst);
#if 1
if ((pattrib->ptdls_sta != NULL) &&
(pattrib->ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) &&
(pattrib->ether_type != 0x0806)) {
pattrib->direct_link = _TRUE;
/* RTW_INFO("send ptk to "MAC_FMT" using direct link\n", MAC_ARG(pattrib->dst)); */
}
#else
if (pattrib->ptdls_sta != NULL &&
pattrib->ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) {
pattrib->direct_link = _TRUE;
#if 0
RTW_INFO("send ptk to "MAC_FMT" using direct link\n", MAC_ARG(pattrib->dst));
#endif
}
/* ARP frame may be helped by AP*/
if (pattrib->ether_type != 0x0806)
pattrib->direct_link = _FALSE;
#endif
}
return pattrib->direct_link;
}
s32 update_tdls_attrib(_adapter *padapter, struct pkt_attrib *pattrib)
{
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
s32 res = _SUCCESS;
psta = rtw_get_stainfo(pstapriv, pattrib->ra);
if (psta == NULL) {
res = _FAIL;
goto exit;
}
pattrib->mac_id = psta->phl_sta->macid;
pattrib->psta = psta;
pattrib->ack_policy = 0;
/* get ether_hdr_len */
pattrib->pkt_hdrlen = ETH_HLEN;
pattrib->qos_en = psta->qos_option;
/* [TDLS] TODO: setup req/rsp should be AC_BK */
if (pqospriv->qos_option && psta->qos_option) {
pattrib->priority = 4; /* tdls management frame should be AC_VI */
pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
pattrib->subtype = WIFI_QOS_DATA_TYPE;
} else {
pattrib->priority = 0;
pattrib->hdrlen = WLAN_HDR_A3_LEN;
pattrib->subtype = WIFI_DATA_TYPE;
}
/* TODO:_lock */
if (update_attrib_sec_info(padapter, pattrib, psta, NON_EAPOL) == _FAIL) {
res = _FAIL;
goto exit;
}
update_attrib_phy_info(padapter, pattrib, psta);
exit:
return res;
}
#endif /* CONFIG_TDLS */
#ifdef CONFIG_LPS
#define LPS_PT_NORMAL 0
#define LPS_PT_SP 1/* only DHCP packets is as SPECIAL_PACKET*/
#define LPS_PT_ICMP 2
/*If EAPOL , ARP , OR DHCP packet, driver must be in active mode.*/
static u8 _rtw_lps_chk_packet_type(struct pkt_attrib *pattrib)
{
u8 pkt_type = LPS_PT_NORMAL; /*normal data frame*/
#ifdef CONFIG_WAPI_SUPPORT
if ((pattrib->ether_type == 0x88B4) || (pattrib->ether_type == 0x0806) || (pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1))
pkt_type = LPS_PT_SP;
#else /* !CONFIG_WAPI_SUPPORT */
#ifndef CONFIG_LPS_NOT_LEAVE_FOR_ICMP
if (pattrib->icmp_pkt == 1)
pkt_type = LPS_PT_ICMP;
else
#endif
if (pattrib->dhcp_pkt == 1)
pkt_type = LPS_PT_SP;
#endif
return pkt_type;
}
#endif
#if 0 //RTW_PHL_TX: mark un-finished codes for reading
static s32 update_xmitframe_from_hdr(_adapter *padapter, struct xmit_frame *pxframe)
{
uint i;
struct pkt_file pktfile;
struct sta_info *psta = NULL;
struct ethhdr etherhdr;
struct sk_buff *pkt = NULL;
sint bmcast;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
PHLTX_LOG;
if (pxframe->pkt)
pkt = pxframe->pkt;
else
return FAIL;
PHLTX_LOG;
_rtw_open_pktfile(pkt, &pktfile);
i = _rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN);
pxframe->attrib.ether_type = ntohs(etherhdr.h_proto);
if (MLME_IS_MESH(padapter)) /* address resolve is done for mesh */
goto get_sta_info;
_rtw_memcpy(pxframe->attrib.dst, ðerhdr.h_dest, ETH_ALEN);
_rtw_memcpy(pxframe->attrib.src, ðerhdr.h_source, ETH_ALEN);
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
_rtw_memcpy(pxframe->attrib.ra, pxframe->attrib.dst, ETH_ALEN);
_rtw_memcpy(pxframe->attrib.ta, adapter_mac_addr(padapter), ETH_ALEN);
} else if (MLME_IS_STA(padapter)) {
#if 0//def CONFIG_TDLS //rtw_phl_tx
if (rtw_check_tdls_established(padapter, pattrib) == _TRUE)
_rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN); /* For TDLS direct link Tx, set ra to be same to dst */
else
#endif
_rtw_memcpy(pxframe->attrib.ra, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pxframe->attrib.ta, adapter_mac_addr(padapter), ETH_ALEN);
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_sta);
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
_rtw_memcpy(pxframe->attrib.ra, pxframe->attrib.dst, ETH_ALEN);
_rtw_memcpy(pxframe->attrib.ta, get_bssid(pmlmepriv), ETH_ALEN);
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_ap);
} else
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_unknown);
PHLTX_LOG;
get_sta_info:
bmcast = IS_MCAST(pxframe->attrib.ra);
if (bmcast) {
PHLTX_LOG;
psta = rtw_get_bcmc_stainfo(padapter);
if (psta == NULL) { /* if we cannot get psta => drop the pkt */
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sta);
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pxframe->attrib.ra));
#endif
return FAIL;
}
} else {
PHLTX_LOG;
psta = rtw_get_stainfo(pstapriv, pxframe->attrib.ra);
if (psta == NULL) { /* if we cannot get psta => drop the pkt */
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_ucast_sta);
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pxframe->attrib.ra));
#endif
return FAIL;
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && !(psta->state & WIFI_ASOC_STATE)) {
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_ucast_ap_link);
return FAIL;
}
}
PHLTX_LOG;
if (!(psta->state & WIFI_ASOC_STATE)) {
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_link);
RTW_INFO("%s-"ADPT_FMT" psta("MAC_FMT")->state(0x%x) != WIFI_ASOC_STATE\n",
__func__, ADPT_ARG(padapter), MAC_ARG(psta->phl_sta->mac_addr), psta->state);
return FAIL;
}
pxframe->attrib.psta = psta;
PHLTX_LOG;
pxframe->attrib.pktlen = pktfile.pkt_len;
/* TODO: 802.1Q VLAN header */
/* TODO: IPV6 */
if (ETH_P_IP == pxframe->attrib.ether_type) {
u8 ip[20];
_rtw_pktfile_read(&pktfile, ip, 20);
if (GET_IPV4_IHL(ip) * 4 > 20)
_rtw_pktfile_read(&pktfile, NULL, GET_IPV4_IHL(ip) - 20);
pxframe->attrib.icmp_pkt = 0;
pxframe->attrib.dhcp_pkt = 0;
pxframe->attrib.hipriority_pkt = 0;
if (GET_IPV4_PROTOCOL(ip) == 0x01) { /* ICMP */
pxframe->attrib.icmp_pkt = 1;
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_icmp);
} else if (GET_IPV4_PROTOCOL(ip) == 0x11) { /* UDP */
u8 udp[24];
_rtw_pktfile_read(&pktfile, udp, 24);
if ((GET_UDP_SRC(udp) == 68 && GET_UDP_DST(udp) == 67)
|| (GET_UDP_SRC(udp) == 67 && GET_UDP_DST(udp) == 68)
) {
/* 67 : UDP BOOTP server, 68 : UDP BOOTP client */
if (pxframe->attrib.pktlen > 282) { /* MINIMUM_DHCP_PACKET_SIZE */
pxframe->attrib.dhcp_pkt = 1;
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_dhcp);
if (0)
RTW_INFO("send DHCP packet\n");
}
}
/* WaveAgent packet, increase priority so that the system can read data in time */
if (((GET_UDP_SIG1(udp) == 0xcc) || (GET_UDP_SIG1(udp) == 0xdd)) &&
(GET_UDP_SIG2(udp) == 0xe2)) {
pxframe->attrib.hipriority_pkt = 1;
}
} else if (GET_IPV4_PROTOCOL(ip) == 0x06 /* TCP */
&& rtw_st_ctl_chk_reg_s_proto(&psta->st_ctl, 0x06) == _TRUE
) {
u8 tcp[20];
_rtw_pktfile_read(&pktfile, tcp, 20);
if (rtw_st_ctl_chk_reg_rule(&psta->st_ctl, padapter, IPV4_SRC(ip), TCP_SRC(tcp), IPV4_DST(ip), TCP_DST(tcp)) == _TRUE) {
if (GET_TCP_SYN(tcp) && GET_TCP_ACK(tcp)) {
session_tracker_add_cmd(padapter, psta
, IPV4_SRC(ip), TCP_SRC(tcp)
, IPV4_SRC(ip), TCP_DST(tcp));
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" local:"IP_FMT":"PORT_FMT", remote:"IP_FMT":"PORT_FMT" SYN-ACK\n"
, FUNC_ADPT_ARG(padapter)
, IP_ARG(IPV4_SRC(ip)), PORT_ARG(TCP_SRC(tcp))
, IP_ARG(IPV4_DST(ip)), PORT_ARG(TCP_DST(tcp)));
}
if (GET_TCP_FIN(tcp)) {
session_tracker_del_cmd(padapter, psta
, IPV4_SRC(ip), TCP_SRC(tcp)
, IPV4_SRC(ip), TCP_DST(tcp));
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" local:"IP_FMT":"PORT_FMT", remote:"IP_FMT":"PORT_FMT" FIN\n"
, FUNC_ADPT_ARG(padapter)
, IP_ARG(IPV4_SRC(ip)), PORT_ARG(TCP_SRC(tcp))
, IP_ARG(IPV4_DST(ip)), PORT_ARG(TCP_DST(tcp)));
}
}
}
} else if (0x888e == pxframe->attrib.ether_type)
parsing_eapol_packet(padapter, pktfile.cur_addr, psta, 1);
#if defined (DBG_ARP_DUMP) || defined (DBG_IP_R_MONITOR)
else if (pxframe->attrib.ether_type == ETH_P_ARP) {
u8 arp[28] = {0};
_rtw_pktfile_read(&pktfile, arp, 28);
dump_arp_pkt(RTW_DBGDUMP, etherhdr.h_dest, etherhdr.h_source, arp, 1);
}
#endif
PHLTX_LOG;
if ((pxframe->attrib.ether_type == 0x888e) || (pxframe->attrib.dhcp_pkt == 1))
rtw_mi_set_scan_deny(padapter, 3000);
if (MLME_IS_STA(padapter) &&
pxframe->attrib.ether_type == ETH_P_ARP &&
!IS_MCAST(pxframe->attrib.dst)) {
rtw_mi_set_scan_deny(padapter, 1000);
rtw_mi_scan_abort(padapter, _FALSE); /*rtw_scan_abort_no_wait*/
}
PHLTX_LOG;
/* get ether_hdr_len */
pxframe->attrib.pkt_hdrlen = ETH_HLEN;/* (pattrib->ether_type == 0x8100) ? (14 + 4 ): 14; */ /* vlan tag */
pxframe->attrib.hdrlen = WLAN_HDR_A3_LEN;
pxframe->attrib.type = WIFI_DATA_TYPE;
pxframe->attrib.subtype = WIFI_DATA_TYPE;
pxframe->attrib.qos_en = pxframe->attrib.psta->qos_option;
pxframe->attrib.priority = 0;
pxframe->attrib.frag_len = pxmitpriv->frag_len;
PHLTX_LOG;
return SUCCESS;
}
static s32 update_xmitframe_qos(_adapter *padapter, struct xmit_frame *pxframe)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
if (!pxframe->attrib.qos_en)
return SUCCESS;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE | WIFI_MESH_STATE
| WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE)
) {
set_qos_core(pxframe);
#if 0//rtw_phl_tx def CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter))
rtw_mesh_tx_set_whdr_mctrl_len(pattrib->mesh_frame_mode, pattrib);
#endif
} else {
#if 0// def CONFIG_TDLS
if (pattrib->direct_link == _TRUE) {
if (pattrib->qos_en)
set_qos(pkt, pattrib);
} else
#endif
{
if (pqospriv->qos_option) {
set_qos_core(pxframe);
if (pmlmepriv->acm_mask != 0)
pxframe->attrib.priority = qos_acm(pmlmepriv->acm_mask, pxframe->attrib.priority);
}
}
}
return SUCCESS;
}
static s32 update_xmitframe_security(_adapter *padapter, struct xmit_frame *pxframe) //rtw_phl_tx todo
{
sint res = _SUCCESS;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
sint bmcast = IS_MCAST(pxframe->attrib.ra);
#if 0
_rtw_memset(pattrib->dot118021x_UncstKey.skey, 0, 16);
_rtw_memset(pattrib->dot11tkiptxmickey.skey, 0, 16);
pattrib->mac_id = psta->phl_sta->macid;
#endif
if (pxframe->attrib.psta->ieee8021x_blocked == _TRUE) {
pxframe->attrib.encrypt = 0;
if ((pxframe->attrib.ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _FALSE)) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s psta->ieee8021x_blocked == _TRUE, pattrib->ether_type(%04x) != 0x888e\n", __FUNCTION__, pxframe->attrib.ether_type);
#endif
res = _FAIL;
goto exit;
}
} else {
GET_ENCRY_ALGO(psecuritypriv, pxframe->attrib.psta, pxframe->attrib.encrypt, bmcast);
#ifdef CONFIG_WAPI_SUPPORT
if (pxframe->attrib.ether_type == 0x88B4)
pxframe->attrib.encrypt = _NO_PRIVACY_;
#endif
switch (psecuritypriv->dot11AuthAlgrthm) {
case dot11AuthAlgrthm_Open:
case dot11AuthAlgrthm_Shared:
case dot11AuthAlgrthm_Auto:
pxframe->attrib.key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex;
break;
case dot11AuthAlgrthm_8021X:
if (bmcast)
pxframe->attrib.key_idx = (u8)psecuritypriv->dot118021XGrpKeyid;
else
pxframe->attrib.key_idx = 0;
break;
default:
pxframe->attrib.key_idx = 0;
break;
}
/* For WPS 1.0 WEP, driver should not encrypt EAPOL Packet for WPS handshake. */
if (((pxframe->attrib.encrypt == _WEP40_) || (pxframe->attrib.encrypt == _WEP104_)) && (pxframe->attrib.ether_type == 0x888e))
pxframe->attrib.encrypt = _NO_PRIVACY_;
}
#if 0 //def CONFIG_TDLS
if (pattrib->direct_link == _TRUE) {
if (pxframe->attrib.encrypt > 0)
pxframe->attrib.encrypt = _AES_;
}
#endif
switch (pxframe->attrib.encrypt) {
case _WEP40_:
case _WEP104_:
pxframe->attrib.iv_len = 4;
pxframe->attrib.icv_len = 4;
WEP_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, pxframe->attrib.key_idx);
break;
case _TKIP_:
pxframe->attrib.iv_len = 8;
pxframe->attrib.icv_len = 4;
if (psecuritypriv->busetkipkey == _FAIL) {
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s psecuritypriv->busetkipkey(%d)==_FAIL drop packet\n", __FUNCTION__, psecuritypriv->busetkipkey);
#endif
res = _FAIL;
goto exit;
}
if (bmcast)
TKIP_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, pxframe->attrib.key_idx);
else
TKIP_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, 0);
//_rtw_memcpy(pattrib->dot11tkiptxmickey.skey, pxframe->attrib.psta->dot11tkiptxmickey.skey, 16);
break;
case _AES_:
pxframe->attrib.iv_len = 8;
pxframe->attrib.icv_len = 8;
if (bmcast)
AES_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, pxframe->attrib.key_idx);
else
AES_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, 0);
break;
case _GCMP_:
case _GCMP_256_:
pxframe->attrib.iv_len = 8;
pxframe->attrib.icv_len = 16;
if (bmcast)
GCMP_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, pxframe->attrib.key_idx);
else
GCMP_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, 0);
break;
case _CCMP_256_:
pxframe->attrib.iv_len = 8;
pxframe->attrib.icv_len = 16;
if (bmcast)
GCMP_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, pxframe->attrib.key_idx);
else
GCMP_IV(pxframe->attrib.iv, pxframe->attrib.psta->dot11txpn, 0);
break;
#ifdef CONFIG_WAPI_SUPPORT
case _SMS4_:
pxframe->attrib.iv_len = 18;
pxframe->attrib.icv_len = 16;
rtw_wapi_get_iv(padapter, pxframe->attrib.ra, pxframe->attrib.iv);
break;
#endif
default:
pxframe->attrib.iv_len = 0;
pxframe->attrib.icv_len = 0;
break;
}
#if 0
if (pxframe->attrib.encrypt > 0) {
_rtw_memcpy(pattrib->dot118021x_UncstKey.skey
, pxframe->attrib.psta->dot118021x_UncstKey.skey
, (pxframe->attrib.encrypt & _SEC_TYPE_256_) ? 32 : 16);
}
#endif
if (pxframe->attrib.encrypt &&
((padapter->securitypriv.sw_encrypt == _TRUE) || (psecuritypriv->hw_decrypted == _FALSE))) {
pxframe->attrib.bswenc = _TRUE;
} else {
pxframe->attrib.bswenc = _FALSE;
}
#if defined(CONFIG_CONCURRENT_MODE)
//pattrib->bmc_camid = padapter->securitypriv.dot118021x_bmc_cam_id;
#endif
#ifdef CONFIG_WAPI_SUPPORT
if (pxframe->attrib.encrypt == _SMS4_)
pxframe->attrib.bswenc = _FALSE;
#endif
exit:
return res;
}
static s32 update_xmitframe_hw(_adapter *padapter, struct xmit_frame *pxframe)
{
pxframe->phl_txreq->mdata.rts_en = pxframe->attrib.psta->rtsen;
pxframe->phl_txreq->mdata.cts2self = pxframe->attrib.psta->cts2self;
pxframe->phl_txreq->mdata.ampdu_density = 0;
return 0;
}
#if 0
static s32 rtw_core_update_txattrib(_adapter *padapter, struct xmit_frame *pxframe)
{
uint i;
struct pkt_file pktfile;
struct sta_info *psta = NULL;
struct ethhdr etherhdr;
struct sk_buff *pkt = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
sint res = _SUCCESS;
#if 0//rtw_phl_tx todo def CONFIG_LPS
pkt_type = _rtw_lps_chk_packet_type(pattrib);
if (pkt_type == LPS_PT_SP) {/*packet is as SPECIAL_PACKET*/
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_active);
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SPECIAL_PACKET, 0);
} else if (pkt_type == LPS_PT_ICMP)
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 0);
#endif /* CONFIG_LPS */
#if 0//rtw_phl_tx todo def CONFIG_BEAMFORMING
update_attrib_txbf_info(padapter, pattrib, psta);
#endif
#if 0
/* TODO:_lock */
if (update_attrib_sec_info(padapter, pattrib, psta, NON_EAPOL) == _FAIL) {
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sec);
res = _FAIL;
goto exit;
}
#endif
update_attrib_phy_info(padapter, pattrib, psta);
/* RTW_INFO("%s ==> mac_id(%d)\n",__FUNCTION__,pattrib->mac_id ); */
/* TODO:_unlock */
#ifdef CONFIG_AUTO_AP_MODE
if (psta->isrc && psta->pid > 0)
pattrib->pctrl = _TRUE;
else
#endif
pattrib->pctrl = 0;
pattrib->ack_policy = 0;
if (bmcast)
pattrib->rate = psta->init_rate;
#ifdef CONFIG_WMMPS_STA
update_attrib_trigger_frame_info(padapter, pattrib);
#endif /* CONFIG_WMMPS_STA */
/* pattrib->priority = 5; */ /* force to used VI queue, for testing */
pattrib->hw_ssn_sel = pxmitpriv->hw_ssn_seq_no;
pattrib->wdinfo_en = 1;/*FPGA_test YiWei need modify*/
rtw_set_tx_chksum_offload(pkt, pattrib);
exit:
return res;
}
#endif
#endif
static u8 rtw_chk_htc_en(_adapter *padapter, struct sta_info *psta, struct pkt_attrib *pattrib)
{
#ifdef CONFIG_80211AX_HE
if (psta->hepriv.he_option == _TRUE) {
/*By test, some HE AP eapol & arp & dhcp pkt can not append ht control*/
if ((0x888e == pattrib->ether_type) || (0x0806 == pattrib->ether_type) || (pattrib->dhcp_pkt == 1))
return 0;
else
return rtw_he_htc_en(padapter, psta);
}
#endif
return 0;
}
static s32 update_attrib(_adapter *padapter, struct sk_buff *pkt, struct pkt_attrib *pattrib)
{
uint i;
struct pkt_file pktfile;
struct sta_info *psta = NULL;
struct ethhdr etherhdr;
sint bmcast;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
sint res = _SUCCESS;
enum eap_type eapol_type = NON_EAPOL;
#ifdef CONFIG_LPS
u8 pkt_type = 0;
#endif
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib);
_rtw_open_pktfile(pkt, &pktfile);
i = _rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN);
pattrib->ether_type = ntohs(etherhdr.h_proto);
if (MLME_STATE(padapter) & (WIFI_AP_STATE | WIFI_MESH_STATE)) /* address resolve is done for ap/mesh */
goto get_sta_info;
_rtw_memcpy(pattrib->dst, ðerhdr.h_dest, ETH_ALEN);
_rtw_memcpy(pattrib->src, ðerhdr.h_source, ETH_ALEN);
_rtw_memcpy(pattrib->ta, adapter_mac_addr(padapter), ETH_ALEN);
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
_rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_adhoc);
} else if (MLME_IS_STA(padapter)) {
#ifdef CONFIG_TDLS
if (rtw_check_tdls_established(padapter, pattrib) == _TRUE)
_rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN); /* For TDLS direct link Tx, set ra to be same to dst */
else
#endif
{
_rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
#ifdef CONFIG_RTW_WDS
if (adapter_use_wds(padapter)
&& _rtw_memcmp(pattrib->src, pattrib->ta, ETH_ALEN) == _FALSE
) {
pattrib->wds = 1;
if (IS_MCAST(pattrib->dst))
rtw_tx_wds_gptr_update(padapter, pattrib->src);
}
#endif
}
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_sta);
} else
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_unknown);
get_sta_info:
bmcast = IS_MCAST(pattrib->ra);
if (bmcast) {
psta = rtw_get_bcmc_stainfo(padapter);
if (psta == NULL) { /* if we cannot get psta => drop the pkt */
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sta);
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pattrib->ra));
#endif
res = _FAIL;
goto exit;
}
} else {
psta = rtw_get_stainfo(pstapriv, pattrib->ra);
if (psta == NULL) { /* if we cannot get psta => drop the pkt */
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_ucast_sta);
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pattrib->ra));
#endif
res = _FAIL;
goto exit;
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && !(psta->state & WIFI_ASOC_STATE)) {
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_ucast_ap_link);
res = _FAIL;
goto exit;
}
#ifdef CONFIG_RTW_WDS
if (XATTRIB_GET_WDS(pattrib) && !(psta->flags & WLAN_STA_WDS))
pattrib->wds = 0;
#endif
}
if (!(psta->state & WIFI_ASOC_STATE)) {
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_link);
RTW_INFO("%s-"ADPT_FMT" psta("MAC_FMT")->state(0x%x) != WIFI_ASOC_STATE\n",
__func__, ADPT_ARG(padapter), MAC_ARG(psta->phl_sta->mac_addr), psta->state);
res = _FAIL;
goto exit;
}
pattrib->pktlen = pktfile.pkt_len;
#ifdef CONFIG_CORE_TXSC
pattrib->frag_len = pxmitpriv->frag_len;
#endif
/* TODO: 802.1Q VLAN header */
/* TODO: IPV6 */
if (ETH_P_IP == pattrib->ether_type) {
u8 ip[20];
_rtw_pktfile_read(&pktfile, ip, 20);
if (GET_IPV4_IHL(ip) * 4 > 20)
_rtw_pktfile_read(&pktfile, NULL, GET_IPV4_IHL(ip) - 20);
pattrib->icmp_pkt = 0;
pattrib->dhcp_pkt = 0;
pattrib->hipriority_pkt = 0;
if (GET_IPV4_PROTOCOL(ip) == 0x01) { /* ICMP */
pattrib->icmp_pkt = 1;
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_icmp);
} else if (GET_IPV4_PROTOCOL(ip) == 0x11) { /* UDP */
u8 udp[24];
_rtw_pktfile_read(&pktfile, udp, 24);
if ((GET_UDP_SRC(udp) == 68 && GET_UDP_DST(udp) == 67)
|| (GET_UDP_SRC(udp) == 67 && GET_UDP_DST(udp) == 68)
) {
/* 67 : UDP BOOTP server, 68 : UDP BOOTP client */
if (pattrib->pktlen > 282) { /* MINIMUM_DHCP_PACKET_SIZE */
pattrib->dhcp_pkt = 1;
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_dhcp);
if (0)
RTW_INFO("send DHCP packet\n");
}
}
/* WaveAgent packet, increase priority so that the system can read data in time */
if (((GET_UDP_SIG1(udp) == 0xcc) || (GET_UDP_SIG1(udp) == 0xdd)) &&
(GET_UDP_SIG2(udp) == 0xe2)) {
pattrib->hipriority_pkt = 1;
}
} else if (GET_IPV4_PROTOCOL(ip) == 0x06 /* TCP */
&& rtw_st_ctl_chk_reg_s_proto(&psta->st_ctl, 0x06) == _TRUE
) {
u8 tcp[20];
_rtw_pktfile_read(&pktfile, tcp, 20);
if (rtw_st_ctl_chk_reg_rule(&psta->st_ctl, padapter, IPV4_SRC(ip), TCP_SRC(tcp), IPV4_DST(ip), TCP_DST(tcp)) == _TRUE) {
if (GET_TCP_SYN(tcp) && GET_TCP_ACK(tcp)) {
session_tracker_add_cmd(padapter, psta
, IPV4_SRC(ip), TCP_SRC(tcp)
, IPV4_SRC(ip), TCP_DST(tcp));
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" local:"IP_FMT":"PORT_FMT", remote:"IP_FMT":"PORT_FMT" SYN-ACK\n"
, FUNC_ADPT_ARG(padapter)
, IP_ARG(IPV4_SRC(ip)), PORT_ARG(TCP_SRC(tcp))
, IP_ARG(IPV4_DST(ip)), PORT_ARG(TCP_DST(tcp)));
}
if (GET_TCP_FIN(tcp)) {
session_tracker_del_cmd(padapter, psta
, IPV4_SRC(ip), TCP_SRC(tcp)
, IPV4_SRC(ip), TCP_DST(tcp));
if (DBG_SESSION_TRACKER)
RTW_INFO(FUNC_ADPT_FMT" local:"IP_FMT":"PORT_FMT", remote:"IP_FMT":"PORT_FMT" FIN\n"
, FUNC_ADPT_ARG(padapter)
, IP_ARG(IPV4_SRC(ip)), PORT_ARG(TCP_SRC(tcp))
, IP_ARG(IPV4_DST(ip)), PORT_ARG(TCP_DST(tcp)));
}
}
}
} else if (0x888e == pattrib->ether_type)
eapol_type = parsing_eapol_packet(padapter, pktfile.cur_addr, psta, 1);
#if defined (DBG_ARP_DUMP) || defined (DBG_IP_R_MONITOR)
else if (pattrib->ether_type == ETH_P_ARP) {
u8 arp[28] = {0};
_rtw_pktfile_read(&pktfile, arp, 28);
dump_arp_pkt(RTW_DBGDUMP, etherhdr.h_dest, etherhdr.h_source, arp, 1);
}
#endif
if ((pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1))
rtw_mi_set_scan_deny(padapter, 3000);
if (MLME_IS_STA(padapter) &&
pattrib->ether_type == ETH_P_ARP &&
!IS_MCAST(pattrib->dst)) {
rtw_mi_set_scan_deny(padapter, 1000);
rtw_mi_scan_abort(padapter, _FALSE); /*rtw_scan_abort_no_wait*/
}
#ifdef CONFIG_LPS
pkt_type = _rtw_lps_chk_packet_type(pattrib);
if (pkt_type == LPS_PT_SP) {/*packet is as SPECIAL_PACKET*/
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_active);
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SPECIAL_PACKET, 0);
} else if (pkt_type == LPS_PT_ICMP)
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 0);
#endif /* CONFIG_LPS */
/* TODO:_lock */
if (update_attrib_sec_info(padapter, pattrib, psta, eapol_type) == _FAIL) {
DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sec);
res = _FAIL;
goto exit;
}
/* get ether_hdr_len */
pattrib->pkt_hdrlen = ETH_HLEN;/* (pattrib->ether_type == 0x8100) ? (14 + 4 ): 14; */ /* vlan tag */
pattrib->hdrlen = XATTRIB_GET_WDS(pattrib) ? WLAN_HDR_A4_LEN : WLAN_HDR_A3_LEN;
pattrib->type = WIFI_DATA_TYPE;
pattrib->subtype = WIFI_DATA_TYPE;
pattrib->qos_en = psta->qos_option;
pattrib->priority = 0;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE | WIFI_MESH_STATE
| WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE)
) {
if (pattrib->qos_en) {
set_qos(pkt, pattrib);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter))
rtw_mesh_tx_set_whdr_mctrl_len(pattrib->mesh_frame_mode, pattrib);
#endif
}
} else {
#ifdef CONFIG_TDLS
if (pattrib->direct_link == _TRUE) {
if (pattrib->qos_en)
set_qos(pkt, pattrib);
} else
#endif
{
if (pqospriv->qos_option) {
set_qos(pkt, pattrib);
if (pmlmepriv->acm_mask != 0)
pattrib->priority = qos_acm(pmlmepriv->acm_mask, pattrib->priority);
}
}
}
pattrib->order = rtw_chk_htc_en(padapter, psta, pattrib);
if (pattrib->order) {
if (pattrib->qos_en)
pattrib->hdrlen = XATTRIB_GET_WDS(pattrib) ? WLAN_HDR_A4_QOS_HTC_LEN : WLAN_HDR_A3_QOS_HTC_LEN;
else
pattrib->hdrlen = XATTRIB_GET_WDS(pattrib) ? WLAN_HDR_A4_HTC_LEN : WLAN_HDR_A3_HTC_LEN;
}
update_attrib_phy_info(padapter, pattrib, psta);
/* RTW_INFO("%s ==> mac_id(%d)\n",__FUNCTION__,pattrib->mac_id ); */
pattrib->psta = psta;
/* TODO:_unlock */
#ifdef CONFIG_AUTO_AP_MODE
if (psta->isrc && psta->pid > 0)
pattrib->pctrl = _TRUE;
else
#endif
pattrib->pctrl = 0;
pattrib->ack_policy = 0;
if (bmcast)
pattrib->rate = psta->init_rate;
#ifdef CONFIG_WMMPS_STA
update_attrib_trigger_frame_info(padapter, pattrib);
#endif /* CONFIG_WMMPS_STA */
/* pattrib->priority = 5; */ /* force to used VI queue, for testing */
pattrib->hw_ssn_sel = pxmitpriv->hw_ssn_seq_no;
pattrib->wdinfo_en = 1;/*FPGA_test YiWei need modify*/
rtw_set_tx_chksum_offload(pkt, pattrib);
exit:
return res;
}
static s32 xmitframe_addmic(_adapter *padapter, struct xmit_frame *pxmitframe)
{
sint curfragnum, length;
u8 *pframe, *payload, mic[8];
struct mic_data micdata;
/* struct sta_info *stainfo; */
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
u8 hw_hdr_offset = 0;
sint bmcst = IS_MCAST(pattrib->ra);
/*
if(pattrib->psta)
{
stainfo = pattrib->psta;
}
else
{
RTW_INFO("%s, call rtw_get_stainfo()\n", __func__);
stainfo=rtw_get_stainfo(&padapter->stapriv ,&pattrib->ra[0]);
}
if(stainfo==NULL)
{
RTW_INFO("%s, psta==NUL\n", __func__);
return _FAIL;
}
if(!(stainfo->state &WIFI_ASOC_STATE))
{
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, stainfo->state);
return _FAIL;
}
*/
#ifdef CONFIG_USB_TX_AGGREGATION
hw_hdr_offset = TXDESC_SIZE + (pxmitframe->pkt_offset * PACKET_OFFSET_SZ);;
#else
#ifdef CONFIG_TX_EARLY_MODE
hw_hdr_offset = TXDESC_OFFSET + EARLY_MODE_INFO_SIZE;
#else
hw_hdr_offset = TXDESC_OFFSET;
#endif
#endif
if (pattrib->encrypt == _TKIP_) { /* if(psecuritypriv->dot11PrivacyAlgrthm==_TKIP_PRIVACY_) */
/* encode mic code */
/* if(stainfo!= NULL) */
{
u8 null_key[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
pframe = pxmitframe->buf_addr + hw_hdr_offset;
if (bmcst) {
if (_rtw_memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16) == _TRUE) {
/* DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey==0\n"); */
/* rtw_msleep_os(10); */
return _FAIL;
}
/* start to calculate the mic code */
rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
} else {
if (_rtw_memcmp(&pattrib->dot11tkiptxmickey.skey[0], null_key, 16) == _TRUE) {
/* DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey==0\n"); */
/* rtw_msleep_os(10); */
return _FAIL;
}
/* start to calculate the mic code */
rtw_secmicsetkey(&micdata, &pattrib->dot11tkiptxmickey.skey[0]);
}
if (pframe[1] & 1) { /* ToDS==1 */
rtw_secmicappend(&micdata, &pframe[16], 6); /* DA */
if (pframe[1] & 2) /* From Ds==1 */
rtw_secmicappend(&micdata, &pframe[24], 6);
else
rtw_secmicappend(&micdata, &pframe[10], 6);
} else { /* ToDS==0 */
rtw_secmicappend(&micdata, &pframe[4], 6); /* DA */
if (pframe[1] & 2) /* From Ds==1 */
rtw_secmicappend(&micdata, &pframe[16], 6);
else
rtw_secmicappend(&micdata, &pframe[10], 6);
}
if (pattrib->qos_en)
priority[0] = (u8)pxmitframe->attrib.priority;
rtw_secmicappend(&micdata, &priority[0], 4);
payload = pframe;
for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
payload = (u8 *)RND4((SIZE_PTR)(payload));
payload = payload + pattrib->hdrlen + pattrib->iv_len;
if ((curfragnum + 1) == pattrib->nr_frags) {
length = pattrib->last_txcmdsz - pattrib->hdrlen - pattrib->iv_len - ((pattrib->bswenc) ? pattrib->icv_len : 0);
rtw_secmicappend(&micdata, payload, length);
payload = payload + length;
} else {
length = pxmitpriv->frag_len - pattrib->hdrlen - pattrib->iv_len - ((pattrib->bswenc) ? pattrib->icv_len : 0);
rtw_secmicappend(&micdata, payload, length);
payload = payload + length + pattrib->icv_len;
}
}
rtw_secgetmic(&micdata, &(mic[0]));
/* add mic code and add the mic code length in last_txcmdsz */
_rtw_memcpy(payload, &(mic[0]), 8);
pattrib->last_txcmdsz += 8;
payload = payload - pattrib->last_txcmdsz + 8;
}
}
return _SUCCESS;
}
/*#define DBG_TX_SW_ENCRYPTOR*/
static s32 xmitframe_swencrypt(_adapter *padapter, struct xmit_frame *pxmitframe)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
if (!pattrib->bswenc)
return _SUCCESS;
#ifdef DBG_TX_SW_ENCRYPTOR
RTW_INFO(ADPT_FMT" - sec_type:%s DO SW encryption\n",
ADPT_ARG(padapter), security_type_str(pattrib->encrypt));
#endif
switch (pattrib->encrypt) {
case _WEP40_:
case _WEP104_:
rtw_wep_encrypt(padapter, (u8 *)pxmitframe);
break;
case _TKIP_:
rtw_tkip_encrypt(padapter, (u8 *)pxmitframe);
break;
case _AES_:
case _CCMP_256_:
rtw_aes_encrypt(padapter, (u8 *)pxmitframe);
break;
case _GCMP_:
case _GCMP_256_:
rtw_gcmp_encrypt(padapter, (u8 *)pxmitframe);
break;
#ifdef CONFIG_WAPI_SUPPORT
case _SMS4_:
rtw_sms4_encrypt(padapter, (u8 *)pxmitframe);
#endif
default:
break;
}
return _SUCCESS;
}
#if 0 //RTW_PHL_TX: mark un-finished codes for reading
static s32 rtw_core_xmitframe_addmic(_adapter *padapter, struct xmit_frame *pxframe)
{
sint curfragnum, payload_length;
u8 *pwlhdr, *payload, mic[8];
struct mic_data micdata;
/* struct sta_info *stainfo; */
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
u8 hw_hdr_offset = 0;
sint bmcst = IS_MCAST(pxframe->attrib.ra);
if (pxframe->attrib.encrypt == _TKIP_) { /* if(psecuritypriv->dot11PrivacyAlgrthm==_TKIP_PRIVACY_) */
/* encode mic code */
/* if(stainfo!= NULL) */
{
u8 null_key[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
pwlhdr = pxframe->wlhdr[0];
payload = pxframe->pkt->data + pxframe->attrib.pkt_hdrlen;
payload_length = pxframe->pkt->len - pxframe->attrib.pkt_hdrlen;
if (bmcst) {
if (_rtw_memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16) == _TRUE) {
/* DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey==0\n"); */
/* rtw_msleep_os(10); */
return _FAIL;
}
/* start to calculate the mic code */
rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
} else {
if (_rtw_memcmp(&pxframe->attrib.psta->dot11tkiptxmickey.skey[0], null_key, 16) == _TRUE) {
/* DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey==0\n"); */
/* rtw_msleep_os(10); */
return _FAIL;
}
/* start to calculate the mic code */
rtw_secmicsetkey(&micdata, &pxframe->attrib.psta->dot11tkiptxmickey.skey[0]);
}
if (pwlhdr[1] & 1) { /* ToDS==1 */
rtw_secmicappend(&micdata, &pwlhdr[16], 6); /* DA */
if (pwlhdr[1] & 2) /* From Ds==1 */
rtw_secmicappend(&micdata, &pwlhdr[24], 6);
else
rtw_secmicappend(&micdata, &pwlhdr[10], 6);
} else { /* ToDS==0 */
rtw_secmicappend(&micdata, &pwlhdr[4], 6); /* DA */
if (pwlhdr[1] & 2) /* From Ds==1 */
rtw_secmicappend(&micdata, &pwlhdr[16], 6);
else
rtw_secmicappend(&micdata, &pwlhdr[10], 6);
}
if (pxframe->attrib.qos_en)
priority[0] = (u8)pxframe->attrib.qos_en;
rtw_secmicappend(&micdata, &priority[0], 4);
payload = (u8 *)RND4((SIZE_PTR)(payload));
rtw_secmicappend(&micdata, payload, payload_length);
rtw_secgetmic(&micdata, &(mic[0]));
/* add mic code and add the mic code length in last_txcmdsz */
_rtw_memcpy(pxframe->wltail[0]+pxframe->attrib.icv_len, &(mic[0]), 8);
}
}
return _SUCCESS;
}
/*#define DBG_TX_SW_ENCRYPTOR*/
static s32 rtw_core_xmitframe_swencrypt(_adapter *padapter, struct xmit_frame *pxframe)
{
if (pxframe->attrib.bswenc) {
#ifdef DBG_TX_SW_ENCRYPTOR
RTW_INFO(ADPT_FMT" - sec_type:%s DO SW encryption\n",
ADPT_ARG(padapter), security_type_str(pxframe->attrib.encrypt));
#endif
switch (pxframe->attrib.encrypt) {
case _WEP40_:
case _WEP104_:
//rtw_wep_encrypt(padapter, (u8 *)pxmitframe);
break;
case _TKIP_:
//rtw_tkip_encrypt(padapter, (u8 *)pxmitframe);
break;
case _AES_:
case _CCMP_256_:
rtw_core_aes_encrypt(padapter, (u8 *)pxframe);
break;
case _GCMP_:
case _GCMP_256_:
//rtw_gcmp_encrypt(padapter, (u8 *)pxmitframe);
break;
#ifdef CONFIG_WAPI_SUPPORT
case _SMS4_:
//rtw_sms4_encrypt(padapter, (u8 *)pxmitframe);
#endif
default:
break;
}
}
return _SUCCESS;
}
s32 rtw_core_make_wlanhdr(_adapter *padapter, u8 *hdr, struct xmit_frame *pxframe)
{
u16 *qc;
struct rtw_ieee80211_hdr *pwlanhdr = (struct rtw_ieee80211_hdr *)hdr;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
u8 qos_option = _FALSE;
sint res = _SUCCESS;
u16 *fctrl = &pwlanhdr->frame_ctl;
_rtw_memset(hdr, 0, WLANHDR_OFFSET);
set_frame_sub_type(fctrl, pxframe->attrib.subtype);
if (pxframe->attrib.subtype & WIFI_DATA_TYPE) {
if (MLME_IS_STA(padapter)) {
#ifdef CONFIG_TDLS
if (pattrib->direct_link == _TRUE) {
/* TDLS data transfer, ToDS=0, FrDs=0 */
_rtw_memcpy(pwlanhdr->addr1, pxframe->attrib.dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pxframe->attrib.src, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
if (pxframe->attrib.qos_en)
qos_option = _TRUE;
} else
#endif /* CONFIG_TDLS */
{
/* to_ds = 1, fr_ds = 0; */
/* 1.Data transfer to AP */
/* 2.Arp pkt will relayed by AP */
SetToDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pxframe->attrib.ta, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pxframe->attrib.dst, ETH_ALEN);
if (pqospriv->qos_option)
qos_option = _TRUE;
}
} else if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)) {
/* to_ds = 0, fr_ds = 1; */
SetFrDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, pxframe->attrib.dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pxframe->attrib.src, ETH_ALEN);
if (pxframe->attrib.qos_en)
qos_option = _TRUE;
} else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
_rtw_memcpy(pwlanhdr->addr1, pxframe->attrib.dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pxframe->attrib.ta, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
if (pxframe->attrib.qos_en)
qos_option = _TRUE;
#ifdef CONFIG_RTW_MESH
} else if (MLME_IS_STA(padapter)) {
rtw_mesh_tx_build_whdr(padapter, pattrib, fctrl, pwlanhdr);
if (pxframe->attrib.qos_en)
qos_option = _TRUE;
else {
RTW_WARN("[%s] !qos_en in Mesh\n", __FUNCTION__);
res = _FAIL;
goto exit;
}
#endif
} else {
res = _FAIL;
goto exit;
}
if (pxframe->attrib.mdata)
SetMData(fctrl);
if (pxframe->attrib.encrypt)
SetPrivacy(fctrl);
if (qos_option) {
qc = (unsigned short *)(hdr + pxframe->attrib.hdrlen - 2);
if (pxframe->attrib.priority)
SetPriority(qc, pxframe->attrib.priority);
SetEOSP(qc, pxframe->attrib.eosp);
SetAckpolicy(qc, pxframe->attrib.ack_policy);
if (pxframe->attrib.amsdu)
SetAMsdu(qc, pxframe->attrib.amsdu);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
/* active: don't care, light sleep: 0, deep sleep: 1*/
set_mps_lv(qc, 0); //TBD
/* TBD: temporary set (rspi, eosp) = (0, 1) which means End MPSP */
set_rspi(qc, 0);
SetEOSP(qc, 1);
set_mctrl_present(qc, 1);
}
#endif
}
/* TODO: fill HT Control Field */
/* Update Seq Num will be handled by f/w */
{
struct sta_info *psta;
psta = pxframe->attrib.psta;
if (psta == NULL) {
RTW_INFO("%s, psta==NUL\n", __func__);
return _FAIL;
}
if (!(psta->state & WIFI_ASOC_STATE)) {
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return _FAIL;
}
if (psta) {
psta->sta_xmitpriv.txseq_tid[pxframe->attrib.priority]++;
psta->sta_xmitpriv.txseq_tid[pxframe->attrib.priority] &= 0xFFF;
pxframe->attrib.seqnum = psta->sta_xmitpriv.txseq_tid[pxframe->attrib.priority];
SetSeqNum(hdr, pxframe->attrib.seqnum);
#ifdef CONFIG_80211N_HT
#if 0 /* move into update_attrib_phy_info(). */
/* check if enable ampdu */
if (pattrib->ht_en && psta->htpriv.ampdu_enable) {
if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
pattrib->ampdu_en = _TRUE;
}
#endif
/* re-check if enable ampdu by BA_starting_seqctrl */
if (pxframe->attrib.ampdu_en == _TRUE) {
u16 tx_seq;
tx_seq = psta->BA_starting_seqctrl[pxframe->attrib.priority & 0x0f];
/* check BA_starting_seqctrl */
if (SN_LESS(pxframe->attrib.seqnum, tx_seq)) {
/* RTW_INFO("tx ampdu seqnum(%d) < tx_seq(%d)\n", pattrib->seqnum, tx_seq); */
pxframe->attrib.ampdu_en = _FALSE;/* AGG BK */
} else if (SN_EQUAL(pxframe->attrib.seqnum, tx_seq)) {
psta->BA_starting_seqctrl[pxframe->attrib.priority & 0x0f] = (tx_seq + 1) & 0xfff;
pxframe->attrib.ampdu_en = _TRUE;/* AGG EN */
} else {
/* RTW_INFO("tx ampdu over run\n"); */
psta->BA_starting_seqctrl[pxframe->attrib.priority & 0x0f] = (pxframe->attrib.seqnum + 1) & 0xfff;
pxframe->attrib.ampdu_en = _TRUE;/* AGG EN */
}
}
#endif /* CONFIG_80211N_HT */
}
}
} else {
}
exit:
return res;
}
#endif
static void rtw_fill_htc_in_wlanhdr(_adapter *padapter, struct pkt_attrib *pattrib, u32 *phtc_buf)
{
#ifdef CONFIG_80211AX_HE
rtw_he_fill_htc(padapter, pattrib, phtc_buf);
#endif
}
s32 rtw_make_wlanhdr(_adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib)
{
u16 *qc;
u32 *htc = NULL;
struct rtw_ieee80211_hdr *pwlanhdr = (struct rtw_ieee80211_hdr *)hdr;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
u8 qos_option = _FALSE, htc_option = _FALSE;
sint res = _SUCCESS;
u16 *fctrl = &pwlanhdr->frame_ctl;
/* struct sta_info *psta; */
/* sint bmcst = IS_MCAST(pattrib->ra); */
/*
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if(pattrib->psta != psta)
{
RTW_INFO("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta);
return;
}
if(psta==NULL)
{
RTW_INFO("%s, psta==NUL\n", __func__);
return _FAIL;
}
if(!(psta->state &WIFI_ASOC_STATE))
{
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return _FAIL;
}
*/
#ifdef RTW_PHL_TX
_rtw_memset(hdr, 0, pattrib->hdrlen);
#else
_rtw_memset(hdr, 0, WLANHDR_OFFSET);
#endif
set_frame_sub_type(fctrl, pattrib->subtype);
if (pattrib->subtype & WIFI_DATA_TYPE) {
if (MLME_IS_STA(padapter)) {
#ifdef CONFIG_TDLS
if (pattrib->direct_link == _TRUE) {
/* TDLS data transfer, ToDS=0, FrDs=0 */
_rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
if (pattrib->qos_en)
qos_option = _TRUE;
} else
#endif /* CONFIG_TDLS */
{
#ifdef CONFIG_RTW_WDS
if (pattrib->wds) {
SetToDs(fctrl);
SetFrDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, pattrib->ra, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->ta, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr4, pattrib->src, ETH_ALEN);
} else
#endif
{
/* to_ds = 1, fr_ds = 0; */
/* 1.Data transfer to AP */
/* 2.Arp pkt will relayed by AP */
SetToDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->ta, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
}
if (pqospriv->qos_option)
qos_option = _TRUE;
}
} else if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)) {
#ifdef CONFIG_RTW_WDS
if (pattrib->wds) {
SetToDs(fctrl);
SetFrDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, pattrib->ra, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->ta, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr4, pattrib->src, ETH_ALEN);
} else
#endif
{
/* to_ds = 0, fr_ds = 1; */
SetFrDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pattrib->src, ETH_ALEN);
}
if (pattrib->qos_en)
qos_option = _TRUE;
} else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
_rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->ta, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
if (pattrib->qos_en)
qos_option = _TRUE;
#ifdef CONFIG_RTW_MESH
} else if (check_fwstate(pmlmepriv, WIFI_MESH_STATE) == _TRUE) {
rtw_mesh_tx_build_whdr(padapter, pattrib, fctrl, pwlanhdr);
if (pattrib->qos_en)
qos_option = _TRUE;
else {
RTW_WARN("[%s] !qos_en in Mesh\n", __FUNCTION__);
res = _FAIL;
goto exit;
}
#endif
} else {
res = _FAIL;
goto exit;
}
if (pattrib->mdata)
SetMData(fctrl);
if (pattrib->encrypt)
SetPrivacy(fctrl);
if (pattrib->order)
htc_option = _TRUE;
if (qos_option) {
qc = (unsigned short *)(hdr + (XATTRIB_GET_WDS(pattrib) ? WLAN_HDR_A4_LEN : WLAN_HDR_A3_LEN));
if (pattrib->priority)
SetPriority(qc, pattrib->priority);
SetEOSP(qc, pattrib->eosp);
SetAckpolicy(qc, pattrib->ack_policy);
if (pattrib->amsdu)
SetAMsdu(qc, pattrib->amsdu);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
/* active: don't care, light sleep: 0, deep sleep: 1*/
set_mps_lv(qc, 0); //TBD
/* TBD: temporary set (rspi, eosp) = (0, 1) which means End MPSP */
set_rspi(qc, 0);
SetEOSP(qc, 1);
set_mctrl_present(qc, 1);
}
#endif
}
/* TODO: fill HT Control Field */
if (htc_option == _TRUE) {
set_htc_order_bit(fctrl);
htc = (u32 *)(hdr + pattrib->hdrlen - 4);
rtw_fill_htc_in_wlanhdr(padapter, pattrib, htc);
}
/* Update Seq Num will be handled by f/w */
{
struct sta_info *psta;
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta) {
RTW_INFO("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta);
return _FAIL;
}
if (psta == NULL) {
RTW_INFO("%s, psta==NUL\n", __func__);
return _FAIL;
}
if (!(psta->state & WIFI_ASOC_STATE)) {
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return _FAIL;
}
if (psta) {
psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
SetSeqNum(hdr, pattrib->seqnum);
#ifdef CONFIG_80211N_HT
#if 0 /* move into update_attrib_phy_info(). */
/* check if enable ampdu */
if (pattrib->ht_en && psta->htpriv.ampdu_enable) {
if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
pattrib->ampdu_en = _TRUE;
}
#endif
/* re-check if enable ampdu by BA_starting_seqctrl */
if (pattrib->ampdu_en == _TRUE) {
u16 tx_seq;
tx_seq = psta->BA_starting_seqctrl[pattrib->priority & 0x0f];
/* check BA_starting_seqctrl */
if (SN_LESS(pattrib->seqnum, tx_seq)) {
/* RTW_INFO("tx ampdu seqnum(%d) < tx_seq(%d)\n", pattrib->seqnum, tx_seq); */
pattrib->ampdu_en = _FALSE;/* AGG BK */
} else if (SN_EQUAL(pattrib->seqnum, tx_seq)) {
psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq + 1) & 0xfff;
pattrib->ampdu_en = _TRUE;/* AGG EN */
} else {
/* RTW_INFO("tx ampdu over run\n"); */
psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum + 1) & 0xfff;
pattrib->ampdu_en = _TRUE;/* AGG EN */
}
}
#endif /* CONFIG_80211N_HT */
}
}
} else {
}
exit:
return res;
}
s32 rtw_txframes_pending(_adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
return ((_rtw_queue_empty(&pxmitpriv->be_pending) == _FALSE) ||
(_rtw_queue_empty(&pxmitpriv->bk_pending) == _FALSE) ||
(_rtw_queue_empty(&pxmitpriv->vi_pending) == _FALSE) ||
(_rtw_queue_empty(&pxmitpriv->vo_pending) == _FALSE));
}
s32 rtw_txframes_sta_ac_pending(_adapter *padapter, struct pkt_attrib *pattrib)
{
struct sta_info *psta;
struct tx_servq *ptxservq;
int priority = pattrib->priority;
/*
if(pattrib->psta)
{
psta = pattrib->psta;
}
else
{
RTW_INFO("%s, call rtw_get_stainfo()\n", __func__);
psta=rtw_get_stainfo(&padapter->stapriv ,&pattrib->ra[0]);
}
*/
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta) {
RTW_INFO("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta);
return 0;
}
if (psta == NULL) {
RTW_INFO("%s, psta==NUL\n", __func__);
return 0;
}
if (!(psta->state & WIFI_ASOC_STATE)) {
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return 0;
}
switch (priority) {
case 1:
case 2:
ptxservq = &(psta->sta_xmitpriv.bk_q);
break;
case 4:
case 5:
ptxservq = &(psta->sta_xmitpriv.vi_q);
break;
case 6:
case 7:
ptxservq = &(psta->sta_xmitpriv.vo_q);
break;
case 0:
case 3:
default:
ptxservq = &(psta->sta_xmitpriv.be_q);
break;
}
return ptxservq->qcnt;
}
#ifdef CONFIG_TDLS
int rtw_build_tdls_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct sta_info *ptdls_sta = NULL;
int res = _SUCCESS;
ptdls_sta = rtw_get_stainfo((&padapter->stapriv), pattrib->dst);
if (ptdls_sta == NULL) {
switch (ptxmgmt->action_code) {
case TDLS_DISCOVERY_REQUEST:
case TUNNELED_PROBE_REQ:
case TUNNELED_PROBE_RSP:
break;
default:
RTW_INFO("[TDLS] %s - Direct Link Peer = "MAC_FMT" not found for action = %d\n", __func__, MAC_ARG(pattrib->dst), ptxmgmt->action_code);
res = _FAIL;
goto exit;
}
}
switch (ptxmgmt->action_code) {
case TDLS_SETUP_REQUEST:
rtw_build_tdls_setup_req_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
case TDLS_SETUP_RESPONSE:
rtw_build_tdls_setup_rsp_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
case TDLS_SETUP_CONFIRM:
rtw_build_tdls_setup_cfm_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
case TDLS_TEARDOWN:
rtw_build_tdls_teardown_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
case TDLS_DISCOVERY_REQUEST:
rtw_build_tdls_dis_req_ies(padapter, pxmitframe, pframe, ptxmgmt);
break;
case TDLS_PEER_TRAFFIC_INDICATION:
rtw_build_tdls_peer_traffic_indication_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
#ifdef CONFIG_TDLS_CH_SW
case TDLS_CHANNEL_SWITCH_REQUEST:
rtw_build_tdls_ch_switch_req_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
case TDLS_CHANNEL_SWITCH_RESPONSE:
rtw_build_tdls_ch_switch_rsp_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
#endif
case TDLS_PEER_TRAFFIC_RESPONSE:
rtw_build_tdls_peer_traffic_rsp_ies(padapter, pxmitframe, pframe, ptxmgmt, ptdls_sta);
break;
#ifdef CONFIG_WFD
case TUNNELED_PROBE_REQ:
rtw_build_tunneled_probe_req_ies(padapter, pxmitframe, pframe);
break;
case TUNNELED_PROBE_RSP:
rtw_build_tunneled_probe_rsp_ies(padapter, pxmitframe, pframe);
break;
#endif /* CONFIG_WFD */
default:
res = _FAIL;
break;
}
exit:
return res;
}
s32 rtw_make_tdls_wlanhdr(_adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt)
{
u16 *qc;
struct rtw_ieee80211_hdr *pwlanhdr = (struct rtw_ieee80211_hdr *)hdr;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta = NULL, *ptdls_sta = NULL;
u8 tdls_seq = 0, baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
sint res = _SUCCESS;
u16 *fctrl = &pwlanhdr->frame_ctl;
_rtw_memset(hdr, 0, WLANHDR_OFFSET);
set_frame_sub_type(fctrl, pattrib->subtype);
switch (ptxmgmt->action_code) {
case TDLS_SETUP_REQUEST:
case TDLS_SETUP_RESPONSE:
case TDLS_SETUP_CONFIRM:
case TDLS_PEER_TRAFFIC_INDICATION:
case TDLS_PEER_PSM_REQUEST:
case TUNNELED_PROBE_REQ:
case TUNNELED_PROBE_RSP:
case TDLS_DISCOVERY_REQUEST:
SetToDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
break;
case TDLS_CHANNEL_SWITCH_REQUEST:
case TDLS_CHANNEL_SWITCH_RESPONSE:
case TDLS_PEER_PSM_RESPONSE:
case TDLS_PEER_TRAFFIC_RESPONSE:
_rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
tdls_seq = 1;
break;
case TDLS_TEARDOWN:
if (ptxmgmt->status_code == _RSON_TDLS_TEAR_UN_RSN_) {
_rtw_memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
tdls_seq = 1;
} else {
SetToDs(fctrl);
_rtw_memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
}
break;
}
if (pattrib->encrypt)
SetPrivacy(fctrl);
if (ptxmgmt->action_code == TDLS_PEER_TRAFFIC_RESPONSE)
SetPwrMgt(fctrl);
if (pqospriv->qos_option) {
qc = (unsigned short *)(hdr + pattrib->hdrlen - 2);
if (pattrib->priority)
SetPriority(qc, pattrib->priority);
SetAckpolicy(qc, pattrib->ack_policy);
}
psta = pattrib->psta;
/* 1. update seq_num per link by sta_info */
/* 2. rewrite encrypt to _AES_, also rewrite iv_len, icv_len */
if (tdls_seq == 1) {
ptdls_sta = rtw_get_stainfo(pstapriv, pattrib->dst);
if (ptdls_sta) {
ptdls_sta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
ptdls_sta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
pattrib->seqnum = ptdls_sta->sta_xmitpriv.txseq_tid[pattrib->priority];
SetSeqNum(hdr, pattrib->seqnum);
if (pattrib->encrypt) {
pattrib->encrypt = _AES_;
pattrib->iv_len = 8;
pattrib->icv_len = 8;
pattrib->bswenc = _FALSE;
}
pattrib->mac_id = ptdls_sta->phl_sta->macid;
} else {
res = _FAIL;
goto exit;
}
} else if (psta) {
psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
SetSeqNum(hdr, pattrib->seqnum);
}
exit:
return res;
}
s32 rtw_xmit_tdls_coalesce(_adapter *padapter, struct xmit_frame *pxmitframe, struct tdls_txmgmt *ptxmgmt)
{
s32 llc_sz;
u8 *pframe, *mem_start;
struct sta_info *psta;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 *pbuf_start;
s32 bmcst = IS_MCAST(pattrib->ra);
s32 res = _SUCCESS;
if (pattrib->psta)
psta = pattrib->psta;
else {
if (bmcst)
psta = rtw_get_bcmc_stainfo(padapter);
else
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
}
if (psta == NULL) {
res = _FAIL;
goto exit;
}
if (pxmitframe->buf_addr == NULL) {
res = _FAIL;
goto exit;
}
pbuf_start = pxmitframe->buf_addr;
mem_start = pbuf_start + TXDESC_OFFSET;
if (rtw_make_tdls_wlanhdr(padapter, mem_start, pattrib, ptxmgmt) == _FAIL) {
res = _FAIL;
goto exit;
}
pframe = mem_start;
pframe += pattrib->hdrlen;
/* adding icv, if necessary... */
if (pattrib->iv_len) {
if (psta != NULL) {
switch (pattrib->encrypt) {
case _WEP40_:
case _WEP104_:
WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
break;
case _TKIP_:
if (bmcst)
TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
break;
case _AES_:
if (bmcst)
AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
AES_IV(pattrib->iv, psta->dot11txpn, 0);
break;
}
}
_rtw_memcpy(pframe, pattrib->iv, pattrib->iv_len);
pframe += pattrib->iv_len;
}
llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
pframe += llc_sz;
/* pattrib->pktlen will be counted in rtw_build_tdls_ies */
pattrib->pktlen = 0;
rtw_build_tdls_ies(padapter, pxmitframe, pframe, ptxmgmt);
if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
pframe += pattrib->pktlen;
_rtw_memcpy(pframe, pattrib->icv, pattrib->icv_len);
pframe += pattrib->icv_len;
}
pattrib->nr_frags = 1;
pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len + llc_sz +
((pattrib->bswenc) ? pattrib->icv_len : 0) + pattrib->pktlen;
if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) {
res = _FAIL;
goto exit;
}
xmitframe_swencrypt(padapter, pxmitframe);
update_attrib_vcs_info(padapter, pxmitframe);
exit:
return res;
}
#endif /* CONFIG_TDLS */
/*
* Calculate wlan 802.11 packet MAX size from pkt_attrib
* This function doesn't consider fragment case
*/
u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib)
{
u32 len = 0;
len = pattrib->hdrlen /* WLAN Header */
+ pattrib->iv_len /* IV */
+ XATTRIB_GET_MCTRL_LEN(pattrib)
+ SNAP_SIZE + sizeof(u16) /* LLC */
+ pattrib->pktlen
+ (pattrib->encrypt == _TKIP_ ? 8 : 0) /* MIC */
+ (pattrib->bswenc ? pattrib->icv_len : 0) /* ICV */
;
return len;
}
#ifdef CONFIG_TX_AMSDU
s32 check_amsdu(struct xmit_frame *pxmitframe)
{
struct pkt_attrib *pattrib;
struct sta_info *psta = NULL;
s32 ret = _TRUE;
if (!pxmitframe)
ret = _FALSE;
pattrib = &pxmitframe->attrib;
psta = rtw_get_stainfo(&pxmitframe->padapter->stapriv, &pattrib->ra[0]);
if (psta) {
if (psta->flags & WLAN_STA_AMSDU_DISABLE)
ret =_FALSE;
}
if (IS_MCAST(pattrib->ra))
ret = _FALSE;
if ((pattrib->ether_type == 0x888e) ||
(pattrib->ether_type == 0x0806) ||
(pattrib->ether_type == 0x88b4) ||
(pattrib->dhcp_pkt == 1))
ret = _FALSE;
if ((pattrib->encrypt == _WEP40_) ||
(pattrib->encrypt == _WEP104_) ||
(pattrib->encrypt == _TKIP_))
ret = _FALSE;
if (!pattrib->qos_en)
ret = _FALSE;
if (IS_AMSDU_AMPDU_NOT_VALID(pattrib))
ret = _FALSE;
return ret;
}
s32 check_amsdu_tx_support(_adapter *padapter)
{
struct dvobj_priv *pdvobjpriv;
int tx_amsdu;
int tx_amsdu_rate;
int current_tx_rate;
s32 ret = _FALSE;
pdvobjpriv = adapter_to_dvobj(padapter);
tx_amsdu = padapter->tx_amsdu;
tx_amsdu_rate = padapter->tx_amsdu_rate;
current_tx_rate = pdvobjpriv->traffic_stat.cur_tx_tp;
if (tx_amsdu == 1)
ret = _TRUE;
else if (tx_amsdu >= 2 && (tx_amsdu_rate == 0 || current_tx_rate > tx_amsdu_rate))
ret = _TRUE;
else
ret = _FALSE;
return ret;
}
s32 rtw_xmitframe_coalesce_amsdu(_adapter *padapter, struct xmit_frame *pxmitframe, struct xmit_frame *pxmitframe_queue)
{
struct pkt_file pktfile;
struct pkt_attrib *pattrib;
struct sk_buff *pkt;
struct pkt_file pktfile_queue;
struct pkt_attrib *pattrib_queue;
struct sk_buff *pkt_queue;
s32 llc_sz, mem_sz;
s32 padding = 0;
u8 *pframe, *mem_start;
u8 hw_hdr_offset;
u16 *len;
u8 *pbuf_start;
s32 res = _SUCCESS;
if (pxmitframe->buf_addr == NULL) {
RTW_INFO("==> %s buf_addr==NULL\n", __FUNCTION__);
return _FAIL;
}
pbuf_start = pxmitframe->buf_addr;
#ifdef CONFIG_USB_TX_AGGREGATION
hw_hdr_offset = TXDESC_SIZE + (pxmitframe->pkt_offset * PACKET_OFFSET_SZ);
#else
#ifdef CONFIG_TX_EARLY_MODE /* for SDIO && Tx Agg */
hw_hdr_offset = TXDESC_OFFSET + EARLY_MODE_INFO_SIZE;
#else
hw_hdr_offset = TXDESC_OFFSET;
#endif
#endif
mem_start = pbuf_start + hw_hdr_offset; //for DMA
pattrib = &pxmitframe->attrib;
pattrib->amsdu = 1;
if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) {
RTW_INFO("%s: rtw_make_wlanhdr fail; drop pkt\n", __func__);
res = _FAIL;
goto exit;
}
llc_sz = 0;
pframe = mem_start;
//SetMFrag(mem_start);
ClearMFrag(mem_start);
pframe += pattrib->hdrlen;
/* adding icv, if necessary... */
if (pattrib->iv_len) {
update_attrib_sec_iv_info(padapter, pattrib);
_rtw_memcpy(pframe, pattrib->iv, pattrib->iv_len); // queue or new?
RTW_DBG("%s: keyid=%d pattrib->iv[3]=%.2x pframe=%.2x %.2x %.2x %.2x\n",
__func__, padapter->securitypriv.dot11PrivacyKeyIndex,
pattrib->iv[3], *pframe, *(pframe + 1), *(pframe + 2), *(pframe + 3));
pframe += pattrib->iv_len;
}
pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len;
if (pxmitframe_queue) {
pattrib_queue = &pxmitframe_queue->attrib;
pkt_queue = pxmitframe_queue->pkt;
_rtw_open_pktfile(pkt_queue, &pktfile_queue);
_rtw_pktfile_read(&pktfile_queue, NULL, pattrib_queue->pkt_hdrlen);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
/* mDA(6), mSA(6), len(2), mctrl */
_rtw_memcpy(pframe, pattrib_queue->mda, ETH_ALEN);
pframe += ETH_ALEN;
_rtw_memcpy(pframe, pattrib_queue->msa, ETH_ALEN);
pframe += ETH_ALEN;
len = (u16 *)pframe;
pframe += 2;
rtw_mesh_tx_build_mctrl(padapter, pattrib_queue, pframe);
pframe += XATTRIB_GET_MCTRL_LEN(pattrib_queue);
} else
#endif
{
/* 802.3 MAC Header DA(6) SA(6) Len(2)*/
_rtw_memcpy(pframe, pattrib_queue->dst, ETH_ALEN);
pframe += ETH_ALEN;
_rtw_memcpy(pframe, pattrib_queue->src, ETH_ALEN);
pframe += ETH_ALEN;
len = (u16 *)pframe;
pframe += 2;
}
llc_sz = rtw_put_snap(pframe, pattrib_queue->ether_type);
pframe += llc_sz;
mem_sz = _rtw_pktfile_read(&pktfile_queue, pframe, pattrib_queue->pktlen);
pframe += mem_sz;
*len = htons(XATTRIB_GET_MCTRL_LEN(pattrib_queue) + llc_sz + mem_sz);
//calc padding
padding = 4 - ((ETH_HLEN + XATTRIB_GET_MCTRL_LEN(pattrib_queue) + llc_sz + mem_sz) & (4-1));
if (padding == 4)
padding = 0;
//_rtw_memset(pframe,0xaa, padding);
pframe += padding;
pattrib->last_txcmdsz += ETH_HLEN + XATTRIB_GET_MCTRL_LEN(pattrib_queue) + llc_sz + mem_sz + padding ;
}
//2nd mpdu
pkt = pxmitframe->pkt;
_rtw_open_pktfile(pkt, &pktfile);
_rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen);
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
/* mDA(6), mSA(6), len(2), mctrl */
_rtw_memcpy(pframe, pattrib->mda, ETH_ALEN);
pframe += ETH_ALEN;
_rtw_memcpy(pframe, pattrib->msa, ETH_ALEN);
pframe += ETH_ALEN;
len = (u16 *)pframe;
pframe += 2;
rtw_mesh_tx_build_mctrl(padapter, pattrib, pframe);
pframe += XATTRIB_GET_MCTRL_LEN(pattrib);
} else
#endif
{
/* 802.3 MAC Header DA(6) SA(6) Len(2) */
_rtw_memcpy(pframe, pattrib->dst, ETH_ALEN);
pframe += ETH_ALEN;
_rtw_memcpy(pframe, pattrib->src, ETH_ALEN);
pframe += ETH_ALEN;
len = (u16 *)pframe;
pframe += 2;
}
llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
pframe += llc_sz;
mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
pframe += mem_sz;
*len = htons(XATTRIB_GET_MCTRL_LEN(pattrib) + llc_sz + mem_sz);
//the last ampdu has no padding
padding = 0;
pattrib->nr_frags = 1;
pattrib->last_txcmdsz += ETH_HLEN + XATTRIB_GET_MCTRL_LEN(pattrib) + llc_sz + mem_sz + padding +
((pattrib->bswenc) ? pattrib->icv_len : 0) ;
if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
_rtw_memcpy(pframe, pattrib->icv, pattrib->icv_len);
pframe += pattrib->icv_len;
}
if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) {
RTW_INFO("xmitframe_addmic(padapter, pxmitframe)==_FAIL\n");
res = _FAIL;
goto exit;
}
xmitframe_swencrypt(padapter, pxmitframe);
update_attrib_vcs_info(padapter, pxmitframe);
exit:
return res;
}
#endif /* CONFIG_TX_AMSDU */
/*
This sub-routine will perform all the following:
1. remove 802.3 header.
2. create wlan_header, based on the info in pxmitframe
3. append sta's iv/ext-iv
4. append LLC
5. move frag chunk from pframe to pxmitframe->mem
6. apply sw-encrypt, if necessary.
*/
s32 rtw_xmitframe_coalesce(_adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pkt_file pktfile;
s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
SIZE_PTR addr;
u8 *pframe, *mem_start;
u8 hw_hdr_offset;
/* struct sta_info *psta; */
/* struct sta_priv *pstapriv = &padapter->stapriv; */
/* struct mlme_priv *pmlmepriv = &padapter->mlmepriv; */
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 *pbuf_start;
s32 bmcst = IS_MCAST(pattrib->ra);
s32 res = _SUCCESS;
/*
if (pattrib->psta)
{
psta = pattrib->psta;
} else
{
RTW_INFO("%s, call rtw_get_stainfo()\n", __func__);
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
}
if(psta==NULL)
{
RTW_INFO("%s, psta==NUL\n", __func__);
return _FAIL;
}
if(!(psta->state &WIFI_ASOC_STATE))
{
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return _FAIL;
}
*/
if (pxmitframe->buf_addr == NULL) {
RTW_INFO("==> %s buf_addr==NULL\n", __FUNCTION__);
return _FAIL;
}
pbuf_start = pxmitframe->buf_addr;
#if 0
#ifdef CONFIG_USB_TX_AGGREGATION
hw_hdr_offset = TXDESC_SIZE + (pxmitframe->pkt_offset * PACKET_OFFSET_SZ);
#else
#ifdef CONFIG_TX_EARLY_MODE /* for SDIO && Tx Agg */
hw_hdr_offset = TXDESC_OFFSET + EARLY_MODE_INFO_SIZE;
#else
hw_hdr_offset = TXDESC_OFFSET;
#endif
#endif
#endif
hw_hdr_offset = rtw_hal_get_txdesc_len(GET_PHL_COM(dvobj), pattrib); /*FPGA_test*/
mem_start = pbuf_start + hw_hdr_offset;
if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) {
RTW_INFO("%s: rtw_make_wlanhdr fail; drop pkt\n", __func__);
res = _FAIL;
goto exit;
}
_rtw_open_pktfile(pkt, &pktfile);
_rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen);
frg_inx = 0;
frg_len = pxmitpriv->frag_len - 4;/* 2346-4 = 2342 */
while (1) {
llc_sz = 0;
mpdu_len = frg_len;
pframe = mem_start;
SetMFrag(mem_start);
pframe += pattrib->hdrlen;
mpdu_len -= pattrib->hdrlen;
/* adding icv, if necessary... */
if (pattrib->iv_len) {
update_attrib_sec_iv_info(padapter, pattrib);
_rtw_memcpy(pframe, pattrib->iv, pattrib->iv_len);
pframe += pattrib->iv_len;
mpdu_len -= pattrib->iv_len;
}
if (frg_inx == 0) {
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
rtw_mesh_tx_build_mctrl(padapter, pattrib, pframe);
pframe += XATTRIB_GET_MCTRL_LEN(pattrib);
mpdu_len -= XATTRIB_GET_MCTRL_LEN(pattrib);
}
#endif
llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
pframe += llc_sz;
mpdu_len -= llc_sz;
}
if ((pattrib->icv_len > 0) && (pattrib->bswenc))
mpdu_len -= pattrib->icv_len;
if (bmcst) {
/* don't do fragment to broadcat/multicast packets */
mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
} else
mem_sz = _rtw_pktfile_read(&pktfile, pframe, mpdu_len);
pframe += mem_sz;
if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
_rtw_memcpy(pframe, pattrib->icv, pattrib->icv_len);
pframe += pattrib->icv_len;
}
frg_inx++;
if (bmcst || (rtw_endofpktfile(&pktfile) == _TRUE)) {
pattrib->nr_frags = frg_inx;
pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len +
((pattrib->nr_frags == 1) ? (XATTRIB_GET_MCTRL_LEN(pattrib) + llc_sz) : 0) +
((pattrib->bswenc) ? pattrib->icv_len : 0) + mem_sz;
ClearMFrag(mem_start);
break;
}
addr = (SIZE_PTR)(pframe);
mem_start = (unsigned char *)RND4(addr) + hw_hdr_offset;
_rtw_memcpy(mem_start, pbuf_start + hw_hdr_offset, pattrib->hdrlen);
}
if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) {
RTW_INFO("xmitframe_addmic(padapter, pxmitframe)==_FAIL\n");
res = _FAIL;
goto exit;
}
xmitframe_swencrypt(padapter, pxmitframe);
if (bmcst == _FALSE)
update_attrib_vcs_info(padapter, pxmitframe);
else
pattrib->vcs_mode = NONE_VCS;
exit:
return res;
}
#if defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH)
/*
* CCMP encryption for unicast robust mgmt frame and broadcast group privicy action
* BIP for broadcast robust mgmt frame
*/
s32 rtw_mgmt_xmitframe_coalesce(_adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
{
#define DBG_MGMT_XMIT_COALESEC_DUMP 0
#define DBG_MGMT_XMIT_BIP_DUMP 0
#define DBG_MGMT_XMIT_ENC_DUMP 0
struct pkt_file pktfile;
s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
SIZE_PTR addr;
u8 *pframe, *mem_start = NULL, *tmp_buf = NULL;
u8 hw_hdr_offset, subtype ;
u8 category = 0xFF;
struct sta_info *psta = NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 *pbuf_start;
s32 bmcst = IS_MCAST(pattrib->ra);
s32 res = _FAIL;
u8 *BIP_AAD = NULL;
u8 *MGMT_body = NULL;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct rtw_ieee80211_hdr *pwlanhdr;
u8 mme_cont[_MME_IE_LENGTH_ - 2];
u8 mme_clen;
u32 ori_len;
union pn48 *pn = NULL;
enum security_type cipher = _NO_PRIVACY_;
u8 kid;
if (pxmitframe->buf_addr == NULL) {
RTW_WARN(FUNC_ADPT_FMT" pxmitframe->buf_addr\n"
, FUNC_ADPT_ARG(padapter));
return _FAIL;
}
mem_start = pframe = (u8 *)(pxmitframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
subtype = get_frame_sub_type(pframe); /* bit(7)~bit(2) */
/* check if robust mgmt frame */
if (subtype != WIFI_DEAUTH && subtype != WIFI_DISASSOC && subtype != WIFI_ACTION)
return _SUCCESS;
if (subtype == WIFI_ACTION) {
category = *(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
if (CATEGORY_IS_NON_ROBUST(category))
return _SUCCESS;
}
if (!bmcst) {
if (pattrib->psta)
psta = pattrib->psta;
else
pattrib->psta = psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (psta == NULL) {
RTW_INFO(FUNC_ADPT_FMT" unicast sta == NULL\n", FUNC_ADPT_ARG(padapter));
return _FAIL;
}
if (!(psta->flags & WLAN_STA_MFP)) {
/* peer is not MFP capable, no need to encrypt */
return _SUCCESS;
}
if (psta->bpairwise_key_installed != _TRUE) {
RTW_INFO(FUNC_ADPT_FMT" PTK is not installed\n"
, FUNC_ADPT_ARG(padapter));
return _FAIL;
}
}
ori_len = BIP_AAD_SIZE + pattrib->pktlen + _MME_IE_LENGTH_;
tmp_buf = BIP_AAD = rtw_zmalloc(ori_len);
if (BIP_AAD == NULL)
return _FAIL;
_rtw_spinlock_bh(&padapter->security_key_mutex);
if (bmcst) {
if (subtype == WIFI_ACTION && CATEGORY_IS_GROUP_PRIVACY(category)) {
/* broadcast group privacy action frame */
#if DBG_MGMT_XMIT_COALESEC_DUMP
RTW_INFO(FUNC_ADPT_FMT" broadcast gp action(%u)\n"
, FUNC_ADPT_ARG(padapter), category);
#endif
if (pattrib->psta)
psta = pattrib->psta;
else
pattrib->psta = psta = rtw_get_bcmc_stainfo(padapter);
if (psta == NULL) {
RTW_INFO(FUNC_ADPT_FMT" broadcast sta == NULL\n"
, FUNC_ADPT_ARG(padapter));
goto xmitframe_coalesce_fail;
}
if (padapter->securitypriv.binstallGrpkey != _TRUE) {
RTW_INFO(FUNC_ADPT_FMT" GTK is not installed\n"
, FUNC_ADPT_ARG(padapter));
goto xmitframe_coalesce_fail;
}
pn = &psta->dot11txpn;
cipher = padapter->securitypriv.dot118021XGrpPrivacy;
kid = padapter->securitypriv.dot118021XGrpKeyid;
} else {
#ifdef CONFIG_IEEE80211W
/* broadcast robust mgmt frame, using BIP */
int frame_body_len;
u8 mic[16];
/* IGTK key is not install ex: mesh MFP without IGTK */
if (SEC_IS_BIP_KEY_INSTALLED(&padapter->securitypriv) != _TRUE)
goto xmitframe_coalesce_success;
#if DBG_MGMT_XMIT_COALESEC_DUMP
if (subtype == WIFI_DEAUTH)
RTW_INFO(FUNC_ADPT_FMT" braodcast deauth\n", FUNC_ADPT_ARG(padapter));
else if (subtype == WIFI_DISASSOC)
RTW_INFO(FUNC_ADPT_FMT" braodcast disassoc\n", FUNC_ADPT_ARG(padapter));
else if (subtype == WIFI_ACTION) {
RTW_INFO(FUNC_ADPT_FMT" braodcast action(%u)\n"
, FUNC_ADPT_ARG(padapter), category);
}
#endif
/*HW encrypt need to record encrypt type*/
pattrib->encrypt = padapter->securitypriv.dot11wCipher;
_rtw_memset(mme_cont, 0, _MME_IE_LENGTH_ - 2);
mme_clen = padapter->securitypriv.dot11wCipher == _BIP_CMAC_128_ ? 16 : 24;
MGMT_body = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
pframe += pattrib->pktlen;
/* octent 0 and 1 is key index ,BIP keyid is 4 or 5, LSB only need octent 0 */
mme_cont[0] = padapter->securitypriv.dot11wBIPKeyid;
/* increase PN and apply to packet */
padapter->securitypriv.dot11wBIPtxpn.val++;
RTW_PUT_LE64(&mme_cont[2], padapter->securitypriv.dot11wBIPtxpn.val);
/* add MME IE with MIC all zero, MME string doesn't include element id and length */
pframe = rtw_set_ie(pframe, _MME_IE_, mme_clen, mme_cont, &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
if (pattrib->encrypt &&
(padapter->securitypriv.sw_encrypt == _TRUE || padapter->securitypriv.hw_decrypted == _FALSE)) {
pattrib->bswenc = _TRUE;
} else {
/* currently HW only support _BIP_CMAC_128_ */
if (pattrib->encrypt == _BIP_CMAC_128_)
pattrib->bswenc = _FALSE;
else
pattrib->bswenc = _TRUE;
}
if (!pattrib->bswenc) {
pattrib->key_idx = padapter->securitypriv.dot11wBIPKeyid;
/*Don't need to append MIC part of MME*/
pattrib->pktlen -= (mme_clen == 16 ? 8 : 16);
pattrib->last_txcmdsz = pattrib->pktlen;
goto xmitframe_coalesce_success;
}
/* total frame length - header length */
frame_body_len = pattrib->pktlen - sizeof(struct rtw_ieee80211_hdr_3addr);
/* conscruct AAD, copy frame control field */
_rtw_memcpy(BIP_AAD, &pwlanhdr->frame_ctl, 2);
ClearRetry(BIP_AAD);
ClearPwrMgt(BIP_AAD);
ClearMData(BIP_AAD);
/* conscruct AAD, copy address 1 to address 3 */
_rtw_memcpy(BIP_AAD + 2, pwlanhdr->addr1, 18);
/* copy management fram body */
_rtw_memcpy(BIP_AAD + BIP_AAD_SIZE, MGMT_body, frame_body_len);
#if DBG_MGMT_XMIT_BIP_DUMP
/* dump total packet include MME with zero MIC */
{
int i;
printk("Total packet: ");
for (i = 0; i < BIP_AAD_SIZE + frame_body_len; i++)
printk(" %02x ", BIP_AAD[i]);
printk("\n");
}
#endif
/* calculate mic */
if (rtw_calculate_bip_mic(padapter->securitypriv.dot11wCipher,
(u8 *)pwlanhdr, pattrib->pktlen,
padapter->securitypriv.dot11wBIPKey[padapter->securitypriv.dot11wBIPKeyid].skey,
BIP_AAD, (BIP_AAD_SIZE + frame_body_len), mic) == _FAIL)
goto xmitframe_coalesce_fail;
#if DBG_MGMT_XMIT_BIP_DUMP
/* dump calculated mic result */
{
int i;
printk("Calculated mic result: ");
for (i = 0; i < 16; i++)
printk(" %02x ", mic[i]);
printk("\n");
}
#endif
/* copy right BIP mic value, total is 128bits, we use the 0~63 bits */
if (padapter->securitypriv.dot11wCipher == _BIP_CMAC_128_)
_rtw_memcpy(pframe - 8, mic, 8);
else
_rtw_memcpy(pframe - 16, mic, 16);
#if DBG_MGMT_XMIT_BIP_DUMP
/*dump all packet after mic ok */
{
int pp;
printk("pattrib->pktlen = %d\n", pattrib->pktlen);
for (pp = 0; pp < pattrib->pktlen; pp++)
printk(" %02x ", mem_start[pp]);
printk("\n");
}
#endif
#endif /* CONFIG_IEEE80211W */
goto xmitframe_coalesce_success;
}
} else {
/* unicast robust mgmt frame */
#if DBG_MGMT_XMIT_COALESEC_DUMP
if (subtype == WIFI_DEAUTH) {
RTW_INFO(FUNC_ADPT_FMT" unicast deauth to "MAC_FMT"\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(pattrib->ra));
} else if (subtype == WIFI_DISASSOC) {
RTW_INFO(FUNC_ADPT_FMT" unicast disassoc to "MAC_FMT"\n"
, FUNC_ADPT_ARG(padapter), MAC_ARG(pattrib->ra));
} else if (subtype == WIFI_ACTION) {
RTW_INFO(FUNC_ADPT_FMT" unicast action(%u) to "MAC_FMT"\n"
, FUNC_ADPT_ARG(padapter), category, MAC_ARG(pattrib->ra));
}
#endif
pn = &psta->dot11txpn;
cipher = psta->dot118021XPrivacy;
kid = 0;
_rtw_memcpy(pattrib->dot118021x_UncstKey.skey
, psta->dot118021x_UncstKey.skey
, (cipher & _SEC_TYPE_256_) ? 32 : 16);
/* To use wrong key */
if (pattrib->key_type == IEEE80211W_WRONG_KEY) {
RTW_INFO("use wrong key\n");
pattrib->dot118021x_UncstKey.skey[0] = 0xff;
}
}
#if DBG_MGMT_XMIT_ENC_DUMP
/* before encrypt dump the management packet content */
{
int i;
printk("Management pkt: ");
for (i = 0; i < pattrib->pktlen; i++)
printk(" %02x ", pframe[i]);
printk("=======\n");
}
#endif
/* bakeup original management packet */
_rtw_memcpy(tmp_buf, pframe, pattrib->pktlen);
/* move to data portion */
pframe += pattrib->hdrlen;
if (pattrib->key_type != IEEE80211W_NO_KEY) {
pattrib->encrypt = cipher;
pattrib->bswenc = _TRUE;
}
/*
* 802.11w encrypted management packet must be:
* _AES_, _CCMP_256_, _GCMP_, _GCMP_256_
*/
switch (pattrib->encrypt) {
case _AES_:
pattrib->iv_len = 8;
pattrib->icv_len = 8;
AES_IV(pattrib->iv, (*pn), kid);
break;
case _CCMP_256_:
pattrib->iv_len = 8;
pattrib->icv_len = 16;
AES_IV(pattrib->iv, (*pn), kid);
break;
case _GCMP_:
case _GCMP_256_:
pattrib->iv_len = 8;
pattrib->icv_len = 16;
GCMP_IV(pattrib->iv, (*pn), kid);
break;
default:
goto xmitframe_coalesce_fail;
}
/* insert iv header into management frame */
_rtw_memcpy(pframe, pattrib->iv, pattrib->iv_len);
pframe += pattrib->iv_len;
/* copy mgmt data portion after CCMP header */
_rtw_memcpy(pframe, tmp_buf + pattrib->hdrlen, pattrib->pktlen - pattrib->hdrlen);
/* move pframe to end of mgmt pkt */
pframe += pattrib->pktlen - pattrib->hdrlen;
/* add 8 bytes CCMP IV header to length */
pattrib->pktlen += pattrib->iv_len;
#if DBG_MGMT_XMIT_ENC_DUMP
/* dump management packet include AES IV header */
{
int i;
printk("Management pkt + IV: ");
/* for(i=0; i<pattrib->pktlen; i++) */
printk("@@@@@@@@@@@@@\n");
}
#endif
if (pattrib->encrypt &&
(padapter->securitypriv.sw_encrypt == _TRUE || psta->hw_decrypted == _FALSE)) {
pattrib->bswenc = _TRUE;
} else {
/* only right key can use HW encrypt */
if (pattrib->key_type == IEEE80211W_RIGHT_KEY)
pattrib->bswenc = _FALSE;
else
pattrib->bswenc = _TRUE;
}
/* at the moment the security CAM may be cleaned already --> use SW encryption */
if (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC)
pattrib->bswenc = _TRUE;
if (!pattrib->bswenc) {
pattrib->key_idx = kid;
pattrib->last_txcmdsz = pattrib->pktlen;
SetPrivacy(mem_start);
goto xmitframe_coalesce_success;
}
if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
_rtw_memcpy(pframe, pattrib->icv, pattrib->icv_len);
pframe += pattrib->icv_len;
}
/* add 8 bytes MIC */
pattrib->pktlen += pattrib->icv_len;
/* set final tx command size */
pattrib->last_txcmdsz = pattrib->pktlen;
/* set protected bit must be beofre SW encrypt */
SetPrivacy(mem_start);
#if DBG_MGMT_XMIT_ENC_DUMP
/* dump management packet include AES header */
{
int i;
printk("prepare to enc Management pkt + IV: ");
for (i = 0; i < pattrib->pktlen; i++)
printk(" %02x ", mem_start[i]);
printk("@@@@@@@@@@@@@\n");
}
#endif
/* software encrypt */
/* move to core_wlan_sw_encrypt() because of new txreq architecture */
xmitframe_coalesce_success:
_rtw_spinunlock_bh(&padapter->security_key_mutex);
rtw_mfree(BIP_AAD, ori_len);
return _SUCCESS;
xmitframe_coalesce_fail:
_rtw_spinunlock_bh(&padapter->security_key_mutex);
rtw_mfree(BIP_AAD, ori_len);
return _FAIL;
}
#endif /* defined(CONFIG_IEEE80211W) || defined(CONFIG_RTW_MESH) */
/* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
* IEEE LLC/SNAP header contains 8 octets
* First 3 octets comprise the LLC portion
* SNAP portion, 5 octets, is divided into two fields:
* Organizationally Unique Identifier(OUI), 3 octets,
* type, defined by that organization, 2 octets.
*/
s32 rtw_put_snap(u8 *data, u16 h_proto)
{
struct ieee80211_snap_hdr *snap;
u8 *oui;
snap = (struct ieee80211_snap_hdr *)data;
snap->dsap = 0xaa;
snap->ssap = 0xaa;
snap->ctrl = 0x03;
if (h_proto == 0x8137 || h_proto == 0x80f3)
oui = P802_1H_OUI;
else
oui = RFC1042_OUI;
snap->oui[0] = oui[0];
snap->oui[1] = oui[1];
snap->oui[2] = oui[2];
*(u16 *)(data + SNAP_SIZE) = htons(h_proto);
return SNAP_SIZE + sizeof(u16);
}
void rtw_update_protection(_adapter *padapter, u8 *ie, uint ie_len)
{
uint protection;
u8 *perp;
sint erp_len;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
switch (pxmitpriv->vcs_setting) {
case DISABLE_VCS:
pxmitpriv->vcs = NONE_VCS;
break;
case ENABLE_VCS:
break;
case AUTO_VCS:
default:
perp = rtw_get_ie(ie, _ERPINFO_IE_, &erp_len, ie_len);
if (perp == NULL)
pxmitpriv->vcs = NONE_VCS;
else {
protection = (*(perp + 2)) & BIT(1);
if (protection) {
if (pregistrypriv->vcs_type == RTS_CTS)
pxmitpriv->vcs = RTS_CTS;
else
pxmitpriv->vcs = CTS_TO_SELF;
} else
pxmitpriv->vcs = NONE_VCS;
}
break;
}
}
#ifdef CONFIG_CORE_TXSC
void rtw_count_tx_stats_tx_req(_adapter *padapter, struct rtw_xmit_req *txreq, struct sta_info *psta)
{
struct stainfo_stats *pstats = NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
u32 sz = 0;
if (txreq->mdata.type == RTW_PHL_PKT_TYPE_DATA) {
pmlmepriv->LinkDetectInfo.NumTxOkInPeriod++;
pxmitpriv->tx_pkts++;
sz = txreq->mdata.pktlen - RTW_SZ_LLC - txreq->mdata.hdr_len;
switch (txreq->mdata.sec_type) {
case RTW_ENC_WEP104:
case RTW_ENC_WEP40:
sz -= 4;
break;
case RTW_ENC_TKIP:
sz -= 8;
break;
case RTW_ENC_CCMP:
sz -= 8;
break;
case RTW_ENC_WAPI:
sz -= 18;
break;
case RTW_ENC_GCMP256:
case RTW_ENC_GCMP:
case RTW_ENC_CCMP256:
sz -= 8;
break;
default:
break;
}
pxmitpriv->tx_bytes += sz;
if (psta) {
pstats = &psta->sta_stats;
pstats->tx_pkts++;
pstats->tx_bytes += sz;
#if 0
if (is_multicast_mac_addr(psta->phl_sta->mac_addr))
pxmitpriv->tx_mc_pkts++;
else if (is_broadcast_mac_addr(psta->phl_sta->mac_addr))
pxmitpriv->tx_bc_pkts++;
else
pxmitpriv->tx_uc_pkts++;
#endif
}
}
}
#endif
void rtw_count_tx_stats(_adapter *padapter, struct xmit_frame *pxmitframe, int sz)
{
struct sta_info *psta = NULL;
struct stainfo_stats *pstats = NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (pxmitframe->xftype == RTW_TX_OS) {
pmlmepriv->LinkDetectInfo.NumTxOkInPeriod++;
pxmitpriv->tx_pkts++;
pxmitpriv->tx_bytes += sz;
psta = pxmitframe->attrib.psta;
if (psta) {
pstats = &psta->sta_stats;
pstats->tx_pkts++;
pstats->tx_bytes += sz;
#if defined(CONFIG_CHECK_LEAVE_LPS) && defined(CONFIG_LPS_CHK_BY_TP)
if (adapter_to_pwrctl(padapter)->lps_chk_by_tp)
traffic_check_for_leave_lps_by_tp(padapter, _TRUE, psta);
#endif /* CONFIG_LPS */
}
#ifdef CONFIG_CHECK_LEAVE_LPS
/* traffic_check_for_leave_lps(padapter, _TRUE); */
#endif /* CONFIG_CHECK_LEAVE_LPS */
}
}
#if 0 /*CONFIG_CORE_XMITBUF*/
static struct xmit_buf *__rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv,
enum cmdbuf_type buf_type)
{
struct xmit_buf *pxmitbuf = NULL;
pxmitbuf = &pxmitpriv->pcmd_xmitbuf[buf_type];
if (pxmitbuf != NULL) {
pxmitbuf->priv_data = NULL;
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->agg_num = 0;
pxmitbuf->pg_num = 0;
#endif
#ifdef CONFIG_PCI_HCI
pxmitbuf->len = 0;
#ifdef CONFIG_TRX_BD_ARCH
/*pxmitbuf->buf_desc = NULL;*/
#else
pxmitbuf->desc = NULL;
#endif
#endif
if (pxmitbuf->sctx) {
RTW_INFO("%s pxmitbuf->sctx is not NULL\n", __func__);
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
}
} else
RTW_INFO("%s fail, no xmitbuf available !!!\n", __func__);
return pxmitbuf;
}
struct xmit_frame *__rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv,
enum cmdbuf_type buf_type)
{
struct xmit_frame *pcmdframe;
struct xmit_buf *pxmitbuf;
pcmdframe = rtw_alloc_xmitframe(pxmitpriv);
if (pcmdframe == NULL) {
RTW_INFO("%s, alloc xmitframe fail\n", __FUNCTION__);
return NULL;
}
pxmitbuf = __rtw_alloc_cmd_xmitbuf(pxmitpriv, buf_type);
if (pxmitbuf == NULL) {
RTW_INFO("%s, alloc xmitbuf fail\n", __FUNCTION__);
rtw_free_xmitframe(pxmitpriv, pcmdframe);
return NULL;
}
pcmdframe->frame_tag = MGNT_FRAMETAG;
pcmdframe->pxmitbuf = pxmitbuf;
pcmdframe->buf_addr = pxmitbuf->pbuf;
/* initial memory to zero */
_rtw_memset(pcmdframe->buf_addr, 0, MAX_CMDBUF_SZ);
pxmitbuf->priv_data = pcmdframe;
return pcmdframe;
}
struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv)
{
struct xmit_buf *pxmitbuf = NULL;
_list *plist, *phead;
_queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
unsigned long sp_flags;
_rtw_spinlock_irq(&pfree_queue->lock, &sp_flags);
if (_rtw_queue_empty(pfree_queue) == _TRUE)
pxmitbuf = NULL;
else {
phead = get_list_head(pfree_queue);
plist = get_next(phead);
pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
rtw_list_delete(&(pxmitbuf->list));
}
if (pxmitbuf != NULL) {
pxmitpriv->free_xmit_extbuf_cnt--;
#ifdef DBG_XMIT_BUF_EXT
RTW_INFO("DBG_XMIT_BUF_EXT ALLOC no=%d, free_xmit_extbuf_cnt=%d\n", pxmitbuf->no, pxmitpriv->free_xmit_extbuf_cnt);
#endif
pxmitbuf->priv_data = NULL;
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->agg_num = 1;
#endif
#ifdef CONFIG_PCI_HCI
pxmitbuf->len = 0;
#ifdef CONFIG_TRX_BD_ARCH
/*pxmitbuf->buf_desc = NULL;*/
#else
pxmitbuf->desc = NULL;
#endif
#endif
if (pxmitbuf->sctx) {
RTW_INFO("%s pxmitbuf->sctx is not NULL\n", __func__);
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
}
}
_rtw_spinunlock_irq(&pfree_queue->lock, &sp_flags);
return pxmitbuf;
}
s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
_queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
unsigned long sp_flags;
if (pxmitbuf == NULL)
return _FAIL;
_rtw_spinlock_irq(&pfree_queue->lock, &sp_flags);
rtw_list_delete(&pxmitbuf->list);
rtw_list_insert_tail(&(pxmitbuf->list), get_list_head(pfree_queue));
pxmitpriv->free_xmit_extbuf_cnt++;
#ifdef DBG_XMIT_BUF_EXT
RTW_INFO("DBG_XMIT_BUF_EXT FREE no=%d, free_xmit_extbuf_cnt=%d\n", pxmitbuf->no, pxmitpriv->free_xmit_extbuf_cnt);
#endif
_rtw_spinunlock_irq(&pfree_queue->lock, &sp_flags);
return _SUCCESS;
}
struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv)
{
struct xmit_buf *pxmitbuf = NULL;
_list *plist, *phead;
_queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
unsigned long sp_flags;
/* RTW_INFO("+rtw_alloc_xmitbuf\n"); */
_rtw_spinlock_irq(&pfree_xmitbuf_queue->lock, &sp_flags);
if (_rtw_queue_empty(pfree_xmitbuf_queue) == _TRUE)
pxmitbuf = NULL;
else {
phead = get_list_head(pfree_xmitbuf_queue);
plist = get_next(phead);
pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
rtw_list_delete(&(pxmitbuf->list));
}
if (pxmitbuf != NULL) {
pxmitpriv->free_xmitbuf_cnt--;
#ifdef DBG_XMIT_BUF
RTW_INFO("DBG_XMIT_BUF ALLOC no=%d, free_xmitbuf_cnt=%d\n", pxmitbuf->no, pxmitpriv->free_xmitbuf_cnt);
#endif
/* RTW_INFO("alloc, free_xmitbuf_cnt=%d\n", pxmitpriv->free_xmitbuf_cnt); */
pxmitbuf->priv_data = NULL;
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->agg_num = 0;
pxmitbuf->pg_num = 0;
#endif
#ifdef CONFIG_PCI_HCI
pxmitbuf->len = 0;
#ifdef CONFIG_TRX_BD_ARCH
/*pxmitbuf->buf_desc = NULL;*/
#else
pxmitbuf->desc = NULL;
#endif
#endif
if (pxmitbuf->sctx) {
RTW_INFO("%s pxmitbuf->sctx is not NULL\n", __func__);
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
}
}
#ifdef DBG_XMIT_BUF
else
RTW_INFO("DBG_XMIT_BUF rtw_alloc_xmitbuf return NULL\n");
#endif
_rtw_spinunlock_irq(&pfree_xmitbuf_queue->lock, &sp_flags);
return pxmitbuf;
}
s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
_queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
unsigned long sp_flags;
/* RTW_INFO("+rtw_free_xmitbuf\n"); */
if (pxmitbuf == NULL)
return _FAIL;
if (pxmitbuf->sctx) {
RTW_INFO("%s pxmitbuf->sctx is not NULL\n", __func__);
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_FREE);
}
if (pxmitbuf->buf_tag == XMITBUF_CMD) {
} else if (pxmitbuf->buf_tag == XMITBUF_MGNT)
rtw_free_xmitbuf_ext(pxmitpriv, pxmitbuf);
else {
_rtw_spinlock_irq(&pfree_xmitbuf_queue->lock, &sp_flags);
rtw_list_delete(&pxmitbuf->list);
rtw_list_insert_tail(&(pxmitbuf->list), get_list_head(pfree_xmitbuf_queue));
pxmitpriv->free_xmitbuf_cnt++;
/* RTW_INFO("FREE, free_xmitbuf_cnt=%d\n", pxmitpriv->free_xmitbuf_cnt); */
#ifdef DBG_XMIT_BUF
RTW_INFO("DBG_XMIT_BUF FREE no=%d, free_xmitbuf_cnt=%d\n", pxmitbuf->no, pxmitpriv->free_xmitbuf_cnt);
#endif
_rtw_spinunlock_irq(&pfree_xmitbuf_queue->lock, &sp_flags);
}
return _SUCCESS;
}
#endif
void rtw_init_xmitframe(struct xmit_frame *pxframe)
{
if (pxframe != NULL) { /* default value setting */
#if 0 /*CONFIG_CORE_XMITBUF*/
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
#endif
_rtw_memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib));
/* pxframe->attrib.psta = NULL; */
pxframe->frame_tag = DATA_FRAMETAG;
#ifdef CONFIG_USB_HCI
pxframe->pkt = NULL;
#ifdef USB_PACKET_OFFSET_SZ
pxframe->pkt_offset = (PACKET_OFFSET_SZ / 8);
#else
pxframe->pkt_offset = 1;/* default use pkt_offset to fill tx desc */
#endif
#ifdef CONFIG_USB_TX_AGGREGATION
pxframe->agg_num = 1;
#endif
#endif /* #ifdef CONFIG_USB_HCI */
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxframe->pg_num = 1;
pxframe->agg_num = 1;
#endif
#ifdef CONFIG_XMIT_ACK
pxframe->ack_report = 0;
#endif
pxframe->txfree_cnt = 0;
}
}
/*
Calling context:
1. OS_TXENTRY
2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
If we turn on USE_RXTHREAD, then, no need for critical section.
Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
Must be very very cautious...
*/
#ifdef RTW_PHL_TX
void core_tx_init_xmitframe(struct xmit_frame *pxframe)
{
if (!pxframe)
return;
#if 0 /*CONFIG_CORE_XMITBUF*/
pxframe->pxmitbuf = NULL;
#endif
_rtw_memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib));
/* TXREQ_QMGT */
pxframe->ptxreq_buf = NULL;
pxframe->phl_txreq = NULL;
pxframe->txreq_cnt = 0;
pxframe->txfree_cnt = 0;
}
s32 core_tx_alloc_xmitframe(_adapter *padapter, struct xmit_frame **pxmitframe, u16 os_qid)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pxframe = NULL;
_queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue;
_list *plist, *phead;
PHLTX_LOG;
_rtw_spinlock_bh(&pfree_xmit_queue->lock);
if (_rtw_queue_empty(pfree_xmit_queue) == _TRUE) {
_rtw_spinunlock_bh(&pfree_xmit_queue->lock);
return FAIL;
} else {
phead = get_list_head(pfree_xmit_queue);
plist = get_next(phead);
pxframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
rtw_list_delete(&pxframe->list);
pxmitpriv->free_xmitframe_cnt--;
pxframe->os_qid = os_qid;
}
_rtw_spinunlock_bh(&pfree_xmit_queue->lock);
rtw_os_check_stop_queue(pxmitpriv->adapter, os_qid);
core_tx_init_xmitframe(pxframe);
*pxmitframe = pxframe;
return SUCCESS;
}
s32 core_tx_free_xmitframe(_adapter *padapter, struct xmit_frame *pxframe)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_queue *queue = NULL;
/* TXREQ_QMGT */
struct xmit_txreq_buf *ptxreq_buf = NULL;
int i;
struct rtw_xmit_req *txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
PHLTX_LOG;
if (pxframe == NULL)
goto exit;
/* TXREQ_QMGT */
ptxreq_buf = pxframe->ptxreq_buf;
pxframe->txfree_cnt++;
/* ?? shall detail check, like free 1 2 3, not free 2 2 3 */
/* ?? rtw_alloc_xmitframe_once case, seems no one use*/
if (pxframe->txfree_cnt < pxframe->txreq_cnt)
goto exit;
#if 0 /*CONFIG_CORE_XMITBUF*/
if (pxframe->pxmitbuf)
rtw_free_xmitbuf(pxmitpriv, pxframe->pxmitbuf);
#endif
for (i = 0; i < pxframe->txreq_cnt; i++) {
if (!pxframe->buf_need_free)
break;
if (!(pxframe->buf_need_free & BIT(i)))
continue;
pxframe->buf_need_free &= ~BIT(i);
txreq = &pxframe->phl_txreq[i];
rtw_warn_on(txreq->pkt_cnt != 1);
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
if (pkt_list->vir_addr && pkt_list->length)
rtw_mfree(pkt_list->vir_addr, pkt_list->length);
}
if (ptxreq_buf) {
queue = &padapter->free_txreq_queue;
_rtw_spinlock_bh(&queue->lock);
rtw_list_delete(&ptxreq_buf->list);
rtw_list_insert_tail(&ptxreq_buf->list, get_list_head(queue));
padapter->free_txreq_cnt++;
_rtw_spinunlock_bh(&queue->lock);
} else {
if (pxframe->ext_tag == 0)
;//printk("%s:tx recyele: ptxreq_buf=NULL\n", __FUNCTION__);
}
rtw_os_xmit_complete(padapter, pxframe);
if (pxframe->ext_tag == 0)
queue = &pxmitpriv->free_xmit_queue;
else if (pxframe->ext_tag == 1)
queue = &pxmitpriv->free_xframe_ext_queue;
else
rtw_warn_on(1);
_rtw_spinlock_bh(&queue->lock);
rtw_list_delete(&pxframe->list);
rtw_list_insert_tail(&pxframe->list, get_list_head(queue));
if (pxframe->ext_tag == 0)
pxmitpriv->free_xmitframe_cnt++;
else if (pxframe->ext_tag == 1)
pxmitpriv->free_xframe_ext_cnt++;
_rtw_spinunlock_bh(&queue->lock);
if (queue == &pxmitpriv->free_xmit_queue)
rtw_os_check_wakup_queue(padapter, pxframe->os_qid);
exit:
return _SUCCESS;
}
#endif
struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv, u16 os_qid)/* (_queue *pfree_xmit_queue) */
{
/*
Please remember to use all the osdep_service api,
and lock/unlock or _enter/_exit critical to protect
pfree_xmit_queue
*/
struct xmit_frame *pxframe = NULL;
_list *plist, *phead;
_queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue;
_rtw_spinlock_bh(&pfree_xmit_queue->lock);
if (_rtw_queue_empty(pfree_xmit_queue) == _TRUE) {
pxframe = NULL;
} else {
phead = get_list_head(pfree_xmit_queue);
plist = get_next(phead);
pxframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
rtw_list_delete(&(pxframe->list));
pxmitpriv->free_xmitframe_cnt--;
pxframe->os_qid = os_qid;
}
_rtw_spinunlock_bh(&pfree_xmit_queue->lock);
if (pxframe)
rtw_os_check_stop_queue(pxmitpriv->adapter, os_qid);
rtw_init_xmitframe(pxframe);
return pxframe;
}
struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv)
{
struct xmit_frame *pxframe = NULL;
_list *plist, *phead;
_queue *queue = &pxmitpriv->free_xframe_ext_queue;
_rtw_spinlock_bh(&queue->lock);
if (_rtw_queue_empty(queue) == _TRUE) {
pxframe = NULL;
} else {
phead = get_list_head(queue);
plist = get_next(phead);
pxframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
rtw_list_delete(&(pxframe->list));
pxmitpriv->free_xframe_ext_cnt--;
}
_rtw_spinunlock_bh(&queue->lock);
rtw_init_xmitframe(pxframe);
return pxframe;
}
struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv)
{
struct xmit_frame *pxframe = NULL;
u8 *alloc_addr;
alloc_addr = rtw_zmalloc(sizeof(struct xmit_frame) + 4);
if (alloc_addr == NULL)
goto exit;
pxframe = (struct xmit_frame *)N_BYTE_ALIGMENT((SIZE_PTR)(alloc_addr), 4);
pxframe->alloc_addr = alloc_addr;
pxframe->padapter = pxmitpriv->adapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
#if 0 /*CONFIG_CORE_XMITBUF*/
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
#endif
rtw_init_xmitframe(pxframe);
RTW_INFO("################## %s ##################\n", __func__);
exit:
return pxframe;
}
s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe)
{
_queue *queue = NULL;
_adapter *padapter = pxmitpriv->adapter;
struct sk_buff *pndis_pkt = NULL;
if (pxmitframe == NULL) {
goto exit;
}
if (pxmitframe->pkt) {
pndis_pkt = pxmitframe->pkt;
pxmitframe->pkt = NULL;
}
if (pxmitframe->alloc_addr) {
RTW_INFO("################## %s with alloc_addr ##################\n", __func__);
rtw_mfree(pxmitframe->alloc_addr, sizeof(struct xmit_frame) + 4);
goto check_pkt_complete;
}
if (pxmitframe->ext_tag == 0)
queue = &pxmitpriv->free_xmit_queue;
else if (pxmitframe->ext_tag == 1)
queue = &pxmitpriv->free_xframe_ext_queue;
else
rtw_warn_on(1);
_rtw_spinlock_bh(&queue->lock);
rtw_list_delete(&pxmitframe->list);
rtw_list_insert_tail(&pxmitframe->list, get_list_head(queue));
if (pxmitframe->ext_tag == 0) {
pxmitpriv->free_xmitframe_cnt++;
} else if (pxmitframe->ext_tag == 1) {
pxmitpriv->free_xframe_ext_cnt++;
} else {
}
_rtw_spinunlock_bh(&queue->lock);
if (queue == &pxmitpriv->free_xmit_queue)
rtw_os_check_wakup_queue(padapter, pxmitframe->os_qid);
check_pkt_complete:
if (pndis_pkt)
rtw_os_pkt_complete(padapter, pndis_pkt);
exit:
return _SUCCESS;
}
void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, _queue *pframequeue)
{
_list *plist, *phead;
struct xmit_frame *pxmitframe;
_rtw_spinlock_bh(&(pframequeue->lock));
phead = get_list_head(pframequeue);
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
pxmitframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
plist = get_next(plist);
rtw_free_xmitframe(pxmitpriv, pxmitframe);
}
_rtw_spinunlock_bh(&(pframequeue->lock));
}
s32 rtw_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe)
{
DBG_COUNTER(padapter->tx_logs.core_tx_enqueue);
if (rtw_xmit_classifier(padapter, pxmitframe) == _FAIL) {
/* pxmitframe->pkt = NULL; */
return _FAIL;
}
return _SUCCESS;
}
static struct xmit_frame *dequeue_one_xmitframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit, struct tx_servq *ptxservq, _queue *pframe_queue)
{
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
xmitframe_phead = get_list_head(pframe_queue);
xmitframe_plist = get_next(xmitframe_phead);
while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
/* xmitframe_plist = get_next(xmitframe_plist); */
/*#ifdef RTK_DMP_PLATFORM
#ifdef CONFIG_USB_TX_AGGREGATION
if((ptxservq->qcnt>0) && (ptxservq->qcnt<=2))
{
pxmitframe = NULL;
rtw_tasklet_schedule(&pxmitpriv->xmit_tasklet);
break;
}
#endif
#endif*/
rtw_list_delete(&pxmitframe->list);
ptxservq->qcnt--;
/* rtw_list_insert_tail(&pxmitframe->list, &phwxmit->pending); */
/* ptxservq->qcnt--; */
break;
/* pxmitframe = NULL; */
}
return pxmitframe;
}
static struct xmit_frame *get_one_xmitframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit, struct tx_servq *ptxservq, _queue *pframe_queue)
{
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
xmitframe_phead = get_list_head(pframe_queue);
xmitframe_plist = get_next(xmitframe_phead);
while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
break;
}
return pxmitframe;
}
struct xmit_frame *rtw_get_xframe(struct xmit_priv *pxmitpriv, int *num_frame)
{
_list *sta_plist, *sta_phead;
struct hw_xmit *phwxmit_i = pxmitpriv->hwxmits;
sint entry = pxmitpriv->hwxmit_entry;
struct hw_xmit *phwxmit;
struct tx_servq *ptxservq = NULL;
_queue *pframe_queue = NULL;
struct xmit_frame *pxmitframe = NULL;
_adapter *padapter = pxmitpriv->adapter;
int i, inx[4];
inx[0] = 0;
inx[1] = 1;
inx[2] = 2;
inx[3] = 3;
*num_frame = 0;
_rtw_spinlock_bh(&pxmitpriv->lock);
for (i = 0; i < entry; i++) {
phwxmit = phwxmit_i + inx[i];
sta_phead = get_list_head(phwxmit->sta_queue);
sta_plist = get_next(sta_phead);
while ((rtw_end_of_queue_search(sta_phead, sta_plist)) == _FALSE) {
ptxservq = LIST_CONTAINOR(sta_plist, struct tx_servq, tx_pending);
pframe_queue = &ptxservq->sta_pending;
if (ptxservq->qcnt) {
*num_frame = ptxservq->qcnt;
pxmitframe = get_one_xmitframe(pxmitpriv, phwxmit, ptxservq, pframe_queue);
goto exit;
}
sta_plist = get_next(sta_plist);
}
}
exit:
_rtw_spinunlock_bh(&pxmitpriv->lock);
return pxmitframe;
}
struct xmit_frame *rtw_dequeue_xframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit_i, sint entry)
{
_list *sta_plist, *sta_phead;
struct hw_xmit *phwxmit;
struct tx_servq *ptxservq = NULL;
_queue *pframe_queue = NULL;
struct xmit_frame *pxmitframe = NULL;
_adapter *padapter = pxmitpriv->adapter;
struct registry_priv *pregpriv = &padapter->registrypriv;
int i, inx[4];
inx[0] = 0;
inx[1] = 1;
inx[2] = 2;
inx[3] = 3;
if (pregpriv->wifi_spec == 1) {
int j;
#if 0
if (flags < XMIT_QUEUE_ENTRY) {
/* priority exchange according to the completed xmitbuf flags. */
inx[flags] = 0;
inx[0] = flags;
}
#endif
#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_PCI_HCI)
for (j = 0; j < 4; j++)
inx[j] = pxmitpriv->wmm_para_seq[j];
#endif
}
_rtw_spinlock_bh(&pxmitpriv->lock);
for (i = 0; i < entry; i++) {
phwxmit = phwxmit_i + inx[i];
/* _rtw_spinlock_irq(&phwxmit->sta_queue->lock, &sp_flags); */
sta_phead = get_list_head(phwxmit->sta_queue);
sta_plist = get_next(sta_phead);
while ((rtw_end_of_queue_search(sta_phead, sta_plist)) == _FALSE) {
ptxservq = LIST_CONTAINOR(sta_plist, struct tx_servq, tx_pending);
pframe_queue = &ptxservq->sta_pending;
pxmitframe = dequeue_one_xmitframe(pxmitpriv, phwxmit, ptxservq, pframe_queue);
if (pxmitframe) {
phwxmit->accnt--;
/* Remove sta node when there is no pending packets. */
if (_rtw_queue_empty(pframe_queue)) /* must be done after get_next and before break */
rtw_list_delete(&ptxservq->tx_pending);
/* _rtw_spinunlock_irq(&phwxmit->sta_queue->lock, sp_flags); */
goto exit;
}
sta_plist = get_next(sta_plist);
}
/* _rtw_spinunlock_irq(&phwxmit->sta_queue->lock, sp_flags); */
}
exit:
_rtw_spinunlock_bh(&pxmitpriv->lock);
return pxmitframe;
}
#if 1
struct tx_servq *rtw_get_sta_pending(_adapter *padapter, struct sta_info *psta, sint up, u8 *ac)
{
struct tx_servq *ptxservq = NULL;
switch (up) {
case 1:
case 2:
ptxservq = &(psta->sta_xmitpriv.bk_q);
*(ac) = 3;
break;
case 4:
case 5:
ptxservq = &(psta->sta_xmitpriv.vi_q);
*(ac) = 1;
break;
case 6:
case 7:
ptxservq = &(psta->sta_xmitpriv.vo_q);
*(ac) = 0;
break;
case 0:
case 3:
default:
ptxservq = &(psta->sta_xmitpriv.be_q);
*(ac) = 2;
break;
}
return ptxservq;
}
#else
__inline static struct tx_servq *rtw_get_sta_pending
(_adapter *padapter, _queue **ppstapending, struct sta_info *psta, sint up) {
struct tx_servq *ptxservq;
struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
#ifdef CONFIG_RTL8711
if (IS_MCAST(psta->phl_sta->mac_addr)) {
ptxservq = &(psta->sta_xmitpriv.be_q); /* we will use be_q to queue bc/mc frames in BCMC_stainfo */
*ppstapending = &padapter->xmitpriv.bm_pending;
} else
#endif
{
switch (up) {
case 1:
case 2:
ptxservq = &(psta->sta_xmitpriv.bk_q);
*ppstapending = &padapter->xmitpriv.bk_pending;
(phwxmits + 3)->accnt++;
break;
case 4:
case 5:
ptxservq = &(psta->sta_xmitpriv.vi_q);
*ppstapending = &padapter->xmitpriv.vi_pending;
(phwxmits + 1)->accnt++;
break;
case 6:
case 7:
ptxservq = &(psta->sta_xmitpriv.vo_q);
*ppstapending = &padapter->xmitpriv.vo_pending;
(phwxmits + 0)->accnt++;
break;
case 0:
case 3:
default:
ptxservq = &(psta->sta_xmitpriv.be_q);
*ppstapending = &padapter->xmitpriv.be_pending;
(phwxmits + 2)->accnt++;
break;
}
}
return ptxservq;
}
#endif
/*
* Will enqueue pxmitframe to the proper queue,
* and indicate it to xx_pending list.....
*/
s32 rtw_xmit_classifier(_adapter *padapter, struct xmit_frame *pxmitframe)
{
u8 ac_index;
struct sta_info *psta;
struct tx_servq *ptxservq;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
sint res = _SUCCESS;
DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class);
/*
if (pattrib->psta) {
psta = pattrib->psta;
} else {
RTW_INFO("%s, call rtw_get_stainfo()\n", __func__);
psta = rtw_get_stainfo(pstapriv, pattrib->ra);
}
*/
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta) {
DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class_err_sta);
RTW_INFO("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta);
return _FAIL;
}
if (psta == NULL) {
DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class_err_nosta);
res = _FAIL;
RTW_INFO("rtw_xmit_classifier: psta == NULL\n");
goto exit;
}
if (!(psta->state & WIFI_ASOC_STATE)) {
DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class_err_fwlink);
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return _FAIL;
}
ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
/* _rtw_spinlock_irq(&pstapending->lock, &flags); */
if (rtw_is_list_empty(&ptxservq->tx_pending))
rtw_list_insert_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue));
/* _rtw_spinlock_irq(&ptxservq->sta_pending.lock, &sp_flags); */
rtw_list_insert_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending));
ptxservq->qcnt++;
phwxmits[ac_index].accnt++;
/* _rtw_spinunlock_irq(&ptxservq->sta_pending.lock, &sp_flags); */
/* _rtw_spinunlock_irq(&pstapending->lock, &flags); */
exit:
return res;
}
void rtw_alloc_hwxmits(_adapter *padapter)
{
struct hw_xmit *hwxmits;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
pxmitpriv->hwxmit_entry = HWXMIT_ENTRY;
pxmitpriv->hwxmits = NULL;
pxmitpriv->hwxmits = (struct hw_xmit *)rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry);
if (pxmitpriv->hwxmits == NULL) {
RTW_INFO("alloc hwxmits fail!...\n");
return;
}
hwxmits = pxmitpriv->hwxmits;
if (pxmitpriv->hwxmit_entry == 5) {
/* pxmitpriv->bmc_txqueue.head = 0; */
/* hwxmits[0] .phwtxqueue = &pxmitpriv->bmc_txqueue; */
hwxmits[0] .sta_queue = &pxmitpriv->bm_pending;
/* pxmitpriv->vo_txqueue.head = 0; */
/* hwxmits[1] .phwtxqueue = &pxmitpriv->vo_txqueue; */
hwxmits[1] .sta_queue = &pxmitpriv->vo_pending;
/* pxmitpriv->vi_txqueue.head = 0; */
/* hwxmits[2] .phwtxqueue = &pxmitpriv->vi_txqueue; */
hwxmits[2] .sta_queue = &pxmitpriv->vi_pending;
/* pxmitpriv->bk_txqueue.head = 0; */
/* hwxmits[3] .phwtxqueue = &pxmitpriv->bk_txqueue; */
hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
/* pxmitpriv->be_txqueue.head = 0; */
/* hwxmits[4] .phwtxqueue = &pxmitpriv->be_txqueue; */
hwxmits[4] .sta_queue = &pxmitpriv->be_pending;
} else if (pxmitpriv->hwxmit_entry == 4) {
/* pxmitpriv->vo_txqueue.head = 0; */
/* hwxmits[0] .phwtxqueue = &pxmitpriv->vo_txqueue; */
hwxmits[0] .sta_queue = &pxmitpriv->vo_pending;
/* pxmitpriv->vi_txqueue.head = 0; */
/* hwxmits[1] .phwtxqueue = &pxmitpriv->vi_txqueue; */
hwxmits[1] .sta_queue = &pxmitpriv->vi_pending;
/* pxmitpriv->be_txqueue.head = 0; */
/* hwxmits[2] .phwtxqueue = &pxmitpriv->be_txqueue; */
hwxmits[2] .sta_queue = &pxmitpriv->be_pending;
/* pxmitpriv->bk_txqueue.head = 0; */
/* hwxmits[3] .phwtxqueue = &pxmitpriv->bk_txqueue; */
hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
} else {
}
}
void rtw_free_hwxmits(_adapter *padapter)
{
struct hw_xmit *hwxmits;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
hwxmits = pxmitpriv->hwxmits;
if (hwxmits)
rtw_mfree((u8 *)hwxmits, (sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry));
}
void rtw_init_hwxmits(struct hw_xmit *phwxmit, sint entry)
{
sint i;
for (i = 0; i < entry; i++, phwxmit++) {
/* _rtw_spinlock_init(&phwxmit->xmit_lock); */
/* _rtw_init_listhead(&phwxmit->pending); */
/* phwxmit->txcmdcnt = 0; */
phwxmit->accnt = 0;
}
}
#ifdef CONFIG_BR_EXT
int rtw_br_client_tx(_adapter *padapter, struct sk_buff **pskb)
{
struct sk_buff *skb = *pskb;
/* if(MLME_IS_STA(adapter) */
{
void dhcp_flag_bcast(_adapter *priv, struct sk_buff *skb);
int res, is_vlan_tag = 0, i, do_nat25 = 1;
unsigned short vlan_hdr = 0;
void *br_port = NULL;
/* mac_clone_handle_frame(priv, skb); */
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
br_port = padapter->pnetdev->br_port;
#else /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) */
rcu_read_lock();
br_port = rcu_dereference(padapter->pnetdev->rx_handler_data);
rcu_read_unlock();
#endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) */
_rtw_spinlock_bh(&padapter->br_ext_lock);
if (!(skb->data[0] & 1) &&
br_port &&
_rtw_memcmp(skb->data + MACADDRLEN, padapter->br_mac, MACADDRLEN) &&
*((unsigned short *)(skb->data + MACADDRLEN * 2)) != __constant_htons(ETH_P_8021Q) &&
*((unsigned short *)(skb->data + MACADDRLEN * 2)) == __constant_htons(ETH_P_IP) &&
!_rtw_memcmp(padapter->scdb_mac, skb->data + MACADDRLEN, MACADDRLEN) && padapter->scdb_entry) {
_rtw_memcpy(skb->data + MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
padapter->scdb_entry->ageing_timer = jiffies;
_rtw_spinunlock_bh(&padapter->br_ext_lock);
} else
/* if (!priv->pmib->ethBrExtInfo.nat25_disable) */
{
/* if (priv->dev->br_port &&
* !_rtw_memcmp(skb->data+MACADDRLEN, priv->br_mac, MACADDRLEN)) { */
#if 1
if (*((unsigned short *)(skb->data + MACADDRLEN * 2)) == __constant_htons(ETH_P_8021Q)) {
is_vlan_tag = 1;
vlan_hdr = *((unsigned short *)(skb->data + MACADDRLEN * 2 + 2));
for (i = 0; i < 6; i++)
*((unsigned short *)(skb->data + MACADDRLEN * 2 + 2 - i * 2)) = *((unsigned short *)(skb->data + MACADDRLEN * 2 - 2 - i * 2));
skb_pull(skb, 4);
}
/* if SA == br_mac && skb== IP => copy SIP to br_ip ?? why */
if (!_rtw_memcmp(skb->data + MACADDRLEN, padapter->br_mac, MACADDRLEN) &&
(*((unsigned short *)(skb->data + MACADDRLEN * 2)) == __constant_htons(ETH_P_IP)))
_rtw_memcpy(padapter->br_ip, skb->data + WLAN_ETHHDR_LEN + 12, 4);
if (*((unsigned short *)(skb->data + MACADDRLEN * 2)) == __constant_htons(ETH_P_IP)) {
if (_rtw_memcmp(padapter->scdb_mac, skb->data + MACADDRLEN, MACADDRLEN)) {
void *scdb_findEntry(_adapter *priv, unsigned char *macAddr, unsigned char *ipAddr);
padapter->scdb_entry = (struct nat25_network_db_entry *)scdb_findEntry(padapter,
skb->data + MACADDRLEN, skb->data + WLAN_ETHHDR_LEN + 12);
if (padapter->scdb_entry != NULL) {
_rtw_memcpy(padapter->scdb_mac, skb->data + MACADDRLEN, MACADDRLEN);
_rtw_memcpy(padapter->scdb_ip, skb->data + WLAN_ETHHDR_LEN + 12, 4);
padapter->scdb_entry->ageing_timer = jiffies;
do_nat25 = 0;
}
} else {
if (padapter->scdb_entry) {
padapter->scdb_entry->ageing_timer = jiffies;
do_nat25 = 0;
} else {
_rtw_memset(padapter->scdb_mac, 0, MACADDRLEN);
_rtw_memset(padapter->scdb_ip, 0, 4);
}
}
}
_rtw_spinunlock_bh(&padapter->br_ext_lock);
#endif /* 1 */
if (do_nat25) {
int nat25_db_handle(_adapter *priv, struct sk_buff *skb, int method);
if (nat25_db_handle(padapter, skb, NAT25_CHECK) == 0) {
struct sk_buff *newskb;
if (is_vlan_tag) {
skb_push(skb, 4);
for (i = 0; i < 6; i++)
*((unsigned short *)(skb->data + i * 2)) = *((unsigned short *)(skb->data + 4 + i * 2));
*((unsigned short *)(skb->data + MACADDRLEN * 2)) = __constant_htons(ETH_P_8021Q);
*((unsigned short *)(skb->data + MACADDRLEN * 2 + 2)) = vlan_hdr;
}
newskb = rtw_skb_copy(skb);
if (newskb == NULL) {
/* priv->ext_stats.tx_drops++; */
DEBUG_ERR("TX DROP: rtw_skb_copy fail!\n");
/* goto stop_proc; */
return -1;
}
rtw_skb_free(skb);
*pskb = skb = newskb;
if (is_vlan_tag) {
vlan_hdr = *((unsigned short *)(skb->data + MACADDRLEN * 2 + 2));
for (i = 0; i < 6; i++)
*((unsigned short *)(skb->data + MACADDRLEN * 2 + 2 - i * 2)) = *((unsigned short *)(skb->data + MACADDRLEN * 2 - 2 - i * 2));
skb_pull(skb, 4);
}
}
if (skb_is_nonlinear(skb))
DEBUG_ERR("%s(): skb_is_nonlinear!!\n", __FUNCTION__);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
res = skb_linearize(skb, GFP_ATOMIC);
#else /* (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)) */
res = skb_linearize(skb);
#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)) */
if (res < 0) {
DEBUG_ERR("TX DROP: skb_linearize fail!\n");
/* goto free_and_stop; */
return -1;
}
res = nat25_db_handle(padapter, skb, NAT25_INSERT);
if (res < 0) {
if (res == -2) {
/* priv->ext_stats.tx_drops++; */
DEBUG_ERR("TX DROP: nat25_db_handle fail!\n");
/* goto free_and_stop; */
return -1;
}
/* we just print warning message and let it go */
/* DEBUG_WARN("%s()-%d: nat25_db_handle INSERT Warning!\n", __FUNCTION__, __LINE__); */
/* return -1; */ /* return -1 will cause system crash on 2011/08/30! */
return 0;
}
}
_rtw_memcpy(skb->data + MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
dhcp_flag_bcast(padapter, skb);
if (is_vlan_tag) {
skb_push(skb, 4);
for (i = 0; i < 6; i++)
*((unsigned short *)(skb->data + i * 2)) = *((unsigned short *)(skb->data + 4 + i * 2));
*((unsigned short *)(skb->data + MACADDRLEN * 2)) = __constant_htons(ETH_P_8021Q);
*((unsigned short *)(skb->data + MACADDRLEN * 2 + 2)) = vlan_hdr;
}
}
#if 0
else {
if (*((unsigned short *)(skb->data + MACADDRLEN * 2)) == __constant_htons(ETH_P_8021Q))
is_vlan_tag = 1;
if (is_vlan_tag) {
if (ICMPV6_MCAST_MAC(skb->data) && ICMPV6_PROTO1A_VALN(skb->data))
_rtw_memcpy(skb->data + MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
} else {
if (ICMPV6_MCAST_MAC(skb->data) && ICMPV6_PROTO1A(skb->data))
_rtw_memcpy(skb->data + MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN);
}
}
#endif /* 0 */
/* check if SA is equal to our MAC */
if (_rtw_memcmp(skb->data + MACADDRLEN, GET_MY_HWADDR(padapter), MACADDRLEN)) {
/* priv->ext_stats.tx_drops++; */
DEBUG_ERR("TX DROP: untransformed frame SA:%02X%02X%02X%02X%02X%02X!\n",
skb->data[6], skb->data[7], skb->data[8], skb->data[9], skb->data[10], skb->data[11]);
/* goto free_and_stop; */
return -1;
}
}
return 0;
}
#endif /* CONFIG_BR_EXT */
static void do_queue_select(_adapter *padapter, struct pkt_attrib *pattrib)
{
u8 qsel;
qsel = pattrib->priority;
/* high priority packet */
if (pattrib->hipriority_pkt) {
pattrib->qsel = rtw_hal_get_qsel(padapter, QSLT_VO_ID);
pattrib->priority = rtw_hal_get_qsel(padapter, QSLT_VO_ID);
}
}
/*
* The main transmit(tx) entry
*
* Return
* 1 enqueue
* 0 success, hardware will handle this xmit frame(packet)
* <0 fail
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
s32 rtw_monitor_xmit_entry(struct sk_buff *skb, struct net_device *ndev)
{
u16 frame_ctl;
struct ieee80211_radiotap_header rtap_hdr;
_adapter *padapter = (_adapter *)rtw_netdev_priv(ndev);
struct pkt_file pktfile;
struct rtw_ieee80211_hdr *pwlanhdr;
struct pkt_attrib *pattrib;
struct xmit_frame *pmgntframe;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
unsigned char *pframe;
u8 dummybuf[32];
int len = skb->len, rtap_len;
rtw_mstat_update(MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, skb->truesize);
#ifndef CONFIG_CUSTOMER_ALIBABA_GENERAL
if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
goto fail;
_rtw_open_pktfile((struct sk_buff *)skb, &pktfile);
_rtw_pktfile_read(&pktfile, (u8 *)(&rtap_hdr), sizeof(struct ieee80211_radiotap_header));
rtap_len = ieee80211_get_radiotap_len((u8 *)(&rtap_hdr));
if (unlikely(rtap_hdr.it_version))
goto fail;
if (unlikely(skb->len < rtap_len))
goto fail;
if (rtap_len != 12) {
RTW_INFO("radiotap len (should be 14): %d\n", rtap_len);
goto fail;
}
_rtw_pktfile_read(&pktfile, dummybuf, rtap_len-sizeof(struct ieee80211_radiotap_header));
len = len - rtap_len;
#endif
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL) {
rtw_udelay_os(500);
goto fail;
}
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
// _rtw_memcpy(pframe, (void *)checking, len);
_rtw_pktfile_read(&pktfile, pframe, len);
/* Check DATA/MGNT frames */
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
frame_ctl = le16_to_cpu(pwlanhdr->frame_ctl);
if ((frame_ctl & RTW_IEEE80211_FCTL_FTYPE) == RTW_IEEE80211_FTYPE_DATA) {
pattrib = &pmgntframe->attrib;
update_monitor_frame_attrib(padapter, pattrib);
if (is_broadcast_mac_addr(pwlanhdr->addr3) || is_broadcast_mac_addr(pwlanhdr->addr1))
pattrib->rate = MGN_24M;
} else {
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
}
pattrib->retry_ctrl = _FALSE;
pattrib->pktlen = len;
pmlmeext->mgnt_seq = GetSequence(pwlanhdr);
pattrib->seqnum = pmlmeext->mgnt_seq;
pmlmeext->mgnt_seq++;
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
fail:
rtw_skb_free(skb);
return 0;
}
#endif
/*
*
* Return _TRUE when frame has been put to queue, otherwise return _FALSE.
*/
static u8 xmit_enqueue(_adapter *a, struct xmit_frame *frame)
{
struct sta_info *sta = NULL;
struct pkt_attrib *attrib = NULL;
_list *head;
u8 ret = _TRUE;
attrib = &frame->attrib;
sta = attrib->psta;
if (!sta)
return _FALSE;
_rtw_spinlock_bh(&sta->tx_queue.lock);
head = get_list_head(&sta->tx_queue);
if ((rtw_is_list_empty(head) == _TRUE) && (!sta->tx_q_enable)) {
ret = _FALSE;
goto exit;
}
rtw_list_insert_tail(&frame->list, head);
RTW_INFO(FUNC_ADPT_FMT ": en-queue tx pkt for macid=%d\n",
FUNC_ADPT_ARG(a), sta->phl_sta->macid);
exit:
_rtw_spinunlock_bh(&sta->tx_queue.lock);
return ret;
}
static void xmit_dequeue(struct sta_info *sta)
{
_adapter *a;
_list *head, *list;
struct xmit_frame *frame;
a = sta->padapter;
_rtw_spinlock_bh(&sta->tx_queue.lock);
head = get_list_head(&sta->tx_queue);
do {
if (rtw_is_list_empty(head) == _TRUE)
break;
list = get_next(head);
rtw_list_delete(list);
frame = LIST_CONTAINOR(list, struct xmit_frame, list);
RTW_INFO(FUNC_ADPT_FMT ": de-queue tx frame of macid=%d\n",
FUNC_ADPT_ARG(a), sta->phl_sta->macid);
/*rtw_hal_xmit(a, frame);*/
rtw_intf_data_xmit(a, frame);
} while (1);
_rtw_spinunlock_bh(&sta->tx_queue.lock);
}
void rtw_xmit_dequeue_callback(_workitem *work)
{
struct sta_info *sta;
sta = container_of(work, struct sta_info, tx_q_work);
xmit_dequeue(sta);
}
void rtw_xmit_queue_set(struct sta_info *sta)
{
_rtw_spinlock_bh(&sta->tx_queue.lock);
if (sta->tx_q_enable) {
RTW_WARN(FUNC_ADPT_FMT ": duplicated set!\n",
FUNC_ADPT_ARG(sta->padapter));
goto exit;
}
sta->tx_q_enable = 1;
RTW_INFO(FUNC_ADPT_FMT ": enable queue TX for macid=%d\n",
FUNC_ADPT_ARG(sta->padapter), sta->phl_sta->macid);
exit:
_rtw_spinunlock_bh(&sta->tx_queue.lock);
}
void rtw_xmit_queue_clear(struct sta_info *sta)
{
_rtw_spinlock_bh(&sta->tx_queue.lock);
if (!sta->tx_q_enable) {
RTW_WARN(FUNC_ADPT_FMT ": tx queue for macid=%d "
"not be enabled!\n",
FUNC_ADPT_ARG(sta->padapter), sta->phl_sta->macid);
goto exit;
}
sta->tx_q_enable = 0;
RTW_INFO(FUNC_ADPT_FMT ": disable queue TX for macid=%d\n",
FUNC_ADPT_ARG(sta->padapter), sta->phl_sta->macid);
_set_workitem(&sta->tx_q_work);
exit:
_rtw_spinunlock_bh(&sta->tx_queue.lock);
}
/*
* The main transmit(tx) entry post handle
*
* Return
* 1 enqueue
* 0 success, hardware will handle this xmit frame(packet)
* <0 fail
*/
s32 rtw_xmit_posthandle(_adapter *padapter, struct xmit_frame *pxmitframe,
struct sk_buff *pkt)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
s32 res;
res = update_attrib(padapter, pkt, &pxmitframe->attrib);
#ifdef CONFIG_WAPI_SUPPORT
if (pxmitframe->attrib.ether_type != 0x88B4) {
if (rtw_wapi_drop_for_key_absent(padapter, pxmitframe->attrib.ra)) {
WAPI_TRACE(WAPI_RX, "drop for key absend when tx\n");
res = _FAIL;
}
}
#endif
if (res == _FAIL) {
/*RTW_INFO("%s-"ADPT_FMT" update attrib fail\n", __func__, ADPT_ARG(padapter));*/
#ifdef DBG_TX_DROP_FRAME
RTW_INFO("DBG_TX_DROP_FRAME %s update attrib fail\n", __FUNCTION__);
#endif
rtw_free_xmitframe(pxmitpriv, pxmitframe);
return -1;
}
pxmitframe->pkt = pkt;
rtw_led_tx_control(padapter, pxmitframe->attrib.dst);
do_queue_select(padapter, &pxmitframe->attrib);
#ifdef CONFIG_AP_MODE
_rtw_spinlock_bh(&pxmitpriv->lock);
if (xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe) == _TRUE) {
_rtw_spinunlock_bh(&pxmitpriv->lock);
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue);
return 1;
}
_rtw_spinunlock_bh(&pxmitpriv->lock);
#endif
/*if (xmit_enqueue(padapter, pxmitframe) == _TRUE)*/
/* return 1;*/
/* pre_xmitframe */
/*if (rtw_hal_xmit(padapter, pxmitframe) == _FALSE)*/
if (rtw_intf_data_xmit(padapter, pxmitframe) == _FALSE)
return 1;
return 0;
}
/*
* The main transmit(tx) entry
*
* Return
* 1 enqueue
* 0 success, hardware will handle this xmit frame(packet)
* <0 fail
*/
s32 rtw_xmit(_adapter *padapter, struct sk_buff **ppkt, u16 os_qid)
{
static systime start = 0;
static u32 drop_cnt = 0;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pxmitframe = NULL;
s32 res;
DBG_COUNTER(padapter->tx_logs.core_tx);
if (IS_CH_WAITING(adapter_to_rfctl(padapter)))
return -1;
if (rtw_linked_check(padapter) == _FALSE)
return -1;
if (start == 0)
start = rtw_get_current_time();
pxmitframe = rtw_alloc_xmitframe(pxmitpriv, os_qid);
if (rtw_get_passing_time_ms(start) > 2000) {
if (drop_cnt)
RTW_INFO("DBG_TX_DROP_FRAME %s no more pxmitframe, drop_cnt:%u\n", __FUNCTION__, drop_cnt);
start = rtw_get_current_time();
drop_cnt = 0;
}
if (pxmitframe == NULL) {
drop_cnt++;
/*RTW_INFO("%s-"ADPT_FMT" no more xmitframe\n", __func__, ADPT_ARG(padapter));*/
DBG_COUNTER(padapter->tx_logs.core_tx_err_pxmitframe);
return -1;
}
#ifdef CONFIG_BR_EXT
if (MLME_IS_STA(padapter) || MLME_IS_ADHOC(padapter)) {
void *br_port = NULL;
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
br_port = padapter->pnetdev->br_port;
#else
rcu_read_lock();
br_port = rcu_dereference(padapter->pnetdev->rx_handler_data);
rcu_read_unlock();
#endif
if (br_port) {
res = rtw_br_client_tx(padapter, ppkt);
if (res == -1) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
DBG_COUNTER(padapter->tx_logs.core_tx_err_brtx);
return -1;
}
}
}
#endif /* CONFIG_BR_EXT */
#ifdef CONFIG_RTW_MESH
if (MLME_IS_MESH(padapter)) {
_list f_list;
res = rtw_mesh_addr_resolve(padapter, pxmitframe, *ppkt, &f_list);
if (res == RTW_RA_RESOLVING)
return 1;
if (res == _FAIL)
return -1;
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
if (!rtw_is_list_empty(&f_list)) {
_list *list = get_next(&f_list);
struct xmit_frame *fframe;
while ((rtw_end_of_queue_search(&f_list, list)) == _FALSE) {
fframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&fframe->list);
fframe->pkt = rtw_skb_copy(*ppkt);
if (!fframe->pkt) {
if (res == RTW_ORI_NO_NEED)
res = _SUCCESS;
rtw_free_xmitframe(pxmitpriv, fframe);
continue;
}
rtw_xmit_posthandle(padapter, fframe, fframe->pkt);
}
}
#endif /* CONFIG_RTW_MESH_DATA_BMC_TO_UC */
if (res == RTW_ORI_NO_NEED) {
rtw_free_xmitframe(&padapter->xmitpriv, pxmitframe);
return 0;
}
}
#endif /* CONFIG_RTW_MESH */
pxmitframe->pkt = NULL; /* let rtw_xmit_posthandle not to free pkt inside */
res = rtw_xmit_posthandle(padapter, pxmitframe, *ppkt);
return res;
}
#ifdef RTW_PHL_TX
#ifdef RTW_PHL_TEST_FPGA
u32 test_seq;
#endif
u8 *get_head_from_txreq(_adapter *padapter, struct xmit_frame *pxframe, u8 frag_idx)
{
return 0;
}
u8 *get_tail_from_txreq(_adapter *padapter, struct xmit_frame *pxframe, u8 frag_idx)
{
return 0;
}
void dump_pkt(u8 *start, u32 len)
{
u32 idx = 0;
for (idx = 0; idx < len; idx++) {
printk("%02x ", start[idx]);
if ((idx % 20) == 19)
printk("\n");
}
printk("\n");
}
/* TXREQ_QMGT */
u8 *get_txreq_buffer(_adapter *padapter, u8 **txreq, u8 **pkt_list, u8 **head, u8 **tail)
{
struct xmit_txreq_buf *ptxreq_buf = NULL;
_list *plist, *phead;
_queue *pfree_txreq_queue = &padapter->free_txreq_queue;
#ifdef CONFIG_CORE_TXSC
u8 i = 0;
#endif
_rtw_spinlock_bh(&pfree_txreq_queue->lock);
if (_rtw_queue_empty(pfree_txreq_queue) == _TRUE) {
padapter->txreq_full_cnt++;
} else {
phead = get_list_head(pfree_txreq_queue);
plist = get_next(phead);
ptxreq_buf = LIST_CONTAINOR(plist, struct xmit_txreq_buf, list);
rtw_list_delete(&ptxreq_buf->list);
padapter->free_txreq_cnt--;
}
_rtw_spinunlock_bh(&pfree_txreq_queue->lock);
if (ptxreq_buf) {
if (txreq)
*txreq = ptxreq_buf->txreq;
if (head)
*head = ptxreq_buf->head;
if (tail)
*tail = ptxreq_buf->tail;
if (pkt_list)
*pkt_list = ptxreq_buf->pkt_list;
#ifdef CONFIG_CORE_TXSC
for (i = 0; i < MAX_TXSC_SKB_NUM; i++)
ptxreq_buf->pkt[i] = NULL;
ptxreq_buf->pkt_cnt = 0;
#endif
}
return (u8 *)ptxreq_buf;
}
void get_txreq_resources(_adapter *padapter, struct xmit_frame *pxframe,
u8 **txreq, u8 **pkt_list, u8 **head, u8 **tail)
{
u32 offset_head = (sizeof(struct rtw_xmit_req) * RTW_MAX_FRAG_NUM);
u32 offset_tail = offset_head + (SZ_HEAD_BUF * RTW_MAX_FRAG_NUM);
u32 offset_list = offset_tail + (SZ_TAIL_BUF * RTW_MAX_FRAG_NUM);
u8 *pbuf = NULL;
PHLTX_ENTER;
//rtw_phl_tx todo: error handle, max tx req limit
padapter->tx_ring_idx++;
padapter->tx_ring_idx = (padapter->tx_ring_idx % MAX_TX_RING_NUM);
pbuf = padapter->tx_pool_ring[padapter->tx_ring_idx];
//memset(pbuf, 0, (SZ_TX_RING*RTW_MAX_FRAG_NUM));
if (txreq)
*txreq = pbuf;
if (head)
*head = pbuf + offset_head;
if (tail)
*tail = pbuf + offset_tail;
if (pkt_list)
*pkt_list = pbuf + offset_list;
}
void dump_xmitframe_txreq(_adapter *padapter, struct xmit_frame *pxframe)
{
struct rtw_xmit_req *txreq = pxframe->phl_txreq;
u32 idx, idx1 = 0;
PHLTX_ENTER;
printk("total txreq=%d \n", pxframe->txreq_cnt);
for (idx = 0; idx < pxframe->txreq_cnt; idx++) {
struct rtw_pkt_buf_list *pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
printk("txreq[%d] with %d pkts =====\n", idx, txreq->pkt_cnt);
for (idx1 = 0; idx1 < txreq->pkt_cnt; idx1++) {
printk("pkt[%d] 0x%p len=%d\n", idx1, (void *)pkt_list->vir_addr, pkt_list->length);
dump_pkt(pkt_list->vir_addr, pkt_list->length);
pkt_list++;
}
txreq++;
}
printk("\n");
}
#ifdef CONFIG_PCI_HCI
void core_recycle_txreq_phyaddr(_adapter *padapter, struct rtw_xmit_req *txreq)
{
PPCI_DATA pci_data = dvobj_to_pci(padapter->dvobj);
struct pci_dev *pdev = pci_data->ppcidev;
struct rtw_pkt_buf_list *pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
u32 idx = 0;
for (idx = 0; idx < txreq->pkt_cnt; idx++) {
dma_addr_t phy_addr = (pkt_list->phy_addr_l);
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
{
u64 phy_addr_h = pkt_list->phy_addr_h;
phy_addr |= (phy_addr_h << 32);
}
#endif
pci_unmap_bus_addr(pdev, &phy_addr, pkt_list->length, PCI_DMA_TODEVICE);
pkt_list++;
}
}
void fill_txreq_phyaddr(_adapter *padapter, struct xmit_frame *pxframe)
{
PPCI_DATA pci_data = dvobj_to_pci(padapter->dvobj);
struct pci_dev *pdev = pci_data->ppcidev;
struct rtw_xmit_req *txreq = pxframe->phl_txreq;
u32 idx, idx1 = 0;
PHLTX_ENTER;
for (idx = 0; idx < pxframe->txreq_cnt; idx++) {
struct rtw_pkt_buf_list *pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
for (idx1 = 0; idx1 < txreq->pkt_cnt; idx1++) {
dma_addr_t phy_addr = 0;
pci_get_bus_addr(pdev, pkt_list->vir_addr, &phy_addr, pkt_list->length, PCI_DMA_TODEVICE);
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
pkt_list->phy_addr_h = phy_addr >> 32;
#else
pkt_list->phy_addr_h = 0x0;
#endif
pkt_list->phy_addr_l = phy_addr & 0xFFFFFFFF;
pkt_list++;
}
txreq++;
}
}
#endif
static void _fill_txreq_list_skb(_adapter *padapter,
struct rtw_xmit_req *txreq, struct rtw_pkt_buf_list **pkt_list,
struct sk_buff *skb, u32 *req_sz, s32 *req_offset)
{
#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 4, 0))
#define skb_frag_off(f) ((f)->page_offset)
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0))
#define skb_frag_page(f) ((f)->page)
#define skb_frag_size(f) ((f)->size)
#endif
#define PKT_LIST_APPEND(_addr, _len) do { \
u32 __len = _len; \
if (__len == 0) \
break; \
list->vir_addr = _addr; \
list->length = __len; \
txreq->pkt_cnt++; \
txreq->total_len += __len; \
list++; \
*pkt_list = list; \
} while (0)
struct rtw_pkt_buf_list *list = *pkt_list;
u8 nr_frags = skb_shinfo(skb)->nr_frags;
s32 offset = *req_offset;
u32 rem_sz = *req_sz;
u32 cur_frag_total, cur_frag_rem;
int i;
/* skb head frag */
cur_frag_total = skb_headlen(skb);
if (cur_frag_total > offset) {
cur_frag_rem = rtw_min(cur_frag_total - offset, rem_sz);
PKT_LIST_APPEND(skb->data + offset, cur_frag_rem);
rem_sz -= cur_frag_rem;
offset = 0;
} else {
offset -= cur_frag_total;
}
for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
u8 *addr;
addr = ((void *)page_address(skb_frag_page(frag))) + skb_frag_off(frag);
cur_frag_total = skb_frag_size(frag);
if (offset < cur_frag_total) {
cur_frag_rem = cur_frag_total - offset;
if (rem_sz < cur_frag_rem) {
PKT_LIST_APPEND(addr + offset, rem_sz);
RTW_WARN("%s:%d, size(rem_sz)=%d cur_frag_rem=%d txreq->total_length = %d\n",
__func__, __LINE__, rem_sz, cur_frag_rem, txreq->total_len);
rem_sz = 0;
break;
} else {
PKT_LIST_APPEND(addr + offset, cur_frag_rem);
RTW_DBG("%s:%d, size=%d txreq->total_length = %d\n",
__func__, __LINE__, cur_frag_rem, txreq->total_len);
rem_sz -= cur_frag_rem;
}
offset = 0;
} else {
offset -= cur_frag_total;
}
}
*req_sz = rem_sz;
*req_offset = offset;
#undef PKT_LIST_APPEND
#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 4, 0))
#undef skb_frag_off
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0))
#undef skb_frag_page
#undef skb_frag_size
#endif
}
static int skb_total_frag_nr(struct sk_buff *head_skb)
{
struct sk_buff *skb;
int nr;
nr = 1 + skb_shinfo(head_skb)->nr_frags;
skb_walk_frags(head_skb, skb)
nr += 1 + skb_shinfo(skb)->nr_frags;
return nr;
}
static void fill_txreq_list_skb(_adapter *padapter,
struct rtw_xmit_req *txreq, struct rtw_pkt_buf_list **pkt_list,
struct sk_buff *head_skb, u32 req_sz, s32 offset)
{
struct sk_buff *skb;
if (skb_total_frag_nr(head_skb) > NUM_PKT_LIST_PER_TXREQ - 2) {
rtw_skb_linearize(head_skb);
RTW_WARN("skb total frag nr over %d\n", NUM_PKT_LIST_PER_TXREQ - 2);
}
_fill_txreq_list_skb(padapter, txreq, pkt_list, head_skb, &req_sz, &offset);
skb_walk_frags(head_skb, skb)
_fill_txreq_list_skb(padapter, txreq, pkt_list, skb, &req_sz, &offset);
if (req_sz != 0)
RTW_WARN("remain req_sz=%d should be zero\n", req_sz);
}
s32 rtw_core_replace_skb(struct sk_buff **pskb, u32 need_head, u32 need_tail)
{
struct sk_buff *newskb;
struct sk_buff *skb = *pskb;
newskb = rtw_skb_copy(skb);
if (newskb == NULL)
return FAIL;
rtw_skb_free(skb);
*pskb = newskb;
return SUCCESS;
}
#ifdef CONFIG_BR_EXT
s32 core_br_client_tx(_adapter *padapter, struct xmit_frame *pxframe, struct sk_buff **pskb)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
if (!adapter_use_wds(padapter) && check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE | WIFI_ADHOC_STATE) == _TRUE) {
void *br_port = NULL;
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
br_port = padapter->pnetdev->br_port;
#else
rcu_read_lock();
br_port = rcu_dereference(padapter->pnetdev->rx_handler_data);
rcu_read_unlock();
#endif
if (br_port) {
if (rtw_br_client_tx(padapter, pskb) == FAIL) {
core_tx_free_xmitframe(padapter, pxframe);
DBG_COUNTER(padapter->tx_logs.core_tx_err_brtx);
return FAIL;
}
}
}
return SUCCESS;
}
#endif
s32 core_tx_update_pkt(_adapter *padapter, struct xmit_frame *pxframe, struct sk_buff **pskb)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sk_buff *skb_orig = *pskb;
PHLTX_LOG;
//rtw_phl_tx todo, BR EXT
if (core_br_client_tx(padapter, pxframe, pskb) == FAIL)
return FAIL;
return SUCCESS;
}
s32 core_tx_update_xmitframe(_adapter *padapter,
struct xmit_frame *pxframe, struct sk_buff **pskb, struct sta_info *psta, u8 type)
{
pxframe->xftype = type;
pxframe->pkt = *pskb;
PHLTX_LOG;
#if 1
if (pxframe->xftype == RTW_TX_OS) {
if (update_attrib(padapter, *pskb, &pxframe->attrib) != _SUCCESS)
return FAIL;
}
#else
pxframe->pkt = *pskb;
if (update_xmitframe_from_hdr(padapter, pxframe) == FAIL)
return FAIL;
PHLTX_LOG;
if (update_xmitframe_qos(padapter, pxframe) == FAIL)
return FAIL;
PHLTX_LOG;
if (update_xmitframe_security(padapter, pxframe) == FAIL)
return FAIL;
PHLTX_LOG;
//if (update_xmitframe_hw(padapter, pxframe) == FAIL)
//return FAIL;
PHLTX_LOG;
if (pxframe->xftype == RTW_TX_OS) {
if (pxframe->attrib.bswenc
&& (skb_shared(*pskb) || skb_cloned(*pskb))
&& (rtw_core_replace_skb(pskb, RTW_MAX_WL_HEAD, RTW_MAX_WL_TAIL) == FAIL))
return FAIL;
}
#endif
PHLTX_LOG;
return SUCCESS;
}
void get_wl_frag_paras(_adapter *padapter, struct xmit_frame *pxframe,
u32 *frag_perfr, u32 *wl_frags)
{
u32 wl_head, wl_tail, payload_totalsz, payload_fragsz, wl_frag_num;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
wl_head = wl_tail = payload_totalsz = 0;
wl_head += pxframe->attrib.hdrlen;
wl_tail += RTW_SZ_FCS;
if (pxframe->attrib.encrypt) {
wl_head += pxframe->attrib.iv_len;
wl_tail += pxframe->attrib.icv_len;
}
payload_fragsz = pxmitpriv->frag_len - wl_head - wl_tail;
payload_totalsz = pxframe->attrib.pktlen;
if (pxframe->xftype == RTW_TX_OS)
payload_totalsz += RTW_SZ_LLC;
if (pxframe->attrib.encrypt == _TKIP_)
payload_totalsz += RTW_TKIP_MIC_LEN;
if (pxframe->attrib.amsdu)
wl_frag_num = 1;
else if (payload_fragsz < payload_totalsz)
wl_frag_num = RTW_DIV_ROUND_UP(payload_totalsz, payload_fragsz);
else
wl_frag_num = 1;
pxframe->attrib.frag_datalen = *frag_perfr = payload_fragsz;
pxframe->attrib.nr_frags = *wl_frags = wl_frag_num;
#ifdef CONFIG_CORE_TXSC
pxframe->attrib.frag_len_txsc = payload_fragsz - (payload_totalsz - pxframe->attrib.pktlen);
#endif
}
u8 fill_txreq_pkt_perfrag_txos(struct _ADAPTER *padapter,
struct xmit_frame *pxframe,
u32 frag_perfr, u32 wl_frags)
{
struct rtw_xmit_req *xf_txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
struct sk_buff *skb = pxframe->pkt;
u8 *txreq, *head, *tail, *list;
u32 head_sz, tail_sz, wlan_tail;
u32 payload_sz, payload_offset;
u8 idx;
u8 *wlhdr[RTW_MAX_FRAG_NUM] = {NULL};
u8 *wltail[RTW_MAX_FRAG_NUM] = {NULL};
/* TXREQ_QMGT */
struct xmit_txreq_buf *txreq_buf = NULL;
PHLTX_ENTER;
//printk("pxframe->attrib.pkt_hdrlen=%d pxframe->attrib.hdrlen=%d pxframe->attrib.iv_len=%d \n", pxframe->attrib.pkt_hdrlen, pxframe->attrib.hdrlen, pxframe->attrib.iv_len);
pxframe->txreq_cnt = wl_frags;
head_sz = pxframe->attrib.hdrlen + (pxframe->attrib.amsdu ? 0 : RTW_SZ_LLC);
tail_sz = 0;
if (pxframe->attrib.encrypt) {
head_sz += pxframe->attrib.iv_len;
if (pxframe->attrib.encrypt == _TKIP_)
tail_sz += RTW_TKIP_MIC_LEN;
if (pxframe->attrib.bswenc)
tail_sz += pxframe->attrib.icv_len;
}
PHLTX_LOG;
//get_txreq_resources(padapter, pxframe, &txreq, &list, &head, &tail);
/* TXREQ_QMGT */
txreq_buf = (struct xmit_txreq_buf *)get_txreq_buffer(padapter, &txreq, &list, &head, &tail);
if (txreq_buf == NULL) {
//do this in core_tx_init_xmitframe
//pxframe->phl_txreq = NULL;
//pxframe->ptxreq_buf = NULL;
//free in rtw_core_tx
//pxframe->pkt = NULL;//for not recycle in abort_core_tx
goto fail;
}
#ifdef USE_PREV_WLHDR_BUF /* CONFIG_CORE_TXSC */
txreq_buf->macid = 0xff;
txreq_buf->txsc_id = 0xff;
#endif
pxframe->ptxreq_buf = txreq_buf;
PHLTX_LOG;
#if 0
payload = skb->data+pxframe->attrib.pkt_hdrlen;
printk("num_txreq=%d, hw_head=%d, hw_tail=%d, list=0x%p\n",
num_txreq, hw_head, hw_tail, (void *)list);
printk("p:txreq=0x%p, head=0x%p, tail=0x%p, payload=0x%p\n",
(void *)txreq, (void *)head, (void *)tail, (void *)payload);
#endif
pxframe->phl_txreq = xf_txreq = (struct rtw_xmit_req *)txreq;
pkt_list = (struct rtw_pkt_buf_list *)list;
#ifdef CONFIG_CORE_TXSC
xf_txreq->shortcut_id = 0;
xf_txreq->treq_type = RTW_PHL_TREQ_TYPE_NORMAL;
#endif
PHLTX_LOG;
/* move to first payload position */
payload_offset = pxframe->attrib.pkt_hdrlen;
for (idx = 0; idx < wl_frags; idx++) {
/* for no memset */
xf_txreq->pkt_cnt = 0;
xf_txreq->total_len = 0;
xf_txreq->pkt_list = (u8 *)pkt_list;
/* fill head into txreq */
wlhdr[idx] = head;
pkt_list->vir_addr = head;
pkt_list->length = head_sz;
if (idx) {
/* deduct LLC size if not first fragment */
pkt_list->length -= RTW_SZ_LLC;
}
head += pkt_list->length;
xf_txreq->pkt_cnt++;
xf_txreq->total_len += pkt_list->length;
pkt_list++;
/* fill payload into txreq */
if (idx == (wl_frags - 1)) {
/* last payload size */
payload_sz = skb->len - payload_offset;
} else if (idx == 0) {
/* first payload size should deduct LLC size */
payload_sz = frag_perfr - RTW_SZ_LLC;
} else {
payload_sz = frag_perfr;
}
/* xf_txreq would be update and pkt_list++ inside */
fill_txreq_list_skb(padapter, xf_txreq, &pkt_list, skb,
payload_sz, payload_offset);
payload_offset += payload_sz;
/* fill tail(if alloc) into txreq */
if (tail_sz) {
wlan_tail = tail_sz;
if ((pxframe->attrib.encrypt == _TKIP_) && (idx != (wl_frags - 1))) {
/* deduct MIC size if not last fragment with TKIP */
wlan_tail -= RTW_TKIP_MIC_LEN;
}
if (wlan_tail) {
wltail[idx] = tail;
pkt_list->vir_addr = tail;
pkt_list->length = wlan_tail;
tail += pkt_list->length;
xf_txreq->pkt_cnt++;
xf_txreq->total_len += pkt_list->length;
pkt_list++;
}
}
if (xf_txreq->pkt_cnt > NUM_PKT_LIST_PER_TXREQ)
RTW_WARN("xf_txreq->pkt_cnt=%d > NUM_PKT_LIST_PER_TXREQ\n",
xf_txreq->pkt_cnt);
xf_txreq++;
}
_rtw_memcpy(pxframe->wlhdr, wlhdr, sizeof(wlhdr));
_rtw_memcpy(pxframe->wltail, wltail, sizeof(wltail));
PHLTX_EXIT;
return _SUCCESS;
fail:
return _FAIL;
}
/* TXREQ_QMGT, MGT_TXREQ_QMGT */
u8 fill_txreq_pkt_mgmt(_adapter *padapter, struct xmit_frame *pxframe)
{
struct rtw_xmit_req *xf_txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
//u8 *txreq, *head, *tail, *list, *mgmt = NULL;
PHLTX_ENTER;
if (!pxframe->phl_txreq)
goto fail;
xf_txreq = pxframe->phl_txreq;
pkt_list = (struct rtw_pkt_buf_list *)xf_txreq->pkt_list;
//get_txreq_resources(padapter, pxframe,
// (u8 **)&xf_txreq, (u8 **)&pkt_list, NULL, NULL);
//printk("p:txreq=0x%p, pkt_list=0x%p \n", (void *)xf_txreq, (void *)pkt_list);
//for no memset
xf_txreq->pkt_cnt = 0;
xf_txreq->total_len = 0;
#ifdef CONFIG_CORE_TXSC
xf_txreq->shortcut_id = 0;
#endif
pkt_list->vir_addr = pxframe->buf_addr;
pkt_list->length = pxframe->attrib.pktlen;
xf_txreq->pkt_cnt = 1;
//xf_txreq->pkt_list = (u8 *)pkt_list;
xf_txreq->treq_type = RTW_PHL_TREQ_TYPE_NORMAL;
pxframe->txreq_cnt = 1;
//pxframe->phl_txreq = xf_txreq;
xf_txreq->total_len = xf_txreq->total_len + pxframe->attrib.pktlen;
//RTW_INFO("%s,%d, xf_txreq->total_length = %d\n", __func__, __LINE__, xf_txreq->total_len);
#ifdef RTW_PHL_TEST_FPGA
{
struct rtw_ieee80211_hdr *p = (struct rtw_ieee80211_hdr *)pxframe->buf_addr;
test_seq++;
test_seq = test_seq%0xFFF;
SetSeqNum(p, test_seq);
}
#endif
exit:
return _SUCCESS;
fail:
return _FAIL;
}
static u8 merge_txreq_to_one_piece(struct _ADAPTER *a,
struct xmit_frame *xf)
{
struct rtw_xmit_req *txreq = NULL;
struct rtw_pkt_buf_list *pkt_list = NULL;
int i, j;
u32 total_sz;
u8 *buf, *ptr;
for (i = 0; i < xf->txreq_cnt; i++) {
txreq = &xf->phl_txreq[i];
total_sz = txreq->total_len;
buf = rtw_zmalloc(total_sz);
if (!buf)
return _FAIL;
xf->buf_need_free |= BIT(i);
ptr = buf;
for (j = 0; j < txreq->pkt_cnt; j++) {
pkt_list = &((struct rtw_pkt_buf_list *)txreq->pkt_list)[j];
_rtw_memcpy(ptr, pkt_list->vir_addr, pkt_list->length);
ptr += pkt_list->length;
}
txreq->pkt_cnt = 1;
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
pkt_list->vir_addr = buf;
pkt_list->length = total_sz;
}
return _SUCCESS;
}
#ifdef RTW_PHL_TEST_FPGA
#define F_TX_MACID (0)
#define F_TX_TID (1)
#define F_TX_TYPE RTW_PHL_PKT_TYPE_DATA
#define F_TX_RATE (0x8F) //HRATE_MCS15
#define F_TX_BW (1)
#define F_TX_DMACH (0)
#endif
static u8 get_security_cam_id(struct _ADAPTER *padapter, struct xmit_frame *pxframe, u8 keyid)
{
struct dvobj_priv *d;
void *phl;
u8 sec_cam_id = 0;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *sta;
sint bmcast = IS_MCAST(pxframe->attrib.ra);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
WLAN_BSSID_EX *pbss_network = (WLAN_BSSID_EX *)&pmlmepriv->cur_network.network;
if (bmcast == _TRUE) {
/* WEP: use unicast key type to match halmac rule (see: setkey_hdl) */
if (pxframe->attrib.encrypt == _WEP40_ || pxframe->attrib.encrypt == _WEP104_)
bmcast = _FALSE;
sta = rtw_get_stainfo(pstapriv, pbss_network->MacAddress);
} else {
sta = rtw_get_stainfo(pstapriv, pxframe->attrib.ra);
}
if (!sta) {
RTW_ERR("%s sta not found\n", __func__);
rtw_warn_on(1);
return sec_cam_id;
}
d = adapter_to_dvobj(padapter);
phl = GET_PHL_INFO(d);
if (keyid >= 4)
sec_cam_id = rtw_phl_get_sec_cam_idx(phl, sta->phl_sta, keyid,
RTW_SEC_KEY_BIP);
else
sec_cam_id = rtw_phl_get_sec_cam_idx(phl, sta->phl_sta, keyid,
bmcast ? RTW_SEC_KEY_MULTICAST : RTW_SEC_KEY_UNICAST);
return sec_cam_id;
}
/* Todo: HE rate mapping not ready */
static const enum rtw_data_rate mrate2phlrate_tbl[] = {
[MGN_1M] = RTW_DATA_RATE_CCK1,
[MGN_2M] = RTW_DATA_RATE_CCK2,
[MGN_5_5M] = RTW_DATA_RATE_CCK5_5,
[MGN_11M] = RTW_DATA_RATE_CCK11,
[MGN_6M] = RTW_DATA_RATE_OFDM6,
[MGN_9M] = RTW_DATA_RATE_OFDM9,
[MGN_12M] = RTW_DATA_RATE_OFDM12,
[MGN_18M] = RTW_DATA_RATE_OFDM18,
[MGN_24M] = RTW_DATA_RATE_OFDM24,
[MGN_36M] = RTW_DATA_RATE_OFDM36,
[MGN_48M] = RTW_DATA_RATE_OFDM48,
[MGN_54M] = RTW_DATA_RATE_OFDM54,
[MGN_MCS0] = RTW_DATA_RATE_MCS0,
[MGN_MCS1] = RTW_DATA_RATE_MCS1,
[MGN_MCS2] = RTW_DATA_RATE_MCS2,
[MGN_MCS3] = RTW_DATA_RATE_MCS3,
[MGN_MCS4] = RTW_DATA_RATE_MCS4,
[MGN_MCS5] = RTW_DATA_RATE_MCS5,
[MGN_MCS6] = RTW_DATA_RATE_MCS6,
[MGN_MCS7] = RTW_DATA_RATE_MCS7,
[MGN_MCS8] = RTW_DATA_RATE_MCS8,
[MGN_MCS9] = RTW_DATA_RATE_MCS9,
[MGN_MCS10] = RTW_DATA_RATE_MCS10,
[MGN_MCS11] = RTW_DATA_RATE_MCS11,
[MGN_MCS12] = RTW_DATA_RATE_MCS12,
[MGN_MCS13] = RTW_DATA_RATE_MCS13,
[MGN_MCS14] = RTW_DATA_RATE_MCS14,
[MGN_MCS15] = RTW_DATA_RATE_MCS15,
[MGN_MCS16] = RTW_DATA_RATE_MCS16,
[MGN_MCS17] = RTW_DATA_RATE_MCS17,
[MGN_MCS18] = RTW_DATA_RATE_MCS18,
[MGN_MCS19] = RTW_DATA_RATE_MCS19,
[MGN_MCS20] = RTW_DATA_RATE_MCS20,
[MGN_MCS21] = RTW_DATA_RATE_MCS21,
[MGN_MCS22] = RTW_DATA_RATE_MCS22,
[MGN_MCS23] = RTW_DATA_RATE_MCS23,
[MGN_MCS24] = RTW_DATA_RATE_MCS24,
[MGN_MCS25] = RTW_DATA_RATE_MCS25,
[MGN_MCS26] = RTW_DATA_RATE_MCS26,
[MGN_MCS27] = RTW_DATA_RATE_MCS27,
[MGN_MCS28] = RTW_DATA_RATE_MCS28,
[MGN_MCS29] = RTW_DATA_RATE_MCS29,
[MGN_MCS30] = RTW_DATA_RATE_MCS30,
[MGN_MCS31] = RTW_DATA_RATE_MCS31,
[MGN_VHT1SS_MCS0] = RTW_DATA_RATE_VHT_NSS1_MCS0,
[MGN_VHT1SS_MCS1] = RTW_DATA_RATE_VHT_NSS1_MCS1,
[MGN_VHT1SS_MCS2] = RTW_DATA_RATE_VHT_NSS1_MCS2,
[MGN_VHT1SS_MCS3] = RTW_DATA_RATE_VHT_NSS1_MCS3,
[MGN_VHT1SS_MCS4] = RTW_DATA_RATE_VHT_NSS1_MCS4,
[MGN_VHT1SS_MCS5] = RTW_DATA_RATE_VHT_NSS1_MCS5,
[MGN_VHT1SS_MCS6] = RTW_DATA_RATE_VHT_NSS1_MCS6,
[MGN_VHT1SS_MCS7] = RTW_DATA_RATE_VHT_NSS1_MCS7,
[MGN_VHT1SS_MCS8] = RTW_DATA_RATE_VHT_NSS1_MCS8,
[MGN_VHT1SS_MCS9] = RTW_DATA_RATE_VHT_NSS1_MCS9,
[MGN_VHT2SS_MCS0] = RTW_DATA_RATE_VHT_NSS2_MCS0,
[MGN_VHT2SS_MCS1] = RTW_DATA_RATE_VHT_NSS2_MCS1,
[MGN_VHT2SS_MCS2] = RTW_DATA_RATE_VHT_NSS2_MCS2,
[MGN_VHT2SS_MCS3] = RTW_DATA_RATE_VHT_NSS2_MCS3,
[MGN_VHT2SS_MCS4] = RTW_DATA_RATE_VHT_NSS2_MCS4,
[MGN_VHT2SS_MCS5] = RTW_DATA_RATE_VHT_NSS2_MCS5,
[MGN_VHT2SS_MCS6] = RTW_DATA_RATE_VHT_NSS2_MCS6,
[MGN_VHT2SS_MCS7] = RTW_DATA_RATE_VHT_NSS2_MCS7,
[MGN_VHT2SS_MCS8] = RTW_DATA_RATE_VHT_NSS2_MCS8,
[MGN_VHT2SS_MCS9] = RTW_DATA_RATE_VHT_NSS2_MCS9,
[MGN_VHT3SS_MCS0] = RTW_DATA_RATE_VHT_NSS3_MCS0,
[MGN_VHT3SS_MCS1] = RTW_DATA_RATE_VHT_NSS3_MCS1,
[MGN_VHT3SS_MCS2] = RTW_DATA_RATE_VHT_NSS3_MCS2,
[MGN_VHT3SS_MCS3] = RTW_DATA_RATE_VHT_NSS3_MCS3,
[MGN_VHT3SS_MCS4] = RTW_DATA_RATE_VHT_NSS3_MCS4,
[MGN_VHT3SS_MCS5] = RTW_DATA_RATE_VHT_NSS3_MCS5,
[MGN_VHT3SS_MCS6] = RTW_DATA_RATE_VHT_NSS3_MCS6,
[MGN_VHT3SS_MCS7] = RTW_DATA_RATE_VHT_NSS3_MCS7,
[MGN_VHT3SS_MCS8] = RTW_DATA_RATE_VHT_NSS3_MCS8,
[MGN_VHT3SS_MCS9] = RTW_DATA_RATE_VHT_NSS3_MCS9,
[MGN_VHT4SS_MCS0] = RTW_DATA_RATE_VHT_NSS4_MCS0,
[MGN_VHT4SS_MCS1] = RTW_DATA_RATE_VHT_NSS4_MCS1,
[MGN_VHT4SS_MCS2] = RTW_DATA_RATE_VHT_NSS4_MCS2,
[MGN_VHT4SS_MCS3] = RTW_DATA_RATE_VHT_NSS4_MCS3,
[MGN_VHT4SS_MCS4] = RTW_DATA_RATE_VHT_NSS4_MCS4,
[MGN_VHT4SS_MCS5] = RTW_DATA_RATE_VHT_NSS4_MCS5,
[MGN_VHT4SS_MCS6] = RTW_DATA_RATE_VHT_NSS4_MCS6,
[MGN_VHT4SS_MCS7] = RTW_DATA_RATE_VHT_NSS4_MCS7,
[MGN_VHT4SS_MCS8] = RTW_DATA_RATE_VHT_NSS4_MCS8,
[MGN_VHT4SS_MCS9] = RTW_DATA_RATE_VHT_NSS4_MCS9,
[MGN_HE1SS_MCS0] = RTW_DATA_RATE_HE_NSS1_MCS0,
[MGN_HE1SS_MCS1] = RTW_DATA_RATE_HE_NSS1_MCS1,
[MGN_HE1SS_MCS2] = RTW_DATA_RATE_HE_NSS1_MCS2,
[MGN_HE1SS_MCS3] = RTW_DATA_RATE_HE_NSS1_MCS3,
[MGN_HE1SS_MCS4] = RTW_DATA_RATE_HE_NSS1_MCS4,
[MGN_HE1SS_MCS5] = RTW_DATA_RATE_HE_NSS1_MCS5,
[MGN_HE1SS_MCS6] = RTW_DATA_RATE_HE_NSS1_MCS6,
[MGN_HE1SS_MCS7] = RTW_DATA_RATE_HE_NSS1_MCS7,
[MGN_HE1SS_MCS8] = RTW_DATA_RATE_HE_NSS1_MCS8,
[MGN_HE1SS_MCS9] = RTW_DATA_RATE_HE_NSS1_MCS9,
[MGN_HE1SS_MCS10] = RTW_DATA_RATE_HE_NSS1_MCS10,
[MGN_HE1SS_MCS11] = RTW_DATA_RATE_HE_NSS1_MCS11,
[MGN_HE2SS_MCS0] = RTW_DATA_RATE_HE_NSS2_MCS0,
[MGN_HE2SS_MCS1] = RTW_DATA_RATE_HE_NSS2_MCS1,
[MGN_HE2SS_MCS2] = RTW_DATA_RATE_HE_NSS2_MCS2,
[MGN_HE2SS_MCS3] = RTW_DATA_RATE_HE_NSS2_MCS3,
[MGN_HE2SS_MCS4] = RTW_DATA_RATE_HE_NSS2_MCS4,
[MGN_HE2SS_MCS5] = RTW_DATA_RATE_HE_NSS2_MCS5,
[MGN_HE2SS_MCS6] = RTW_DATA_RATE_HE_NSS2_MCS6,
[MGN_HE2SS_MCS7] = RTW_DATA_RATE_HE_NSS2_MCS7,
[MGN_HE2SS_MCS8] = RTW_DATA_RATE_HE_NSS2_MCS8,
[MGN_HE2SS_MCS9] = RTW_DATA_RATE_HE_NSS2_MCS9,
[MGN_HE2SS_MCS10] = RTW_DATA_RATE_HE_NSS2_MCS10,
[MGN_HE2SS_MCS11] = RTW_DATA_RATE_HE_NSS2_MCS11,
[MGN_HE3SS_MCS0] = RTW_DATA_RATE_HE_NSS3_MCS0,
[MGN_HE3SS_MCS1] = RTW_DATA_RATE_HE_NSS3_MCS1,
[MGN_HE3SS_MCS2] = RTW_DATA_RATE_HE_NSS3_MCS2,
[MGN_HE3SS_MCS3] = RTW_DATA_RATE_HE_NSS3_MCS3,
[MGN_HE3SS_MCS4] = RTW_DATA_RATE_HE_NSS3_MCS4,
[MGN_HE3SS_MCS5] = RTW_DATA_RATE_HE_NSS3_MCS5,
[MGN_HE3SS_MCS6] = RTW_DATA_RATE_HE_NSS3_MCS6,
[MGN_HE3SS_MCS7] = RTW_DATA_RATE_HE_NSS3_MCS7,
[MGN_HE3SS_MCS8] = RTW_DATA_RATE_HE_NSS3_MCS8,
[MGN_HE3SS_MCS9] = RTW_DATA_RATE_HE_NSS3_MCS9,
[MGN_HE3SS_MCS10] = RTW_DATA_RATE_HE_NSS3_MCS10,
[MGN_HE3SS_MCS11] = RTW_DATA_RATE_HE_NSS3_MCS11,
[MGN_HE4SS_MCS0] = RTW_DATA_RATE_HE_NSS4_MCS0,
[MGN_HE4SS_MCS1] = RTW_DATA_RATE_HE_NSS4_MCS1,
[MGN_HE4SS_MCS2] = RTW_DATA_RATE_HE_NSS4_MCS2,
[MGN_HE4SS_MCS3] = RTW_DATA_RATE_HE_NSS4_MCS3,
[MGN_HE4SS_MCS4] = RTW_DATA_RATE_HE_NSS4_MCS4,
[MGN_HE4SS_MCS5] = RTW_DATA_RATE_HE_NSS4_MCS5,
[MGN_HE4SS_MCS6] = RTW_DATA_RATE_HE_NSS4_MCS6,
[MGN_HE4SS_MCS7] = RTW_DATA_RATE_HE_NSS4_MCS7,
[MGN_HE4SS_MCS8] = RTW_DATA_RATE_HE_NSS4_MCS8,
[MGN_HE4SS_MCS9] = RTW_DATA_RATE_HE_NSS4_MCS9,
[MGN_HE4SS_MCS10] = RTW_DATA_RATE_HE_NSS4_MCS10,
[MGN_HE4SS_MCS11] = RTW_DATA_RATE_HE_NSS4_MCS11,
};
/*
* _rate_mrate2phl() - convert data rate from mrate to PHL(MAC)
* @sta: struct sta_info *
* @mrate: date rate of mrate type, enum MGN_RATE
*
* Convert data rate from MGN_RATE definition to PHL's definition.
*
* Return PHL's data rate definition "enum rtw_data_rate".
* 0x0~0xB: CCK 1M ~ OFDM 54M
* 0x80~0x9F: HT MCS0~MCS31
* 0x100~0x109: VHT 1SS MCS0~MCS9
* 0x110~0x119: VHT 2SS MCS0~MCS9
* 0x120~0x129: VHT 3SS MCS0~MCS9
* 0x130~0x139: VHT 4SS MCS0~MCS9
* 0x180~0x18B: HE 1SS MCS0~MCS11
* 0x190~0x19B: HE 2SS MCS0~MCS11
* 0x1A0~0x1AB: HE 3SS MCS0~MCS11
* 0x1B0~0x1BB: HE 4SS MCS0~MCS11
*/
static enum rtw_data_rate _rate_mrate2phl(enum MGN_RATE mrate)
{
enum rtw_data_rate phl = RTW_DATA_RATE_CCK1;
if (mrate < ARRAY_SIZE(mrate2phlrate_tbl))
phl = mrate2phlrate_tbl[mrate];
if ((mrate != MGN_1M) && (phl == RTW_DATA_RATE_CCK1))
RTW_WARN("%s: Invalid rate 0x%x\n", __func__, mrate);
return phl;
}
/*
* _rate_drv2phl() - convert data rate from drive to PHL(MAC)
* @sta: struct sta_info *
* @rate: date rate of driver
* 0x0~0xB: CCK 1M ~ OFDM 54M
* >0xB: HT/VHT/HE use the same bits field to represent each
* data rate, so these bits's real definition depended on
* sta's wireless mode.
*
* Convert driver's data rate definition to PHL's definition.
*
* Return PHL's data rate definition "enum rtw_data_rate".
*/
static enum rtw_data_rate _rate_drv2phl(struct sta_info *sta, u8 rate)
{
enum rtw_data_rate phl = RTW_DATA_RATE_CCK1;
u8 ht_support = 0, vht_support = 0, he_support = 0;
if (rate < 12) {
/* B/G mode, CCK/OFDM rate */
return (enum rtw_data_rate)rate;
}
#ifdef CONFIG_80211N_HT
if (sta->htpriv.ht_option == _TRUE)
ht_support = 1;
#ifdef CONFIG_80211AC_VHT
if (sta->vhtpriv.vht_option == _TRUE)
vht_support = 1;
#ifdef CONFIG_80211AX_HE
if (sta->hepriv.he_option == _TRUE)
he_support = 1;
#endif /* CONFIG_80211AX_HE */
#endif /* CONFIG_80211AC_VHT */
#endif /* CONFIG_80211N_HT */
rate -= 12;
if (he_support) {
if (rate < 12)
phl = RTW_DATA_RATE_HE_NSS1_MCS0 + rate;
else if (rate < 24)
phl = RTW_DATA_RATE_HE_NSS2_MCS0 + (rate - 12);
else if (rate < 36)
phl = RTW_DATA_RATE_HE_NSS3_MCS0 + (rate - 24);
else
phl = RTW_DATA_RATE_HE_NSS4_MCS0 + (rate - 36);
} else if (vht_support) {
if (rate < 10)
phl = RTW_DATA_RATE_VHT_NSS1_MCS0 + rate;
else if (rate < 20)
phl = RTW_DATA_RATE_VHT_NSS2_MCS0 + (rate - 10);
else if (rate < 30)
phl = RTW_DATA_RATE_VHT_NSS3_MCS0 + (rate - 20);
else
phl = RTW_DATA_RATE_VHT_NSS4_MCS0 + (rate - 30);
} else if (ht_support) {
phl = RTW_DATA_RATE_MCS0 + rate;
}
return phl;
}
void fill_txreq_mdata(_adapter *padapter, struct xmit_frame *pxframe)
{
struct rtw_xmit_req *txreq = pxframe->phl_txreq;
struct sta_info *psta = pxframe->attrib.psta;
struct rtw_phl_stainfo_t *phl_sta = NULL;
struct rtw_t_meta_data *mdata = &(txreq->mdata);
#ifdef BMC_ON_HIQ
struct sta_priv *pstapriv = &padapter->stapriv;
#endif
u32 idx = 0;
u8 htc_option = _FALSE;
#ifdef CONFIG_XMIT_ACK
struct xmit_priv *pxmitpriv = &(GET_PRIMARY_ADAPTER(padapter))->xmitpriv;
#endif
PHLTX_LOG;
if (pxframe->attrib.order)
htc_option = _TRUE;
/* packet identify */
if (pxframe->xftype == RTW_TX_DRV_MGMT)
mdata->type = RTW_PHL_PKT_TYPE_MGNT;
else
mdata->type = RTW_PHL_PKT_TYPE_DATA;
mdata->macid = pxframe->attrib.mac_id;
/* enable wd info by default */
mdata->wdinfo_en = 1;
/* packet content */
mdata->hdr_len = pxframe->attrib.hdrlen;
mdata->hw_seq_mode = 0;
mdata->sw_seq = pxframe->attrib.seqnum;
mdata->hw_sec_iv = 0;
mdata->nav_use_hdr = 0;
/* packet security */
if (pxframe->attrib.encrypt == _NO_PRIVACY_ || pxframe->attrib.bswenc == _TRUE) {
mdata->sec_hw_enc = _FALSE;
mdata->sec_type = RTW_ENC_NONE;
} else {
mdata->sec_hw_enc = _TRUE;
mdata->sec_type = rtw_sec_algo_drv2phl(pxframe->attrib.encrypt);
mdata->sec_cam_idx = get_security_cam_id(padapter, pxframe, pxframe->attrib.key_idx);
}
/* Currently dump secrity settings for dbg */
RTW_DBG("sec_type= %d sec_hw_enc= %d sec_cam_idx= %d \n",
mdata->sec_type, mdata->sec_hw_enc, mdata->sec_cam_idx);
/* packet capability */
if (pxframe->attrib.ampdu_en == _TRUE) {
mdata->ampdu_en = 1;
mdata->bk = 0;
mdata->ampdu_density = pxframe->attrib.ampdu_spacing;
mdata->max_agg_num = 0x3F; /* temporally fix to 64 */
} else {
mdata->ampdu_en = 0;
mdata->bk = 1;
}
mdata->dis_data_rate_fb = 0;
mdata->dis_rts_rate_fb = 0;
mdata->data_tx_cnt_lmt_en = 0;
mdata->data_tx_cnt_lmt = 0;
/* Set DATA_RTY_LOWEST_RATE: 2.4G to CCK1M & 5G to OFDM6M */
if (rtw_get_oper_band(padapter) == BAND_ON_24G)
mdata->data_rty_lowest_rate = RTW_DATA_RATE_CCK1;
else if (rtw_get_oper_band(padapter) == BAND_ON_5G)
mdata->data_rty_lowest_rate = RTW_DATA_RATE_OFDM6;
else
RTW_WARN("%s: mdata->data_rty_lowest_rate is not set.\n", __func__);
mdata->life_time_sel = 0;
mdata->rts_en = pxframe->attrib.rtsen;
mdata->cts2self = pxframe->attrib.cts2self;
mdata->hw_rts_en = pxframe->attrib.hw_rts_en;
mdata->rts_cca_mode = 0;
mdata->f_bw = pxframe->attrib.bwmode;
/* Todo: GI and LTF not ready for HE */
mdata->f_gi_ltf = pxframe->attrib.sgi;
mdata->mc = IS_MCAST(pxframe->attrib.ra) ? 1 : 0;
mdata->bc = MacAddr_isBcst(pxframe->attrib.ra) ? 1 : 0;
#ifdef CONFIG_80211AX_HE
if (psta && htc_option)
mdata->a_ctrl_bsr = 1;
#endif
mdata->raw = 0;
#ifdef BMC_ON_HIQ
if ((pxframe->xftype != RTW_TX_DRV_MGMT)
&& (mdata->mc || mdata->bc)
&& (rtw_tim_map_anyone_be_set(padapter, pstapriv->sta_dz_bitmap))) {
mdata->tid = RTW_PHL_RING_CAT_HIQ; /* HIQ */
mdata->mbssid = 0; /* ToDo: Consider MBSSID */
mdata->hal_port = padapter->phl_role->hw_port;
} else
#endif
{
mdata->tid = pxframe->attrib.priority;
}
#ifdef CONFIG_CORE_TXSC
mdata->ampdu_density = 0;
mdata->userate_sel = 0;
#endif
if (pxframe->xftype == RTW_TX_DRV_MGMT) {
mdata->userate_sel = 1;
mdata->f_rate = _rate_mrate2phl(pxframe->attrib.rate);
} else {
/* low rate for EAPOL/ARP/DHCP */
if ((pxframe->attrib.ether_type == 0x888e) ||
(pxframe->attrib.ether_type == 0x0806) ||
(pxframe->attrib.dhcp_pkt == 1)) {
mdata->userate_sel = 1;
if (IS_CCK_RATE(padapter->mlmeextpriv.tx_rate))
mdata->f_rate = RTW_DATA_RATE_CCK1;
else
mdata->f_rate = RTW_DATA_RATE_OFDM6;
} else {
/* fix rate for non specail packet */
if (padapter->fix_rate != NO_FIX_RATE) {
mdata->userate_sel = 1;
mdata->f_rate = GET_FIX_RATE(padapter->fix_rate);
mdata->f_gi_ltf = GET_FIX_RATE_SGI(padapter->fix_rate);
if (!padapter->data_fb)
mdata->dis_data_rate_fb = 1;
} else {
mdata->userate_sel = 0;
}
if (padapter->fix_bw != NO_FIX_BW)
mdata->f_bw = padapter->fix_bw;
}
}
mdata->f_er = 0;
mdata->f_dcm = 0;
mdata->f_stbc = pxframe->attrib.stbc;
mdata->f_ldpc = pxframe->attrib.ldpc;
mdata->band = 0;
mdata->dma_ch = 0;
mdata->spe_rpt = 0;
mdata->sw_define = 0;
#ifdef CONFIG_XMIT_ACK
if (pxframe->ack_report) {
mdata->spe_rpt = 1;
mdata->sw_define = pxmitpriv->seq_no;
#ifdef RTW_WKARD_CCX_RPT_LIMIT_CTRL
mdata->data_tx_cnt_lmt_en = 1;
mdata->data_tx_cnt_lmt = 8;
#endif
}
#endif
#ifdef CONFIG_CORE_TXSC
mdata->pktlen = txreq->total_len;
#endif
#ifdef RTW_PHL_TEST_FPGA
mdata->type = F_TX_TYPE;
mdata->macid = F_TX_MACID;
mdata->tid = F_TX_TID;
mdata->dma_ch = F_TX_DMACH;
//mdata->band = cap->band;
mdata->f_rate = F_TX_RATE;
mdata->f_bw = F_TX_BW;
mdata->f_gi_ltf = 0;
mdata->f_stbc = 0;
mdata->f_ldpc = 0;
mdata->userate_sel = 1;
mdata->dis_data_rate_fb = 1;
mdata->dis_rts_rate_fb = 1;
#endif
#ifdef RTW_PHL_DBG_CMD
if (pxframe->xftype != RTW_TX_DRV_MGMT) {
if (padapter->txForce_enable) {
if (padapter->txForce_rate != INV_TXFORCE_VAL)
mdata->f_rate = padapter->txForce_rate;
if (padapter->txForce_agg != INV_TXFORCE_VAL)
mdata->ampdu_en = padapter->txForce_agg;
if (padapter->txForce_aggnum != INV_TXFORCE_VAL)
mdata->max_agg_num = padapter->txForce_aggnum;
if (padapter->txForce_gi != INV_TXFORCE_VAL)
mdata->f_gi_ltf = padapter->txForce_gi;
}
}
#endif
#ifdef CONFIG_CORE_TXSC
_print_txreq_mdata(mdata, __func__);
#endif
if (pxframe->txreq_cnt > 1) {
struct rtw_t_meta_data *mdata_tmp;
txreq++;
for (idx = 1; idx < pxframe->txreq_cnt; idx++) {
#ifdef CONFIG_CORE_TXSC
mdata->pktlen = txreq->total_len;
#endif
mdata_tmp = &(txreq->mdata);
memcpy(mdata_tmp, mdata, sizeof(struct rtw_t_meta_data));
txreq++;
}
}
}
void fill_txreq_others(_adapter *padapter, struct xmit_frame *pxframe)
{
struct rtw_xmit_req *txreq = pxframe->phl_txreq;
u32 idx = 0;
PHLTX_ENTER;
for (idx = 0; idx < pxframe->txreq_cnt; idx++) {
txreq->os_priv = pxframe;
txreq++;
}
}
u8 core_wlan_fill_txreq_pre(_adapter *padapter, struct xmit_frame *pxframe)
{
u32 frag_perfr, wl_frags = 0;
if (pxframe->xftype == RTW_TX_OS) {
get_wl_frag_paras(padapter, pxframe, &frag_perfr, &wl_frags);
if (fill_txreq_pkt_perfrag_txos(padapter, pxframe, frag_perfr, wl_frags) == _FAIL)
return _FAIL;
} else if (pxframe->xftype == RTW_TX_DRV_MGMT) {
if (fill_txreq_pkt_mgmt(padapter, pxframe) == _FAIL)
return _FAIL;
}
return _SUCCESS;
}
void core_wlan_fill_txreq_post(_adapter *padapter, struct xmit_frame *pxframe)
{
fill_txreq_mdata(padapter, pxframe);
fill_txreq_others(padapter, pxframe);
#ifdef CONFIG_PCI_HCI
/*must be called after all pkt contents modified (cache sync)*/
fill_txreq_phyaddr(padapter, pxframe);
#endif
}
void core_wlan_fill_head(_adapter *padapter, struct xmit_frame *pxframe)
{
u32 idx = 0;
if (pxframe->xftype == RTW_TX_OS) {
for (idx = 0; idx < pxframe->attrib.nr_frags; idx++) {
u8 *pwlanhdr = pxframe->wlhdr[idx];
if (!pwlanhdr) {
PHLTX_ERR;
continue;
}
rtw_make_wlanhdr(padapter, pwlanhdr, &pxframe->attrib); //rtw_core_make_wlanhdr(padapter, pwlanhdr, pxframe);
if (idx == (pxframe->attrib.nr_frags - 1))
ClearMFrag(pwlanhdr);
else
SetMFrag(pwlanhdr);
if (pxframe->attrib.iv_len) {
update_attrib_sec_iv_info(padapter, &pxframe->attrib);
_rtw_memcpy((pwlanhdr+pxframe->attrib.hdrlen), pxframe->attrib.iv, pxframe->attrib.iv_len);
}
if (idx == 0 && !pxframe->attrib.amsdu) {
/* Add LLC/SNAP to first fragment */
rtw_put_snap(pwlanhdr+pxframe->attrib.hdrlen+pxframe->attrib.iv_len,
pxframe->attrib.ether_type);
}
#ifdef RTW_PHL_TEST_FPGA
{
struct rtw_ieee80211_hdr *p = (struct rtw_ieee80211_hdr *)pwlanhdr;
unsigned short *fctrl;
unsigned int pktlen = 0;
u16 *qc;
test_seq++;
test_seq = test_seq%0xFFF;
SetSeqNum(p, test_seq);
}
#endif
}
}
}
void core_wlan_fill_tail(_adapter *padapter, struct xmit_frame *pxframe)
{
;
}
u8 core_wlan_fill_tkip_mic(_adapter *padapter, struct xmit_frame *pxframe)
{
u8 *llc = NULL;
u8 *payload = NULL;
u8 mic[8] = {0x0};
struct mic_data micdata;
struct pkt_attrib *pattrib = &pxframe->attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
s8 bmcst = IS_MCAST(pattrib->ra);
u8 priority[4] = {0x0};
int i = 0;
struct rtw_xmit_req *xf_txreq = pxframe->phl_txreq;
struct rtw_pkt_buf_list *pkt_list = NULL;
if (pattrib->encrypt == _TKIP_) {
u8 null_key[16] = {0x0};
/* set TKIP MIC key */
if (bmcst) {
if (_rtw_memcmp(
psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey,
null_key, 16) == _TRUE)
return _FAIL;
rtw_secmicsetkey(&micdata,
psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
} else {
if (_rtw_memcmp(
&pattrib->dot11tkiptxmickey.skey[0],
null_key, 16) == _TRUE)
return _FAIL;
rtw_secmicsetkey(&micdata, &pattrib->dot11tkiptxmickey.skey[0]);
}
/* set DA, SA */
rtw_secmicappend(&micdata, &pattrib->dst[0], 6);
rtw_secmicappend(&micdata, &pattrib->src[0], 6);
if (pattrib->qos_en)
priority[0] = pattrib->priority;
/* set priority */
rtw_secmicappend(&micdata, &priority[0], 4);
/* set LLC; TBD: should check if LLC is existed or not */
llc = pxframe->wlhdr[0] + pxframe->attrib.hdrlen + pxframe->attrib.iv_len;
rtw_secmicappend(&micdata, llc, SNAP_SIZE + sizeof(u16));
/* set MSDU payload */
pkt_list = (struct rtw_pkt_buf_list *) xf_txreq->pkt_list;
/*ignore hdr move to payload*/
pkt_list ++;
/*for loop ignore tail*/
for (i = 1; i < xf_txreq->pkt_cnt - 1; i++) {
rtw_secmicappend(&micdata, pkt_list->vir_addr, pkt_list->length);
pkt_list ++;
}
/* calculate MIC */
rtw_secgetmic(&micdata, &mic[0]);
/* append MIC to the last tail */
_rtw_memcpy(pxframe->wltail[pxframe->attrib.nr_frags-1], &(mic[0]), 8);
}
return _SUCCESS;
}
static void core_wlan_sw_encrypt(_adapter *padapter, struct xmit_frame *pxframe)
{
struct pkt_attrib *attrib;
u8 res;
attrib = &pxframe->attrib;
if (!attrib->encrypt)
return;
if (!attrib->bswenc)
return;
/* convert txreq to one piece */
res = merge_txreq_to_one_piece(padapter, pxframe);
if (res != _SUCCESS) {
RTW_ERR("%s: fail alloc buffer for sw enc!\n", __func__);
return;
}
xmitframe_swencrypt(padapter, pxframe);
}
#ifdef CONFIG_TX_AMSDU_SW_MODE
static bool core_tx_amsdu_timeout(_adapter *padapter, struct pkt_attrib *pattrib)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u8 amsdu_timeout;
amsdu_timeout = rtw_amsdu_get_timer_status(padapter, pattrib->priority);
if (amsdu_timeout == RTW_AMSDU_TIMER_UNSET) {
rtw_amsdu_set_timer_status(padapter,
pattrib->priority, RTW_AMSDU_TIMER_SETTING);
rtw_amsdu_set_timer(padapter, pattrib->priority);
pxmitpriv->amsdu_debug_set_timer++;
return false;
} else if (amsdu_timeout == RTW_AMSDU_TIMER_SETTING) {
return false;
} else if (amsdu_timeout == RTW_AMSDU_TIMER_TIMEOUT) {
rtw_amsdu_set_timer_status(padapter,
pattrib->priority, RTW_AMSDU_TIMER_UNSET);
pxmitpriv->amsdu_debug_timeout++;
return true;
}
return false;
}
/* 'pxframes[]' is array to store xframe to do AMSDU whose size is 'max_xf_nr',
* and return value is real used size. If return size is 1, then set 'amsdu' to
* decide normal frame or AMSDU one.
*/
static int core_tx_amsdu_dequeue(_adapter *padapter, struct xmit_frame *pxframes[],
int max_xf_nr, bool *amsdu)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
struct xmit_frame *pxframe;
int tx_amsdu = rtw_min(padapter->tx_amsdu, max_xf_nr);
int tx_amsdu_rate = padapter->tx_amsdu_rate;
int current_tx_rate = dvobj->traffic_stat.cur_tx_tp;
int num_frame;
int nr_xf;
if (tx_amsdu == 0)
goto dequeue_normal_pkt;
if (!MLME_IS_STA(padapter))
goto dequeue_normal_pkt;
if (tx_amsdu >= 2 && tx_amsdu_rate && current_tx_rate < tx_amsdu_rate)
goto dequeue_normal_pkt;
/*No amsdu when wifi_spec on*/
if (pregpriv->wifi_spec == 1)
goto dequeue_normal_pkt;
pxframe = rtw_get_xframe(pxmitpriv, &num_frame);
if (num_frame == 0 || !pxframe)
return 0;
if (num_frame < tx_amsdu) { /* Not enough MSDU for specific A-MSDU */
if (!core_tx_amsdu_timeout(padapter, &pxframe->attrib))
return 0; /* Not timeout yet */
}
for (nr_xf = 0; nr_xf < tx_amsdu; nr_xf++) {
pxframe = rtw_get_xframe(pxmitpriv, &num_frame);
if (num_frame == 0 || !pxframe)
break;
if (!check_amsdu(pxframe))
break;
/* TODO: check if size is over peer's capability */
pxframe = rtw_dequeue_xframe(pxmitpriv, pxmitpriv->hwxmits,
pxmitpriv->hwxmit_entry);
pxframes[nr_xf] = pxframe;
}
if (nr_xf == 0) {
if (num_frame > 0)
goto dequeue_normal_pkt;
RTW_WARN("%s: nr_xf=0, num_frame=%d\n", __func__, num_frame);
return 0;
}
if (nr_xf < AMSDU_DEBUG_MAX_COUNT)
pxmitpriv->amsdu_debug_coalesce[nr_xf-1]++;
else
pxmitpriv->amsdu_debug_coalesce[AMSDU_DEBUG_MAX_COUNT-1]++;
*amsdu = (nr_xf == 1 && tx_amsdu >= 2) ? false : true;
return nr_xf;
dequeue_normal_pkt:
pxframe = rtw_dequeue_xframe(pxmitpriv, pxmitpriv->hwxmits,
pxmitpriv->hwxmit_entry);
if (!pxframe)
return 0;
pxframes[0] = pxframe;
*amsdu = false;
return 1;
}
static bool core_tx_amsdu_dump(_adapter *padapter, struct xmit_frame *pxframes[],
int xf_nr, bool amsdu)
{
struct xmit_frame *head_xframe;
struct pkt_attrib *head_attrib;
u32 pktlen;
/* prepare head xmitframe */
head_xframe = pxframes[0];
head_attrib = &head_xframe->attrib;
if (xf_nr == 1 && !amsdu)
goto dump_pkt;
rtw_coalesce_tx_amsdu(padapter, pxframes, xf_nr, amsdu, &pktlen);
/* update proper attribute */
head_attrib->amsdu = 1;
head_attrib->pkt_hdrlen = 0;
head_attrib->pktlen = pktlen;
dump_pkt:
if (core_tx_prepare_phl(padapter, head_xframe) == FAIL)
goto abort_core_tx;
if (core_tx_call_phl(padapter, head_xframe, NULL) == FAIL)
goto abort_core_tx;
return true;
abort_core_tx:
core_tx_free_xmitframe(padapter, head_xframe);
return true;
}
void core_tx_amsdu_tasklet(_adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pxframes[5];
int xf_nr;
bool amsdu;
pxmitpriv->amsdu_debug_tasklet++;
while (1) {
xf_nr = core_tx_amsdu_dequeue(padapter, pxframes, ARRAY_SIZE(pxframes),
&amsdu);
if (xf_nr == 0)
break;
pxmitpriv->amsdu_debug_dequeue++;
core_tx_amsdu_dump(padapter, pxframes, xf_nr, amsdu);
}
}
static s32 core_tx_amsdu_enqueue(_adapter *padapter, struct xmit_frame *pxframe)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct pkt_attrib *pattrib = &pxframe->attrib;
int tx_amsdu = padapter->tx_amsdu;
u8 amsdu_timeout;
s32 res;
if (MLME_IS_STA(padapter) && check_amsdu_tx_support(padapter)) {
if (IS_AMSDU_AMPDU_VALID(pattrib))
goto enqueue;
}
return FAIL;
enqueue:
_rtw_spinlock_bh(&pxmitpriv->lock);
res = rtw_xmitframe_enqueue(padapter, pxframe);
if (res == _FAIL) {
_rtw_spinunlock_bh(&pxmitpriv->lock);
return FAIL;
}
pxmitpriv->amsdu_debug_enqueue++;
if (tx_amsdu >= 2) {
amsdu_timeout = rtw_amsdu_get_timer_status(padapter, pattrib->priority);
if (amsdu_timeout == RTW_AMSDU_TIMER_SETTING) {
rtw_amsdu_cancel_timer(padapter, pattrib->priority);
rtw_amsdu_set_timer_status(padapter, pattrib->priority,
RTW_AMSDU_TIMER_UNSET);
}
}
_rtw_spinunlock_bh(&pxmitpriv->lock);
rtw_tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
return _TRUE;
}
#endif /* CONFIG_TX_AMSDU_SW_MODE */
s32 core_tx_prepare_phl(_adapter *padapter, struct xmit_frame *pxframe)
{
if (core_wlan_fill_txreq_pre(padapter, pxframe) == _FAIL)
return FAIL;
if (pxframe->xftype == RTW_TX_OS) {
core_wlan_fill_head(padapter, pxframe);
if (core_wlan_fill_tkip_mic(padapter, pxframe) == _FAIL) {
RTW_ERR("core_wlan_fill_tkip_mic FAIL\n");
return FAIL;
}
}
core_wlan_fill_tail(padapter, pxframe);
core_wlan_sw_encrypt(padapter, pxframe);
core_wlan_fill_txreq_post(padapter, pxframe);
return SUCCESS;
}
s32 core_tx_call_phl(_adapter *padapter, struct xmit_frame *pxframe, void *txsc_pkt)
{
struct rtw_xmit_req *txreq = NULL;
void *phl = padapter->dvobj->phl;
u32 idx = 0;
u8 txreq_cnt = 0;
#ifdef CONFIG_CORE_TXSC
struct rtw_xmit_req *ptxsc_txreq = NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
#endif
#ifdef CONFIG_CORE_TXSC
struct txsc_pkt_entry *ptxsc_pkt = (struct txsc_pkt_entry *)txsc_pkt;
if (ptxsc_pkt)
ptxsc_txreq = ptxsc_pkt->ptxreq;
txreq = pxframe ? pxframe->phl_txreq : ptxsc_txreq;
txreq_cnt = pxframe ? pxframe->txreq_cnt : 1;
#else
txreq = pxframe->phl_txreq;
txreq_cnt = pxframe->txreq_cnt;
#endif
for (idx = 0; idx < txreq_cnt; idx++) {
#ifdef RTW_PHL_TEST_FPGA
core_add_record(padapter, REC_TX_PHL, txreq);
#endif
if (rtw_phl_add_tx_req(phl, txreq) != RTW_PHL_STATUS_SUCCESS)
return FAIL;
rtw_phl_tx_req_notify(phl);
txreq++;
}
/* should count tx status after add tx req is success */
#ifdef CONFIG_CORE_TXSC
if (ptxsc_txreq != NULL)
rtw_count_tx_stats_tx_req(padapter, ptxsc_txreq, ptxsc_pkt->psta);
else
#endif
rtw_count_tx_stats(padapter, pxframe, pxframe->attrib.pktlen);
return SUCCESS;
}
s32 core_tx_per_packet(_adapter *padapter, struct xmit_frame *pxframe,
struct sk_buff **pskb, struct sta_info *psta)
{
#if defined(CONFIG_AP_MODE) || defined(CONFIG_CORE_TXSC)
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
#endif
if (core_tx_update_xmitframe(padapter, pxframe, pskb, psta, RTW_TX_OS) == FAIL)
goto abort_tx_per_packet;
#ifdef CONFIG_80211N_HT
if ((pxframe->attrib.ether_type != 0x0806)
&& (pxframe->attrib.ether_type != 0x888e)
&& (pxframe->attrib.dhcp_pkt != 1))
rtw_issue_addbareq_cmd(padapter, pxframe, _TRUE);
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_TX_AMSDU_SW_MODE
if (core_tx_amsdu_enqueue(padapter, pxframe) == _TRUE)
return SUCCESS; /* queued to do AMSDU */
#endif
if (core_tx_prepare_phl(padapter, pxframe) == FAIL)
goto abort_tx_per_packet;
#ifdef CONFIG_AP_MODE
_rtw_spinlock_bh(&pxmitpriv->lock);
if (xmitframe_enqueue_for_sleeping_sta(padapter, pxframe) == _TRUE) {
_rtw_spinunlock_bh(&pxmitpriv->lock);
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue);
return SUCCESS;
}
_rtw_spinunlock_bh(&pxmitpriv->lock);
#endif
#if !defined(CONFIG_CORE_TXSC) || defined(CONFIG_RTW_DATA_BMC_TO_UC)
if (core_tx_call_phl(padapter, pxframe, NULL) == SUCCESS)
#endif
return SUCCESS;
abort_tx_per_packet:
if (pxframe == NULL) {
rtw_os_pkt_complete(padapter, *pskb);
} else {
if (pxframe->pkt == NULL)
rtw_os_pkt_complete(padapter, *pskb);
core_tx_free_xmitframe(padapter, pxframe);
}
return FAIL;
}
s32 rtw_core_tx(_adapter *padapter, struct sk_buff **pskb, struct sta_info *psta, u16 os_qid)
{
struct xmit_frame *pxframe = NULL;
#if defined(CONFIG_AP_MODE) || defined(CONFIG_CORE_TXSC)
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
#endif
s32 res = 0;
#ifdef CONFIG_CORE_TXSC
struct txsc_pkt_entry txsc_pkt;
#endif
#ifdef CONFIG_CORE_TXSC
if (txsc_get_sc_cached_entry(padapter, *pskb, &txsc_pkt) == _SUCCESS)
goto core_txsc;
#endif
if (core_tx_alloc_xmitframe(padapter, &pxframe, os_qid) == FAIL)
goto abort_core_tx;
if (core_tx_update_pkt(padapter, pxframe, pskb) == FAIL)
goto abort_core_tx;
#if defined(CONFIG_AP_MODE)
if (MLME_STATE(padapter) & WIFI_AP_STATE) {
_list f_list;
res = rtw_ap_addr_resolve(padapter, os_qid, pxframe, *pskb, &f_list);
if (res == _FAIL)
goto abort_core_tx;
#if defined(CONFIG_RTW_WDS) || CONFIG_RTW_DATA_BMC_TO_UC
if (!rtw_is_list_empty(&f_list)) {
_list *list = get_next(&f_list);
struct xmit_frame *fframe;
while ((rtw_end_of_queue_search(&f_list, list)) == _FALSE) {
fframe = LIST_CONTAINOR(list, struct xmit_frame, list);
list = get_next(list);
rtw_list_delete(&fframe->list);
if (res == RTW_ORI_NO_NEED && rtw_is_list_empty(&f_list)) {
fframe->pkt = pxframe->pkt; /*last frame */
pxframe->pkt = NULL;
} else {
fframe->pkt = rtw_skb_copy(*pskb);
}
if (!fframe->pkt) {
if (res == RTW_ORI_NO_NEED && IS_MCAST(pxframe->attrib.dst))
res = _SUCCESS;
core_tx_free_xmitframe(padapter, fframe);
continue;
}
core_tx_per_packet(padapter, fframe, &fframe->pkt, NULL);
}
}
#endif
if (res == RTW_ORI_NO_NEED) {
core_tx_free_xmitframe(padapter, pxframe);
return SUCCESS;
}
}
#endif /* defined(CONFIG_AP_MODE) */
#ifdef CONFIG_LAYER2_ROAMING
if ((padapter->mlmepriv.roam_network) && ((*pskb)->protocol != htons(0x888e))) { /* eapol never enqueue.*/
pxframe->pkt = *pskb;
rtw_list_delete(&pxframe->list);
_rtw_spinlock_bh(&pxmitpriv->rpkt_queue.lock);
rtw_list_insert_tail(&(pxframe->list), get_list_head(&(pxmitpriv->rpkt_queue)));
_rtw_spinunlock_bh(&pxmitpriv->rpkt_queue.lock);
return SUCCESS;
}
#endif
res = core_tx_per_packet(padapter, pxframe, pskb, psta);
if (res == FAIL)
return FAIL;
#ifdef CONFIG_CORE_TXSC
txsc_add_sc_cache_entry(padapter, pxframe, &txsc_pkt);
core_txsc:
if (txsc_apply_sc_cached_entry(padapter, &txsc_pkt) == _FAIL)
goto abort_core_tx;
if (core_tx_call_phl(padapter, pxframe, &txsc_pkt) == FAIL)
goto abort_core_tx;
#endif
return SUCCESS;
abort_core_tx:
if (pxframe == NULL) {
#ifdef CONFIG_CORE_TXSC
if (txsc_pkt.ptxreq)
txsc_free_txreq(padapter, txsc_pkt.ptxreq);
else
#endif
rtw_os_pkt_complete(padapter, *pskb);
} else {
if (pxframe->pkt == NULL)
rtw_os_pkt_complete(padapter, *pskb);
core_tx_free_xmitframe(padapter, pxframe);
}
return FAIL;
}
enum rtw_phl_status
rtw_core_tx_recycle(void *drv_priv, struct rtw_xmit_req *txreq)
{
_adapter *padapter = NULL;
struct xmit_frame *pxframe = NULL;
#ifdef CONFIG_CORE_TXSC
struct xmit_txreq_buf *ptxreq_buf = NULL;
#endif
if (txreq->os_priv == NULL) {
RTW_ERR("NULL txreq!\n");
return RTW_PHL_STATUS_FAILURE;
}
#ifdef CONFIG_CORE_TXSC
if (txreq->treq_type == RTW_PHL_TREQ_TYPE_CORE_TXSC) {
ptxreq_buf = (struct xmit_txreq_buf *)txreq->os_priv;
padapter = ptxreq_buf->adapter;
#ifdef RTW_PHL_DBG_CMD
core_add_record(padapter, REC_TX_PHL_RCC, txreq);
#endif
txsc_free_txreq(padapter, txreq);
return RTW_PHL_STATUS_SUCCESS;
}
#endif /* CONFIG_CORE_TXSC */
pxframe = (struct xmit_frame *)txreq->os_priv;
if (pxframe == NULL) {
RTW_ERR("%s: NULL xmitframe !!\n", __func__);
rtw_warn_on(1);
return RTW_PHL_STATUS_FAILURE;
}
padapter = pxframe->padapter;
#ifdef RTW_PHL_DBG_CMD
core_add_record(padapter, REC_TX_PHL_RCC, txreq);
#endif
#ifdef CONFIG_PCI_HCI
core_recycle_txreq_phyaddr(padapter, txreq);
#endif
core_tx_free_xmitframe(padapter, pxframe);
return RTW_PHL_STATUS_SUCCESS;
}
#endif
#ifdef CONFIG_TDLS
sint xmitframe_enqueue_for_tdls_sleeping_sta(_adapter *padapter, struct xmit_frame *pxmitframe)
{
sint ret = _FALSE;
struct sta_info *ptdls_sta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
int i;
ptdls_sta = rtw_get_stainfo(pstapriv, pattrib->dst);
if (ptdls_sta == NULL)
return ret;
else if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) {
if (pattrib->triggered == 1) {
ret = _TRUE;
return ret;
}
_rtw_spinlock_bh(&ptdls_sta->sleep_q.lock);
if (ptdls_sta->state & WIFI_SLEEP_STATE) {
rtw_list_delete(&pxmitframe->list);
/* _rtw_spinlock_bh(&psta->sleep_q.lock); */
rtw_list_insert_tail(&pxmitframe->list, get_list_head(&ptdls_sta->sleep_q));
ptdls_sta->sleepq_len++;
ptdls_sta->sleepq_ac_len++;
/* indicate 4-AC queue bit in TDLS peer traffic indication */
switch (pattrib->priority) {
case 1:
case 2:
ptdls_sta->uapsd_bk |= BIT(1);
break;
case 4:
case 5:
ptdls_sta->uapsd_vi |= BIT(1);
break;
case 6:
case 7:
ptdls_sta->uapsd_vo |= BIT(1);
break;
case 0:
case 3:
default:
ptdls_sta->uapsd_be |= BIT(1);
break;
}
/* Transmit TDLS PTI via AP */
if (ptdls_sta->sleepq_len == 1)
rtw_tdls_cmd(padapter, ptdls_sta->phl_sta->mac_addr, TDLS_ISSUE_PTI);
ret = _TRUE;
}
_rtw_spinunlock_bh(&ptdls_sta->sleep_q.lock);
}
return ret;
}
#endif /* CONFIG_TDLS */
#define RTW_HIQ_FILTER_ALLOW_ALL 0
#define RTW_HIQ_FILTER_ALLOW_SPECIAL 1
#define RTW_HIQ_FILTER_DENY_ALL 2
inline bool xmitframe_hiq_filter(struct xmit_frame *xmitframe)
{
bool allow = _FALSE;
_adapter *adapter = xmitframe->padapter;
struct registry_priv *registry = &adapter->registrypriv;
if (adapter->registrypriv.wifi_spec == 1)
allow = _TRUE;
else if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_SPECIAL) {
struct pkt_attrib *attrib = &xmitframe->attrib;
if (attrib->ether_type == 0x0806
|| attrib->ether_type == 0x888e
#ifdef CONFIG_WAPI_SUPPORT
|| attrib->ether_type == 0x88B4
#endif
|| attrib->dhcp_pkt
) {
if (0)
RTW_INFO(FUNC_ADPT_FMT" ether_type:0x%04x%s\n", FUNC_ADPT_ARG(xmitframe->padapter)
, attrib->ether_type, attrib->dhcp_pkt ? " DHCP" : "");
allow = _TRUE;
}
} else if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_ALL)
allow = _TRUE;
else if (registry->hiq_filter == RTW_HIQ_FILTER_DENY_ALL)
allow = _FALSE;
else
rtw_warn_on(1);
return allow;
}
#if defined(CONFIG_AP_MODE) || defined(CONFIG_TDLS)
sint xmitframe_enqueue_for_sleeping_sta(_adapter *padapter, struct xmit_frame *pxmitframe)
{
sint ret = _FALSE;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
sint bmcst = IS_MCAST(pattrib->ra);
bool update_tim = _FALSE;
#ifdef CONFIG_TDLS
if (padapter->tdlsinfo.link_established == _TRUE)
ret = xmitframe_enqueue_for_tdls_sleeping_sta(padapter, pxmitframe);
#endif /* CONFIG_TDLS */
if (!MLME_IS_AP(padapter) && !MLME_IS_MESH(padapter)) {
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_fwstate);
return ret;
}
/*
if(pattrib->psta)
{
psta = pattrib->psta;
}
else
{
RTW_INFO("%s, call rtw_get_stainfo()\n", __func__);
psta=rtw_get_stainfo(pstapriv, pattrib->ra);
}
*/
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta) {
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_sta);
RTW_INFO("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta);
return _FALSE;
}
if (psta == NULL) {
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_nosta);
RTW_INFO("%s, psta==NUL\n", __func__);
return _FALSE;
}
if (!(psta->state & WIFI_ASOC_STATE)) {
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_link);
RTW_INFO("%s, psta->state(0x%x) != WIFI_ASOC_STATE\n", __func__, psta->state);
return _FALSE;
}
if (pattrib->triggered == 1) {
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_trigger);
/* RTW_INFO("directly xmit pspoll_triggered packet\n"); */
/* pattrib->triggered=0; */
if (bmcst && xmitframe_hiq_filter(pxmitframe) == _TRUE)
pattrib->qsel = rtw_hal_get_qsel(padapter, QSLT_HIGH_ID);/* HIQ */
return ret;
}
if (bmcst) {
#ifndef BMC_ON_HIQ
_rtw_spinlock_bh(&psta->sleep_q.lock);
if (rtw_tim_map_anyone_be_set(padapter, pstapriv->sta_dz_bitmap)) { /* if anyone sta is in ps mode */
/* pattrib->qsel = rtw_hal_get_qsel(padapter,QSLT_HIGH_ID);*/ /* HIQ */
rtw_list_delete(&pxmitframe->list);
/*_rtw_spinlock_bh(&psta->sleep_q.lock);*/
rtw_list_insert_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
psta->sleepq_len++;
if (!(rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, 0)))
update_tim = _TRUE;
rtw_tim_map_set(padapter, pstapriv->tim_bitmap, 0);
rtw_tim_map_set(padapter, pstapriv->sta_dz_bitmap, 0);
/* RTW_INFO("enqueue, sq_len=%d\n", psta->sleepq_len); */
/* RTW_INFO_DUMP("enqueue, tim=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len); */
if (update_tim == _TRUE) {
if (is_broadcast_mac_addr(pattrib->ra))
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0, "buffer BC");
else
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0, "buffer MC");
} else
chk_bmc_sleepq_cmd(padapter);
/*_rtw_spinunlock_bh(&psta->sleep_q.lock);*/
ret = _TRUE;
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_mcast);
}
_rtw_spinunlock_bh(&psta->sleep_q.lock);
#endif
return ret;
}
_rtw_spinlock_bh(&psta->sleep_q.lock);
if (psta->state & WIFI_SLEEP_STATE) {
u8 wmmps_ac = 0;
if (rtw_tim_map_is_set(padapter, pstapriv->sta_dz_bitmap, psta->phl_sta->aid)) {
rtw_list_delete(&pxmitframe->list);
/* _rtw_spinlock_bh(&psta->sleep_q.lock); */
rtw_list_insert_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
psta->sleepq_len++;
switch (pattrib->priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk & BIT(0);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi & BIT(0);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo & BIT(0);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be & BIT(0);
break;
}
if (wmmps_ac)
psta->sleepq_ac_len++;
if (((psta->has_legacy_ac) && (!wmmps_ac)) || ((!psta->has_legacy_ac) && (wmmps_ac))) {
if (!(rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid)))
update_tim = _TRUE;
rtw_tim_map_set(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
/* RTW_INFO("enqueue, sq_len=%d\n", psta->sleepq_len); */
/* RTW_INFO_DUMP("enqueue, tim=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len); */
if (update_tim == _TRUE) {
/* RTW_INFO("sleepq_len==1, update BCNTIM\n"); */
/* upate BCN for TIM IE */
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0, "buffer UC");
}
}
/* _rtw_spinunlock_bh(&psta->sleep_q.lock); */
/* if(psta->sleepq_len > (NR_XMITFRAME>>3)) */
/* { */
/* wakeup_sta_to_xmit(padapter, psta); */
/* } */
ret = _TRUE;
DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_ucast);
}
}
_rtw_spinunlock_bh(&psta->sleep_q.lock);
return ret;
}
static void dequeue_xmitframes_to_sleeping_queue(_adapter *padapter, struct sta_info *psta, _queue *pframequeue)
{
sint ret;
_list *plist, *phead;
u8 ac_index;
struct tx_servq *ptxservq;
struct pkt_attrib *pattrib;
struct xmit_frame *pxmitframe;
struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
phead = get_list_head(pframequeue);
plist = get_next(phead);
while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
pxmitframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
plist = get_next(plist);
pattrib = &pxmitframe->attrib;
pattrib->triggered = 0;
ret = xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe);
if (_TRUE == ret) {
ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
ptxservq->qcnt--;
phwxmits[ac_index].accnt--;
} else {
/* RTW_INFO("xmitframe_enqueue_for_sleeping_sta return _FALSE\n"); */
}
}
}
void stop_sta_xmit(_adapter *padapter, struct sta_info *psta)
{
struct sta_info *psta_bmc;
struct sta_xmit_priv *pstaxmitpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
pstaxmitpriv = &psta->sta_xmitpriv;
/* for BC/MC Frames */
psta_bmc = rtw_get_bcmc_stainfo(padapter);
if (!psta_bmc)
rtw_warn_on(1);
_rtw_spinlock_bh(&pxmitpriv->lock);
psta->state |= WIFI_SLEEP_STATE;
#ifdef CONFIG_TDLS
if (!(psta->tdls_sta_state & TDLS_LINKED_STATE))
#endif /* CONFIG_TDLS */
rtw_tim_map_set(padapter, pstapriv->sta_dz_bitmap, psta->phl_sta->aid);
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->vo_q.tx_pending));
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->vi_q.tx_pending));
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->bk_q.tx_pending));
if (psta_bmc != NULL
#ifdef CONFIG_TDLS
&& !(psta->tdls_sta_state & TDLS_LINKED_STATE)
#endif
) {
/* for BC/MC Frames */
#ifndef BMC_ON_HIQ
pstaxmitpriv = &psta_bmc->sta_xmitpriv;
dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->vo_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->vo_q.tx_pending));
dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->vi_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->vi_q.tx_pending));
dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->be_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->be_q.tx_pending));
dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->bk_q.sta_pending);
rtw_list_delete(&(pstaxmitpriv->bk_q.tx_pending));
#endif
}
_rtw_spinunlock_bh(&pxmitpriv->lock);
}
void wakeup_sta_to_xmit(_adapter *padapter, struct sta_info *psta)
{
u8 update_mask = 0, wmmps_ac = 0;
struct sta_info *psta_bmc;
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
psta_bmc = rtw_get_bcmc_stainfo(padapter);
/* _rtw_spinlock_bh(&psta->sleep_q.lock); */
_rtw_spinlock_bh(&pxmitpriv->lock);
xmitframe_phead = get_list_head(&psta->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
xmitframe_plist = get_next(xmitframe_plist);
rtw_list_delete(&pxmitframe->list);
switch (pxmitframe->attrib.priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk & BIT(1);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi & BIT(1);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo & BIT(1);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be & BIT(1);
break;
}
psta->sleepq_len--;
if (psta->sleepq_len > 0)
pxmitframe->attrib.mdata = 1;
else
pxmitframe->attrib.mdata = 0;
if (wmmps_ac) {
psta->sleepq_ac_len--;
if (psta->sleepq_ac_len > 0) {
pxmitframe->attrib.mdata = 1;
pxmitframe->attrib.eosp = 0;
} else {
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.eosp = 1;
}
}
pxmitframe->attrib.triggered = 1;
/*
_rtw_spinunlock_bh(&psta->sleep_q.lock);
//rtw_intf_data_xmit
if(rtw_hal_xmit(padapter, pxmitframe) == _TRUE)
{
rtw_os_xmit_complete(padapter, pxmitframe);
}
_rtw_spinlock_bh(&psta->sleep_q.lock);
*/
rtw_intf_xmitframe_enqueue(padapter, pxmitframe);
}
if (psta->sleepq_len == 0) {
#ifdef CONFIG_TDLS
if (psta->tdls_sta_state & TDLS_LINKED_STATE) {
if (psta->state & WIFI_SLEEP_STATE)
psta->state ^= WIFI_SLEEP_STATE;
_rtw_spinunlock_bh(&pxmitpriv->lock);
return;
}
#endif /* CONFIG_TDLS */
if (rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid)) {
/* RTW_INFO("wakeup to xmit, qlen==0\n"); */
/* RTW_INFO_DUMP("update_BCNTIM, tim=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len); */
/* upate BCN for TIM IE */
/* update_BCNTIM(padapter); */
update_mask = BIT(0);
}
rtw_tim_map_clear(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
if (psta->state & WIFI_SLEEP_STATE)
psta->state ^= WIFI_SLEEP_STATE;
if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
RTW_INFO("%s alive check\n", __func__);
psta->expire_to = pstapriv->expire_to;
psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
}
rtw_tim_map_clear(padapter, pstapriv->sta_dz_bitmap, psta->phl_sta->aid);
}
/* for BC/MC Frames */
if (!psta_bmc)
goto _exit;
if (!(rtw_tim_map_anyone_be_set_exclude_aid0(padapter, pstapriv->sta_dz_bitmap))) { /* no any sta in ps mode */
xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
xmitframe_plist = get_next(xmitframe_plist);
rtw_list_delete(&pxmitframe->list);
psta_bmc->sleepq_len--;
if (psta_bmc->sleepq_len > 0)
pxmitframe->attrib.mdata = 1;
else
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.triggered = 1;
/*
_rtw_spinunlock_bh(&psta_bmc->sleep_q.lock);
//rtw_intf_data_xmit
if(rtw_hal_xmit(padapter, pxmitframe) == _TRUE)
{
rtw_os_xmit_complete(padapter, pxmitframe);
}
_rtw_spinlock_bh(&psta_bmc->sleep_q.lock);
*/
rtw_intf_xmitframe_enqueue(padapter, pxmitframe);
}
if (psta_bmc->sleepq_len == 0) {
if (rtw_tim_map_is_set(padapter, pstapriv->tim_bitmap, 0)) {
/* RTW_INFO("wakeup to xmit, qlen==0\n"); */
/* RTW_INFO_DUMP("update_BCNTIM, tim=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len); */
/* upate BCN for TIM IE */
/* update_BCNTIM(padapter); */
update_mask |= BIT(1);
}
rtw_tim_map_clear(padapter, pstapriv->tim_bitmap, 0);
rtw_tim_map_clear(padapter, pstapriv->sta_dz_bitmap, 0);
}
}
_exit:
/* _rtw_spinunlock_bh(&psta_bmc->sleep_q.lock); */
_rtw_spinunlock_bh(&pxmitpriv->lock);
if (update_mask) {
/* update_BCNTIM(padapter); */
if ((update_mask & (BIT(0) | BIT(1))) == (BIT(0) | BIT(1)))
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0, "clear UC&BMC");
else if ((update_mask & BIT(1)) == BIT(1))
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0, "clear BMC");
else
_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0, "clear UC");
}
}
void xmit_delivery_enabled_frames(_adapter *padapter, struct sta_info *psta)
{
u8 wmmps_ac = 0;
_list *xmitframe_plist, *xmitframe_phead;
struct xmit_frame *pxmitframe = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
/* _rtw_spinlock_bh(&psta->sleep_q.lock); */
_rtw_spinlock_bh(&pxmitpriv->lock);
xmitframe_phead = get_list_head(&psta->sleep_q);
xmitframe_plist = get_next(xmitframe_phead);
while ((rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist)) == _FALSE) {
pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
xmitframe_plist = get_next(xmitframe_plist);
switch (pxmitframe->attrib.priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk & BIT(1);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi & BIT(1);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo & BIT(1);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be & BIT(1);
break;
}
if (!wmmps_ac)
continue;
rtw_list_delete(&pxmitframe->list);
psta->sleepq_len--;
psta->sleepq_ac_len--;
if (psta->sleepq_ac_len > 0) {
pxmitframe->attrib.mdata = 1;
pxmitframe->attrib.eosp = 0;
} else {
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.eosp = 1;
}
pxmitframe->attrib.triggered = 1;
rtw_intf_xmitframe_enqueue(padapter, pxmitframe);
if ((psta->sleepq_ac_len == 0) && (!psta->has_legacy_ac) && (wmmps_ac)) {
#ifdef CONFIG_TDLS
if (psta->tdls_sta_state & TDLS_LINKED_STATE) {
/* _rtw_spinunlock_bh(&psta->sleep_q.lock); */
goto exit;
}
#endif /* CONFIG_TDLS */
rtw_tim_map_clear(padapter, pstapriv->tim_bitmap, psta->phl_sta->aid);
/* RTW_INFO("wakeup to xmit, qlen==0\n"); */
/* RTW_INFO_DUMP("update_BCNTIM, tim=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len); */
/* upate BCN for TIM IE */
/* update_BCNTIM(padapter); */
rtw_update_beacon(padapter, _TIM_IE_, NULL, _TRUE, 0);
/* update_mask = BIT(0); */
}
}
#ifdef CONFIG_TDLS
exit:
#endif
/* _rtw_spinunlock_bh(&psta->sleep_q.lock); */
_rtw_spinunlock_bh(&pxmitpriv->lock);
return;
}
#endif /* defined(CONFIG_AP_MODE) || defined(CONFIG_TDLS) */
#if 0 /*#ifdef CONFIG_XMIT_THREAD_MODE*/
void enqueue_pending_xmitbuf(
struct xmit_priv *pxmitpriv,
struct xmit_buf *pxmitbuf)
{
_queue *pqueue;
_adapter *pri_adapter = pxmitpriv->adapter;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
_rtw_spinlock_bh(&pqueue->lock);
rtw_list_delete(&pxmitbuf->list);
rtw_list_insert_tail(&pxmitbuf->list, get_list_head(pqueue));
_rtw_spinunlock_bh(&pqueue->lock);
#if defined(CONFIG_SDIO_HCI) && defined(CONFIG_CONCURRENT_MODE)
pri_adapter = GET_PRIMARY_ADAPTER(pri_adapter);
#endif /*SDIO_HCI + CONCURRENT*/
_rtw_up_sema(&(pri_adapter->xmitpriv.xmit_sema));
}
void enqueue_pending_xmitbuf_to_head(
struct xmit_priv *pxmitpriv,
struct xmit_buf *pxmitbuf)
{
_queue *pqueue = &pxmitpriv->pending_xmitbuf_queue;
_rtw_spinlock_bh(&pqueue->lock);
rtw_list_delete(&pxmitbuf->list);
rtw_list_insert_head(&pxmitbuf->list, get_list_head(pqueue));
_rtw_spinunlock_bh(&pqueue->lock);
}
struct xmit_buf *dequeue_pending_xmitbuf(
struct xmit_priv *pxmitpriv)
{
struct xmit_buf *pxmitbuf;
_queue *pqueue;
pxmitbuf = NULL;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
_rtw_spinlock_bh(&pqueue->lock);
if (_rtw_queue_empty(pqueue) == _FALSE) {
_list *plist, *phead;
phead = get_list_head(pqueue);
plist = get_next(phead);
pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
rtw_list_delete(&pxmitbuf->list);
}
_rtw_spinunlock_bh(&pqueue->lock);
return pxmitbuf;
}
static struct xmit_buf *dequeue_pending_xmitbuf_ext(
struct xmit_priv *pxmitpriv)
{
struct xmit_buf *pxmitbuf;
_queue *pqueue;
pxmitbuf = NULL;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
_rtw_spinlock_bh(&pqueue->lock);
if (_rtw_queue_empty(pqueue) == _FALSE) {
_list *plist, *phead;
phead = get_list_head(pqueue);
plist = phead;
do {
plist = get_next(plist);
if (plist == phead)
break;
pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list);
if (pxmitbuf->buf_tag == XMITBUF_MGNT) {
rtw_list_delete(&pxmitbuf->list);
break;
}
pxmitbuf = NULL;
} while (1);
}
_rtw_spinunlock_bh(&pqueue->lock);
return pxmitbuf;
}
struct xmit_buf *select_and_dequeue_pending_xmitbuf(_adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_buf *pxmitbuf = NULL;
if (_TRUE == rtw_is_xmit_blocked(padapter))
return pxmitbuf;
pxmitbuf = dequeue_pending_xmitbuf_ext(pxmitpriv);
if (pxmitbuf == NULL && rtw_xmit_ac_blocked(padapter) != _TRUE)
pxmitbuf = dequeue_pending_xmitbuf(pxmitpriv);
return pxmitbuf;
}
sint check_pending_xmitbuf(
struct xmit_priv *pxmitpriv)
{
_queue *pqueue;
sint ret = _FALSE;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
_rtw_spinlock_bh(&pqueue->lock);
if (_rtw_queue_empty(pqueue) == _FALSE)
ret = _TRUE;
_rtw_spinunlock_bh(&pqueue->lock);
return ret;
}
thread_return rtw_xmit_thread(thread_context context)
{
s32 err;
_adapter *adapter;
#ifdef RTW_XMIT_THREAD_HIGH_PRIORITY
#ifdef PLATFORM_LINUX
struct sched_param param = { .sched_priority = 1 };
sched_setscheduler(current, SCHED_FIFO, ¶m);
#endif /* PLATFORM_LINUX */
#endif /* RTW_XMIT_THREAD_HIGH_PRIORITY */
err = _SUCCESS;
adapter = (_adapter *)context;
rtw_thread_enter("RTW_XMIT_THREAD");
do {
err = rtw_intf_xmit_buf_handler(adapter);
flush_signals_thread();
} while (_SUCCESS == err);
RTW_INFO(FUNC_ADPT_FMT " Exit\n", FUNC_ADPT_ARG(adapter));
rtw_thread_wait_stop();
return 0;
}
#endif
#ifdef DBG_XMIT_BLOCK
void dump_xmit_block(void *sel, _adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
RTW_PRINT_SEL(sel, "[XMIT-BLOCK] xmit_block :0x%02x\n", dvobj->xmit_block);
if (dvobj->xmit_block & XMIT_BLOCK_REDLMEM)
RTW_PRINT_SEL(sel, "Reason:%s\n", "XMIT_BLOCK_REDLMEM");
if (dvobj->xmit_block & XMIT_BLOCK_SUSPEND)
RTW_PRINT_SEL(sel, "Reason:%s\n", "XMIT_BLOCK_SUSPEND");
if (dvobj->xmit_block == XMIT_BLOCK_NONE)
RTW_PRINT_SEL(sel, "Reason:%s\n", "XMIT_BLOCK_NONE");
}
void dump_xmit_block_info(void *sel, const char *fun_name, _adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
RTW_INFO("\n"ADPT_FMT" call %s\n", ADPT_ARG(padapter), fun_name);
dump_xmit_block(sel, padapter);
}
#define DBG_XMIT_BLOCK_DUMP(adapter) dump_xmit_block_info(RTW_DBGDUMP, __func__, adapter)
#endif
void rtw_set_xmit_block(_adapter *padapter, enum XMIT_BLOCK_REASON reason)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
_rtw_spinlock_bh(&dvobj->xmit_block_lock);
dvobj->xmit_block |= reason;
_rtw_spinunlock_bh(&dvobj->xmit_block_lock);
#ifdef DBG_XMIT_BLOCK
DBG_XMIT_BLOCK_DUMP(padapter);
#endif
}
void rtw_clr_xmit_block(_adapter *padapter, enum XMIT_BLOCK_REASON reason)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
_rtw_spinlock_bh(&dvobj->xmit_block_lock);
dvobj->xmit_block &= ~reason;
_rtw_spinunlock_bh(&dvobj->xmit_block_lock);
#ifdef DBG_XMIT_BLOCK
DBG_XMIT_BLOCK_DUMP(padapter);
#endif
}
bool rtw_is_xmit_blocked(_adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
#ifdef DBG_XMIT_BLOCK
DBG_XMIT_BLOCK_DUMP(padapter);
#endif
return ((dvobj->xmit_block) ? _TRUE : _FALSE);
}
bool rtw_xmit_ac_blocked(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
_adapter *iface;
struct mlme_ext_priv *mlmeext;
bool blocked = _FALSE;
int i;
#ifdef DBG_CONFIG_ERROR_DETECT
#ifdef DBG_CONFIG_ERROR_RESET
#ifdef CONFIG_USB_HCI
if (rtw_hal_sreset_inprogress(adapter) == _TRUE) {
blocked = _TRUE;
goto exit;
}
#endif/* #ifdef CONFIG_USB_HCI */
#endif/* #ifdef DBG_CONFIG_ERROR_RESET */
#endif/* #ifdef DBG_CONFIG_ERROR_DETECT */
if (rfctl->offch_state != OFFCHS_NONE
#if CONFIG_DFS
|| IS_RADAR_DETECTED(rfctl) || rfctl->csa_chandef.chan
#endif
) {
blocked = _TRUE;
goto exit;
}
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlmeext = &iface->mlmeextpriv;
/* check scan state */
if (mlmeext_scan_state(mlmeext) != SCAN_DISABLE
&& mlmeext_scan_state(mlmeext) != SCAN_BACK_OP
) {
blocked = _TRUE;
goto exit;
}
if (mlmeext_scan_state(mlmeext) == SCAN_BACK_OP
&& !mlmeext_chk_scan_backop_flags(mlmeext, SS_BACKOP_TX_RESUME)
) {
blocked = _TRUE;
goto exit;
}
}
exit:
return blocked;
}
#ifdef CONFIG_LAYER2_ROAMING
/* dequeuq + xmit the cache skb during the roam procedure */
void dequeuq_roam_pkt(_adapter *padapter)
{
struct xmit_frame *rframe;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_list *plist = NULL, *phead = NULL;
if (padapter->mlmepriv.roam_network) {
padapter->mlmepriv.roam_network = NULL;
_rtw_spinlock_bh(&pxmitpriv->rpkt_queue.lock);
phead = get_list_head(&pxmitpriv->rpkt_queue);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
rframe = LIST_CONTAINOR(plist, struct xmit_frame, list);
plist = get_next(plist);
rtw_list_delete(&rframe->list);
core_tx_per_packet(padapter, rframe, &rframe->pkt, NULL);
}
_rtw_spinunlock_bh(&pxmitpriv->rpkt_queue.lock);
}
}
#endif
#ifdef CONFIG_TX_AMSDU
void rtw_amsdu_vo_timeout_handler(void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
adapter->xmitpriv.amsdu_vo_timeout = RTW_AMSDU_TIMER_TIMEOUT;
rtw_tasklet_hi_schedule(&adapter->xmitpriv.xmit_tasklet);
}
void rtw_amsdu_vi_timeout_handler(void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
adapter->xmitpriv.amsdu_vi_timeout = RTW_AMSDU_TIMER_TIMEOUT;
rtw_tasklet_hi_schedule(&adapter->xmitpriv.xmit_tasklet);
}
void rtw_amsdu_be_timeout_handler(void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
adapter->xmitpriv.amsdu_be_timeout = RTW_AMSDU_TIMER_TIMEOUT;
rtw_tasklet_hi_schedule(&adapter->xmitpriv.xmit_tasklet);
}
void rtw_amsdu_bk_timeout_handler(void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
adapter->xmitpriv.amsdu_bk_timeout = RTW_AMSDU_TIMER_TIMEOUT;
rtw_tasklet_hi_schedule(&adapter->xmitpriv.xmit_tasklet);
}
u8 rtw_amsdu_get_timer_status(_adapter *padapter, u8 priority)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u8 status = RTW_AMSDU_TIMER_UNSET;
switch (priority) {
case 1:
case 2:
status = pxmitpriv->amsdu_bk_timeout;
break;
case 4:
case 5:
status = pxmitpriv->amsdu_vi_timeout;
break;
case 6:
case 7:
status = pxmitpriv->amsdu_vo_timeout;
break;
case 0:
case 3:
default:
status = pxmitpriv->amsdu_be_timeout;
break;
}
return status;
}
void rtw_amsdu_set_timer_status(_adapter *padapter, u8 priority, u8 status)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
switch (priority) {
case 1:
case 2:
pxmitpriv->amsdu_bk_timeout = status;
break;
case 4:
case 5:
pxmitpriv->amsdu_vi_timeout = status;
break;
case 6:
case 7:
pxmitpriv->amsdu_vo_timeout = status;
break;
case 0:
case 3:
default:
pxmitpriv->amsdu_be_timeout = status;
break;
}
}
void rtw_amsdu_set_timer(_adapter *padapter, u8 priority)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_timer *amsdu_timer = NULL;
switch (priority) {
case 1:
case 2:
amsdu_timer = &pxmitpriv->amsdu_bk_timer;
break;
case 4:
case 5:
amsdu_timer = &pxmitpriv->amsdu_vi_timer;
break;
case 6:
case 7:
amsdu_timer = &pxmitpriv->amsdu_vo_timer;
break;
case 0:
case 3:
default:
amsdu_timer = &pxmitpriv->amsdu_be_timer;
break;
}
_set_timer(amsdu_timer, 1);
}
void rtw_amsdu_cancel_timer(_adapter *padapter, u8 priority)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_timer *amsdu_timer = NULL;
switch (priority) {
case 1:
case 2:
amsdu_timer = &pxmitpriv->amsdu_bk_timer;
break;
case 4:
case 5:
amsdu_timer = &pxmitpriv->amsdu_vi_timer;
break;
case 6:
case 7:
amsdu_timer = &pxmitpriv->amsdu_vo_timer;
break;
case 0:
case 3:
default:
amsdu_timer = &pxmitpriv->amsdu_be_timer;
break;
}
_cancel_timer_ex(amsdu_timer);
}
#endif /* CONFIG_TX_AMSDU */
#if 0 /*def DBG_TXBD_DESC_DUMP*/
static struct rtw_tx_desc_backup tx_backup[HW_QUEUE_ENTRY][TX_BAK_FRMAE_CNT];
static u8 backup_idx[HW_QUEUE_ENTRY];
void rtw_tx_desc_backup(_adapter *padapter, struct xmit_frame *pxmitframe, u8 desc_size, u8 hwq)
{
u32 tmp32;
u8 *pxmit_buf;
if (rtw_hw_get_init_completed(adapter_to_dvobj(padapter)) == _FALSE)
return;
pxmit_buf = pxmitframe->pxmitbuf->pbuf;
_rtw_memcpy(tx_backup[hwq][backup_idx[hwq]].tx_bak_desc, pxmit_buf, desc_size);
_rtw_memcpy(tx_backup[hwq][backup_idx[hwq]].tx_bak_data_hdr, pxmit_buf+desc_size, TX_BAK_DATA_LEN);
#if 0 /*GEORGIA_TODO_REDEFINE_IO*/
tmp32 = rtw_read32(padapter, get_txbd_rw_reg(hwq));
#else
tmp32 = rtw_hal_get_txbd_rwreg(padapter);
#endif
tx_backup[hwq][backup_idx[hwq]].tx_bak_rp = (tmp32>>16)&0xfff;
tx_backup[hwq][backup_idx[hwq]].tx_bak_wp = tmp32&0xfff;
tx_backup[hwq][backup_idx[hwq]].tx_desc_size = desc_size;
backup_idx[hwq] = (backup_idx[hwq] + 1) % TX_BAK_FRMAE_CNT;
}
void rtw_tx_desc_backup_reset(void)
{
int i, j;
for (i = 0; i < HW_QUEUE_ENTRY; i++) {
for (j = 0; j < TX_BAK_FRMAE_CNT; j++)
_rtw_memset(&tx_backup[i][j], 0, sizeof(struct rtw_tx_desc_backup));
backup_idx[i] = 0;
}
}
u8 rtw_get_tx_desc_backup(_adapter *padapter, u8 hwq, struct rtw_tx_desc_backup **pbak)
{
*pbak = &tx_backup[hwq][0];
return backup_idx[hwq];
}
#endif
#ifdef CONFIG_PCI_TX_POLLING
void rtw_tx_poll_init(_adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_timer *timer = &pxmitpriv->tx_poll_timer;
if (!is_primary_adapter(padapter))
return;
if (timer->function != NULL) {
RTW_INFO("tx polling timer has been init.\n");
return;
}
rtw_init_timer(timer, rtw_tx_poll_timeout_handler, padapter);
rtw_tx_poll_timer_set(padapter, 1);
RTW_INFO("Tx poll timer init!\n");
}
void rtw_tx_poll_timeout_handler(void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
rtw_tx_poll_timer_set(adapter, 1);
if (adapter->dvobj->hal_func.tx_poll_handler)
adapter->dvobj->hal_func.tx_poll_handler(adapter);
else
RTW_WARN("hal ops: tx_poll_handler is NULL\n");
}
void rtw_tx_poll_timer_set(_adapter *padapter, u32 delay)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_timer *timer = NULL;
timer = &pxmitpriv->tx_poll_timer;
_set_timer(timer, delay);
}
void rtw_tx_poll_timer_cancel(_adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_timer *timer = NULL;
if (!is_primary_adapter(padapter))
return;
timer = &pxmitpriv->tx_poll_timer;
_cancel_timer_ex(timer);
timer->function = NULL;
RTW_INFO("Tx poll timer cancel !\n");
}
#endif /* CONFIG_PCI_TX_POLLING */
void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms)
{
sctx->timeout_ms = timeout_ms;
sctx->submit_time = rtw_get_current_time();
_rtw_init_completion(&sctx->done);
sctx->status = RTW_SCTX_SUBMITTED;
}
int rtw_sctx_wait(struct submit_ctx *sctx, const char *msg)
{
int ret = _FAIL;
unsigned long expire;
int status = 0;
#ifdef PLATFORM_LINUX
expire = sctx->timeout_ms ? msecs_to_jiffies(sctx->timeout_ms) : MAX_SCHEDULE_TIMEOUT;
if (!_rtw_wait_for_comp_timeout(&sctx->done, expire)) {
/* timeout, do something?? */
status = RTW_SCTX_DONE_TIMEOUT;
RTW_INFO("%s timeout: %s\n", __func__, msg);
} else
status = sctx->status;
#endif
if (status == RTW_SCTX_DONE_SUCCESS)
ret = _SUCCESS;
return ret;
}
bool rtw_sctx_chk_waring_status(int status)
{
switch (status) {
case RTW_SCTX_DONE_UNKNOWN:
case RTW_SCTX_DONE_BUF_ALLOC:
case RTW_SCTX_DONE_BUF_FREE:
case RTW_SCTX_DONE_DRV_STOP:
case RTW_SCTX_DONE_DEV_REMOVE:
return _TRUE;
default:
return _FALSE;
}
}
void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
{
if (*sctx) {
if (rtw_sctx_chk_waring_status(status))
RTW_INFO("%s status:%d\n", __func__, status);
(*sctx)->status = status;
#ifdef PLATFORM_LINUX
complete(&((*sctx)->done));
#endif
*sctx = NULL;
}
}
void rtw_sctx_done(struct submit_ctx **sctx)
{
rtw_sctx_done_err(sctx, RTW_SCTX_DONE_SUCCESS);
}
#ifdef CONFIG_XMIT_ACK
int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms)
{
struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
pack_tx_ops->submit_time = rtw_get_current_time();
pack_tx_ops->timeout_ms = timeout_ms;
pack_tx_ops->status = RTW_SCTX_SUBMITTED;
return rtw_sctx_wait(pack_tx_ops, __func__);
}
void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status)
{
struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
if (pxmitpriv->ack_tx)
rtw_sctx_done_err(&pack_tx_ops, status);
else
RTW_INFO("%s ack_tx not set\n", __func__);
}
#endif /* CONFIG_XMIT_ACK */
|
2301_81045437/rtl8852be
|
core/rtw_xmit.c
|
C
|
agpl-3.0
| 251,863
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#include <drv_types.h>
#ifdef CONFIG_CORE_TXSC
u8 DBG_PRINT_MDATA_ONCE;
void _print_txreq_mdata(struct rtw_t_meta_data *mdata, const char *func)
{
if (DBG_PRINT_MDATA_ONCE == 1) {
RTW_PRINT("[%s]\n", func);
RTW_PRINT("da: %02x%02x%02x%02x%02x%02x\n",
mdata->da[0], mdata->da[1], mdata->da[2], mdata->da[3], mdata->da[4], mdata->da[5]);
RTW_PRINT("sa: %02x%02x%02x%02x%02x%02x\n",
mdata->sa[0], mdata->sa[1], mdata->sa[2], mdata->sa[3], mdata->sa[4], mdata->sa[5]);
RTW_PRINT("to_ds: %d\n", mdata->to_ds);
RTW_PRINT("from_ds: %d\n", mdata->from_ds);
RTW_PRINT("band: %d\n", mdata->band);
RTW_PRINT("type: %d\n", mdata->type);
RTW_PRINT("hw_seq_mode: %d\n", mdata->hw_seq_mode);
RTW_PRINT("hw_ssn_sel: %d\n", mdata->hw_ssn_sel);
RTW_PRINT("smh_en: %d\n", mdata->smh_en);
RTW_PRINT("hw_amsdu: %d\n", mdata->hw_amsdu);
RTW_PRINT("hw_sec_iv: %d\n", mdata->hw_sec_iv);
RTW_PRINT("wd_page_size: %d\n", mdata->wd_page_size);
RTW_PRINT("hdr_len: %d\n", mdata->hdr_len);
RTW_PRINT("dma_ch: %d\n", mdata->dma_ch);
RTW_PRINT("usb_pkt_ofst: %d\n", mdata->usb_pkt_ofst);
RTW_PRINT("wdinfo_en: %d\n", mdata->wdinfo_en);
RTW_PRINT("wp_offset: %d\n", mdata->wp_offset);
RTW_PRINT("shcut_camid: %d\n", mdata->shcut_camid);
RTW_PRINT("usb_txagg_num: %d\n", mdata->usb_txagg_num);
RTW_PRINT("pktlen: %d\n", mdata->pktlen);
RTW_PRINT("tid: %d\n", mdata->tid);
RTW_PRINT("macid: %d\n", mdata->macid);
RTW_PRINT("sw_seq: %d\n", mdata->sw_seq);
RTW_PRINT("ampdu_en: %d\n", mdata->ampdu_en);
RTW_PRINT("bk: %d\n", mdata->bk);
RTW_PRINT("mbssid: %d\n", mdata->mbssid);
RTW_PRINT("hal_port: %d\n", mdata->hal_port);
RTW_PRINT("data_bw_er: %d\n", mdata->data_bw_er);
RTW_PRINT("dis_rts_rate_fb: %d\n", mdata->dis_rts_rate_fb);
RTW_PRINT("dis_data_rate_fb: %d\n", mdata->dis_data_rate_fb);
RTW_PRINT("f_ldpc: %d\n", mdata->f_ldpc);
RTW_PRINT("f_stbc: %d\n", mdata->f_stbc);
RTW_PRINT("f_dcm: %d\n", mdata->f_dcm);
RTW_PRINT("f_er: %d\n", mdata->f_er);
RTW_PRINT("f_rate: %d\n", mdata->f_rate);
RTW_PRINT("f_gi_ltf: %d\n", mdata->f_gi_ltf);
RTW_PRINT("f_bw: %d\n", mdata->f_bw);
RTW_PRINT("userate_sel: %d\n", mdata->userate_sel);
RTW_PRINT("ack_ch_info: %d\n", mdata->ack_ch_info);
RTW_PRINT("max_agg_num: %d\n", mdata->max_agg_num);
RTW_PRINT("nav_use_hdr: %d\n", mdata->nav_use_hdr);
RTW_PRINT("bc: %d\n", mdata->bc);
RTW_PRINT("mc: %d\n", mdata->mc);
RTW_PRINT("a_ctrl_bqr: %d\n", mdata->a_ctrl_bqr);
RTW_PRINT("a_ctrl_uph: %d\n", mdata->a_ctrl_uph);
RTW_PRINT("a_ctrl_bsr: %d\n", mdata->a_ctrl_bsr);
RTW_PRINT("a_ctrl_cas: %d\n", mdata->a_ctrl_cas);
RTW_PRINT("data_rty_lowest_rate: %d\n", mdata->data_rty_lowest_rate);
RTW_PRINT("data_tx_cnt_lmt: %d\n", mdata->data_tx_cnt_lmt);
RTW_PRINT("data_tx_cnt_lmt_en: %d\n", mdata->data_tx_cnt_lmt_en);
RTW_PRINT("sec_cam_idx: %d\n", mdata->sec_cam_idx);
RTW_PRINT("sec_hw_enc: %d\n", mdata->sec_hw_enc);
RTW_PRINT("sec_type: %d\n", mdata->sec_type);
RTW_PRINT("life_time_sel: %d\n", mdata->life_time_sel);
RTW_PRINT("ampdu_density: %d\n", mdata->ampdu_density);
RTW_PRINT("no_ack: %d\n", mdata->no_ack);
RTW_PRINT("ndpa: %d\n", mdata->ndpa);
RTW_PRINT("snd_pkt_sel: %d\n", mdata->snd_pkt_sel);
RTW_PRINT("sifs_tx: %d\n", mdata->sifs_tx);
RTW_PRINT("rtt_en: %d\n", mdata->rtt_en);
RTW_PRINT("spe_rpt: %d\n", mdata->spe_rpt);
RTW_PRINT("raw: %d\n", mdata->raw);
RTW_PRINT("sw_define: %d\n", mdata->sw_define);
RTW_PRINT("rts_en: %d\n", mdata->rts_en);
RTW_PRINT("cts2self: %d\n", mdata->cts2self);
RTW_PRINT("rts_cca_mode: %d\n", mdata->rts_cca_mode);
RTW_PRINT("hw_rts_en: %d\n", mdata->hw_rts_en);
DBG_PRINT_MDATA_ONCE = 0;
}
}
u8 DBG_PRINT_TXREQ_ONCE;
void _print_txreq_pklist(struct xmit_frame *pxframe, struct rtw_xmit_req *ptxreq, struct sk_buff *pskb, const char *func)
{
struct rtw_pkt_buf_list *pkt_list = NULL;
struct rtw_xmit_req *txreq = NULL;
u8 pkt_cnt = 0, i;
if (DBG_PRINT_TXREQ_ONCE == 1) {
RTW_PRINT("%s\n", func);
RTW_PRINT("[%s] pxframe=%p txreq=%p\n", func, pxframe, ptxreq);
if (pskb)
txsc_dump_data(pskb->data, ETH_HLEN, "ETHHDR");
if (ptxreq != NULL)
txreq = ptxreq;
else
txreq = pxframe->phl_txreq;
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
pkt_cnt = txreq->pkt_cnt;
RTW_PRINT("os_priv:%p, treq_type:%d, pkt_cnt:%d, total_len:%d, shortcut_id:%d\n\n",
txreq->os_priv, txreq->treq_type, txreq->pkt_cnt, txreq->total_len, txreq->shortcut_id);
for (i = 0; i < pkt_cnt; i++) {
RTW_PRINT("pkt_list[%d]\n", i);
txsc_dump_data(pkt_list->vir_addr, pkt_list->length, "pkt_list");
pkt_list++;
}
DBG_PRINT_TXREQ_ONCE = 0;
}
}
void txsc_init(_adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
pxmitpriv->txsc_enable = 1; /* default TXSC on */
pxmitpriv->txsc_debug_mode = 0;
pxmitpriv->txsc_debug_mask = 0x3;
}
void txsc_clear(_adapter *padapter)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_info *psta = NULL;
int i;
u8 tmp = 0;
RTW_PRINT("[TXSC] clear txsc entry\n");
_rtw_spinlock_bh(&pxmitpriv->txsc_lock);
if (pxmitpriv->txsc_enable) {
tmp = pxmitpriv->txsc_enable;
pxmitpriv->txsc_enable = 0;
}
pxmitpriv->ptxsc_sta_cached = NULL;
for (i = 0; i < pstapriv->max_num_sta; i++) {
psta = pstapriv->sta_aid[i];
if (!psta)
continue;
psta->txsc_cache_num = 0;
psta->txsc_cur_idx = 0;
psta->txsc_cache_idx = 0;
psta->txsc_cache_hit = 0;
psta->txsc_cache_miss = 0;
psta->txsc_path_slow = 0;
_rtw_memset(psta->txsc_entry_cache, 0x0, sizeof(struct txsc_entry) * CORE_TXSC_ENTRY_NUM);
}
pxmitpriv->txsc_enable = tmp;
_rtw_spinunlock_bh(&pxmitpriv->txsc_lock);
}
void txsc_dump(_adapter *padapter)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_info *psta = NULL;
int i, j;
RTW_PRINT("[txsc][core] (txsc,enable) txsc_enable:%x\n", pxmitpriv->txsc_enable);
RTW_PRINT("[txsc][core] (txsc,debug) txsc_debug_mode:%x\n", pxmitpriv->txsc_debug_mode);
RTW_PRINT("[txsc][core] txsc_phl_err_cnt1:%d\n", pxmitpriv->txsc_phl_err_cnt1);
RTW_PRINT("[txsc][core] txsc_phl_err_cnt2:%d\n", pxmitpriv->txsc_phl_err_cnt2);
RTW_PRINT("\n");
for (i = 0; i < pstapriv->max_num_sta; i++) {
psta = pstapriv->sta_aid[i];
if (!psta)
continue;
RTW_PRINT("[%d] STA[%02x:%02x:%02x:%02x:%02x:%02x]\n", i,
psta->phl_sta->mac_addr[0], psta->phl_sta->mac_addr[1], psta->phl_sta->mac_addr[2],
psta->phl_sta->mac_addr[3], psta->phl_sta->mac_addr[4], psta->phl_sta->mac_addr[5]);
RTW_PRINT("[txsc] cur_idx:%d\n", psta->txsc_cur_idx);
RTW_PRINT("[txsc][core] txsc_path_slow:%d\n", psta->txsc_path_slow);
RTW_PRINT("[txsc][core] txsc_path_ps:%d\n", psta->txsc_path_ps);
RTW_PRINT("[txsc][core] txsc_cache_hit:%d\n", psta->txsc_cache_hit);
RTW_PRINT("[txsc][core] txsc_cache_miss:%d\n", psta->txsc_cache_miss);
RTW_PRINT("\n");
for (j = 0 ; j < CORE_TXSC_ENTRY_NUM; j++) {
if (!psta->txsc_entry_cache[j].txsc_is_used)
continue;
RTW_PRINT(" [%d][txsc][core] txsc_core_hit:%d\n", j, psta->txsc_entry_cache[j].txsc_cache_hit);
#ifdef CONFIG_PHL_TXSC
RTW_PRINT(" [%d][txsc][phl] txsc_phl_hit:%d\n", j, psta->phl_sta->phl_txsc[j].txsc_cache_hit);
#endif
RTW_PRINT("\n");
}
}
}
void txsc_dump_data(u8 *buf, u16 buf_len, const char *prefix)
{
int i = 0, j;
RTW_PRINT("[txsc_dump] [%s (%uB)]@%p:\n", prefix, buf_len, buf);
if (buf == NULL) {
RTW_PRINT("[txsc_dump] NULL!\n");
return;
}
while (i < buf_len) {
RTW_PRINT("[txsc_dump] %04X -", i);
for (j = 0; (j < 4) && (i < buf_len); j++, i += 4)
RTW_PRINT(" %02X %02X %02X %02X", buf[i], buf[i+1], buf[i+2], buf[i+3]);
RTW_PRINT("\n");
}
}
#ifdef CONFIG_PCI_HCI
void txsc_recycle_txreq_phyaddr(_adapter *padapter, struct rtw_xmit_req *txreq)
{
PPCI_DATA pci_data = dvobj_to_pci(padapter->dvobj);
struct pci_dev *pdev = pci_data->ppcidev;
struct rtw_pkt_buf_list *pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
dma_addr_t phy_addr = 0;
/* only recycle pkt_list[1] = skb->data for SW TXSC */
pkt_list++;
phy_addr = (pkt_list->phy_addr_l);
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
phy_addr |= ((u64)pkt_list->phy_addr_h << 32);
#endif
pci_unmap_bus_addr(pdev, &phy_addr, pkt_list->length, PCI_DMA_TODEVICE);
}
void txsc_fill_txreq_phyaddr(_adapter *padapter, struct rtw_pkt_buf_list *pkt_list)
{
PPCI_DATA pci_data = dvobj_to_pci(padapter->dvobj);
struct pci_dev *pdev = pci_data->ppcidev;
dma_addr_t phy_addr = 0;
pci_get_bus_addr(pdev, pkt_list->vir_addr, &phy_addr, pkt_list->length, PCI_DMA_TODEVICE);
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
pkt_list->phy_addr_h = phy_addr >> 32;
#else
pkt_list->phy_addr_h = 0x0;
#endif
pkt_list->phy_addr_l = phy_addr & 0xFFFFFFFF;
}
#endif
static void txsc_init_pkt_entry(_adapter *padapter, struct sk_buff *pskb, struct txsc_pkt_entry *txsc_pkt)
{
u8 priority = 0, i;
txsc_pkt->step = TXSC_NONE;
txsc_pkt->txsc_id = 0xff;
txsc_pkt->ptxreq = NULL;
for (i = 0; i < MAX_TXSC_SKB_NUM; i++)
txsc_pkt->xmit_skb[i] = NULL;
txsc_pkt->psta = NULL;
txsc_pkt->xmit_skb[0] = pskb;
txsc_pkt->skb_cnt = 1;
priority = *(pskb->data + ETH_HLEN + 1);
txsc_pkt->priority = tos_to_up(priority);
}
static void txsc_add_sc_check(_adapter *padapter, struct xmit_frame *pxframe, struct txsc_pkt_entry *txsc_pkt)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct pkt_attrib *pattrib = &pxframe->attrib;
struct sta_info *psta = pxframe->attrib.psta;
if (!pxmitpriv->txsc_enable) {
if (psta->txsc_cache_num > 0)
txsc_pkt->step = TXSC_SKIP;
else
txsc_pkt->step = TXSC_NONE;
goto exit;
}
if (pxframe->attrib.nr_frags > 1 || pxframe->attrib.bswenc == 1)
goto exit;
if (txsc_pkt->step != TXSC_NONE)
goto exit;
if (pattrib->qos_en &&
pattrib->ampdu_en == 1 &&
pattrib->ether_type == ETH_P_IP &&
!IS_MCAST(pattrib->ra) &&
!pattrib->icmp_pkt &&
!pattrib->dhcp_pkt) {
RTW_PRINT("[%s] sta[%02x] add eth_type=0x%x pkt to txsc\n",
__func__, pattrib->psta->phl_sta->mac_addr[5], pattrib->ether_type);
txsc_pkt->step = TXSC_ADD;
}
exit:
return;
}
static u8 txsc_get_sc_entry(_adapter *padapter, struct sk_buff *pskb, struct txsc_pkt_entry *txsc_pkt)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_info *psta = NULL;
u8 *ptxsc_ethdr = NULL;
u8 i, res, da[6], offset, res2 = 0, sta_hit = 0;
res = _FAIL;
offset = 6;
if (!pxmitpriv->txsc_enable)
return res;
if (pxmitpriv->ptxsc_sta_cached) {
if (pxmitpriv->ptxsc_sta_cached->phl_sta)
sta_hit = _rtw_memcmp(pxmitpriv->ptxsc_sta_cached->phl_sta->mac_addr, pskb->data, 6);
if (sta_hit)
psta = pxmitpriv->ptxsc_sta_cached;
}
if (!sta_hit) {
_rtw_memcpy(da, pskb->data, 6);
if (IS_MCAST(da)) {
res = _FAIL;
} else {
if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
psta = rtw_get_stainfo(pstapriv, da);
else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (!psta)
res = _FAIL;
}
}
if (!psta) {
res = _FAIL;
goto exit;
}
/* skip power saving mode */
if (psta->state & WIFI_SLEEP_STATE) {
res = _FAIL;
txsc_pkt->step = TXSC_SKIP;
psta->txsc_path_ps++;
goto exit;
}
if (psta->txsc_cache_num == 0) {
res = _FAIL;
goto exit;
}
pxmitpriv->ptxsc_sta_cached = psta;
txsc_pkt->step = TXSC_NONE;
ptxsc_ethdr = (u8 *)&psta->txsc_entry_cache[psta->txsc_cache_idx].txsc_ethdr;
res2 = _rtw_memcmp((pskb->data + offset), (ptxsc_ethdr + offset), (ETH_HLEN - offset));
if (res2 &&
(pskb->len <= psta->txsc_entry_cache[psta->txsc_cache_idx].txsc_frag_len)) {
txsc_pkt->step = TXSC_APPLY;
txsc_pkt->psta = psta;
txsc_pkt->txsc_id = psta->txsc_cache_idx;
res = _SUCCESS;
} else {
for (i = 0; i < CORE_TXSC_ENTRY_NUM; i++) {
if (i != psta->txsc_cache_idx && psta->txsc_entry_cache[i].txsc_is_used) {
ptxsc_ethdr = (u8 *)&(psta->txsc_entry_cache[i].txsc_ethdr);
if (_rtw_memcmp((pskb->data + offset), (ptxsc_ethdr + offset), (ETH_HLEN - offset)) &&
(pskb->len <= psta->txsc_entry_cache[i].txsc_frag_len)) {
txsc_pkt->step = TXSC_APPLY;
txsc_pkt->txsc_id = i;
txsc_pkt->psta = psta;
psta->txsc_cache_idx = i;
res = _SUCCESS;
break;
}
}
}
}
if ((res == _SUCCESS) && (pxmitpriv->txsc_debug_mode == 1)) {
txsc_pkt->step = TXSC_DEBUG;
res = _FAIL;
}
exit:
return res;
}
static void txsc_prepare_sc_entry(_adapter *padapter, struct xmit_frame *pxframe, struct txsc_pkt_entry *txsc_pkt)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct sta_info *psta = pxframe->attrib.psta;
struct pkt_attrib *pattrib = &pxframe->attrib;
struct rtw_xmit_req *txreq = pxframe->phl_txreq;
struct rtw_pkt_buf_list *pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
struct rtw_pkt_buf_list *ptxsc_pkt_list0 = NULL;
struct rtw_t_meta_data *ptxsc_mdata = NULL;
struct sk_buff *pskb = txsc_pkt->xmit_skb[0];
u8 i, idx;
u8 *ptxsc_ethdr = NULL;
u8 *ptxsc_wlhdr = NULL;
u8 *ptxsc_wlhdr_len = NULL;
if (!psta) {
RTW_ERR("%s: fetal err, XF_STA = NULL, please check.\n", __func__);
return;
}
if (txsc_pkt->step == TXSC_SKIP) {
if (pxmitpriv->txsc_enable && psta->txsc_cache_num > 0)
psta->txsc_cache_miss++;
else
psta->txsc_path_slow++;
} else if (txsc_pkt->step == TXSC_NONE) {
psta->txsc_path_slow++;
}
if (txsc_pkt->step != TXSC_ADD)
return;
idx = psta->txsc_cur_idx;
ptxsc_ethdr = (u8 *)&psta->txsc_entry_cache[idx].txsc_ethdr;
#ifdef USE_ONE_WLHDR
ptxsc_wlhdr = psta->txsc_entry_cache[idx].txsc_wlhdr;
#else
ptxsc_wlhdr = (u8 *)&psta->txsc_entry_cache[idx].txsc_wlhdr;
#endif
ptxsc_pkt_list0 = &psta->txsc_entry_cache[idx].txsc_pkt_list0;
ptxsc_mdata = &psta->txsc_entry_cache[idx].txsc_mdata;
ptxsc_wlhdr_len = &psta->txsc_entry_cache[idx].txsc_wlhdr_len;
_rtw_spinlock_bh(&pxmitpriv->txsc_lock);
if (psta->txsc_entry_cache[idx].txsc_is_used == 1)
RTW_PRINT("[CORE_TXSC] txsc entry is full, replace rentry[%d]\n", idx);
/* ALLOC WLHDR in DMA addr */
#ifdef USE_ONE_WLHDR
if (!ptxsc_wlhdr) {
ptxsc_wlhdr = rtw_zmalloc(CORE_TXSC_WLHDR_SIZE);
psta->txsc_entry_cache[idx].txsc_wlhdr = ptxsc_wlhdr;
}
#endif
/* ETH HDR */
_rtw_memcpy(ptxsc_ethdr, pskb->data, ETH_HLEN);
/* WLAN HDR + LLC */
_rtw_memcpy(ptxsc_wlhdr, pkt_list->vir_addr, pkt_list->length);
*ptxsc_wlhdr_len = pkt_list->length;
/* pkt_list[0] */
ptxsc_pkt_list0->vir_addr = ptxsc_wlhdr;
ptxsc_pkt_list0->length = pkt_list->length;
#ifdef CONFIG_PCI_HCI
txsc_fill_txreq_phyaddr(padapter, ptxsc_pkt_list0);
#endif
/* META DATA */
_rtw_memcpy(ptxsc_mdata, &txreq->mdata, sizeof(*ptxsc_mdata));
/* FRAGE_LEN */
psta->txsc_entry_cache[idx].txsc_frag_len = pxframe->attrib.frag_len_txsc;
psta->txsc_entry_cache[idx].txsc_is_used = 1;
psta->txsc_cache_idx = idx;
psta->txsc_cur_idx = (psta->txsc_cur_idx + 1) % CORE_TXSC_ENTRY_NUM;
if (psta->txsc_cache_num < CORE_TXSC_ENTRY_NUM)
psta->txsc_cache_num++;
psta->txsc_path_slow++;
pxmitpriv->ptxsc_sta_cached = psta;
txreq->treq_type = RTW_PHL_TREQ_TYPE_PHL_ADD_TXSC | RTW_PHL_TREQ_TYPE_PHL_UPDATE_TXSC;
/* set shortcut id */
txreq->shortcut_id = idx;
psta->txsc_entry_cache[idx].txsc_phl_id = idx;
/* disable phl txsc */
if (!(pxmitpriv->txsc_debug_mask&BIT1))
txreq->shortcut_id = 0;
RTW_PRINT("[CORE_TXSC][ADD] core_txsc_idx:%d(cur_idx:%d), txreq_sc_id:%d, txsc_frag_len:%d\n",
idx, psta->txsc_cur_idx, txreq->shortcut_id, psta->txsc_entry_cache[idx].txsc_frag_len);
/* for debug */
_print_txreq_mdata(ptxsc_mdata, __func__);
_rtw_spinunlock_bh(&pxmitpriv->txsc_lock);
}
u8 txsc_get_sc_cached_entry(_adapter *padapter, struct sk_buff *pskb, struct txsc_pkt_entry *txsc_pkt)
{
txsc_init_pkt_entry(padapter, pskb, txsc_pkt);
return txsc_get_sc_entry(padapter, pskb, txsc_pkt);
}
void txsc_add_sc_cache_entry(_adapter *padapter, struct xmit_frame *pxframe, struct txsc_pkt_entry *txsc_pkt)
{
txsc_add_sc_check(padapter, pxframe, txsc_pkt);
txsc_prepare_sc_entry(padapter, pxframe, txsc_pkt);
}
u8 txsc_apply_sc_cached_entry(_adapter *padapter, struct txsc_pkt_entry *txsc_pkt)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct rtw_pkt_buf_list *pkt_list = NULL;
struct rtw_pkt_buf_list *pkt_list0 = NULL;
struct rtw_t_meta_data *mdata = NULL;
struct rtw_xmit_req *txreq = NULL;
struct xmit_txreq_buf *txreq_buf = NULL;
struct txsc_entry *txsc;
struct sta_info *psta = txsc_pkt->psta;
struct sk_buff *xmit_skb[MAX_TXSC_SKB_NUM];
u8 *hdr = NULL;
u16 *qc;
int wlhdr_copy_len, payload_offset = ETH_HLEN;
u8 idx, priority = 0, res = _SUCCESS;
u8 i, skb_cnt = 0, is_hdr_need_update = 0, txsc_wlhdr_len;
#ifndef USE_ONE_WLHDR
u8 *head, *ptxsc_wlhdr;
#endif
if (!pxmitpriv->txsc_enable || !psta)
return _SUCCESS;
if (txsc_pkt->step != TXSC_APPLY &&
txsc_pkt->step != TXSC_AMSDU_APPLY &&
txsc_pkt->step != TXSC_DEBUG)
return _SUCCESS;
_rtw_memset(xmit_skb, 0x0, sizeof(xmit_skb));
/* get cached entry */
idx = txsc_pkt->txsc_id;
txsc = &psta->txsc_entry_cache[idx];
pkt_list0 = &txsc->txsc_pkt_list0;
mdata = &txsc->txsc_mdata;
#ifdef USE_ONE_WLHDR
txsc_wlhdr_len = pkt_list0->length;
#else
ptxsc_wlhdr = (u8 *)txsc->txsc_wlhdr;
txsc_wlhdr_len = txsc->txsc_wlhdr_len;
#endif
if (txsc_pkt->step == TXSC_DEBUG) {
_rtw_memset(psta->debug_buf, 0x0, (sizeof(struct rtw_xmit_req)+sizeof(struct rtw_pkt_buf_list)*2));
txreq = (struct rtw_xmit_req *)psta->debug_buf;
pkt_list = (struct rtw_pkt_buf_list *)psta->debug_buf + sizeof(struct rtw_xmit_req);
} else {
#ifdef USE_ONE_WLHDR
txreq_buf = (struct xmit_txreq_buf *)get_txreq_buffer(padapter, (u8 **)&txreq, (u8 **)&pkt_list, NULL, NULL);
#else
txreq_buf = (struct xmit_txreq_buf *)get_txreq_buffer(padapter, (u8 **)&txreq, (u8 **)&pkt_list, (u8 **)&head, NULL);
#endif
if (txreq_buf == NULL) {
res = _FAIL;
goto exit;
}
}
/* init txreq buf */
txreq_buf->adapter = padapter;
/* fill txreq other */
txreq->os_priv = (void *)txreq_buf;
txreq->pkt_list = (u8 *)pkt_list;
txreq->pkt_cnt = 0;
txreq->total_len = 0;
/* fill txsc pkt entry */
txsc_pkt->ptxreq = txreq;
{
/* for no tx_amsdu case */
xmit_skb[0] = txsc_pkt->xmit_skb[0];
skb_cnt = txsc_pkt->skb_cnt;
}
if (skb_cnt == 0)
RTW_PRINT("[ERR][%s:%d] skb_cnt = 0 is a fatel error, plz check\n", __func__, __LINE__);
/* fill_txreq_mdata */
_rtw_memcpy(&txreq->mdata, mdata, sizeof(txreq->mdata));
/* Update TID from IP header */
/* priority = *(xmit_skb[0]->data + ETH_HLEN + 1); */
/*txreq->mdata.tid = tos_to_up(priority); */
priority = txreq->mdata.tid = txsc_pkt->priority;
/* SW shortcut --- */
/* rtw_core_wlan_fill_head */
/* use swseq in amsdu */
if (txreq->mdata.hw_seq_mode == 0) {
/* generate sw seq */
//priority = txreq->mdata.tid;
psta->sta_xmitpriv.txseq_tid[priority]++;
psta->sta_xmitpriv.txseq_tid[priority] &= 0xFFF;
txreq->mdata.sw_seq = psta->sta_xmitpriv.txseq_tid[priority];
hdr = txsc->txsc_wlhdr;
SetSeqNum(hdr, txreq->mdata.sw_seq);
is_hdr_need_update = 1;
}
wlhdr_copy_len = txsc_wlhdr_len;
/* WLAN header from cache */
#ifdef USE_ONE_WLHDR
_rtw_memcpy(pkt_list, pkt_list0, sizeof(struct rtw_pkt_buf_list));
#else
#ifdef USE_PREV_WLHDR_BUF
if (txreq_buf->macid == txreq->mdata.macid && txreq_buf->txsc_id == idx) {
if (is_hdr_need_update)
SetSeqNum(head, txreq->mdata.sw_seq);/* set sw seq */
} else
#endif /* USE_PREV_WLHDR_BUF */
{
_rtw_memcpy(head, ptxsc_wlhdr, wlhdr_copy_len);
}
/* fill wlhdr in pkt_list[0] */
pkt_list->vir_addr = head;
pkt_list->length = wlhdr_copy_len;
#ifdef CONFIG_PCI_HCI
txsc_fill_txreq_phyaddr(padapter, pkt_list);
#endif
#endif/* USE_ONE_WLHDR */
txreq->total_len += pkt_list->length;
txreq->pkt_cnt++;
#ifdef USE_PREV_WLHDR_BUF
txreq_buf->macid = txreq->mdata.macid;
txreq_buf->txsc_id = idx;
#endif/* USE_PREV_WLHDR_BUF */
/* Payload w.o. ether header */ /* CONFIG_TXSC_AMSDU for multiple skb */
for (i = 0; i < skb_cnt; i++) {
pkt_list++;
pkt_list->vir_addr = xmit_skb[i]->data + payload_offset;
pkt_list->length = xmit_skb[i]->len - payload_offset;
txreq->total_len += pkt_list->length;
txreq->pkt_cnt++;
#ifdef CONFIG_PCI_HCI
txsc_fill_txreq_phyaddr(padapter, pkt_list);
#endif
txreq_buf->pkt[i] = (u8 *)xmit_skb[i];
}
txreq->treq_type = RTW_PHL_TREQ_TYPE_CORE_TXSC;
if (txsc_pkt->step == TXSC_APPLY) {
psta->txsc_cache_hit++;
txsc->txsc_cache_hit++;
} else
psta->txsc_path_slow++;
/* SW shortcut --- */
txreq_buf->pkt_cnt = skb_cnt;/* for recycle multiple skb */
txreq->mdata.pktlen = txreq->total_len;
txreq->shortcut_id = psta->txsc_entry_cache[idx].txsc_phl_id;
if (!(pxmitpriv->txsc_debug_mask&BIT1))
txreq->shortcut_id = 0;
/* send addbareq */
txsc_issue_addbareq_cmd(padapter, priority, psta, _TRUE);
#ifdef RTW_PHL_DBG_CMD
/* Update force rate settings so force rate takes effects
* after shortcut cached
*/
if (padapter->txForce_enable) {
if (padapter->txForce_rate != INV_TXFORCE_VAL) {
txreq->mdata.f_rate = padapter->txForce_rate;
txreq->mdata.userate_sel = 1;
txreq->mdata.dis_data_rate_fb = 1;
txreq->mdata.dis_rts_rate_fb = 1;
}
if (padapter->txForce_agg != INV_TXFORCE_VAL)
txreq->mdata.ampdu_en = padapter->txForce_agg;
if (padapter->txForce_aggnum != INV_TXFORCE_VAL)
txreq->mdata.max_agg_num = padapter->txForce_aggnum;
if (padapter->txForce_gi != INV_TXFORCE_VAL)
txreq->mdata.f_gi_ltf = padapter->txForce_gi;
if (padapter->txForce_ampdu_density != INV_TXFORCE_VAL)
txreq->mdata.ampdu_density = padapter->txForce_ampdu_density;
if (padapter->txForce_bw != INV_TXFORCE_VAL)
txreq->mdata.f_bw = padapter->txForce_bw;
}
#endif /* RTW_PHL_DBG_CMD */
/* for tx debug */
_print_txreq_mdata(&txreq->mdata, __func__);
_print_txreq_pklist(NULL, txsc_pkt->ptxreq, xmit_skb[0], __func__);
exit:
return res;
}
void txsc_free_txreq(_adapter *padapter, struct rtw_xmit_req *txreq)
{
struct xmit_txreq_buf *ptxreq_buf = NULL;
struct sk_buff *tx_skb = NULL;
_queue *queue = NULL;
u8 i;
if (txreq != NULL)
ptxreq_buf = txreq->os_priv;
else
return;
#ifdef CONFIG_PCI_HCI
#ifdef USE_ONE_WLHDR
txsc_recycle_txreq_phyaddr(padapter, txreq);
#else
core_recycle_txreq_phyaddr(padapter, txreq);
#endif
#endif
if (!ptxreq_buf) {
RTW_ERR("%s: NULL ptxreq_buf !!\n", __func__);
rtw_warn_on(1);
return;
}
queue = &padapter->free_txreq_queue;
_rtw_spinlock_bh(&queue->lock);
rtw_list_delete(&ptxreq_buf->list);
rtw_list_insert_tail(&ptxreq_buf->list, get_list_head(queue));
txreq->os_priv = NULL;
txreq->pkt_list = NULL;
txreq->treq_type = RTW_PHL_TREQ_TYPE_NORMAL;
/* this must be protected in spinlock section */
if (ptxreq_buf->pkt_cnt == 0)
RTW_PRINT("[ERR][%s:%d] pkt_cnt = 0 is a fatel error, plz check\n", __func__, __LINE__);
for (i = 0; i < ptxreq_buf->pkt_cnt; i++) {
tx_skb = (struct sk_buff *)ptxreq_buf->pkt[i];
if (tx_skb)
rtw_os_pkt_complete(padapter, tx_skb);
else
RTW_DBG("%s:tx recyele: tx_skb=NULL\n", __func__);
ptxreq_buf->pkt[i] = NULL;
}
padapter->free_txreq_cnt++;
_rtw_spinunlock_bh(&queue->lock);
}
void txsc_debug_sc_entry(_adapter *padapter, struct xmit_frame *pxframe, struct txsc_pkt_entry *txsc_pkt)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct rtw_pkt_buf_list *pkt_list = NULL;
struct rtw_pkt_buf_list *txsc_pkt_list = NULL;
struct rtw_xmit_req *txreq = pxframe->phl_txreq;
struct rtw_xmit_req *ptxsc_txreq = txsc_pkt->ptxreq;
u8 i;
if (txsc_pkt->step != TXSC_DEBUG)
return;
if (pxmitpriv->txsc_debug_mask&BIT2) {
RTW_PRINT("\n\nNormal Path TXREQ: %p\n\n", txreq);
txsc_dump_data((u8 *)txreq, sizeof(struct rtw_xmit_req), "txreq:");
RTW_PRINT("os_priv=%p\n", txreq->os_priv);
RTW_PRINT("treq_type=%d shortcut_id=%d\n", txreq->treq_type, txreq->shortcut_id);
RTW_PRINT("total_len=%d pkt_cnt=%d\n", txreq->total_len, txreq->pkt_cnt);
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
for (i = 0; i < txreq->pkt_cnt; i++) {
RTW_PRINT("[%d]", i);
txsc_dump_data((u8 *)pkt_list, sizeof(struct rtw_pkt_buf_list), "pklist");
txsc_dump_data((u8 *)pkt_list->vir_addr, pkt_list->length, "pkt_list->vir_addr");
pkt_list++;
}
RTW_PRINT("mdata: pktlen=%d sw_seq=%d\n", txreq->mdata.pktlen, txreq->mdata.sw_seq);
RTW_PRINT("\n\nShortcut Path TXREQ: %p\n\n", ptxsc_txreq);
txsc_dump_data((u8 *)ptxsc_txreq, sizeof(struct rtw_xmit_req), "ptxsc_txreq:");
RTW_PRINT("os_priv=%p\n", ptxsc_txreq->os_priv);
RTW_PRINT("treq_type=%d shortcut_id=%d\n", ptxsc_txreq->treq_type, ptxsc_txreq->shortcut_id);
RTW_PRINT("total_len=%d pkt_cnt=%d\n", ptxsc_txreq->total_len, ptxsc_txreq->pkt_cnt);
txsc_pkt_list = (struct rtw_pkt_buf_list *)ptxsc_txreq->pkt_list;
for (i = 0; i < txreq->pkt_cnt; i++) {
RTW_PRINT("[%d]", i);
txsc_dump_data((u8 *)txsc_pkt_list, sizeof(struct rtw_pkt_buf_list), "pklist");
txsc_dump_data((u8 *)txsc_pkt_list->vir_addr, txsc_pkt_list->length, "pkt_list->vir_addr");
txsc_pkt_list++;
}
RTW_PRINT("mdata: pktlen=%d sw_seq=%d\n", ptxsc_txreq->mdata.pktlen, ptxsc_txreq->mdata.sw_seq);
} else {
if (!_rtw_memcmp(&txreq->mdata, &ptxsc_txreq->mdata, sizeof(struct rtw_t_meta_data))) {
txsc_dump_data((u8 *)&txreq->mdata, sizeof(struct rtw_t_meta_data), "txreq->mdata");
txsc_dump_data((u8 *)&ptxsc_txreq->mdata, sizeof(struct rtw_t_meta_data), "ptxsc_txreq->mdata");
}
pkt_list = (struct rtw_pkt_buf_list *)txreq->pkt_list;
txsc_pkt_list = (struct rtw_pkt_buf_list *)ptxsc_txreq->pkt_list;
if (pkt_list->length != txsc_pkt_list->length) {
txsc_dump_data((u8 *)pkt_list, sizeof(struct rtw_pkt_buf_list), "pkt_list[0]");
txsc_dump_data((u8 *)txsc_pkt_list, sizeof(struct rtw_pkt_buf_list), "txsc_pkt_list[0]");
txsc_dump_data((u8 *)pkt_list->vir_addr, pkt_list->length, "pkt_list[0]->vir_addr");
txsc_dump_data(txsc_pkt_list->vir_addr, pkt_list->length, "txsc_pkt_list[0]->vir_addr");
} else if (pkt_list->length == txsc_pkt_list->length) {
if (!_rtw_memcmp(pkt_list->vir_addr, txsc_pkt_list->vir_addr, pkt_list->length)) {
txsc_dump_data((u8 *)pkt_list->vir_addr, pkt_list->length, "pkt_list[0]->vir_addr");
txsc_dump_data((u8 *)txsc_pkt_list->vir_addr, pkt_list->length, "txsc_pkt_list[0]->vir_addr");
}
}
}
/* DO NOT WD CACHE */
txreq->shortcut_id = 0;
txreq->treq_type = RTW_PHL_TREQ_TYPE_NORMAL;
}
#ifdef CONFIG_80211N_HT
static u8 txsc_issue_addbareq_check(_adapter *padapter, u8 issue_when_busy)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct registry_priv *pregistry = &padapter->registrypriv;
if (pregistry->tx_quick_addba_req == 0) {
if ((issue_when_busy == _TRUE) && (pmlmepriv->LinkDetectInfo.bBusyTraffic == _FALSE))
return _FALSE;
if (pmlmepriv->LinkDetectInfo.NumTxOkInPeriod < 100)
return _FALSE;
}
return _TRUE;
}
void txsc_issue_addbareq_cmd(_adapter *padapter, u8 priority, struct sta_info *psta, u8 issue_when_busy)
{
u8 issued;
struct ht_priv *phtpriv;
if (txsc_issue_addbareq_check(padapter, issue_when_busy) == _FALSE)
return;
phtpriv = &psta->htpriv;
if ((phtpriv->ht_option == _TRUE) && (phtpriv->ampdu_enable == _TRUE)) {
issued = (phtpriv->agg_enable_bitmap >> priority) & 0x1;
issued |= (phtpriv->candidate_tid_bitmap >> priority) & 0x1;
if (issued == 0) {
RTW_INFO("rtw_issue_addbareq_cmd, p=%d\n", priority);
psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
rtw_addbareq_cmd(padapter, (u8) priority, psta->phl_sta->mac_addr);
}
}
}
#endif /* CONFIG_80211N_HT */
#endif /* CONFIG_CORE_TXSC */
|
2301_81045437/rtl8852be
|
core/rtw_xmit_shortcut.c
|
C
|
agpl-3.0
| 28,492
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#define _RTW_WDS_C_
#include <drv_types.h>
#if defined(CONFIG_RTW_WDS)
#include <linux/jhash.h>
#if defined(CONFIG_AP_MODE)
#ifdef PLATFORM_LINUX
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0))
static void rtw_wpath_free_rcu(struct rtw_wds_path *wpath)
{
kfree_rcu(wpath, rcu);
rtw_mstat_update(MSTAT_TYPE_PHY, MSTAT_FREE, sizeof(struct rtw_wds_path));
}
#else
static void rtw_wpath_free_rcu_callback(rtw_rcu_head *head)
{
struct rtw_wds_path *wpath;
wpath = container_of(head, struct rtw_wds_path, rcu);
rtw_mfree(wpath, sizeof(struct rtw_wds_path));
}
static void rtw_wpath_free_rcu(struct rtw_wds_path *wpath)
{
call_rcu(&wpath->rcu, rtw_wpath_free_rcu_callback);
}
#endif
#endif /* PLATFORM_LINUX */
static void rtw_wds_path_free_rcu(struct rtw_wds_table *tbl, struct rtw_wds_path *wpath);
static u32 rtw_wds_table_hash(const void *addr, u32 len, u32 seed)
{
/* Use last four bytes of hw addr as hash index */
return jhash_1word(*(u32 *)(addr+2), seed);
}
static const rtw_rhashtable_params rtw_wds_rht_params = {
.nelem_hint = 2,
.automatic_shrinking = true,
.key_len = ETH_ALEN,
.key_offset = offsetof(struct rtw_wds_path, dst),
.head_offset = offsetof(struct rtw_wds_path, rhash),
.hashfn = rtw_wds_table_hash,
};
static void rtw_wds_path_rht_free(void *ptr, void *tblptr)
{
struct rtw_wds_path *wpath = ptr;
struct rtw_wds_table *tbl = tblptr;
rtw_wds_path_free_rcu(tbl, wpath);
}
static struct rtw_wds_table *rtw_wds_table_alloc(void)
{
struct rtw_wds_table *newtbl;
newtbl = rtw_malloc(sizeof(struct rtw_wds_table));
if (!newtbl)
return NULL;
return newtbl;
}
static void rtw_wds_table_free(struct rtw_wds_table *tbl)
{
rtw_rhashtable_free_and_destroy(&tbl->rhead,
rtw_wds_path_rht_free, tbl);
rtw_mfree(tbl, sizeof(struct rtw_wds_table));
}
void rtw_wds_path_assign_nexthop(struct rtw_wds_path *wpath, struct sta_info *sta)
{
rtw_rcu_assign_pointer(wpath->next_hop, sta);
}
static struct rtw_wds_path *rtw_wpath_lookup(struct rtw_wds_table *tbl, const u8 *dst)
{
struct rtw_wds_path *wpath;
if (!tbl)
return NULL;
wpath = rtw_rhashtable_lookup_fast(&tbl->rhead, dst, rtw_wds_rht_params);
return wpath;
}
struct rtw_wds_path *rtw_wds_path_lookup(_adapter *adapter, const u8 *dst)
{
return rtw_wpath_lookup(adapter->wds_paths, dst);
}
static struct rtw_wds_path *
__rtw_wds_path_lookup_by_idx(struct rtw_wds_table *tbl, int idx)
{
int i = 0, ret;
struct rtw_wds_path *wpath = NULL;
rtw_rhashtable_iter iter;
if (!tbl)
return NULL;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return NULL;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto err;
while ((wpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(wpath) && PTR_ERR(wpath) == -EAGAIN)
continue;
if (IS_ERR(wpath))
break;
if (i++ == idx)
break;
}
err:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
if (IS_ERR(wpath) || !wpath)
return NULL;
return wpath;
}
/**
* Locking: must be called within a read rcu section.
*/
struct rtw_wds_path *
rtw_wds_path_lookup_by_idx(_adapter *adapter, int idx)
{
return __rtw_wds_path_lookup_by_idx(adapter->wds_paths, idx);
}
void dump_wpath(void *sel, _adapter *adapter)
{
struct rtw_wds_path *wpath;
int idx = 0;
char dst[ETH_ALEN];
char next_hop[ETH_ALEN];
u32 age_ms;
RTW_PRINT_SEL(sel, "num:%d\n", ATOMIC_READ(&adapter->wds_path_num));
RTW_PRINT_SEL(sel, "%-17s %-17s %-6s\n"
, "dst", "next_hop", "age"
);
do {
rtw_rcu_read_lock();
wpath = rtw_wds_path_lookup_by_idx(adapter, idx);
if (wpath) {
_rtw_memcpy(dst, wpath->dst, ETH_ALEN);
_rtw_memcpy(next_hop, wpath->next_hop->phl_sta->mac_addr, ETH_ALEN);
age_ms = rtw_get_passing_time_ms(wpath->last_update);
}
rtw_rcu_read_unlock();
if (wpath) {
RTW_PRINT_SEL(sel, MAC_FMT" "MAC_FMT" %6u\n"
, MAC_ARG(dst), MAC_ARG(next_hop)
, age_ms < 999999 ? age_ms : 999999
);
}
idx++;
} while (wpath);
}
static
struct rtw_wds_path *rtw_wds_path_new(_adapter *adapter,
const u8 *dst)
{
struct rtw_wds_path *new_wpath;
new_wpath = rtw_zmalloc(sizeof(struct rtw_wds_path));
if (!new_wpath)
return NULL;
new_wpath->adapter = adapter;
_rtw_memcpy(new_wpath->dst, dst, ETH_ALEN);
new_wpath->last_update = rtw_get_current_time();
return new_wpath;
}
/**
* Returns: 0 on success
*
* State: the initial state of the new path is set to 0
*/
struct rtw_wds_path *rtw_wds_path_add(_adapter *adapter,
const u8 *dst, struct sta_info *next_hop)
{
struct rtw_wds_table *tbl = adapter->wds_paths;
struct rtw_wds_path *wpath, *new_wpath;
int ret;
if (!tbl)
return ERR_PTR(-ENOTSUPP);
if (_rtw_memcmp(dst, adapter_mac_addr(adapter), ETH_ALEN) == _TRUE)
/* never add ourselves as neighbours */
return ERR_PTR(-ENOTSUPP);
if (IS_MCAST(dst))
return ERR_PTR(-ENOTSUPP);
if (ATOMIC_INC_UNLESS(&adapter->wds_path_num, RTW_WDS_MAX_PATHS) == 0)
return ERR_PTR(-ENOSPC);
new_wpath = rtw_wds_path_new(adapter, dst);
if (!new_wpath)
return ERR_PTR(-ENOMEM);
do {
ret = rtw_rhashtable_lookup_insert_fast(&tbl->rhead,
&new_wpath->rhash,
rtw_wds_rht_params);
if (ret == -EEXIST)
wpath = rtw_rhashtable_lookup_fast(&tbl->rhead,
dst,
rtw_wds_rht_params);
} while (unlikely(ret == -EEXIST && !wpath));
if (ret && ret != -EEXIST)
return ERR_PTR(ret);
/* At this point either new_wpath was added, or we found a
* matching entry already in the table; in the latter case
* free the unnecessary new entry.
*/
if (ret == -EEXIST) {
rtw_mfree(new_wpath, sizeof(struct rtw_wds_path));
new_wpath = wpath;
}
rtw_wds_path_assign_nexthop(new_wpath, next_hop);
return new_wpath;
}
static void rtw_wds_path_free_rcu(struct rtw_wds_table *tbl,
struct rtw_wds_path *wpath)
{
_adapter *adapter = wpath->adapter;
ATOMIC_DEC(&adapter->wds_path_num);
rtw_wpath_free_rcu(wpath);
}
static void __rtw_wds_path_del(struct rtw_wds_table *tbl, struct rtw_wds_path *wpath)
{
rtw_rhashtable_remove_fast(&tbl->rhead, &wpath->rhash, rtw_wds_rht_params);
rtw_wds_path_free_rcu(tbl, wpath);
}
void rtw_wds_path_flush_by_nexthop(struct sta_info *sta)
{
_adapter *adapter = sta->padapter;
struct rtw_wds_table *tbl = adapter->wds_paths;
struct rtw_wds_path *wpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((wpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(wpath) && PTR_ERR(wpath) == -EAGAIN)
continue;
if (IS_ERR(wpath))
break;
if (rtw_rcu_access_pointer(wpath->next_hop) == sta)
__rtw_wds_path_del(tbl, wpath);
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
static void rtw_wds_table_flush_by_iface(struct rtw_wds_table *tbl)
{
struct rtw_wds_path *wpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((wpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(wpath) && PTR_ERR(wpath) == -EAGAIN)
continue;
if (IS_ERR(wpath))
break;
__rtw_wds_path_del(tbl, wpath);
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
void rtw_wds_path_flush_by_iface(_adapter *adapter)
{
rtw_wds_table_flush_by_iface(adapter->wds_paths);
}
static int rtw_wds_table_path_del(struct rtw_wds_table *tbl,
const u8 *addr)
{
struct rtw_wds_path *wpath;
if (!tbl)
return -ENXIO;
rtw_rcu_read_lock();
wpath = rtw_rhashtable_lookup_fast(&tbl->rhead, addr, rtw_wds_rht_params);
if (!wpath) {
rtw_rcu_read_unlock();
return -ENXIO;
}
__rtw_wds_path_del(tbl, wpath);
rtw_rcu_read_unlock();
return 0;
}
int rtw_wds_path_del(_adapter *adapter, const u8 *addr)
{
int err;
err = rtw_wds_table_path_del(adapter->wds_paths, addr);
return err;
}
int rtw_wds_pathtbl_init(_adapter *adapter)
{
struct rtw_wds_table *tbl_path;
int ret;
tbl_path = rtw_wds_table_alloc();
if (!tbl_path)
return -ENOMEM;
rtw_rhashtable_init(&tbl_path->rhead, &rtw_wds_rht_params);
ATOMIC_SET(&adapter->wds_path_num, 0);
adapter->wds_paths = tbl_path;
return 0;
}
static
void rtw_wds_path_tbl_expire(_adapter *adapter,
struct rtw_wds_table *tbl)
{
struct rtw_wds_path *wpath;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((wpath = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(wpath) && PTR_ERR(wpath) == -EAGAIN)
continue;
if (IS_ERR(wpath))
break;
if (rtw_time_after(rtw_get_current_time(), wpath->last_update + RTW_WDS_PATH_EXPIRE))
__rtw_wds_path_del(tbl, wpath);
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
void rtw_wds_path_expire(_adapter *adapter)
{
rtw_wds_path_tbl_expire(adapter, adapter->wds_paths);
}
void rtw_wds_pathtbl_unregister(_adapter *adapter)
{
if (adapter->wds_paths) {
rtw_wds_table_free(adapter->wds_paths);
adapter->wds_paths = NULL;
}
}
int rtw_wds_nexthop_lookup(_adapter *adapter, const u8 *da, u8 *ra)
{
struct rtw_wds_path *wpath;
struct sta_info *next_hop;
int err = -ENOENT;
rtw_rcu_read_lock();
wpath = rtw_wds_path_lookup(adapter, da);
if (!wpath)
goto endlookup;
next_hop = rtw_rcu_dereference(wpath->next_hop);
if (next_hop) {
_rtw_memcpy(ra, next_hop->phl_sta->mac_addr, ETH_ALEN);
err = 0;
}
endlookup:
rtw_rcu_read_unlock();
return err;
}
#endif /* defined(CONFIG_AP_MODE) */
/* WDS group adddressed proxy TX record */
struct rtw_wds_gptr {
u8 src[ETH_ALEN];
systime last_update;
rtw_rhash_head rhash;
_adapter *adapter;
rtw_rcu_head rcu;
};
#define RTW_WDS_GPTR_EXPIRE (2 * HZ)
/* Maximum number of gptrs per interface */
#define RTW_WDS_MAX_GPTRS 1024
#ifdef PLATFORM_LINUX
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 0))
static void rtw_wgptr_free_rcu(struct rtw_wds_gptr *wgptr)
{
kfree_rcu(wgptr, rcu);
rtw_mstat_update(MSTAT_TYPE_PHY, MSTAT_FREE, sizeof(struct rtw_wds_gptr));
}
#else
static void rtw_wgptr_free_rcu_callback(rtw_rcu_head *head)
{
struct rtw_wds_gptr *wgptr;
wgptr = container_of(head, struct rtw_wds_gptr, rcu);
rtw_mfree(wgptr, sizeof(struct rtw_wds_gptr));
}
static void rtw_wgptr_free_rcu(struct rtw_wds_gptr *wgptr)
{
call_rcu(&wgptr->rcu, rtw_wgptr_free_rcu_callback);
}
#endif
#endif /* PLATFORM_LINUX */
static void rtw_wds_gptr_free_rcu(struct rtw_wds_gptr_table *tbl, struct rtw_wds_gptr *wgptr)
{
_adapter *adapter = wgptr->adapter;
ATOMIC_DEC(&adapter->wds_gpt_record_num);
rtw_wgptr_free_rcu(wgptr);
}
static u32 rtw_wds_gptr_table_hash(const void *addr, u32 len, u32 seed)
{
/* Use last four bytes of hw addr as hash index */
return jhash_1word(*(u32 *)(addr+2), seed);
}
static const rtw_rhashtable_params rtw_wds_gptr_rht_params = {
.nelem_hint = 2,
.automatic_shrinking = true,
.key_len = ETH_ALEN,
.key_offset = offsetof(struct rtw_wds_gptr, src),
.head_offset = offsetof(struct rtw_wds_gptr, rhash),
.hashfn = rtw_wds_gptr_table_hash,
};
static void rtw_wds_gptr_rht_free(void *ptr, void *tblptr)
{
struct rtw_wds_gptr *wgptr = ptr;
struct rtw_wds_gptr_table *tbl = tblptr;
rtw_wds_gptr_free_rcu(tbl, wgptr);
}
static struct rtw_wds_gptr_table *rtw_wds_gptr_table_alloc(void)
{
struct rtw_wds_gptr_table *newtbl;
newtbl = rtw_malloc(sizeof(struct rtw_wds_gptr_table));
if (!newtbl)
return NULL;
return newtbl;
}
static void rtw_wds_gptr_table_free(struct rtw_wds_gptr_table *tbl)
{
rtw_rhashtable_free_and_destroy(&tbl->rhead,
rtw_wds_gptr_rht_free, tbl);
rtw_mfree(tbl, sizeof(struct rtw_wds_gptr_table));
}
static struct rtw_wds_gptr *rtw_wds_gptr_lookup(_adapter *adapter, const u8 *src)
{
struct rtw_wds_gptr_table *tbl = adapter->wds_gpt_records;
if (!tbl)
return NULL;
return rtw_rhashtable_lookup_fast(&tbl->rhead, src, rtw_wds_gptr_rht_params);
}
/**
* Locking: must be called within a read rcu section.
*/
static struct rtw_wds_gptr *rtw_wds_gptr_lookup_by_idx(_adapter *adapter, int idx)
{
int i = 0, ret;
struct rtw_wds_gptr_table *tbl = adapter->wds_gpt_records;
struct rtw_wds_gptr *wgptr = NULL;
rtw_rhashtable_iter iter;
if (!tbl)
return NULL;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return NULL;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto err;
while ((wgptr = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(wgptr) && PTR_ERR(wgptr) == -EAGAIN)
continue;
if (IS_ERR(wgptr))
break;
if (i++ == idx)
break;
}
err:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
if (IS_ERR(wgptr) || !wgptr)
return NULL;
return wgptr;
}
void dump_wgptr(void *sel, _adapter *adapter)
{
struct rtw_wds_gptr *wgptr;
int idx = 0;
char src[ETH_ALEN];
u32 age_ms;
RTW_PRINT_SEL(sel, "num:%d\n", ATOMIC_READ(&adapter->wds_gpt_record_num));
RTW_PRINT_SEL(sel, "%-17s %-6s\n"
, "src", "age"
);
do {
rtw_rcu_read_lock();
wgptr = rtw_wds_gptr_lookup_by_idx(adapter, idx);
if (wgptr) {
_rtw_memcpy(src, wgptr->src, ETH_ALEN);
age_ms = rtw_get_passing_time_ms(wgptr->last_update);
}
rtw_rcu_read_unlock();
if (wgptr) {
RTW_PRINT_SEL(sel, MAC_FMT" %6u\n"
, MAC_ARG(src)
, age_ms < 999999 ? age_ms : 999999
);
}
idx++;
} while (wgptr);
}
static struct rtw_wds_gptr *rtw_wds_gptr_new(_adapter *adapter, const u8 *src)
{
struct rtw_wds_gptr *new_wgptr;
new_wgptr = rtw_zmalloc(sizeof(struct rtw_wds_gptr));
if (!new_wgptr)
return NULL;
new_wgptr->adapter = adapter;
_rtw_memcpy(new_wgptr->src, src, ETH_ALEN);
new_wgptr->last_update = rtw_get_current_time();
return new_wgptr;
}
static struct rtw_wds_gptr *rtw_wds_gptr_add(_adapter *adapter, const u8 *src)
{
struct rtw_wds_gptr_table *tbl = adapter->wds_gpt_records;
struct rtw_wds_gptr *wgptr, *new_wgptr;
int ret;
if (!tbl)
return ERR_PTR(-ENOTSUPP);
if (ATOMIC_INC_UNLESS(&adapter->wds_gpt_record_num, RTW_WDS_MAX_PATHS) == 0)
return ERR_PTR(-ENOSPC);
new_wgptr = rtw_wds_gptr_new(adapter, src);
if (!new_wgptr)
return ERR_PTR(-ENOMEM);
do {
ret = rtw_rhashtable_lookup_insert_fast(&tbl->rhead,
&new_wgptr->rhash,
rtw_wds_gptr_rht_params);
if (ret == -EEXIST)
wgptr = rtw_rhashtable_lookup_fast(&tbl->rhead,
src,
rtw_wds_gptr_rht_params);
} while (unlikely(ret == -EEXIST && !wgptr));
if (ret && ret != -EEXIST)
return ERR_PTR(ret);
/* At this point either new_wgptr was added, or we found a
* matching entry already in the table; in the latter case
* free the unnecessary new entry.
*/
if (ret == -EEXIST) {
rtw_mfree(new_wgptr, sizeof(struct rtw_wds_gptr));
new_wgptr = wgptr;
}
return new_wgptr;
}
bool rtw_rx_wds_gptr_check(_adapter *adapter, const u8 *src)
{
struct rtw_wds_gptr *wgptr;
bool ret = 0;
rtw_rcu_read_lock();
wgptr = rtw_wds_gptr_lookup(adapter, src);
if (wgptr)
ret = rtw_time_after(wgptr->last_update + RTW_WDS_GPTR_EXPIRE, rtw_get_current_time());
rtw_rcu_read_unlock();
return ret;
}
void rtw_tx_wds_gptr_update(_adapter *adapter, const u8 *src)
{
struct rtw_wds_gptr *wgptr;
rtw_rcu_read_lock();
wgptr = rtw_wds_gptr_lookup(adapter, src);
if (!wgptr)
rtw_wds_gptr_add(adapter, src);
else
wgptr->last_update = rtw_get_current_time();
rtw_rcu_read_unlock();
}
static void __rtw_wds_gptr_del(struct rtw_wds_gptr_table *tbl, struct rtw_wds_gptr *wgptr)
{
rtw_rhashtable_remove_fast(&tbl->rhead, &wgptr->rhash, rtw_wds_gptr_rht_params);
rtw_wds_gptr_free_rcu(tbl, wgptr);
}
void rtw_wds_gptr_expire(_adapter *adapter)
{
struct rtw_wds_gptr_table *tbl = adapter->wds_gpt_records;
struct rtw_wds_gptr *wgptr;
rtw_rhashtable_iter iter;
int ret;
if (!tbl)
return;
ret = rtw_rhashtable_walk_enter(&tbl->rhead, &iter);
if (ret)
return;
ret = rtw_rhashtable_walk_start(&iter);
if (ret && ret != -EAGAIN)
goto out;
while ((wgptr = rtw_rhashtable_walk_next(&iter))) {
if (IS_ERR(wgptr) && PTR_ERR(wgptr) == -EAGAIN)
continue;
if (IS_ERR(wgptr))
break;
if (rtw_time_after(rtw_get_current_time(), wgptr->last_update + RTW_WDS_GPTR_EXPIRE))
__rtw_wds_gptr_del(tbl, wgptr);
}
out:
rtw_rhashtable_walk_stop(&iter);
rtw_rhashtable_walk_exit(&iter);
}
int rtw_wds_gptr_tbl_init(_adapter *adapter)
{
struct rtw_wds_gptr_table *tbl;
int ret;
tbl = rtw_wds_gptr_table_alloc();
if (!tbl)
return -ENOMEM;
rtw_rhashtable_init(&tbl->rhead, &rtw_wds_gptr_rht_params);
ATOMIC_SET(&adapter->wds_gpt_record_num, 0);
adapter->wds_gpt_records = tbl;
return 0;
}
void rtw_wds_gptr_tbl_unregister(_adapter *adapter)
{
if (adapter->wds_gpt_records) {
rtw_wds_gptr_table_free(adapter->wds_gpt_records);
adapter->wds_gpt_records = NULL;
}
}
#endif /* defined(CONFIG_RTW_WDS) */
|
2301_81045437/rtl8852be
|
core/wds/rtw_wds.c
|
C
|
agpl-3.0
| 17,738
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __RTW_WDS_H_
#define __RTW_WDS_H_
#ifdef CONFIG_AP_MODE
struct rtw_wds_path {
u8 dst[ETH_ALEN];
rtw_rhash_head rhash;
_adapter *adapter;
struct sta_info __rcu *next_hop;
rtw_rcu_head rcu;
systime last_update;
};
struct rtw_wds_table {
rtw_rhashtable rhead;
};
#define RTW_WDS_PATH_EXPIRE (600 * HZ)
/* Maximum number of paths per interface */
#define RTW_WDS_MAX_PATHS 1024
int rtw_wds_nexthop_lookup(_adapter *adapter, const u8 *da, u8 *ra);
struct rtw_wds_path *rtw_wds_path_lookup(_adapter *adapter, const u8 *dst);
void dump_wpath(void *sel, _adapter *adapter);
void rtw_wds_path_expire(_adapter *adapter);
struct rtw_wds_path *rtw_wds_path_add(_adapter *adapter, const u8 *dst, struct sta_info *next_hop);
void rtw_wds_path_assign_nexthop(struct rtw_wds_path *path, struct sta_info *sta);
int rtw_wds_pathtbl_init(_adapter *adapter);
void rtw_wds_pathtbl_unregister(_adapter *adapter);
void rtw_wds_path_flush_by_nexthop(struct sta_info *sta);
#endif /* CONFIG_AP_MODE */
struct rtw_wds_gptr_table {
rtw_rhashtable rhead;
};
void dump_wgptr(void *sel, _adapter *adapter);
bool rtw_rx_wds_gptr_check(_adapter *adapter, const u8 *src);
void rtw_tx_wds_gptr_update(_adapter *adapter, const u8 *src);
void rtw_wds_gptr_expire(_adapter *adapter);
int rtw_wds_gptr_tbl_init(_adapter *adapter);
void rtw_wds_gptr_tbl_unregister(_adapter *adapter);
#endif /* __RTW_WDSH_ */
|
2301_81045437/rtl8852be
|
core/wds/rtw_wds.h
|
C
|
agpl-3.0
| 2,058
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef _HAL_API_TMP_H_
#define _HAL_API_TMP_H_
/**** may be get from hal_com **********************************/
#define H2C_MSR_ROLE_RSVD 0
#define H2C_MSR_ROLE_STA 1
#define H2C_MSR_ROLE_AP 2
#define H2C_MSR_ROLE_GC 3
#define H2C_MSR_ROLE_GO 4
#define H2C_MSR_ROLE_TDLS 5
#define H2C_MSR_ROLE_ADHOC 6
#define H2C_MSR_ROLE_MESH 7
#define H2C_MSR_ROLE_MAX 8
/*************************************************************************************/
typedef enum _HW_VARIABLES {
HW_VAR_NET_TYPE,
HW_VAR_SET_OPMODE,
HW_VAR_MAC_ADDR,
HW_VAR_BSSID,
HW_VAR_BASIC_RATE,
HW_VAR_TXPAUSE,
HW_VAR_BCN_FUNC,
HW_VAR_CORRECT_TSF,
HW_VAR_RCR,
HW_VAR_MLME_DISCONNECT,
HW_VAR_MLME_SITESURVEY,
HW_VAR_MLME_JOIN,
HW_VAR_ON_RCR_AM,
HW_VAR_OFF_RCR_AM,
HW_VAR_BEACON_INTERVAL,
HW_VAR_SLOT_TIME,
HW_VAR_RESP_SIFS,
HW_VAR_ACK_PREAMBLE,
HW_VAR_SEC_CFG,
HW_VAR_SEC_DK_CFG,
HW_VAR_BCN_VALID,
HW_VAR_FREECNT,
HW_VAR_STOP_BCN,
HW_VAR_RESUME_BCN,
/* PHYDM odm->SupportAbility */
HW_VAR_CAM_EMPTY_ENTRY,
HW_VAR_CAM_INVALID_ALL,
HW_VAR_AC_PARAM_VO,
HW_VAR_AC_PARAM_VI,
HW_VAR_AC_PARAM_BE,
HW_VAR_AC_PARAM_BK,
HW_VAR_ACM_CTRL,
#ifdef CONFIG_WMMPS_STA
HW_VAR_UAPSD_TID,
#endif /* CONFIG_WMMPS_STA */
HW_VAR_AMPDU_MIN_SPACE,
#ifdef CONFIG_80211N_HT
HW_VAR_AMPDU_FACTOR,
#endif /* CONFIG_80211N_HT */
HW_VAR_RXDMA_AGG_PG_TH,
HW_VAR_SET_RPWM,
HW_VAR_CPWM,
HW_VAR_H2C_FW_PWRMODE,
HW_VAR_H2C_INACTIVE_IPS,
HW_VAR_H2C_FW_JOINBSSRPT,
HW_VAR_FWLPS_RF_ON,
HW_VAR_H2C_FW_P2P_PS_OFFLOAD,
#ifdef CONFIG_LPS_PG
HW_VAR_LPS_PG_HANDLE,
#endif
HW_VAR_TRIGGER_GPIO_0,
HW_VAR_BT_SET_COEXIST,
HW_VAR_BT_ISSUE_DELBA,
HW_VAR_FIFO_CLEARN_UP,
HW_VAR_RESTORE_HW_SEQ,
HW_VAR_CHECK_TXBUF,
HW_VAR_PCIE_STOP_TX_DMA,
HW_VAR_APFM_ON_MAC, /* Auto FSM to Turn On, include clock, isolation, power control for MAC only */
/* The valid upper nav range for the HW updating, if the true value is larger than the upper range, the HW won't update it. */
/* Unit in microsecond. 0 means disable this function. */
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
HW_VAR_WOWLAN,
HW_VAR_WAKEUP_REASON,
#endif
HW_VAR_RPWM_TOG,
#ifdef CONFIG_GPIO_WAKEUP
HW_VAR_WOW_OUTPUT_GPIO,
HW_VAR_WOW_INPUT_GPIO,
HW_SET_GPIO_WL_CTRL,
#endif
HW_VAR_SYS_CLKR,
HW_VAR_NAV_UPPER,
HW_VAR_CHK_HI_QUEUE_EMPTY,
HW_VAR_CHK_MGQ_CPU_EMPTY,
HW_VAR_DL_BCN_SEL,
HW_VAR_AMPDU_MAX_TIME,
HW_VAR_WIRELESS_MODE,
HW_VAR_USB_MODE,
HW_VAR_PORT_SWITCH,
HW_VAR_PORT_CFG,
HW_VAR_DM_IN_LPS_LCLK,/*flag CONFIG_LPS_LCLK_WD_TIMER*/
#ifdef DBG_CHECK_FW_PS_STATE
HW_VAR_FW_PS_STATE,
#endif
HW_VAR_SOUNDING_ENTER,
HW_VAR_SOUNDING_LEAVE,
HW_VAR_SOUNDING_RATE,
HW_VAR_SOUNDING_STATUS,
HW_VAR_SOUNDING_FW_NDPA,
HW_VAR_SOUNDING_CLK,
HW_VAR_SOUNDING_SET_GID_TABLE,
HW_VAR_SOUNDING_CSI_REPORT,
HW_VAR_DL_RSVD_PAGE,
HW_VAR_DUMP_MAC_QUEUE_INFO,
HW_VAR_ASIX_IOT,
HW_VAR_CH_SW_NEED_TO_TAKE_CARE_IQK_INFO,
HW_VAR_CH_SW_IQK_INFO_BACKUP,
HW_VAR_CH_SW_IQK_INFO_RESTORE,
HW_VAR_DBI,
HW_VAR_MDIO,
HW_VAR_L1OFF_CAPABILITY,
HW_VAR_L1OFF_NIC_SUPPORT,
#ifdef CONFIG_TDLS
#ifdef CONFIG_TDLS_CH_SW
HW_VAR_TDLS_BCN_EARLY_C2H_RPT,
#endif
#endif
HW_VAR_DUMP_MAC_TXFIFO,
HW_VAR_PWR_CMD,
HW_VAR_SET_SOML_PARAM,
HW_VAR_ENABLE_RX_BAR,
HW_VAR_TSF_AUTO_SYNC,
HW_VAR_LPS_STATE_CHK,
#ifdef CONFIG_RTS_FULL_BW
HW_VAR_SET_RTS_BW,
#endif
#if defined(CONFIG_PCI_HCI)
HW_VAR_ENSWBCN,
#endif
HW_VAR_ACKTO,
HW_VAR_ACKTO_CCK,
} HW_VARIABLES;
static inline u8 rtw_hal_set_hwreg(_adapter *padapter, u8 var, u8 *val)
{
return 0;
}
static inline void rtw_hal_get_hwreg(_adapter *padapter, u8 var, u8 *val)
{}
typedef enum _HAL_DEF_VARIABLE {
HAL_DEF_IS_SUPPORT_ANT_DIV,
HAL_DEF_DBG_DUMP_RXPKT,/* for dbg */
HAL_DEF_BEAMFORMER_CAP,
HAL_DEF_BEAMFORMEE_CAP,
HW_VAR_MAX_RX_AMPDU_FACTOR,
HW_DEF_RA_INFO_DUMP,
HAL_DEF_DBG_DUMP_TXPKT,
HAL_DEF_TX_PAGE_SIZE,
HW_VAR_BEST_AMPDU_DENSITY,
} HAL_DEF_VARIABLE;
static inline u8 rtw_hal_set_def_var(_adapter *padapter, HAL_DEF_VARIABLE def_var, void *val)
{
return 0;
}
u8 rtw_hal_get_def_var(struct _ADAPTER *a,
enum _HAL_DEF_VARIABLE def_var, void *val);
static inline u8 rtw_hal_check_ips_status(_adapter *padapter)
{
return 0;
}
static inline void rtw_hal_sec_read_cam_ent(_adapter *adapter, u8 id, u8 *ctrl, u8 *mac, u8 *key)
{}
static inline void rtw_hal_sec_write_cam_ent(_adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key)
{}
static inline void rtw_hal_sec_clr_cam_ent(_adapter *adapter, u8 id)
{}
static inline bool rtw_hal_sec_read_cam_is_gk(_adapter *adapter, u8 id)
{
return _TRUE;
}
static inline u8 rtw_hal_get_current_tx_rate(_adapter *adapter, struct sta_info *psta)
{
return 0;
}
static u8 rtw_get_current_tx_sgi(_adapter *padapter, struct sta_info *psta)
{
return 0;
}
static inline void rtw_hal_linked_info_dump(_adapter *padapter, u8 benable)
{}
static inline bool rtw_hal_get_phy_edcca_flag(_adapter *adapter)
{
return _TRUE;
}
static inline u64 rtw_hal_get_tsftr_by_port(_adapter *adapter, u8 port)
{
return 1;
}
static inline void rtw_hal_dump_rsvd_page(void *sel, _adapter *adapter, u8 page_offset, u8 page_num)
{}
/*u8 beamforming_get_htndp_tx_rate(void *dm_void, u8 bfer_str_num);*/
static inline u8 rtw_hal_get_htndp_tx_rate(_adapter *adapter, u8 bfer_str_num)
{
return 0;
}
/*u8 beamforming_get_vht_ndp_tx_rate(void *dm_void, u8 bfer_str_num);*/
static inline u8 rtw_hal_get_vht_ndp_tx_rate(_adapter *adapter, u8 bfer_str_num)
{
return 0;
}
static inline u8 rtw_hal_get_sounding_info(_adapter *adapter,u16 *throughput,
u8 total_bfee_num, u8 *tx_rate)
{
return 0;
}
static inline void rtw_hal_dump_target_tx_power(void *sel, _adapter *adapter)
{}
static inline void rtw_hal_dump_tx_power_by_rate(void *sel, _adapter *adapter)
{}
static inline void rtw_hal_dump_macaddr(void *sel, _adapter *adapter)
{}
static inline void rtw_hal_dump_trx_mode(void *sel, _adapter *adapter)
{}
static inline void rtw_hal_phy_adaptivity_parm_msg(void *sel, _adapter *adapter)
{}
static inline void rtw_hal_phy_adaptivity_parm_set(_adapter *adapter,
s8 th_l2h_ini, s8 th_edcca_hl_diff)
{}
#if defined(CONFIG_RTW_LED) && defined(CONFIG_RTW_SW_LED)
#ifndef CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
#define CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY 0
#endif
#if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
void rtw_sw_led_blink_uc_trx_only(LED_DATA *led);
void rtw_sw_led_ctl_mode_uc_trx_only(_adapter *adapter, LED_CTL_MODE ctl);
#endif
void rtw_led_control(_adapter *adapter, LED_CTL_MODE ctl);
void rtw_led_tx_control(_adapter *adapter, const u8 *da);
void rtw_led_rx_control(_adapter *adapter, const u8 *da);
void rtw_led_set_iface_en(_adapter *adapter, u8 en);
void rtw_led_set_iface_en_mask(_adapter *adapter, u8 mask);
void rtw_led_set_ctl_en_mask(_adapter *adapter, u32 ctl_mask);
void rtw_led_set_ctl_en_mask_primary(_adapter *adapter);
void rtw_led_set_ctl_en_mask_virtual(_adapter *adapter);
#else
#define rtw_led_control(adapter, ctl) do {} while (0)
#define rtw_led_tx_control(adapter, da) do {} while (0)
#define rtw_led_rx_control(adapter, da) do {} while (0)
#define rtw_led_set_iface_en(adapter, en) do {} while (0)
#define rtw_led_set_iface_en_mask(adapter, mask) do {} while (0)
#define rtw_led_set_ctl_en_mask(adapter, ctl_mask) do {} while (0)
#define rtw_led_set_ctl_en_mask_primary(adapter) do {} while (0)
#define rtw_led_set_ctl_en_mask_virtual(adapter) do {} while (0)
#endif /* defined(CONFIG_RTW_LED) && defined(CONFIG_RTW_SW_LED) */
#ifdef CONFIG_PCI_HCI
static inline void rtw_hal_irp_reset(_adapter *padapter)
{}
static inline void rtw_hal_pci_dbi_write(_adapter *padapter, u16 addr, u8 data)
{}
static inline u8 rtw_hal_pci_dbi_read(_adapter *padapter, u16 addr)
{ return 0;}
static inline void rtw_hal_pci_mdio_write(_adapter *padapter, u8 addr, u16 data)
{}
static inline u16 rtw_hal_pci_mdio_read(_adapter *padapter, u8 addr)
{ return 0;}
static inline u8 rtw_hal_pci_l1off_nic_support(_adapter *padapter)
{ return 0;}
static inline u8 rtw_hal_pci_l1off_capability(_adapter *padapter)
{ return 0;}
static inline void rtw_hal_unmap_beacon_icf(_adapter *padapter)
{
//hal->hal_ops.unmap_beacon_icf(padapter);
}
#endif
#if defined(CONFIG_PCI_HCI)
static inline u8 rtw_hal_check_nic_enough_desc_all(_adapter *padapter)
{ return _SUCCESS;}
static s32 rtw_hal_dump_xframe(_adapter *adapter, struct xmit_frame *pxmitframe)
{ return _SUCCESS;}
#endif
static inline s32 rtw_hal_macid_sleep(_adapter *adapter, u8 macid)
{ return 0;}
static inline s32 rtw_hal_macid_wakeup(_adapter *adapter, u8 macid)
{ return 0;}
static inline s32 rtw_hal_macid_sleep_all_used(_adapter *adapter)
{ return 0;}
static inline s32 rtw_hal_macid_wakeup_all_used(_adapter *adapter)
{ return 0;}
static void rtw_hal_c2h_pkt_hdl(_adapter *adapter, u8 *buf, u16 len)
{
//adapter->dvobj->hal_func.hal_mac_c2h_handler(adapter, buf, len);
}
static inline s32 rtw_hal_fill_h2c_cmd(_adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
{
/*
_adapter *pri_adapter = GET_PRIMARY_ADAPTER(padapter);
if (GET_PHL_COM(pri_adapter)->fw_ready == _TRUE)
return hal->hal_ops.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
else if (padapter->registrypriv.mp_mode == 0)
RTW_PRINT(FUNC_ADPT_FMT" FW doesn't exit when no MP mode, by pass H2C id:0x%02x\n"
, FUNC_ADPT_ARG(padapter), ElementID);
*/
return 0;
}
#ifdef CONFIG_DFS_MASTER
static inline void rtw_odm_radar_detect_reset(_adapter *adapter)
{
//phydm_radar_detect_reset(adapter_to_phydm(adapter));
}
static inline void rtw_odm_radar_detect_disable(_adapter *adapter)
{
//phydm_radar_detect_disable(adapter_to_phydm(adapter));
}
/* called after ch, bw is set */
static inline void rtw_odm_radar_detect_enable(_adapter *adapter)
{
//phydm_radar_detect_enable(adapter_to_phydm(adapter));
}
static inline BOOLEAN rtw_odm_radar_detect(_adapter *adapter)
{
return 0;//phydm_radar_detect(adapter_to_phydm(adapter));
}
static inline u8 rtw_odm_radar_detect_polling_int_ms(struct dvobj_priv *dvobj)
{
return 0;//phydm_dfs_polling_time(dvobj_to_phydm(dvobj));
}
#endif /* CONFIG_DFS_MASTER */
static inline void rtw_hal_reqtxrpt(_adapter *padapter, u8 macid)
{
//if (hal->hal_ops.reqtxrpt)
//hal->hal_ops.reqtxrpt(padapter, macid);
}
static inline u8 rtw_hal_get_port(_adapter *adapter)
{ return 0;}
static inline void rtw_hal_read_edca(_adapter *adapter, u16 *vo_params, u16 *vi_params,
u16 *be_params, u16 *bk_params)
{
//hal->hal_func.read_wmmedca_reg(padapter, vo_params, vi_params, be_params, bk_params);
}
static inline void rtw_hal_update_iqk_fw_offload_cap(_adapter *adapter)
{}
static inline void rtw_hal_dump_sta_traffic(void *sel, _adapter *adapter, struct sta_info *psta)
{}
static inline s32 rtw_hal_set_FwMediaStatusRpt_single_cmd
(_adapter *adapter, bool opmode, bool miracast, bool miracast_sink, u8 role, u8 macid)
{ return 0;}
static inline void rtw_hal_rcr_set_chk_bssid(_adapter *adapter, u8 self_action)
{}
enum QSEL_ID {
QSLT_BK_ID,
QSLT_BE_ID,
QSLT_VI_ID,
QSLT_VO_ID,
QSLT_BEACON_ID,
QSLT_HIGH_ID,
QSLT_MGNT_ID,
QSLT_CMD_ID
};
static inline u8 rtw_hal_get_qsel(_adapter *adapter, enum QSEL_ID qsel)
{
/*QSLT_HIGH*/
return 0;
}
/************************ xmit *******************/
static inline void rtw_hal_bcn_param_setting(_adapter *padapter)
{
//hal->hal_ops.set_beacon_param_handler(padapter);
}
static inline void rtw_hal_set_tx_power_level(_adapter *adapter, u8 channel)
{}
/****************** GEORGIA_TODO_REDEFINE_IO ************************/
static inline u32 rtw_hal_get_htsf(_adapter *adapter)/*get tst high 4 bytes */
{
return 0;
}
static inline u32 rtw_hal_get_ltsf(_adapter *adapter)/*get tst low 4 bytes */
{
return 0;
}
static inline u32 rtw_hal_get_dma_statu(_adapter *adapter)
{
return 0;
}
#ifdef DBG_TXBD_DESC_DUMP
static inline u32 rtw_hal_get_txbd_rwreg(_adapter *adapter)
{
return 0;
}
#endif
#ifdef RTW_SUPPORT_PLATFORM_SHUTDOWN
static inline u8 rtw_hal_sdio_leave_suspend(_adapter *adapter)
{
return 0;
}
#endif
#if defined(CONFIG_FWLPS_IN_IPS)
static inline void rtw_hal_set_fw_in_ips_mode(_adapter *padapter, u8 enable)
{}
#endif
#ifdef CONFIG_LPS_RPWM_TIMER
static inline bool rtw_hal_is_leave_ps(_adapter *padapter)
{
return _FALSE;
}
#endif
static inline void rtw_hal_get_version(char *str, u32 len)
{
//get hal version
//rtw_halmac_get_version(str, 30);
// get fw version
// get phy (bb/rf) version
// get btc version
}
#endif /*_HAL_API_TMP_H_*/
|
2301_81045437/rtl8852be
|
include/_hal_api_tmp.h
|
C
|
agpl-3.0
| 13,009
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __HAL_RATE_H__
#define __HAL_RATE_H__
/*-----------------------------------------------------------
* HW Rate def
* -----------------------------------------------------------
* CCK Rates, TxHT = 0 */
#define DESC_RATE1M 0x00
#define DESC_RATE2M 0x01
#define DESC_RATE5_5M 0x02
#define DESC_RATE11M 0x03
/* OFDM Rates, TxHT = 0 */
#define DESC_RATE6M 0x04
#define DESC_RATE9M 0x05
#define DESC_RATE12M 0x06
#define DESC_RATE18M 0x07
#define DESC_RATE24M 0x08
#define DESC_RATE36M 0x09
#define DESC_RATE48M 0x0A
#define DESC_RATE54M 0x0B
/* MCS Rates, TxHT = 1 */
#define DESC_RATEMCS0 0x0C
#define DESC_RATEMCS1 0x0D
#define DESC_RATEMCS2 0x0E
#define DESC_RATEMCS3 0x0F
#define DESC_RATEMCS4 0x10
#define DESC_RATEMCS5 0x11
#define DESC_RATEMCS6 0x12
#define DESC_RATEMCS7 0x13
#define DESC_RATEMCS8 0x14
#define DESC_RATEMCS9 0x15
#define DESC_RATEMCS10 0x16
#define DESC_RATEMCS11 0x17
#define DESC_RATEMCS12 0x18
#define DESC_RATEMCS13 0x19
#define DESC_RATEMCS14 0x1A
#define DESC_RATEMCS15 0x1B
#define DESC_RATEMCS16 0x1C
#define DESC_RATEMCS17 0x1D
#define DESC_RATEMCS18 0x1E
#define DESC_RATEMCS19 0x1F
#define DESC_RATEMCS20 0x20
#define DESC_RATEMCS21 0x21
#define DESC_RATEMCS22 0x22
#define DESC_RATEMCS23 0x23
#define DESC_RATEMCS24 0x24
#define DESC_RATEMCS25 0x25
#define DESC_RATEMCS26 0x26
#define DESC_RATEMCS27 0x27
#define DESC_RATEMCS28 0x28
#define DESC_RATEMCS29 0x29
#define DESC_RATEMCS30 0x2A
#define DESC_RATEMCS31 0x2B
#define DESC_RATEVHTSS1MCS0 0x2C
#define DESC_RATEVHTSS1MCS1 0x2D
#define DESC_RATEVHTSS1MCS2 0x2E
#define DESC_RATEVHTSS1MCS3 0x2F
#define DESC_RATEVHTSS1MCS4 0x30
#define DESC_RATEVHTSS1MCS5 0x31
#define DESC_RATEVHTSS1MCS6 0x32
#define DESC_RATEVHTSS1MCS7 0x33
#define DESC_RATEVHTSS1MCS8 0x34
#define DESC_RATEVHTSS1MCS9 0x35
#define DESC_RATEVHTSS2MCS0 0x36
#define DESC_RATEVHTSS2MCS1 0x37
#define DESC_RATEVHTSS2MCS2 0x38
#define DESC_RATEVHTSS2MCS3 0x39
#define DESC_RATEVHTSS2MCS4 0x3A
#define DESC_RATEVHTSS2MCS5 0x3B
#define DESC_RATEVHTSS2MCS6 0x3C
#define DESC_RATEVHTSS2MCS7 0x3D
#define DESC_RATEVHTSS2MCS8 0x3E
#define DESC_RATEVHTSS2MCS9 0x3F
#define DESC_RATEVHTSS3MCS0 0x40
#define DESC_RATEVHTSS3MCS1 0x41
#define DESC_RATEVHTSS3MCS2 0x42
#define DESC_RATEVHTSS3MCS3 0x43
#define DESC_RATEVHTSS3MCS4 0x44
#define DESC_RATEVHTSS3MCS5 0x45
#define DESC_RATEVHTSS3MCS6 0x46
#define DESC_RATEVHTSS3MCS7 0x47
#define DESC_RATEVHTSS3MCS8 0x48
#define DESC_RATEVHTSS3MCS9 0x49
#define DESC_RATEVHTSS4MCS0 0x4A
#define DESC_RATEVHTSS4MCS1 0x4B
#define DESC_RATEVHTSS4MCS2 0x4C
#define DESC_RATEVHTSS4MCS3 0x4D
#define DESC_RATEVHTSS4MCS4 0x4E
#define DESC_RATEVHTSS4MCS5 0x4F
#define DESC_RATEVHTSS4MCS6 0x50
#define DESC_RATEVHTSS4MCS7 0x51
#define DESC_RATEVHTSS4MCS8 0x52
#define DESC_RATEVHTSS4MCS9 0x53
#define HDATA_RATE(rate)\
(rate == DESC_RATE1M) ? "CCK_1M" :\
(rate == DESC_RATE2M) ? "CCK_2M" :\
(rate == DESC_RATE5_5M) ? "CCK5_5M" :\
(rate == DESC_RATE11M) ? "CCK_11M" :\
(rate == DESC_RATE6M) ? "OFDM_6M" :\
(rate == DESC_RATE9M) ? "OFDM_9M" :\
(rate == DESC_RATE12M) ? "OFDM_12M" :\
(rate == DESC_RATE18M) ? "OFDM_18M" :\
(rate == DESC_RATE24M) ? "OFDM_24M" :\
(rate == DESC_RATE36M) ? "OFDM_36M" :\
(rate == DESC_RATE48M) ? "OFDM_48M" :\
(rate == DESC_RATE54M) ? "OFDM_54M" :\
(rate == DESC_RATEMCS0) ? "MCS0" :\
(rate == DESC_RATEMCS1) ? "MCS1" :\
(rate == DESC_RATEMCS2) ? "MCS2" :\
(rate == DESC_RATEMCS3) ? "MCS3" :\
(rate == DESC_RATEMCS4) ? "MCS4" :\
(rate == DESC_RATEMCS5) ? "MCS5" :\
(rate == DESC_RATEMCS6) ? "MCS6" :\
(rate == DESC_RATEMCS7) ? "MCS7" :\
(rate == DESC_RATEMCS8) ? "MCS8" :\
(rate == DESC_RATEMCS9) ? "MCS9" :\
(rate == DESC_RATEMCS10) ? "MCS10" :\
(rate == DESC_RATEMCS11) ? "MCS11" :\
(rate == DESC_RATEMCS12) ? "MCS12" :\
(rate == DESC_RATEMCS13) ? "MCS13" :\
(rate == DESC_RATEMCS14) ? "MCS14" :\
(rate == DESC_RATEMCS15) ? "MCS15" :\
(rate == DESC_RATEMCS16) ? "MCS16" :\
(rate == DESC_RATEMCS17) ? "MCS17" :\
(rate == DESC_RATEMCS18) ? "MCS18" :\
(rate == DESC_RATEMCS19) ? "MCS19" :\
(rate == DESC_RATEMCS20) ? "MCS20" :\
(rate == DESC_RATEMCS21) ? "MCS21" :\
(rate == DESC_RATEMCS22) ? "MCS22" :\
(rate == DESC_RATEMCS23) ? "MCS23" :\
(rate == DESC_RATEMCS24) ? "MCS24" :\
(rate == DESC_RATEMCS25) ? "MCS25" :\
(rate == DESC_RATEMCS26) ? "MCS26" :\
(rate == DESC_RATEMCS27) ? "MCS27" :\
(rate == DESC_RATEMCS28) ? "MCS28" :\
(rate == DESC_RATEMCS29) ? "MCS29" :\
(rate == DESC_RATEMCS30) ? "MCS30" :\
(rate == DESC_RATEMCS31) ? "MCS31" :\
(rate == DESC_RATEVHTSS1MCS0) ? "VHTSS1MCS0" :\
(rate == DESC_RATEVHTSS1MCS1) ? "VHTSS1MCS1" :\
(rate == DESC_RATEVHTSS1MCS2) ? "VHTSS1MCS2" :\
(rate == DESC_RATEVHTSS1MCS3) ? "VHTSS1MCS3" :\
(rate == DESC_RATEVHTSS1MCS4) ? "VHTSS1MCS4" :\
(rate == DESC_RATEVHTSS1MCS5) ? "VHTSS1MCS5" :\
(rate == DESC_RATEVHTSS1MCS6) ? "VHTSS1MCS6" :\
(rate == DESC_RATEVHTSS1MCS7) ? "VHTSS1MCS7" :\
(rate == DESC_RATEVHTSS1MCS8) ? "VHTSS1MCS8" :\
(rate == DESC_RATEVHTSS1MCS9) ? "VHTSS1MCS9" :\
(rate == DESC_RATEVHTSS2MCS0) ? "VHTSS2MCS0" :\
(rate == DESC_RATEVHTSS2MCS1) ? "VHTSS2MCS1" :\
(rate == DESC_RATEVHTSS2MCS2) ? "VHTSS2MCS2" :\
(rate == DESC_RATEVHTSS2MCS3) ? "VHTSS2MCS3" :\
(rate == DESC_RATEVHTSS2MCS4) ? "VHTSS2MCS4" :\
(rate == DESC_RATEVHTSS2MCS5) ? "VHTSS2MCS5" :\
(rate == DESC_RATEVHTSS2MCS6) ? "VHTSS2MCS6" :\
(rate == DESC_RATEVHTSS2MCS7) ? "VHTSS2MCS7" :\
(rate == DESC_RATEVHTSS2MCS8) ? "VHTSS2MCS8" :\
(rate == DESC_RATEVHTSS2MCS9) ? "VHTSS2MCS9" :\
(rate == DESC_RATEVHTSS3MCS0) ? "VHTSS3MCS0" :\
(rate == DESC_RATEVHTSS3MCS1) ? "VHTSS3MCS1" :\
(rate == DESC_RATEVHTSS3MCS2) ? "VHTSS3MCS2" :\
(rate == DESC_RATEVHTSS3MCS3) ? "VHTSS3MCS3" :\
(rate == DESC_RATEVHTSS3MCS4) ? "VHTSS3MCS4" :\
(rate == DESC_RATEVHTSS3MCS5) ? "VHTSS3MCS5" :\
(rate == DESC_RATEVHTSS3MCS6) ? "VHTSS3MCS6" :\
(rate == DESC_RATEVHTSS3MCS7) ? "VHTSS3MCS7" :\
(rate == DESC_RATEVHTSS3MCS8) ? "VHTSS3MCS8" :\
(rate == DESC_RATEVHTSS3MCS9) ? "VHTSS3MCS9" :\
(rate == DESC_RATEVHTSS4MCS0) ? "VHTSS4MCS0" :\
(rate == DESC_RATEVHTSS4MCS1) ? "VHTSS4MCS1" :\
(rate == DESC_RATEVHTSS4MCS2) ? "VHTSS4MCS2" :\
(rate == DESC_RATEVHTSS4MCS3) ? "VHTSS4MCS3" :\
(rate == DESC_RATEVHTSS4MCS4) ? "VHTSS4MCS4" :\
(rate == DESC_RATEVHTSS4MCS5) ? "VHTSS4MCS5" :\
(rate == DESC_RATEVHTSS4MCS6) ? "VHTSS4MCS6" :\
(rate == DESC_RATEVHTSS4MCS7) ? "VHTSS4MCS7" :\
(rate == DESC_RATEVHTSS4MCS8) ? "VHTSS4MCS8" :\
(rate == DESC_RATEVHTSS4MCS9) ? "VHTSS4MCS9" :\
"UNKNOWN"
enum hw_data_rate {
HRATE_CCK1 = 0x0,
HRATE_CCK2 = 0x1,
HRATE_CCK5_5 = 0x2,
HRATE_CCK11 = 0x3,
HRATE_OFDM6 = 0x4,
HRATE_OFDM9 = 0x5,
HRATE_OFDM12 = 0x6,
HRATE_OFDM18 = 0x7,
HRATE_OFDM24 = 0x8,
HRATE_OFDM36 = 0x9,
HRATE_OFDM48 = 0xA,
HRATE_OFDM54 = 0xB,
HRATE_MCS0 = 0x80,
HRATE_MCS1 = 0x81,
HRATE_MCS2 = 0x82,
HRATE_MCS3 = 0x83,
HRATE_MCS4 = 0x84,
HRATE_MCS5 = 0x85,
HRATE_MCS6 = 0x86,
HRATE_MCS7 = 0x87,
HRATE_MCS8 = 0x88,
HRATE_MCS9 = 0x89,
HRATE_MCS10 = 0x8A,
HRATE_MCS11 = 0x8B,
HRATE_MCS12 = 0x8C,
HRATE_MCS13 = 0x8D,
HRATE_MCS14 = 0x8E,
HRATE_MCS15 = 0x8F,
HRATE_MCS16 = 0x90,
HRATE_MCS17 = 0x91,
HRATE_MCS18 = 0x92,
HRATE_MCS19 = 0x93,
HRATE_MCS20 = 0x94,
HRATE_MCS21 = 0x95,
HRATE_MCS22 = 0x96,
HRATE_MCS23 = 0x97,
HRATE_MCS24 = 0x98,
HRATE_MCS25 = 0x99,
HRATE_MCS26 = 0x9A,
HRATE_MCS27 = 0x9B,
HRATE_MCS28 = 0x9C,
HRATE_MCS29 = 0x9D,
HRATE_MCS30 = 0x9E,
HRATE_MCS31 = 0x9F,
HRATE_VHT_NSS1_MCS0 = 0x100,
HRATE_VHT_NSS1_MCS1 = 0x101,
HRATE_VHT_NSS1_MCS2 = 0x102,
HRATE_VHT_NSS1_MCS3 = 0x103,
HRATE_VHT_NSS1_MCS4 = 0x104,
HRATE_VHT_NSS1_MCS5 = 0x105,
HRATE_VHT_NSS1_MCS6 = 0x106,
HRATE_VHT_NSS1_MCS7 = 0x107,
HRATE_VHT_NSS1_MCS8 = 0x108,
HRATE_VHT_NSS1_MCS9 = 0x109,
HRATE_VHT_NSS2_MCS0 = 0x110,
HRATE_VHT_NSS2_MCS1 = 0x111,
HRATE_VHT_NSS2_MCS2 = 0x112,
HRATE_VHT_NSS2_MCS3 = 0x113,
HRATE_VHT_NSS2_MCS4 = 0x114,
HRATE_VHT_NSS2_MCS5 = 0x115,
HRATE_VHT_NSS2_MCS6 = 0x116,
HRATE_VHT_NSS2_MCS7 = 0x117,
HRATE_VHT_NSS2_MCS8 = 0x118,
HRATE_VHT_NSS2_MCS9 = 0x119,
HRATE_VHT_NSS3_MCS0 = 0x120,
HRATE_VHT_NSS3_MCS1 = 0x121,
HRATE_VHT_NSS3_MCS2 = 0x122,
HRATE_VHT_NSS3_MCS3 = 0x123,
HRATE_VHT_NSS3_MCS4 = 0x124,
HRATE_VHT_NSS3_MCS5 = 0x125,
HRATE_VHT_NSS3_MCS6 = 0x126,
HRATE_VHT_NSS3_MCS7 = 0x127,
HRATE_VHT_NSS3_MCS8 = 0x128,
HRATE_VHT_NSS3_MCS9 = 0x129,
HRATE_VHT_NSS4_MCS0 = 0x130,
HRATE_VHT_NSS4_MCS1 = 0x131,
HRATE_VHT_NSS4_MCS2 = 0x132,
HRATE_VHT_NSS4_MCS3 = 0x133,
HRATE_VHT_NSS4_MCS4 = 0x134,
HRATE_VHT_NSS4_MCS5 = 0x135,
HRATE_VHT_NSS4_MCS6 = 0x136,
HRATE_VHT_NSS4_MCS7 = 0x137,
HRATE_VHT_NSS4_MCS8 = 0x138,
HRATE_VHT_NSS4_MCS9 = 0x139,
HRATE_HE_NSS1_MCS0 = 0x180,
HRATE_HE_NSS1_MCS1 = 0x181,
HRATE_HE_NSS1_MCS2 = 0x182,
HRATE_HE_NSS1_MCS3 = 0x183,
HRATE_HE_NSS1_MCS4 = 0x184,
HRATE_HE_NSS1_MCS5 = 0x185,
HRATE_HE_NSS1_MCS6 = 0x186,
HRATE_HE_NSS1_MCS7 = 0x187,
HRATE_HE_NSS1_MCS8 = 0x188,
HRATE_HE_NSS1_MCS9 = 0x189,
HRATE_HE_NSS1_MCS10 = 0x18A,
HRATE_HE_NSS1_MCS11 = 0x18B,
HRATE_HE_NSS2_MCS0 = 0x190,
HRATE_HE_NSS2_MCS1 = 0x191,
HRATE_HE_NSS2_MCS2 = 0x192,
HRATE_HE_NSS2_MCS3 = 0x193,
HRATE_HE_NSS2_MCS4 = 0x194,
HRATE_HE_NSS2_MCS5 = 0x195,
HRATE_HE_NSS2_MCS6 = 0x196,
HRATE_HE_NSS2_MCS7 = 0x197,
HRATE_HE_NSS2_MCS8 = 0x198,
HRATE_HE_NSS2_MCS9 = 0x199,
HRATE_HE_NSS2_MCS10 = 0x19A,
HRATE_HE_NSS2_MCS11 = 0x19B,
HRATE_HE_NSS3_MCS0 = 0x1A0,
HRATE_HE_NSS3_MCS1 = 0x1A1,
HRATE_HE_NSS3_MCS2 = 0x1A2,
HRATE_HE_NSS3_MCS3 = 0x1A3,
HRATE_HE_NSS3_MCS4 = 0x1A4,
HRATE_HE_NSS3_MCS5 = 0x1A5,
HRATE_HE_NSS3_MCS6 = 0x1A6,
HRATE_HE_NSS3_MCS7 = 0x1A7,
HRATE_HE_NSS3_MCS8 = 0x1A8,
HRATE_HE_NSS3_MCS9 = 0x1A9,
HRATE_HE_NSS3_MCS10 = 0x1AA,
HRATE_HE_NSS3_MCS11 = 0x1AB,
HRATE_HE_NSS4_MCS0 = 0x1B0,
HRATE_HE_NSS4_MCS1 = 0x1B1,
HRATE_HE_NSS4_MCS2 = 0x1B2,
HRATE_HE_NSS4_MCS3 = 0x1B3,
HRATE_HE_NSS4_MCS4 = 0x1B4,
HRATE_HE_NSS4_MCS5 = 0x1B5,
HRATE_HE_NSS4_MCS6 = 0x1B6,
HRATE_HE_NSS4_MCS7 = 0x1B7,
HRATE_HE_NSS4_MCS8 = 0x1B8,
HRATE_HE_NSS4_MCS9 = 0x1B9,
HRATE_HE_NSS4_MCS10 = 0x1BA,
HRATE_HE_NSS4_MCS11 = 0x1BB
};
static inline u16 mrate_to_hwrate(u16 rate)
{
u16 ret = DESC_RATE1M;
switch (rate) {
case MGN_1M:
ret = RTW_DATA_RATE_CCK1;
break;
case MGN_2M:
ret = RTW_DATA_RATE_CCK2;
break;
case MGN_5_5M:
ret = RTW_DATA_RATE_CCK5_5;
break;
case MGN_11M:
ret = RTW_DATA_RATE_CCK11;
break;
case MGN_6M:
ret = RTW_DATA_RATE_OFDM6;
break;
case MGN_9M:
ret = RTW_DATA_RATE_OFDM9;
break;
case MGN_12M:
ret = RTW_DATA_RATE_OFDM12;
break;
case MGN_18M:
ret = RTW_DATA_RATE_OFDM18;
break;
case MGN_24M:
ret = RTW_DATA_RATE_OFDM24;
break;
case MGN_36M:
ret = RTW_DATA_RATE_OFDM36;
break;
case MGN_48M:
ret = RTW_DATA_RATE_OFDM48;
break;
case MGN_54M:
ret = RTW_DATA_RATE_OFDM54;
break;
case MGN_MCS0:
ret = RTW_DATA_RATE_MCS0;
break;
case MGN_MCS1:
ret = RTW_DATA_RATE_MCS1;
break;
case MGN_MCS2:
ret = RTW_DATA_RATE_MCS2;
break;
case MGN_MCS3:
ret = RTW_DATA_RATE_MCS3;
break;
case MGN_MCS4:
ret = RTW_DATA_RATE_MCS4;
break;
case MGN_MCS5:
ret = RTW_DATA_RATE_MCS5;
break;
case MGN_MCS6:
ret = RTW_DATA_RATE_MCS6;
break;
case MGN_MCS7:
ret = RTW_DATA_RATE_MCS7;
break;
case MGN_MCS8:
ret = RTW_DATA_RATE_MCS8;
break;
case MGN_MCS9:
ret = RTW_DATA_RATE_MCS9;
break;
case MGN_MCS10:
ret = RTW_DATA_RATE_MCS10;
break;
case MGN_MCS11:
ret = RTW_DATA_RATE_MCS11;
break;
case MGN_MCS12:
ret = RTW_DATA_RATE_MCS12;
break;
case MGN_MCS13:
ret = RTW_DATA_RATE_MCS13;
break;
case MGN_MCS14:
ret = RTW_DATA_RATE_MCS14;
break;
case MGN_MCS15:
ret = RTW_DATA_RATE_MCS15;
break;
case MGN_MCS16:
ret = RTW_DATA_RATE_MCS16;
break;
case MGN_MCS17:
ret = RTW_DATA_RATE_MCS17;
break;
case MGN_MCS18:
ret = RTW_DATA_RATE_MCS18;
break;
case MGN_MCS19:
ret = RTW_DATA_RATE_MCS19;
break;
case MGN_MCS20:
ret = RTW_DATA_RATE_MCS20;
break;
case MGN_MCS21:
ret = RTW_DATA_RATE_MCS21;
break;
case MGN_MCS22:
ret = RTW_DATA_RATE_MCS22;
break;
case MGN_MCS23:
ret = RTW_DATA_RATE_MCS23;
break;
case MGN_MCS24:
ret = RTW_DATA_RATE_MCS24;
break;
case MGN_MCS25:
ret = RTW_DATA_RATE_MCS25;
break;
case MGN_MCS26:
ret = RTW_DATA_RATE_MCS26;
break;
case MGN_MCS27:
ret = RTW_DATA_RATE_MCS27;
break;
case MGN_MCS28:
ret = RTW_DATA_RATE_MCS28;
break;
case MGN_MCS29:
ret = RTW_DATA_RATE_MCS29;
break;
case MGN_MCS30:
ret = RTW_DATA_RATE_MCS30;
break;
case MGN_MCS31:
ret = RTW_DATA_RATE_MCS31;
break;
case MGN_VHT1SS_MCS0:
ret = RTW_DATA_RATE_VHT_NSS1_MCS0;
break;
case MGN_VHT1SS_MCS1:
ret = RTW_DATA_RATE_VHT_NSS1_MCS1;
break;
case MGN_VHT1SS_MCS2:
ret = RTW_DATA_RATE_VHT_NSS1_MCS2;
break;
case MGN_VHT1SS_MCS3:
ret = RTW_DATA_RATE_VHT_NSS1_MCS3;
break;
case MGN_VHT1SS_MCS4:
ret = RTW_DATA_RATE_VHT_NSS1_MCS4;
break;
case MGN_VHT1SS_MCS5:
ret = RTW_DATA_RATE_VHT_NSS1_MCS5;
break;
case MGN_VHT1SS_MCS6:
ret = RTW_DATA_RATE_VHT_NSS1_MCS6;
break;
case MGN_VHT1SS_MCS7:
ret = RTW_DATA_RATE_VHT_NSS1_MCS7;
break;
case MGN_VHT1SS_MCS8:
ret = RTW_DATA_RATE_VHT_NSS1_MCS8;
break;
case MGN_VHT1SS_MCS9:
ret = RTW_DATA_RATE_VHT_NSS1_MCS9;
break;
case MGN_VHT2SS_MCS0:
ret = RTW_DATA_RATE_VHT_NSS2_MCS0;
break;
case MGN_VHT2SS_MCS1:
ret = RTW_DATA_RATE_VHT_NSS2_MCS1;
break;
case MGN_VHT2SS_MCS2:
ret = RTW_DATA_RATE_VHT_NSS2_MCS2;
break;
case MGN_VHT2SS_MCS3:
ret = RTW_DATA_RATE_VHT_NSS2_MCS3;
break;
case MGN_VHT2SS_MCS4:
ret = RTW_DATA_RATE_VHT_NSS2_MCS4;
break;
case MGN_VHT2SS_MCS5:
ret = RTW_DATA_RATE_VHT_NSS2_MCS5;
break;
case MGN_VHT2SS_MCS6:
ret = RTW_DATA_RATE_VHT_NSS2_MCS6;
break;
case MGN_VHT2SS_MCS7:
ret = RTW_DATA_RATE_VHT_NSS2_MCS7;
break;
case MGN_VHT2SS_MCS8:
ret = RTW_DATA_RATE_VHT_NSS2_MCS8;
break;
case MGN_VHT2SS_MCS9:
ret = RTW_DATA_RATE_VHT_NSS2_MCS9;
break;
case MGN_VHT3SS_MCS0:
ret = RTW_DATA_RATE_VHT_NSS3_MCS0;
break;
case MGN_VHT3SS_MCS1:
ret = RTW_DATA_RATE_VHT_NSS3_MCS1;
break;
case MGN_VHT3SS_MCS2:
ret = RTW_DATA_RATE_VHT_NSS3_MCS2;
break;
case MGN_VHT3SS_MCS3:
ret = RTW_DATA_RATE_VHT_NSS3_MCS3;
break;
case MGN_VHT3SS_MCS4:
ret = RTW_DATA_RATE_VHT_NSS3_MCS4;
break;
case MGN_VHT3SS_MCS5:
ret = RTW_DATA_RATE_VHT_NSS3_MCS5;
break;
case MGN_VHT3SS_MCS6:
ret = RTW_DATA_RATE_VHT_NSS3_MCS6;
break;
case MGN_VHT3SS_MCS7:
ret = RTW_DATA_RATE_VHT_NSS3_MCS7;
break;
case MGN_VHT3SS_MCS8:
ret = RTW_DATA_RATE_VHT_NSS3_MCS8;
break;
case MGN_VHT3SS_MCS9:
ret = RTW_DATA_RATE_VHT_NSS3_MCS9;
break;
case MGN_VHT4SS_MCS0:
ret = RTW_DATA_RATE_VHT_NSS4_MCS0;
break;
case MGN_VHT4SS_MCS1:
ret = RTW_DATA_RATE_VHT_NSS4_MCS1;
break;
case MGN_VHT4SS_MCS2:
ret = RTW_DATA_RATE_VHT_NSS4_MCS2;
break;
case MGN_VHT4SS_MCS3:
ret = RTW_DATA_RATE_VHT_NSS4_MCS3;
break;
case MGN_VHT4SS_MCS4:
ret = RTW_DATA_RATE_VHT_NSS4_MCS4;
break;
case MGN_VHT4SS_MCS5:
ret = RTW_DATA_RATE_VHT_NSS4_MCS5;
break;
case MGN_VHT4SS_MCS6:
ret = RTW_DATA_RATE_VHT_NSS4_MCS6;
break;
case MGN_VHT4SS_MCS7:
ret = RTW_DATA_RATE_VHT_NSS4_MCS7;
break;
case MGN_VHT4SS_MCS8:
ret = RTW_DATA_RATE_VHT_NSS4_MCS8;
break;
case MGN_VHT4SS_MCS9:
ret = RTW_DATA_RATE_VHT_NSS4_MCS9;
break;
case MGN_HE1SS_MCS0:
ret = RTW_DATA_RATE_HE_NSS1_MCS0;
break;
case MGN_HE1SS_MCS1:
ret = RTW_DATA_RATE_HE_NSS1_MCS1;
break;
case MGN_HE1SS_MCS2:
ret = RTW_DATA_RATE_HE_NSS1_MCS2;
break;
case MGN_HE1SS_MCS3:
ret = RTW_DATA_RATE_HE_NSS1_MCS3;
break;
case MGN_HE1SS_MCS4:
ret = RTW_DATA_RATE_HE_NSS1_MCS4;
break;
case MGN_HE1SS_MCS5:
ret = RTW_DATA_RATE_HE_NSS1_MCS5;
break;
case MGN_HE1SS_MCS6:
ret = RTW_DATA_RATE_HE_NSS1_MCS6;
break;
case MGN_HE1SS_MCS7:
ret = RTW_DATA_RATE_HE_NSS1_MCS7;
break;
case MGN_HE1SS_MCS8:
ret = RTW_DATA_RATE_HE_NSS1_MCS8;
break;
case MGN_HE1SS_MCS9:
ret = RTW_DATA_RATE_HE_NSS1_MCS9;
break;
case MGN_HE1SS_MCS10:
ret = RTW_DATA_RATE_HE_NSS1_MCS10;
break;
case MGN_HE1SS_MCS11:
ret = RTW_DATA_RATE_HE_NSS1_MCS11;
break;
case MGN_HE2SS_MCS0:
ret = RTW_DATA_RATE_HE_NSS2_MCS0;
break;
case MGN_HE2SS_MCS1:
ret = RTW_DATA_RATE_HE_NSS2_MCS1;
break;
case MGN_HE2SS_MCS2:
ret = RTW_DATA_RATE_HE_NSS2_MCS2;
break;
case MGN_HE2SS_MCS3:
ret = RTW_DATA_RATE_HE_NSS2_MCS3;
break;
case MGN_HE2SS_MCS4:
ret = RTW_DATA_RATE_HE_NSS2_MCS4;
break;
case MGN_HE2SS_MCS5:
ret = RTW_DATA_RATE_HE_NSS2_MCS5;
break;
case MGN_HE2SS_MCS6:
ret = RTW_DATA_RATE_HE_NSS2_MCS6;
break;
case MGN_HE2SS_MCS7:
ret = RTW_DATA_RATE_HE_NSS2_MCS7;
break;
case MGN_HE2SS_MCS8:
ret = RTW_DATA_RATE_HE_NSS2_MCS8;
break;
case MGN_HE2SS_MCS9:
ret = RTW_DATA_RATE_HE_NSS2_MCS9;
break;
case MGN_HE2SS_MCS10:
ret = RTW_DATA_RATE_HE_NSS2_MCS10;
break;
case MGN_HE2SS_MCS11:
ret = RTW_DATA_RATE_HE_NSS2_MCS11;
break;
case MGN_HE3SS_MCS0:
ret = RTW_DATA_RATE_HE_NSS3_MCS0;
break;
case MGN_HE3SS_MCS1:
ret = RTW_DATA_RATE_HE_NSS3_MCS1;
break;
case MGN_HE3SS_MCS2:
ret = RTW_DATA_RATE_HE_NSS3_MCS2;
break;
case MGN_HE3SS_MCS3:
ret = RTW_DATA_RATE_HE_NSS3_MCS3;
break;
case MGN_HE3SS_MCS4:
ret = RTW_DATA_RATE_HE_NSS3_MCS4;
break;
case MGN_HE3SS_MCS5:
ret = RTW_DATA_RATE_HE_NSS3_MCS5;
break;
case MGN_HE3SS_MCS6:
ret = RTW_DATA_RATE_HE_NSS3_MCS6;
break;
case MGN_HE3SS_MCS7:
ret = RTW_DATA_RATE_HE_NSS3_MCS7;
break;
case MGN_HE3SS_MCS8:
ret = RTW_DATA_RATE_HE_NSS3_MCS8;
break;
case MGN_HE3SS_MCS9:
ret = RTW_DATA_RATE_HE_NSS3_MCS9;
break;
case MGN_HE3SS_MCS10:
ret = RTW_DATA_RATE_HE_NSS3_MCS10;
break;
case MGN_HE3SS_MCS11:
ret = RTW_DATA_RATE_HE_NSS3_MCS11;
break;
case MGN_HE4SS_MCS0:
ret = RTW_DATA_RATE_HE_NSS4_MCS0;
break;
case MGN_HE4SS_MCS1:
ret = RTW_DATA_RATE_HE_NSS4_MCS1;
break;
case MGN_HE4SS_MCS2:
ret = RTW_DATA_RATE_HE_NSS4_MCS2;
break;
case MGN_HE4SS_MCS3:
ret = RTW_DATA_RATE_HE_NSS4_MCS3;
break;
case MGN_HE4SS_MCS4:
ret = RTW_DATA_RATE_HE_NSS4_MCS4;
break;
case MGN_HE4SS_MCS5:
ret = RTW_DATA_RATE_HE_NSS4_MCS5;
break;
case MGN_HE4SS_MCS6:
ret = RTW_DATA_RATE_HE_NSS4_MCS6;
break;
case MGN_HE4SS_MCS7:
ret = RTW_DATA_RATE_HE_NSS4_MCS7;
break;
case MGN_HE4SS_MCS8:
ret = RTW_DATA_RATE_HE_NSS4_MCS8;
break;
case MGN_HE4SS_MCS9:
ret = RTW_DATA_RATE_HE_NSS4_MCS9;
break;
case MGN_HE4SS_MCS10:
ret = RTW_DATA_RATE_HE_NSS4_MCS10;
break;
case MGN_HE4SS_MCS11:
ret = RTW_DATA_RATE_HE_NSS4_MCS11;
break;
default:
break;
}
return ret;
}
static inline u8 hwrate_to_mrate(u16 rate)
{
u16 ret_rate = MGN_1M;
switch (rate) {
case RTW_DATA_RATE_CCK1:
ret_rate = MGN_1M;
break;
case RTW_DATA_RATE_CCK2:
ret_rate = MGN_2M;
break;
case RTW_DATA_RATE_CCK5_5:
ret_rate = MGN_5_5M;
break;
case RTW_DATA_RATE_CCK11:
ret_rate = MGN_11M;
break;
case RTW_DATA_RATE_OFDM6:
ret_rate = MGN_6M;
break;
case RTW_DATA_RATE_OFDM9:
ret_rate = MGN_9M;
break;
case RTW_DATA_RATE_OFDM12:
ret_rate = MGN_12M;
break;
case RTW_DATA_RATE_OFDM18:
ret_rate = MGN_18M;
break;
case RTW_DATA_RATE_OFDM24:
ret_rate = MGN_24M;
break;
case RTW_DATA_RATE_OFDM36:
ret_rate = MGN_36M;
break;
case RTW_DATA_RATE_OFDM48:
ret_rate = MGN_48M;
break;
case RTW_DATA_RATE_OFDM54:
ret_rate = MGN_54M;
break;
case RTW_DATA_RATE_MCS0:
ret_rate = MGN_MCS0;
break;
case RTW_DATA_RATE_MCS1:
ret_rate = MGN_MCS1;
break;
case RTW_DATA_RATE_MCS2:
ret_rate = MGN_MCS2;
break;
case RTW_DATA_RATE_MCS3:
ret_rate = MGN_MCS3;
break;
case RTW_DATA_RATE_MCS4:
ret_rate = MGN_MCS4;
break;
case RTW_DATA_RATE_MCS5:
ret_rate = MGN_MCS5;
break;
case RTW_DATA_RATE_MCS6:
ret_rate = MGN_MCS6;
break;
case RTW_DATA_RATE_MCS7:
ret_rate = MGN_MCS7;
break;
case RTW_DATA_RATE_MCS8:
ret_rate = MGN_MCS8;
break;
case RTW_DATA_RATE_MCS9:
ret_rate = MGN_MCS9;
break;
case RTW_DATA_RATE_MCS10:
ret_rate = MGN_MCS10;
break;
case RTW_DATA_RATE_MCS11:
ret_rate = MGN_MCS11;
break;
case RTW_DATA_RATE_MCS12:
ret_rate = MGN_MCS12;
break;
case RTW_DATA_RATE_MCS13:
ret_rate = MGN_MCS13;
break;
case RTW_DATA_RATE_MCS14:
ret_rate = MGN_MCS14;
break;
case RTW_DATA_RATE_MCS15:
ret_rate = MGN_MCS15;
break;
case RTW_DATA_RATE_MCS16:
ret_rate = MGN_MCS16;
break;
case RTW_DATA_RATE_MCS17:
ret_rate = MGN_MCS17;
break;
case RTW_DATA_RATE_MCS18:
ret_rate = MGN_MCS18;
break;
case RTW_DATA_RATE_MCS19:
ret_rate = MGN_MCS19;
break;
case RTW_DATA_RATE_MCS20:
ret_rate = MGN_MCS20;
break;
case RTW_DATA_RATE_MCS21:
ret_rate = MGN_MCS21;
break;
case RTW_DATA_RATE_MCS22:
ret_rate = MGN_MCS22;
break;
case RTW_DATA_RATE_MCS23:
ret_rate = MGN_MCS23;
break;
case RTW_DATA_RATE_MCS24:
ret_rate = MGN_MCS24;
break;
case RTW_DATA_RATE_MCS25:
ret_rate = MGN_MCS25;
break;
case RTW_DATA_RATE_MCS26:
ret_rate = MGN_MCS26;
break;
case RTW_DATA_RATE_MCS27:
ret_rate = MGN_MCS27;
break;
case RTW_DATA_RATE_MCS28:
ret_rate = MGN_MCS28;
break;
case RTW_DATA_RATE_MCS29:
ret_rate = MGN_MCS29;
break;
case RTW_DATA_RATE_MCS30:
ret_rate = MGN_MCS30;
break;
case RTW_DATA_RATE_MCS31:
ret_rate = MGN_MCS31;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS0:
ret_rate = MGN_VHT1SS_MCS0;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS1:
ret_rate = MGN_VHT1SS_MCS1;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS2:
ret_rate = MGN_VHT1SS_MCS2;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS3:
ret_rate = MGN_VHT1SS_MCS3;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS4:
ret_rate = MGN_VHT1SS_MCS4;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS5:
ret_rate = MGN_VHT1SS_MCS5;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS6:
ret_rate = MGN_VHT1SS_MCS6;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS7:
ret_rate = MGN_VHT1SS_MCS7;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS8:
ret_rate = MGN_VHT1SS_MCS8;
break;
case RTW_DATA_RATE_VHT_NSS1_MCS9:
ret_rate = MGN_VHT1SS_MCS9;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS0:
ret_rate = MGN_VHT2SS_MCS0;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS1:
ret_rate = MGN_VHT2SS_MCS1;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS2:
ret_rate = MGN_VHT2SS_MCS2;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS3:
ret_rate = MGN_VHT2SS_MCS3;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS4:
ret_rate = MGN_VHT2SS_MCS4;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS5:
ret_rate = MGN_VHT2SS_MCS5;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS6:
ret_rate = MGN_VHT2SS_MCS6;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS7:
ret_rate = MGN_VHT2SS_MCS7;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS8:
ret_rate = MGN_VHT2SS_MCS8;
break;
case RTW_DATA_RATE_VHT_NSS2_MCS9:
ret_rate = MGN_VHT2SS_MCS9;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS0:
ret_rate = MGN_VHT3SS_MCS0;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS1:
ret_rate = MGN_VHT3SS_MCS1;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS2:
ret_rate = MGN_VHT3SS_MCS2;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS3:
ret_rate = MGN_VHT3SS_MCS3;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS4:
ret_rate = MGN_VHT3SS_MCS4;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS5:
ret_rate = MGN_VHT3SS_MCS5;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS6:
ret_rate = MGN_VHT3SS_MCS6;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS7:
ret_rate = MGN_VHT3SS_MCS7;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS8:
ret_rate = MGN_VHT3SS_MCS8;
break;
case RTW_DATA_RATE_VHT_NSS3_MCS9:
ret_rate = MGN_VHT3SS_MCS9;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS0:
ret_rate = MGN_VHT4SS_MCS0;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS1:
ret_rate = MGN_VHT4SS_MCS1;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS2:
ret_rate = MGN_VHT4SS_MCS2;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS3:
ret_rate = MGN_VHT4SS_MCS3;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS4:
ret_rate = MGN_VHT4SS_MCS4;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS5:
ret_rate = MGN_VHT4SS_MCS5;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS6:
ret_rate = MGN_VHT4SS_MCS6;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS7:
ret_rate = MGN_VHT4SS_MCS7;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS8:
ret_rate = MGN_VHT4SS_MCS8;
break;
case RTW_DATA_RATE_VHT_NSS4_MCS9:
ret_rate = MGN_VHT4SS_MCS9;
break;
case RTW_DATA_RATE_HE_NSS1_MCS0:
ret_rate = MGN_HE1SS_MCS0;
break;
case RTW_DATA_RATE_HE_NSS1_MCS1:
ret_rate = MGN_HE1SS_MCS1;
break;
case RTW_DATA_RATE_HE_NSS1_MCS2:
ret_rate = MGN_HE1SS_MCS2;
break;
case RTW_DATA_RATE_HE_NSS1_MCS3:
ret_rate = MGN_HE1SS_MCS3;
break;
case RTW_DATA_RATE_HE_NSS1_MCS4:
ret_rate = MGN_HE1SS_MCS4;
break;
case RTW_DATA_RATE_HE_NSS1_MCS5:
ret_rate = MGN_HE1SS_MCS5;
break;
case RTW_DATA_RATE_HE_NSS1_MCS6:
ret_rate = MGN_HE1SS_MCS6;
break;
case RTW_DATA_RATE_HE_NSS1_MCS7:
ret_rate = MGN_HE1SS_MCS7;
break;
case RTW_DATA_RATE_HE_NSS1_MCS8:
ret_rate = MGN_HE1SS_MCS8;
break;
case RTW_DATA_RATE_HE_NSS1_MCS9:
ret_rate = MGN_HE1SS_MCS9;
break;
case RTW_DATA_RATE_HE_NSS1_MCS10:
ret_rate = MGN_HE1SS_MCS10;
break;
case RTW_DATA_RATE_HE_NSS1_MCS11:
ret_rate = MGN_HE1SS_MCS11;
break;
case RTW_DATA_RATE_HE_NSS2_MCS0:
ret_rate = MGN_HE2SS_MCS0;
break;
case RTW_DATA_RATE_HE_NSS2_MCS1:
ret_rate = MGN_HE2SS_MCS1;
break;
case RTW_DATA_RATE_HE_NSS2_MCS2:
ret_rate = MGN_HE2SS_MCS2;
break;
case RTW_DATA_RATE_HE_NSS2_MCS3:
ret_rate = MGN_HE2SS_MCS3;
break;
case RTW_DATA_RATE_HE_NSS2_MCS4:
ret_rate = MGN_HE2SS_MCS4;
break;
case RTW_DATA_RATE_HE_NSS2_MCS5:
ret_rate = MGN_HE2SS_MCS5;
break;
case RTW_DATA_RATE_HE_NSS2_MCS6:
ret_rate = MGN_HE2SS_MCS6;
break;
case RTW_DATA_RATE_HE_NSS2_MCS7:
ret_rate = MGN_HE2SS_MCS7;
break;
case RTW_DATA_RATE_HE_NSS2_MCS8:
ret_rate = MGN_HE2SS_MCS8;
break;
case RTW_DATA_RATE_HE_NSS2_MCS9:
ret_rate = MGN_HE2SS_MCS9;
break;
case RTW_DATA_RATE_HE_NSS2_MCS10:
ret_rate = MGN_HE2SS_MCS10;
break;
case RTW_DATA_RATE_HE_NSS2_MCS11:
ret_rate = MGN_HE2SS_MCS11;
break;
case RTW_DATA_RATE_HE_NSS3_MCS0:
ret_rate = MGN_HE3SS_MCS0;
break;
case RTW_DATA_RATE_HE_NSS3_MCS1:
ret_rate = MGN_HE3SS_MCS1;
break;
case RTW_DATA_RATE_HE_NSS3_MCS2:
ret_rate = MGN_HE3SS_MCS2;
break;
case RTW_DATA_RATE_HE_NSS3_MCS3:
ret_rate = MGN_HE3SS_MCS3;
break;
case RTW_DATA_RATE_HE_NSS3_MCS4:
ret_rate = MGN_HE3SS_MCS4;
break;
case RTW_DATA_RATE_HE_NSS3_MCS5:
ret_rate = MGN_HE3SS_MCS5;
break;
case RTW_DATA_RATE_HE_NSS3_MCS6:
ret_rate = MGN_HE3SS_MCS6;
break;
case RTW_DATA_RATE_HE_NSS3_MCS7:
ret_rate = MGN_HE3SS_MCS7;
break;
case RTW_DATA_RATE_HE_NSS3_MCS8:
ret_rate = MGN_HE3SS_MCS8;
break;
case RTW_DATA_RATE_HE_NSS3_MCS9:
ret_rate = MGN_HE3SS_MCS9;
break;
case RTW_DATA_RATE_HE_NSS3_MCS10:
ret_rate = MGN_HE3SS_MCS10;
break;
case RTW_DATA_RATE_HE_NSS3_MCS11:
ret_rate = MGN_HE3SS_MCS11;
break;
case RTW_DATA_RATE_HE_NSS4_MCS0:
ret_rate = MGN_HE4SS_MCS0;
break;
case RTW_DATA_RATE_HE_NSS4_MCS1:
ret_rate = MGN_HE4SS_MCS1;
break;
case RTW_DATA_RATE_HE_NSS4_MCS2:
ret_rate = MGN_HE4SS_MCS2;
break;
case RTW_DATA_RATE_HE_NSS4_MCS3:
ret_rate = MGN_HE4SS_MCS3;
break;
case RTW_DATA_RATE_HE_NSS4_MCS4:
ret_rate = MGN_HE4SS_MCS4;
break;
case RTW_DATA_RATE_HE_NSS4_MCS5:
ret_rate = MGN_HE4SS_MCS5;
break;
case RTW_DATA_RATE_HE_NSS4_MCS6:
ret_rate = MGN_HE4SS_MCS6;
break;
case RTW_DATA_RATE_HE_NSS4_MCS7:
ret_rate = MGN_HE4SS_MCS7;
break;
case RTW_DATA_RATE_HE_NSS4_MCS8:
ret_rate = MGN_HE4SS_MCS8;
break;
case RTW_DATA_RATE_HE_NSS4_MCS9:
ret_rate = MGN_HE4SS_MCS9;
break;
case RTW_DATA_RATE_HE_NSS4_MCS10:
ret_rate = MGN_HE4SS_MCS10;
break;
case RTW_DATA_RATE_HE_NSS4_MCS11:
ret_rate = MGN_HE4SS_MCS11;
break;
default:
break;
}
return ret_rate;
}
#endif /* __HAL_RATE_H__ */
|
2301_81045437/rtl8852be
|
include/_hal_rate.h
|
C
|
agpl-3.0
| 28,518
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
/***** temporarily flag for IC development phase *******/
#define CONFIG_SINGLE_IMG
/*#define CONFIG_NO_FW*/
/*#define CONFIG_DISABLE_ODM*/
#define RTW_WKARD_CORE_RSSI_V1
#ifdef RTW_WKARD_CORE_RSSI_V1
#define CONFIG_RX_PSTS_PER_PKT
#define CONFIG_SIGNAL_STAT_PROCESS
#endif
#ifndef DBG_MEM_ALLOC
#define DBG_MEM_ALLOC
#define DBG_PHL_MEM_ALLOC
#define DBG_HAL_MAC_MEM_MOINTOR
#define DBG_HAL_MEM_MOINTOR
#endif
/*#define CONFIG_PHL_USE_KMEM_ALLOC*/
#define CONFIG_HW_RTS
/*
* Work around Config
*/
#define RTW_WKARD_DIS_PROBE_REQ_RPT_TO_HOSTAPD
/***** temporarily flag *******/
/*
* Public General Config
*/
#define AUTOCONF_INCLUDED
#define DRV_NAME "rtl8852be"
#define CONFIG_PCI_HCI
#define CONFIG_PCIE_TRX_MIT
#ifdef CONFIG_PCIE_TRX_MIT
#define PCIE_RX_INT_MIT_TIMER 4096
#endif
#define CONFIG_RPQ_AGG_NUM 30
/*
* Wi-Fi Functions Config
*/
/*#define CONFIG_RECV_REORDERING_CTRL*/
#define CONFIG_80211N_HT
#define CONFIG_80211AC_VHT
#define CONFIG_80211AX_HE
#ifdef CONFIG_80211AC_VHT
#ifndef CONFIG_80211N_HT
#define CONFIG_80211N_HT
#endif
#endif
#ifdef CONFIG_80211AX_HE
#ifndef CONFIG_80211N_HT
#define CONFIG_80211N_HT
#endif
#ifndef CONFIG_80211AC_VHT
#define CONFIG_80211AC_VHT
#endif
#endif
#define CONFIG_BEAMFORMING
#ifdef CONFIG_BEAMFORMING
/*#define RTW_WKARD_TX_DISABLE_BFEE*/
#endif
/*#define CONFIG_IOCTL_CFG80211*/
#ifdef CONFIG_IOCTL_CFG80211
/*#define RTW_USE_CFG80211_STA_EVENT*/ /* Indecate new sta asoc through cfg80211_new_sta */
#define CONFIG_CFG80211_FORCE_COMPATIBLE_2_6_37_UNDER
/*#define CONFIG_DEBUG_CFG80211*/
#define CONFIG_SET_SCAN_DENY_TIMER
#endif
#define CONFIG_TX_AMSDU
#ifdef CONFIG_TX_AMSDU
#ifdef CONFIG_PLATFORM_RTL8198D
#define CONFIG_TX_AMSDU_HW_MODE 1
#else
#define CONFIG_TX_AMSDU_SW_MODE 1
#endif
#endif
/*
* Internal General Config
*/
/*#define CONFIG_PWRCTRL*/
#define CONFIG_TRX_BD_ARCH /* PCI only */
#define USING_RX_TAG
#define CONFIG_EMBEDDED_FWIMG
#ifdef CONFIG_EMBEDDED_FWIMG
#define LOAD_FW_HEADER_FROM_DRIVER
#endif
/*#define CONFIG_FILE_FWIMG*/
/* #define CONFIG_XMIT_ACK */
#ifdef CONFIG_XMIT_ACK
#define CONFIG_ACTIVE_KEEP_ALIVE_CHECK
#endif
#define BUF_DESC_ARCH /* if defined, hardware follows Rx buffer descriptor architecture */
#ifdef CONFIG_POWER_SAVING
#define CONFIG_IPS
#ifdef CONFIG_IPS
#endif
#define CONFIG_LPS
#if defined(CONFIG_LPS)
/*#define CONFIG_LPS_LCLK*/ /* 32K */
#endif
#ifdef CONFIG_LPS_LCLK
#define CONFIG_XMIT_THREAD_MODE
#define LPS_RPWM_WAIT_MS 300
#endif
#endif
/*#define CONFIG_RTW_IPS*/
/*#define CONFIG_RTW_LPS*/
/*#define CONFIG_ANTENNA_DIVERSITY*/
/*#define CONFIG_PCI_ASPM*/
#ifdef CONFIG_PCI_ASPM
#define CONFIG_PCI_DYNAMIC_ASPM
#endif
#define CONFIG_AP_MODE
#ifdef CONFIG_AP_MODE
#define CONFIG_NATIVEAP_MLME
#ifndef CONFIG_NATIVEAP_MLME
#define CONFIG_HOSTAPD_MLME
#endif
/*#define CONFIG_FIND_BEST_CHANNEL*/
/*#define CONFIG_AUTO_AP_MODE*/
#endif
#define CONFIG_P2P
#ifdef CONFIG_P2P
/* The CONFIG_WFD is for supporting the Wi-Fi display */
#define CONFIG_WFD
#define CONFIG_P2P_REMOVE_GROUP_INFO
/*#define CONFIG_DBG_P2P*/
#define CONFIG_P2P_PS
/*#define CONFIG_P2P_IPS*/
#define CONFIG_P2P_OP_CHK_SOCIAL_CH
#define CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT /* replace CONFIG_P2P_CHK_INVITE_CH_LIST flag */
/*#define CONFIG_P2P_INVITE_IOT*/
#endif
/* Added by Kurt 20110511 */
#ifdef CONFIG_TDLS
#define CONFIG_TDLS_DRIVER_SETUP
#if 0
#ifndef CONFIG_WFD
#define CONFIG_WFD
#endif
#define CONFIG_TDLS_AUTOSETUP
#endif
#define CONFIG_TDLS_AUTOCHECKALIVE
/* #define CONFIG_TDLS_CH_SW */ /* Enable this flag only when we confirm that TDLS CH SW is supported in FW */
#endif
#define CONFIG_SKB_COPY /* for amsdu */
/*#define CONFIG_RTW_LED*/
#ifdef CONFIG_RTW_LED
/*#define CONFIG_RTW_SW_LED*/
#ifdef CONFIG_RTW_SW_LED
/*#define CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD*/
#endif
#endif /* CONFIG_RTW_LED */
#define CONFIG_GLOBAL_UI_PID
/*#define CONFIG_ADAPTOR_INFO_CACHING_FILE*/ /* now just applied on 8192cu only, should make it general...*/
/*#define CONFIG_RESUME_IN_WORKQUEUE*/
/*#define CONFIG_SET_SCAN_DENY_TIMER*/
#define CONFIG_LONG_DELAY_ISSUE
/*#define CONFIG_SIGNAL_DISPLAY_DBM*/ /* display RX signal with dbm */
#ifdef CONFIG_SIGNAL_DISPLAY_DBM
/*#define CONFIG_BACKGROUND_NOISE_MONITOR*/
#endif
/*
* Software feature Related Config
*/
/*
* Interface Related Config
*/
/*
* HAL Related Config
*/
#define CONFIG_RX_PACKET_APPEND_FCS
#define DISABLE_BB_RF 0
#ifdef CONFIG_MP_INCLUDED
#define MP_DRIVER 1
#else
#define MP_DRIVER 0
#endif
#ifndef EFUSE_MAP_PATH
#define EFUSE_MAP_PATH "/system/etc/wifi/wifi_efuse.map"
#endif
#ifndef WIFIMAC_PATH
#define WIFIMAC_PATH "/data/wifimac.txt"
#endif
/* Use cmd frame to issue beacon. Use a fixed buffer for beacon. */
#define CONFIG_BCN_ICF
#ifdef CONFIG_HWSIM
/* Use pure sw beacon */
#undef CONFIG_BCN_ICF
#endif
/* #define RTL8814BE_AMPDU_PRE_TX_OFF */
/*
* Platform Related Config
*/
/* #define CONFIG_TX_EARLY_MODE */
/*
* Debug Related Config
*/
#define DBG 1
/*#define DBG_CONFIG_ERROR_DETECT*/
/* #define DBG_CONFIG_ERROR_DETECT_INT */
/* #define DBG_CONFIG_ERROR_RESET */
/* #define DBG_IO */
/* #define DBG_DELAY_OS */
/* #define DBG_MEM_ALLOC */
/* #define DBG_IOCTL */
/* #define DBG_TX */
/* #define DBG_XMIT_BUF */
/* #define DBG_XMIT_BUF_EXT */
/* #define DBG_TX_DROP_FRAME */
/* #define DBG_RX_DROP_FRAME */
/* #define DBG_RX_SEQ */
/* #define DBG_RX_SIGNAL_DISPLAY_PROCESSING */
/* #define DBG_RX_SIGNAL_DISPLAY_SSID_MONITORED "jeff-ap" */
/* #define DBG_ROAMING_TEST */
/* #define DBG_HAL_INIT_PROFILING */
/*#define DBG_MEMORY_LEAK*/
/* #define CONFIG_FW_C2H_DEBUG */
#define CONFIG_DBG_COUNTER
#define DBG_RX_DFRAME_RAW_DATA
/*#define DBG_TXBD_DESC_DUMP*/
#define CONFIG_PCI_BCN_POLLING
//#define RTW_PHL_TEST_FPGA //For 8852A PCIE FPGA TEST
#ifndef CONFIG_DYNAMIC_RX_BUF
#define CONFIG_DYNAMIC_RX_BUF
#endif
/*#define CONFIG_RTW_BTM_ROAM*/
/*#define CONFIG_RTW_80211R*/
#ifdef CONFIG_RTW_MBO
#ifndef CONFIG_RTW_WNM
#define CONFIG_RTW_WNM
#endif
#ifndef CONFIG_RTW_80211K
#define CONFIG_RTW_80211K
#endif
#endif /* CONFIG_RTW_MBO */
/* Separate TRX path into different CPUs */
/*#define CONFIG_PHL_CPU_BALANCE*/
#ifdef CONFIG_PHL_CPU_BALANCE
#define CONFIG_PHL_CPU_BALANCE_TX
#define CPU_ID_TX_PHL_0 1
/*#define CONFIG_PHL_CPU_BALANCE_RX*/
#define CPU_ID_RX_CORE_0 2
#endif
#ifdef RTW_PHL_TEST_FPGA
#ifndef RTW_PHL_TX
#define RTW_PHL_TX
#endif
#ifndef RTW_PHL_RX
#define RTW_PHL_RX
#endif
#ifndef DIRTY_FOR_WORK
#define DIRTY_FOR_WORK
#endif
#ifndef CONFIG_DYNAMIC_RX_BUF
#define CONFIG_DYNAMIC_RX_BUF
#endif
#ifndef RTW_PHL_DBG_CMD
#define RTW_PHL_DBG_CMD
#endif
#ifndef CONFIG_DRV_FAKE_AP
#error "Please enable CONFIG_DRV_FAKE_AP in Makefile before Beacon ready\n"
#endif
#ifndef RTW_PHL_FWDL
#define RTW_PHL_FWDL
#endif
#ifdef CONFIG_RTW_NAPI
#undef CONFIG_RTW_NAPI
#endif
#ifdef CONFIG_RTW_GRO
#undef CONFIG_RTW_GRO
#endif
#ifdef CONFIG_RTW_NETIF_SG
#undef CONFIG_RTW_NETIF_SG
#endif
#if 1
#define DBGP(fmt, args...) printk("dbg [%s][%d]"fmt, __FUNCTION__, __LINE__, ## args)
#else
#define DBGP(arg...) do {} while (0)
#endif
#else //RTW_PHL_TEST_FPGA
#define DBGP(arg...) do {} while (0)
#endif
/* Platform dependent config, shall put on the bottom of this file */
#ifdef CONFIG_PLATFORM_RTL8198D
#include "autoconf_mips_98d.h"
#endif
/* Platform dependent config, shall put on the bottom of this file */
#ifdef CONFIG_I386_BUILD_VERIFY
#include "autoconf_i386_ap_func.h"
#endif
#ifdef CONFIG_ARCH_CORTINA
#include "autoconf_arm_9617b.h"
#endif /* CONFIG_ARCH_CORTINA */
#include "autoconf_8852be_custom.h"
#if 0 /* For Debug Purpose */
/* Core Config */
#ifndef CONFIG_PHL_USE_KMEM_ALLOC
#define CONFIG_PHL_USE_KMEM_ALLOC
#endif
#ifdef CONFIG_DYNAMIC_RX_BUF
#undef CONFIG_DYNAMIC_RX_BUF
#endif
#define CONFIG_RXBUF_NUM_1024
#define CONFIG_TX_SKB_ORPHAN
#define CONFIG_SWCAP_SYNC_WIN
/* PHL Config */
#define PHL_RX_BATCH_IND
#define RTW_WKARD_98D_RXTAG
#endif
|
2301_81045437/rtl8852be
|
include/autoconf.h
|
C
|
agpl-3.0
| 8,723
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __BASIC_TYPES_H__
#define __BASIC_TYPES_H__
#define SUCCESS 0
#define FAIL (-1)
#ifndef TRUE
#define _TRUE 1
#else
#define _TRUE TRUE
#endif
#ifndef FALSE
#define _FALSE 0
#else
#define _FALSE FALSE
#endif
#ifdef PLATFORM_LINUX
#include <linux/version.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/utsname.h>
typedef signed int sint;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
typedef _Bool bool;
enum {
false = 0,
true = 1
};
#endif
typedef void (*proc_t)(void *);
typedef __kernel_size_t SIZE_T;
typedef __kernel_ssize_t SSIZE_T;
#define FIELD_OFFSET(s, field) ((SSIZE_T)&((s *)(0))->field)
#endif /*PLATFORM_LINUX*/
#ifdef PLATFORM_FREEBSD
typedef signed char s8;
typedef unsigned char u8;
typedef signed short s16;
typedef unsigned short u16;
typedef signed int s32;
typedef unsigned int u32;
typedef unsigned int uint;
typedef signed int sint;
typedef signed long long s64;
typedef unsigned long long u64;
typedef u32 dma_addr_t;
typedef long atomic_t;
typedef void (*proc_t)(void *);
typedef unsigned int __kernel_size_t;
typedef int __kernel_ssize_t;
typedef __kernel_size_t SIZE_T;
typedef __kernel_ssize_t SSIZE_T;
#define FIELD_OFFSET(s, field) ((SSIZE_T)&((s *)(0))->field)
#endif
#define MEM_ALIGNMENT_OFFSET (sizeof (SIZE_T))
#define MEM_ALIGNMENT_PADDING (sizeof(SIZE_T) - 1)
#define SIZE_PTR SIZE_T
#define SSIZE_PTR SSIZE_T
/*
* Continuous bits starting from least significant bit
* Example:
* BIT_LEN_MASK_32(0) => 0x00000000
* BIT_LEN_MASK_32(1) => 0x00000001
* BIT_LEN_MASK_32(2) => 0x00000003
* BIT_LEN_MASK_32(32) => 0xFFFFFFFF
*/
#define BIT_LEN_MASK_32(__BitLen) ((u32)(0xFFFFFFFF >> (32 - (__BitLen))))
#define BIT_LEN_MASK_16(__BitLen) ((u16)(0xFFFF >> (16 - (__BitLen))))
#define BIT_LEN_MASK_8(__BitLen) ((u8)(0xFF >> (8 - (__BitLen))))
/*
* Continuous bits starting from least significant bit
* Example:
* BIT_OFFSET_LEN_MASK_32(0, 2) => 0x00000003
* BIT_OFFSET_LEN_MASK_32(16, 2) => 0x00030000
*/
#define BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen) ((u32)(BIT_LEN_MASK_32(__BitLen) << (__BitOffset)))
#define BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen) ((u16)(BIT_LEN_MASK_16(__BitLen) << (__BitOffset)))
#define BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen) ((u8)(BIT_LEN_MASK_8(__BitLen) << (__BitOffset)))
/*
* Convert LE data to host byte order
*/
#define EF1Byte (u8)
#define EF2Byte le16_to_cpu
#define EF4Byte le32_to_cpu
/*
* Read LE data from memory to host byte order
*/
#define ReadLE4Byte(_ptr) le32_to_cpu(*((u32 *)(_ptr)))
#define ReadLE2Byte(_ptr) le16_to_cpu(*((u16 *)(_ptr)))
#define ReadLE1Byte(_ptr) (*((u8 *)(_ptr)))
/*
* Read BE data from memory to host byte order
*/
#define ReadBEE4Byte(_ptr) be32_to_cpu(*((u32 *)(_ptr)))
#define ReadBE2Byte(_ptr) be16_to_cpu(*((u16 *)(_ptr)))
#define ReadBE1Byte(_ptr) (*((u8 *)(_ptr)))
/*
* Write host byte order data to memory in LE order
*/
#define WriteLE4Byte(_ptr, _val) ((*((u32 *)(_ptr))) = cpu_to_le32(_val))
#define WriteLE2Byte(_ptr, _val) ((*((u16 *)(_ptr))) = cpu_to_le16(_val))
#define WriteLE1Byte(_ptr, _val) ((*((u8 *)(_ptr))) = ((u8)(_val)))
/*
* Write host byte order data to memory in BE order
*/
#define WriteBE4Byte(_ptr, _val) ((*((u32 *)(_ptr))) = cpu_to_be32(_val))
#define WriteBE2Byte(_ptr, _val) ((*((u16 *)(_ptr))) = cpu_to_be16(_val))
#define WriteBE1Byte(_ptr, _val) ((*((u8 *)(_ptr))) = ((u8)(_val)))
/*
* Return 4-byte value in host byte ordering from 4-byte pointer in litten-endian system.
*/
#define LE_P4BYTE_TO_HOST_4BYTE(__pStart) (le32_to_cpu(*((u32 *)(__pStart))))
#define LE_P2BYTE_TO_HOST_2BYTE(__pStart) (le16_to_cpu(*((u16 *)(__pStart))))
#define LE_P1BYTE_TO_HOST_1BYTE(__pStart) ((*((u8 *)(__pStart))))
/*
* Return 4-byte value in host byte ordering from 4-byte pointer in big-endian system.
*/
#define BE_P4BYTE_TO_HOST_4BYTE(__pStart) (be32_to_cpu(*((u32 *)(__pStart))))
#define BE_P2BYTE_TO_HOST_2BYTE(__pStart) (be16_to_cpu(*((u16 *)(__pStart))))
#define BE_P1BYTE_TO_HOST_1BYTE(__pStart) ((*((u8 *)(__pStart))))
/*
* Translate subfield (continuous bits in little-endian) of 4-byte value in LE byte to
* 4-byte value in host byte ordering.
*/
#define LE_BITS_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
((LE_P4BYTE_TO_HOST_4BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_32(__BitLen))
#define LE_BITS_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
((LE_P2BYTE_TO_HOST_2BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_16(__BitLen))
#define LE_BITS_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
((LE_P1BYTE_TO_HOST_1BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_8(__BitLen))
/*
* Translate subfield (continuous bits in big-endian) of 4-byte value in BE byte to
* 4-byte value in host byte ordering.
*/
#define BE_BITS_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
((BE_P4BYTE_TO_HOST_4BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_32(__BitLen))
#define BE_BITS_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
((BE_P2BYTE_TO_HOST_2BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_16(__BitLen))
#define BE_BITS_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
((BE_P1BYTE_TO_HOST_1BYTE(__pStart) >> (__BitOffset)) & BIT_LEN_MASK_8(__BitLen))
/*
* Mask subfield (continuous bits in little-endian) of 4-byte value in LE byte oredering
* and return the result in 4-byte value in host byte ordering.
*/
#define LE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
(LE_P4BYTE_TO_HOST_4BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen)))
#define LE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
(LE_P2BYTE_TO_HOST_2BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen)))
#define LE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
(LE_P1BYTE_TO_HOST_1BYTE(__pStart) & ((u8)(~BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen))))
/*
* Mask subfield (continuous bits in big-endian) of 4-byte value in BE byte oredering
* and return the result in 4-byte value in host byte ordering.
*/
#define BE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
(BE_P4BYTE_TO_HOST_4BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen)))
#define BE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
(BE_P2BYTE_TO_HOST_2BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen)))
#define BE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
(BE_P1BYTE_TO_HOST_1BYTE(__pStart) & (~BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen)))
/*
* Set subfield of little-endian 4-byte value to specified value.
*/
#define SET_BITS_TO_LE_4BYTE(__pStart, __BitOffset, __BitLen, __Value) \
do { \
if (__BitOffset == 0 && __BitLen == 32) \
WriteLE4Byte(__pStart, __Value); \
else { \
WriteLE4Byte(__pStart, \
LE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
| \
((((u32)__Value) & BIT_LEN_MASK_32(__BitLen)) << (__BitOffset)) \
); \
} \
} while (0)
#define SET_BITS_TO_LE_2BYTE(__pStart, __BitOffset, __BitLen, __Value) \
do { \
if (__BitOffset == 0 && __BitLen == 16) \
WriteLE2Byte(__pStart, __Value); \
else { \
WriteLE2Byte(__pStart, \
LE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
| \
((((u16)__Value) & BIT_LEN_MASK_16(__BitLen)) << (__BitOffset)) \
); \
} \
} while (0)
#define SET_BITS_TO_LE_1BYTE(__pStart, __BitOffset, __BitLen, __Value) \
do { \
if (__BitOffset == 0 && __BitLen == 8) \
WriteLE1Byte(__pStart, __Value); \
else { \
WriteLE1Byte(__pStart, \
LE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
| \
((((u8)__Value) & BIT_LEN_MASK_8(__BitLen)) << (__BitOffset)) \
); \
} \
} while (0)
/*
* Set subfield of big-endian 4-byte value to specified value.
*/
#define SET_BITS_TO_BE_4BYTE(__pStart, __BitOffset, __BitLen, __Value) \
do { \
if (__BitOffset == 0 && __BitLen == 32) \
WriteBE4Byte(__pStart, __Value); \
else { \
WriteBE4Byte(__pStart, \
BE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
| \
((((u32)__Value) & BIT_LEN_MASK_32(__BitLen)) << (__BitOffset)) \
); \
} \
} while (0)
#define SET_BITS_TO_BE_2BYTE(__pStart, __BitOffset, __BitLen, __Value) \
do { \
if (__BitOffset == 0 && __BitLen == 16) \
WriteBE2Byte(__pStart, __Value); \
else { \
WriteBE2Byte(__pStart, \
BE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
| \
((((u16)__Value) & BIT_LEN_MASK_16(__BitLen)) << (__BitOffset)) \
); \
} \
} while (0)
#define SET_BITS_TO_BE_1BYTE(__pStart, __BitOffset, __BitLen, __Value) \
do { \
if (__BitOffset == 0 && __BitLen == 8) \
WriteBE1Byte(__pStart, __Value); \
else { \
WriteBE1Byte(__pStart, \
BE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
| \
((((u8)__Value) & BIT_LEN_MASK_8(__BitLen)) << (__BitOffset)) \
); \
} \
} while (0)
/* Get the N-bytes aligment offset from the current length */
#define N_BYTE_ALIGMENT(__Value, __Aligment) ((__Aligment == 1) ? (__Value) : (((__Value + __Aligment - 1) / __Aligment) * __Aligment))
#define N_BYTE_ALIGNMENT(__Value, __Alignment) ((__Alignment == 1)\
? (__Value) : (((__Value + __Alignment - 1) / __Alignment) * __Alignment))
typedef unsigned char BOOLEAN, *PBOOLEAN, boolean;
#define _FAIL 0
#define _SUCCESS 1
#undef _TRUE
#define _TRUE 1
#undef _FALSE
#define _FALSE 0
#define TEST_FLAG(__Flag, __testFlag) (((__Flag) & (__testFlag)) != 0)
#define SET_FLAG(__Flag, __setFlag) ((__Flag) |= __setFlag)
#define CLEAR_FLAG(__Flag, __clearFlag) ((__Flag) &= ~(__clearFlag))
#define CLEAR_FLAGS(__Flag) ((__Flag) = 0)
#define TEST_FLAGS(__Flag, __testFlags) (((__Flag) & (__testFlags)) == (__testFlags))
#endif /* __BASIC_TYPES_H__ */
|
2301_81045437/rtl8852be
|
include/basic_types.h
|
C
|
agpl-3.0
| 10,391
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef _LINUX_BYTEORDER_BIG_ENDIAN_H
#define _LINUX_BYTEORDER_BIG_ENDIAN_H
#ifndef __BIG_ENDIAN
#define __BIG_ENDIAN 4321
#endif
#ifndef __BIG_ENDIAN_BITFIELD
#define __BIG_ENDIAN_BITFIELD
#endif
#include <byteorder/swab.h>
#define __constant_htonl(x) ((__u32)(x))
#define __constant_ntohl(x) ((__u32)(x))
#define __constant_htons(x) ((__u16)(x))
#define __constant_ntohs(x) ((__u16)(x))
#define __constant_cpu_to_le64(x) ___constant_swab64((x))
#define __constant_le64_to_cpu(x) ___constant_swab64((x))
#define __constant_cpu_to_le32(x) ___constant_swab32((x))
#define __constant_le32_to_cpu(x) ___constant_swab32((x))
#define __constant_cpu_to_le16(x) ___constant_swab16((x))
#define __constant_le16_to_cpu(x) ___constant_swab16((x))
#define __constant_cpu_to_be64(x) ((__u64)(x))
#define __constant_be64_to_cpu(x) ((__u64)(x))
#define __constant_cpu_to_be32(x) ((__u32)(x))
#define __constant_be32_to_cpu(x) ((__u32)(x))
#define __constant_cpu_to_be16(x) ((__u16)(x))
#define __constant_be16_to_cpu(x) ((__u16)(x))
#define __cpu_to_le64(x) __swab64((x))
#define __le64_to_cpu(x) __swab64((x))
#define __cpu_to_le32(x) __swab32((x))
#define __le32_to_cpu(x) __swab32((x))
#define __cpu_to_le16(x) __swab16((x))
#define __le16_to_cpu(x) __swab16((x))
#define __cpu_to_be64(x) ((__u64)(x))
#define __be64_to_cpu(x) ((__u64)(x))
#define __cpu_to_be32(x) ((__u32)(x))
#define __be32_to_cpu(x) ((__u32)(x))
#define __cpu_to_be16(x) ((__u16)(x))
#define __be16_to_cpu(x) ((__u16)(x))
#define __cpu_to_le64p(x) __swab64p((x))
#define __le64_to_cpup(x) __swab64p((x))
#define __cpu_to_le32p(x) __swab32p((x))
#define __le32_to_cpup(x) __swab32p((x))
#define __cpu_to_le16p(x) __swab16p((x))
#define __le16_to_cpup(x) __swab16p((x))
#define __cpu_to_be64p(x) (*(__u64 *)(x))
#define __be64_to_cpup(x) (*(__u64 *)(x))
#define __cpu_to_be32p(x) (*(__u32 *)(x))
#define __be32_to_cpup(x) (*(__u32 *)(x))
#define __cpu_to_be16p(x) (*(__u16 *)(x))
#define __be16_to_cpup(x) (*(__u16 *)(x))
#define __cpu_to_le64s(x) __swab64s((x))
#define __le64_to_cpus(x) __swab64s((x))
#define __cpu_to_le32s(x) __swab32s((x))
#define __le32_to_cpus(x) __swab32s((x))
#define __cpu_to_le16s(x) __swab16s((x))
#define __le16_to_cpus(x) __swab16s((x))
#define __cpu_to_be64s(x) do {} while (0)
#define __be64_to_cpus(x) do {} while (0)
#define __cpu_to_be32s(x) do {} while (0)
#define __be32_to_cpus(x) do {} while (0)
#define __cpu_to_be16s(x) do {} while (0)
#define __be16_to_cpus(x) do {} while (0)
#include <byteorder/generic.h>
#endif /* _LINUX_BYTEORDER_BIG_ENDIAN_H */
|
2301_81045437/rtl8852be
|
include/byteorder/big_endian.h
|
C
|
agpl-3.0
| 3,214
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef _LINUX_BYTEORDER_GENERIC_H
#define _LINUX_BYTEORDER_GENERIC_H
/*
* linux/byteorder_generic.h
* Generic Byte-reordering support
*
* Francois-Rene Rideau <fare@tunes.org> 19970707
* gathered all the good ideas from all asm-foo/byteorder.h into one file,
* cleaned them up.
* I hope it is compliant with non-GCC compilers.
* I decided to put __BYTEORDER_HAS_U64__ in byteorder.h,
* because I wasn't sure it would be ok to put it in types.h
* Upgraded it to 2.1.43
* Francois-Rene Rideau <fare@tunes.org> 19971012
* Upgraded it to 2.1.57
* to please Linus T., replaced huge #ifdef's between little/big endian
* by nestedly #include'd files.
* Francois-Rene Rideau <fare@tunes.org> 19971205
* Made it to 2.1.71; now a facelift:
* Put files under include/linux/byteorder/
* Split swab from generic support.
*
* TODO:
* = Regular kernel maintainers could also replace all these manual
* byteswap macros that remain, disseminated among drivers,
* after some grep or the sources...
* = Linus might want to rename all these macros and files to fit his taste,
* to fit his personal naming scheme.
* = it seems that a few drivers would also appreciate
* nybble swapping support...
* = every architecture could add their byteswap macro in asm/byteorder.h
* see how some architectures already do (i386, alpha, ppc, etc)
* = cpu_to_beXX and beXX_to_cpu might some day need to be well
* distinguished throughout the kernel. This is not the case currently,
* since little endian, big endian, and pdp endian machines needn't it.
* But this might be the case for, say, a port of Linux to 20/21 bit
* architectures (and F21 Linux addict around?).
*/
/*
* The following macros are to be defined by <asm/byteorder.h>:
*
* Conversion of long and short int between network and host format
* ntohl(__u32 x)
* ntohs(__u16 x)
* htonl(__u32 x)
* htons(__u16 x)
* It seems that some programs (which? where? or perhaps a standard? POSIX?)
* might like the above to be functions, not macros (why?).
* if that's true, then detect them, and take measures.
* Anyway, the measure is: define only ___ntohl as a macro instead,
* and in a separate file, have
* unsigned long inline ntohl(x){return ___ntohl(x);}
*
* The same for constant arguments
* __constant_ntohl(__u32 x)
* __constant_ntohs(__u16 x)
* __constant_htonl(__u32 x)
* __constant_htons(__u16 x)
*
* Conversion of XX-bit integers (16- 32- or 64-)
* between native CPU format and little/big endian format
* 64-bit stuff only defined for proper architectures
* cpu_to_[bl]eXX(__uXX x)
* [bl]eXX_to_cpu(__uXX x)
*
* The same, but takes a pointer to the value to convert
* cpu_to_[bl]eXXp(__uXX x)
* [bl]eXX_to_cpup(__uXX x)
*
* The same, but change in situ
* cpu_to_[bl]eXXs(__uXX x)
* [bl]eXX_to_cpus(__uXX x)
*
* See asm-foo/byteorder.h for examples of how to provide
* architecture-optimized versions
*
*/
#if defined(PLATFORM_LINUX) || defined(PLATFORM_MPIXEL) || defined(PLATFORM_FREEBSD)
/*
* inside the kernel, we can use nicknames;
* outside of it, we must avoid POSIX namespace pollution...
*/
#define cpu_to_le64 __cpu_to_le64
#define le64_to_cpu __le64_to_cpu
#define cpu_to_le32 __cpu_to_le32
#define le32_to_cpu __le32_to_cpu
#define cpu_to_le16 __cpu_to_le16
#define le16_to_cpu __le16_to_cpu
#define cpu_to_be64 __cpu_to_be64
#define be64_to_cpu __be64_to_cpu
#define cpu_to_be32 __cpu_to_be32
#define be32_to_cpu __be32_to_cpu
#define cpu_to_be16 __cpu_to_be16
#define be16_to_cpu __be16_to_cpu
#define cpu_to_le64p __cpu_to_le64p
#define le64_to_cpup __le64_to_cpup
#define cpu_to_le32p __cpu_to_le32p
#define le32_to_cpup __le32_to_cpup
#define cpu_to_le16p __cpu_to_le16p
#define le16_to_cpup __le16_to_cpup
#define cpu_to_be64p __cpu_to_be64p
#define be64_to_cpup __be64_to_cpup
#define cpu_to_be32p __cpu_to_be32p
#define be32_to_cpup __be32_to_cpup
#define cpu_to_be16p __cpu_to_be16p
#define be16_to_cpup __be16_to_cpup
#define cpu_to_le64s __cpu_to_le64s
#define le64_to_cpus __le64_to_cpus
#define cpu_to_le32s __cpu_to_le32s
#define le32_to_cpus __le32_to_cpus
#define cpu_to_le16s __cpu_to_le16s
#define le16_to_cpus __le16_to_cpus
#define cpu_to_be64s __cpu_to_be64s
#define be64_to_cpus __be64_to_cpus
#define cpu_to_be32s __cpu_to_be32s
#define be32_to_cpus __be32_to_cpus
#define cpu_to_be16s __cpu_to_be16s
#define be16_to_cpus __be16_to_cpus
#endif
/*
* Handle ntohl and suches. These have various compatibility
* issues - like we want to give the prototype even though we
* also have a macro for them in case some strange program
* wants to take the address of the thing or something..
*
* Note that these used to return a "long" in libc5, even though
* long is often 64-bit these days.. Thus the casts.
*
* They have to be macros in order to do the constant folding
* correctly - if the argument passed into a inline function
* it is no longer constant according to gcc..
*/
#undef ntohl
#undef ntohs
#undef htonl
#undef htons
/*
* Do the prototypes. Somebody might want to take the
* address or some such sick thing..
*/
#if defined(PLATFORM_LINUX) || (defined(__GLIBC__) && __GLIBC__ >= 2)
extern __u32 ntohl(__u32);
extern __u32 htonl(__u32);
#else /* defined(PLATFORM_LINUX) || (defined (__GLIBC__) && __GLIBC__ >= 2) */
extern unsigned long int ntohl(unsigned long int);
extern unsigned long int htonl(unsigned long int);
#endif
extern unsigned short int ntohs(unsigned short int);
extern unsigned short int htons(unsigned short int);
#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__) || defined(PLATFORM_MPIXEL)
#define ___htonl(x) __cpu_to_be32(x)
#define ___htons(x) __cpu_to_be16(x)
#define ___ntohl(x) __be32_to_cpu(x)
#define ___ntohs(x) __be16_to_cpu(x)
#if defined(PLATFORM_LINUX) || (defined(__GLIBC__) && __GLIBC__ >= 2)
#define htonl(x) ___htonl(x)
#define ntohl(x) ___ntohl(x)
#else
#define htonl(x) ((unsigned long)___htonl(x))
#define ntohl(x) ((unsigned long)___ntohl(x))
#endif
#define htons(x) ___htons(x)
#define ntohs(x) ___ntohs(x)
#endif /* OPTIMIZE */
#endif /* _LINUX_BYTEORDER_GENERIC_H */
|
2301_81045437/rtl8852be
|
include/byteorder/generic.h
|
C
|
agpl-3.0
| 6,897
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef _LINUX_BYTEORDER_LITTLE_ENDIAN_H
#define _LINUX_BYTEORDER_LITTLE_ENDIAN_H
#ifndef __LITTLE_ENDIAN
#define __LITTLE_ENDIAN 1234
#endif
#ifndef __LITTLE_ENDIAN_BITFIELD
#define __LITTLE_ENDIAN_BITFIELD
#endif
#include <byteorder/swab.h>
#ifndef __constant_htonl
#define __constant_htonl(x) ___constant_swab32((x))
#define __constant_ntohl(x) ___constant_swab32((x))
#define __constant_htons(x) ___constant_swab16((x))
#define __constant_ntohs(x) ___constant_swab16((x))
#define __constant_cpu_to_le64(x) ((__u64)(x))
#define __constant_le64_to_cpu(x) ((__u64)(x))
#define __constant_cpu_to_le32(x) ((__u32)(x))
#define __constant_le32_to_cpu(x) ((__u32)(x))
#define __constant_cpu_to_le16(x) ((__u16)(x))
#define __constant_le16_to_cpu(x) ((__u16)(x))
#define __constant_cpu_to_be64(x) ___constant_swab64((x))
#define __constant_be64_to_cpu(x) ___constant_swab64((x))
#define __constant_cpu_to_be32(x) ___constant_swab32((x))
#define __constant_be32_to_cpu(x) ___constant_swab32((x))
#define __constant_cpu_to_be16(x) ___constant_swab16((x))
#define __constant_be16_to_cpu(x) ___constant_swab16((x))
#define __cpu_to_le64(x) ((__u64)(x))
#define __le64_to_cpu(x) ((__u64)(x))
#define __cpu_to_le32(x) ((__u32)(x))
#define __le32_to_cpu(x) ((__u32)(x))
#define __cpu_to_le16(x) ((__u16)(x))
#define __le16_to_cpu(x) ((__u16)(x))
#define __cpu_to_be64(x) __swab64((x))
#define __be64_to_cpu(x) __swab64((x))
#define __cpu_to_be32(x) __swab32((x))
#define __be32_to_cpu(x) __swab32((x))
#define __cpu_to_be16(x) __swab16((x))
#define __be16_to_cpu(x) __swab16((x))
#define __cpu_to_le64p(x) (*(__u64 *)(x))
#define __le64_to_cpup(x) (*(__u64 *)(x))
#define __cpu_to_le32p(x) (*(__u32 *)(x))
#define __le32_to_cpup(x) (*(__u32 *)(x))
#define __cpu_to_le16p(x) (*(__u16 *)(x))
#define __le16_to_cpup(x) (*(__u16 *)(x))
#define __cpu_to_be64p(x) __swab64p((x))
#define __be64_to_cpup(x) __swab64p((x))
#define __cpu_to_be32p(x) __swab32p((x))
#define __be32_to_cpup(x) __swab32p((x))
#define __cpu_to_be16p(x) __swab16p((x))
#define __be16_to_cpup(x) __swab16p((x))
#define __cpu_to_le64s(x) do {} while (0)
#define __le64_to_cpus(x) do {} while (0)
#define __cpu_to_le32s(x) do {} while (0)
#define __le32_to_cpus(x) do {} while (0)
#define __cpu_to_le16s(x) do {} while (0)
#define __le16_to_cpus(x) do {} while (0)
#define __cpu_to_be64s(x) __swab64s((x))
#define __be64_to_cpus(x) __swab64s((x))
#define __cpu_to_be32s(x) __swab32s((x))
#define __be32_to_cpus(x) __swab32s((x))
#define __cpu_to_be16s(x) __swab16s((x))
#define __be16_to_cpus(x) __swab16s((x))
#endif /* __constant_htonl */
#include <byteorder/generic.h>
#endif /* _LINUX_BYTEORDER_LITTLE_ENDIAN_H */
|
2301_81045437/rtl8852be
|
include/byteorder/little_endian.h
|
C
|
agpl-3.0
| 3,386
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef _LINUX_BYTEORDER_SWAB_H
#define _LINUX_BYTEORDER_SWAB_H
#if !defined(CONFIG_PLATFORM_MSTAR)
#ifndef __u16
typedef unsigned short __u16;
#endif
#ifndef __u32
typedef unsigned int __u32;
#endif
#ifndef __u8
typedef unsigned char __u8;
#endif
#ifndef __u64
typedef unsigned long long __u64;
#endif
__inline static __u16 ___swab16(__u16 x)
{
__u16 __x = x;
return
(__u16)(
(((__u16)(__x)&(__u16)0x00ffU) << 8) |
(((__u16)(__x)&(__u16)0xff00U) >> 8));
}
__inline static __u32 ___swab32(__u32 x)
{
__u32 __x = (x);
return (__u32)(
(((__u32)(__x)&(__u32)0x000000ffUL) << 24) |
(((__u32)(__x)&(__u32)0x0000ff00UL) << 8) |
(((__u32)(__x)&(__u32)0x00ff0000UL) >> 8) |
(((__u32)(__x)&(__u32)0xff000000UL) >> 24));
}
__inline static __u64 ___swab64(__u64 x)
{
__u64 __x = (x);
return
(__u64)(\
(__u64)(((__u64)(__x)&(__u64)0x00000000000000ffULL) << 56) | \
(__u64)(((__u64)(__x)&(__u64)0x000000000000ff00ULL) << 40) | \
(__u64)(((__u64)(__x)&(__u64)0x0000000000ff0000ULL) << 24) | \
(__u64)(((__u64)(__x)&(__u64)0x00000000ff000000ULL) << 8) | \
(__u64)(((__u64)(__x)&(__u64)0x000000ff00000000ULL) >> 8) | \
(__u64)(((__u64)(__x)&(__u64)0x0000ff0000000000ULL) >> 24) | \
(__u64)(((__u64)(__x)&(__u64)0x00ff000000000000ULL) >> 40) | \
(__u64)(((__u64)(__x)&(__u64)0xff00000000000000ULL) >> 56));
\
}
#endif /* CONFIG_PLATFORM_MSTAR */
#ifndef __arch__swab16
__inline static __u16 __arch__swab16(__u16 x)
{
return ___swab16(x);
}
#endif
#ifndef __arch__swab32
__inline static __u32 __arch__swab32(__u32 x)
{
__u32 __tmp = (x) ;
return ___swab32(__tmp);
}
#endif
#ifndef __arch__swab64
__inline static __u64 __arch__swab64(__u64 x)
{
__u64 __tmp = (x) ;
return ___swab64(__tmp);
}
#endif
#ifndef __swab16
#define __swab16(x) __fswab16(x)
#define __swab32(x) __fswab32(x)
#define __swab64(x) __fswab64(x)
#endif /* __swab16 */
#ifdef PLATFORM_FREEBSD
__inline static __u16 __fswab16(__u16 x)
#else
__inline static const __u16 __fswab16(__u16 x)
#endif /* PLATFORM_FREEBSD */
{
return __arch__swab16(x);
}
#ifdef PLATFORM_FREEBSD
__inline static __u32 __fswab32(__u32 x)
#else
__inline static const __u32 __fswab32(__u32 x)
#endif /* PLATFORM_FREEBSD */
{
return __arch__swab32(x);
}
#if defined(PLATFORM_LINUX)
#define swab16 __swab16
#define swab32 __swab32
#define swab64 __swab64
#define swab16p __swab16p
#define swab32p __swab32p
#define swab64p __swab64p
#define swab16s __swab16s
#define swab32s __swab32s
#define swab64s __swab64s
#endif
#endif /* _LINUX_BYTEORDER_SWAB_H */
|
2301_81045437/rtl8852be
|
include/byteorder/swab.h
|
C
|
agpl-3.0
| 3,243
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef _LINUX_BYTEORDER_SWABB_H
#define _LINUX_BYTEORDER_SWABB_H
/*
* linux/byteorder/swabb.h
* SWAp Bytes Bizarrely
* swaHHXX[ps]?(foo)
*
* Support for obNUXIous pdp-endian and other bizarre architectures.
* Will Linux ever run on such ancient beasts? if not, this file
* will be but a programming pearl. Still, it's a reminder that we
* shouldn't be making too many assumptions when trying to be portable.
*
*/
/*
* Meaning of the names I chose (vaxlinux people feel free to correct them):
* swahw32 swap 16-bit half-words in a 32-bit word
* swahb32 swap 8-bit halves of each 16-bit half-word in a 32-bit word
*
* No 64-bit support yet. I don't know NUXI conventions for long longs.
* I guarantee it will be a mess when it's there, though :->
* It will be even worse if there are conflicting 64-bit conventions.
* Hopefully, no one ever used 64-bit objects on NUXI machines.
*
*/
#define ___swahw32(x) \
({ \
__u32 __x = (x); \
((__u32)(\
(((__u32)(__x) & (__u32)0x0000ffffUL) << 16) | \
(((__u32)(__x) & (__u32)0xffff0000UL) >> 16))); \
})
#define ___swahb32(x) \
({ \
__u32 __x = (x); \
((__u32)(\
(((__u32)(__x) & (__u32)0x00ff00ffUL) << 8) | \
(((__u32)(__x) & (__u32)0xff00ff00UL) >> 8))); \
})
#define ___constant_swahw32(x) \
((__u32)(\
(((__u32)(x) & (__u32)0x0000ffffUL) << 16) | \
(((__u32)(x) & (__u32)0xffff0000UL) >> 16)))
#define ___constant_swahb32(x) \
((__u32)(\
(((__u32)(x) & (__u32)0x00ff00ffUL) << 8) | \
(((__u32)(x) & (__u32)0xff00ff00UL) >> 8)))
/*
* provide defaults when no architecture-specific optimization is detected
*/
#ifndef __arch__swahw32
#define __arch__swahw32(x) ___swahw32(x)
#endif
#ifndef __arch__swahb32
#define __arch__swahb32(x) ___swahb32(x)
#endif
#ifndef __arch__swahw32p
#define __arch__swahw32p(x) __swahw32(*(x))
#endif
#ifndef __arch__swahb32p
#define __arch__swahb32p(x) __swahb32(*(x))
#endif
#ifndef __arch__swahw32s
#define __arch__swahw32s(x) do { *(x) = __swahw32p((x)); } while (0)
#endif
#ifndef __arch__swahb32s
#define __arch__swahb32s(x) do { *(x) = __swahb32p((x)); } while (0)
#endif
/*
* Allow constant folding
*/
#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__)
# define __swahw32(x) \
(__builtin_constant_p((__u32)(x)) ? \
___swahw32((x)) : \
__fswahw32((x)))
# define __swahb32(x) \
(__builtin_constant_p((__u32)(x)) ? \
___swahb32((x)) : \
__fswahb32((x)))
#else
# define __swahw32(x) __fswahw32(x)
# define __swahb32(x) __fswahb32(x)
#endif /* OPTIMIZE */
__inline static__ __const__ __u32 __fswahw32(__u32 x)
{
return __arch__swahw32(x);
}
__inline static__ __u32 __swahw32p(__u32 *x)
{
return __arch__swahw32p(x);
}
__inline static__ void __swahw32s(__u32 *addr)
{
__arch__swahw32s(addr);
}
__inline static__ __const__ __u32 __fswahb32(__u32 x)
{
return __arch__swahb32(x);
}
__inline static__ __u32 __swahb32p(__u32 *x)
{
return __arch__swahb32p(x);
}
__inline static__ void __swahb32s(__u32 *addr)
{
__arch__swahb32s(addr);
}
#ifdef __BYTEORDER_HAS_U64__
/*
* Not supported yet
*/
#endif /* __BYTEORDER_HAS_U64__ */
#if defined(PLATFORM_LINUX)
#define swahw32 __swahw32
#define swahb32 __swahb32
#define swahw32p __swahw32p
#define swahb32p __swahb32p
#define swahw32s __swahw32s
#define swahb32s __swahb32s
#endif
#endif /* _LINUX_BYTEORDER_SWABB_H */
|
2301_81045437/rtl8852be
|
include/byteorder/swabb.h
|
C
|
agpl-3.0
| 4,020
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __CIRC_BUF_H_
#define __CIRC_BUF_H_ 1
#define CIRC_CNT(head,tail,size) (((head) - (tail)) & ((size)-1))
#define CIRC_SPACE(head,tail,size) CIRC_CNT((tail),((head)+1),(size))
#endif //_CIRC_BUF_H_
|
2301_81045437/rtl8852be
|
include/circ_buf.h
|
C
|
agpl-3.0
| 864
|
/******************************************************************************
*
* Copyright(c) 2016 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __CUSTOM_GPIO_H__
#define __CUSTOM_GPIO_H___
#include <drv_conf.h>
#include <osdep_service.h>
typedef enum cust_gpio_modes {
WLAN_PWDN_ON,
WLAN_PWDN_OFF,
WLAN_POWER_ON,
WLAN_POWER_OFF,
WLAN_BT_PWDN_ON,
WLAN_BT_PWDN_OFF
} cust_gpio_modes_t;
extern int rtw_wifi_gpio_init(void);
extern int rtw_wifi_gpio_deinit(void);
extern void rtw_wifi_gpio_wlan_ctrl(int onoff);
#endif
|
2301_81045437/rtl8852be
|
include/custom_gpio.h
|
C
|
agpl-3.0
| 1,045
|
/******************************************************************************
*
* Copyright(c) 2007 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __DRV_CONF_H__
#define __DRV_CONF_H__
#include "autoconf.h"
#define CONFIG_RSSI_PRIORITY
/*
* RTW_BUSY_DENY_SCAN control if scan would be denied by busy traffic.
* When this defined, BUSY_TRAFFIC_SCAN_DENY_PERIOD would be used to judge if
* scan request coming from scan UI. Scan request from scan UI would be
* exception and never be denied by busy traffic.
*/
#define RTW_BUSY_DENY_SCAN
#if defined(CONFIG_MCC_MODE) && (!defined(CONFIG_CONCURRENT_MODE))
#error "Enable CONCURRENT_MODE before enable MCC MODE\n"
#endif
#if defined(CONFIG_MCC_MODE) && defined(CONFIG_BTC)
#error "Disable BT COEXIST before enable MCC MODE\n"
#endif
#if defined(CONFIG_MCC_MODE) && defined(CONFIG_TDLS)
#error "Disable TDLS before enable MCC MODE\n"
#endif
#if defined(CONFIG_RTW_80211R) && !defined(CONFIG_LAYER2_ROAMING)
#error "Enable CONFIG_LAYER2_ROAMING before enable CONFIG_RTW_80211R\n"
#endif
#ifdef CONFIG_RTW_ANDROID
#include <linux/version.h>
#ifndef CONFIG_IOCTL_CFG80211
#define CONFIG_IOCTL_CFG80211
#endif
#ifndef RTW_USE_CFG80211_STA_EVENT
#define RTW_USE_CFG80211_STA_EVENT
#endif
#if (CONFIG_RTW_ANDROID > 4)
#ifndef CONFIG_RADIO_WORK
#define CONFIG_RADIO_WORK
#endif
#endif
#if (CONFIG_RTW_ANDROID >= 8)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,0))
#ifndef CONFIG_RTW_WIFI_HAL
#define CONFIG_RTW_WIFI_HAL
#endif
#else
#error "Linux kernel version is too old\n"
#endif
#endif
#ifdef CONFIG_RTW_WIFI_HAL
#ifndef CONFIG_RTW_WIFI_HAL_DEBUG
//#define CONFIG_RTW_WIFI_HAL_DEBUG
#endif
#if (CONFIG_RTW_ANDROID < 11)
#ifndef CONFIG_RTW_CFGVENDOR_LLSTATS
#define CONFIG_RTW_CFGVENDOR_LLSTATS
#endif
#endif
#ifndef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
#define CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
#endif
#ifndef CONFIG_RTW_CFGVENDOR_RSSIMONITOR
#define CONFIG_RTW_CFGVENDOR_RSSIMONITOR
#endif
#ifndef CONFIG_RTW_CFGVENDOR_WIFI_LOGGER
#define CONFIG_RTW_CFGVENDOR_WIFI_LOGGER
#endif
#if (CONFIG_RTW_ANDROID >= 10)
#ifndef CONFIG_RTW_CFGVENDOR_WIFI_OFFLOAD
//#define CONFIG_RTW_CFGVENDOR_WIFI_OFFLOAD
#endif
//#ifndef CONFIG_KERNEL_PATCH_EXTERNAL_AUTH
//#define CONFIG_KERNEL_PATCH_EXTERNAL_AUTH
//#endif
#endif
#endif // CONFIG_RTW_WIFI_HAL
/* Some Android build will restart the UI while non-printable ascii is passed
* between java and c/c++ layer (JNI). We force CONFIG_VALIDATE_SSID
* for Android here. If you are sure there is no risk on your system about this,
* mask this macro define to support non-printable ascii ssid.
* #define CONFIG_VALIDATE_SSID */
/* Android expect dbm as the rx signal strength unit */
#define CONFIG_SIGNAL_DISPLAY_DBM
#endif // CONFIG_RTW_ANDROID
/*
#if defined(CONFIG_HAS_EARLYSUSPEND) && defined(CONFIG_RESUME_IN_WORKQUEUE)
#warning "You have CONFIG_HAS_EARLYSUSPEND enabled in your system, we disable CONFIG_RESUME_IN_WORKQUEUE automatically"
#undef CONFIG_RESUME_IN_WORKQUEUE
#endif
#if defined(CONFIG_ANDROID_POWER) && defined(CONFIG_RESUME_IN_WORKQUEUE)
#warning "You have CONFIG_ANDROID_POWER enabled in your system, we disable CONFIG_RESUME_IN_WORKQUEUE automatically"
#undef CONFIG_RESUME_IN_WORKQUEUE
#endif
*/
#ifdef CONFIG_RESUME_IN_WORKQUEUE /* this can be removed, because there is no case for this... */
#if !defined(CONFIG_WAKELOCK) && !defined(CONFIG_ANDROID_POWER)
#error "enable CONFIG_RESUME_IN_WORKQUEUE without CONFIG_WAKELOCK or CONFIG_ANDROID_POWER will suffer from the danger of wifi's unfunctionality..."
#error "If you still want to enable CONFIG_RESUME_IN_WORKQUEUE in this case, mask this preprossor checking and GOOD LUCK..."
#endif
#endif
/* About USB VENDOR REQ */
#if defined(CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC) && !defined(CONFIG_USB_VENDOR_REQ_MUTEX)
#warning "define CONFIG_USB_VENDOR_REQ_MUTEX for CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC automatically"
#define CONFIG_USB_VENDOR_REQ_MUTEX
#endif
#if defined(CONFIG_VENDOR_REQ_RETRY) && !defined(CONFIG_USB_VENDOR_REQ_MUTEX)
#warning "define CONFIG_USB_VENDOR_REQ_MUTEX for CONFIG_VENDOR_REQ_RETRY automatically"
#define CONFIG_USB_VENDOR_REQ_MUTEX
#endif
#ifdef CONFIG_WIFI_MONITOR
/* #define CONFIG_MONITOR_MODE_XMIT */
#endif
#ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
#ifndef CONFIG_WIFI_MONITOR
#define CONFIG_WIFI_MONITOR
#endif
#ifndef CONFIG_MONITOR_MODE_XMIT
#define CONFIG_MONITOR_MODE_XMIT
#endif
#ifdef CONFIG_POWER_SAVING
#undef CONFIG_POWER_SAVING
#endif
#endif
#ifndef CONFIG_RTW_DATA_BMC_TO_UC
#define CONFIG_RTW_DATA_BMC_TO_UC 0
#endif
#ifdef CONFIG_AP_MODE
#define CONFIG_LIMITED_AP_NUM 1
#define BMC_ON_HIQ
#ifndef CONFIG_RTW_AP_DATA_BMC_TO_UC
#define CONFIG_RTW_AP_DATA_BMC_TO_UC 1
#endif
#if CONFIG_RTW_AP_DATA_BMC_TO_UC
#undef CONFIG_RTW_DATA_BMC_TO_UC
#define CONFIG_RTW_DATA_BMC_TO_UC 1
#endif
#ifndef CONFIG_RTW_AP_SRC_B2U_FLAGS
#define CONFIG_RTW_AP_SRC_B2U_FLAGS 0x8 /* see RTW_AP_B2U_XXX */
#endif
#ifndef CONFIG_RTW_AP_FWD_B2U_FLAGS
#define CONFIG_RTW_AP_FWD_B2U_FLAGS 0x8 /* see RTW_AP_B2U_XXX */
#endif
#endif
#ifdef CONFIG_RTW_MULTI_AP
#ifndef CONFIG_AP_MODE
#error "enable CONFIG_RTW_MULTI_AP without CONFIG_AP_MODE"
#endif
#ifndef CONFIG_RTW_WDS
#define CONFIG_RTW_WDS
#endif
#ifndef CONFIG_RTW_UNASOC_STA_MODE_OF_STYPE
#define CONFIG_RTW_UNASOC_STA_MODE_OF_STYPE {2, 1} /* BMC:2 for all, NMY_UC:1 for interested target */
#endif
#ifndef CONFIG_RTW_NLRTW
#define CONFIG_RTW_NLRTW
#endif
#ifndef CONFIG_RTW_WNM
#define CONFIG_RTW_WNM
#endif
#ifndef CONFIG_RTW_80211K
#define CONFIG_RTW_80211K
#endif
#endif
#ifdef CONFIG_RTW_MESH
#ifndef CONFIG_RTW_MESH_ACNODE_PREVENT
#define CONFIG_RTW_MESH_ACNODE_PREVENT 1
#endif
#ifndef CONFIG_RTW_MESH_OFFCH_CAND
#define CONFIG_RTW_MESH_OFFCH_CAND 1
#endif
#ifndef CONFIG_RTW_MESH_PEER_BLACKLIST
#define CONFIG_RTW_MESH_PEER_BLACKLIST 1
#endif
#ifndef CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
#define CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST 1
#endif
#ifndef CONFIG_RTW_MESH_CTO_MGATE_CARRIER
#define CONFIG_RTW_MESH_CTO_MGATE_CARRIER CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
#endif
#ifndef CONFIG_RTW_MPM_TX_IES_SYNC_BSS
#define CONFIG_RTW_MPM_TX_IES_SYNC_BSS 1
#endif
#if CONFIG_RTW_MPM_TX_IES_SYNC_BSS
#ifndef CONFIG_RTW_MESH_AEK
#define CONFIG_RTW_MESH_AEK
#endif
#endif
#ifndef CONFIG_RTW_MESH_DATA_BMC_TO_UC
#define CONFIG_RTW_MESH_DATA_BMC_TO_UC 1
#endif
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
#undef CONFIG_RTW_DATA_BMC_TO_UC
#define CONFIG_RTW_DATA_BMC_TO_UC 1
#endif
#ifndef CONFIG_RTW_MSRC_B2U_FLAGS
#define CONFIG_RTW_MSRC_B2U_FLAGS 0x0 /* see RTW_MESH_B2U_XXX */
#endif
#ifndef CONFIG_RTW_MFWD_B2U_FLAGS
#define CONFIG_RTW_MFWD_B2U_FLAGS 0x2 /* see RTW_MESH_B2U_XXX */
#endif
#endif
#if !defined(CONFIG_SCAN_BACKOP) && defined(CONFIG_AP_MODE)
#define CONFIG_SCAN_BACKOP
#endif
#define RTW_SCAN_SPARSE_MIRACAST 1
#define RTW_SCAN_SPARSE_BG 0
#ifndef CONFIG_RTW_HIQ_FILTER
#define CONFIG_RTW_HIQ_FILTER 1
#endif
#ifndef CONFIG_RTW_ADAPTIVITY_EN
#define CONFIG_RTW_ADAPTIVITY_EN 0
#endif
#ifndef CONFIG_RTW_ADAPTIVITY_MODE
#define CONFIG_RTW_ADAPTIVITY_MODE 0
#endif
#ifndef CONFIG_RTW_ADAPTIVITY_TH_L2H_INI
#define CONFIG_RTW_ADAPTIVITY_TH_L2H_INI 0
#endif
#ifndef CONFIG_RTW_ADAPTIVITY_TH_EDCCA_HL_DIFF
#define CONFIG_RTW_ADAPTIVITY_TH_EDCCA_HL_DIFF 0
#endif
#ifndef CONFIG_RTW_EXCL_CHS
#define CONFIG_RTW_EXCL_CHS {0}
#endif
#ifndef CONFIG_RTW_EXCL_CHS_6G
#define CONFIG_RTW_EXCL_CHS_6G {0}
#endif
#ifndef CONFIG_RTW_COUNTRY_IE_SLAVE_EN_ROLE
#define CONFIG_RTW_COUNTRY_IE_SLAVE_EN_ROLE 0x03 /* BIT0 for pure STA mode, BIT1 for P2P group client */
#endif
#ifndef CONFIG_RTW_COUNTRY_IE_SLAVE_EN_IFBMP
#define CONFIG_RTW_COUNTRY_IE_SLAVE_EN_IFBMP 0xFF /* all iface */
#endif
#define CONFIG_IEEE80211_BAND_5GHZ 1
#ifndef CONFIG_IEEE80211_BAND_6GHZ
#define CONFIG_IEEE80211_BAND_6GHZ 0
#endif
#ifndef CONFIG_DFS
#define CONFIG_DFS 1
#endif
#if CONFIG_DFS
#define CONFIG_ECSA_PHL /* Process ECSA by PHL cmd dispatcher */
#ifdef CONFIG_ECSA_PHL
#define CONFIG_ECSA
#endif
#endif
#if CONFIG_IEEE80211_BAND_5GHZ && CONFIG_DFS && defined(CONFIG_AP_MODE)
#if !defined(CONFIG_DFS_SLAVE_WITH_RADAR_DETECT)
#define CONFIG_DFS_SLAVE_WITH_RADAR_DETECT 0
#endif
#if !defined(CONFIG_DFS_MASTER) || CONFIG_DFS_SLAVE_WITH_RADAR_DETECT
#define CONFIG_DFS_MASTER
#endif
#if defined(CONFIG_DFS_MASTER) && !defined(CONFIG_RTW_DFS_REGION_DOMAIN)
#define CONFIG_RTW_DFS_REGION_DOMAIN 0
#endif
#else
#undef CONFIG_DFS_MASTER
#undef CONFIG_RTW_DFS_REGION_DOMAIN
#define CONFIG_RTW_DFS_REGION_DOMAIN 0
#undef CONFIG_DFS_SLAVE_WITH_RADAR_DETECT
#define CONFIG_DFS_SLAVE_WITH_RADAR_DETECT 0
#endif
#ifndef CONFIG_TXPWR_BY_RATE_EN
#define CONFIG_TXPWR_BY_RATE_EN 2 /* by efuse */
#endif
#ifndef CONFIG_TXPWR_LIMIT_EN
#define CONFIG_TXPWR_LIMIT_EN 2 /* by efuse */
#endif
#ifndef CONFIG_RTW_CHPLAN
#define CONFIG_RTW_CHPLAN 0xFFFF /* RTW_CHPLAN_IOCTL_UNSPECIFIED */
#endif
#ifndef CONFIG_RTW_CHPLAN_6G
#define CONFIG_RTW_CHPLAN_6G 0xFFFF /* RTW_CHPLAN_IOCTL_UNSPECIFIED */
#endif
/* compatible with old fashion configuration */
#if defined(CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY)
#undef CONFIG_TXPWR_BY_RATE_EN
#undef CONFIG_TXPWR_LIMIT_EN
#define CONFIG_TXPWR_BY_RATE_EN 1
#define CONFIG_TXPWR_LIMIT_EN 1
#elif defined(CONFIG_CALIBRATE_TX_POWER_TO_MAX)
#undef CONFIG_TXPWR_BY_RATE_EN
#undef CONFIG_TXPWR_LIMIT_EN
#define CONFIG_TXPWR_BY_RATE_EN 1
#define CONFIG_TXPWR_LIMIT_EN 0
#endif
#ifndef RTW_DEF_MODULE_REGULATORY_CERT
#define RTW_DEF_MODULE_REGULATORY_CERT 0
#endif
#if RTW_DEF_MODULE_REGULATORY_CERT
#ifdef CONFIG_REGD_SRC_FROM_OS
#error "CONFIG_REGD_SRC_FROM_OS is not supported when enable RTW_DEF_MODULE_REGULATORY_CERT"
#endif
/* force enable TX power by rate and TX power limit */
#undef CONFIG_TXPWR_BY_RATE_EN
#undef CONFIG_TXPWR_LIMIT_EN
#define CONFIG_TXPWR_BY_RATE_EN 1
#define CONFIG_TXPWR_LIMIT_EN 1
#endif
#if !CONFIG_TXPWR_LIMIT && CONFIG_TXPWR_LIMIT_EN
#undef CONFIG_TXPWR_LIMIT
#define CONFIG_TXPWR_LIMIT 1
#endif
#ifndef CONFIG_RTW_REGD_SRC
#define CONFIG_RTW_REGD_SRC 1 /* 0:RTK_PRIV, 1:OS */
#endif
#ifdef CONFIG_RTW_IPCAM_APPLICATION
#undef CONFIG_TXPWR_BY_RATE_EN
#define CONFIG_TXPWR_BY_RATE_EN 1
#define CONFIG_RTW_CUSTOMIZE_BEEDCA 0x0000431C
#define CONFIG_RTW_CUSTOMIZE_BWMODE 0x00
#define CONFIG_RTW_CUSTOMIZE_RLSTA 0x7
#if defined(CONFIG_RTL8822B)
#define CONFIG_RTW_TX_NPATH_EN /*mutually incompatible with STBC_TX & Beamformer */
#endif
#endif
/* #define CONFIG_RTW_TOKEN_BASED_XMIT */
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
#define NR_TBTX_SLOT 4
#define NR_MAXSTA_INSLOT 5
#define TBTX_TX_DURATION 30
#define MAX_TXPAUSE_DURATION (TBTX_TX_DURATION*NR_TBTX_SLOT)
#endif
/*#define CONFIG_EXTEND_LOWRATE_TXOP */
#ifndef CONFIG_RTW_RX_AMPDU_SZ_LIMIT_1SS
#define CONFIG_RTW_RX_AMPDU_SZ_LIMIT_1SS {0xFF, 0xFF, 0xFF, 0xFF}
#endif
#ifndef CONFIG_RTW_RX_AMPDU_SZ_LIMIT_2SS
#define CONFIG_RTW_RX_AMPDU_SZ_LIMIT_2SS {0xFF, 0xFF, 0xFF, 0xFF}
#endif
#ifndef CONFIG_RTW_RX_AMPDU_SZ_LIMIT_3SS
#define CONFIG_RTW_RX_AMPDU_SZ_LIMIT_3SS {0xFF, 0xFF, 0xFF, 0xFF}
#endif
#ifndef CONFIG_RTW_RX_AMPDU_SZ_LIMIT_4SS
#define CONFIG_RTW_RX_AMPDU_SZ_LIMIT_4SS {0xFF, 0xFF, 0xFF, 0xFF}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_2G_A
#define CONFIG_RTW_TARGET_TX_PWR_2G_A {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_2G_B
#define CONFIG_RTW_TARGET_TX_PWR_2G_B {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_2G_C
#define CONFIG_RTW_TARGET_TX_PWR_2G_C {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_2G_D
#define CONFIG_RTW_TARGET_TX_PWR_2G_D {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_5G_A
#define CONFIG_RTW_TARGET_TX_PWR_5G_A {-1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_5G_B
#define CONFIG_RTW_TARGET_TX_PWR_5G_B {-1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_5G_C
#define CONFIG_RTW_TARGET_TX_PWR_5G_C {-1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_TARGET_TX_PWR_5G_D
#define CONFIG_RTW_TARGET_TX_PWR_5G_D {-1, -1, -1, -1, -1, -1, -1, -1, -1}
#endif
#ifndef CONFIG_RTW_AMPLIFIER_TYPE_2G
#define CONFIG_RTW_AMPLIFIER_TYPE_2G 0
#endif
#ifndef CONFIG_RTW_AMPLIFIER_TYPE_5G
#define CONFIG_RTW_AMPLIFIER_TYPE_5G 0
#endif
#ifndef CONFIG_RTW_RFE_TYPE
#define CONFIG_RTW_RFE_TYPE 0xFF
#endif
#ifndef CONFIG_RTW_GLNA_TYPE
#define CONFIG_RTW_GLNA_TYPE 0
#endif
#ifndef CONFIG_RTW_PLL_REF_CLK_SEL
#define CONFIG_RTW_PLL_REF_CLK_SEL 0x0F
#endif
#ifndef CONFIG_IFACE_NUMBER
#ifdef CONFIG_CONCURRENT_MODE
#define CONFIG_IFACE_NUMBER 2
#else
#define CONFIG_IFACE_NUMBER 1
#endif
#endif
#ifdef CONFIG_CONCURRENT_MODE
#if (CONFIG_IFACE_NUMBER < 2)
#error "CONFIG_IFACE_NUMBER less 2,but CONFIG_CONCURRENT_MODE defined"
#endif
#else
#if (CONFIG_IFACE_NUMBER > 1)
#error "CONFIG_IFACE_NUMBER over 1,but CONFIG_CONCURRENT_MODE not defined"
#endif
#endif
#if (CONFIG_IFACE_NUMBER == 0)
#error "CONFIG_IFACE_NUMBER cound not be 0 !!"
#endif
#if (CONFIG_IFACE_NUMBER > 4)
#error "Not support over 4 interfaces yet !!"
#endif
#if (CONFIG_IFACE_NUMBER > 8) /*IFACE_ID_MAX*/
#error "HW count not support over 8 interfaces !!"
#endif
#if (CONFIG_IFACE_NUMBER > 2)
#ifdef CONFIG_AP_MODE
#undef CONFIG_LIMITED_AP_NUM
#define CONFIG_LIMITED_AP_NUM 2
#endif /*CONFIG_AP_MODE*/
#endif/*(CONFIG_IFACE_NUMBER > 2)*/
#define MACID_NUM_SW_LIMIT 32
#define SEC_CAM_ENT_NUM_SW_LIMIT 32
/*
Mark CONFIG_DEAUTH_BEFORE_CONNECT by Arvin 2015/07/20
If the failure of Wi-Fi connection is due to some irregular disconnection behavior (like unplug dongle,
power down etc.) in last time, we can unmark this flag to avoid some unpredictable response from AP.
*/
/*#define CONFIG_DEAUTH_BEFORE_CONNECT */
/*#define CONFIG_WEXT_DONT_JOIN_BYSSID */
/* #include <rtw_byteorder.h> */
/*#define CONFIG_DOSCAN_IN_BUSYTRAFFIC */
/*Don't release SDIO irq in suspend/resume procedure*/
#define CONFIG_RTW_SDIO_KEEP_IRQ 0
/*
* Add by Lucas@2016/02/15
* For RX Aggregation
*/
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_USB_RX_AGGREGATION)
#define RTW_RX_AGGREGATION
#endif /* CONFIG_SDIO_HCI || CONFIG_USB_RX_AGGREGATION */
#ifdef CONFIG_RTW_HOSTAPD_ACS
#ifdef CONFIG_FIND_BEST_CHANNEL
#undef CONFIG_FIND_BEST_CHANNEL
#endif
#ifndef CONFIG_RTW_ACS
#define CONFIG_RTW_ACS
#endif
#endif
#ifdef DBG_CONFIG_ERROR_RESET
#ifndef CONFIG_IPS
#define CONFIG_IPS
#endif
#endif
/* IPS */
#ifndef RTW_IPS_MODE
#if defined(CONFIG_IPS)
#define RTW_IPS_MODE 1
#else
#define RTW_IPS_MODE 0
#endif
#endif /* !RTW_IPS_MODE */
#if (RTW_IPS_MODE > 1 || RTW_IPS_MODE < 0)
#error "The CONFIG_IPS_MODE value is wrong. Please follow HowTo_enable_the_power_saving_functionality.pdf.\n"
#endif
/* LPS */
#ifndef RTW_LPS_MODE
#if defined(CONFIG_LPS_PG)
#define RTW_LPS_MODE 3
#elif defined(CONFIG_LPS_LCLK)
#define RTW_LPS_MODE 2
#elif defined(CONFIG_LPS)
#define RTW_LPS_MODE 1
#else
#define RTW_LPS_MODE 0
#endif
#endif /* !RTW_LPS_MODE */
#if (RTW_LPS_MODE > 3 || RTW_LPS_MODE < 0)
#error "The CONFIG_LPS_MODE value is wrong. Please follow HowTo_enable_the_power_saving_functionality.pdf.\n"
#endif
#ifndef RTW_LPS_1T1R
#define RTW_LPS_1T1R 0
#endif
#ifndef RTW_WOW_LPS_1T1R
#define RTW_WOW_LPS_1T1R 0
#endif
/* WOW LPS */
#ifndef RTW_WOW_LPS_MODE
#if defined(CONFIG_LPS_PG)
#define RTW_WOW_LPS_MODE 3
#elif defined(CONFIG_LPS_LCLK)
#define RTW_WOW_LPS_MODE 2
#elif defined(CONFIG_LPS)
#define RTW_WOW_LPS_MODE 1
#else
#define RTW_WOW_LPS_MODE 0
#endif
#endif /* !RTW_WOW_LPS_MODE */
#if (RTW_WOW_LPS_MODE > 3 || RTW_WOW_LPS_MODE < 0)
#error "The RTW_WOW_LPS_MODE value is wrong. Please follow HowTo_enable_the_power_saving_functionality.pdf.\n"
#endif
#ifdef RTW_REDUCE_SCAN_SWITCH_CH_TIME
#ifndef CONFIG_RTL8822B
#error "Only 8822B support RTW_REDUCE_SCAN_SWITCH_CH_TIME"
#endif
#ifndef RTW_CHANNEL_SWITCH_OFFLOAD
#define RTW_CHANNEL_SWITCH_OFFLOAD
#endif
#endif
#ifdef CONFIG_PCI_BCN_POLLING
#define CONFIG_BCN_ICF
#endif
#ifndef CONFIG_PCI_MSI
#define CONFIG_RTW_PCI_MSI_DISABLE
#endif
#if defined(CONFIG_PCI_DYNAMIC_ASPM_L1_LATENCY) || \
defined(CONFIG_PCI_DYNAMIC_ASPM_LINK_CTRL)
#define CONFIG_PCI_DYNAMIC_ASPM
#endif
#if 0
/* Debug related compiler flags */
#define DBG_THREAD_PID /* Add thread pid to debug message prefix */
#define DBG_CPU_INFO /* Add CPU info to debug message prefix */
#endif
#ifdef CONFIG_TX_AMSDU_HW_MODE
#define CONFIG_HW_HDR_CONVERSION
#elif defined(CONFIG_TX_AMSDU_SW_MODE)
#else
#define CONFIG_HW_HDR_CONVERSION /* TODO: should be 'unchange' */
#endif
/* for phl illegal mac io access check*/
#define CONFIG_MAC_REG_RW_CHK
#ifdef CONFIG_CMD_DISP
/*#define DBG_CONFIG_CMD_DISP*/
#define CONFIG_CMD_SCAN
#ifdef CONFIG_CMD_SCAN
#ifdef CONFIG_IOCTL_CFG80211
#define CONFIG_PHL_CMD_SCAN_BKOP_TIME
#endif
/* Scan hidden AP in passive channel */
#define RTW_WKARD_CMD_SCAN_EXTEND_ACTIVE_SCAN
#define RTW_EXTEND_ACTIVE_SCAN_PERIOD 30 /* unit: ms */
#endif /* CONFIG_CMD_SCAN */
#define CONFIG_CMD_GENERAL
#define CONFIG_CMD_SER
#define CONFIG_STA_CMD_DISPR
#define CONFIG_AP_CMD_DISPR
/*#define CONFIG_IBSS_CMD_DISPR*/
#define CONFIG_CMD_TSF_SYNC
#endif
#ifdef ROKU_PRIVATE
#define CONFIG_USB_RELEASE_RPT
#define CONFIG_RA_TXSTS_DBG
#endif
/*
* Work around Config
*/
/*
* RTW_WKARD_UPDATE_PHL_ROLE_CAP
* Update adapter->phl_role.cap & proto_role_cap by driver parameters(registry).
*/
#define RTW_WKARD_UPDATE_PHL_ROLE_CAP
#endif /* __DRV_CONF_H__ */
|
2301_81045437/rtl8852be
|
include/drv_conf.h
|
C
|
agpl-3.0
| 18,222
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
/*-------------------------------------------------------------------------------
For type defines and data structure defines
--------------------------------------------------------------------------------*/
#ifndef __DRV_TYPES_H__
#define __DRV_TYPES_H__
#include <drv_conf.h>
#include <basic_types.h>
#include <osdep_service.h>
#include <rtw_byteorder.h>
#include <wlan_bssdef.h>
#include <wifi.h>
#include <ieee80211.h>
#ifdef CONFIG_ARP_KEEP_ALIVE
#include <net/neighbour.h>
#include <net/arp.h>
#endif
typedef struct _ADAPTER _adapter;
/* connection interface of drv and hal */
#include "../phl/rtw_general_def.h"
#include <rtw_debug.h>
#include <rtw_rf.h>
#include "../core/rtw_chplan.h"
#ifdef CONFIG_80211N_HT
#include <rtw_ht.h>
#endif
#ifdef CONFIG_80211AC_VHT
#include <rtw_vht.h>
#endif
#include <rtw_security.h>
#include <rtw_xmit.h>
#include <xmit_osdep.h>
#include <rtw_recv.h>
#include <rtw_rm.h>
#ifdef CONFIG_80211AX_HE
#include <rtw_he.h>
#endif
#ifdef CONFIG_BEAMFORMING
#include <rtw_beamforming.h>
#endif
#include <recv_osdep.h>
#include <rtw_sreset.h>
/*CONFIG_PHL_ARCH*/
#include "rtw_cmd.h"
#include "rtw_phl_cmd.h"
#include "../phl/phl_headers_core.h"
#include "phl_api_tmp.h"
#include "rtw_phl.h"
/*GEORGIA_TODO_FIXIT*/
#include "_hal_rate.h"
#include "_hal_api_tmp.h"
#include "platform_ops.h"
#include "rtw_scan.h"
#ifdef CONFIG_RTW_80211R
#include <rtw_ft.h>
#endif
#if defined(CONFIG_RTW_WNM) || defined(CONFIG_RTW_80211K)
#include <rtw_wnm.h>
#endif
#ifdef CONFIG_RTW_MBO
#include <rtw_mbo.h>
#endif
#include <rtw_qos.h>
#include <rtw_wow.h>
#include <rtw_pwrctrl.h>
#include <rtw_mlme.h>
#include <mlme_osdep.h>
#include <rtw_io.h>
#ifdef CONFIG_RTW_CORE_RXSC
#include <rtw_recv_shortcut.h>
#endif
#ifdef CONFIG_CORE_TXSC
#include <rtw_xmit_shortcut.h>
#endif
#include <rtw_ioctl.h>
#include <rtw_ioctl_set.h>
#include <rtw_ioctl_query.h>
#include "rtw_cfg.h"
#include <osdep_intf.h>
#include <sta_info.h>
#include <rtw_event.h>
#include <rtw_mlme_ext.h>
#include <rtw_sec_cam.h>
#include <rtw_mi.h>
#include <rtw_ap.h>
#include <rtw_csa.h>
#ifdef CONFIG_RTW_WDS
#include "../core/wds/rtw_wds.h"
#endif
#ifdef CONFIG_RTW_MESH
#include "../core/mesh/rtw_mesh.h"
#endif
#ifdef CONFIG_WIFI_MONITOR
#include "../core/monitor/rtw_radiotap.h"
#endif
#include <rtw_version.h>
#ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
#include <rtw_mem.h>
#endif
#include <rtw_p2p.h>
#ifdef CONFIG_TDLS
#include <rtw_tdls.h>
#endif /* CONFIG_TDLS */
#ifdef CONFIG_WAPI_SUPPORT
#include <rtw_wapi.h>
#endif /* CONFIG_WAPI_SUPPORT */
#ifdef CONFIG_MP_INCLUDED
#include <rtw_mp.h>
#include <rtw_efuse.h>
#endif /* CONFIG_MP_INCLUDED */
#ifdef CONFIG_BR_EXT
#include <rtw_br_ext.h>
#endif /* CONFIG_BR_EXT */
#include <ip.h>
#include <if_ether.h>
#include <ethernet.h>
#include <circ_buf.h>
#include <rtw_android.h>
#include <rtw_btc.h>
#define SPEC_DEV_ID_NONE BIT(0)
#define SPEC_DEV_ID_DISABLE_HT BIT(1)
#define SPEC_DEV_ID_ENABLE_PS BIT(2)
#define SPEC_DEV_ID_RF_CONFIG_1T1R BIT(3)
#define SPEC_DEV_ID_RF_CONFIG_2T2R BIT(4)
#define SPEC_DEV_ID_ASSIGN_IFNAME BIT(5)
#if defined(RTW_PHL_TX) || defined(RTW_PHL_RX)
//#define PHLRX_LOG(fmt, args...) printk("phl-rx [%s][%d]"fmt, __FUNCTION__,__LINE__, ## args)
#define PHLRX_LOG printk("phl-rx [%s][%d] \n", __FUNCTION__, __LINE__);
#define PHLRX_ENTER printk("phl-rx [%s][%d] ++\n", __FUNCTION__, __LINE__);
#define PHLRX_EXIT printk("phl-rx [%s][%d] --\n", __FUNCTION__, __LINE__);
#endif
struct specific_device_id {
u32 flags;
u16 idVendor;
u16 idProduct;
};
struct registry_priv {
u8 chip_version;
u8 rfintfs;
u8 lbkmode;
u8 hci;
NDIS_802_11_SSID ssid;
u8 network_mode; /* infra, ad-hoc, auto */
u8 channel;/* ad-hoc support requirement */
u8 wireless_mode;/* A, B, G, auto */
u8 band_type;
enum rtw_phl_scan_type scan_mode;/*scan methods - active, passive */
u8 radio_enable;
u8 preamble;/* long, short, auto */
u8 vrtl_carrier_sense;/* Enable, Disable, Auto */
u8 vcs_type;/* RTS/CTS, CTS-to-self */
u16 rts_thresh;
u8 hw_rts_en;
u16 frag_thresh;
u8 adhoc_tx_pwr;
u8 soft_ap;
u8 power_mgnt;
u8 ips_mode;
u8 lps_level;
#ifdef CONFIG_LPS_1T1R
u8 lps_1t1r;
#endif
u8 lps_chk_by_tp;
#ifdef CONFIG_WOWLAN
u8 wow_power_mgnt;
u8 wow_lps_level;
#ifdef CONFIG_LPS_1T1R
u8 wow_lps_1t1r;
#endif
#endif /* CONFIG_WOWLAN */
u8 smart_ps;
#ifdef CONFIG_WMMPS_STA
u8 wmm_smart_ps;
#endif /* CONFIG_WMMPS_STA */
u8 usb_rxagg_mode;
u8 dynamic_agg_enable;
u8 long_retry_lmt;
u8 short_retry_lmt;
u16 busy_thresh;
u16 max_bss_cnt;
u8 ack_policy;
u8 mp_mode;
#if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_RTW_CUSTOMER_STR)
u8 mp_customer_str;
#endif
u8 mp_dm;
u8 software_encrypt;
u8 software_decrypt;
#ifdef CONFIG_TX_EARLY_MODE
u8 early_mode;
#endif
#ifdef CONFIG_NARROWBAND_SUPPORTING
u8 rtw_nb_config;
#endif
u8 acm_method;
/* WMM */
u8 wmm_enable;
#ifdef CONFIG_WMMPS_STA
/* uapsd (unscheduled automatic power-save delivery) = a kind of wmmps */
u8 uapsd_max_sp_len;
/* BIT0: AC_VO UAPSD, BIT1: AC_VI UAPSD, BIT2: AC_BK UAPSD, BIT3: AC_BE UAPSD */
u8 uapsd_ac_enable;
#endif /* CONFIG_WMMPS_STA */
WLAN_BSSID_EX dev_network;
u8 tx_bw_mode;
#ifdef CONFIG_AP_MODE
u8 bmc_tx_rate;
#if CONFIG_RTW_AP_DATA_BMC_TO_UC
u8 ap_src_b2u_flags;
u8 ap_fwd_b2u_flags;
#endif
#endif
#ifdef CONFIG_RTW_MESH
#if CONFIG_RTW_MESH_DATA_BMC_TO_UC
u8 msrc_b2u_flags;
u8 mfwd_b2u_flags;
#endif
#endif
#ifdef CONFIG_80211N_HT
u8 ht_enable;
/* 0: 20 MHz, 1: 40 MHz, 2: 80 MHz, 3: 160MHz */
/* 2.4G use bit 0 ~ 3, 5G use bit 4 ~ 7 */
/* 0x21 means enable 2.4G 40MHz & 5G 80MHz */
u8 bw_mode;
u8 ampdu_enable;/* for tx */
u8 rx_ampdu_amsdu;/* Rx A-MPDU Supports A-MSDU is permitted */
u8 tx_ampdu_amsdu;/* Tx A-MPDU Supports A-MSDU is permitted */
u8 tx_quick_addba_req;
u8 rx_ampdu_sz_limit_by_nss_bw[4][4]; /* 1~4SS, BW20~BW160 */
/* Short GI support Bit Map */
/* BIT0 - 20MHz, 1: support, 0: non-support */
/* BIT1 - 40MHz, 1: support, 0: non-support */
/* BIT2 - 80MHz, 1: support, 0: non-support */
/* BIT3 - 160MHz, 1: support, 0: non-support */
u8 short_gi;
/* BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx */
u8 ldpc_cap;
/*
* BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx
* BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx
* BIT8: Enable HE STBC Rx, BIT9: Enable HE STBC Rx(greater than 80M)
* BIT10: Enable HE STBC Tx, BIT11: Enable HE STBC Tx(greater than 80M)
*/
u16 stbc_cap;
#if defined(CONFIG_RTW_TX_NPATH_EN)
u8 tx_npath;
#endif
#if defined(CONFIG_RTW_PATH_DIV)
u8 path_div;
#endif
/*
* BIT0: Enable VHT SU Beamformer
* BIT1: Enable VHT SU Beamformee
* BIT2: Enable VHT MU Beamformer, depend on VHT SU Beamformer
* BIT3: Enable VHT MU Beamformee, depend on VHT SU Beamformee
* BIT4: Enable HT Beamformer
* BIT5: Enable HT Beamformee
*/
u8 beamform_cap;
u8 dyn_txbf;
u8 beamformer_rf_num;
u8 beamformee_rf_num;
#endif /* CONFIG_80211N_HT */
#ifdef CONFIG_80211AC_VHT
u8 vht_enable; /* 0:disable, 1:enable, 2:auto */
u8 vht_24g_enable; /* 0:disable, 1:enable */
u8 ampdu_factor;
u8 vht_rx_mcs_map[2];
#endif /* CONFIG_80211AC_VHT */
#ifdef CONFIG_80211AX_HE
u8 he_enable; /* 0:disable, 1:enable, 2:auto */
#endif
u8 lowrate_two_xmit;
u8 low_power ;
u8 wifi_spec;/* !turbo_mode */
u8 rf_path; /*rf_config*/
u8 tx_nss;
u8 rx_nss;
#ifdef CONFIG_REGD_SRC_FROM_OS
enum regd_src_t regd_src;
#endif
char alpha2[2];
u8 channel_plan;
u8 excl_chs[MAX_CHANNEL_NUM_2G_5G];
#if CONFIG_IEEE80211_BAND_6GHZ
u8 channel_plan_6g;
u8 excl_chs_6g[MAX_CHANNEL_NUM_6G];
#endif
u8 full_ch_in_p2p_handshake; /* 0: reply only softap channel, 1: reply full channel list*/
#ifdef CONFIG_BTC
u8 btcoex;
u8 bt_iso;
u8 bt_sco;
u8 bt_ampdu;
u8 ant_num;
u8 single_ant_path;
#endif
BOOLEAN bAcceptAddbaReq;
u8 antdiv_cfg;
u8 antdiv_type;
u8 drv_ant_band_switch;
u8 switch_usb_mode;
u8 hw_wps_pbc;/* 0:disable,1:enable */
#ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
char adaptor_info_caching_file_path[PATH_LENGTH_MAX];
#endif
#ifdef CONFIG_LAYER2_ROAMING
u8 max_roaming_times; /* the max number driver will try to roaming */
#endif
#ifdef CONFIG_80211D
u8 country_ie_slave_en_role;
u8 country_ie_slave_en_ifbmp;
#endif
u8 ifname[16];
u8 if2name[16];
/* for pll reference clock selction */
u8 pll_ref_clk_sel;
u8 target_tx_pwr_valid;
s8 target_tx_pwr_2g[RF_PATH_MAX][RATE_SECTION_NUM];
#if CONFIG_IEEE80211_BAND_5GHZ
s8 target_tx_pwr_5g[RF_PATH_MAX][RATE_SECTION_NUM - 1];
#endif
s8 TxBBSwing_2G;
s8 TxBBSwing_5G;
u8 AmplifierType_2G;
u8 AmplifierType_5G;
u8 bEn_RFE;
u8 RFE_Type;
u8 PowerTracking_Type;
u8 GLNA_Type;
u8 check_fw_ps;
u8 RegPwrTrimEnable;
#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
u8 load_phy_file;
u8 RegDecryptCustomFile;
#endif
#if defined(CONFIG_CONCURRENT_MODE) && !RTW_P2P_GROUP_INTERFACE
#ifdef CONFIG_P2P
u8 sel_p2p_iface;
#endif
#endif
#ifdef CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST
u8 ignore_go_in_scan;
u8 ignore_low_rssi_in_scan;
#endif
u32 vo_edca;
u8 qos_opt_enable;
u8 hiq_filter;
u8 adaptivity_en;
u8 adaptivity_mode;
s8 adaptivity_th_l2h_ini;
s8 adaptivity_th_edcca_hl_diff;
u8 boffefusemask;
BOOLEAN bFileMaskEfuse;
BOOLEAN bBTFileMaskEfuse;
#ifdef CONFIG_RTW_ACS
u8 acs_auto_scan;
u8 acs_mode;
#endif
u32 reg_rxgain_offset_2g;
u32 reg_rxgain_offset_5gl;
u32 reg_rxgain_offset_5gm;
u32 reg_rxgain_offset_5gh;
#ifdef CONFIG_DFS_MASTER
u8 dfs_region_domain;
#endif
#ifdef CONFIG_RTW_NAPI
u8 en_napi;
#ifdef CONFIG_RTW_NAPI_DYNAMIC
u32 napi_threshold; /* unit: Mbps */
#endif /* CONFIG_RTW_NAPI_DYNAMIC */
#ifdef CONFIG_RTW_GRO
u8 en_gro;
#endif /* CONFIG_RTW_GRO */
#endif /* CONFIG_RTW_NAPI */
#ifdef CONFIG_WOWLAN
u8 wowlan_enable;
u8 wakeup_event;
u8 suspend_type;
#endif
u8 check_hw_status;
u8 wowlan_sta_mix_mode;
#ifdef CONFIG_PCI_HCI
u32 pci_aspm_config;
u32 pci_dynamic_aspm_linkctrl;
#endif
u8 iqk_fw_offload;
u8 ch_switch_offload;
#ifdef CONFIG_TDLS
u8 en_tdls;
#endif
#ifdef CONFIG_FW_OFFLOAD_PARAM_INIT
u8 fw_param_init;
#endif
#ifdef DBG_LA_MODE
u8 la_mode_en;
#endif
u32 phydm_ability;
u32 halrf_ability;
#ifdef CONFIG_TDMADIG
u8 tdmadig_en;
u8 tdmadig_mode;
u8 tdmadig_dynamic;
#endif/*CONFIG_TDMADIG*/
u8 en_dyn_rrsr;
u32 set_rrsr_value;
#ifdef CONFIG_RTW_MESH
u8 peer_alive_based_preq;
#endif
#ifdef RTW_BUSY_DENY_SCAN
/*
* scan_interval_thr means scan interval threshold which is used to
* judge if user is in scan page or not.
* If scan interval < scan_interval_thr we guess user is in scan page,
* and driver won't deny any scan request at that time.
* Its default value comes from compiler flag
* BUSY_TRAFFIC_SCAN_DENY_PERIOD, and unit is ms.
*/
u32 scan_interval_thr;
#endif
u8 deny_legacy;
#ifdef CONFIG_RTW_MULTI_AP
u8 unassoc_sta_mode_of_stype[UNASOC_STA_SRC_NUM];
u16 max_unassoc_sta_cnt;
#endif
#ifdef CONFIG_IOCTL_CFG80211
u16 roch_min_home_dur; /* min duration for op channel */
u16 roch_max_away_dur; /* max acceptable away duration for remain on channel */
u16 roch_extend_dur; /* minimum duration to stay in roch when mgnt tx */
#endif
#if defined(ROKU_PRIVATE) && defined(CONFIG_P2P)
unsigned long go_hidden_ssid_mode;
ATOMIC_T set_hide_ssid_timer;
#endif
u8 amsdu_mode;
};
/* For registry parameters */
#define RGTRY_OFT(field) ((u32)FIELD_OFFSET(struct registry_priv, field))
#define RGTRY_SZ(field) sizeof(((struct registry_priv *) 0)->field)
#define WOWLAN_IS_STA_MIX_MODE(_Adapter) (_Adapter->registrypriv.wowlan_sta_mix_mode)
#define BSSID_OFT(field) ((u32)FIELD_OFFSET(WLAN_BSSID_EX, field))
#define BSSID_SZ(field) sizeof(((PWLAN_BSSID_EX) 0)->field)
#define BW_MODE_2G(bw_mode) ((bw_mode) & 0x0F)
#define BW_MODE_5G(bw_mode) ((bw_mode) >> 4)
#ifdef CONFIG_80211N_HT
#define REGSTY_BW_2G(regsty) BW_MODE_2G((regsty)->bw_mode)
#define REGSTY_BW_5G(regsty) BW_MODE_5G((regsty)->bw_mode)
#else
#define REGSTY_BW_2G(regsty) CHANNEL_WIDTH_20
#define REGSTY_BW_5G(regsty) CHANNEL_WIDTH_20
#endif
#define REGSTY_IS_BW_2G_SUPPORT(regsty, bw) (REGSTY_BW_2G((regsty)) >= (bw))
#define REGSTY_IS_BW_5G_SUPPORT(regsty, bw) (REGSTY_BW_5G((regsty)) >= (bw))
#ifdef CONFIG_80211AC_VHT
#define REGSTY_IS_11AC_ENABLE(regsty) ((regsty)->vht_enable != 0)
#define REGSTY_IS_11AC_AUTO(regsty) ((regsty)->vht_enable == 2)
#define REGSTY_IS_11AC_24G_ENABLE(regsty) ((regsty)->vht_24g_enable != 0)
#else
#define REGSTY_IS_11AC_ENABLE(regsty) 0
#define REGSTY_IS_11AC_AUTO(regsty) 0
#define REGSTY_IS_11AC_24G_ENABLE(regsty) 0
#endif
#define REGSTY_IS_11AX_ENABLE(regsty) ((regsty)->he_enable != 0)
#define REGSTY_IS_11AX_AUTO(regsty) ((regsty)->he_enable == 2)
#ifdef CONFIG_REGD_SRC_FROM_OS
#define REGSTY_REGD_SRC_FROM_OS(regsty) ((regsty)->regd_src == REGD_SRC_OS)
#else
#define REGSTY_REGD_SRC_FROM_OS(regsty) 0
#endif
#ifdef CONFIG_SDIO_HCI
#include <drv_types_sdio.h>
#endif
#ifdef CONFIG_GSPI_HCI
#include <drv_types_gspi.h>
#endif
#ifdef CONFIG_PCI_HCI
#include <drv_types_pci.h>
#endif
#ifdef CONFIG_USB_HCI
#include <drv_types_usb.h>
#endif
#include <rtw_trx.h>
#define get_hw_port(adapter) (adapter->hw_port)
#ifdef CONFIG_CONCURRENT_MODE
#define is_primary_adapter(adapter) (adapter->adapter_type == PRIMARY_ADAPTER)
#define is_vir_adapter(adapter) (adapter->adapter_type == VIRTUAL_ADAPTER)
#else
#define is_primary_adapter(adapter) (1)
#define is_vir_adapter(adapter) (0)
#endif
#define GET_PRIMARY_ADAPTER(padapter) (((_adapter *)padapter)->dvobj->padapters[IFACE_ID0])
#define GET_IFACE_NUMS(padapter) (((_adapter *)padapter)->dvobj->iface_nums)
#define GET_ADAPTER(padapter, iface_id) (((_adapter *)padapter)->dvobj->padapters[iface_id])
#ifdef RTW_PHL_TX
#if 1
#define PHLTX_ENTER //printk("eric-tx [%s][%d] ++\n", __FUNCTION__, __LINE__)
#define PHLTX_LOG //printk("eric-tx [%s][%d]\n", __FUNCTION__, __LINE__)
#define PHLTX_EXIT //printk("eric-tx [%s][%d] --\n", __FUNCTION__, __LINE__)
#define PHLTX_ERR //printk("PHLTX_ERR [%s][%d]\n", __FUNCTION__, __LINE__)
#else
#define PHLTX_ENTER printk("eric-tx [%s][%d] ++\n", __FUNCTION__, __LINE__)
#define PHLTX_LOG printk("eric-tx [%s][%d]\n", __FUNCTION__, __LINE__)
#define PHLTX_EXIT printk("eric-tx [%s][%d] --\n", __FUNCTION__, __LINE__)
#define PHLTX_ERR printk("PHLTX_ERR [%s][%d]\n", __FUNCTION__, __LINE__)
#endif
#define SZ_TXREQ (sizeof(struct rtw_xmit_req))
#define SZ_HEAD_BUF 100
#define SZ_TAIL_BUF 30
#define NUM_PKT_LIST_PER_TXREQ 8
#define SZ_PKT_LIST (sizeof(struct rtw_pkt_buf_list))
#define SZ_TX_RING (SZ_TXREQ+SZ_HEAD_BUF+SZ_TAIL_BUF+(SZ_PKT_LIST*NUM_PKT_LIST_PER_TXREQ))
#define SZ_MGT_RING (SZ_TXREQ + SZ_PKT_LIST)/* MGT_TXREQ_QMGT */
#define MAX_TX_RING_NUM 4096
#endif
enum _IFACE_ID {
IFACE_ID0, /*PRIMARY_ADAPTER*/
IFACE_ID1,
IFACE_ID2,
IFACE_ID3,
IFACE_ID4,
IFACE_ID5,
IFACE_ID6,
IFACE_ID7,
IFACE_ID_MAX,
};
#define VIF_START_ID 1
#ifdef CONFIG_DBG_COUNTER
struct rx_logs {
u32 intf_rx;
u32 intf_rx_err_recvframe;
u32 intf_rx_err_skb;
u32 intf_rx_report;
u32 core_rx;
u32 core_rx_pre;
u32 core_rx_pre_ver_err;
u32 core_rx_pre_mgmt;
u32 core_rx_pre_mgmt_err_80211w;
u32 core_rx_pre_mgmt_err;
u32 core_rx_pre_ctrl;
u32 core_rx_pre_ctrl_err;
u32 core_rx_pre_data;
u32 core_rx_pre_data_wapi_seq_err;
u32 core_rx_pre_data_wapi_key_err;
u32 core_rx_pre_data_handled;
u32 core_rx_pre_data_err;
u32 core_rx_pre_data_unknown;
u32 core_rx_pre_unknown;
u32 core_rx_enqueue;
u32 core_rx_dequeue;
u32 core_rx_post;
u32 core_rx_post_decrypt;
u32 core_rx_post_decrypt_wep;
u32 core_rx_post_decrypt_tkip;
u32 core_rx_post_decrypt_aes;
u32 core_rx_post_decrypt_wapi;
u32 core_rx_post_decrypt_gcmp;
u32 core_rx_post_decrypt_hw;
u32 core_rx_post_decrypt_unknown;
u32 core_rx_post_decrypt_err;
u32 core_rx_post_defrag_err;
u32 core_rx_post_portctrl_err;
u32 core_rx_post_indicate;
u32 core_rx_post_indicate_in_oder;
u32 core_rx_post_indicate_reoder;
u32 core_rx_post_indicate_err;
u32 os_indicate;
u32 os_indicate_ap_mcast;
u32 os_indicate_ap_forward;
u32 os_indicate_ap_self;
u32 os_indicate_err;
u32 os_netif_ok;
u32 os_netif_err;
};
struct tx_logs {
u32 os_tx;
u32 os_tx_err_up;
u32 os_tx_err_xmit;
u32 os_tx_m2u;
u32 os_tx_m2u_ignore_fw_linked;
u32 os_tx_m2u_ignore_self;
u32 os_tx_m2u_entry;
u32 os_tx_m2u_entry_err_xmit;
u32 os_tx_m2u_entry_err_skb;
u32 os_tx_m2u_stop;
u32 core_tx;
u32 core_tx_err_pxmitframe;
u32 core_tx_err_brtx;
u32 core_tx_upd_attrib;
u32 core_tx_upd_attrib_adhoc;
u32 core_tx_upd_attrib_sta;
u32 core_tx_upd_attrib_ap;
u32 core_tx_upd_attrib_unknown;
u32 core_tx_upd_attrib_dhcp;
u32 core_tx_upd_attrib_icmp;
u32 core_tx_upd_attrib_active;
u32 core_tx_upd_attrib_err_ucast_sta;
u32 core_tx_upd_attrib_err_ucast_ap_link;
u32 core_tx_upd_attrib_err_sta;
u32 core_tx_upd_attrib_err_link;
u32 core_tx_upd_attrib_err_sec;
u32 core_tx_ap_enqueue_warn_fwstate;
u32 core_tx_ap_enqueue_warn_sta;
u32 core_tx_ap_enqueue_warn_nosta;
u32 core_tx_ap_enqueue_warn_link;
u32 core_tx_ap_enqueue_warn_trigger;
u32 core_tx_ap_enqueue_mcast;
u32 core_tx_ap_enqueue_ucast;
u32 core_tx_ap_enqueue;
u32 intf_tx;
u32 intf_tx_pending_ac;
u32 intf_tx_pending_fw_under_survey;
u32 intf_tx_pending_fw_under_linking;
u32 intf_tx_pending_xmitbuf;
u32 intf_tx_enqueue;
u32 core_tx_enqueue;
u32 core_tx_enqueue_class;
u32 core_tx_enqueue_class_err_sta;
u32 core_tx_enqueue_class_err_nosta;
u32 core_tx_enqueue_class_err_fwlink;
u32 intf_tx_direct;
u32 intf_tx_direct_err_coalesce;
u32 intf_tx_dequeue;
u32 intf_tx_dequeue_err_coalesce;
u32 intf_tx_dump_xframe;
u32 intf_tx_dump_xframe_err_txdesc;
u32 intf_tx_dump_xframe_err_port;
};
struct int_logs {
u32 all;
u32 err;
u32 tbdok;
u32 tbder;
u32 bcnderr;
u32 bcndma;
u32 bcndma_e;
u32 rx;
u32 rx_rdu;
u32 rx_fovw;
u32 txfovw;
u32 mgntok;
u32 highdok;
u32 bkdok;
u32 bedok;
u32 vidok;
u32 vodok;
};
#endif /* CONFIG_DBG_COUNTER */
struct debug_priv {
u32 dbg_sdio_free_irq_error_cnt;
u32 dbg_sdio_alloc_irq_error_cnt;
u32 dbg_sdio_free_irq_cnt;
u32 dbg_sdio_alloc_irq_cnt;
u32 dbg_sdio_deinit_error_cnt;
u32 dbg_sdio_init_error_cnt;
u32 dbg_suspend_error_cnt;
u32 dbg_suspend_cnt;
u32 dbg_resume_cnt;
u32 dbg_resume_error_cnt;
u32 dbg_deinit_fail_cnt;
u32 dbg_carddisable_cnt;
u32 dbg_carddisable_error_cnt;
u32 dbg_ps_insuspend_cnt;
u32 dbg_dev_unload_inIPS_cnt;
u32 dbg_wow_leave_ps_fail_cnt;
u32 dbg_scan_pwr_state_cnt;
u32 dbg_downloadfw_pwr_state_cnt;
u32 dbg_fw_read_ps_state_fail_cnt;
u32 dbg_leave_ips_fail_cnt;
u32 dbg_leave_lps_fail_cnt;
u32 dbg_h2c_leave32k_fail_cnt;
u32 dbg_diswow_dload_fw_fail_cnt;
u32 dbg_enwow_dload_fw_fail_cnt;
u32 dbg_ips_drvopen_fail_cnt;
u32 dbg_poll_fail_cnt;
u32 dbg_rpwm_toogle_cnt;
u32 dbg_rpwm_timeout_fail_cnt;
u32 dbg_sreset_cnt;
u32 dbg_fw_mem_dl_error_cnt;
u64 dbg_rx_fifo_last_overflow;
u64 dbg_rx_fifo_curr_overflow;
u64 dbg_rx_fifo_diff_overflow;
};
struct rtw_traffic_statistics {
/* tx statistics */
u64 tx_bytes;
u64 tx_pkts;
u64 tx_drop;
u64 cur_tx_bytes;
u64 last_tx_bytes;
u32 cur_tx_tp; /* Tx throughput in Mbps. */
/* rx statistics */
u64 rx_bytes;
u64 rx_pkts;
u64 rx_drop;
u64 cur_rx_bytes;
u64 last_rx_bytes;
u32 cur_rx_tp; /* Rx throughput in Mbps. */
};
#define SEC_CAP_CHK_EXTRA_SEC BIT1 /* 256 bit */
#define KEY_FMT "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
#define KEY_ARG(x) ((u8 *)(x))[0], ((u8 *)(x))[1], ((u8 *)(x))[2], ((u8 *)(x))[3], ((u8 *)(x))[4], ((u8 *)(x))[5], \
((u8 *)(x))[6], ((u8 *)(x))[7], ((u8 *)(x))[8], ((u8 *)(x))[9], ((u8 *)(x))[10], ((u8 *)(x))[11], \
((u8 *)(x))[12], ((u8 *)(x))[13], ((u8 *)(x))[14], ((u8 *)(x))[15]
/* used for rf_ctl_t.rate_bmp_cck_ofdm */
#define RATE_BMP_CCK 0x000F
#define RATE_BMP_OFDM 0xFFF0
#define RATE_BMP_HAS_CCK(_bmp_cck_ofdm) (_bmp_cck_ofdm & RATE_BMP_CCK)
#define RATE_BMP_HAS_OFDM(_bmp_cck_ofdm) (_bmp_cck_ofdm & RATE_BMP_OFDM)
#define RATE_BMP_GET_CCK(_bmp_cck_ofdm) (_bmp_cck_ofdm & RATE_BMP_CCK)
#define RATE_BMP_GET_OFDM(_bmp_cck_ofdm) ((_bmp_cck_ofdm & RATE_BMP_OFDM) >> 4)
/* used for rf_ctl_t.rate_bmp_ht_by_bw */
#define RATE_BMP_HT_1SS 0x000000FF
#define RATE_BMP_HT_2SS 0x0000FF00
#define RATE_BMP_HT_3SS 0x00FF0000
#define RATE_BMP_HT_4SS 0xFF000000
#define RATE_BMP_HAS_HT_1SS(_bmp_ht) (_bmp_ht & RATE_BMP_HT_1SS)
#define RATE_BMP_HAS_HT_2SS(_bmp_ht) (_bmp_ht & RATE_BMP_HT_2SS)
#define RATE_BMP_HAS_HT_3SS(_bmp_ht) (_bmp_ht & RATE_BMP_HT_3SS)
#define RATE_BMP_HAS_HT_4SS(_bmp_ht) (_bmp_ht & RATE_BMP_HT_4SS)
#define RATE_BMP_GET_HT_1SS(_bmp_ht) (_bmp_ht & RATE_BMP_HT_1SS)
#define RATE_BMP_GET_HT_2SS(_bmp_ht) ((_bmp_ht & RATE_BMP_HT_2SS) >> 8)
#define RATE_BMP_GET_HT_3SS(_bmp_ht) ((_bmp_ht & RATE_BMP_HT_3SS) >> 16)
#define RATE_BMP_GET_HT_4SS(_bmp_ht) ((_bmp_ht & RATE_BMP_HT_4SS) >> 24)
/* used for rf_ctl_t.rate_bmp_vht_by_bw */
#define RATE_BMP_VHT_1SS 0x00000003FF
#define RATE_BMP_VHT_2SS 0x00000FFC00
#define RATE_BMP_VHT_3SS 0x003FF00000
#define RATE_BMP_VHT_4SS 0xFFC0000000
#define RATE_BMP_HAS_VHT_1SS(_bmp_vht) (_bmp_vht & RATE_BMP_VHT_1SS)
#define RATE_BMP_HAS_VHT_2SS(_bmp_vht) (_bmp_vht & RATE_BMP_VHT_2SS)
#define RATE_BMP_HAS_VHT_3SS(_bmp_vht) (_bmp_vht & RATE_BMP_VHT_3SS)
#define RATE_BMP_HAS_VHT_4SS(_bmp_vht) (_bmp_vht & RATE_BMP_VHT_4SS)
#define RATE_BMP_GET_VHT_1SS(_bmp_vht) ((u16)(_bmp_vht & RATE_BMP_VHT_1SS))
#define RATE_BMP_GET_VHT_2SS(_bmp_vht) ((u16)((_bmp_vht & RATE_BMP_VHT_2SS) >> 10))
#define RATE_BMP_GET_VHT_3SS(_bmp_vht) ((u16)((_bmp_vht & RATE_BMP_VHT_3SS) >> 20))
#define RATE_BMP_GET_VHT_4SS(_bmp_vht) ((u16)((_bmp_vht & RATE_BMP_VHT_4SS) >> 30))
#define TXPWR_LMT_REF_VHT_FROM_HT BIT0
#define TXPWR_LMT_REF_HT_FROM_VHT BIT1
#define TXPWR_LMT_HAS_CCK_1T BIT0
#define TXPWR_LMT_HAS_CCK_2T BIT1
#define TXPWR_LMT_HAS_CCK_3T BIT2
#define TXPWR_LMT_HAS_CCK_4T BIT3
#define TXPWR_LMT_HAS_OFDM_1T BIT4
#define TXPWR_LMT_HAS_OFDM_2T BIT5
#define TXPWR_LMT_HAS_OFDM_3T BIT6
#define TXPWR_LMT_HAS_OFDM_4T BIT7
#define OFFCHS_NONE 0
#define OFFCHS_LEAVING_OP 1
#define OFFCHS_LEAVE_OP 2
#define OFFCHS_BACKING_OP 3
#define COUNTRY_IE_SLAVE_EN_ROLE_STA BIT0 /* pure STA mode */
#define COUNTRY_IE_SLAVE_EN_ROLE_GC BIT1 /* P2P group client */
struct rf_ctl_t {
bool disable_sw_chplan;
enum regd_src_t regd_src;
enum rtw_regd_inr regd_inr;
char alpha2[2];
u8 ChannelPlan;
#if CONFIG_IEEE80211_BAND_6GHZ
u8 chplan_6g;
#endif
u8 edcca_mode_2g_override;
#if CONFIG_IEEE80211_BAND_5GHZ
u8 edcca_mode_5g_override;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
u8 edcca_mode_6g_override;
#endif
#if CONFIG_TXPWR_LIMIT
u8 txpwr_lmt_override;
#endif
#if defined(CONFIG_80211AX_HE) || defined(CONFIG_80211AC_VHT)
u8 proto_en;
#endif
/* initial channel plan selectors */
char init_alpha2[2];
u8 init_ChannelPlan;
#if CONFIG_IEEE80211_BAND_6GHZ
u8 init_chplan_6g;
#endif
/* channel plan selectors by user */
char user_alpha2[2]; /* "\x00\x00" is not set */
u8 user_ChannelPlan;
#if CONFIG_IEEE80211_BAND_6GHZ
u8 user_chplan_6g;
#endif
#ifdef CONFIG_80211D
u8 country_ie_slave_en_role;
u8 country_ie_slave_en_ifbmp;
struct country_ie_slave_record cisr[CONFIG_IFACE_NUMBER];
u8 effected_cisr_id;
#endif
u8 max_chan_nums;
RT_CHANNEL_INFO channel_set[MAX_CHANNEL_NUM];
struct op_class_pref_t **spt_op_class_ch;
u8 cap_spt_op_class_num;
u8 reg_spt_op_class_num;
u8 cur_spt_op_class_num;
struct p2p_channels channel_list;
u8 op_class;
u8 op_ch;
s16 op_txpwr_max; /* mBm */
u8 if_op_class[CONFIG_IFACE_NUMBER];
u8 if_op_ch[CONFIG_IFACE_NUMBER];
_mutex offch_mutex;
u8 offch_state;
/* used for debug or by tx power limit */
u16 rate_bmp_cck_ofdm; /* 20MHz */
u32 rate_bmp_ht_by_bw[2]; /* 20MHz, 40MHz. 4SS supported */
u64 rate_bmp_vht_by_bw[4]; /* 20MHz, 40MHz, 80MHz, 160MHz. 4SS supported */
#if CONFIG_TXPWR_LIMIT
u8 highest_ht_rate_bw_bmp;
u8 highest_vht_rate_bw_bmp;
#endif
bool ch_sel_within_same_band;
u8 edcca_mode_2g;
#if CONFIG_IEEE80211_BAND_5GHZ
u8 edcca_mode_5g;
#endif
#if CONFIG_IEEE80211_BAND_6GHZ
u8 edcca_mode_6g;
#endif
enum band_type last_edcca_mode_op_band;
#if CONFIG_DFS
u8 csa_mode;
u8 csa_switch_cnt;
/* @csa_ch_width definition from 802.11 spec
* 0 for 20 MHz or 40 MHz
* 1 for 80 MHz, 160 MHz or 80+80 MHz
* 2 for 160 MHz
* 3 for non-contiguous 80+80 MHz
*/
u8 csa_ch_width;
struct rtw_chan_def csa_chandef;
#ifdef CONFIG_DFS_MASTER
u8 dfs_region_domain;
_timer radar_detect_timer;
bool radar_detect_by_others;
u8 radar_detect_enabled;
bool radar_detected;
u8 radar_detect_ch;
u8 radar_detect_bw;
u8 radar_detect_offset;
systime cac_start_time;
systime cac_end_time;
u8 cac_force_stop;
#if CONFIG_DFS_SLAVE_WITH_RADAR_DETECT
u8 dfs_slave_with_rd;
#endif
u8 dfs_ch_sel_e_flags;
u8 dfs_ch_sel_d_flags;
u8 dbg_dfs_fake_radar_detect_cnt;
u8 dbg_dfs_radar_detect_trigger_non;
u8 dbg_dfs_choose_dfs_ch_first;
#endif /* CONFIG_DFS_MASTER */
#endif /* CONFIG_DFS */
#ifdef CONFIG_RTW_MBO
struct npref_ch_rtp ch_rtp;
#endif
};
struct wow_ctl_t {
u8 wow_cap;
};
#define WOW_CAP_TKIP_OL BIT0
#define RFCTL_REG_WORLDWIDE(rfctl) (IS_ALPHA2_WORLDWIDE(rfctl->alpha2))
#define RFCTL_REG_ALPHA2_UNSPEC(rfctl) (IS_ALPHA2_UNSPEC(rfctl->alpha2)) /* ex: only domain code is specified */
#ifdef CONFIG_80211AC_VHT
#define RFCTL_REG_EN_11AC(rfctl) (((rfctl)->proto_en & CHPLAN_PROTO_EN_AC) ? 1 : 0)
#else
#define RFCTL_REG_EN_11AC(rfctl) 0
#endif
#ifdef CONFIG_80211AX_HE
#define RFCTL_REG_EN_11AX(rfctl) (((rfctl)->proto_en & CHPLAN_PROTO_EN_AX) ? 1 : 0)
#else
#define RFCTL_REG_EN_11AX(rfctl) 0
#endif
#define RTW_CAC_STOPPED 0
#ifdef CONFIG_DFS_MASTER
#define IS_CAC_STOPPED(rfctl) ((rfctl)->cac_end_time == RTW_CAC_STOPPED)
#define IS_CH_WAITING(rfctl) (!IS_CAC_STOPPED(rfctl) && rtw_time_after((rfctl)->cac_end_time, rtw_get_current_time()))
#define IS_UNDER_CAC(rfctl) (IS_CH_WAITING(rfctl) && rtw_time_after(rtw_get_current_time(), (rfctl)->cac_start_time))
#define IS_RADAR_DETECTED(rfctl) ((rfctl)->radar_detected)
#else
#define IS_CAC_STOPPED(rfctl) 1
#define IS_CH_WAITING(rfctl) 0
#define IS_UNDER_CAC(rfctl) 0
#define IS_RADAR_DETECTED(rfctl) 0
#endif /* CONFIG_DFS_MASTER */
#if CONFIG_DFS_SLAVE_WITH_RADAR_DETECT
#define IS_DFS_SLAVE_WITH_RD(rfctl) ((rfctl)->dfs_slave_with_rd)
#else
#define IS_DFS_SLAVE_WITH_RD(rfctl) 0
#endif
#ifdef CONFIG_USB_HCI
struct trx_urb_buf_q {
_queue free_urb_buf_queue;
u8 *alloc_urb_buf;
u8 *urb_buf;
uint free_urb_buf_cnt;
};
struct data_urb {
_list list;
struct urb *urb;
u8 bulk_id;
u8 minlen;
};
#endif
struct trx_data_buf_q {
_queue free_data_buf_queue;
u8 *alloc_data_buf;
u8 *data_buf;
uint free_data_buf_cnt;
};
struct lite_data_buf {
_list list;
struct dvobj_priv *dvobj;
u16 buf_tag;
u8 *pbuf;
u8 *phl_buf_ptr; /*point to phl rtw_usb_buf from phl*/
#ifdef CONFIG_USB_HCI
struct data_urb *dataurb;
#endif
struct submit_ctx *sctx;
};
#ifdef CONFIG_DRV_FAKE_AP
struct fake_ap {
struct sk_buff_head rxq; /* RX queue */
_workitem work;
struct rtw_timer_list bcn_timer;
};
#endif /* CONFIG_DRV_FAKE_AP */
/*device object*/
struct dvobj_priv {
/*-------- below is common data --------*/
ATOMIC_T bSurpriseRemoved;
ATOMIC_T bDriverStopped;
ATOMIC_T hw_start;
s32 processing_dev_remove;
_mutex hw_init_mutex;
_mutex ioctrl_mutex;
_mutex setch_mutex;
_mutex setbw_mutex;
_mutex rf_read_reg_mutex;
_adapter *padapters[CONFIG_IFACE_NUMBER];/*IFACE_ID_MAX*/
u8 virtual_iface_num;/*from registary*/
u8 iface_nums; /* total number of ifaces used runtime */
struct mi_state iface_state;
enum rtl_ic_id ic_id;
enum rtw_hci_type interface_type;/*USB,SDIO,SPI,PCI*/
/*CONFIG_PHL_ARCH*/
void *phl;
struct rtw_phl_com_t *phl_com;
#ifdef DBG_PHL_MEM_ALLOC
ATOMIC_T phl_mem;
#endif
struct rf_ctl_t rf_ctl;
/* move to phl */
/* struct macid_ctl_t macid_ctl; *//*shared HW resource*/
struct cam_ctl_t cam_ctl;/*sec-cam shared HW resource*/
struct sec_cam_ent cam_cache[SEC_CAM_ENT_NUM_SW_LIMIT];
struct wow_ctl_t wow_ctl;
/****** Band info may be x 2*********/
/* saved channel info when call set_channel_bw */
systime on_oper_ch_time;
/****** hal dep info*********/
ATOMIC_T continual_io_error;
ATOMIC_T disable_func;
u8 xmit_block;
_lock xmit_block_lock;
struct pwrctrl_priv pwrctl_priv;
struct cmd_priv cmdpriv;
struct recv_priv recvpriv;
#ifdef CONFIG_WOWLAN
struct wow_priv wowlan_priv;
#endif /* CONFIG_WOWLAN */
struct rtw_traffic_statistics traffic_stat;
#ifdef PLATFORM_LINUX
_thread_hdl_ rtnl_lock_holder;
#if defined(CONFIG_IOCTL_CFG80211)
struct wiphy *wiphy;
#endif
#endif /* PLATFORM_LINUX */
#if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
_timer dynamic_chk_timer; /* dynamic/periodic check timer */
#endif
#ifdef CONFIG_RTW_NAPI_DYNAMIC
u8 en_napi_dynamic;
#endif /* CONFIG_RTW_NAPI_DYNAMIC */
#ifdef CONFIG_RTW_WIFI_HAL
u32 nodfs;
#endif
/*-------- below is for PCIE/USB/SDIO INTERFACE --------*/
#ifdef CONFIG_SDIO_HCI
SDIO_DATA sdio_data;
#endif
#ifdef CONFIG_GSPI_HCI
GSPI_DATA gspi_data;
#endif
#ifdef CONFIG_PCI_HCI
PCI_DATA pci_data;
#endif
#ifdef CONFIG_USB_HCI
USB_DATA usb_data;
#endif
struct rtw_intf_ops *intf_ops;
struct trx_data_buf_q litexmitbuf_q;
struct trx_data_buf_q litexmit_extbuf_q;
struct trx_data_buf_q literecvbuf_q;
/*-------- below is for USB INTERFACE --------*/
#ifdef CONFIG_USB_HCI
u8 Queue2Pipe[HW_QUEUE_ENTRY];/* for out pipe mapping */
struct trx_urb_buf_q xmit_urb_q;
struct trx_urb_buf_q recv_urb_q;
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
struct trx_data_buf_q intin_buf_q;
struct trx_urb_buf_q intin_urb_q;
ATOMIC_T rx_pending_cnt;/* urb counts for sumit to host */
#endif
#endif/* CONFIG_USB_HCI */
/*-------- below is for PCIE INTERFACE --------*/
#ifdef CONFIG_PCI_HCI
#endif/* CONFIG_PCI_HCI */
/* also for RTK T/P Testing Mode */
u8 scan_deny;
#ifdef CONFIG_RTW_CUSTOMER_STR
_mutex customer_str_mutex;
struct submit_ctx *customer_str_sctx;
u8 customer_str[RTW_CUSTOMER_STR_LEN];
#endif
struct debug_priv drv_dbg;
#ifdef CONFIG_DRV_FAKE_AP
struct fake_ap fakeap;
#endif /* CONFIG_DRV_FAKE_AP */
#ifdef CONFIG_FILE_FWIMG
/* Placeholder for per physical adapter firmware file name.
* Freddie ToDo: Move to phl_com as PHL/HAL common feature
* should be placed there.
*/
char fw_file[PATH_LENGTH_MAX];
#endif
/* WPAS maintain from w1.fi */
#define RTW_WPAS_W1FI 0x00
/* WPAS maintain from android */
#define RTW_WPAS_ANDROID 0x01
u8 wpas_type;
};
#define DEV_STA_NUM(_dvobj) MSTATE_STA_NUM(&((_dvobj)->iface_state))
#define DEV_STA_LD_NUM(_dvobj) MSTATE_STA_LD_NUM(&((_dvobj)->iface_state))
#define DEV_STA_LG_NUM(_dvobj) MSTATE_STA_LG_NUM(&((_dvobj)->iface_state))
#define DEV_TDLS_LD_NUM(_dvobj) MSTATE_TDLS_LD_NUM(&((_dvobj)->iface_state))
#define DEV_AP_NUM(_dvobj) MSTATE_AP_NUM(&((_dvobj)->iface_state))
#define DEV_AP_STARTING_NUM(_dvobj) MSTATE_AP_STARTING_NUM(&((_dvobj)->iface_state))
#define DEV_AP_LD_NUM(_dvobj) MSTATE_AP_LD_NUM(&((_dvobj)->iface_state))
#define DEV_ADHOC_NUM(_dvobj) MSTATE_ADHOC_NUM(&((_dvobj)->iface_state))
#define DEV_ADHOC_LD_NUM(_dvobj) MSTATE_ADHOC_LD_NUM(&((_dvobj)->iface_state))
#define DEV_MESH_NUM(_dvobj) MSTATE_MESH_NUM(&((_dvobj)->iface_state))
#define DEV_MESH_LD_NUM(_dvobj) MSTATE_MESH_LD_NUM(&((_dvobj)->iface_state))
#define DEV_P2P_DV_NUM(_dvobj) MSTATE_P2P_DV_NUM(&((_dvobj)->iface_state))
#define DEV_P2P_GC_NUM(_dvobj) MSTATE_P2P_GC_NUM(&((_dvobj)->iface_state))
#define DEV_P2P_GO_NUM(_dvobj) MSTATE_P2P_GO_NUM(&((_dvobj)->iface_state))
#define DEV_SCAN_NUM(_dvobj) MSTATE_SCAN_NUM(&((_dvobj)->iface_state))
#define DEV_WPS_NUM(_dvobj) MSTATE_WPS_NUM(&((_dvobj)->iface_state))
#define DEV_ROCH_NUM(_dvobj) MSTATE_ROCH_NUM(&((_dvobj)->iface_state))
#define DEV_MGMT_TX_NUM(_dvobj) MSTATE_MGMT_TX_NUM(&((_dvobj)->iface_state))
#define DEV_U_CH(_dvobj) MSTATE_U_CH(&((_dvobj)->iface_state))
#define DEV_U_BW(_dvobj) MSTATE_U_BW(&((_dvobj)->iface_state))
#define DEV_U_OFFSET(_dvobj) MSTATE_U_OFFSET(&((_dvobj)->iface_state))
#define dvobj_to_pwrctl(dvobj) (&(dvobj->pwrctl_priv))
#ifdef CONFIG_WOWLAN
#define dvobj_to_wowlan(dvobj) (&(dvobj->wowlan_priv))
#endif /* CONFIG_WOWLAN */
#define pwrctl_to_dvobj(pwrctl) container_of(pwrctl, struct dvobj_priv, pwrctl_priv)
#define dvobj_to_macidctl(dvobj) (&(dvobj->macid_ctl))
#define dvobj_to_sec_camctl(dvobj) (&(dvobj->cam_ctl))
#define dvobj_to_regsty(dvobj) (&(dvobj->padapters[IFACE_ID0]->registrypriv))
#if defined(CONFIG_IOCTL_CFG80211)
#define dvobj_to_wiphy(dvobj) ((dvobj)->wiphy)
#endif
#define dvobj_to_rfctl(dvobj) (&(dvobj->rf_ctl))
#define rfctl_to_dvobj(rfctl) container_of((rfctl), struct dvobj_priv, rf_ctl)
#ifdef CONFIG_PCI_HCI
static inline PCI_DATA *dvobj_to_pci(struct dvobj_priv *dvobj)
{
return &dvobj->pci_data;
}
#endif
#ifdef CONFIG_USB_HCI
static inline USB_DATA *dvobj_to_usb(struct dvobj_priv *dvobj)
{
return &dvobj->usb_data;
}
#endif
#ifdef CONFIG_SDIO_HCI
static inline SDIO_DATA *dvobj_to_sdio(struct dvobj_priv *dvobj)
{
return &dvobj->sdio_data;
}
#endif
#ifdef CONFIG_GSPI_HCI
static inline GSPI_DATA *dvobj_to_gspi(struct dvobj_priv *dvobj)
{
return &dvobj->gspi_data;
}
#endif
#ifdef PLATFORM_LINUX
static inline struct device *dvobj_to_dev(struct dvobj_priv *dvobj)
{
/* todo: get interface type from dvobj and the return the dev accordingly */
#ifdef RTW_DVOBJ_CHIP_HW_TYPE
#endif
#ifdef CONFIG_USB_HCI
return &dvobj->usb_data.pusbintf->dev;
#endif
#ifdef CONFIG_SDIO_HCI
return &dvobj->sdio_data.func->dev;
#endif
#ifdef CONFIG_GSPI_HCI
return &dvobj->gspi_data.func->dev;
#endif
#ifdef CONFIG_PCI_HCI
return &dvobj->pci_data.ppcidev->dev;
#endif
}
#endif
_adapter *dvobj_get_unregisterd_adapter(struct dvobj_priv *dvobj);
_adapter *dvobj_get_adapter_by_addr(struct dvobj_priv *dvobj, u8 *addr);
#define dvobj_get_primary_adapter(dvobj) ((dvobj)->padapters[IFACE_ID0])
enum _ADAPTER_TYPE {
PRIMARY_ADAPTER,
VIRTUAL_ADAPTER,
MAX_ADAPTER = 0xFF,
};
#ifdef CONFIG_RTW_NAPI
enum _NAPI_STATE {
NAPI_DISABLE = 0,
NAPI_ENABLE = 1,
};
#endif
#if 0 /*#ifdef CONFIG_MAC_LOOPBACK_DRIVER*/
typedef struct loopbackdata {
_sema sema;
_thread_hdl_ lbkthread;
u8 bstop;
u32 cnt;
u16 size;
u16 txsize;
u8 txbuf[0x8000];
u16 rxsize;
u8 rxbuf[0x8000];
u8 msg[100];
} LOOPBACKDATA, *PLOOPBACKDATA;
#endif
#define ADAPTER_TX_BW_2G(adapter) BW_MODE_2G((adapter)->driver_tx_bw_mode)
#define ADAPTER_TX_BW_5G(adapter) BW_MODE_5G((adapter)->driver_tx_bw_mode)
#ifdef RTW_PHL_DBG_CMD
#define CORE_LOG_NUM (100)
#define MAX_FRAG (4)
#define INV_TXFORCE_VAL (0xFFFF)
enum _CORE_REC_DUMP {
REC_DUMP_NO = 0,
REC_DUMP_ALL,
REC_DUMP_TX,
REC_DUMP_RX,
};
enum _CORE_REC_TYPE {
REC_TX_MGMT = 0,
REC_TX_DATA,
REC_TX_PHL,
REC_TX_PHL_RCC,
REC_RX_PHL,
REC_RX_PHL_RCC,
REC_RX_MGMT,
REC_RX_DATA,
REC_RX_DATA_RETRY,
};
struct core_record {
u32 type;
u32 totalSz;
u32 wl_seq;
u32 wl_type;
u32 wl_subtype;
u8 fragNum;
u32 fragLen[MAX_FRAG];
void* virtAddr[MAX_FRAG];
void* phyAddrL[MAX_FRAG];
void* phyAddrH[MAX_FRAG];
};
struct core_logs {
u32 txCnt_all;
u32 txCnt_data;
u32 txCnt_mgmt;
u32 txCnt_phl;
u32 txSize_phl;
u32 txCnt_recycle;
u32 txSize_recycle;
struct core_record drvTx[CORE_LOG_NUM];
struct core_record phlTx[CORE_LOG_NUM];
struct core_record txRcycle[CORE_LOG_NUM];
u32 rxCnt_phl;
u32 rxSize_phl;
u32 rxCnt_recycle;
u32 rxSize_recycle;
u32 rxCnt_data;
u32 rxCnt_data_retry;
u32 rxCnt_mgmt;
u32 rxCnt_all;
struct core_record drvRx[CORE_LOG_NUM];
struct core_record phlRx[CORE_LOG_NUM];
struct core_record rxRcycle[CORE_LOG_NUM];
#ifdef CONFIG_RTW_CORE_RXSC
u32 rxCnt_data_orig;
u32 rxCnt_data_shortcut;
#endif
};
#define MAX_TXBD_SIZE 40
#define MAX_TXWD_SIZE 128
#define MAX_RXWD_SIZE 32
enum _PHL_REC_TYPE {
REC_TXBD = 0,
REC_TXWD,
REC_RXWD,
REC_WP_RCC,
REC_RX_MAP,
REC_RX_UNMAP,
REC_RX_AMPDU,
};
struct record_txbd {
u32 bd_len;
u8 bd_buf[MAX_TXBD_SIZE];
};
struct record_txwd {
u32 wp_seq;
u32 wd_len;
u8 wd_buf[MAX_TXWD_SIZE];
};
struct record_rxwd {
u32 wd_len;
u8 wd_buf[MAX_RXWD_SIZE];
};
struct record_pci {
u32 map_len;
void *virtAddr;
void* phyAddrL;
void* phyAddrH;
};
struct record_wp_rcc {
u32 wp_seq;
};
struct phl_logs {
u32 txCnt_bd;
u32 txCnt_wd;
u32 txCnt_recycle;
struct record_txbd txBd[CORE_LOG_NUM];
struct record_txwd txWd[CORE_LOG_NUM];
struct record_wp_rcc wpRecycle[CORE_LOG_NUM];
u32 rxCnt_map;
u32 rxSize_map;
u32 rxCnt_unmap;
u32 rxSize_unmap;
struct record_pci rxPciMap[CORE_LOG_NUM];
struct record_pci rxPciUnmap[CORE_LOG_NUM];
u32 rxCnt_wd;
struct record_rxwd rxWd[CORE_LOG_NUM];
u32 rxCnt_ampdu;
u32 rxAmpdu[CORE_LOG_NUM];
};
#endif
enum _DIS_TURBO_EDCA {
EN_TURBO = 0,
DIS_TURBO,
DIS_TURBO_USE_MANUAL,
};
struct _ADAPTER {
int pid[3];/*process id from UI, 0:wpa_supplicant, 1:hostapd, 2:dhcpcd*/
/*extend to support multi interface*/
u8 iface_id;
u8 isprimary; /* is primary adapter or not */
/* notes:
** if isprimary is true, the adapter_type value is 0, iface_id is IFACE_ID0 for PRIMARY_ADAPTER
** if isprimary is false, the adapter_type value is 1, iface_id is IFACE_ID1 for VIRTUAL_ADAPTER
** refer to iface_id if iface_nums>2 and isprimary is false and the adapter_type value is 0xff.*/
u8 adapter_type;/*be used in Multi-interface to recognize whether is PRIMARY_ADAPTER or not(PRIMARY_ADAPTER/VIRTUAL_ADAPTER) .*/
u8 hw_port; /*interface port type, it depends on HW port */
u8 mac_addr[ETH_ALEN];
/*CONFIG_PHL_ARCH*/
struct rtw_wifi_role_t *phl_role;
ATOMIC_T need_tsf_sync_done;
#ifdef CONFIG_HWSIM
int bup_hwsim;
#endif
u8 netif_up;
u8 registered;
u8 ndev_unregistering;
struct dvobj_priv *dvobj;
struct mlme_priv mlmepriv;
struct mlme_ext_priv mlmeextpriv;
struct xmit_priv xmitpriv;
struct recv_info recvinfo;/*rssi*/
struct sta_priv stapriv;
struct security_priv securitypriv;
_lock security_key_mutex; /* add for CONFIG_IEEE80211W, none 11w also can use */
struct registry_priv registrypriv;
#ifdef CONFIG_RTW_80211K
struct rm_priv rmpriv;
#endif
#ifdef CONFIG_MP_INCLUDED
struct mp_priv mppriv;
#endif
#ifdef CONFIG_AP_MODE
struct hostapd_priv *phostapdpriv;
u8 bmc_tx_rate;
#ifdef CONFIG_AP_CMD_DISPR
struct ap_cmd_dispr_priv *apcmd_dipsr_priv;
u32 ap_start_cmd_token;
u32 ap_stop_cmd_token;
u8 ap_start_cmd_state;
u8 ap_stop_cmd_state;
#endif
#if CONFIG_RTW_AP_DATA_BMC_TO_UC
u8 b2u_flags_ap_src;
u8 b2u_flags_ap_fwd;
#endif
#endif/*CONFIG_AP_MODE*/
u32 setband;
ATOMIC_T bandskip;
#ifdef CONFIG_P2P
struct wifidirect_info wdinfo;
#endif /* CONFIG_P2P */
#ifdef CONFIG_TDLS
struct tdls_info tdlsinfo;
#endif /* CONFIG_TDLS */
#ifdef CONFIG_WFD
struct wifi_display_info wfd_info;
#endif /* CONFIG_WFD */
#ifdef CONFIG_RTW_NAPI
struct napi_struct napi;
u8 napi_state;
#endif
#ifdef CONFIG_GPIO_API
u8 pre_gpio_pin;
struct gpio_int_priv {
u8 interrupt_mode;
u8 interrupt_enable_mask;
void (*callback[8])(u8 level);
} gpiointpriv;
#endif
#if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
_thread_hdl_ cmdThread;
#endif
#if 0 /*def CONFIG_XMIT_THREAD_MODE*/
_thread_hdl_ xmitThread;
#endif
#ifdef CONFIG_RECV_THREAD_MODE
_thread_hdl_ recvThread;
#endif
#ifdef PLATFORM_LINUX
#ifdef CONFIG_IOCTL_CFG80211
struct cfg80211_roch_info cfg80211_rochinfo;
#endif /* CONFIG_IOCTL_CFG80211 */
_nic_hdl pnetdev;
char old_ifname[IFNAMSIZ];
/* used by rtw_rereg_nd_name related function */
struct rereg_nd_name_data {
_nic_hdl old_pnetdev;
char old_ifname[IFNAMSIZ];
u8 old_ips_mode;
u8 old_bRegUseLed;
} rereg_nd_name_priv;
struct net_device_stats stats;
struct iw_statistics iwstats;
struct proc_dir_entry *dir_dev;/* for proc directory */
struct proc_dir_entry *dir_odm;
#ifdef CONFIG_IOCTL_CFG80211
struct wireless_dev *rtw_wdev;
struct rtw_wdev_priv wdev_data;
#endif /* CONFIG_IOCTL_CFG80211 */
#endif /* PLATFORM_LINUX */
#ifdef CONFIG_TX_AMSDU
u8 tx_amsdu;
u16 tx_amsdu_rate;
#endif
#ifdef CONFIG_RTW_WDS
bool use_wds; /* for STA, AP mode */
/* for STA mode */
struct rtw_wds_gptr_table *wds_gpt_records;
ATOMIC_T wds_gpt_record_num;
/* for AP mode */
#ifdef CONFIG_AP_MODE
struct rtw_wds_table *wds_paths;
ATOMIC_T wds_path_num;
#endif
#endif /* CONFIG_RTW_WDS */
#ifdef CONFIG_RTW_MULTI_AP
u8 multi_ap;
u8 ch_util_threshold;
#endif
#ifdef CONFIG_RTW_MESH
struct rtw_mesh_cfg mesh_cfg;
struct rtw_mesh_info mesh_info;
_timer mesh_path_timer;
_timer mesh_path_root_timer;
_timer mesh_atlm_param_req_timer; /* airtime link metrics param request timer */
_workitem mesh_work;
unsigned long wrkq_flags;
#endif /* CONFIG_RTW_MESH */
#ifdef CONFIG_RTW_TOKEN_BASED_XMIT
ATOMIC_T tbtx_tx_pause;
ATOMIC_T tbtx_remove_tx_pause;
u8 tbtx_capability;
u32 tbtx_duration;
#endif /* CONFIG_RTW_TOKEN_BASED_XMIT */
#ifdef CONFIG_WAPI_SUPPORT
u8 WapiSupport;
RT_WAPI_T wapiInfo;
#endif
#ifdef CONFIG_BR_EXT
_lock br_ext_lock;
/* unsigned int macclone_completed; */
struct nat25_network_db_entry *nethash[NAT25_HASH_SIZE];
int pppoe_connection_in_progress;
unsigned char pppoe_addr[MACADDRLEN];
unsigned char scdb_mac[MACADDRLEN];
unsigned char scdb_ip[4];
struct nat25_network_db_entry *scdb_entry;
unsigned char br_mac[MACADDRLEN];
unsigned char br_ip[4];
struct br_ext_info ethBrExtInfo;
#endif /* CONFIG_BR_EXT */
#if 0 /*#ifdef CONFIG_MAC_LOOPBACK_DRIVER*/
PLOOPBACKDATA ploopback;
#endif
#ifdef PLATFORM_FREEBSD
_nic_hdl pifp;
_lock glock;
#endif /* PLATFORM_FREEBSD */
/* for debug purpose */
#define NO_FIX_RATE 0xFFFF
#define GET_FIX_RATE(v) ((v) & 0x0FFF)
#define GET_FIX_RATE_SGI(v) (((v) & 0x7000) >> 12)
u16 fix_rate;
#define NO_FIX_BW 0xFF
u8 fix_bw;
u8 data_fb; /* data rate fallback, valid only when fix_rate is not 0xffff */
u8 power_offset;
u8 driver_tx_bw_mode;
u8 rsvd_page_offset;
u8 rsvd_page_num;
u8 ch_clm_ratio;
u8 ch_nhm_ratio;
#ifdef CONFIG_SUPPORT_FIFO_DUMP
u8 fifo_sel;
u32 fifo_addr;
u32 fifo_size;
#endif
u8 bLinkInfoDump;
/* Added by Albert 2012/10/26 */
/* The driver will show up the desired channel number when this flag is 1. */
u8 bNotifyChannelChange;
u8 bsta_tp_dump;
#ifdef CONFIG_P2P
/* Added by Albert 2012/12/06 */
/* The driver will show the current P2P status when the upper application reads it. */
u8 bShowGetP2PState;
#endif
u8 driver_vcs_en; /* Enable=1, Disable=0 driver control vrtl_carrier_sense for tx */
u8 driver_vcs_type;/* force 0:disable VCS, 1:RTS-CTS, 2:CTS-to-self when vcs_en=1. */
u8 driver_ampdu_spacing;/* driver control AMPDU Density for peer sta's rx */
u8 driver_rx_ampdu_factor;/* 0xff: disable drv ctrl, 0:8k, 1:16k, 2:32k, 3:64k; */
u8 driver_rx_ampdu_spacing; /* driver control Rx AMPDU Density */
u8 fix_rx_ampdu_accept;
u8 fix_rx_ampdu_size; /* 0~127, TODO:consider each sta and each TID */
u8 driver_tx_max_agg_num; /*fix tx desc max agg num , 0xff: disable drv ctrl*/
#ifdef DBG_RX_COUNTER_DUMP
u8 dump_rx_cnt_mode;/*BIT0:drv,BIT1:mac,BIT2:phy*/
u32 drv_rx_cnt_ok;
u32 drv_rx_cnt_crcerror;
u32 drv_rx_cnt_drop;
#endif
#ifdef CONFIG_DBG_COUNTER
struct rx_logs rx_logs;
struct tx_logs tx_logs;
struct int_logs int_logs;
#endif
#ifdef RTW_PHL_DBG_CMD
struct core_logs core_logs;
struct phl_logs phl_logs;
u32 txForce_enable;
u32 txForce_rate;
u32 txForce_agg;
u32 txForce_aggnum;
u32 txForce_gi;
u32 sniffer_enable;
u8 record_enable;
#endif
#ifdef RTW_PHL_TX
u8 *pxmit_txreq_buf;
_queue free_txreq_queue;
u32 free_txreq_cnt;
u32 txreq_full_cnt;
u32 tx_ring_idx;
u8 *tx_pool_ring [MAX_TX_RING_NUM];
#endif
#ifdef CONFIG_RTW_CORE_RXSC
u8 enable_rxsc;
#endif
#ifdef DBG_CONFIG_CMD_DISP
enum phl_cmd_type cmd_type;
u32 cmd_timeout;
#endif
u8 dis_turboedca;/* 1: disable turboedca,
2. disable turboedca,and setting EDCA parameter based on the input parameter*/
u32 edca_param_mode;
u32 last_edca;
#ifdef CONFIG_STA_CMD_DISPR
_lock connect_st_lock;
u8 connect_state;
#define CONNECT_ST_NOT_READY 0
#define CONNECT_ST_IDLE 1
#define CONNECT_ST_REQUESTING 2
#define CONNECT_ST_ACQUIRED 3
bool connect_abort;
struct phl_cmd_token_req connect_req;
u32 connect_token;
_lock disconnect_lock;
struct phl_cmd_token_req disconnect_req;
u32 disconnect_token;
struct cmd_obj *discon_cmd;
#endif /* CONFIG_STA_CMD_DISPR */
#ifdef CONFIG_ECSA_PHL
struct core_ecsa_info ecsa_info;
#endif
};
#define adapter_to_dvobj(adapter) ((adapter)->dvobj)
#define adapter_to_regsty(adapter) dvobj_to_regsty(adapter_to_dvobj((adapter)))
#define adapter_to_pwrctl(adapter) dvobj_to_pwrctl(adapter_to_dvobj((adapter)))
#ifdef CONFIG_WOWLAN
#define adapter_to_wowlan(adapter) dvobj_to_wowlan(adapter_to_dvobj((adapter)))
#endif /* CONFIG_WOWLAN */
#define adapter_wdev_data(adapter) (&((adapter)->wdev_data))
#define adapter_to_wiphy(adapter) dvobj_to_wiphy(adapter_to_dvobj(adapter))
#define adapter_to_rfctl(adapter) dvobj_to_rfctl(adapter_to_dvobj((adapter)))
#define adapter_to_macidctl(adapter) dvobj_to_macidctl(adapter_to_dvobj((adapter)))
#ifdef CONFIG_RTW_WDS
#define adapter_use_wds(adapter) (adapter->use_wds)
#define adapter_set_use_wds(adapter, en) do { \
(adapter)->use_wds = (en) ? 1 : 0; \
RTW_INFO(FUNC_ADPT_FMT" set use_wds=%d\n", FUNC_ADPT_ARG(adapter), (adapter)->use_wds); \
} while (0)
#else
#define adapter_use_wds(adapter) 0
#endif
#define adapter_mac_addr(adapter) (adapter->mac_addr)
#ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
#define adapter_pno_mac_addr(adapter) \
((adapter_wdev_data(adapter))->pno_mac_addr)
#endif
#define adapter_to_chset(adapter) (adapter_to_rfctl((adapter))->channel_set)
#define mlme_to_adapter(mlme) container_of((mlme), _adapter, mlmepriv)
#define tdls_info_to_adapter(tdls) container_of((tdls), _adapter, tdlsinfo)
#define rtw_get_chip_id(adapter) (((_adapter *)adapter)->dvobj->chip_id)
#define rtw_get_intf_type(adapter) (((_adapter *)adapter)->dvobj->interface_type)
#define rtw_get_mi_nums(adapter) (((_adapter *)adapter)->dvobj->iface_nums)
static inline void dev_set_surprise_removed(struct dvobj_priv *dvobj)
{
ATOMIC_SET(&dvobj->bSurpriseRemoved, _TRUE);
if (dvobj->phl)
rtw_phl_dev_terminate_ntf(dvobj->phl);
}
static inline void dev_clr_surprise_removed(struct dvobj_priv *dvobj)
{
ATOMIC_SET(&dvobj->bSurpriseRemoved, _FALSE);
if (dvobj->phl_com)
CLEAR_STATUS_FLAG(dvobj->phl_com->dev_state, RTW_DEV_SURPRISE_REMOVAL);
}
static inline void dev_set_drv_stopped(struct dvobj_priv *dvobj)
{
ATOMIC_SET(&dvobj->bDriverStopped, _TRUE);
}
static inline void dev_clr_drv_stopped(struct dvobj_priv *dvobj)
{
ATOMIC_SET(&dvobj->bDriverStopped, _FALSE);
}
static inline void dev_set_hw_start(struct dvobj_priv *dvobj)
{
ATOMIC_SET(&dvobj->hw_start, _TRUE);
}
static inline void dev_clr_hw_start(struct dvobj_priv *dvobj)
{
ATOMIC_SET(&dvobj->hw_start, _FALSE);
}
#define dev_is_surprise_removed(dvobj) (ATOMIC_READ(&dvobj->bSurpriseRemoved) == _TRUE)
#define dev_is_drv_stopped(dvobj) (ATOMIC_READ(&dvobj->bDriverStopped) == _TRUE)
#define dev_is_hw_start(dvobj) (ATOMIC_READ(&dvobj->hw_start) == _TRUE)
/*
* Function disabled.
* */
#define DF_TX_BIT BIT0 /*rtw_usb_write_port_cancel*/
#define DF_RX_BIT BIT1 /*rtw_usb_read_port_cancel*/
#define DF_IO_BIT BIT2
/* #define RTW_DISABLE_FUNC(padapter, func) (ATOMIC_ADD(&dvobj->disable_func, (func))) */
/* #define RTW_ENABLE_FUNC(padapter, func) (ATOMIC_SUB(&dvobj->disable_func, (func))) */
__inline static void RTW_DISABLE_FUNC(struct dvobj_priv *dvobj, int func_bit)
{
int df = ATOMIC_READ(&dvobj->disable_func);
df |= func_bit;
ATOMIC_SET(&dvobj->disable_func, df);
}
__inline static void RTW_ENABLE_FUNC(struct dvobj_priv *dvobj, int func_bit)
{
int df = ATOMIC_READ(&dvobj->disable_func);
df &= ~(func_bit);
ATOMIC_SET(&dvobj->disable_func, df);
}
#define RTW_CANNOT_RUN(dvobj) \
(dev_is_surprise_removed(dvobj) || \
dev_is_drv_stopped(dvobj))
#define RTW_IS_FUNC_DISABLED(dvobj, func_bit) \
(ATOMIC_READ(&dvobj->disable_func) & (func_bit))
#define RTW_CANNOT_IO(dvobj) \
(dev_is_surprise_removed(dvobj) || \
RTW_IS_FUNC_DISABLED((dvobj), DF_IO_BIT))
#define RTW_CANNOT_RX(dvobj) \
(RTW_CANNOT_RUN(dvobj) || \
RTW_IS_FUNC_DISABLED((dvobj), DF_RX_BIT))
#define RTW_CANNOT_TX(dvobj) \
(RTW_CANNOT_RUN(dvobj) || \
RTW_IS_FUNC_DISABLED((dvobj), DF_TX_BIT))
/* HCI Related header file */
#ifdef CONFIG_USB_HCI
#include <usb_ops.h>
#endif
#ifdef CONFIG_SDIO_HCI
#include <sdio_ops.h>
#endif
#ifdef CONFIG_GSPI_HCI
#include <gspi_ops.h>
#endif
#ifdef CONFIG_PCI_HCI
#include <pci_ops.h>
#endif
#include <rtw_trx_ops.h>
#endif /* __DRV_TYPES_H__ */
|
2301_81045437/rtl8852be
|
include/drv_types.h
|
C
|
agpl-3.0
| 49,328
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __DRV_TYPES_GSPI_H__
#define __DRV_TYPES_GSPI_H__
/* SPI Header Files */
#ifdef PLATFORM_LINUX
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/gpio.h>
/* #include <mach/ldo.h> */
#include <asm/mach-types.h>
#include <asm/gpio.h>
#include <asm/io.h>
#include <mach/board.h>
#include <mach/hardware.h>
#include <mach/irqs.h>
#include <custom_gpio.h>
#endif
typedef struct gspi_data {
u8 func_number;
u8 tx_block_mode;
u8 rx_block_mode;
u32 block_transfer_len;
#ifdef PLATFORM_LINUX
struct spi_device *func;
struct workqueue_struct *priv_wq;
struct delayed_work irq_work;
#endif
} GSPI_DATA, *PGSPI_DATA;
#endif /* #ifndef __DRV_TYPES_GSPI_H__ */
|
2301_81045437/rtl8852be
|
include/drv_types_gspi.h
|
C
|
agpl-3.0
| 1,367
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __DRV_TYPES_PCI_H__
#define __DRV_TYPES_PCI_H__
#ifdef PLATFORM_LINUX
#include <linux/pci.h>
#endif
#define INTEL_VENDOR_ID 0x8086
#define SIS_VENDOR_ID 0x1039
#define ATI_VENDOR_ID 0x1002
#define ATI_DEVICE_ID 0x7914
#define AMD_VENDOR_ID 0x1022
#define PCI_VENDER_ID_REALTEK 0x10ec
enum aspm_mode {
ASPM_MODE_UND,
ASPM_MODE_PERF,
ASPM_MODE_PS,
ASPM_MODE_DEF,
};
struct pci_priv {
BOOLEAN pci_clk_req;
u8 pciehdr_offset;
u8 linkctrl_reg;
u8 pcibridge_linkctrlreg;
u8 amd_l1_patch;
#ifdef CONFIG_PCI_DYNAMIC_ASPM
u8 aspm_mode;
#endif
};
typedef struct _RT_ISR_CONTENT {
union {
u32 IntArray[2];
u32 IntReg4Byte;
u16 IntReg2Byte;
};
} RT_ISR_CONTENT, *PRT_ISR_CONTENT;
typedef struct pci_data {
#ifdef PLATFORM_LINUX
struct pci_dev *ppcidev;
/* PCI MEM map */
unsigned long pci_mem_end; /* shared mem end */
unsigned long pci_mem_start; /* shared mem start */
/* PCI IO map */
unsigned long pci_base_addr; /* device I/O address */
#ifdef RTK_129X_PLATFORM
unsigned long ctrl_start;
/* PCI MASK addr */
unsigned long mask_addr;
/* PCI TRANSLATE addr */
unsigned long tran_addr;
_lock io_reg_lock;
#endif
/* PciBridge */
struct pci_priv pcipriv;
u8 irq_alloc;
unsigned int irq; /* get from pci_dev.irq, store to net_device.irq */
u16 irqline;
u8 irq_enabled;
RT_ISR_CONTENT isr_content;
_lock irq_th_lock;
u8 bdma64;
#endif/* PLATFORM_LINUX */
} PCI_DATA, *PPCI_DATA;
#endif
|
2301_81045437/rtl8852be
|
include/drv_types_pci.h
|
C
|
agpl-3.0
| 2,125
|
/******************************************************************************
*
* Copyright(c) 2007 - 2021 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __DRV_TYPES_SDIO_H__
#define __DRV_TYPES_SDIO_H__
/* SDIO Header Files */
#ifdef PLATFORM_LINUX
#include <linux/mmc/sdio_func.h>
#include <linux/mmc/sdio_ids.h>
#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#ifdef CONFIG_PLATFORM_SPRD
#include <linux/gpio.h>
#include <custom_gpio.h>
#endif /* CONFIG_PLATFORM_SPRD */
#endif
#define RTW_SDIO_CLK_33M 33000000
#define RTW_SDIO_CLK_40M 40000000
#define RTW_SDIO_CLK_80M 80000000
#define RTW_SDIO_CLK_160M 160000000
typedef struct sdio_data {
u8 func_number;
u8 tx_block_mode;
u8 rx_block_mode;
u32 block_transfer_len;
u16 max_byte_size; /* MAX size for cmd53 byte mode */
u8 irq_alloc;
#ifdef PLATFORM_LINUX
struct mmc_card *card;
struct sdio_func *func;
u8 *tmpbuf; /* buffer for register access */
u8 tmpbuf_sz;
#endif
_thread_hdl_ sys_sdio_irq_thd;
unsigned int clock;
unsigned int timing;
u8 sd3_bus_mode;
#ifdef DBG_SDIO
#ifdef PLATFORM_LINUX
struct proc_dir_entry *proc_sdio_dbg;
#endif /* PLATFORM_LINUX */
u32 cmd52_err_cnt; /* CMD52 I/O error count */
u32 cmd53_err_cnt; /* CMD53 I/O error count */
#if (DBG_SDIO >= 1)
u32 reg_dump_mark; /* reg dump at specific error count */
#endif /* DBG_SDIO >= 1 */
#if (DBG_SDIO >= 2)
u8 *dbg_msg; /* Messages for debug */
u8 dbg_msg_size;
u8 *reg_mac; /* Device MAC register, 0x0~0x800 */
u8 *reg_mac_ext; /* Device MAC extend register, 0x1000~0x1800 */
u8 *reg_local; /* Device SDIO local register, 0x0~0xFF */
u8 *reg_cia; /* SDIO CIA(CCCR, FBR and etc.), 0x0~0x1FF */
#endif /* DBG_SDIO >= 2 */
#if (DBG_SDIO >= 3)
u8 dbg_enable; /* 0/1: disable/enable debug mode */
u8 err_stop; /* Stop(surprise remove) when I/O error happen */
u8 err_test; /* Simulate error happen */
u8 err_test_triggered; /* Simulate error already triggered */
#endif /* DBG_SDIO >= 3 */
#endif /* DBG_SDIO */
} SDIO_DATA, *PSDIO_DATA;
#define dvobj_to_sdio_func(d) ((d)->sdio_data.func)
#define RTW_SDIO_ADDR_CMD52_BIT (1<<17)
#define RTW_SDIO_ADDR_CMD52_GEN(a) (a | RTW_SDIO_ADDR_CMD52_BIT)
#define RTW_SDIO_ADDR_CMD52_CLR(a) (a&~RTW_SDIO_ADDR_CMD52_BIT)
#define RTW_SDIO_ADDR_CMD52_CHK(a) (a&RTW_SDIO_ADDR_CMD52_BIT ? 1 : 0)
#define RTW_SDIO_ADDR_F0_BIT (1<<18)
#define RTW_SDIO_ADDR_F0_GEN(a) (a | RTW_SDIO_ADDR_F0_BIT)
#define RTW_SDIO_ADDR_F0_CLR(a) (a&~RTW_SDIO_ADDR_F0_BIT)
#define RTW_SDIO_ADDR_F0_CHK(a) (a&RTW_SDIO_ADDR_F0_BIT ? 1 : 0)
#endif
|
2301_81045437/rtl8852be
|
include/drv_types_sdio.h
|
C
|
agpl-3.0
| 3,066
|
/******************************************************************************
*
* Copyright(c) 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __DRV_TYPES_USB_H__
#define __DRV_TYPES_USB_H__
/*FOR 8852AU*/
#define MAX_ENDPOINT_NUM 9 /* 2 x Bulk-IN + 7 x Bulk-OUT */
#define MAX_BULKOUT_NUM 7
#define MAX_BULKIN_NUM 2 /*EP4 for Bulk-IN, EP8 for Bulk-IN interrupt or Bulk-INT*/
typedef struct usb_data {
u8 usb_intf_start;
u8 usb_speed; /* 1.1, 2.0 or 3.0 */
u16 usb_bulkout_size;
u8 nr_endpoint; /*MAX_ENDPOINT_NUM*/
/* Bulk In , Out Pipe information */
int RtInPipe[MAX_BULKIN_NUM];
u8 inpipe_type[MAX_BULKIN_NUM];
u8 RtNumInPipes;
int RtOutPipe[MAX_BULKOUT_NUM];
u8 RtNumOutPipes;
#ifdef CONFIG_USB_VENDOR_REQ_MUTEX
_mutex usb_vendor_req_mutex;
#endif
#ifdef CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC
u8 *usb_alloc_vendor_req_buf;
u8 *usb_vendor_req_buf;
#endif
#ifdef PLATFORM_LINUX
struct usb_interface *pusbintf;
struct usb_device *pusbdev;
#endif/* PLATFORM_LINUX */
} USB_DATA, *PUSB_DATA;
#endif /*__DRV_TYPES_USB_H__*/
|
2301_81045437/rtl8852be
|
include/drv_types_usb.h
|
C
|
agpl-3.0
| 1,559
|
/******************************************************************************
*
* Copyright(c) 2007 - 2019 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
/*! \file */
#ifndef __INC_ETHERNET_H
#define __INC_ETHERNET_H
#define ETHERNET_ADDRESS_LENGTH 6 /* !< Ethernet Address Length */
#define ETHERNET_HEADER_SIZE 14 /* !< Ethernet Header Length */
#define LLC_HEADER_SIZE 6 /* !< LLC Header Length */
#define TYPE_LENGTH_FIELD_SIZE 2 /* !< Type/Length Size */
#define MINIMUM_ETHERNET_PACKET_SIZE 60 /* !< Minimum Ethernet Packet Size */
#define MAXIMUM_ETHERNET_PACKET_SIZE 1514 /* !< Maximum Ethernet Packet Size */
#define RT_ETH_IS_MULTICAST(_pAddr) ((((u8 *)(_pAddr))[0]&0x01) != 0) /* !< Is Multicast Address? */
#define RT_ETH_IS_BROADCAST(_pAddr) (\
((u8 *)(_pAddr))[0] == 0xff && \
((u8 *)(_pAddr))[1] == 0xff && \
((u8 *)(_pAddr))[2] == 0xff && \
((u8 *)(_pAddr))[3] == 0xff && \
((u8 *)(_pAddr))[4] == 0xff && \
((u8 *)(_pAddr))[5] == 0xff) /* !< Is Broadcast Address? */
#endif /* #ifndef __INC_ETHERNET_H */
|
2301_81045437/rtl8852be
|
include/ethernet.h
|
C
|
agpl-3.0
| 1,567
|
/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
#ifndef __GSPI_HAL_H__
#define __GSPI_HAL_H__
void spi_int_dpc(_adapter *padapter, u32 sdio_hisr);
#endif /* __GSPI_HAL_H__ */
|
2301_81045437/rtl8852be
|
include/gspi_hal.h
|
C
|
agpl-3.0
| 786
|