Merge "[Feature][T8TSK-79][Factory-test]Further optimize factory test sleep" into MR3.0
diff --git a/meta-sdk/meta-sdk.tar.gz b/meta-sdk/meta-sdk.tar.gz
index dee47fc..a1c574c 100644
--- a/meta-sdk/meta-sdk.tar.gz
+++ b/meta-sdk/meta-sdk.tar.gz
Binary files differ
diff --git a/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wg870_drv_insmod.sh b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wg870_drv_insmod.sh
index efb5945..f163a9e 100755
--- a/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wg870_drv_insmod.sh
+++ b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wg870_drv_insmod.sh
@@ -9,7 +9,7 @@
fi
echo insmod wg870 driver
-insmod /lib/modules/4.19.98/kernel/drivers/net/wireless/bcmdhd/bcmdhd.ko firmware_path=/etc/firmware_pcie.trxse nvram_path=/system/etc/firmware/wifi/wg870/cyw955572fcipa_rev2.52.txt || exit 1
+insmod /lib/modules/4.19.98/kernel/drivers/net/wireless/bcmdhd/bcmdhd.ko firmware_path=/etc/config_pcie.trxse nvram_path=/system/etc/firmware/wifi/wg870/cyw955572fcipa_rev2.52.txt clm_path=/etc/0926.clm_blob || exit 1
wpa_supplicant -g/var/run/wpa_wlan0_cmd -dd -t -u &
exit 0
diff --git a/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/0926.clm_blob b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/0926.clm_blob
new file mode 100755
index 0000000..8b9b2e0
--- /dev/null
+++ b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/0926.clm_blob
Binary files differ
diff --git a/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/config_pcie.trxse b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/config_pcie.trxse
new file mode 100755
index 0000000..87ae8d9
--- /dev/null
+++ b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/config_pcie.trxse
Binary files differ
diff --git a/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/config_pcie_mfgtest.trxse b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/config_pcie_mfgtest.trxse
new file mode 100755
index 0000000..04db000
--- /dev/null
+++ b/meta/meta-mediatek-mt2735/recipes-kernel/modules/files/wifi/wg870/config_pcie_mfgtest.trxse
Binary files differ
diff --git a/src/bsp/lk/platform/mt2735/drivers/gpio/mt_gpio.c b/src/bsp/lk/platform/mt2735/drivers/gpio/mt_gpio.c
index 88300aa..0b6fb75 100644
--- a/src/bsp/lk/platform/mt2735/drivers/gpio/mt_gpio.c
+++ b/src/bsp/lk/platform/mt2735/drivers/gpio/mt_gpio.c
@@ -812,17 +812,17 @@
mt_set_gpio_mode(GPIO25, 0);
mt_set_gpio_dir(GPIO25, GPIO_DIR_OUT);
mt_set_gpio_out(GPIO25, GPIO_OUT_ZERO);
-
+
//you.chen@20220606 modify for wifi begin
- mt_set_gpio_mode(GPIO67, 0);
+ mt_set_gpio_mode(GPIO67, 1); //dongyu@2022.10.21 Test pcie with at command returns error
mt_set_gpio_dir(GPIO67, GPIO_DIR_OUT);
mt_set_gpio_out(GPIO67, GPIO_OUT_ZERO);
-
- mt_set_gpio_mode(GPIO68, 0);
+
+ mt_set_gpio_mode(GPIO68, 1); //dongyu@2022.10.21 Test pcie with at command returns error
mt_set_gpio_pull_enable(GPIO68, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO68, GPIO_PULL_UP);
-
- mt_set_gpio_mode(GPIO69, 0);
+
+ mt_set_gpio_mode(GPIO69, 1); //dongyu@2022.10.21 Test pcie with at command returns error
mt_set_gpio_pull_enable(GPIO69, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO69, GPIO_PULL_UP);
//you.chen@20220606 modify for wifi end
diff --git a/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig b/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig
index 1fd42d0..a9c4cc4 100644
--- a/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig
+++ b/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig
@@ -66,6 +66,7 @@
CONFIG_BCMDHD_PCIE=y
CONFIG_BCMDHD=m
CONFIG_CYW89570=y
+CONFIG_RFKILL=y
#tianyan@2021.10.15 modify for open wifi6 module end
#tianyan@2021.10.15 modify for open wifi5 module start
CONFIG_WLAN=y
diff --git a/src/kernel/linux/v4.19/arch/arm64/configs/defconfig b/src/kernel/linux/v4.19/arch/arm64/configs/defconfig
index 2fc45d5..d2a9ecf 100644
--- a/src/kernel/linux/v4.19/arch/arm64/configs/defconfig
+++ b/src/kernel/linux/v4.19/arch/arm64/configs/defconfig
@@ -171,7 +171,9 @@
CONFIG_CFG80211=m
CONFIG_MAC80211=m
CONFIG_MAC80211_LEDS=y
-CONFIG_RFKILL=m
+CONFIG_RFKILL=y
+#CONFIG_RFKILL_PM=y
+#CONFIG_RFKILL_RK=y
CONFIG_NET_9P=y
CONFIG_NET_9P_VIRTIO=y
CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
diff --git a/src/kernel/linux/v4.19/drivers/mtd/nandx/core/nand_chip.c b/src/kernel/linux/v4.19/drivers/mtd/nandx/core/nand_chip.c
index acb1445..702da05 100644
--- a/src/kernel/linux/v4.19/drivers/mtd/nandx/core/nand_chip.c
+++ b/src/kernel/linux/v4.19/drivers/mtd/nandx/core/nand_chip.c
@@ -63,7 +63,10 @@
}
nand->performance->read_data_time = (int)time_cons;
#endif
-
+ /*jb.qi change for ubi problem on 20221026 start*/
+ if (ops[i].status < 0)
+ pr_err("%s, row:0x%x, status: %d\n", __func__, row, ops[i].status);
+ /*jb.qi change for ubi problem on 20221026 end*/
ret_max = max_t(int, ret_max, ops[i].status);
ret_min = min_t(int, ret_min, ops[i].status);
#if NANDX_PAGE_PERFORMANCE_TRACE
@@ -99,6 +102,8 @@
row = ops[i].row;
col = ops[i].col;
+ pr_err("%s, row:0x%x\n", __func__, row);//jb.qi change for ubi problem on 20221026 start
+
nand->addressing(nand, &row, &col);
ops[i].status = nand->write_enable(nand);
@@ -176,6 +181,8 @@
nand->addressing(nand, &row, &col);
+ pr_err("%s, row:0x%x\n", __func__, row);//jb.qi change for ubi problem on 20221026 start
+
ops[i].status = nand->write_enable(nand);
if (ops[i].status) {
pr_debug("Write Protect at %x!\n", row);
diff --git a/src/kernel/linux/v4.19/drivers/mtd/ubi/io.c b/src/kernel/linux/v4.19/drivers/mtd/ubi/io.c
index 0e3a76a..48df1f1 100644
--- a/src/kernel/linux/v4.19/drivers/mtd/ubi/io.c
+++ b/src/kernel/linux/v4.19/drivers/mtd/ubi/io.c
@@ -461,21 +461,13 @@
*/
static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
{
- int err;
+ int err, ec_err, vid_err;
size_t written;
loff_t addr;
uint32_t data = 0;
struct ubi_ec_hdr ec_hdr;
- struct ubi_vid_io_buf vidb;
-
- /*
- * Note, we cannot generally define VID header buffers on stack,
- * because of the way we deal with these buffers (see the header
- * comment in this file). But we know this is a NOR-specific piece of
- * code, so we can do this. But yes, this is error-prone and we should
- * (pre-)allocate VID header buffer instead.
- */
- struct ubi_vid_hdr vid_hdr;
+ /*jb.qi change for ubi problem on 20221026 start*/
+ struct ubi_vid_io_buf *vidb;
/*
* If VID or EC is valid, we have to corrupt them before erasing.
@@ -485,25 +477,33 @@
* corrupted and will try to preserve it, and print scary warnings.
*/
addr = (loff_t)pnum * ubi->peb_size;
- err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
- if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&
- err != UBI_IO_FF){
- err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
- if(err)
+ vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS);
+ if (!vidb)
+ return -ENOMEM;
+
+ ec_err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
+ vid_err = ubi_io_read_vid_hdr(ubi, pnum, vidb, 0);
+ if (ec_err != UBI_IO_BAD_HDR_EBADMSG && ec_err != UBI_IO_BAD_HDR &&
+ ec_err != UBI_IO_FF){
+ ec_err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
+ if(ec_err) {
+ err = ec_err;
goto error;
+ }
}
- ubi_init_vid_buf(ubi, &vidb, &vid_hdr);
- ubi_assert(&vid_hdr == ubi_get_vid_hdr(&vidb));
-
- err = ubi_io_read_vid_hdr(ubi, pnum, &vidb, 0);
- if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&
- err != UBI_IO_FF){
+ if (vid_err != UBI_IO_BAD_HDR_EBADMSG && vid_err != UBI_IO_BAD_HDR &&
+ vid_err != UBI_IO_FF){
addr += ubi->vid_hdr_aloffset;
- err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
- if (err)
- goto error;
+ vid_err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
+ if(vid_err) {
+ err = vid_err;
+ goto error;
+ }
}
+
+ ubi_free_vid_buf(vidb);
+ /*jb.qi change for ubi problem on 20221026 end*/
return 0;
error:
@@ -514,6 +514,7 @@
*/
ubi_err(ubi, "cannot invalidate PEB %d, write returned %d", pnum, err);
ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
+ ubi_free_vid_buf(vidb);//jb.qi change for ubi problem on 20221026
return -EIO;
}
@@ -547,13 +548,11 @@
ubi_err(ubi, "read-only mode");
return -EROFS;
}
-
- if (ubi->nor_flash) {
- err = nor_erase_prepare(ubi, pnum);
- if (err)
- return err;
- }
-
+ /*jb.qi change for ubi problem on 20221026 start*/
+ err = erase_prepare(ubi, pnum);
+ if (err)
+ return err;
+ /*jb.qi change for ubi problem on 20221026 end*/
if (torture) {
ret = torture_peb(ubi, pnum);
if (ret < 0)
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Kconfig b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Kconfig
old mode 100644
new mode 100755
index 767d58d..29835c5
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Kconfig
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Kconfig
@@ -39,7 +39,7 @@
config BCM4359
tristate "BCM4359 support"
depends on BCMDHD
- default n
+ default y
config BCM4361
tristate "BCM4361 support"
@@ -49,7 +49,7 @@
config CYW89570
tristate "CYW89570 support"
depends on BCMDHD
- default n
+ default y
config DHD_OF_SUPPORT
bool "Use in-drive platform device"
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Makefile b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Makefile
old mode 100644
new mode 100755
index e16db13..6507e16
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Makefile
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/Makefile
@@ -39,7 +39,7 @@
-DGET_CUSTOM_MAC_ENABLE \
-DSEC_ENHANCEMENT -DDHD_FW_COREDUMP -DCHIPS_CUSTOMER_HW6 \
-DDHD_RND_DEBUG -DDHD_DUMP_FILE_WRITE_FROM_KERNEL \
- -DDHD_DONOT_FORWARD_BCMEVENT_AS_NETWORK_PKT
+ -DDHD_DONOT_FORWARD_BCMEVENT_AS_NETWORK_PKT -DWL11AX
GCCVERSIONGTEQ9 := $(shell expr `$(CROSS_COMPILE)gcc -dumpversion | cut -f1 -d.` \>= 9)
ifeq "$(GCCVERSIONGTEQ9)" "1"
@@ -145,6 +145,12 @@
DHDCFLAGS += -DWBTEXT
DHDCFLAGS += -DDHD_LOSSLESS_ROAMING
+# Hog flags
+#DHDCFLAGS += -DENABLE_HOGSQS
+#ifeq ($(ENABLE_HOGSQS), y)
+#DHDCFLAGS += -DM_HOGSQS_CFG=0x1910
+#endif // endif
+
# For special PNO Event keep wake lock for 10sec
DHDCFLAGS += -DCUSTOM_PNO_EVENT_LOCK_xTIME=10
DHDCFLAGS += -DMIRACAST_AMPDU_SIZE=8
@@ -302,7 +308,12 @@
ifeq ($(CONFIG_BCMDHD_SDMMC),y)
DHDCFLAGS += -DBCMLXSDMMC -DCUSTOM_TXGLOM=1
ifneq ($(CONFIG_HAVE_IMX8_SOC),)
- DHDCFLAGS += -DCONFIG_DTS -DPLATFORM_IMX
+ DHDCFLAGS += \
+ -DCONFIG_DTS \
+ -DOEM_EMBEDDED_LINUX \
+ -DPLATFORM_IMX \
+ -DSDIO_ISR_THREAD \
+ -DWL_VIF_SUPPORT
endif
endif
@@ -338,6 +349,11 @@
DHDCFLAGS += -DWLFC_STATE_PREALLOC
DHDCFLAGS += -DREVERSE_AIFSN
+
+# btsharedsdio
+ifneq ($(CONFIG_BT_OVER_SDIO),)
+ DHDCFLAGS += -DBT_OVER_SDIO
+endif
endif
# Expand TCP tx queue to 10 times of default size
@@ -394,7 +410,8 @@
# Enable MSI interrupt Support
DHDCFLAGS += -DDHD_MSI_SUPPORT
-
+ DHDCFLAGS += -DDHD_FORCE_MSI
+ DHDCFLAGS += -DDHD_DISABLE_FWLOG_IN_CHIPBOOT
# Enabling temporarily due to build failure
DHDCFLAGS += -DDHD_PKTTS -DTX_STATUS_LATENCY_STATS
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmdhd_89570_temp_disable_fwlog.diff b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmdhd_89570_temp_disable_fwlog.diff
new file mode 100755
index 0000000..b744ef9
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmdhd_89570_temp_disable_fwlog.diff
@@ -0,0 +1,42 @@
+diff -urN bcmdhd_headhight_89570_bak/dhd_linux.c bcmdhd/dhd_linux.c
+--- bcmdhd_headhight_89570_bak/dhd_linux.c 2022-09-18 19:32:16.209593494 +0800
++++ bcmdhd/dhd_linux.c 2022-09-18 19:58:09.449580833 +0800
+@@ -8420,6 +8420,11 @@
+
+ dhd_attach_states_t dhd_state = DHD_ATTACH_STATE_INIT;
+ DHD_TRACE(("%s: Enter\n", __FUNCTION__));
++
++#ifdef DHD_DISABLE_FWLOG_IN_CHIPBOOT
++ dhd_msg_level = (dhd_msg_level & (~DHD_FWLOG_VAL));
++ DHD_ERROR(("%s , dhd_msg_level: 0x%x\n", __FUNCTION__, dhd_msg_level));
++#endif
+
+ #ifdef PCIE_FULL_DONGLE
+ ASSERT(sizeof(dhd_pkttag_fd_t) <= OSL_PKTTAG_SZ);
+@@ -12077,10 +12082,15 @@
+ net->netdev_ops = &dhd_ops_virt;
+
+ /* Ok, link into the network layer... */
++ DHD_ERROR(("%s , ifidx: %d\n", __FUNCTION__, ifidx));
+ if (ifidx == 0) {
+ /*
+ * device functions for the primary interface only
+ */
++#ifdef DHD_DISABLE_FWLOG_IN_CHIPBOOT
++ dhd_msg_level = (dhd_msg_level | (DHD_FWLOG_VAL));
++ DHD_ERROR(("%s , dhd_msg_level: 0x%x\n", __FUNCTION__, dhd_msg_level));
++#endif
+ net->netdev_ops = &dhd_ops_pri;
+ if (!ETHER_ISNULLADDR(dhd->pub.mac.octet))
+ memcpy(temp_addr, dhd->pub.mac.octet, ETHER_ADDR_LEN);
+diff -urN bcmdhd_headhight_89570_bak/Makefile bcmdhd/Makefile
+--- bcmdhd_headhight_89570_bak/Makefile 2022-09-18 19:32:16.285593494 +0800
++++ bcmdhd/Makefile 2022-09-18 19:51:12.753584229 +0800
+@@ -38,6 +38,7 @@
+ # DHDCFLAGS += -DCUSTOM_AMPDU_MPDU=16
+
+ DHDCFLAGS += -DDHD_FORCE_MSI
++DHDCFLAGS += -DDHD_DISABLE_FWLOG_IN_CHIPBOOT
+ #####################
+ # SDIO Basic feature
+ #####################
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmsdh.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmsdh.c
old mode 100644
new mode 100755
index b453875..f27c1c2
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmsdh.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmsdh.c
@@ -147,7 +147,11 @@
BCMSDH_INFO(("%s: func %p \n", __FUNCTION__, func));
func_f3 = func;
processf3intr = f3intr_fun;
+#if defined(BCMLXSDMMC)
sdioh_sdmmc_card_enable_func_f3(bcmsdh->sdioh, func);
+#else
+ BCMSDH_ERROR(("bcmsdh_btsdio_interface_init: not support f3 enable on non-sdmmc build\n"));
+#endif /* defined(BCMLXSDMMC) */
process_dhd_hang_notification = hang_notification;
} EXPORT_SYMBOL(bcmsdh_btsdio_interface_init);
@@ -614,7 +618,7 @@
incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
- if (width == 4)
+ if (fn != SDIO_FUNC_3 && width == 4)
addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
@@ -652,7 +656,7 @@
incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
- if (width == 4)
+ if (fn != SDIO_FUNC_3 && width == 4)
addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmwifi_channels.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmwifi_channels.h
old mode 100644
new mode 100755
index 4b22113..e78878b
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmwifi_channels.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/bcmwifi_channels.h
@@ -52,12 +52,15 @@
#define CH_MIN_2G_40M_CHANNEL 3u /* Min 40MHz center channel in 2G band */
#define CH_MAX_2G_40M_CHANNEL 11u /* Max 40MHz center channel in 2G band */
+#define CH_MIN_6G_CHANNEL 1u /* Min channel in 6G band */
+#define CH_MAX_6G_CHANNEL 233u /* Max channel in 6G band */
+
/* maximum # channels the s/w supports */
-#define MAXCHANNEL 224 /* max # supported channels. The max channel no is above,
- * this is that + 1 rounded up to a multiple of NBBY (8).
+#define MAXCHANNEL 240 /* max # supported channels. The max channel no is 233,
+ * this is that + 7 rounded up to a multiple of NBBY (8).
* DO NOT MAKE it > 255: channels are uint8's all over
*/
-#define MAXCHANNEL_NUM (MAXCHANNEL - 1) /* max channel number */
+#define MAXCHANNEL_NUM (MAXCHANNEL - 7) /* max channel number */
#define INVCHANNEL 255 /* error value for a bad channel */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd.h
old mode 100644
new mode 100755
index cf3d66f..f426c42
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd.h
@@ -41,6 +41,7 @@
#undef CONFIG_PM_WAKELOCKS
+
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd.h.bak b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd.h.bak
new file mode 100755
index 0000000..d3c4dd6
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd.h.bak
@@ -0,0 +1,3491 @@
+/*
+ * Header file describing the internal (inter-module) DHD interfaces.
+ *
+ * Provides type definitions and function prototypes used to link the
+ * DHD OS, bus, and protocol modules.
+ *
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
+ *
+ * Copyright (C) 1999-2017, Broadcom Corporation
+ *
+ * Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed to you
+ * under the terms of the GNU General Public License version 2 (the "GPL"),
+ * available at http://www.broadcom.com/licenses/GPLv2.php, with the
+ * following added to such license:
+ *
+ * As a special exception, the copyright holders of this software give you
+ * permission to link this software with independent modules, and to copy and
+ * distribute the resulting executable under terms of your choice, provided that
+ * you also meet, for each linked independent module, the terms and conditions of
+ * the license of that module. An independent module is a module which is not
+ * derived from this software. The special exception does not apply to any
+ * modifications of the software.
+ *
+ * Notwithstanding the above, under no circumstances may you combine this
+ * software in any way with any other Broadcom software provided under a license
+ * other than the GPL, without Broadcom's express prior written consent.
+ *
+ *
+ * <<Broadcom-WL-IPTag/Open:>>
+ *
+ * $Id: dhd.h 701844 2017-05-26 18:56:40Z $
+ */
+
+/****************
+ * Common types *
+ */
+
+#ifndef _dhd_h_
+#define _dhd_h_
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/skbuff.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/random.h>
+#include <linux/spinlock.h>
+#include <linux/ethtool.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <asm/uaccess.h>
+#include <asm/unaligned.h>
+#if defined(CONFIG_PM_WAKELOCKS) || defined(CONFIG_HAS_WAKELOCK)
+//#include <linux/wakelock.h>
+#endif /* CONFIG_PM_WAKELOCKS || CONFIG_HAS_WAKELOCK */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
+#include <linux/sched/types.h>
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) */
+/* The kernel threading is sdio-specific */
+struct task_struct;
+struct sched_param;
+#if defined(BT_OVER_SDIO)
+#include <dhd_bt_interface.h>
+#endif /* defined (BT_OVER_SDIO) */
+int setScheduler(struct task_struct *p, int policy, struct sched_param *param);
+int get_scheduler_policy(struct task_struct *p);
+#define MAX_EVENT 16
+
+#define ALL_INTERFACES 0xff
+
+/* H2D and D2H ring dump is enabled by default */
+#ifdef PCIE_FULL_DONGLE
+#define DHD_DUMP_PCIE_RINGS
+#endif /* PCIE_FULL_DONGLE */
+
+#include <wlioctl.h>
+#include <bcmstdlib_s.h>
+#include <dhdioctl.h>
+#include <wlfc_proto.h>
+#include <hnd_armtrap.h>
+#if defined(DUMP_IOCTL_IOV_LIST) || defined(DHD_DEBUG)
+#include <bcmutils.h>
+#endif /* DUMP_IOCTL_IOV_LIST || DHD_DEBUG */
+
+#if defined(BCMWDF)
+#include <wdf.h>
+#include <WdfMiniport.h>
+#endif /* (BCMWDF) */
+
+#ifdef WL_CFGVENDOR_SEND_HANG_EVENT
+#include <rte_ioctl.h>
+#endif /* WL_CFGVENDOR_SEND_HANG_EVENT */
+
+#ifdef DHD_ERPOM
+#include <pom.h>
+#endif /* DHD_ERPOM */
+
+#include <dngl_stats.h>
+
+#ifdef DEBUG_DPC_THREAD_WATCHDOG
+#define MAX_RESCHED_CNT 600
+#endif /* DEBUG_DPC_THREAD_WATCHDOG */
+
+#if defined(KEEP_ALIVE)
+/* Default KEEP_ALIVE Period is 55 sec to prevent AP from sending Keep Alive probe frame */
+#define KEEP_ALIVE_PERIOD 55000
+#define NULL_PKT_STR "null_pkt"
+#endif /* KEEP_ALIVE */
+
+/* By default enabled from here, later the WQ code will be removed */
+#define DHD_USE_KTHREAD_FOR_LOGTRACE
+
+/*
+ * Earlier DHD used to have it own time stamp for printk and
+ * Dongle used to have its own time stamp for console messages
+ * With this flag, DHD and Dongle console messges will have same time zone
+ */
+#define DHD_H2D_LOG_TIME_SYNC
+/* Forward decls */
+struct dhd_bus;
+struct dhd_prot;
+struct dhd_info;
+struct dhd_ioctl;
+struct dhd_dbg;
+struct dhd_ts;
+#ifdef DNGL_AXI_ERROR_LOGGING
+struct dhd_axi_error_dump;
+#endif /* DNGL_AXI_ERROR_LOGGING */
+
+/* The level of bus communication with the dongle */
+enum dhd_bus_state {
+ DHD_BUS_DOWN, /* Not ready for frame transfers */
+ DHD_BUS_LOAD, /* Download access only (CPU reset) */
+ DHD_BUS_DATA, /* Ready for frame transfers */
+ DHD_BUS_SUSPEND, /* Bus has been suspended */
+ DHD_BUS_DOWN_IN_PROGRESS, /* Bus going Down */
+};
+
+/* The level of bus communication with the dongle */
+enum dhd_bus_devreset_type {
+ DHD_BUS_DEVRESET_ON = 0, /* ON */
+ DHD_BUS_DEVRESET_OFF = 1, /* OFF */
+ DHD_BUS_DEVRESET_FLR = 2, /* FLR */
+ DHD_BUS_DEVRESET_FLR_FORCE_FAIL = 3, /* FLR FORCE FAIL */
+ DHD_BUS_DEVRESET_QUIESCE = 4, /* FLR */
+};
+
+/*
+ * Bit fields to Indicate clean up process that wait till they are finished.
+ * Future synchronizable processes can add their bit filed below and update
+ * their functionalities accordingly
+ */
+#define DHD_BUS_BUSY_IN_TX 0x01
+#define DHD_BUS_BUSY_IN_SEND_PKT 0x02
+#define DHD_BUS_BUSY_IN_DPC 0x04
+#define DHD_BUS_BUSY_IN_WD 0x08
+#define DHD_BUS_BUSY_IN_IOVAR 0x10
+#define DHD_BUS_BUSY_IN_DHD_IOVAR 0x20
+#define DHD_BUS_BUSY_SUSPEND_IN_PROGRESS 0x40
+#define DHD_BUS_BUSY_RESUME_IN_PROGRESS 0x80
+#define DHD_BUS_BUSY_RPM_SUSPEND_IN_PROGRESS 0x100
+#define DHD_BUS_BUSY_RPM_SUSPEND_DONE 0x200
+#define DHD_BUS_BUSY_RPM_RESUME_IN_PROGRESS 0x400
+#define DHD_BUS_BUSY_RPM_ALL (DHD_BUS_BUSY_RPM_SUSPEND_DONE | \
+ DHD_BUS_BUSY_RPM_SUSPEND_IN_PROGRESS | \
+ DHD_BUS_BUSY_RPM_RESUME_IN_PROGRESS)
+#define DHD_BUS_BUSY_IN_CHECKDIED 0x800
+#define DHD_BUS_BUSY_IN_MEMDUMP 0x1000
+#define DHD_BUS_BUSY_IN_SSSRDUMP 0x2000
+#define DHD_BUS_BUSY_IN_LOGDUMP 0x4000
+#define DHD_BUS_BUSY_IN_HALDUMP 0x8000
+
+#define DHD_BUS_BUSY_SET_IN_TX(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_TX
+#define DHD_BUS_BUSY_SET_IN_SEND_PKT(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_SEND_PKT
+#define DHD_BUS_BUSY_SET_IN_DPC(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_DPC
+#define DHD_BUS_BUSY_SET_IN_WD(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_WD
+#define DHD_BUS_BUSY_SET_IN_IOVAR(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_IOVAR
+#define DHD_BUS_BUSY_SET_IN_DHD_IOVAR(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_DHD_IOVAR
+#define DHD_BUS_BUSY_SET_SUSPEND_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_SUSPEND_IN_PROGRESS
+#define DHD_BUS_BUSY_SET_RESUME_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_RESUME_IN_PROGRESS
+#define DHD_BUS_BUSY_SET_RPM_SUSPEND_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_RPM_SUSPEND_IN_PROGRESS
+#define DHD_BUS_BUSY_SET_RPM_SUSPEND_DONE(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_RPM_SUSPEND_DONE
+#define DHD_BUS_BUSY_SET_RPM_RESUME_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_RPM_RESUME_IN_PROGRESS
+#define DHD_BUS_BUSY_SET_IN_CHECKDIED(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_CHECKDIED
+#define DHD_BUS_BUSY_SET_IN_MEMDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_MEMDUMP
+#define DHD_BUS_BUSY_SET_IN_SSSRDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_SSSRDUMP
+#define DHD_BUS_BUSY_SET_IN_LOGDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_LOGDUMP
+#define DHD_BUS_BUSY_SET_IN_HALDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state |= DHD_BUS_BUSY_IN_HALDUMP
+
+#define DHD_BUS_BUSY_CLEAR_IN_TX(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_TX
+#define DHD_BUS_BUSY_CLEAR_IN_SEND_PKT(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_SEND_PKT
+#define DHD_BUS_BUSY_CLEAR_IN_DPC(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_DPC
+#define DHD_BUS_BUSY_CLEAR_IN_WD(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_WD
+#define DHD_BUS_BUSY_CLEAR_IN_IOVAR(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_IOVAR
+#define DHD_BUS_BUSY_CLEAR_IN_DHD_IOVAR(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_DHD_IOVAR
+#define DHD_BUS_BUSY_CLEAR_SUSPEND_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_SUSPEND_IN_PROGRESS
+#define DHD_BUS_BUSY_CLEAR_RESUME_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_RESUME_IN_PROGRESS
+#define DHD_BUS_BUSY_CLEAR_RPM_SUSPEND_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_RPM_SUSPEND_IN_PROGRESS
+#define DHD_BUS_BUSY_CLEAR_RPM_SUSPEND_DONE(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_RPM_SUSPEND_DONE
+#define DHD_BUS_BUSY_CLEAR_RPM_RESUME_IN_PROGRESS(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_RPM_RESUME_IN_PROGRESS
+#define DHD_BUS_BUSY_CLEAR_IN_CHECKDIED(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_CHECKDIED
+#define DHD_BUS_BUSY_CLEAR_IN_MEMDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_MEMDUMP
+#define DHD_BUS_BUSY_CLEAR_IN_SSSRDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_SSSRDUMP
+#define DHD_BUS_BUSY_CLEAR_IN_LOGDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_LOGDUMP
+#define DHD_BUS_BUSY_CLEAR_IN_HALDUMP(dhdp) \
+ (dhdp)->dhd_bus_busy_state &= ~DHD_BUS_BUSY_IN_HALDUMP
+
+#define DHD_BUS_BUSY_CHECK_IN_TX(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_TX)
+#define DHD_BUS_BUSY_CHECK_IN_SEND_PKT(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_SEND_PKT)
+#define DHD_BUS_BUSY_CHECK_IN_DPC(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_DPC)
+#define DHD_BUS_BUSY_CHECK_IN_WD(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_WD)
+#define DHD_BUS_BUSY_CHECK_IN_IOVAR(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_IOVAR)
+#define DHD_BUS_BUSY_CHECK_IN_DHD_IOVAR(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_DHD_IOVAR)
+#define DHD_BUS_BUSY_CHECK_SUSPEND_IN_PROGRESS(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_SUSPEND_IN_PROGRESS)
+#define DHD_BUS_BUSY_CHECK_RESUME_IN_PROGRESS(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_RESUME_IN_PROGRESS)
+#define DHD_BUS_BUSY_CHECK_RPM_SUSPEND_IN_PROGRESS(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_RPM_SUSPEND_IN_PROGRESS)
+#define DHD_BUS_BUSY_CHECK_RPM_SUSPEND_DONE(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_RPM_SUSPEND_DONE)
+#define DHD_BUS_BUSY_CHECK_RPM_RESUME_IN_PROGRESS(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_RPM_RESUME_IN_PROGRESS)
+#define DHD_BUS_BUSY_CHECK_RPM_ALL(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_RPM_ALL)
+#define DHD_BUS_BUSY_CHECK_IN_CHECKDIED(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_CHECKDIED)
+#define DHD_BUS_BUSY_CHECK_IN_MEMDUMP(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_MEMDUMP)
+#define DHD_BUS_BUSY_CHECK_IN_SSSRDUMP(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_SSSRDUMP)
+#define DHD_BUS_BUSY_CHECK_IN_LOGDUMP(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_LOGDUMP)
+#define DHD_BUS_BUSY_CHECK_IN_HALDUMP(dhdp) \
+ ((dhdp)->dhd_bus_busy_state & DHD_BUS_BUSY_IN_HALDUMP)
+#define DHD_BUS_BUSY_CHECK_IDLE(dhdp) \
+ ((dhdp)->dhd_bus_busy_state == 0)
+
+#define DHD_BUS_CHECK_SUSPEND_OR_SUSPEND_IN_PROGRESS(dhdp) \
+ ((dhdp)->busstate == DHD_BUS_SUSPEND || DHD_BUS_BUSY_CHECK_SUSPEND_IN_PROGRESS(dhdp))
+
+#define DHD_BUS_CHECK_ANY_SUSPEND_IN_PROGRESS(dhdp) \
+ (DHD_BUS_BUSY_CHECK_SUSPEND_IN_PROGRESS(dhdp) || \
+ DHD_BUS_BUSY_CHECK_RPM_SUSPEND_IN_PROGRESS(dhdp))
+
+#define DHD_BUS_CHECK_SUSPEND_OR_ANY_SUSPEND_IN_PROGRESS(dhdp) \
+ ((dhdp)->busstate == DHD_BUS_SUSPEND || DHD_BUS_CHECK_ANY_SUSPEND_IN_PROGRESS(dhdp))
+
+#define DHD_BUS_CHECK_DOWN_OR_DOWN_IN_PROGRESS(dhdp) \
+ ((dhdp)->busstate == DHD_BUS_DOWN || (dhdp)->busstate == DHD_BUS_DOWN_IN_PROGRESS)
+
+/* IOVar flags for common error checks */
+#define DHD_IOVF_PWRREQ_BYPASS (1<<0) /* flags to prevent bp access during host sleep state */
+
+#define MAX_MTU_SZ (1600u)
+
+/* (u64)result = (u64)dividend / (u64)divisor */
+#define DIV_U64_BY_U64(dividend, divisor) div64_u64(dividend, divisor)
+
+/* (u64)result = (u64)dividend / (u32)divisor */
+#define DIV_U64_BY_U32(dividend, divisor) div_u64(dividend, divisor)
+
+/* Be careful while using this, as it divides dividend also
+ * (u32)remainder = (u64)dividend % (u32)divisor
+ * (u64)dividend = (u64)dividend / (u32)divisor
+ */
+#define DIV_AND_MOD_U64_BY_U32(dividend, divisor) do_div(dividend, divisor)
+
+/* (u32)remainder = (u64)dividend % (u32)divisor */
+#define MOD_U64_BY_U32(dividend, divisor) ({ \
+ uint64 temp_dividend = (dividend); \
+ uint32 rem = DIV_AND_MOD_U64_BY_U32(temp_dividend, (divisor)); \
+ rem; \
+})
+
+#define SEC_USEC_FMT \
+ "%5llu.%06u"
+
+/* t: time in nano second */
+#define GET_SEC_USEC(t) \
+ DIV_U64_BY_U32(t, NSEC_PER_SEC), \
+ ((uint32)(MOD_U64_BY_U32(t, NSEC_PER_SEC) / (uint32)NSEC_PER_USEC))
+
+/* Download Types */
+typedef enum download_type {
+ FW,
+ NVRAM,
+ CLM_BLOB,
+ TXCAP_BLOB
+} download_type_t;
+
+/* For supporting multiple interfaces */
+#define DHD_MAX_IFS 16
+#define DHD_MAX_STATIC_IFS 5
+#define DHD_DEL_IF -0xE
+#define DHD_BAD_IF -0xF
+#define DHD_DUMMY_INFO_IF 0xDEAF /* Hack i/f to handle events from INFO Ring */
+#define DHD_EVENT_IF DHD_DUMMY_INFO_IF
+
+enum dhd_op_flags {
+/* Firmware requested operation mode */
+ DHD_FLAG_STA_MODE = (1 << (0)), /* STA only */
+ DHD_FLAG_HOSTAP_MODE = (1 << (1)), /* SOFTAP only */
+ DHD_FLAG_P2P_MODE = (1 << (2)), /* P2P Only */
+ /* STA + P2P */
+ DHD_FLAG_CONCURR_SINGLE_CHAN_MODE = (DHD_FLAG_STA_MODE | DHD_FLAG_P2P_MODE),
+ /* STA + SoftAP */
+ DHD_FLAG_CONCURR_STA_HOSTAP_MODE = (DHD_FLAG_STA_MODE | DHD_FLAG_HOSTAP_MODE),
+ DHD_FLAG_CONCURR_MULTI_CHAN_MODE = (1 << (4)), /* STA + P2P */
+ /* Current P2P mode for P2P connection */
+ DHD_FLAG_P2P_GC_MODE = (1 << (5)),
+ DHD_FLAG_P2P_GO_MODE = (1 << (6)),
+ DHD_FLAG_MBSS_MODE = (1 << (7)), /* MBSS in future */
+ DHD_FLAG_IBSS_MODE = (1 << (8)),
+ DHD_FLAG_MFG_MODE = (1 << (9)),
+ DHD_FLAG_RSDB_MODE = (1 << (10)),
+ DHD_FLAG_MP2P_MODE = (1 << (11))
+};
+
+#define DHD_OPMODE_SUPPORTED(dhd, opmode_flag) \
+ (dhd ? ((((dhd_pub_t *)dhd)->op_mode) & opmode_flag) : -1)
+#define DHD_OPMODE_STA_SOFTAP_CONCURR(dhd) \
+ (dhd ? (((dhd->op_mode) & DHD_FLAG_CONCURR_STA_HOSTAP_MODE) == \
+ DHD_FLAG_CONCURR_STA_HOSTAP_MODE) : 0)
+
+/* Max sequential TX/RX Control timeouts to set HANG event */
+#ifndef MAX_CNTL_TX_TIMEOUT
+#define MAX_CNTL_TX_TIMEOUT 2
+#endif /* MAX_CNTL_TX_TIMEOUT */
+#ifndef MAX_CNTL_RX_TIMEOUT
+#define MAX_CNTL_RX_TIMEOUT 1
+#endif /* MAX_CNTL_RX_TIMEOUT */
+
+#define DHD_SCAN_ASSOC_ACTIVE_TIME 40 /* ms: Embedded default Active setting from DHD */
+#define DHD_SCAN_UNASSOC_ACTIVE_TIME 80 /* ms: Embedded def. Unassoc Active setting from DHD */
+#define DHD_SCAN_HOME_TIME 45 /* ms: Embedded default Home time setting from DHD */
+#define DHD_SCAN_HOME_AWAY_TIME 100 /* ms: Embedded default Home Away time setting from DHD */
+#ifndef CUSTOM_SCAN_PASSIVE_TIME
+#define DHD_SCAN_PASSIVE_TIME 130 /* ms: Embedded default Passive setting from DHD */
+#else
+#define DHD_SCAN_PASSIVE_TIME CUSTOM_SCAN_PASSIVE_TIME /* ms: Custom Passive setting from DHD */
+#endif /* CUSTOM_SCAN_PASSIVE_TIME */
+
+#ifndef POWERUP_MAX_RETRY
+#define POWERUP_MAX_RETRY 3 /* how many times we retry to power up the chip */
+#endif // endif
+#ifndef POWERUP_WAIT_MS
+#define POWERUP_WAIT_MS 2000 /* ms: time out in waiting wifi to come up */
+#endif // endif
+/*
+ * MAX_NVRAMBUF_SIZE determines the size of the Buffer in the DHD that holds
+ * the NVRAM data. That is the size of the buffer pointed by bus->vars
+ * This also needs to be increased to 16K to support NVRAM size higher than 8K
+ */
+#define MAX_NVRAMBUF_SIZE (16 * 1024) /* max nvram buf size */
+#define MAX_CLM_BUF_SIZE (48 * 1024) /* max clm blob size */
+#define MAX_TXCAP_BUF_SIZE (16 * 1024) /* max txcap blob size */
+#ifdef DHD_DEBUG
+#define DHD_JOIN_MAX_TIME_DEFAULT 10000 /* ms: Max time out for joining AP */
+#define DHD_SCAN_DEF_TIMEOUT 10000 /* ms: Max time out for scan in progress */
+#endif /* DHD_DEBUG */
+
+#ifndef CONFIG_BCMDHD_CLM_PATH
+#ifdef OEM_ANDROID
+#define CONFIG_BCMDHD_CLM_PATH "/etc/wifi/bcmdhd_clm.blob"
+#else
+#define CONFIG_BCMDHD_CLM_PATH "/var/run/bcmdhd_clm.blob"
+#endif /* OEM_ANDROID */
+#endif /* CONFIG_BCMDHD_CLM_PATH */
+#define WL_CCODE_NULL_COUNTRY "#n"
+
+#define FW_VER_STR_LEN 128
+#define FWID_STR_LEN 256
+#define CLM_VER_STR_LEN 128
+#define BUS_API_REV_STR_LEN 128
+#define FW_VER_STR "Version"
+#define FWID_STR_1 "FWID: 01-"
+#define FWID_STR_2 "FWID=01-"
+extern char bus_api_revision[];
+
+enum dhd_bus_wake_state {
+ WAKE_LOCK_OFF = 0,
+ WAKE_LOCK_PRIV = 1,
+ WAKE_LOCK_DPC = 2,
+ WAKE_LOCK_IOCTL = 3,
+ WAKE_LOCK_DOWNLOAD = 4,
+ WAKE_LOCK_TMOUT = 5,
+ WAKE_LOCK_WATCHDOG = 6,
+ WAKE_LOCK_LINK_DOWN_TMOUT = 7,
+ WAKE_LOCK_PNO_FIND_TMOUT = 8,
+ WAKE_LOCK_SOFTAP_SET = 9,
+ WAKE_LOCK_SOFTAP_STOP = 10,
+ WAKE_LOCK_SOFTAP_START = 11,
+ WAKE_LOCK_SOFTAP_THREAD = 12
+};
+
+enum dhd_prealloc_index {
+ DHD_PREALLOC_PROT = 0,
+ DHD_PREALLOC_RXBUF = 1,
+ DHD_PREALLOC_DATABUF = 2,
+ DHD_PREALLOC_OSL_BUF = 3,
+ /* 4 */
+ DHD_PREALLOC_WIPHY_ESCAN0 = 5,
+ DHD_PREALLOC_WIPHY_ESCAN1 = 6,
+ DHD_PREALLOC_DHD_INFO = 7,
+ DHD_PREALLOC_DHD_WLFC_INFO = 8,
+ DHD_PREALLOC_IF_FLOW_LKUP = 9,
+ /* 10 */
+ DHD_PREALLOC_MEMDUMP_RAM = 11,
+ DHD_PREALLOC_DHD_WLFC_HANGER = 12,
+ DHD_PREALLOC_PKTID_MAP = 13,
+ DHD_PREALLOC_PKTID_MAP_IOCTL = 14,
+ DHD_PREALLOC_DHD_LOG_DUMP_BUF = 15,
+ DHD_PREALLOC_DHD_LOG_DUMP_BUF_EX = 16,
+ DHD_PREALLOC_DHD_PKTLOG_DUMP_BUF = 17
+};
+
+enum dhd_dongledump_mode {
+ DUMP_DISABLED = 0,
+ DUMP_MEMONLY = 1,
+ DUMP_MEMFILE = 2,
+ DUMP_MEMFILE_BUGON = 3,
+ DUMP_MEMFILE_MAX = 4
+};
+
+enum dhd_dongledump_type {
+ DUMP_TYPE_RESUMED_ON_TIMEOUT = 1,
+ DUMP_TYPE_D3_ACK_TIMEOUT = 2,
+ DUMP_TYPE_DONGLE_TRAP = 3,
+ DUMP_TYPE_MEMORY_CORRUPTION = 4,
+ DUMP_TYPE_PKTID_AUDIT_FAILURE = 5,
+ DUMP_TYPE_PKTID_INVALID = 6,
+ DUMP_TYPE_SCAN_TIMEOUT = 7,
+ DUMP_TYPE_SCAN_BUSY = 8,
+ DUMP_TYPE_BY_SYSDUMP = 9,
+ DUMP_TYPE_BY_LIVELOCK = 10,
+ DUMP_TYPE_AP_LINKUP_FAILURE = 11,
+ DUMP_TYPE_AP_ABNORMAL_ACCESS = 12,
+ DUMP_TYPE_CFG_VENDOR_TRIGGERED = 13,
+ DUMP_TYPE_RESUMED_ON_TIMEOUT_TX = 14,
+ DUMP_TYPE_RESUMED_ON_TIMEOUT_RX = 15,
+ DUMP_TYPE_RESUMED_ON_INVALID_RING_RDWR = 16,
+ DUMP_TYPE_TRANS_ID_MISMATCH = 17,
+ DUMP_TYPE_IFACE_OP_FAILURE = 18,
+ DUMP_TYPE_DONGLE_INIT_FAILURE = 19,
+ DUMP_TYPE_READ_SHM_FAIL = 20,
+ DUMP_TYPE_DONGLE_HOST_EVENT = 21,
+ DUMP_TYPE_SMMU_FAULT = 22,
+ DUMP_TYPE_RESUMED_UNKNOWN = 23,
+ DUMP_TYPE_DUE_TO_BT = 24,
+ DUMP_TYPE_LOGSET_BEYOND_RANGE = 25,
+ DUMP_TYPE_BY_USER = 26,
+ DUMP_TYPE_CTO_RECOVERY = 27,
+ DUMP_TYPE_SEQUENTIAL_PRIVCMD_ERROR = 28,
+ DUMP_TYPE_PROXD_TIMEOUT = 29,
+ DUMP_TYPE_PKTID_POOL_DEPLETED = 30
+};
+
+enum dhd_hang_reason {
+ HANG_REASON_MASK = 0x8000,
+ HANG_REASON_IOCTL_RESP_TIMEOUT = 0x8001,
+ HANG_REASON_DONGLE_TRAP = 0x8002,
+ HANG_REASON_D3_ACK_TIMEOUT = 0x8003,
+ HANG_REASON_BUS_DOWN = 0x8004,
+ HANG_REASON_MSGBUF_LIVELOCK = 0x8006,
+ HANG_REASON_IFACE_DEL_FAILURE = 0x8007,
+ HANG_REASON_HT_AVAIL_ERROR = 0x8008,
+ HANG_REASON_PCIE_RC_LINK_UP_FAIL = 0x8009,
+ HANG_REASON_PCIE_PKTID_ERROR = 0x800A,
+ HANG_REASON_IFACE_ADD_FAILURE = 0x800B,
+ HANG_REASON_IOCTL_RESP_TIMEOUT_SCHED_ERROR = 0x800C,
+ HANG_REASON_D3_ACK_TIMEOUT_SCHED_ERROR = 0x800D,
+ HANG_REASON_SEQUENTIAL_PRIVCMD_ERROR = 0x800E,
+ HANG_REASON_PCIE_LINK_DOWN_RC_DETECT = 0x8805,
+ HANG_REASON_INVALID_EVENT_OR_DATA = 0x8806,
+ HANG_REASON_UNKNOWN = 0x8807,
+ HANG_REASON_PCIE_LINK_DOWN_EP_DETECT = 0x8808,
+ HANG_REASON_PCIE_CTO_DETECT = 0x8809,
+ HANG_REASON_MAX = 0x880A
+};
+
+#define WLC_E_DEAUTH_MAX_REASON 0x0FFF
+
+enum dhd_rsdb_scan_features {
+ /* Downgraded scan feature for AP active */
+ RSDB_SCAN_DOWNGRADED_AP_SCAN = 0x01,
+ /* Downgraded scan feature for P2P Discovery */
+ RSDB_SCAN_DOWNGRADED_P2P_DISC_SCAN = 0x02,
+ /* Enable channel pruning for ROAM SCAN */
+ RSDB_SCAN_DOWNGRADED_CH_PRUNE_ROAM = 0x10,
+ /* Enable channel pruning for any SCAN */
+ RSDB_SCAN_DOWNGRADED_CH_PRUNE_ALL = 0x20
+};
+
+#define VENDOR_SEND_HANG_EXT_INFO_LEN (800 + 1)
+
+#ifdef DHD_EWPR_VER2
+#define VENDOR_SEND_HANG_EXT_INFO_VER 20181111
+#else
+#define VENDOR_SEND_HANG_EXT_INFO_VER 20170905
+#endif // endif
+
+#define HANG_INFO_TRAP_T_NAME_MAX 6
+#define HANG_INFO_TRAP_T_REASON_IDX 0
+#define HANG_INFO_TRAP_T_SUBTYPE_IDX 2
+#define HANG_INFO_TRAP_T_OFFSET_IDX 3
+#define HANG_INFO_TRAP_T_EPC_IDX 4
+#define HANG_FIELD_STR_MAX_LEN 9
+#define HANG_FIELD_CNT_MAX 69
+#define HANG_FIELD_IF_FAILURE_CNT 10
+#define HANG_FIELD_IOCTL_RESP_TIMEOUT_CNT 8
+#define HANG_FIELD_TRAP_T_STACK_CNT_MAX 16
+#define HANG_FIELD_MISMATCH_CNT 10
+#define HANG_INFO_BIGDATA_KEY_STACK_CNT 4
+
+#define DEBUG_DUMP_TIME_BUF_LEN (16 + 1)
+/* delimiter between values */
+#define HANG_KEY_DEL ' '
+#define HANG_RAW_DEL '_'
+
+#ifdef DHD_EWPR_VER2
+#define HANG_INFO_BIGDATA_EXTRA_KEY 4
+#define HANG_INFO_TRAP_T_EXTRA_KEY_IDX 5
+#endif // endif
+
+/* Packet alignment for most efficient SDIO (can change based on platform) */
+#ifndef DHD_SDALIGN
+#if defined(BCMSPI)
+#define DHD_SDALIGN 4
+#else
+#define DHD_SDALIGN 32
+#endif /* BCMSPI */
+#endif /* !DHD_SDALIGN */
+
+#define DHD_TX_CONTEXT_MASK 0xff
+#define DHD_TX_START_XMIT 0x01
+#define DHD_TX_SEND_PKT 0x02
+#define DHD_IF_SET_TX_ACTIVE(ifp, context) \
+ ifp->tx_paths_active |= context;
+#define DHD_IF_CLR_TX_ACTIVE(ifp, context) \
+ ifp->tx_paths_active &= ~context;
+#define DHD_IF_IS_TX_ACTIVE(ifp) \
+ (ifp->tx_paths_active)
+/**
+ * DMA-able buffer parameters
+ * - dmaaddr_t is 32bits on a 32bit host.
+ * dhd_dma_buf::pa may not be used as a sh_addr_t, bcm_addr64_t or uintptr
+ * - dhd_dma_buf::_alloced is ONLY for freeing a DMA-able buffer.
+ */
+typedef struct dhd_dma_buf {
+ void *va; /* virtual address of buffer */
+ uint32 len; /* user requested buffer length */
+ dmaaddr_t pa; /* physical address of buffer */
+ void *dmah; /* dma mapper handle */
+ void *secdma; /* secure dma sec_cma_info handle */
+ uint32 _alloced; /* actual size of buffer allocated with align and pad */
+} dhd_dma_buf_t;
+
+/* host reordering packts logic */
+/* followed the structure to hold the reorder buffers (void **p) */
+typedef struct reorder_info {
+ void **p;
+ uint8 flow_id;
+ uint8 cur_idx;
+ uint8 exp_idx;
+ uint8 max_idx;
+ uint8 pend_pkts;
+} reorder_info_t;
+
+/* throughput test packet format */
+typedef struct tput_pkt {
+ /* header */
+ uint8 mac_sta[ETHER_ADDR_LEN];
+ uint8 mac_ap[ETHER_ADDR_LEN];
+ uint16 pkt_type;
+ uint8 PAD[2];
+ /* data */
+ uint32 crc32;
+ uint32 pkt_id;
+ uint32 num_pkts;
+} tput_pkt_t;
+
+typedef enum {
+ TPUT_PKT_TYPE_NORMAL,
+ TPUT_PKT_TYPE_STOP
+} tput_pkt_type_t;
+
+#define TPUT_TEST_MAX_PAYLOAD 1500
+#define TPUT_TEST_WAIT_TIMEOUT_DEFAULT 5000
+
+#ifdef DHDTCPACK_SUPPRESS
+
+enum {
+ /* TCPACK suppress off */
+ TCPACK_SUP_OFF,
+ /* Replace TCPACK in txq when new coming one has higher ACK number. */
+ TCPACK_SUP_REPLACE,
+ /* TCPACK_SUP_REPLACE + delayed TCPACK TX unless ACK to PSH DATA.
+ * This will give benefits to Half-Duplex bus interface(e.g. SDIO) that
+ * 1. we are able to read TCP DATA packets first from the bus
+ * 2. TCPACKs that don't need to hurry delivered remains longer in TXQ so can be suppressed.
+ */
+ TCPACK_SUP_DELAYTX,
+ TCPACK_SUP_HOLD,
+ TCPACK_SUP_LAST_MODE
+};
+#endif /* DHDTCPACK_SUPPRESS */
+
+#define DHD_NULL_CHK_AND_RET(cond) \
+ if (!cond) { \
+ DHD_ERROR(("%s " #cond " is NULL\n", __FUNCTION__)); \
+ return; \
+ }
+
+#define DHD_NULL_CHK_AND_RET_VAL(cond, value) \
+ if (!cond) { \
+ DHD_ERROR(("%s " #cond " is NULL\n", __FUNCTION__)); \
+ return value; \
+ }
+
+#define DHD_NULL_CHK_AND_GOTO(cond, label) \
+ if (!cond) { \
+ DHD_ERROR(("%s " #cond " is NULL\n", __FUNCTION__)); \
+ goto label; \
+ }
+
+/*
+ * Accumulating the queue lengths of all flowring queues in a parent object,
+ * to assert flow control, when the cummulative queue length crosses an upper
+ * threshold defined on a parent object. Upper threshold may be maintained
+ * at a station level, at an interface level, or at a dhd instance.
+ *
+ * cumm_ctr_t abstraction:
+ * cumm_ctr_t abstraction may be enhanced to use an object with a hysterisis
+ * pause on/off threshold callback.
+ * All macros use the address of the cummulative length in the parent objects.
+ *
+ * BCM_GMAC3 builds use a single perimeter lock, as opposed to a per queue lock.
+ * Cummulative counters in parent objects may be updated without spinlocks.
+ *
+ * In non BCM_GMAC3, if a cummulative queue length is desired across all flows
+ * belonging to either of (a station, or an interface or a dhd instance), then
+ * an atomic operation is required using an atomic_t cummulative counters or
+ * using a spinlock. BCM_ROUTER_DHD uses the Linux atomic_t construct.
+ */
+
+/* Cummulative length not supported. */
+typedef uint32 cumm_ctr_t;
+#define DHD_CUMM_CTR_PTR(clen) ((cumm_ctr_t*)(clen))
+#define DHD_CUMM_CTR(clen) *(DHD_CUMM_CTR_PTR(clen)) /* accessor */
+#define DHD_CUMM_CTR_READ(clen) DHD_CUMM_CTR(clen) /* read access */
+#define DHD_CUMM_CTR_INIT(clen) \
+ ASSERT(DHD_CUMM_CTR_PTR(clen) != DHD_CUMM_CTR_PTR(NULL));
+#define DHD_CUMM_CTR_INCR(clen) \
+ ASSERT(DHD_CUMM_CTR_PTR(clen) != DHD_CUMM_CTR_PTR(NULL));
+#define DHD_CUMM_CTR_DECR(clen) \
+ ASSERT(DHD_CUMM_CTR_PTR(clen) != DHD_CUMM_CTR_PTR(NULL));
+
+#if defined(WLTDLS) && defined(PCIE_FULL_DONGLE)
+struct tdls_peer_node {
+ uint8 addr[ETHER_ADDR_LEN];
+ struct tdls_peer_node *next;
+};
+typedef struct tdls_peer_node tdls_peer_node_t;
+typedef struct {
+ tdls_peer_node_t *node;
+ uint8 tdls_peer_count;
+} tdls_peer_tbl_t;
+#endif /* defined(WLTDLS) && defined(PCIE_FULL_DONGLE) */
+
+#ifdef DHD_LOG_DUMP
+#define DUMP_SSSR_ATTR_START 2
+#define DUMP_SSSR_ATTR_COUNT 6
+
+typedef enum {
+ SSSR_C0_D11_BEFORE = 0,
+ SSSR_C0_D11_AFTER = 1,
+ SSSR_C1_D11_BEFORE = 2,
+ SSSR_C1_D11_AFTER = 3,
+ SSSR_DIG_BEFORE = 4,
+ SSSR_DIG_AFTER = 5
+} EWP_SSSR_DUMP;
+
+typedef enum {
+ DLD_BUF_TYPE_GENERAL = 0,
+ DLD_BUF_TYPE_PRESERVE = 1,
+ DLD_BUF_TYPE_SPECIAL = 2,
+ DLD_BUF_TYPE_ECNTRS = 3,
+ DLD_BUF_TYPE_FILTER = 4,
+ DLD_BUF_TYPE_ALL = 5
+} log_dump_type_t;
+
+#define LOG_DUMP_MAGIC 0xDEB3DEB3
+#define HEALTH_CHK_BUF_SIZE 256
+
+#ifdef EWP_ECNTRS_LOGGING
+#define ECNTR_RING_ID 0xECDB
+#define ECNTR_RING_NAME "ewp_ecntr_ring"
+#endif /* EWP_ECNTRS_LOGGING */
+
+#ifdef EWP_RTT_LOGGING
+#define RTT_RING_ID 0xADCD
+#define RTT_RING_NAME "ewp_rtt_ring"
+#endif /* EWP_ECNTRS_LOGGING */
+
+#if defined(DEBUGABILITY) && defined(EWP_ECNTRS_LOGGING)
+#error "Duplicate rings will be created since both the features are enabled"
+#endif /* DEBUGABILITY && EWP_ECNTRS_LOGGING */
+
+typedef enum {
+ LOG_DUMP_SECTION_GENERAL = 0,
+ LOG_DUMP_SECTION_ECNTRS,
+ LOG_DUMP_SECTION_SPECIAL,
+ LOG_DUMP_SECTION_DHD_DUMP,
+ LOG_DUMP_SECTION_EXT_TRAP,
+ LOG_DUMP_SECTION_HEALTH_CHK,
+ LOG_DUMP_SECTION_PRESERVE,
+ LOG_DUMP_SECTION_COOKIE,
+ LOG_DUMP_SECTION_FLOWRING,
+ LOG_DUMP_SECTION_STATUS,
+ LOG_DUMP_SECTION_RTT
+} log_dump_section_type_t;
+
+/* Each section in the debug_dump log file shall begin with a header */
+typedef struct {
+ uint32 magic; /* 0xDEB3DEB3 */
+ uint32 type; /* of type log_dump_section_type_t */
+ uint64 timestamp;
+ uint32 length; /* length of the section that follows */
+ uint32 pad;
+} log_dump_section_hdr_t;
+
+/* below structure describe ring buffer. */
+struct dhd_log_dump_buf
+{
+ spinlock_t lock;
+ void *dhd_pub;
+ unsigned int enable;
+ unsigned int wraparound;
+ unsigned long max;
+ unsigned int remain;
+ char* present;
+ char* front;
+ char* buffer;
+};
+
+#define DHD_LOG_DUMP_MAX_TEMP_BUFFER_SIZE 256
+#define DHD_LOG_DUMP_MAX_TAIL_FLUSH_SIZE (80 * 1024)
+
+extern void dhd_log_dump_write(int type, char *binary_data,
+ int binary_len, const char *fmt, ...);
+#endif /* DHD_LOG_DUMP */
+
+/* DEBUG_DUMP SUB COMMAND */
+enum {
+ CMD_DEFAULT,
+ CMD_UNWANTED,
+ CMD_DISCONNECTED,
+ CMD_MAX
+};
+
+#define DHD_LOG_DUMP_TS_MULTIPLIER_VALUE 60
+#define DHD_LOG_DUMP_TS_FMT_YYMMDDHHMMSSMSMS "%02d%02d%02d%02d%02d%02d%04d"
+#define DHD_DEBUG_DUMP_TYPE "debug_dump_FORUSER"
+#define DHD_DUMP_SUBSTR_UNWANTED "_unwanted"
+#define DHD_DUMP_SUBSTR_DISCONNECTED "_disconnected"
+
+#ifdef DNGL_AXI_ERROR_LOGGING
+#define DHD_DUMP_AXI_ERROR_FILENAME "axi_error"
+#define DHD_DUMP_HAL_FILENAME_SUFFIX "_hal"
+#endif /* DNGL_AXI_ERROR_LOGGING */
+
+extern void get_debug_dump_time(char *str);
+extern void clear_debug_dump_time(char *str);
+#if defined(WL_CFGVENDOR_SEND_HANG_EVENT) || defined(DHD_PKT_LOGGING)
+extern void copy_debug_dump_time(char *dest, char *src);
+#endif /* WL_CFGVENDOR_SEND_HANG_EVENT || DHD_PKT_LOGGING */
+
+#define FW_LOGSET_MASK_ALL 0xFF
+
+#ifdef WL_MONITOR
+#define MONPKT_EXTRA_LEN 48u
+#endif /* WL_MONITOR */
+
+#define DHDIF_FWDER(dhdif) FALSE
+
+#if defined(CUSTOMER_HW2) || defined(BOARD_HIKEY)
+#define DHD_COMMON_DUMP_PATH "/data/misc/wifi/"
+#elif defined(OEM_ANDROID) && (defined(BOARD_PANDA) || defined(__ARM_ARCH_7A__))
+#define DHD_COMMON_DUMP_PATH "/data/vendor/wifi/"
+#elif defined(OEM_ANDROID) /* For Brix Live Image */
+#define DHD_COMMON_DUMP_PATH "/installmedia/"
+#else /* Default */
+#define DHD_COMMON_DUMP_PATH "/root/"
+#endif // endif
+
+struct cntry_locales_custom {
+ char iso_abbrev[WLC_CNTRY_BUF_SZ]; /* ISO 3166-1 country abbreviation */
+ char custom_locale[WLC_CNTRY_BUF_SZ]; /* Custom firmware locale */
+ int32 custom_locale_rev; /* Custom local revisin default -1 */
+};
+
+int dhd_send_msg_to_daemon(struct sk_buff *skb, void *data, int size);
+
+#ifdef DMAMAP_STATS
+typedef struct dmamap_stats {
+ uint64 txdata;
+ uint64 txdata_sz;
+ uint64 rxdata;
+ uint64 rxdata_sz;
+ uint64 ioctl_rx;
+ uint64 ioctl_rx_sz;
+ uint64 event_rx;
+ uint64 event_rx_sz;
+ uint64 info_rx;
+ uint64 info_rx_sz;
+ uint64 tsbuf_rx;
+ uint64 tsbuf_rx_sz;
+} dma_stats_t;
+#endif /* DMAMAP_STATS */
+
+/* see wlfc_proto.h for tx status details */
+#define DHD_MAX_TX_STATUS_MSGS 9u
+
+#ifdef TX_STATUS_LATENCY_STATS
+typedef struct dhd_if_tx_status_latency {
+ /* total number of tx_status received on this interface */
+ uint64 num_tx_status;
+ /* cumulative tx_status latency for this interface */
+ uint64 cum_tx_status_latency;
+} dhd_if_tx_status_latency_t;
+#endif /* TX_STATUS_LATENCY_STATS */
+
+#if defined(SHOW_LOGTRACE) && defined(DHD_USE_KTHREAD_FOR_LOGTRACE)
+/* Timestamps to trace dhd_logtrace_thread() */
+struct dhd_logtrace_thr_ts {
+ uint64 entry_time;
+ uint64 sem_down_time;
+ uint64 flush_time;
+ uint64 unexpected_break_time;
+ uint64 complete_time;
+};
+#endif /* SHOW_LOGTRACE && DHD_USE_KTHREAD_FOR_LOGTRACE */
+
+/* Enable Reserve STA flowrings only for Android */
+#if defined(OEM_ANDROID)
+#define DHD_LIMIT_MULTI_CLIENT_FLOWRINGS
+#endif /* OEM_ANDROID */
+
+typedef enum dhd_induce_error_states
+{
+ DHD_INDUCE_ERROR_CLEAR = 0x0,
+ DHD_INDUCE_IOCTL_TIMEOUT = 0x1,
+ DHD_INDUCE_D3_ACK_TIMEOUT = 0x2,
+ DHD_INDUCE_LIVELOCK = 0x3,
+ DHD_INDUCE_DROP_OOB_IRQ = 0x4,
+ DHD_INDUCE_DROP_AXI_SIG = 0x5,
+ DHD_INDUCE_ERROR_MAX = 0x6
+} dhd_induce_error_states_t;
+
+#ifdef DHD_HP2P
+#define MAX_TX_HIST_BIN 16
+#define MAX_RX_HIST_BIN 10
+#define MAX_HP2P_FLOWS 16
+#define HP2P_PRIO 7
+#define HP2P_PKT_THRESH 48
+#define HP2P_TIME_THRESH 200
+#define HP2P_PKT_EXPIRY 40
+#define HP2P_TIME_SCALE 32
+
+typedef struct hp2p_info {
+ void *dhd_pub;
+ uint16 flowid;
+ bool hrtimer_init;
+ void *ring;
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(5, 1, 21))
+ struct tasklet_hrtimer timer;
+#else
+ struct hrtimer timer;
+#endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(5, 1, 21) */
+ uint64 num_pkt_limit;
+ uint64 num_timer_limit;
+ uint64 num_timer_start;
+ uint64 tx_t0[MAX_TX_HIST_BIN];
+ uint64 tx_t1[MAX_TX_HIST_BIN];
+ uint64 rx_t0[MAX_RX_HIST_BIN];
+} hp2p_info_t;
+#endif /* DHD_HP2P */
+
+typedef enum {
+ FW_UNLOADED = 0,
+ FW_DOWNLOAD_IN_PROGRESS = 1,
+ FW_DOWNLOAD_DONE = 2
+} fw_download_status_t;
+
+/**
+ * Common structure for module and instance linkage.
+ * Instantiated once per hardware (dongle) instance that this DHD manages.
+ */
+typedef struct dhd_pub {
+ /* Linkage ponters */
+ osl_t *osh; /* OSL handle */
+ struct dhd_bus *bus; /* Bus module handle */
+ struct dhd_prot *prot; /* Protocol module handle */
+ struct dhd_info *info; /* Info module handle */
+ struct dhd_dbg *dbg; /* Debugability module handle */
+#if defined(SHOW_LOGTRACE) && defined(DHD_USE_KTHREAD_FOR_LOGTRACE)
+ struct dhd_logtrace_thr_ts logtrace_thr_ts;
+#endif /* SHOW_LOGTRACE && DHD_USE_KTHREAD_FOR_LOGTRACE */
+
+ /* to NDIS developer, the structure dhd_common is redundant,
+ * please do NOT merge it back from other branches !!!
+ */
+
+ /* Internal dhd items */
+ bool up; /* Driver up/down (to OS) */
+#ifdef WL_CFG80211
+ spinlock_t up_lock; /* Synchronization with CFG80211 down */
+#endif /* WL_CFG80211 */
+ bool txoff; /* Transmit flow-controlled */
+ bool dongle_reset; /* TRUE = DEVRESET put dongle into reset */
+ enum dhd_bus_state busstate;
+ uint dhd_bus_busy_state; /* Bus busy state */
+ uint hdrlen; /* Total DHD header length (proto + bus) */
+ uint maxctl; /* Max size rxctl request from proto to bus */
+ uint rxsz; /* Rx buffer size bus module should use */
+ uint8 wme_dp; /* wme discard priority */
+#ifdef DNGL_AXI_ERROR_LOGGING
+ uint32 axierror_logbuf_addr;
+ bool axi_error;
+ struct dhd_axi_error_dump *axi_err_dump;
+#endif /* DNGL_AXI_ERROR_LOGGING */
+ /* Dongle media info */
+ bool iswl; /* Dongle-resident driver is wl */
+ ulong drv_version; /* Version of dongle-resident driver */
+ struct ether_addr mac; /* MAC address obtained from dongle */
+ dngl_stats_t dstats; /* Stats for dongle-based data */
+
+ /* Additional stats for the bus level */
+ ulong tx_packets; /* Data packets sent to dongle */
+ ulong tx_dropped; /* Data packets dropped in dhd */
+ ulong tx_multicast; /* Multicast data packets sent to dongle */
+ ulong tx_errors; /* Errors in sending data to dongle */
+ ulong tx_ctlpkts; /* Control packets sent to dongle */
+ ulong tx_ctlerrs; /* Errors sending control frames to dongle */
+ ulong rx_packets; /* Packets sent up the network interface */
+ ulong rx_multicast; /* Multicast packets sent up the network interface */
+ ulong rx_errors; /* Errors processing rx data packets */
+ ulong rx_ctlpkts; /* Control frames processed from dongle */
+ ulong rx_ctlerrs; /* Errors in processing rx control frames */
+ ulong rx_dropped; /* Packets dropped locally (no memory) */
+ ulong rx_flushed; /* Packets flushed due to unscheduled sendup thread */
+ ulong wd_dpc_sched; /* Number of times dhd dpc scheduled by watchdog timer */
+ ulong rx_pktgetfail; /* Number of PKTGET failures in DHD on RX */
+ ulong tx_pktgetfail; /* Number of PKTGET failures in DHD on TX */
+ ulong rx_readahead_cnt; /* Number of packets where header read-ahead was used. */
+ ulong tx_realloc; /* Number of tx packets we had to realloc for headroom */
+ ulong fc_packets; /* Number of flow control pkts recvd */
+ ulong tx_big_packets; /* Dropped data packets that are larger than MAX_MTU_SZ */
+#ifdef DMAMAP_STATS
+ /* DMA Mapping statistics */
+ dma_stats_t dma_stats;
+#endif /* DMAMAP_STATS */
+
+ /* Last error return */
+ int bcmerror;
+ uint tickcnt;
+
+ /* Last error from dongle */
+ int dongle_error;
+
+ uint8 country_code[WLC_CNTRY_BUF_SZ];
+
+ /* Suspend disable flag and "in suspend" flag */
+ int suspend_disable_flag; /* "1" to disable all extra powersaving during suspend */
+ int in_suspend; /* flag set to 1 when early suspend called */
+#ifdef PNO_SUPPORT
+ int pno_enable; /* pno status : "1" is pno enable */
+ int pno_suspend; /* pno suspend status : "1" is pno suspended */
+#endif /* PNO_SUPPORT */
+ /* DTIM skip value, default 0(or 1) means wake each DTIM
+ * 3 means skip 2 DTIMs and wake up 3rd DTIM(9th beacon when AP DTIM is 3)
+ */
+ int suspend_bcn_li_dtim; /* bcn_li_dtim value in suspend mode */
+#ifdef PKT_FILTER_SUPPORT
+ int early_suspended; /* Early suspend status */
+ int dhcp_in_progress; /* DHCP period */
+#endif // endif
+
+ /* Pkt filter defination */
+ char * pktfilter[100];
+ int pktfilter_count;
+
+ wl_country_t dhd_cspec; /* Current Locale info */
+#ifdef CUSTOM_COUNTRY_CODE
+ uint dhd_cflags;
+#endif /* CUSTOM_COUNTRY_CODE */
+#if defined(DHD_BLOB_EXISTENCE_CHECK)
+ bool is_blob; /* Checking for existance of Blob file */
+#endif /* DHD_BLOB_EXISTENCE_CHECK */
+ bool force_country_change;
+ char eventmask[WL_EVENTING_MASK_LEN];
+ int op_mode; /* STA, HostAPD, WFD, SoftAP */
+
+/* Set this to 1 to use a seperate interface (p2p0) for p2p operations.
+ * For ICS MR1 releases it should be disable to be compatable with ICS MR1 Framework
+ * see target dhd-cdc-sdmmc-panda-cfg80211-icsmr1-gpl-debug in Makefile
+ */
+/* #define WL_ENABLE_P2P_IF 1 */
+
+#if defined(OEM_ANDROID)
+ struct mutex wl_start_stop_lock; /* lock/unlock for Android start/stop */
+ struct mutex wl_softap_lock; /* lock/unlock for any SoftAP/STA settings */
+#endif /* defined(OEM_ANDROID) */
+
+#ifdef PROP_TXSTATUS
+ bool wlfc_enabled;
+ int wlfc_mode;
+ void* wlfc_state;
+ /*
+ Mode in which the dhd flow control shall operate. Must be set before
+ traffic starts to the device.
+ 0 - Do not do any proptxtstatus flow control
+ 1 - Use implied credit from a packet status
+ 2 - Use explicit credit
+ 3 - Only AMPDU hostreorder used. no wlfc.
+ */
+ uint8 proptxstatus_mode;
+ bool proptxstatus_txoff;
+ bool proptxstatus_module_ignore;
+ bool proptxstatus_credit_ignore;
+ bool proptxstatus_txstatus_ignore;
+
+ bool wlfc_rxpkt_chk;
+#ifdef LIMIT_BORROW
+ bool wlfc_borrow_allowed;
+#endif /* LIMIT_BORROW */
+ /*
+ * implement below functions in each platform if needed.
+ */
+ /* platform specific function whether to skip flow control */
+ bool (*skip_fc)(void * dhdp, uint8 ifx);
+ /* platform specific function for wlfc_enable and wlfc_deinit */
+ void (*plat_init)(void *dhd);
+ void (*plat_deinit)(void *dhd);
+#ifdef DHD_WLFC_THREAD
+ bool wlfc_thread_go;
+ struct task_struct* wlfc_thread;
+ wait_queue_head_t wlfc_wqhead;
+#endif /* DHD_WLFC_THREAD */
+#endif /* PROP_TXSTATUS */
+#ifdef PNO_SUPPORT
+ void *pno_state;
+#endif // endif
+#ifdef RTT_SUPPORT
+ void *rtt_state;
+#endif // endif
+#ifdef ROAM_AP_ENV_DETECTION
+ bool roam_env_detection;
+#endif // endif
+ bool dongle_isolation;
+ bool is_pcie_watchdog_reset;
+
+/* Begin - Variables to track Bus Errors */
+ bool dongle_trap_occured; /* flag for sending HANG event to upper layer */
+ bool iovar_timeout_occured; /* flag to indicate iovar resumed on timeout */
+ bool is_sched_error; /* flag to indicate timeout due to scheduling issue */
+#ifdef PCIE_FULL_DONGLE
+ bool d3ack_timeout_occured; /* flag to indicate d3ack resumed on timeout */
+ bool livelock_occured; /* flag to indicate livelock occured */
+ bool pktid_audit_failed; /* flag to indicate pktid audit failure */
+#endif /* PCIE_FULL_DONGLE */
+ bool iface_op_failed; /* flag to indicate interface operation failed */
+ bool scan_timeout_occurred; /* flag to indicate scan has timedout */
+ bool scan_busy_occurred; /* flag to indicate scan busy occurred */
+#ifdef BT_OVER_SDIO
+ bool is_bt_recovery_required;
+#endif // endif
+ bool smmu_fault_occurred; /* flag to indicate SMMU Fault */
+ /*
+ * Add any new variables to track Bus errors above
+ * this line. Also ensure that the variable is
+ * cleared from dhd_clear_bus_errors
+ */
+/* End - Variables to track Bus Errors */
+
+ int hang_was_sent;
+ int hang_was_pending;
+ int rxcnt_timeout; /* counter rxcnt timeout to send HANG */
+ int txcnt_timeout; /* counter txcnt timeout to send HANG */
+#ifdef BCMPCIE
+ int d3ackcnt_timeout; /* counter d3ack timeout to send HANG */
+#endif /* BCMPCIE */
+ bool hang_report; /* enable hang report by default */
+ uint16 hang_reason; /* reason codes for HANG event */
+#if defined(DHD_HANG_SEND_UP_TEST)
+ uint req_hang_type;
+#endif /* DHD_HANG_SEND_UP_TEST */
+#if defined(CONFIG_BCM_DETECT_CONSECUTIVE_HANG)
+ uint hang_counts;
+#endif /* CONFIG_BCM_DETECT_CONSECUTIVE_HANG */
+#ifdef WLTDLS
+ bool tdls_enable;
+#endif // endif
+ struct reorder_info *reorder_bufs[WLHOST_REORDERDATA_MAXFLOWS];
+ #define WLC_IOCTL_MAXBUF_FWCAP 1024
+ char fw_capabilities[WLC_IOCTL_MAXBUF_FWCAP];
+ #define MAXSKBPEND 1024
+ void *skbbuf[MAXSKBPEND];
+ uint32 store_idx;
+ uint32 sent_idx;
+#ifdef DHDTCPACK_SUPPRESS
+ uint8 tcpack_sup_mode; /* TCPACK suppress mode */
+ void *tcpack_sup_module; /* TCPACK suppress module */
+ uint32 tcpack_sup_ratio;
+ uint32 tcpack_sup_delay;
+#endif /* DHDTCPACK_SUPPRESS */
+#if defined(ARP_OFFLOAD_SUPPORT)
+ uint32 arp_version;
+#endif // endif
+#if defined(BCMSUP_4WAY_HANDSHAKE)
+ bool fw_4way_handshake; /* Whether firmware will to do the 4way handshake. */
+#endif // endif
+#ifdef DEBUG_DPC_THREAD_WATCHDOG
+ bool dhd_bug_on;
+#endif /* DEBUG_DPC_THREAD_WATCHDOG */
+#ifdef CUSTOM_SET_CPUCORE
+ struct task_struct * current_dpc;
+ struct task_struct * current_rxf;
+ int chan_isvht80;
+#endif /* CUSTOM_SET_CPUCORE */
+
+ void *sta_pool; /* pre-allocated pool of sta objects */
+ void *staid_allocator; /* allocator of sta indexes */
+#ifdef PCIE_FULL_DONGLE
+ bool flow_rings_inited; /* set this flag after initializing flow rings */
+#endif /* PCIE_FULL_DONGLE */
+ void *flowid_allocator; /* unique flowid allocator */
+ void *flow_ring_table; /* flow ring table, include prot and bus info */
+ void *if_flow_lkup; /* per interface flowid lkup hash table */
+ void *flowid_lock; /* per os lock for flowid info protection */
+ void *flowring_list_lock; /* per os lock for flowring list protection */
+ uint8 max_multi_client_flow_rings;
+ uint8 multi_client_flow_rings;
+ uint32 num_flow_rings;
+ cumm_ctr_t cumm_ctr; /* cumm queue length placeholder */
+ cumm_ctr_t l2cumm_ctr; /* level 2 cumm queue length placeholder */
+ uint32 d2h_sync_mode; /* D2H DMA completion sync mode */
+ uint8 flow_prio_map[NUMPRIO];
+ uint8 flow_prio_map_type;
+ char enable_log[MAX_EVENT];
+ bool dma_d2h_ring_upd_support;
+ bool dma_h2d_ring_upd_support;
+ bool dma_ring_upd_overwrite; /* host overwrites support setting */
+
+ bool hwa_enable;
+ uint hwa_inited;
+
+ bool idma_enable;
+ uint idma_inited;
+
+ bool ifrm_enable; /* implicit frm enable */
+ uint ifrm_inited; /* implicit frm init */
+
+ bool dar_enable; /* use DAR registers */
+ uint dar_inited;
+
+ bool fast_delete_ring_support; /* fast delete ring supported */
+
+#ifdef DHD_L2_FILTER
+ unsigned long l2_filter_cnt; /* for L2_FILTER ARP table timeout */
+#endif /* DHD_L2_FILTER */
+#ifdef DHD_SSSR_DUMP
+ bool sssr_inited;
+ bool sssr_dump_collected; /* Flag to indicate sssr dump is collected */
+ sssr_reg_info_v1_t sssr_reg_info;
+ uint8 *sssr_mempool;
+ uint *sssr_d11_before[MAX_NUM_D11CORES];
+ uint *sssr_d11_after[MAX_NUM_D11CORES];
+ bool sssr_d11_outofreset[MAX_NUM_D11CORES];
+ uint *sssr_dig_buf_before;
+ uint *sssr_dig_buf_after;
+ uint32 sssr_dump_mode;
+ bool collect_sssr; /* Flag to indicate SSSR dump is required */
+#endif /* DHD_SSSR_DUMP */
+ uint8 *soc_ram;
+ uint32 soc_ram_length;
+ uint32 memdump_type;
+#ifdef DHD_RND_DEBUG
+ uint8 *rnd_buf;
+ uint32 rnd_len;
+#endif /* DHD_RND_DEBUG */
+#ifdef DHD_FW_COREDUMP
+ uint32 memdump_enabled;
+#ifdef DHD_DEBUG_UART
+ bool memdump_success;
+#endif /* DHD_DEBUG_UART */
+#endif /* DHD_FW_COREDUMP */
+#ifdef PCIE_FULL_DONGLE
+#ifdef WLTDLS
+ tdls_peer_tbl_t peer_tbl;
+#endif /* WLTDLS */
+ uint8 tx_in_progress;
+#endif /* PCIE_FULL_DONGLE */
+#ifdef DHD_ULP
+ void *dhd_ulp;
+#endif // endif
+#ifdef WLTDLS
+ uint32 tdls_mode;
+#endif // endif
+#ifdef GSCAN_SUPPORT
+ bool lazy_roam_enable;
+#endif // endif
+#if defined(PKT_FILTER_SUPPORT) && defined(APF)
+ bool apf_set;
+#endif /* PKT_FILTER_SUPPORT && APF */
+ void *macdbg_info;
+#ifdef DHD_WET
+ void *wet_info;
+#endif // endif
+ bool h2d_phase_supported;
+ bool force_dongletrap_on_bad_h2d_phase;
+ uint32 dongle_trap_data;
+ fw_download_status_t fw_download_status;
+ trap_t last_trap_info; /* trap info from the last trap */
+ uint8 rand_mac_oui[DOT11_OUI_LEN];
+#ifdef DHD_LOSSLESS_ROAMING
+ uint8 dequeue_prec_map;
+ uint8 prio_8021x;
+#endif // endif
+#ifdef WL_NATOE
+ struct dhd_nfct_info *nfct;
+ spinlock_t nfct_lock;
+#endif /* WL_NATOE */
+ /* timesync link */
+ struct dhd_ts *ts;
+ bool d2h_hostrdy_supported;
+#ifdef DHD_PCIE_NATIVE_RUNTIMEPM
+ atomic_t block_bus;
+#endif /* DHD_PCIE_NATIVE_RUNTIMEPM */
+#if defined(DBG_PKT_MON) || defined(DHD_PKT_LOGGING)
+ bool d11_tx_status;
+#endif /* DBG_PKT_MON || DHD_PKT_LOGGING */
+ uint16 ndo_version; /* ND offload version supported */
+#ifdef NDO_CONFIG_SUPPORT
+ bool ndo_enable; /* ND offload feature enable */
+ bool ndo_host_ip_overflow; /* # of host ip addr exceed FW capacity */
+ uint32 ndo_max_host_ip; /* # of host ip addr supported by FW */
+#endif /* NDO_CONFIG_SUPPORT */
+#if defined(DHD_LOG_DUMP)
+ /* buffer to hold 'dhd dump' data before dumping to file */
+ uint8 *concise_dbg_buf;
+ uint64 last_file_posn;
+ int logdump_periodic_flush;
+ /* ecounter debug ring */
+#ifdef EWP_ECNTRS_LOGGING
+ void *ecntr_dbg_ring;
+#endif // endif
+#ifdef EWP_RTT_LOGGING
+ void *rtt_dbg_ring;
+#endif // endif
+#ifdef DNGL_EVENT_SUPPORT
+ uint8 health_chk_event_data[HEALTH_CHK_BUF_SIZE];
+#endif // endif
+ void *logdump_cookie;
+#endif /* DHD_LOG_DUMP */
+ uint32 dhd_console_ms; /** interval for polling the dongle for console (log) messages */
+ bool ext_trap_data_supported;
+ uint32 *extended_trap_data;
+#ifdef DUMP_IOCTL_IOV_LIST
+ /* dump iovar list */
+ dll_t dump_iovlist_head;
+ uint8 dump_iovlist_len;
+#endif /* DUMP_IOCTL_IOV_LIST */
+#ifdef CUSTOM_SET_ANTNPM
+ uint32 mimo_ant_set;
+#endif /* CUSTOM_SET_ANTNPM */
+#ifdef CUSTOM_SET_OCLOFF
+ bool ocl_off;
+#endif /* CUSTOM_SET_OCLOFF */
+#ifdef DHD_DEBUG
+ /* memwaste feature */
+ dll_t mw_list_head; /* memwaste list head */
+ uint32 mw_id; /* memwaste list unique id */
+#endif /* DHD_DEBUG */
+#ifdef WLTDLS
+ spinlock_t tdls_lock;
+#endif /* WLTDLS */
+ uint pcie_txs_metadata_enable;
+ uint wbtext_policy; /* wbtext policy of dongle */
+ bool wbtext_support; /* for product policy only */
+ bool max_dtim_enable; /* use MAX bcn_li_dtim value in suspend mode */
+ tput_test_t tput_data;
+ uint64 tput_start_ts;
+ uint64 tput_stop_ts;
+#ifdef WL_MONITOR
+ bool monitor_enable;
+#endif // endif
+#ifdef DHD_PKT_LOGGING
+ struct dhd_pktlog *pktlog;
+ char debug_dump_time_pktlog_str[DEBUG_DUMP_TIME_BUF_LEN];
+#endif /* DHD_PKT_LOGGING */
+ uint dhd_watchdog_ms_backup;
+ void *event_log_filter;
+#ifdef WL_CFGVENDOR_SEND_HANG_EVENT
+ char *hang_info;
+ int hang_info_cnt;
+ char debug_dump_time_hang_str[DEBUG_DUMP_TIME_BUF_LEN];
+#endif /* WL_CFGVENDOR_SEND_HANG_EVENT */
+ char debug_dump_time_str[DEBUG_DUMP_TIME_BUF_LEN];
+ uint32 logset_prsrv_mask;
+ bool wl_event_enabled;
+ bool logtrace_pkt_sendup;
+#ifdef DHD_DUMP_MNGR
+ struct _dhd_dump_file_manage *dump_file_manage;
+#endif /* DHD_DUMP_MNGR */
+ int debug_dump_subcmd;
+ uint64 debug_dump_time_sec;
+ bool hscb_enable;
+ wait_queue_head_t tx_completion_wait;
+ uint32 batch_tx_pkts_cmpl;
+ uint32 batch_tx_num_pkts;
+#ifdef DHD_ERPOM
+ bool enable_erpom;
+ pom_func_handler_t pom_wlan_handler;
+ int (*pom_func_register)(pom_func_handler_t *func);
+ int (*pom_func_deregister)(pom_func_handler_t *func);
+ int (*pom_toggle_reg_on)(uchar func_id, uchar reason);
+#endif /* DHD_ERPOM */
+#ifdef EWP_EDL
+ bool dongle_edl_support;
+ dhd_dma_buf_t edl_ring_mem;
+#endif /* EWP_EDL */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25))
+ struct mutex ndev_op_sync;
+#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)) */
+
+ bool debug_buf_dest_support;
+ uint32 debug_buf_dest_stat[DEBUG_BUF_DEST_MAX];
+#if defined(DHD_H2D_LOG_TIME_SYNC)
+#define DHD_H2D_LOG_TIME_STAMP_MATCH (10000) /* 10 Seconds */
+ /*
+ * Interval for updating the dongle console message time stamp with the Host (DHD)
+ * time stamp
+ */
+ uint32 dhd_rte_time_sync_ms;
+#endif /* DHD_H2D_LOG_TIME_SYNC */
+ int wlc_ver_major;
+ int wlc_ver_minor;
+#ifdef DHD_STATUS_LOGGING
+ void *statlog;
+#endif /* DHD_STATUS_LOGGING */
+#ifdef DHD_HP2P
+ bool hp2p_enable;
+ bool hp2p_infra_enable;
+ bool hp2p_capable;
+ bool hp2p_ts_capable;
+ uint16 pkt_thresh;
+ uint16 time_thresh;
+ uint16 pkt_expiry;
+ hp2p_info_t hp2p_info[MAX_HP2P_FLOWS];
+ bool hp2p_ring_active;
+#endif /* D2H_HP2P */
+#ifdef DHD_DB0TS
+ bool db0ts_capable;
+#endif /* DHD_DB0TS */
+ bool event_log_max_sets_queried;
+ uint32 event_log_max_sets;
+ uint16 dhd_induce_error;
+#ifdef CONFIG_SILENT_ROAM
+ bool sroam_turn_on; /* Silent roam monitor enable flags */
+ bool sroamed; /* Silent roam monitor check flags */
+#endif /* CONFIG_SILENT_ROAM */
+ bool extdtxs_in_txcpl;
+ bool hostrdy_after_init;
+#ifdef SUPPORT_SET_TID
+ uint8 tid_mode;
+ uint32 target_uid;
+ uint8 target_tid;
+#endif /* SUPPORT_SET_TID */
+#ifdef DHD_PKTDUMP_ROAM
+ void *pktcnts;
+#endif /* DHD_PKTDUMP_ROAM */
+ bool disable_dtim_in_suspend; /* Disable set bcn_li_dtim in suspend */
+#ifdef REVERSE_AIFSN
+ bool aifsn_reverse;
+#endif /* REVERSE_AIFSN */
+} dhd_pub_t;
+
+typedef struct {
+ uint rxwake;
+ uint rcwake;
+#ifdef DHD_WAKE_RX_STATUS
+ uint rx_bcast;
+ uint rx_arp;
+ uint rx_mcast;
+ uint rx_multi_ipv6;
+ uint rx_icmpv6;
+ uint rx_icmpv6_ra;
+ uint rx_icmpv6_na;
+ uint rx_icmpv6_ns;
+ uint rx_multi_ipv4;
+ uint rx_multi_other;
+ uint rx_ucast;
+#endif /* DHD_WAKE_RX_STATUS */
+#ifdef DHD_WAKE_EVENT_STATUS
+ uint rc_event[WLC_E_LAST];
+#endif /* DHD_WAKE_EVENT_STATUS */
+} wake_counts_t;
+
+#if defined(PCIE_FULL_DONGLE)
+
+/* Packet Tag for PCIE Full Dongle DHD */
+typedef struct dhd_pkttag_fd {
+ uint16 flowid; /* Flowring Id */
+ uint16 ifid;
+#ifndef DHD_PCIE_PKTID
+ uint16 dma_len; /* pkt len for DMA_MAP/UNMAP */
+ dmaaddr_t pa; /* physical address */
+ void *dmah; /* dma mapper handle */
+ void *secdma; /* secure dma sec_cma_info handle */
+#endif /* !DHD_PCIE_PKTID */
+#if defined(TX_STATUS_LATENCY_STATS)
+ uint64 q_time_us; /* time when tx pkt queued to flowring */
+#endif // endif
+ uint16 flags;
+} dhd_pkttag_fd_t;
+
+/* Packet Tag for DHD PCIE Full Dongle */
+#define DHD_PKTTAG_FD(pkt) ((dhd_pkttag_fd_t *)(PKTTAG(pkt)))
+
+#define DHD_PKT_GET_FLOWID(pkt) ((DHD_PKTTAG_FD(pkt))->flowid)
+#define DHD_PKT_SET_FLOWID(pkt, pkt_flowid) \
+ DHD_PKTTAG_FD(pkt)->flowid = (uint16)(pkt_flowid)
+
+#define DHD_PKT_GET_DATAOFF(pkt) ((DHD_PKTTAG_FD(pkt))->dataoff)
+#define DHD_PKT_SET_DATAOFF(pkt, pkt_dataoff) \
+ DHD_PKTTAG_FD(pkt)->dataoff = (uint16)(pkt_dataoff)
+
+#define DHD_PKT_GET_DMA_LEN(pkt) ((DHD_PKTTAG_FD(pkt))->dma_len)
+#define DHD_PKT_SET_DMA_LEN(pkt, pkt_dma_len) \
+ DHD_PKTTAG_FD(pkt)->dma_len = (uint16)(pkt_dma_len)
+
+#define DHD_PKT_GET_PA(pkt) ((DHD_PKTTAG_FD(pkt))->pa)
+#define DHD_PKT_SET_PA(pkt, pkt_pa) \
+ DHD_PKTTAG_FD(pkt)->pa = (dmaaddr_t)(pkt_pa)
+
+#define DHD_PKT_GET_DMAH(pkt) ((DHD_PKTTAG_FD(pkt))->dmah)
+#define DHD_PKT_SET_DMAH(pkt, pkt_dmah) \
+ DHD_PKTTAG_FD(pkt)->dmah = (void *)(pkt_dmah)
+
+#define DHD_PKT_GET_SECDMA(pkt) ((DHD_PKTTAG_FD(pkt))->secdma)
+#define DHD_PKT_SET_SECDMA(pkt, pkt_secdma) \
+ DHD_PKTTAG_FD(pkt)->secdma = (void *)(pkt_secdma)
+
+#if defined(TX_STATUS_LATENCY_STATS)
+#define DHD_PKT_GET_QTIME(pkt) ((DHD_PKTTAG_FD(pkt))->q_time_us)
+#define DHD_PKT_SET_QTIME(pkt, pkt_q_time_us) \
+ DHD_PKTTAG_FD(pkt)->q_time_us = (uint64)(pkt_q_time_us)
+#endif // endif
+
+#define DHD_PKT_GET_FLAGS(pkt) ((DHD_PKTTAG_FD(pkt))->flags)
+#define DHD_PKT_SET_FLAGS(pkt, pkt_flags) \
+ DHD_PKTTAG_FD(pkt)->flags = (uint16)(pkt_flags)
+
+#define PKTFLAG_NO_FWD 0x8000
+
+#define DHD_PKT_FLAGS_SET_NO_FWD(pkt) \
+ DHD_PKTTAG_FD(pkt)->flags |= PKTFLAG_NO_FWD
+#define DHD_PKT_FLAGS_CLEAR_NO_FWD(pkt) \
+ DHD_PKTTAG_FD(pkt)->flags &= ~PKTFLAG_NO_FWD
+#define DHD_PKT_FLAGS_IS_NO_FWD(pkt) \
+ (DHD_PKTTAG_FD(pkt)->flags & PKTFLAG_NO_FWD)
+
+#endif /* PCIE_FULL_DONGLE */
+
+#if defined(BCMWDF)
+typedef struct {
+ dhd_pub_t *dhd_pub;
+} dhd_workitem_context_t;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(dhd_workitem_context_t, dhd_get_dhd_workitem_context)
+#endif /* (BCMWDF) */
+
+ #if defined(CONFIG_PM_SLEEP)
+
+ #define DHD_PM_RESUME_WAIT_INIT(a) DECLARE_WAIT_QUEUE_HEAD(a);
+ #define _DHD_PM_RESUME_WAIT(a, b) do {\
+ int retry = 0; \
+ SMP_RD_BARRIER_DEPENDS(); \
+ while (dhd_mmc_suspend && retry++ != b) { \
+ SMP_RD_BARRIER_DEPENDS(); \
+ wait_event_interruptible_timeout(a, !dhd_mmc_suspend, 1); \
+ } \
+ } while (0)
+ #define DHD_PM_RESUME_WAIT(a) _DHD_PM_RESUME_WAIT(a, 200)
+ #define DHD_PM_RESUME_WAIT_FOREVER(a) _DHD_PM_RESUME_WAIT(a, ~0)
+ #define DHD_PM_RESUME_RETURN_ERROR(a) do { \
+ if (dhd_mmc_suspend) { \
+ printf("%s[%d]: mmc is still in suspend state!!!\n", \
+ __FUNCTION__, __LINE__); \
+ return a; \
+ } \
+ } while (0)
+ #define DHD_PM_RESUME_RETURN do { if (dhd_mmc_suspend) return; } while (0)
+
+ #define DHD_SPINWAIT_SLEEP_INIT(a) DECLARE_WAIT_QUEUE_HEAD(a);
+ #define SPINWAIT_SLEEP(a, exp, us) do { \
+ uint countdown = (us) + 9999; \
+ while ((exp) && (countdown >= 10000)) { \
+ wait_event_interruptible_timeout(a, FALSE, 1); \
+ countdown -= 10000; \
+ } \
+ } while (0)
+
+ #else
+
+ #define DHD_PM_RESUME_WAIT_INIT(a)
+ #define DHD_PM_RESUME_WAIT(a)
+ #define DHD_PM_RESUME_WAIT_FOREVER(a)
+ #define DHD_PM_RESUME_RETURN_ERROR(a)
+ #define DHD_PM_RESUME_RETURN
+
+ #define DHD_SPINWAIT_SLEEP_INIT(a)
+ #define SPINWAIT_SLEEP(a, exp, us) do { \
+ uint countdown = (us) + 9; \
+ while ((exp) && (countdown >= 10)) { \
+ OSL_DELAY(10); \
+ countdown -= 10; \
+ } \
+ } while (0)
+
+ #endif /* CONFIG_PM_SLEEP */
+
+#ifndef OSL_SLEEP
+#define OSL_SLEEP(ms) OSL_DELAY(ms*1000)
+#endif /* OSL_SLEEP */
+
+#define DHD_IF_VIF 0x01 /* Virtual IF (Hidden from user) */
+
+#ifdef PNO_SUPPORT
+int dhd_pno_clean(dhd_pub_t *dhd);
+#endif /* PNO_SUPPORT */
+
+/*
+ * Wake locks are an Android power management concept. They are used by applications and services
+ * to request CPU resources.
+ */
+#if defined(OEM_ANDROID)
+extern int dhd_os_wake_lock(dhd_pub_t *pub);
+extern int dhd_os_wake_unlock(dhd_pub_t *pub);
+extern int dhd_os_wake_lock_waive(dhd_pub_t *pub);
+extern int dhd_os_wake_lock_restore(dhd_pub_t *pub);
+extern void dhd_event_wake_lock(dhd_pub_t *pub);
+extern void dhd_event_wake_unlock(dhd_pub_t *pub);
+extern void dhd_pm_wake_lock_timeout(dhd_pub_t *pub, int val);
+extern void dhd_pm_wake_unlock(dhd_pub_t *pub);
+extern void dhd_txfl_wake_lock_timeout(dhd_pub_t *pub, int val);
+extern void dhd_txfl_wake_unlock(dhd_pub_t *pub);
+extern int dhd_os_wake_lock_timeout(dhd_pub_t *pub);
+extern int dhd_os_wake_lock_rx_timeout_enable(dhd_pub_t *pub, int val);
+extern int dhd_os_wake_lock_ctrl_timeout_enable(dhd_pub_t *pub, int val);
+extern int dhd_os_wake_lock_ctrl_timeout_cancel(dhd_pub_t *pub);
+extern int dhd_os_wd_wake_lock(dhd_pub_t *pub);
+extern int dhd_os_wd_wake_unlock(dhd_pub_t *pub);
+extern void dhd_os_wake_lock_init(struct dhd_info *dhd);
+extern void dhd_os_wake_lock_destroy(struct dhd_info *dhd);
+#ifdef DHD_USE_SCAN_WAKELOCK
+extern void dhd_os_scan_wake_lock_timeout(dhd_pub_t *pub, int val);
+extern void dhd_os_scan_wake_unlock(dhd_pub_t *pub);
+#endif /* BCMPCIE_SCAN_WAKELOCK */
+
+inline static void MUTEX_LOCK_SOFTAP_SET_INIT(dhd_pub_t * dhdp)
+{
+#if defined(OEM_ANDROID)
+ mutex_init(&dhdp->wl_softap_lock);
+#endif /* OEM_ANDROID */
+}
+
+inline static void MUTEX_LOCK_SOFTAP_SET(dhd_pub_t * dhdp)
+{
+#if defined(OEM_ANDROID)
+ mutex_lock(&dhdp->wl_softap_lock);
+#endif /* OEM_ANDROID */
+}
+
+inline static void MUTEX_UNLOCK_SOFTAP_SET(dhd_pub_t * dhdp)
+{
+#if defined(OEM_ANDROID)
+ mutex_unlock(&dhdp->wl_softap_lock);
+#endif /* OEM_ANDROID */
+}
+
+#ifdef DHD_DEBUG_WAKE_LOCK
+#define DHD_OS_WAKE_LOCK(pub) \
+ do { \
+ printf("call wake_lock: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock(pub); \
+ } while (0)
+#define DHD_OS_WAKE_UNLOCK(pub) \
+ do { \
+ printf("call wake_unlock: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_unlock(pub); \
+ } while (0)
+#define DHD_EVENT_WAKE_LOCK(pub) \
+ do { \
+ printf("call event wake_lock: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_event_wake_lock(pub); \
+ } while (0)
+#define DHD_EVENT_WAKE_UNLOCK(pub) \
+ do { \
+ printf("call event wake_unlock: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_event_wake_unlock(pub); \
+ } while (0)
+#define DHD_PM_WAKE_LOCK_TIMEOUT(pub, val) \
+ do { \
+ printf("call pm_wake_timeout enable\n"); \
+ dhd_pm_wake_lock_timeout(pub, val); \
+ } while (0)
+#define DHD_PM_WAKE_UNLOCK(pub) \
+ do { \
+ printf("call pm_wake unlock\n"); \
+ dhd_pm_wake_unlock(pub); \
+ } while (0)
+#define DHD_TXFL_WAKE_LOCK_TIMEOUT(pub, val) \
+ do { \
+ printf("call pm_wake_timeout enable\n"); \
+ dhd_txfl_wake_lock_timeout(pub, val); \
+ } while (0)
+#define DHD_TXFL_WAKE_UNLOCK(pub) \
+ do { \
+ printf("call pm_wake unlock\n"); \
+ dhd_txfl_wake_unlock(pub); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_TIMEOUT(pub) \
+ do { \
+ printf("call wake_lock_timeout: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_timeout(pub); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_RX_TIMEOUT_ENABLE(pub, val) \
+ do { \
+ printf("call wake_lock_rx_timeout_enable[%d]: %s %d\n", \
+ val, __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_rx_timeout_enable(pub, val); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_ENABLE(pub, val) \
+ do { \
+ printf("call wake_lock_ctrl_timeout_enable[%d]: %s %d\n", \
+ val, __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_ctrl_timeout_enable(pub, val); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_CANCEL(pub) \
+ do { \
+ printf("call wake_lock_ctrl_timeout_cancel: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_ctrl_timeout_cancel(pub); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_WAIVE(pub) \
+ do { \
+ printf("call wake_lock_waive: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_waive(pub); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_RESTORE(pub) \
+ do { \
+ printf("call wake_lock_restore: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_restore(pub); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_INIT(dhd) \
+ do { \
+ printf("call wake_lock_init: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_init(dhd); \
+ } while (0)
+#define DHD_OS_WAKE_LOCK_DESTROY(dhd) \
+ do { \
+ printf("call wake_lock_destroy: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_wake_lock_destroy(dhd); \
+ } while (0)
+#else
+#define DHD_OS_WAKE_LOCK(pub) dhd_os_wake_lock(pub)
+#define DHD_OS_WAKE_UNLOCK(pub) dhd_os_wake_unlock(pub)
+#define DHD_EVENT_WAKE_LOCK(pub) dhd_event_wake_lock(pub)
+#define DHD_EVENT_WAKE_UNLOCK(pub) dhd_event_wake_unlock(pub)
+#define DHD_PM_WAKE_LOCK_TIMEOUT(pub, val) dhd_pm_wake_lock_timeout(pub, val)
+#define DHD_PM_WAKE_UNLOCK(pub) dhd_pm_wake_unlock(pub)
+#define DHD_TXFL_WAKE_LOCK_TIMEOUT(pub, val) dhd_txfl_wake_lock_timeout(pub, val)
+#define DHD_TXFL_WAKE_UNLOCK(pub) dhd_txfl_wake_unlock(pub)
+#define DHD_OS_WAKE_LOCK_TIMEOUT(pub) dhd_os_wake_lock_timeout(pub)
+#define DHD_OS_WAKE_LOCK_RX_TIMEOUT_ENABLE(pub, val) \
+ dhd_os_wake_lock_rx_timeout_enable(pub, val)
+#define DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_ENABLE(pub, val) \
+ dhd_os_wake_lock_ctrl_timeout_enable(pub, val)
+#define DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_CANCEL(pub) \
+ dhd_os_wake_lock_ctrl_timeout_cancel(pub)
+#define DHD_OS_WAKE_LOCK_WAIVE(pub) dhd_os_wake_lock_waive(pub)
+#define DHD_OS_WAKE_LOCK_RESTORE(pub) dhd_os_wake_lock_restore(pub)
+#define DHD_OS_WAKE_LOCK_INIT(dhd) dhd_os_wake_lock_init(dhd);
+#define DHD_OS_WAKE_LOCK_DESTROY(dhd) dhd_os_wake_lock_destroy(dhd);
+#endif /* DHD_DEBUG_WAKE_LOCK */
+
+#define DHD_OS_WD_WAKE_LOCK(pub) dhd_os_wd_wake_lock(pub)
+#define DHD_OS_WD_WAKE_UNLOCK(pub) dhd_os_wd_wake_unlock(pub)
+
+#ifdef DHD_USE_SCAN_WAKELOCK
+#ifdef DHD_DEBUG_SCAN_WAKELOCK
+#define DHD_OS_SCAN_WAKE_LOCK_TIMEOUT(pub, val) \
+ do { \
+ printf("call wake_lock_scan: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_scan_wake_lock_timeout(pub, val); \
+ } while (0)
+#define DHD_OS_SCAN_WAKE_UNLOCK(pub) \
+ do { \
+ printf("call wake_unlock_scan: %s %d\n", \
+ __FUNCTION__, __LINE__); \
+ dhd_os_scan_wake_unlock(pub); \
+ } while (0)
+#else
+#define DHD_OS_SCAN_WAKE_LOCK_TIMEOUT(pub, val) dhd_os_scan_wake_lock_timeout(pub, val)
+#define DHD_OS_SCAN_WAKE_UNLOCK(pub) dhd_os_scan_wake_unlock(pub)
+#endif /* DHD_DEBUG_SCAN_WAKELOCK */
+#else
+#define DHD_OS_SCAN_WAKE_LOCK_TIMEOUT(pub, val)
+#define DHD_OS_SCAN_WAKE_UNLOCK(pub)
+#endif /* DHD_USE_SCAN_WAKELOCK */
+
+#else
+
+/* Wake lock are used in Android only (until the Linux community accepts it) */
+#define DHD_OS_WAKE_LOCK(pub)
+#define DHD_OS_WAKE_UNLOCK(pub)
+#define DHD_EVENT_WAKE_LOCK(pub)
+#define DHD_EVENT_WAKE_UNLOCK(pub)
+#define DHD_PM_WAKE_LOCK_TIMEOUT(pub, val)
+#define DHD_PM_WAKE_UNLOCK(pub)
+#define DHD_TXFL_WAKE_LOCK_TIMEOUT(pub, val)
+#define DHD_TXFL_WAKE_UNLOCK(pub)
+#define DHD_OS_WD_WAKE_LOCK(pub)
+#define DHD_OS_WD_WAKE_UNLOCK(pub)
+#define DHD_OS_WAKE_LOCK_TIMEOUT(pub)
+#define DHD_OS_WAKE_LOCK_RX_TIMEOUT_ENABLE(pub, val) UNUSED_PARAMETER(val)
+#define DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_ENABLE(pub, val) UNUSED_PARAMETER(val)
+#define DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_CANCEL(pub, val)
+#define DHD_OS_WAKE_LOCK_WAIVE(pub)
+#define DHD_OS_WAKE_LOCK_RESTORE(pub)
+#define DHD_OS_SCAN_WAKE_LOCK_TIMEOUT(pub, val)
+#define DHD_OS_SCAN_WAKE_UNLOCK(pub)
+#define DHD_OS_WAKE_LOCK_INIT(dhd)
+#define DHD_OS_WAKE_LOCK_DESTROY(dhd)
+
+#endif // endif
+
+#ifdef BCMPCIE_OOB_HOST_WAKE
+#define OOB_WAKE_LOCK_TIMEOUT 500
+extern void dhd_os_oob_irq_wake_lock_timeout(dhd_pub_t *pub, int val);
+extern void dhd_os_oob_irq_wake_unlock(dhd_pub_t *pub);
+
+#define DHD_OS_OOB_IRQ_WAKE_LOCK_TIMEOUT(pub, val) dhd_os_oob_irq_wake_lock_timeout(pub, val)
+#define DHD_OS_OOB_IRQ_WAKE_UNLOCK(pub) dhd_os_oob_irq_wake_unlock(pub)
+#endif /* BCMPCIE_OOB_HOST_WAKE */
+
+#define DHD_PACKET_TIMEOUT_MS 500
+#define DHD_EVENT_TIMEOUT_MS 1500
+#define SCAN_WAKE_LOCK_TIMEOUT 10000
+#define MAX_TX_TIMEOUT 500
+
+/* Enum for IOCTL recieved status */
+typedef enum dhd_ioctl_recieved_status
+{
+ IOCTL_WAIT = 0,
+ IOCTL_RETURN_ON_SUCCESS,
+ IOCTL_RETURN_ON_TRAP,
+ IOCTL_RETURN_ON_BUS_STOP,
+ IOCTL_RETURN_ON_ERROR
+} dhd_ioctl_recieved_status_t;
+
+/* interface operations (register, remove) should be atomic, use this lock to prevent race
+ * condition among wifi on/off and interface operation functions
+ */
+void dhd_net_if_lock(struct net_device *dev);
+void dhd_net_if_unlock(struct net_device *dev);
+
+#if defined(MULTIPLE_SUPPLICANT)
+#if defined(OEM_ANDROID) && defined(BCMSDIO)
+extern struct mutex _dhd_sdio_mutex_lock_;
+#endif // endif
+#endif /* MULTIPLE_SUPPLICANT */
+
+typedef enum dhd_attach_states
+{
+ DHD_ATTACH_STATE_INIT = 0x0,
+ DHD_ATTACH_STATE_NET_ALLOC = 0x1,
+ DHD_ATTACH_STATE_DHD_ALLOC = 0x2,
+ DHD_ATTACH_STATE_ADD_IF = 0x4,
+ DHD_ATTACH_STATE_PROT_ATTACH = 0x8,
+ DHD_ATTACH_STATE_WL_ATTACH = 0x10,
+ DHD_ATTACH_STATE_THREADS_CREATED = 0x20,
+ DHD_ATTACH_STATE_WAKELOCKS_INIT = 0x40,
+ DHD_ATTACH_STATE_CFG80211 = 0x80,
+ DHD_ATTACH_STATE_EARLYSUSPEND_DONE = 0x100,
+ DHD_ATTACH_TIMESYNC_ATTACH_DONE = 0x200,
+ DHD_ATTACH_LOGTRACE_INIT = 0x400,
+ DHD_ATTACH_STATE_LB_ATTACH_DONE = 0x800,
+ DHD_ATTACH_STATE_DONE = 0x1000
+} dhd_attach_states_t;
+
+/* Value -1 means we are unsuccessful in creating the kthread. */
+#define DHD_PID_KT_INVALID -1
+/* Value -2 means we are unsuccessful in both creating the kthread and tasklet */
+#define DHD_PID_KT_TL_INVALID -2
+
+/* default reporting period */
+#define ECOUNTERS_DEFAULT_PERIOD 0
+
+/* default number of reports. '0' indicates forever */
+#define ECOUNTERS_NUM_REPORTS 0
+
+typedef struct ecounters_cfg {
+ uint16 type;
+ uint16 if_slice_idx;
+ uint16 stats_rep;
+} ecounters_cfg_t;
+
+typedef struct event_ecounters_cfg {
+ uint16 event_id;
+ uint16 type;
+ uint16 if_slice_idx;
+ uint16 stats_rep;
+} event_ecounters_cfg_t;
+
+typedef struct ecountersv2_xtlv_list_elt {
+ /* Not quite the exact bcm_xtlv_t type as data could be pointing to other pieces in
+ * memory at the time of parsing arguments.
+ */
+ uint16 id;
+ uint16 len;
+ uint8 *data;
+ struct ecountersv2_xtlv_list_elt *next;
+} ecountersv2_xtlv_list_elt_t;
+
+typedef struct ecountersv2_processed_xtlv_list_elt {
+ uint8 *data;
+ struct ecountersv2_processed_xtlv_list_elt *next;
+} ecountersv2_processed_xtlv_list_elt;
+
+/*
+ * Exported from dhd OS modules (dhd_linux/dhd_ndis)
+ */
+
+/* Indication from bus module regarding presence/insertion of dongle.
+ * Return dhd_pub_t pointer, used as handle to OS module in later calls.
+ * Returned structure should have bus and prot pointers filled in.
+ * bus_hdrlen specifies required headroom for bus module header.
+ */
+extern dhd_pub_t *dhd_attach(osl_t *osh, struct dhd_bus *bus, uint bus_hdrlen);
+extern int dhd_attach_net(dhd_pub_t *dhdp, bool need_rtnl_lock);
+#if defined(WLP2P) && defined(WL_CFG80211)
+/* To allow attach/detach calls corresponding to p2p0 interface */
+extern int dhd_attach_p2p(dhd_pub_t *);
+extern int dhd_detach_p2p(dhd_pub_t *);
+#endif /* WLP2P && WL_CFG80211 */
+extern int dhd_register_if(dhd_pub_t *dhdp, int idx, bool need_rtnl_lock);
+#ifdef WL_VIF_SUPPORT
+extern int dhd_register_vif(dhd_pub_t *dhdp);
+#endif /* WL_VIF_SUPPORT */
+
+/* Indication from bus module regarding removal/absence of dongle */
+extern void dhd_detach(dhd_pub_t *dhdp);
+extern void dhd_free(dhd_pub_t *dhdp);
+extern void dhd_clear(dhd_pub_t *dhdp);
+
+/* Indication from bus module to change flow-control state */
+extern void dhd_txflowcontrol(dhd_pub_t *dhdp, int ifidx, bool on);
+
+/* Store the status of a connection attempt for later retrieval by an iovar */
+extern void dhd_store_conn_status(uint32 event, uint32 status, uint32 reason);
+
+extern bool dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, void *pkt, int prec);
+
+extern void dhd_rx_frame(dhd_pub_t *dhdp, int ifidx, void *rxp, int numpkt, uint8 chan);
+
+/* Return pointer to interface name */
+extern char *dhd_ifname(dhd_pub_t *dhdp, int idx);
+
+#ifdef DHD_UCODE_DOWNLOAD
+/* Returns the ucode path */
+extern char *dhd_get_ucode_path(dhd_pub_t *dhdp);
+#endif /* DHD_UCODE_DOWNLOAD */
+
+/* Request scheduling of the bus dpc */
+extern void dhd_sched_dpc(dhd_pub_t *dhdp);
+
+/* Notify tx completion */
+extern void dhd_txcomplete(dhd_pub_t *dhdp, void *txp, bool success);
+#ifdef DHD_4WAYM4_FAIL_DISCONNECT
+extern void dhd_eap_txcomplete(dhd_pub_t *dhdp, void *txp, bool success, int ifidx);
+extern void dhd_cleanup_m4_state_work(dhd_pub_t *dhdp, int ifidx);
+#endif /* DHD_4WAYM4_FAIL_DISCONNECT */
+
+#ifdef DHD_PCIE_NATIVE_RUNTIMEPM
+extern void dhd_bus_wakeup_work(dhd_pub_t *dhdp);
+#endif /* DHD_PCIE_NATIVE_RUNTIMEPM */
+
+#define WIFI_FEATURE_INFRA 0x0001 /* Basic infrastructure mode */
+#define WIFI_FEATURE_INFRA_5G 0x0002 /* Support for 5 GHz Band */
+#define WIFI_FEATURE_HOTSPOT 0x0004 /* Support for GAS/ANQP */
+#define WIFI_FEATURE_P2P 0x0008 /* Wifi-Direct */
+#define WIFI_FEATURE_SOFT_AP 0x0010 /* Soft AP */
+#define WIFI_FEATURE_GSCAN 0x0020 /* Google-Scan APIs */
+#define WIFI_FEATURE_NAN 0x0040 /* Neighbor Awareness Networking */
+#define WIFI_FEATURE_D2D_RTT 0x0080 /* Device-to-device RTT */
+#define WIFI_FEATURE_D2AP_RTT 0x0100 /* Device-to-AP RTT */
+#define WIFI_FEATURE_BATCH_SCAN 0x0200 /* Batched Scan (legacy) */
+#define WIFI_FEATURE_PNO 0x0400 /* Preferred network offload */
+#define WIFI_FEATURE_ADDITIONAL_STA 0x0800 /* Support for two STAs */
+#define WIFI_FEATURE_TDLS 0x1000 /* Tunnel directed link setup */
+#define WIFI_FEATURE_TDLS_OFFCHANNEL 0x2000 /* Support for TDLS off channel */
+#define WIFI_FEATURE_EPR 0x4000 /* Enhanced power reporting */
+#define WIFI_FEATURE_AP_STA 0x8000 /* Support for AP STA Concurrency */
+#define WIFI_FEATURE_LINKSTAT 0x10000 /* Support for Linkstats */
+#define WIFI_FEATURE_LOGGER 0x20000 /* WiFi Logger */
+#define WIFI_FEATURE_HAL_EPNO 0x40000 /* WiFi PNO enhanced */
+#define WIFI_FEATURE_RSSI_MONITOR 0x80000 /* RSSI Monitor */
+#define WIFI_FEATURE_MKEEP_ALIVE 0x100000 /* WiFi mkeep_alive */
+#define WIFI_FEATURE_CONFIG_NDO 0x200000 /* ND offload configure */
+#define WIFI_FEATURE_TX_TRANSMIT_POWER 0x400000 /* Capture Tx transmit power levels */
+#define WIFI_FEATURE_CONTROL_ROAMING 0x800000 /* Enable/Disable firmware roaming */
+#define WIFI_FEATURE_FILTER_IE 0x1000000 /* Probe req ie filter */
+#define WIFI_FEATURE_SCAN_RAND 0x2000000 /* Support MAC & Prb SN randomization */
+#define WIFI_FEATURE_SET_TX_POWER_LIMIT 0x4000000 /* Support Tx Power Limit setting */
+#define WIFI_FEATURE_USE_BODY_HEAD_SAR 0x8000000 /* Body/Head Proximity for SAR */
+#define WIFI_FEATURE_SET_LATENCY_MODE 0x40000000 /* Support Latency mode setting */
+#define WIFI_FEATURE_P2P_RAND_MAC 0x80000000 /* Support P2P MAC randomization */
+#define WIFI_FEATURE_INVALID 0xFFFFFFFF /* Invalid Feature */
+
+#define MAX_FEATURE_SET_CONCURRRENT_GROUPS 3
+
+extern int dhd_dev_get_feature_set(struct net_device *dev);
+extern int dhd_dev_get_feature_set_matrix(struct net_device *dev, int num);
+extern int dhd_dev_cfg_rand_mac_oui(struct net_device *dev, uint8 *oui);
+#ifdef CUSTOM_FORCE_NODFS_FLAG
+extern int dhd_dev_set_nodfs(struct net_device *dev, uint nodfs);
+#endif /* CUSTOM_FORCE_NODFS_FLAG */
+#ifdef NDO_CONFIG_SUPPORT
+#ifndef NDO_MAX_HOST_IP_ENTRIES
+#define NDO_MAX_HOST_IP_ENTRIES 10
+#endif /* NDO_MAX_HOST_IP_ENTRIES */
+
+extern int dhd_dev_ndo_cfg(struct net_device *dev, u8 enable);
+extern int dhd_dev_ndo_update_inet6addr(struct net_device * dev);
+#endif /* NDO_CONFIG_SUPPORT */
+extern int dhd_set_rand_mac_oui(dhd_pub_t *dhd);
+#ifdef GSCAN_SUPPORT
+extern int dhd_dev_set_lazy_roam_cfg(struct net_device *dev,
+ wlc_roam_exp_params_t *roam_param);
+extern int dhd_dev_lazy_roam_enable(struct net_device *dev, uint32 enable);
+extern int dhd_dev_set_lazy_roam_bssid_pref(struct net_device *dev,
+ wl_bssid_pref_cfg_t *bssid_pref, uint32 flush);
+#endif /* GSCAN_SUPPORT */
+#if defined(GSCAN_SUPPORT) || defined(ROAMEXP_SUPPORT)
+extern int dhd_dev_set_blacklist_bssid(struct net_device *dev, maclist_t *blacklist,
+ uint32 len, uint32 flush);
+extern int dhd_dev_set_whitelist_ssid(struct net_device *dev, wl_ssid_whitelist_t *whitelist,
+ uint32 len, uint32 flush);
+#endif /* GSCAN_SUPPORT || ROAMEXP_SUPPORT */
+
+/* OS independent layer functions */
+extern void dhd_os_dhdiovar_lock(dhd_pub_t *pub);
+extern void dhd_os_dhdiovar_unlock(dhd_pub_t *pub);
+void dhd_os_logdump_lock(dhd_pub_t *pub);
+void dhd_os_logdump_unlock(dhd_pub_t *pub);
+extern int dhd_os_proto_block(dhd_pub_t * pub);
+extern int dhd_os_proto_unblock(dhd_pub_t * pub);
+extern int dhd_os_ioctl_resp_wait(dhd_pub_t * pub, uint * condition);
+extern int dhd_os_ioctl_resp_wake(dhd_pub_t * pub);
+extern unsigned int dhd_os_get_ioctl_resp_timeout(void);
+extern void dhd_os_set_ioctl_resp_timeout(unsigned int timeout_msec);
+extern void dhd_os_ioctl_resp_lock(dhd_pub_t * pub);
+extern void dhd_os_ioctl_resp_unlock(dhd_pub_t * pub);
+#ifdef PCIE_FULL_DONGLE
+extern void dhd_wakeup_ioctl_event(dhd_pub_t *pub, dhd_ioctl_recieved_status_t reason);
+#else
+static INLINE void dhd_wakeup_ioctl_event(dhd_pub_t *pub, dhd_ioctl_recieved_status_t reason)
+{ printf("%s is NOT implemented for SDIO", __FUNCTION__); return; }
+#endif // endif
+#ifdef SHOW_LOGTRACE
+/* Bound and delay are fine tuned after several experiments and these
+ * are the best case values to handle bombarding of console logs.
+ */
+#define DHD_EVENT_LOGTRACE_BOUND 10
+/* since FW has event log rate health check (EVENT_LOG_RATE_HC) we can reduce
+ * the reschedule delay to 10ms
+*/
+#define DHD_EVENT_LOGTRACE_RESCHEDULE_DELAY_MS 10u
+extern int dhd_os_read_file(void *file, char *buf, uint32 size);
+extern int dhd_os_seek_file(void *file, int64 offset);
+void dhd_sendup_info_buf(dhd_pub_t *dhdp, uint8 *msg);
+#endif /* SHOW_LOGTRACE */
+int dhd_os_write_file_posn(void *fp, unsigned long *posn,
+ void *buf, unsigned long buflen);
+int dhd_msix_message_set(dhd_pub_t *dhdp, uint table_entry,
+ uint message_number, bool unmask);
+
+extern void
+dhd_pcie_dump_core_regs(dhd_pub_t * pub, uint32 index, uint32 first_addr, uint32 last_addr);
+extern void wl_dhdpcie_dump_regs(void * context);
+
+extern int dhd_os_get_image_block(char * buf, int len, void * image);
+extern int dhd_os_get_image_size(void * image);
+#if defined(BT_OVER_SDIO)
+extern int dhd_os_gets_image(dhd_pub_t *pub, char *str, int len, void *image);
+extern void dhdsdio_bus_usr_cnt_inc(dhd_pub_t *pub);
+extern void dhdsdio_bus_usr_cnt_dec(dhd_pub_t *pub);
+#endif /* (BT_OVER_SDIO) */
+extern void *dhd_os_open_image1(dhd_pub_t *pub, char *filename); /* rev1 function signature */
+extern void dhd_os_close_image1(dhd_pub_t *pub, void *image);
+extern void dhd_os_wd_timer(void *bus, uint wdtick);
+#ifdef DHD_PCIE_RUNTIMEPM
+extern void dhd_os_runtimepm_timer(void *bus, uint tick);
+#endif /* DHD_PCIE_RUNTIMEPM */
+extern void dhd_os_sdlock(dhd_pub_t * pub);
+extern void dhd_os_sdunlock(dhd_pub_t * pub);
+extern void dhd_os_sdlock_txq(dhd_pub_t * pub);
+extern void dhd_os_sdunlock_txq(dhd_pub_t * pub);
+extern void dhd_os_sdlock_rxq(dhd_pub_t * pub);
+extern void dhd_os_sdunlock_rxq(dhd_pub_t * pub);
+extern void dhd_os_sdlock_sndup_rxq(dhd_pub_t * pub);
+extern void dhd_os_tracelog(const char *format, ...);
+#ifdef DHDTCPACK_SUPPRESS
+extern unsigned long dhd_os_tcpacklock(dhd_pub_t *pub);
+extern void dhd_os_tcpackunlock(dhd_pub_t *pub, unsigned long flags);
+#endif /* DHDTCPACK_SUPPRESS */
+
+extern int dhd_customer_oob_irq_map(void *adapter, unsigned long *irq_flags_ptr);
+extern int dhd_customer_gpio_wlan_ctrl(void *adapter, int onoff);
+extern int dhd_custom_get_mac_address(void *adapter, unsigned char *buf);
+#if defined(CUSTOM_COUNTRY_CODE)
+extern void get_customized_country_code(void *adapter, char *country_iso_code,
+ wl_country_t *cspec, u32 flags);
+#else
+extern void get_customized_country_code(void *adapter, char *country_iso_code, wl_country_t *cspec);
+#endif /* CUSTOM_COUNTRY_CODE */
+extern void dhd_os_sdunlock_sndup_rxq(dhd_pub_t * pub);
+extern void dhd_os_sdlock_eventq(dhd_pub_t * pub);
+extern void dhd_os_sdunlock_eventq(dhd_pub_t * pub);
+extern bool dhd_os_check_hang(dhd_pub_t *dhdp, int ifidx, int ret);
+extern int dhd_os_send_hang_message(dhd_pub_t *dhdp);
+extern void dhd_set_version_info(dhd_pub_t *pub, char *fw);
+extern bool dhd_os_check_if_up(dhd_pub_t *pub);
+extern int dhd_os_check_wakelock(dhd_pub_t *pub);
+extern int dhd_os_check_wakelock_all(dhd_pub_t *pub);
+extern int dhd_get_instance(dhd_pub_t *pub);
+#ifdef CUSTOM_SET_CPUCORE
+extern void dhd_set_cpucore(dhd_pub_t *dhd, int set);
+#endif /* CUSTOM_SET_CPUCORE */
+
+#if defined(KEEP_ALIVE)
+extern int dhd_keep_alive_onoff(dhd_pub_t *dhd);
+#endif /* KEEP_ALIVE */
+
+#if defined(DHD_FW_COREDUMP)
+void dhd_schedule_memdump(dhd_pub_t *dhdp, uint8 *buf, uint32 size);
+#endif /* DHD_FW_COREDUMP */
+
+void dhd_write_sssr_dump(dhd_pub_t *dhdp, uint32 dump_mode);
+#ifdef DNGL_AXI_ERROR_LOGGING
+void dhd_schedule_axi_error_dump(dhd_pub_t *dhdp, void *type);
+#endif /* DNGL_AXI_ERROR_LOGGING */
+#ifdef BCMPCIE
+void dhd_schedule_cto_recovery(dhd_pub_t *dhdp);
+#endif /* BCMPCIE */
+
+#ifdef PKT_FILTER_SUPPORT
+#define DHD_UNICAST_FILTER_NUM 0
+#define DHD_BROADCAST_FILTER_NUM 1
+#define DHD_MULTICAST4_FILTER_NUM 2
+#define DHD_MULTICAST6_FILTER_NUM 3
+#define DHD_MDNS_FILTER_NUM 4
+#define DHD_ARP_FILTER_NUM 5
+#define DHD_BROADCAST_ARP_FILTER_NUM 6
+#define DHD_IP4BCAST_DROP_FILTER_NUM 7
+#define DHD_LLC_STP_DROP_FILTER_NUM 8
+#define DHD_LLC_XID_DROP_FILTER_NUM 9
+#define DISCARD_IPV4_MCAST "102 1 6 IP4_H:16 0xf0 0xe0"
+#define DISCARD_IPV6_MCAST "103 1 6 IP6_H:24 0xff 0xff"
+#define DISCARD_IPV4_BCAST "107 1 6 IP4_H:16 0xffffffff 0xffffffff"
+#define DISCARD_LLC_STP "108 1 6 ETH_H:14 0xFFFFFFFFFFFF 0xAAAA0300000C"
+#define DISCARD_LLC_XID "109 1 6 ETH_H:14 0xFFFFFF 0x0001AF"
+extern int dhd_os_enable_packet_filter(dhd_pub_t *dhdp, int val);
+extern void dhd_enable_packet_filter(int value, dhd_pub_t *dhd);
+extern int dhd_packet_filter_add_remove(dhd_pub_t *dhdp, int add_remove, int num);
+extern int net_os_enable_packet_filter(struct net_device *dev, int val);
+extern int net_os_rxfilter_add_remove(struct net_device *dev, int val, int num);
+
+#define MAX_PKTFLT_BUF_SIZE 2048
+#define MAX_PKTFLT_FIXED_PATTERN_SIZE 32
+#define MAX_PKTFLT_FIXED_BUF_SIZE \
+ (WL_PKT_FILTER_FIXED_LEN + MAX_PKTFLT_FIXED_PATTERN_SIZE * 2)
+#define MAXPKT_ARG 16
+#endif /* PKT_FILTER_SUPPORT */
+
+#if defined(OEM_ANDROID) && defined(BCMPCIE)
+extern int dhd_get_suspend_bcn_li_dtim(dhd_pub_t *dhd, int *dtim_period, int *bcn_interval);
+#else
+extern int dhd_get_suspend_bcn_li_dtim(dhd_pub_t *dhd);
+#endif /* OEM_ANDROID && BCMPCIE */
+
+extern bool dhd_support_sta_mode(dhd_pub_t *dhd);
+extern int write_to_file(dhd_pub_t *dhd, uint8 *buf, int size);
+
+#ifdef RSSI_MONITOR_SUPPORT
+extern int dhd_dev_set_rssi_monitor_cfg(struct net_device *dev, int start,
+ int8 max_rssi, int8 min_rssi);
+#endif /* RSSI_MONITOR_SUPPORT */
+
+#ifdef DHDTCPACK_SUPPRESS
+int dhd_dev_set_tcpack_sup_mode_cfg(struct net_device *dev, uint8 enable);
+#endif /* DHDTCPACK_SUPPRESS */
+
+#define DHD_RSSI_MONITOR_EVT_VERSION 1
+typedef struct {
+ uint8 version;
+ int8 cur_rssi;
+ struct ether_addr BSSID;
+} dhd_rssi_monitor_evt_t;
+
+typedef struct {
+ uint32 limit; /* Expiration time (usec) */
+ uint32 increment; /* Current expiration increment (usec) */
+ uint32 elapsed; /* Current elapsed time (usec) */
+ uint32 tick; /* O/S tick time (usec) */
+} dhd_timeout_t;
+
+#ifdef SHOW_LOGTRACE
+typedef struct {
+ uint num_fmts;
+ char **fmts;
+ char *raw_fmts;
+ char *raw_sstr;
+ uint32 fmts_size;
+ uint32 raw_fmts_size;
+ uint32 raw_sstr_size;
+ uint32 ramstart;
+ uint32 rodata_start;
+ uint32 rodata_end;
+ char *rom_raw_sstr;
+ uint32 rom_raw_sstr_size;
+ uint32 rom_ramstart;
+ uint32 rom_rodata_start;
+ uint32 rom_rodata_end;
+} dhd_event_log_t;
+#endif /* SHOW_LOGTRACE */
+
+#ifdef KEEP_ALIVE
+extern int dhd_dev_start_mkeep_alive(dhd_pub_t *dhd_pub, uint8 mkeep_alive_id, uint8 *ip_pkt,
+ uint16 ip_pkt_len, uint8* src_mac_addr, uint8* dst_mac_addr, uint32 period_msec);
+extern int dhd_dev_stop_mkeep_alive(dhd_pub_t *dhd_pub, uint8 mkeep_alive_id);
+#endif /* KEEP_ALIVE */
+
+#if defined(PKT_FILTER_SUPPORT) && defined(APF)
+/*
+ * As per Google's current implementation, there will be only one APF filter.
+ * Therefore, userspace doesn't bother about filter id and because of that
+ * DHD has to manage the filter id.
+ */
+#define PKT_FILTER_APF_ID 200
+#define DHD_APF_LOCK(ndev) dhd_apf_lock(ndev)
+#define DHD_APF_UNLOCK(ndev) dhd_apf_unlock(ndev)
+
+extern void dhd_apf_lock(struct net_device *dev);
+extern void dhd_apf_unlock(struct net_device *dev);
+extern int dhd_dev_apf_get_version(struct net_device *ndev, uint32 *version);
+extern int dhd_dev_apf_get_max_len(struct net_device *ndev, uint32 *max_len);
+extern int dhd_dev_apf_add_filter(struct net_device *ndev, u8* program,
+ uint32 program_len);
+extern int dhd_dev_apf_enable_filter(struct net_device *ndev);
+extern int dhd_dev_apf_disable_filter(struct net_device *ndev);
+extern int dhd_dev_apf_delete_filter(struct net_device *ndev);
+#endif /* PKT_FILTER_SUPPORT && APF */
+
+extern void dhd_timeout_start(dhd_timeout_t *tmo, uint usec);
+extern int dhd_timeout_expired(dhd_timeout_t *tmo);
+
+extern int dhd_ifname2idx(struct dhd_info *dhd, char *name);
+extern int dhd_net2idx(struct dhd_info *dhd, struct net_device *net);
+extern struct net_device * dhd_idx2net(void *pub, int ifidx);
+extern int net_os_send_hang_message(struct net_device *dev);
+extern int net_os_send_hang_message_reason(struct net_device *dev, const char *string_num);
+extern bool dhd_wowl_cap(void *bus);
+extern int wl_host_event(dhd_pub_t *dhd_pub, int *idx, void *pktdata, uint pktlen,
+ wl_event_msg_t *, void **data_ptr, void *);
+extern int wl_process_host_event(dhd_pub_t *dhd_pub, int *idx, void *pktdata, uint pktlen,
+ wl_event_msg_t *, void **data_ptr, void *);
+extern void wl_event_to_host_order(wl_event_msg_t * evt);
+extern int wl_host_event_get_data(void *pktdata, uint pktlen, bcm_event_msg_u_t *evu);
+extern int dhd_wl_ioctl(dhd_pub_t *dhd_pub, int ifindex, wl_ioctl_t *ioc, void *buf, int len);
+extern int dhd_wl_ioctl_cmd(dhd_pub_t *dhd_pub, int cmd, void *arg, int len, uint8 set,
+ int ifindex);
+extern int dhd_wl_ioctl_get_intiovar(dhd_pub_t *dhd_pub, char *name, uint *pval,
+ int cmd, uint8 set, int ifidx);
+extern int dhd_wl_ioctl_set_intiovar(dhd_pub_t *dhd_pub, char *name, uint val,
+ int cmd, uint8 set, int ifidx);
+extern void dhd_common_init(osl_t *osh);
+
+extern int dhd_do_driver_init(struct net_device *net);
+extern int dhd_event_ifadd(struct dhd_info *dhd, struct wl_event_data_if *ifevent,
+ char *name, uint8 *mac);
+extern int dhd_event_ifdel(struct dhd_info *dhd, struct wl_event_data_if *ifevent,
+ char *name, uint8 *mac);
+extern int dhd_event_ifchange(struct dhd_info *dhd, struct wl_event_data_if *ifevent,
+ char *name, uint8 *mac);
+extern struct net_device* dhd_allocate_if(dhd_pub_t *dhdpub, int ifidx, const char *name,
+ uint8 *mac, uint8 bssidx, bool need_rtnl_lock, const char *dngl_name);
+extern int dhd_remove_if(dhd_pub_t *dhdpub, int ifidx, bool need_rtnl_lock);
+#ifdef WL_STATIC_IF
+extern s32 dhd_update_iflist_info(dhd_pub_t *dhdp, struct net_device *ndev, int ifidx,
+ uint8 *mac, uint8 bssidx, const char *dngl_name, int if_state);
+#endif /* WL_STATIC_IF */
+extern void dhd_vif_add(struct dhd_info *dhd, int ifidx, char * name);
+extern void dhd_vif_del(struct dhd_info *dhd, int ifidx);
+extern void dhd_event(struct dhd_info *dhd, char *evpkt, int evlen, int ifidx);
+extern void dhd_vif_sendup(struct dhd_info *dhd, int ifidx, uchar *cp, int len);
+
+#ifdef WL_NATOE
+extern int dhd_natoe_ct_event(dhd_pub_t *dhd, char *data);
+#endif /* WL_NATOE */
+
+/* Send packet to dongle via data channel */
+extern int dhd_sendpkt(dhd_pub_t *dhdp, int ifidx, void *pkt);
+
+/* send up locally generated event */
+extern void dhd_sendup_event_common(dhd_pub_t *dhdp, wl_event_msg_t *event, void *data);
+/* Send event to host */
+extern void dhd_sendup_event(dhd_pub_t *dhdp, wl_event_msg_t *event, void *data);
+#ifdef LOG_INTO_TCPDUMP
+extern void dhd_sendup_log(dhd_pub_t *dhdp, void *data, int len);
+#endif /* LOG_INTO_TCPDUMP */
+#ifdef SHOW_LOGTRACE
+void dhd_sendup_info_buf(dhd_pub_t *dhdp, uint8 *msg);
+#endif // endif
+extern int dhd_bus_devreset(dhd_pub_t *dhdp, uint8 flag);
+extern uint dhd_bus_status(dhd_pub_t *dhdp);
+extern int dhd_bus_start(dhd_pub_t *dhdp);
+extern int dhd_bus_suspend(dhd_pub_t *dhdpub);
+extern int dhd_bus_resume(dhd_pub_t *dhdpub, int stage);
+extern int dhd_bus_membytes(dhd_pub_t *dhdp, bool set, uint32 address, uint8 *data, uint size);
+extern void dhd_print_buf(void *pbuf, int len, int bytes_per_line);
+extern bool dhd_is_associated(dhd_pub_t *dhd, uint8 ifidx, int *retval);
+#if defined(BCMSDIO) || defined(BCMPCIE)
+extern uint dhd_bus_chip_id(dhd_pub_t *dhdp);
+extern uint dhd_bus_chiprev_id(dhd_pub_t *dhdp);
+extern uint dhd_bus_chippkg_id(dhd_pub_t *dhdp);
+#endif /* defined(BCMSDIO) || defined(BCMPCIE) */
+int dhd_bus_get_fw_mode(dhd_pub_t *dhdp);
+
+#if defined(KEEP_ALIVE)
+extern int dhd_keep_alive_onoff(dhd_pub_t *dhd);
+#endif /* KEEP_ALIVE */
+
+/* OS spin lock API */
+extern void *dhd_os_spin_lock_init(osl_t *osh);
+extern void dhd_os_spin_lock_deinit(osl_t *osh, void *lock);
+extern unsigned long dhd_os_spin_lock(void *lock);
+void dhd_os_spin_unlock(void *lock, unsigned long flags);
+
+/* linux is defined for DHD EFI builds also,
+* since its cross-compiled for EFI from linux.
+* dbgring_lock apis are meant only for linux
+* to use mutexes, other OSes will continue to
+* use dhd_os_spin_lock
+*/
+void *dhd_os_dbgring_lock_init(osl_t *osh);
+void dhd_os_dbgring_lock_deinit(osl_t *osh, void *mtx);
+unsigned long dhd_os_dbgring_lock(void *lock);
+void dhd_os_dbgring_unlock(void *lock, unsigned long flags);
+
+static INLINE int dhd_os_tput_test_wait(dhd_pub_t *pub, uint *condition,
+ uint timeout_ms)
+{ return 0; }
+static INLINE int dhd_os_tput_test_wake(dhd_pub_t * pub)
+{ return 0; }
+
+extern int dhd_os_busbusy_wait_negation(dhd_pub_t * pub, uint * condition);
+extern int dhd_os_busbusy_wake(dhd_pub_t * pub);
+extern void dhd_os_tx_completion_wake(dhd_pub_t *dhd);
+extern int dhd_os_busbusy_wait_condition(dhd_pub_t *pub, uint *var, uint condition);
+int dhd_os_busbusy_wait_bitmask(dhd_pub_t *pub, uint *var,
+ uint bitmask, uint condition);
+extern int dhd_os_d3ack_wait(dhd_pub_t * pub, uint * condition);
+extern int dhd_os_d3ack_wake(dhd_pub_t * pub);
+extern int dhd_os_dmaxfer_wait(dhd_pub_t *pub, uint *condition);
+extern int dhd_os_dmaxfer_wake(dhd_pub_t *pub);
+
+/*
+ * Manage sta objects in an interface. Interface is identified by an ifindex and
+ * sta(s) within an interfaces are managed using a MacAddress of the sta.
+ */
+struct dhd_sta;
+extern bool dhd_sta_associated(dhd_pub_t *dhdp, uint32 bssidx, uint8 *mac);
+extern struct dhd_sta *dhd_find_sta(void *pub, int ifidx, void *ea);
+extern struct dhd_sta *dhd_findadd_sta(void *pub, int ifidx, void *ea);
+extern void dhd_del_all_sta(void *pub, int ifidx);
+extern void dhd_del_sta(void *pub, int ifidx, void *ea);
+extern int dhd_get_ap_isolate(dhd_pub_t *dhdp, uint32 idx);
+extern int dhd_set_ap_isolate(dhd_pub_t *dhdp, uint32 idx, int val);
+extern int dhd_bssidx2idx(dhd_pub_t *dhdp, uint32 bssidx);
+extern struct net_device *dhd_linux_get_primary_netdev(dhd_pub_t *dhdp);
+
+extern bool dhd_is_concurrent_mode(dhd_pub_t *dhd);
+int dhd_iovar(dhd_pub_t *pub, int ifidx, char *name, char *param_buf, uint param_len,
+ char *res_buf, uint res_len, int set);
+extern int dhd_getiovar(dhd_pub_t *pub, int ifidx, char *name, char *cmd_buf,
+ uint cmd_len, char **resptr, uint resp_len);
+
+#ifdef DHD_MCAST_REGEN
+extern int dhd_get_mcast_regen_bss_enable(dhd_pub_t *dhdp, uint32 idx);
+extern int dhd_set_mcast_regen_bss_enable(dhd_pub_t *dhdp, uint32 idx, int val);
+#endif // endif
+typedef enum cust_gpio_modes {
+ WLAN_RESET_ON,
+ WLAN_RESET_OFF,
+ WLAN_POWER_ON,
+ WLAN_POWER_OFF
+} cust_gpio_modes_t;
+
+typedef struct dmaxref_mem_map {
+ dhd_dma_buf_t *srcmem;
+ dhd_dma_buf_t *dstmem;
+} dmaxref_mem_map_t;
+
+#if defined(OEM_ANDROID)
+extern int wl_iw_iscan_set_scan_broadcast_prep(struct net_device *dev, uint flag);
+extern int wl_iw_send_priv_event(struct net_device *dev, char *flag);
+#endif /* defined(OEM_ANDROID) */
+
+#ifdef DHD_PCIE_NATIVE_RUNTIMEPM
+extern void dhd_flush_rx_tx_wq(dhd_pub_t *dhdp);
+#endif /* DHD_PCIE_NATIVE_RUNTIMEPM */
+
+/*
+ * Insmod parameters for debug/test
+ */
+
+/* Watchdog timer interval */
+extern uint dhd_watchdog_ms;
+#ifdef DHD_PCIE_RUNTIMEPM
+extern uint dhd_runtimepm_ms;
+#endif /* DHD_PCIE_RUNTIMEPM */
+
+/** Default console output poll interval */
+extern uint dhd_console_ms;
+
+#if defined(DHD_DEBUG)
+extern uint wl_msg_level;
+#endif /* defined(DHD_DEBUG) */
+
+extern uint dhd_slpauto;
+
+/* Use interrupts */
+extern uint dhd_intr;
+
+/* Use polling */
+extern uint dhd_poll;
+
+/* ARP offload agent mode */
+extern uint dhd_arp_mode;
+
+/* ARP offload enable */
+extern uint dhd_arp_enable;
+
+/* Pkt filte enable control */
+extern uint dhd_pkt_filter_enable;
+
+/* Pkt filter init setup */
+extern uint dhd_pkt_filter_init;
+
+/* Pkt filter mode control */
+extern uint dhd_master_mode;
+
+/* Roaming mode control */
+extern uint dhd_roam_disable;
+
+/* Roaming mode control */
+extern uint dhd_radio_up;
+
+/* TCM verification control */
+extern uint dhd_tcm_test_enable;
+
+/* Disable BUG_ON(1) */
+#ifdef DHD_FW_COREDUMP
+extern uint disable_bug_on;
+#endif /* DHD_FW_COREDUMP */
+
+/* Initial idletime ticks (may be -1 for immediate idle, 0 for no idle) */
+extern int dhd_idletime;
+#ifdef DHD_USE_IDLECOUNT
+#define DHD_IDLETIME_TICKS 5
+#else
+#define DHD_IDLETIME_TICKS 1
+#endif /* DHD_USE_IDLECOUNT */
+
+/* SDIO Drive Strength */
+extern uint dhd_sdiod_drive_strength;
+
+/* triggers bcm_bprintf to print to kernel log */
+extern bool bcm_bprintf_bypass;
+
+/* Override to force tx queueing all the time */
+extern uint dhd_force_tx_queueing;
+
+/* Default bcn_timeout value is 4 */
+#define DEFAULT_BCN_TIMEOUT_VALUE 4
+#ifndef CUSTOM_BCN_TIMEOUT_SETTING
+#define CUSTOM_BCN_TIMEOUT_SETTING DEFAULT_BCN_TIMEOUT_VALUE
+#endif // endif
+
+/* Default KEEP_ALIVE Period is 55 sec to prevent AP from sending Keep Alive probe frame */
+#define DEFAULT_KEEP_ALIVE_VALUE 55000 /* msec */
+#ifndef CUSTOM_KEEP_ALIVE_SETTING
+#define CUSTOM_KEEP_ALIVE_SETTING DEFAULT_KEEP_ALIVE_VALUE
+#endif /* DEFAULT_KEEP_ALIVE_VALUE */
+
+#define NULL_PKT_STR "null_pkt"
+
+/* hooks for custom glom setting option via Makefile */
+#define DEFAULT_GLOM_VALUE -1
+#ifndef CUSTOM_GLOM_SETTING
+#define CUSTOM_GLOM_SETTING DEFAULT_GLOM_VALUE
+#endif // endif
+#define WL_AUTO_ROAM_TRIGGER -75
+/* hooks for custom Roaming Trigger setting via Makefile */
+#define DEFAULT_ROAM_TRIGGER_VALUE -75 /* dBm default roam trigger all band */
+#define DEFAULT_ROAM_TRIGGER_SETTING -1
+#ifndef CUSTOM_ROAM_TRIGGER_SETTING
+#define CUSTOM_ROAM_TRIGGER_SETTING DEFAULT_ROAM_TRIGGER_VALUE
+#endif // endif
+
+/* hooks for custom Roaming Romaing setting via Makefile */
+#define DEFAULT_ROAM_DELTA_VALUE 10 /* dBm default roam delta all band */
+#define DEFAULT_ROAM_DELTA_SETTING -1
+#ifndef CUSTOM_ROAM_DELTA_SETTING
+#define CUSTOM_ROAM_DELTA_SETTING DEFAULT_ROAM_DELTA_VALUE
+#endif // endif
+
+/* hooks for custom PNO Event wake lock to guarantee enough time
+ for the Platform to detect Event before system suspended
+*/
+#define DEFAULT_PNO_EVENT_LOCK_xTIME 2 /* multiplay of DHD_PACKET_TIMEOUT_MS */
+#ifndef CUSTOM_PNO_EVENT_LOCK_xTIME
+#define CUSTOM_PNO_EVENT_LOCK_xTIME DEFAULT_PNO_EVENT_LOCK_xTIME
+#endif // endif
+/* hooks for custom dhd_dpc_prio setting option via Makefile */
+#define DEFAULT_DHP_DPC_PRIO 1
+#ifndef CUSTOM_DPC_PRIO_SETTING
+#define CUSTOM_DPC_PRIO_SETTING DEFAULT_DHP_DPC_PRIO
+#endif // endif
+
+#ifndef CUSTOM_LISTEN_INTERVAL
+#define CUSTOM_LISTEN_INTERVAL LISTEN_INTERVAL
+#endif /* CUSTOM_LISTEN_INTERVAL */
+
+#define DEFAULT_SUSPEND_BCN_LI_DTIM 3
+#ifndef CUSTOM_SUSPEND_BCN_LI_DTIM
+#define CUSTOM_SUSPEND_BCN_LI_DTIM DEFAULT_SUSPEND_BCN_LI_DTIM
+#endif // endif
+
+#ifdef OEM_ANDROID
+#ifndef BCN_TIMEOUT_IN_SUSPEND
+#define BCN_TIMEOUT_IN_SUSPEND 6 /* bcn timeout value in suspend mode */
+#endif // endif
+#endif /* OEM_ANDROID */
+
+#ifndef CUSTOM_RXF_PRIO_SETTING
+#define CUSTOM_RXF_PRIO_SETTING MAX((CUSTOM_DPC_PRIO_SETTING - 1), 1)
+#endif // endif
+
+#define DEFAULT_WIFI_TURNOFF_DELAY 0
+#ifndef WIFI_TURNOFF_DELAY
+#define WIFI_TURNOFF_DELAY DEFAULT_WIFI_TURNOFF_DELAY
+#endif /* WIFI_TURNOFF_DELAY */
+
+#define DEFAULT_WIFI_TURNON_DELAY 200
+#ifndef WIFI_TURNON_DELAY
+#define WIFI_TURNON_DELAY DEFAULT_WIFI_TURNON_DELAY
+#endif /* WIFI_TURNON_DELAY */
+
+#define DEFAULT_DHD_WATCHDOG_INTERVAL_MS 10 /* msec */
+#ifndef CUSTOM_DHD_WATCHDOG_MS
+#define CUSTOM_DHD_WATCHDOG_MS DEFAULT_DHD_WATCHDOG_INTERVAL_MS
+#endif /* DEFAULT_DHD_WATCHDOG_INTERVAL_MS */
+
+#define DEFAULT_ASSOC_RETRY_MAX 3
+#ifndef CUSTOM_ASSOC_RETRY_MAX
+#define CUSTOM_ASSOC_RETRY_MAX DEFAULT_ASSOC_RETRY_MAX
+#endif /* DEFAULT_ASSOC_RETRY_MAX */
+
+#if defined(BCMSDIO) || defined(DISABLE_FRAMEBURST)
+#define DEFAULT_FRAMEBURST_SET 0
+#else
+#define DEFAULT_FRAMEBURST_SET 1
+#endif /* BCMSDIO */
+
+#ifndef CUSTOM_FRAMEBURST_SET
+#define CUSTOM_FRAMEBURST_SET DEFAULT_FRAMEBURST_SET
+#endif /* CUSTOM_FRAMEBURST_SET */
+
+#ifdef WLTDLS
+#ifndef CUSTOM_TDLS_IDLE_MODE_SETTING
+#define CUSTOM_TDLS_IDLE_MODE_SETTING 60000 /* 60sec to tear down TDLS of not active */
+#endif // endif
+#ifndef CUSTOM_TDLS_RSSI_THRESHOLD_HIGH
+#define CUSTOM_TDLS_RSSI_THRESHOLD_HIGH -70 /* rssi threshold for establishing TDLS link */
+#endif // endif
+#ifndef CUSTOM_TDLS_RSSI_THRESHOLD_LOW
+#define CUSTOM_TDLS_RSSI_THRESHOLD_LOW -80 /* rssi threshold for tearing down TDLS link */
+#endif // endif
+#ifndef CUSTOM_TDLS_PCKTCNT_THRESHOLD_HIGH
+#define CUSTOM_TDLS_PCKTCNT_THRESHOLD_HIGH 100 /* pkt/sec threshold for establishing TDLS link */
+#endif // endif
+#ifndef CUSTOM_TDLS_PCKTCNT_THRESHOLD_LOW
+#define CUSTOM_TDLS_PCKTCNT_THRESHOLD_LOW 10 /* pkt/sec threshold for tearing down TDLS link */
+#endif // endif
+#endif /* WLTDLS */
+
+#if defined(VSDB) || defined(ROAM_ENABLE)
+#define DEFAULT_BCN_TIMEOUT 8
+#else
+#define DEFAULT_BCN_TIMEOUT 4
+#endif // endif
+
+#ifndef CUSTOM_BCN_TIMEOUT
+#define CUSTOM_BCN_TIMEOUT DEFAULT_BCN_TIMEOUT
+#endif // endif
+
+#define MAX_DTIM_SKIP_BEACON_INTERVAL 100 /* max allowed associated AP beacon for DTIM skip */
+#ifndef MAX_DTIM_ALLOWED_INTERVAL
+#define MAX_DTIM_ALLOWED_INTERVAL 600 /* max allowed total beacon interval for DTIM skip */
+#endif // endif
+
+#ifdef OEM_ANDROID
+#ifndef MIN_DTIM_FOR_ROAM_THRES_EXTEND
+#define MIN_DTIM_FOR_ROAM_THRES_EXTEND 600 /* minimum dtim interval to extend roam threshold */
+#endif // endif
+#endif /* OEM_ANDROID */
+
+#define NO_DTIM_SKIP 1
+#ifdef SDTEST
+/* Echo packet generator (SDIO), pkts/s */
+extern uint dhd_pktgen;
+
+/* Echo packet len (0 => sawtooth, max 1800) */
+extern uint dhd_pktgen_len;
+#define MAX_PKTGEN_LEN 1800
+#endif // endif
+
+/* optionally set by a module_param_string() */
+#define MOD_PARAM_PATHLEN 2048
+#define MOD_PARAM_INFOLEN 512
+#define MOD_PARAM_SRLEN 64
+
+#ifdef SOFTAP
+extern char fw_path2[MOD_PARAM_PATHLEN];
+#endif // endif
+
+#if defined(ANDROID_PLATFORM_VERSION)
+#if (ANDROID_PLATFORM_VERSION < 7)
+#define DHD_LEGACY_FILE_PATH
+#define VENDOR_PATH "/system"
+#elif (ANDROID_PLATFORM_VERSION == 7)
+#define VENDOR_PATH "/system"
+#elif (ANDROID_PLATFORM_VERSION >= 8)
+#define VENDOR_PATH "/vendor"
+#endif /* ANDROID_PLATFORM_VERSION < 7 */
+#else
+#define VENDOR_PATH ""
+#endif /* ANDROID_PLATFORM_VERSION */
+
+#if defined(ANDROID_PLATFORM_VERSION)
+#if (ANDROID_PLATFORM_VERSION < 9)
+#ifdef WL_STATIC_IF
+#undef WL_STATIC_IF
+#endif /* WL_STATIC_IF */
+#ifdef WL_STATIC_IFNAME_PREFIX
+#undef WL_STATIC_IFNAME_PREFIX
+#endif /* WL_STATIC_IFNAME_PREFIX */
+#endif /* ANDROID_PLATFORM_VERSION < 9 */
+#endif /* ANDROID_PLATFORM_VERSION */
+
+#if defined(DHD_LEGACY_FILE_PATH)
+#define PLATFORM_PATH "/data/"
+#elif defined(PLATFORM_SLP)
+#define PLATFORM_PATH "/opt/etc/"
+#else
+#if defined(ANDROID_PLATFORM_VERSION)
+#if (ANDROID_PLATFORM_VERSION >= 9)
+#define PLATFORM_PATH "/data/vendor/conn/"
+#define DHD_MAC_ADDR_EXPORT
+#define DHD_ADPS_BAM_EXPORT
+#define DHD_EXPORT_CNTL_FILE
+#define DHD_SOFTAP_DUAL_IF_INFO
+#define DHD_SEND_HANG_PRIVCMD_ERRORS
+#else
+#define PLATFORM_PATH "/data/misc/conn/"
+#endif /* ANDROID_PLATFORM_VERSION >= 9 */
+#else
+#define PLATFORM_PATH "/data/misc/conn/"
+#endif /* ANDROID_PLATFORM_VERSION */
+#endif /* DHD_LEGACY_FILE_PATH */
+
+#ifdef DHD_MAC_ADDR_EXPORT
+extern struct ether_addr sysfs_mac_addr;
+#endif /* DHD_MAC_ADDR_EXPORT */
+
+/* Flag to indicate if we should download firmware on driver load */
+extern uint dhd_download_fw_on_driverload;
+extern int allow_delay_fwdl;
+
+extern int dhd_process_cid_mac(dhd_pub_t *dhdp, bool prepost);
+extern int dhd_write_file(const char *filepath, char *buf, int buf_len);
+extern int dhd_read_file(const char *filepath, char *buf, int buf_len);
+extern int dhd_write_file_and_check(const char *filepath, char *buf, int buf_len);
+extern int dhd_file_delete(char *path);
+
+#ifdef READ_MACADDR
+extern int dhd_set_macaddr_from_file(dhd_pub_t *dhdp);
+#else
+static INLINE int dhd_set_macaddr_from_file(dhd_pub_t *dhdp) { return 0; }
+#endif /* READ_MACADDR */
+#ifdef WRITE_MACADDR
+extern int dhd_write_macaddr(struct ether_addr *mac);
+#else
+static INLINE int dhd_write_macaddr(struct ether_addr *mac) { return 0; }
+#endif /* WRITE_MACADDR */
+#ifdef USE_CID_CHECK
+#define MAX_VNAME_LEN 64
+#ifdef DHD_EXPORT_CNTL_FILE
+extern char cidinfostr[MAX_VNAME_LEN];
+#endif /* DHD_EXPORT_CNTL_FILE */
+extern int dhd_check_module_cid(dhd_pub_t *dhdp);
+extern char *dhd_get_cid_info(unsigned char *vid, int vid_length);
+#else
+static INLINE int dhd_check_module_cid(dhd_pub_t *dhdp) { return 0; }
+#endif /* USE_CID_CHECK */
+#ifdef GET_MAC_FROM_OTP
+extern int dhd_check_module_mac(dhd_pub_t *dhdp);
+#else
+static INLINE int dhd_check_module_mac(dhd_pub_t *dhdp) { return 0; }
+#endif /* GET_MAC_FROM_OTP */
+
+#if defined(READ_MACADDR) || defined(WRITE_MACADDR) || defined(USE_CID_CHECK) || \
+ defined(GET_MAC_FROM_OTP)
+#define DHD_USE_CISINFO
+#endif /* READ_MACADDR || WRITE_MACADDR || USE_CID_CHECK || GET_MAC_FROM_OTP */
+
+#ifdef DHD_USE_CISINFO
+int dhd_read_cis(dhd_pub_t *dhdp);
+void dhd_clear_cis(dhd_pub_t *dhdp);
+#if defined(SUPPORT_MULTIPLE_MODULE_CIS) && defined(USE_CID_CHECK)
+extern int dhd_check_module_b85a(void);
+extern int dhd_check_module_b90(void);
+#define BCM4359_MODULE_TYPE_B90B 1
+#define BCM4359_MODULE_TYPE_B90S 2
+#endif /* defined(SUPPORT_MULTIPLE_MODULE_CIS) && defined(USE_CID_CHECK) */
+#if defined(USE_CID_CHECK)
+extern int dhd_check_module_bcm(char *module_type, int index, bool *is_murata_fem);
+#endif /* defined(USE_CID_CHECK) */
+#else
+static INLINE int dhd_read_cis(dhd_pub_t *dhdp) { return 0; }
+static INLINE void dhd_clear_cis(dhd_pub_t *dhdp) { }
+#endif /* DHD_USE_CISINFO */
+
+#if defined(WL_CFG80211) && defined(SUPPORT_DEEP_SLEEP)
+/* Flags to indicate if we distingish power off policy when
+ * user set the memu "Keep Wi-Fi on during sleep" to "Never"
+ */
+extern int trigger_deep_sleep;
+int dhd_deepsleep(struct net_device *dev, int flag);
+#endif /* WL_CFG80211 && SUPPORT_DEEP_SLEEP */
+
+extern void dhd_wait_for_event(dhd_pub_t *dhd, bool *lockvar);
+extern void dhd_wait_event_wakeup(dhd_pub_t*dhd);
+
+#define IFLOCK_INIT(lock) *lock = 0
+#define IFLOCK(lock) while (InterlockedCompareExchange((lock), 1, 0)) \
+ NdisStallExecution(1);
+#define IFUNLOCK(lock) InterlockedExchange((lock), 0)
+#define IFLOCK_FREE(lock)
+#define FW_SUPPORTED(dhd, capa) ((strstr(dhd->fw_capabilities, " " #capa " ") != NULL))
+#ifdef ARP_OFFLOAD_SUPPORT
+#define MAX_IPV4_ENTRIES 8
+void dhd_arp_offload_set(dhd_pub_t * dhd, int arp_mode);
+void dhd_arp_offload_enable(dhd_pub_t * dhd, int arp_enable);
+
+/* dhd_commn arp offload wrapers */
+void dhd_aoe_hostip_clr(dhd_pub_t *dhd, int idx);
+void dhd_aoe_arp_clr(dhd_pub_t *dhd, int idx);
+int dhd_arp_get_arp_hostip_table(dhd_pub_t *dhd, void *buf, int buflen, int idx);
+void dhd_arp_offload_add_ip(dhd_pub_t *dhd, uint32 ipaddr, int idx);
+#endif /* ARP_OFFLOAD_SUPPORT */
+#ifdef WLTDLS
+int dhd_tdls_enable(struct net_device *dev, bool tdls_on, bool auto_on, struct ether_addr *mac);
+int dhd_tdls_set_mode(dhd_pub_t *dhd, bool wfd_mode);
+#ifdef PCIE_FULL_DONGLE
+int dhd_tdls_update_peer_info(dhd_pub_t *dhdp, wl_event_msg_t *event);
+int dhd_tdls_event_handler(dhd_pub_t *dhd_pub, wl_event_msg_t *event);
+int dhd_free_tdls_peer_list(dhd_pub_t *dhd_pub);
+#endif /* PCIE_FULL_DONGLE */
+#endif /* WLTDLS */
+
+/* Neighbor Discovery Offload Support */
+extern int dhd_ndo_enable(dhd_pub_t * dhd, int ndo_enable);
+int dhd_ndo_add_ip(dhd_pub_t *dhd, char* ipaddr, int idx);
+int dhd_ndo_remove_ip(dhd_pub_t *dhd, int idx);
+
+/* Enhanced ND offload support */
+uint16 dhd_ndo_get_version(dhd_pub_t *dhdp);
+int dhd_ndo_add_ip_with_type(dhd_pub_t *dhdp, char *ipv6addr, uint8 type, int idx);
+int dhd_ndo_remove_ip_by_addr(dhd_pub_t *dhdp, char *ipv6addr, int idx);
+int dhd_ndo_remove_ip_by_type(dhd_pub_t *dhdp, uint8 type, int idx);
+int dhd_ndo_unsolicited_na_filter_enable(dhd_pub_t *dhdp, int enable);
+
+/* ioctl processing for nl80211 */
+int dhd_ioctl_process(dhd_pub_t *pub, int ifidx, struct dhd_ioctl *ioc, void *data_buf);
+
+#if defined(SUPPORT_MULTIPLE_REVISION)
+extern int
+concate_revision(struct dhd_bus *bus, char *fwpath, char *nvpath);
+#endif /* SUPPORT_MULTIPLE_REVISION */
+void dhd_bus_update_fw_nv_path(struct dhd_bus *bus, char *pfw_path, char *pnv_path);
+void dhd_set_bus_state(void *bus, uint32 state);
+
+/* Remove proper pkts(either one no-frag pkt or whole fragmented pkts) */
+typedef int (*f_droppkt_t)(dhd_pub_t *dhdp, int prec, void* p, bool bPktInQ);
+extern bool dhd_prec_drop_pkts(dhd_pub_t *dhdp, struct pktq *pq, int prec, f_droppkt_t fn);
+
+#ifdef PROP_TXSTATUS
+int dhd_os_wlfc_block(dhd_pub_t *pub);
+int dhd_os_wlfc_unblock(dhd_pub_t *pub);
+extern const uint8 prio2fifo[];
+#endif /* PROP_TXSTATUS */
+
+int dhd_os_socram_dump(struct net_device *dev, uint32 *dump_size);
+int dhd_os_get_socram_dump(struct net_device *dev, char **buf, uint32 *size);
+int dhd_common_socram_dump(dhd_pub_t *dhdp);
+
+int dhd_dump(dhd_pub_t *dhdp, char *buf, int buflen);
+
+int dhd_os_get_version(struct net_device *dev, bool dhd_ver, char **buf, uint32 size);
+void dhd_get_memdump_filename(struct net_device *ndev, char *memdump_path, int len, char *fname);
+uint8* dhd_os_prealloc(dhd_pub_t *dhdpub, int section, uint size, bool kmalloc_if_fail);
+void dhd_os_prefree(dhd_pub_t *dhdpub, void *addr, uint size);
+
+#if defined(CONFIG_DHD_USE_STATIC_BUF)
+#define DHD_OS_PREALLOC(dhdpub, section, size) dhd_os_prealloc(dhdpub, section, size, FALSE)
+#define DHD_OS_PREFREE(dhdpub, addr, size) dhd_os_prefree(dhdpub, addr, size)
+#else
+#define DHD_OS_PREALLOC(dhdpub, section, size) MALLOC(dhdpub->osh, size)
+#define DHD_OS_PREFREE(dhdpub, addr, size) MFREE(dhdpub->osh, addr, size)
+#endif /* defined(CONFIG_DHD_USE_STATIC_BUF) */
+
+#ifdef USE_WFA_CERT_CONF
+enum {
+ SET_PARAM_BUS_TXGLOM_MODE,
+ SET_PARAM_ROAMOFF,
+#ifdef USE_WL_FRAMEBURST
+ SET_PARAM_FRAMEBURST,
+#endif /* USE_WL_FRAMEBURST */
+#ifdef USE_WL_TXBF
+ SET_PARAM_TXBF,
+#endif /* USE_WL_TXBF */
+#ifdef PROP_TXSTATUS
+ SET_PARAM_PROPTX,
+ SET_PARAM_PROPTXMODE,
+#endif /* PROP_TXSTATUS */
+ PARAM_LAST_VALUE
+};
+extern int sec_get_param_wfa_cert(dhd_pub_t *dhd, int mode, uint* read_val);
+#ifdef DHD_EXPORT_CNTL_FILE
+#define VALUENOTSET 0xFFFFFFFFu
+extern uint32 bus_txglom;
+extern uint32 roam_off;
+#ifdef USE_WL_FRAMEBURST
+extern uint32 frameburst;
+#endif /* USE_WL_FRAMEBURST */
+#ifdef USE_WL_TXBF
+extern uint32 txbf;
+#endif /* USE_WL_TXBF */
+#ifdef PROP_TXSTATUS
+extern uint32 proptx;
+#endif /* PROP_TXSTATUS */
+#endif /* DHD_EXPORT_CNTL_FILE */
+#endif /* USE_WFA_CERT_CONF */
+
+#define dhd_add_flowid(pub, ifidx, ac_prio, ea, flowid) do {} while (0)
+#define dhd_del_flowid(pub, ifidx, flowid) do {} while (0)
+bool dhd_wet_chainable(dhd_pub_t *dhdp);
+
+extern unsigned long dhd_os_general_spin_lock(dhd_pub_t *pub);
+extern void dhd_os_general_spin_unlock(dhd_pub_t *pub, unsigned long flags);
+
+/** Miscellaenous DHD Spin Locks */
+
+/* Disable router 3GMAC bypass path perimeter lock */
+#define DHD_PERIM_LOCK(dhdp) do {} while (0)
+#define DHD_PERIM_UNLOCK(dhdp) do {} while (0)
+#define DHD_PERIM_LOCK_ALL(processor_id) do {} while (0)
+#define DHD_PERIM_UNLOCK_ALL(processor_id) do {} while (0)
+
+/* Enable DHD general spin lock/unlock */
+#define DHD_GENERAL_LOCK(dhdp, flags) \
+ (flags) = dhd_os_general_spin_lock(dhdp)
+#define DHD_GENERAL_UNLOCK(dhdp, flags) \
+ dhd_os_general_spin_unlock((dhdp), (flags))
+
+/* Enable DHD timer spin lock/unlock */
+#define DHD_TIMER_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_TIMER_UNLOCK(lock, flags) dhd_os_spin_unlock(lock, (flags))
+
+/* Enable DHD flowring spin lock/unlock */
+#define DHD_FLOWRING_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_FLOWRING_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+/* Enable DHD common flowring info spin lock/unlock */
+#define DHD_FLOWID_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_FLOWID_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+/* Enable DHD common flowring list spin lock/unlock */
+#define DHD_FLOWRING_LIST_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_FLOWRING_LIST_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+#define DHD_SPIN_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_SPIN_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+#define DHD_RING_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_RING_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+#define DHD_BUS_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_BUS_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+/* Enable DHD backplane spin lock/unlock */
+#define DHD_BACKPLANE_ACCESS_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_BACKPLANE_ACCESS_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+#define DHD_BUS_INB_DW_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_BUS_INB_DW_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+/* Enable DHD TDLS peer list spin lock/unlock */
+#ifdef WLTDLS
+#define DHD_TDLS_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_TDLS_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+#endif /* WLTDLS */
+
+#define DHD_BUS_INB_DW_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_BUS_INB_DW_UNLOCK(lock, flags) dhd_os_spin_unlock((lock), (flags))
+
+#ifdef DBG_PKT_MON
+/* Enable DHD PKT MON spin lock/unlock */
+#define DHD_PKT_MON_LOCK(lock, flags) (flags) = dhd_os_spin_lock(lock)
+#define DHD_PKT_MON_UNLOCK(lock, flags) dhd_os_spin_unlock(lock, (flags))
+#endif /* DBG_PKT_MON */
+
+#define DHD_LINUX_GENERAL_LOCK(dhdp, flags) DHD_GENERAL_LOCK(dhdp, flags)
+#define DHD_LINUX_GENERAL_UNLOCK(dhdp, flags) DHD_GENERAL_UNLOCK(dhdp, flags)
+
+/* linux is defined for DHD EFI builds also,
+* since its cross-compiled for EFI from linux
+*/
+#define DHD_DBG_RING_LOCK_INIT(osh) dhd_os_dbgring_lock_init(osh)
+#define DHD_DBG_RING_LOCK_DEINIT(osh, lock) dhd_os_dbgring_lock_deinit(osh, (lock))
+#define DHD_DBG_RING_LOCK(lock, flags) (flags) = dhd_os_dbgring_lock(lock)
+#define DHD_DBG_RING_UNLOCK(lock, flags) dhd_os_dbgring_unlock((lock), flags)
+
+extern void dhd_dump_to_kernelog(dhd_pub_t *dhdp);
+
+extern void dhd_print_tasklet_status(dhd_pub_t *dhd);
+
+#ifdef DHD_L2_FILTER
+extern int dhd_get_parp_status(dhd_pub_t *dhdp, uint32 idx);
+extern int dhd_set_parp_status(dhd_pub_t *dhdp, uint32 idx, int val);
+extern int dhd_get_dhcp_unicast_status(dhd_pub_t *dhdp, uint32 idx);
+extern int dhd_set_dhcp_unicast_status(dhd_pub_t *dhdp, uint32 idx, int val);
+extern int dhd_get_block_ping_status(dhd_pub_t *dhdp, uint32 idx);
+extern int dhd_set_block_ping_status(dhd_pub_t *dhdp, uint32 idx, int val);
+extern int dhd_get_grat_arp_status(dhd_pub_t *dhdp, uint32 idx);
+extern int dhd_set_grat_arp_status(dhd_pub_t *dhdp, uint32 idx, int val);
+extern int dhd_get_block_tdls_status(dhd_pub_t *dhdp, uint32 idx);
+extern int dhd_set_block_tdls_status(dhd_pub_t *dhdp, uint32 idx, int val);
+#endif /* DHD_L2_FILTER */
+
+typedef struct wl_io_pport {
+ dhd_pub_t *dhd_pub;
+ uint ifidx;
+} wl_io_pport_t;
+
+typedef struct wl_evt_pport {
+ dhd_pub_t *dhd_pub;
+ int *ifidx;
+ void *pktdata;
+ uint data_len;
+ void **data_ptr;
+ void *raw_event;
+} wl_evt_pport_t;
+
+extern void *dhd_pub_shim(dhd_pub_t *dhd_pub);
+#ifdef DHD_FW_COREDUMP
+void* dhd_get_fwdump_buf(dhd_pub_t *dhd_pub, uint32 length);
+#endif /* DHD_FW_COREDUMP */
+
+#if defined(SET_RPS_CPUS)
+int dhd_rps_cpus_enable(struct net_device *net, int enable);
+int custom_rps_map_set(struct netdev_rx_queue *queue, char *buf, size_t len);
+void custom_rps_map_clear(struct netdev_rx_queue *queue);
+#define PRIMARY_INF 0
+#define VIRTUAL_INF 1
+#if defined(CONFIG_MACH_UNIVERSAL5433) || defined(CONFIG_MACH_UNIVERSAL7420) || \
+ defined(CONFIG_SOC_EXYNOS8890)
+#define RPS_CPUS_MASK "10"
+#define RPS_CPUS_MASK_P2P "10"
+#define RPS_CPUS_MASK_IBSS "10"
+#define RPS_CPUS_WLAN_CORE_ID 4
+#else
+#define RPS_CPUS_MASK "6"
+#define RPS_CPUS_MASK_P2P "6"
+#define RPS_CPUS_MASK_IBSS "6"
+#endif /* CONFIG_MACH_UNIVERSAL5433 || CONFIG_MACH_UNIVERSAL7420 || CONFIG_SOC_EXYNOS8890 */
+#endif // endif
+
+int dhd_get_download_buffer(dhd_pub_t *dhd, char *file_path, download_type_t component,
+ char ** buffer, int *length);
+
+void dhd_free_download_buffer(dhd_pub_t *dhd, void *buffer, int length);
+
+int dhd_download_blob(dhd_pub_t *dhd, unsigned char *buf,
+ uint32 len, char *iovar);
+
+int dhd_download_blob_cached(dhd_pub_t *dhd, char *file_path,
+ uint32 len, char *iovar);
+
+int dhd_apply_default_txcap(dhd_pub_t *dhd, char *txcap_path);
+int dhd_apply_default_clm(dhd_pub_t *dhd, char *clm_path);
+
+#ifdef SHOW_LOGTRACE
+int dhd_parse_logstrs_file(osl_t *osh, char *raw_fmts, int logstrs_size,
+ dhd_event_log_t *event_log);
+int dhd_parse_map_file(osl_t *osh, void *file, uint32 *ramstart,
+ uint32 *rodata_start, uint32 *rodata_end);
+#ifdef PCIE_FULL_DONGLE
+int dhd_event_logtrace_infobuf_pkt_process(dhd_pub_t *dhdp, void *pktbuf,
+ dhd_event_log_t *event_data);
+#endif /* PCIE_FULL_DONGLE */
+#endif /* SHOW_LOGTRACE */
+
+#define dhd_is_device_removed(x) FALSE
+#define dhd_os_ind_firmware_stall(x)
+
+#if defined(DHD_FW_COREDUMP)
+extern void dhd_get_memdump_info(dhd_pub_t *dhd);
+#endif /* defined(DHD_FW_COREDUMP) */
+#ifdef BCMASSERT_LOG
+extern void dhd_get_assert_info(dhd_pub_t *dhd);
+#else
+static INLINE void dhd_get_assert_info(dhd_pub_t *dhd) { }
+#endif /* BCMASSERT_LOG */
+
+#define DMAXFER_FREE(dhdp, dmap) dhd_schedule_dmaxfer_free(dhdp, dmap);
+
+#if defined(PCIE_FULL_DONGLE)
+extern void dmaxfer_free_prev_dmaaddr(dhd_pub_t *dhdp, dmaxref_mem_map_t *dmmap);
+void dhd_schedule_dmaxfer_free(dhd_pub_t *dhdp, dmaxref_mem_map_t *dmmap);
+#endif /* PCIE_FULL_DONGLE */
+
+#define DHD_LB_STATS_NOOP do { /* noop */ } while (0)
+#if defined(DHD_LB_STATS)
+#include <bcmutils.h>
+extern void dhd_lb_stats_init(dhd_pub_t *dhd);
+extern void dhd_lb_stats_deinit(dhd_pub_t *dhd);
+extern void dhd_lb_stats_dump(dhd_pub_t *dhdp, struct bcmstrbuf *strbuf);
+extern void dhd_lb_stats_update_napi_histo(dhd_pub_t *dhdp, uint32 count);
+extern void dhd_lb_stats_update_txc_histo(dhd_pub_t *dhdp, uint32 count);
+extern void dhd_lb_stats_update_rxc_histo(dhd_pub_t *dhdp, uint32 count);
+extern void dhd_lb_stats_txc_percpu_cnt_incr(dhd_pub_t *dhdp);
+extern void dhd_lb_stats_rxc_percpu_cnt_incr(dhd_pub_t *dhdp);
+#define DHD_LB_STATS_INIT(dhdp) dhd_lb_stats_init(dhdp)
+#define DHD_LB_STATS_DEINIT(dhdp) dhd_lb_stats_deinit(dhdp)
+/* Reset is called from common layer so it takes dhd_pub_t as argument */
+#define DHD_LB_STATS_RESET(dhdp) dhd_lb_stats_init(dhdp)
+#define DHD_LB_STATS_CLR(x) (x) = 0U
+#define DHD_LB_STATS_INCR(x) (x) = (x) + 1
+#define DHD_LB_STATS_ADD(x, c) (x) = (x) + (c)
+#define DHD_LB_STATS_PERCPU_ARR_INCR(x) \
+ { \
+ int cpu = get_cpu(); put_cpu(); \
+ DHD_LB_STATS_INCR(x[cpu]); \
+ }
+#define DHD_LB_STATS_UPDATE_NAPI_HISTO(dhdp, x) dhd_lb_stats_update_napi_histo(dhdp, x)
+#define DHD_LB_STATS_UPDATE_TXC_HISTO(dhdp, x) dhd_lb_stats_update_txc_histo(dhdp, x)
+#define DHD_LB_STATS_UPDATE_RXC_HISTO(dhdp, x) dhd_lb_stats_update_rxc_histo(dhdp, x)
+#define DHD_LB_STATS_TXC_PERCPU_CNT_INCR(dhdp) dhd_lb_stats_txc_percpu_cnt_incr(dhdp)
+#define DHD_LB_STATS_RXC_PERCPU_CNT_INCR(dhdp) dhd_lb_stats_rxc_percpu_cnt_incr(dhdp)
+#else /* !DHD_LB_STATS */
+#define DHD_LB_STATS_INIT(dhdp) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_DEINIT(dhdp) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_RESET(dhdp) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_CLR(x) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_INCR(x) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_ADD(x, c) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_PERCPU_ARR_INCR(x) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_UPDATE_NAPI_HISTO(dhd, x) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_UPDATE_TXC_HISTO(dhd, x) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_UPDATE_RXC_HISTO(dhd, x) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_TXC_PERCPU_CNT_INCR(dhdp) DHD_LB_STATS_NOOP
+#define DHD_LB_STATS_RXC_PERCPU_CNT_INCR(dhdp) DHD_LB_STATS_NOOP
+#endif /* !DHD_LB_STATS */
+
+#ifdef DHD_SSSR_DUMP
+#define DHD_SSSR_MEMPOOL_SIZE (2 * 1024 * 1024) /* 2MB size */
+
+/* used in sssr_dump_mode */
+#define SSSR_DUMP_MODE_SSSR 0 /* dump both *before* and *after* files */
+#define SSSR_DUMP_MODE_FIS 1 /* dump *after* files only */
+
+extern int dhd_sssr_mempool_init(dhd_pub_t *dhd);
+extern void dhd_sssr_mempool_deinit(dhd_pub_t *dhd);
+extern int dhd_sssr_dump_init(dhd_pub_t *dhd);
+extern void dhd_sssr_dump_deinit(dhd_pub_t *dhd);
+extern int dhdpcie_sssr_dump(dhd_pub_t *dhd);
+extern void dhd_sssr_print_filepath(dhd_pub_t *dhd, char *path);
+
+#define DHD_SSSR_MEMPOOL_INIT(dhdp) dhd_sssr_mempool_init(dhdp)
+#define DHD_SSSR_MEMPOOL_DEINIT(dhdp) dhd_sssr_mempool_deinit(dhdp)
+#define DHD_SSSR_DUMP_INIT(dhdp) dhd_sssr_dump_init(dhdp)
+#define DHD_SSSR_DUMP_DEINIT(dhdp) dhd_sssr_dump_deinit(dhdp)
+#define DHD_SSSR_PRINT_FILEPATH(dhdp, path) dhd_sssr_print_filepath(dhdp, path)
+#else
+#define DHD_SSSR_MEMPOOL_INIT(dhdp) do { /* noop */ } while (0)
+#define DHD_SSSR_MEMPOOL_DEINIT(dhdp) do { /* noop */ } while (0)
+#define DHD_SSSR_DUMP_INIT(dhdp) do { /* noop */ } while (0)
+#define DHD_SSSR_DUMP_DEINIT(dhdp) do { /* noop */ } while (0)
+#define DHD_SSSR_PRINT_FILEPATH(dhdp, path) do { /* noop */ } while (0)
+#endif /* DHD_SSSR_DUMP */
+
+#ifdef BCMPCIE
+extern int dhd_prot_debug_info_print(dhd_pub_t *dhd);
+extern bool dhd_bus_skip_clm(dhd_pub_t *dhdp);
+extern void dhd_pcie_dump_rc_conf_space_cap(dhd_pub_t *dhd);
+extern bool dhd_pcie_dump_int_regs(dhd_pub_t *dhd);
+#else
+#define dhd_prot_debug_info_print(x)
+static INLINE bool dhd_bus_skip_clm(dhd_pub_t *dhd_pub)
+{ return 0; }
+#endif /* BCMPCIE */
+
+fw_download_status_t dhd_fw_download_status(dhd_pub_t * dhd_pub);
+void dhd_show_kirqstats(dhd_pub_t *dhd);
+
+/* Bitmask used for Join Timeout */
+#define WLC_SSID_MASK 0x01
+#define WLC_WPA_MASK 0x02
+
+extern int dhd_start_join_timer(dhd_pub_t *pub);
+extern int dhd_stop_join_timer(dhd_pub_t *pub);
+extern int dhd_start_scan_timer(dhd_pub_t *pub, bool is_escan);
+extern int dhd_stop_scan_timer(dhd_pub_t *pub, bool is_escan, uint16 sync_id);
+extern int dhd_start_cmd_timer(dhd_pub_t *pub);
+extern int dhd_stop_cmd_timer(dhd_pub_t *pub);
+extern int dhd_start_bus_timer(dhd_pub_t *pub);
+extern int dhd_stop_bus_timer(dhd_pub_t *pub);
+extern uint16 dhd_get_request_id(dhd_pub_t *pub);
+extern int dhd_set_request_id(dhd_pub_t *pub, uint16 id, uint32 cmd);
+extern void dhd_set_join_error(dhd_pub_t *pub, uint32 mask);
+extern void dhd_clear_join_error(dhd_pub_t *pub, uint32 mask);
+extern void dhd_get_scan_to_val(dhd_pub_t *pub, uint32 *to_val);
+extern void dhd_set_scan_to_val(dhd_pub_t *pub, uint32 to_val);
+extern void dhd_get_join_to_val(dhd_pub_t *pub, uint32 *to_val);
+extern void dhd_set_join_to_val(dhd_pub_t *pub, uint32 to_val);
+extern void dhd_get_cmd_to_val(dhd_pub_t *pub, uint32 *to_val);
+extern void dhd_set_cmd_to_val(dhd_pub_t *pub, uint32 to_val);
+extern void dhd_get_bus_to_val(dhd_pub_t *pub, uint32 *to_val);
+extern void dhd_set_bus_to_val(dhd_pub_t *pub, uint32 to_val);
+extern int dhd_start_timesync_timer(dhd_pub_t *pub);
+extern int dhd_stop_timesync_timer(dhd_pub_t *pub);
+
+#ifdef DHD_PKTID_AUDIT_ENABLED
+void dhd_pktid_error_handler(dhd_pub_t *dhdp);
+#endif /* DHD_PKTID_AUDIT_ENABLED */
+
+#ifdef DHD_MAP_PKTID_LOGGING
+extern void dhd_pktid_logging_dump(dhd_pub_t *dhdp);
+#endif /* DHD_MAP_PKTID_LOGGING */
+
+#ifdef DHD_PCIE_RUNTIMEPM
+extern bool dhd_runtimepm_state(dhd_pub_t *dhd);
+extern bool dhd_runtime_bus_wake(struct dhd_bus *bus, bool wait, void *func_addr);
+extern bool dhdpcie_runtime_bus_wake(dhd_pub_t *dhdp, bool wait, void *func_addr);
+extern void dhdpcie_block_runtime_pm(dhd_pub_t *dhdp);
+extern bool dhdpcie_is_resume_done(dhd_pub_t *dhdp);
+extern void dhd_runtime_pm_disable(dhd_pub_t *dhdp);
+extern void dhd_runtime_pm_enable(dhd_pub_t *dhdp);
+/* Disable the Runtime PM and wake up if the bus is already in suspend */
+#define DHD_DISABLE_RUNTIME_PM(dhdp) \
+do { \
+ dhd_runtime_pm_disable(dhdp); \
+} while (0);
+
+/* Enable the Runtime PM */
+#define DHD_ENABLE_RUNTIME_PM(dhdp) \
+do { \
+ dhd_runtime_pm_enable(dhdp); \
+} while (0);
+#else
+#define DHD_DISABLE_RUNTIME_PM(dhdp)
+#define DHD_ENABLE_RUNTIME_PM(dhdp)
+#endif /* DHD_PCIE_RUNTIMEPM */
+
+#ifdef REVERSE_AIFSN
+extern int check_reverse_aifsn_condition(dhd_pub_t *dhdp, struct net_device *ndev);
+
+#define DHD_REVERSE_AIFSN(dhdp, ndev) \
+do { \
+ check_reverse_aifsn_condition(dhdp, ndev); \
+} while (0);
+#else
+#define DHD_REVERSE_AIFSN(dhdp, ndev)
+#endif /* AIFSN_REVERSE */
+
+extern bool dhd_prot_is_cmpl_ring_empty(dhd_pub_t *dhd, void *prot_info);
+extern void dhd_prot_dump_ring_ptrs(void *prot_info);
+
+#if defined(DHD_TRACE_WAKE_LOCK)
+void dhd_wk_lock_stats_dump(dhd_pub_t *dhdp);
+#endif // endif
+
+extern bool dhd_query_bus_erros(dhd_pub_t *dhdp);
+void dhd_clear_bus_errors(dhd_pub_t *dhdp);
+
+#if defined(CONFIG_64BIT)
+#define DHD_SUPPORT_64BIT
+#endif /* (linux || LINUX) && CONFIG_64BIT */
+
+#if defined(DHD_ERPOM)
+extern void dhd_schedule_reset(dhd_pub_t *dhdp);
+#else
+static INLINE void dhd_schedule_reset(dhd_pub_t *dhdp) {;}
+#endif // endif
+
+extern void init_dhd_timeouts(dhd_pub_t *pub);
+extern void deinit_dhd_timeouts(dhd_pub_t *pub);
+
+typedef enum timeout_resons {
+ DHD_REASON_COMMAND_TO,
+ DHD_REASON_JOIN_TO,
+ DHD_REASON_SCAN_TO,
+ DHD_REASON_OQS_TO
+} timeout_reasons_t;
+
+extern void dhd_prhex(const char *msg, volatile uchar *buf, uint nbytes, uint8 dbg_level);
+int dhd_tput_test(dhd_pub_t *dhd, tput_test_t *tput_data);
+void dhd_tput_test_rx(dhd_pub_t *dhd, void *pkt);
+static INLINE int dhd_get_max_txbufs(dhd_pub_t *dhdp)
+{ return -1; }
+
+#ifdef FILTER_IE
+int dhd_read_from_file(dhd_pub_t *dhd);
+int dhd_parse_filter_ie(dhd_pub_t *dhd, uint8 *buf);
+int dhd_get_filter_ie_count(dhd_pub_t *dhd, uint8 *buf);
+int dhd_parse_oui(dhd_pub_t *dhd, uint8 *inbuf, uint8 *oui, int len);
+int dhd_check_valid_ie(dhd_pub_t *dhdp, uint8 *buf, int len);
+#endif /* FILTER_IE */
+
+uint16 dhd_prot_get_ioctl_trans_id(dhd_pub_t *dhdp);
+
+#ifdef SET_PCIE_IRQ_CPU_CORE
+enum {
+ PCIE_IRQ_AFFINITY_OFF = 0,
+ PCIE_IRQ_AFFINITY_BIG_CORE_ANY,
+ PCIE_IRQ_AFFINITY_BIG_CORE_EXYNOS,
+ PCIE_IRQ_AFFINITY_LAST
+};
+extern void dhd_set_irq_cpucore(dhd_pub_t *dhdp, int affinity_cmd);
+#endif /* SET_PCIE_IRQ_CPU_CORE */
+
+#if defined(DHD_HANG_SEND_UP_TEST)
+extern void dhd_make_hang_with_reason(struct net_device *dev, const char *string_num);
+#endif /* DHD_HANG_SEND_UP_TEST */
+
+#ifdef DHD_RND_DEBUG
+int dhd_dump_rnd_info(dhd_pub_t *dhd, uint8 *rnd_buf, uint32 rnd_len);
+int dhd_get_rnd_info(dhd_pub_t *dhd);
+#endif /* DHD_RND_DEBUG */
+
+#ifdef DHD_WAKE_STATUS
+wake_counts_t* dhd_get_wakecount(dhd_pub_t *dhdp);
+#endif /* DHD_WAKE_STATUS */
+extern int dhd_get_random_bytes(uint8 *buf, uint len);
+#if defined(DHD_BLOB_EXISTENCE_CHECK)
+extern void dhd_set_blob_support(dhd_pub_t *dhdp, char *fw_path);
+#endif /* DHD_BLOB_EXISTENCE_CHECK */
+
+/* configuration of ecounters. API's tp start/stop. currently supported only for linux */
+extern int dhd_ecounter_configure(dhd_pub_t *dhd, bool enable);
+extern int dhd_start_ecounters(dhd_pub_t *dhd);
+extern int dhd_stop_ecounters(dhd_pub_t *dhd);
+extern int dhd_start_event_ecounters(dhd_pub_t *dhd);
+extern int dhd_stop_event_ecounters(dhd_pub_t *dhd);
+
+int dhd_get_preserve_log_numbers(dhd_pub_t *dhd, uint32 *logset_mask);
+
+#ifdef DHD_LOG_DUMP
+void dhd_schedule_log_dump(dhd_pub_t *dhdp, void *type);
+void dhd_log_dump_trigger(dhd_pub_t *dhdp, int subcmd);
+int dhd_log_dump_ring_to_file(dhd_pub_t *dhdp, void *ring_ptr, void *file,
+ unsigned long *file_posn, log_dump_section_hdr_t *sec_hdr, char *text_hdr,
+ uint32 sec_type);
+int dhd_dump_debug_ring(dhd_pub_t *dhdp, void *ring_ptr, const void *user_buf,
+ log_dump_section_hdr_t *sec_hdr, char *text_hdr, int buflen, uint32 sec_type);
+int dhd_log_dump_cookie_to_file(dhd_pub_t *dhdp, void *fp,
+ const void *user_buf, unsigned long *f_pos);
+int dhd_log_dump_cookie(dhd_pub_t *dhdp, const void *user_buf);
+uint32 dhd_log_dump_cookie_len(dhd_pub_t *dhdp);
+int dhd_logdump_cookie_init(dhd_pub_t *dhdp, uint8 *buf, uint32 buf_size);
+void dhd_logdump_cookie_deinit(dhd_pub_t *dhdp);
+void dhd_logdump_cookie_save(dhd_pub_t *dhdp, char *cookie, char *type);
+int dhd_logdump_cookie_get(dhd_pub_t *dhdp, char *ret_cookie, uint32 buf_size);
+int dhd_logdump_cookie_count(dhd_pub_t *dhdp);
+int dhd_get_dld_log_dump(void *dev, dhd_pub_t *dhdp, const void *user_buf, void *fp,
+ uint32 len, int type, void *pos);
+int dhd_print_ext_trap_data(void *dev, dhd_pub_t *dhdp, const void *user_buf,
+ void *fp, uint32 len, void *pos);
+int dhd_print_dump_data(void *dev, dhd_pub_t *dhdp, const void *user_buf,
+ void *fp, uint32 len, void *pos);
+int dhd_print_cookie_data(void *dev, dhd_pub_t *dhdp, const void *user_buf,
+ void *fp, uint32 len, void *pos);
+int dhd_print_health_chk_data(void *dev, dhd_pub_t *dhdp, const void *user_buf,
+ void *fp, uint32 len, void *pos);
+int dhd_print_time_str(const void *user_buf, void *fp, uint32 len, void *pos);
+#ifdef DHD_DUMP_PCIE_RINGS
+int dhd_print_flowring_data(void *dev, dhd_pub_t *dhdp, const void *user_buf,
+ void *fp, uint32 len, void *pos);
+uint32 dhd_get_flowring_len(void *ndev, dhd_pub_t *dhdp);
+#endif /* DHD_DUMP_PCIE_RINGS */
+#ifdef DHD_STATUS_LOGGING
+extern int dhd_print_status_log_data(void *dev, dhd_pub_t *dhdp,
+ const void *user_buf, void *fp, uint32 len, void *pos);
+extern uint32 dhd_get_status_log_len(void *ndev, dhd_pub_t *dhdp);
+#endif /* DHD_STATUS_LOGGING */
+int dhd_print_ecntrs_data(void *dev, dhd_pub_t *dhdp, const void *user_buf,
+ void *fp, uint32 len, void *pos);
+int dhd_print_rtt_data(void *dev, dhd_pub_t *dhdp, const void *user_buf,
+ void *fp, uint32 len, void *pos);
+int dhd_get_debug_dump_file_name(void *dev, dhd_pub_t *dhdp,
+ char *dump_path, int size);
+uint32 dhd_get_ext_trap_len(void *ndev, dhd_pub_t *dhdp);
+uint32 dhd_get_time_str_len(void);
+uint32 dhd_get_health_chk_len(void *ndev, dhd_pub_t *dhdp);
+uint32 dhd_get_dhd_dump_len(void *ndev, dhd_pub_t *dhdp);
+uint32 dhd_get_cookie_log_len(void *ndev, dhd_pub_t *dhdp);
+uint32 dhd_get_ecntrs_len(void *ndev, dhd_pub_t *dhdp);
+uint32 dhd_get_rtt_len(void *ndev, dhd_pub_t *dhdp);
+uint32 dhd_get_dld_len(int log_type);
+void dhd_init_sec_hdr(log_dump_section_hdr_t *sec_hdr);
+extern char *dhd_log_dump_get_timestamp(void);
+bool dhd_log_dump_ecntr_enabled(void);
+bool dhd_log_dump_rtt_enabled(void);
+void dhd_nla_put_sssr_dump_len(void *ndev, uint32 *arr_len);
+int dhd_get_debug_dump(void *dev, const void *user_buf, uint32 len, int type);
+int
+dhd_sssr_dump_d11_buf_before(void *dev, const void *user_buf, uint32 len, int core);
+int
+dhd_sssr_dump_d11_buf_after(void *dev, const void *user_buf, uint32 len, int core);
+int
+dhd_sssr_dump_dig_buf_before(void *dev, const void *user_buf, uint32 len);
+int
+dhd_sssr_dump_dig_buf_after(void *dev, const void *user_buf, uint32 len);
+#ifdef DHD_PKT_LOGGING
+extern int dhd_os_get_pktlog_dump(void *dev, const void *user_buf, uint32 len);
+extern uint32 dhd_os_get_pktlog_dump_size(struct net_device *dev);
+extern void dhd_os_get_pktlogdump_filename(struct net_device *dev, char *dump_path, int len);
+#endif /* DHD_PKT_LOGGING */
+
+#ifdef DNGL_AXI_ERROR_LOGGING
+extern int dhd_os_get_axi_error_dump(void *dev, const void *user_buf, uint32 len);
+extern int dhd_os_get_axi_error_dump_size(struct net_device *dev);
+extern void dhd_os_get_axi_error_filename(struct net_device *dev, char *dump_path, int len);
+#endif /* DNGL_AXI_ERROR_LOGGING */
+
+#endif /* DHD_LOG_DUMP */
+int dhd_export_debug_data(void *mem_buf, void *fp, const void *user_buf, int buf_len, void *pos);
+#define DHD_PCIE_CONFIG_SAVE(bus) pci_save_state(bus->dev)
+#define DHD_PCIE_CONFIG_RESTORE(bus) pci_restore_state(bus->dev)
+
+#ifdef BIGDATA_SOFTAP
+void dhd_schedule_gather_ap_stadata(void *bcm_cfg, void *ndev, const wl_event_msg_t *e);
+#endif /* BIGDATA_SOFTAP */
+
+typedef struct dhd_pkt_parse {
+ uint32 proto; /* Network layer protocol */
+ uint32 t1; /* n-tuple */
+ uint32 t2;
+} dhd_pkt_parse_t;
+
+/* ========= RING API functions : exposed to others ============= */
+#define DHD_RING_TYPE_FIXED 1
+#define DHD_RING_TYPE_SINGLE_IDX 2
+uint32 dhd_ring_get_hdr_size(void);
+void *dhd_ring_init(dhd_pub_t *dhdp, uint8 *buf, uint32 buf_size, uint32 elem_size,
+ uint32 elem_cnt, uint32 type);
+void dhd_ring_deinit(dhd_pub_t *dhdp, void *_ring);
+void *dhd_ring_get_first(void *_ring);
+void dhd_ring_free_first(void *_ring);
+void dhd_ring_set_read_idx(void *_ring, uint32 read_idx);
+void dhd_ring_set_write_idx(void *_ring, uint32 write_idx);
+uint32 dhd_ring_get_read_idx(void *_ring);
+uint32 dhd_ring_get_write_idx(void *_ring);
+void *dhd_ring_get_last(void *_ring);
+void *dhd_ring_get_next(void *_ring, void *cur);
+void *dhd_ring_get_prev(void *_ring, void *cur);
+void *dhd_ring_get_empty(void *_ring);
+int dhd_ring_get_cur_size(void *_ring);
+void dhd_ring_lock(void *ring, void *fist_ptr, void *last_ptr);
+void dhd_ring_lock_free(void *ring);
+void *dhd_ring_lock_get_first(void *_ring);
+void *dhd_ring_lock_get_last(void *_ring);
+int dhd_ring_lock_get_count(void *_ring);
+void dhd_ring_lock_free_first(void *ring);
+void dhd_ring_whole_lock(void *ring);
+void dhd_ring_whole_unlock(void *ring);
+
+#define DHD_DUMP_TYPE_NAME_SIZE 32
+#define DHD_DUMP_FILE_PATH_SIZE 256
+#define DHD_DUMP_FILE_COUNT_MAX 5
+#define DHD_DUMP_TYPE_COUNT_MAX 10
+
+#ifdef DHD_DUMP_MNGR
+typedef struct _DFM_elem {
+ char type_name[DHD_DUMP_TYPE_NAME_SIZE];
+ char file_path[DHD_DUMP_FILE_COUNT_MAX][DHD_DUMP_FILE_PATH_SIZE];
+ int file_idx;
+} DFM_elem_t;
+
+typedef struct _dhd_dump_file_manage {
+ DFM_elem_t elems[DHD_DUMP_TYPE_COUNT_MAX];
+} dhd_dump_file_manage_t;
+
+extern void dhd_dump_file_manage_enqueue(dhd_pub_t *dhd, char *dump_path, char *fname);
+#endif /* DHD_DUMP_MNGR */
+
+#ifdef PKT_FILTER_SUPPORT
+extern void dhd_pktfilter_offload_set(dhd_pub_t * dhd, char *arg);
+extern void dhd_pktfilter_offload_enable(dhd_pub_t * dhd, char *arg, int enable, int master_mode);
+extern void dhd_pktfilter_offload_delete(dhd_pub_t *dhd, int id);
+#endif // endif
+
+#ifdef DHD_DUMP_PCIE_RINGS
+extern int dhd_d2h_h2d_ring_dump(dhd_pub_t *dhd, void *file, const void *user_buf,
+ unsigned long *file_posn, bool file_write);
+#endif /* DHD_DUMP_PCIE_RINGS */
+
+#ifdef EWP_EDL
+#define DHD_EDL_RING_SIZE (D2HRING_EDL_MAX_ITEM * D2HRING_EDL_ITEMSIZE)
+int dhd_event_logtrace_process_edl(dhd_pub_t *dhdp, uint8 *data,
+ void *evt_decode_data);
+int dhd_edl_mem_init(dhd_pub_t *dhd);
+void dhd_edl_mem_deinit(dhd_pub_t *dhd);
+void dhd_prot_edl_ring_tcm_rd_update(dhd_pub_t *dhd);
+#define DHD_EDL_MEM_INIT(dhdp) dhd_edl_mem_init(dhdp)
+#define DHD_EDL_MEM_DEINIT(dhdp) dhd_edl_mem_deinit(dhdp)
+#define DHD_EDL_RING_TCM_RD_UPDATE(dhdp) \
+ dhd_prot_edl_ring_tcm_rd_update(dhdp)
+#else
+#define DHD_EDL_MEM_INIT(dhdp) do { /* noop */ } while (0)
+#define DHD_EDL_MEM_DEINIT(dhdp) do { /* noop */ } while (0)
+#define DHD_EDL_RING_TCM_RD_UPDATE(dhdp) do { /* noop */ } while (0)
+#endif /* EWP_EDL */
+
+void dhd_schedule_logtrace(void *dhd_info);
+int dhd_print_fw_ver_from_file(dhd_pub_t *dhdp, char *fwpath);
+
+#define HD_PREFIX_SIZE 2 /* hexadecimal prefix size */
+#define HD_BYTE_SIZE 2 /* hexadecimal byte size */
+
+#if defined(DHD_H2D_LOG_TIME_SYNC)
+void dhd_h2d_log_time_sync_deferred_wq_schedule(dhd_pub_t *dhdp);
+void dhd_h2d_log_time_sync(dhd_pub_t *dhdp);
+#endif /* DHD_H2D_LOG_TIME_SYNC */
+extern void dhd_cleanup_if(struct net_device *net);
+
+#ifdef DNGL_AXI_ERROR_LOGGING
+extern void dhd_axi_error(dhd_pub_t *dhd);
+#ifdef DHD_USE_WQ_FOR_DNGL_AXI_ERROR
+extern void dhd_axi_error_dispatch(dhd_pub_t *dhdp);
+#endif /* DHD_USE_WQ_FOR_DNGL_AXI_ERROR */
+#endif /* DNGL_AXI_ERROR_LOGGING */
+
+#ifdef DHD_HP2P
+extern unsigned long dhd_os_hp2plock(dhd_pub_t *pub);
+extern void dhd_os_hp2punlock(dhd_pub_t *pub, unsigned long flags);
+#endif /* DHD_HP2P */
+extern struct dhd_if * dhd_get_ifp(dhd_pub_t *dhdp, uint32 ifidx);
+
+#ifdef DHD_STATUS_LOGGING
+#include <dhd_statlog.h>
+#else
+#define ST(x) 0
+#define STDIR(x) 0
+#define DHD_STATLOG_CTRL(dhdp, stat, ifidx, reason) \
+ do { /* noop */ } while (0)
+#define DHD_STATLOG_DATA(dhdp, stat, ifidx, dir, cond) \
+ do { BCM_REFERENCE(cond); } while (0)
+#define DHD_STATLOG_DATA_RSN(dhdp, stat, ifidx, dir, reason) \
+ do { /* noop */ } while (0)
+#endif /* DHD_STATUS_LOGGING */
+
+#ifdef CONFIG_SILENT_ROAM
+extern int dhd_sroam_set_mon(dhd_pub_t *dhd, bool set);
+typedef wlc_sroam_info_v1_t wlc_sroam_info_t;
+#endif /* CONFIG_SILENT_ROAM */
+
+#ifdef SUPPORT_SET_TID
+enum dhd_set_tid_mode {
+ /* Disalbe changing TID */
+ SET_TID_OFF = 0,
+ /* Change TID for all UDP frames */
+ SET_TID_ALL_UDP,
+ /* Change TID for UDP frames based on UID */
+ SET_TID_BASED_ON_UID
+};
+extern void dhd_set_tid_based_on_uid(dhd_pub_t *dhdp, void *pkt);
+#endif /* SUPPORT_SET_TID */
+
+#ifdef DHD_DUMP_FILE_WRITE_FROM_KERNEL
+#define FILE_NAME_HAL_TAG ""
+#else
+#define FILE_NAME_HAL_TAG "_hal" /* The tag name concatenated by HAL */
+#endif /* DHD_DUMP_FILE_WRITE_FROM_KERNEL */
+
+#if defined(DISABLE_HE_ENAB) || defined(CUSTOM_CONTROL_HE_ENAB)
+extern int dhd_control_he_enab(dhd_pub_t * dhd, uint8 he_enab);
+extern uint8 control_he_enab;
+#endif /* DISABLE_HE_ENAB || CUSTOM_CONTROL_HE_ENAB */
+
+#if defined(BCMSDIO)
+void dhd_set_role(dhd_pub_t *dhdp, int role, int bssidx);
+#endif /* BCMSDIO */
+#endif /* _dhd_h_ */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_bt_interface.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_bt_interface.h
new file mode 100755
index 0000000..fda4426
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_bt_interface.h
@@ -0,0 +1,76 @@
+/*
+ *
+ *
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
+ *
+ * Copyright (C) 1999-2017, Broadcom Corporation
+ *
+ * Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed to you
+ * under the terms of the GNU General Public License version 2 (the "GPL"),
+ * available at http://www.broadcom.com/licenses/GPLv2.php, with the
+ * following added to such license:
+ *
+ * As a special exception, the copyright holders of this software give you
+ * permission to link this software with independent modules, and to copy and
+ * distribute the resulting executable under terms of your choice, provided that
+ * you also meet, for each linked independent module, the terms and conditions of
+ * the license of that module. An independent module is a module which is not
+ * derived from this software. The special exception does not apply to any
+ * modifications of the software.
+ *
+ * Notwithstanding the above, under no circumstances may you combine this
+ * software in any way with any other Broadcom software provided under a license
+ * other than the GPL, without Broadcom's express prior written consent.
+ *
+ *
+ * <<Broadcom-WL-IPTag/Open:>>
+ *
+ * $Id: $
+ *
+ */
+
+#ifndef _dhd_bt_interface_h_
+#define _dhd_bt_interface_h_
+#include <linux/mmc/sdio_func.h>
+
+typedef enum {
+ WLAN_MODULE = 0,
+ BT_MODULE
+} bus_owner_t;
+
+typedef void * wlan_bt_handle_t;
+typedef void (*f3intr_handler)(struct sdio_func *func);
+typedef void (*dhd_hang_notification)(struct sdio_func *func, bool wifi_state);
+
+extern void bcmsdh_btsdio_interface_init(struct sdio_func *func,
+ f3intr_handler f3intr_fun, dhd_hang_notification hang_notification);
+void bcmsdh_btsdio_process_f3_intr(void);
+void bcmsdh_btsdio_process_dhd_hang_notification(bool wifi_recovery_completed);
+
+extern int dhd_bus_recv_buf(void *h, uint32 addr, uint fn, uint8 *buf, uint nbytes);
+extern int dhd_bus_send_buf(void *h, uint32 addr, uint fn, uint8 *buf, uint nbytes);
+extern int dhd_bus_set_blocksize(void *h, unsigned int fun_num, unsigned int block_size);
+
+/* Shared Layer Init function */
+extern wlan_bt_handle_t dhd_bt_get_pub_hndl(void);
+extern int dhd_download_btfw(wlan_bt_handle_t handle, char* btfw_path);
+extern int dhd_bus_get(wlan_bt_handle_t handle, bus_owner_t owner);
+extern int dhd_bus_put(wlan_bt_handle_t handle, bus_owner_t owner);
+
+extern unsigned char dhd_bus_cfg_read(void *h, unsigned int fun_num, unsigned int addr, int *err);
+extern void dhd_bus_cfg_write(void *h, unsigned int fun_num, unsigned int addr,
+ unsigned char val, int *err);
+
+/*
+ * Functions to be called from other layers to enable/disable Bus clock
+ * can_wait - Callers pass TRUE, if they want & can wait until the
+ * clock configuration takes effect (there is a register poll until the
+ * PLLs are locked). If the caller cannot wait they can simply pass
+ * FALSE.
+ */
+extern int dhd_bus_clk_enable(wlan_bt_handle_t handle, bus_owner_t owner);
+extern int dhd_bus_clk_disable(wlan_bt_handle_t handle, bus_owner_t owner);
+extern void dhd_bus_reset_bt_use_count(wlan_bt_handle_t handle);
+extern void dhd_bus_retry_hang_recovery(wlan_bt_handle_t handle);
+#endif /* _dhd_bt_interface_h_ */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_common.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_common.c
old mode 100644
new mode 100755
index 9980fc7..680bc6d
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_common.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_common.c
@@ -89,6 +89,7 @@
#include <dhd_wlfc.h>
#endif // endif
+#include <dhd_linux_priv.h>
#if defined(DHD_POST_EAPOL_M1_AFTER_ROAM_EVT)
#include <dhd_linux.h>
#endif // endif
@@ -115,8 +116,8 @@
#ifdef DHD_LOG_PRINT_RATE_LIMIT
int log_print_threshold = 0;
#endif /* DHD_LOG_PRINT_RATE_LIMIT */
-//int dhd_msg_level = DHD_ERROR_VAL | DHD_FWLOG_VAL | DHD_EVENT_VAL
-int dhd_msg_level = DHD_ERROR_VAL | DHD_EVENT_VAL
+int dhd_msg_level = DHD_ERROR_VAL | DHD_FWLOG_VAL | DHD_EVENT_VAL
+//int dhd_msg_level = DHD_ERROR_VAL | DHD_EVENT_VAL
/* For CUSTOMER_HW4 do not enable DHD_IOVAR_MEM_VAL by default */
#if !defined(BOARD_HIKEY)
| DHD_IOVAR_MEM_VAL
@@ -3658,6 +3659,13 @@
}
break;
#endif /* DHD_POST_EAPOL_M1_AFTER_ROAM_EVT */
+#ifdef BCMSDIO
+ case WLC_E_AP_STARTED:
+ if (FW_SUPPORTED(dhd_pub, idsup)) {
+ dhd_pub->info->iflist[*ifidx]->role = WLC_E_IF_ROLE_AP;
+ }
+ break;
+#endif /* BCMSDIO */
case WLC_E_LINK:
#ifdef PCIE_FULL_DONGLE
if (dhd_update_interface_link_status(dhd_pub, (uint8)dhd_ifname2idx(dhd_pub->info,
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_debug.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_debug.c
old mode 100644
new mode 100755
index 9c36642..57317ce
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_debug.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_debug.c
@@ -1380,13 +1380,9 @@
uint32
__dhd_dbg_driver_ts_usec(void)
{
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0))
struct timespec64 ts;
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39))
- struct timespec ts;
-#endif /* LINUX_VER >= 2.6.39 */
- get_monotonic_boottime(&ts);
+ ts = ktime_to_timespec64(ktime_get_boottime());
return ((uint32)(__TIMESPEC_TO_US(ts)));
}
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.c
old mode 100644
new mode 100755
index 2713bb3..cb9bf49
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.c
@@ -3098,9 +3098,6 @@
int ret = 0;
dhd_info_t *dhd = DHD_DEV_INFO(dev);
-#if defined(SUPPORT_RANDOM_MAC_SCAN)
- struct bcm_cfg80211 *cfg = wl_get_cfg(dev);
-#endif // endif
struct sockaddr *sa = (struct sockaddr *)addr;
int ifidx;
dhd_if_t *dhdif;
@@ -3111,15 +3108,6 @@
dhdif = dhd->iflist[ifidx];
- if ((dhdif != NULL) &&
-#if defined(SUPPORT_RANDOM_MAC_SCAN)
- (!(cfg->random_mac_enabled)) &&
-#endif // endif
- (dhdif->idx > 0)) {
- DHD_ERROR(("%s: Intf[%s] Blocking MAC Overwrite \n", __FUNCTION__, dhdif->name));
- return 0;
- }
-
dhd_net_if_lock_local(dhd);
memcpy(dhdif->mac_addr, sa->sa_data, ETHER_ADDR_LEN);
dhdif->set_macaddress = TRUE;
@@ -5921,230 +5909,6 @@
#endif /* CFI_CHECK */
}
-#if defined(BT_OVER_SDIO)
-
-void
-dhdsdio_bus_usr_cnt_inc(dhd_pub_t *dhdp)
-{
- dhdp->info->bus_user_count++;
-}
-
-void
-dhdsdio_bus_usr_cnt_dec(dhd_pub_t *dhdp)
-{
- dhdp->info->bus_user_count--;
-}
-
-/* Return values:
- * Success: Returns 0
- * Failure: Returns -1 or errono code
- */
-int
-dhd_bus_get(wlan_bt_handle_t handle, bus_owner_t owner)
-{
- dhd_pub_t *dhdp = (dhd_pub_t *)handle;
- dhd_info_t *dhd = (dhd_info_t *)dhdp->info;
- int ret = 0;
-
- mutex_lock(&dhd->bus_user_lock);
- ++dhd->bus_user_count;
- if (dhd->bus_user_count < 0) {
- DHD_ERROR(("%s(): bus_user_count is negative, which is invalid\n", __FUNCTION__));
- ret = -1;
- goto exit;
- }
-
- if (dhd->bus_user_count == 1) {
-
- dhd->pub.hang_was_sent = 0;
-
- /* First user, turn on WL_REG, start the bus */
- DHD_ERROR(("%s(): First user Turn On WL_REG & start the bus", __FUNCTION__));
-
- if (!wifi_platform_set_power(dhd->adapter, TRUE, WIFI_TURNON_DELAY)) {
- /* Enable F1 */
- ret = dhd_bus_resume(dhdp, 0);
- if (ret) {
- DHD_ERROR(("%s(): Failed to enable F1, err=%d\n",
- __FUNCTION__, ret));
- goto exit;
- }
- }
-
- dhd_update_fw_nv_path(dhd);
- /* update firmware and nvram path to sdio bus */
- dhd_bus_update_fw_nv_path(dhd->pub.bus,
- dhd->fw_path, dhd->nv_path);
- /* download the firmware, Enable F2 */
- /* TODO: Should be done only in case of FW switch */
- ret = dhd_bus_devreset(dhdp, FALSE);
- dhd_bus_resume(dhdp, 1);
- if (!ret) {
- if (dhd_sync_with_dongle(&dhd->pub) < 0) {
- DHD_ERROR(("%s(): Sync with dongle failed!!\n", __FUNCTION__));
- ret = -EFAULT;
- }
- } else {
- DHD_ERROR(("%s(): Failed to download, err=%d\n", __FUNCTION__, ret));
- }
- } else {
- DHD_ERROR(("%s(): BUS is already acquired, just increase the count %d \r\n",
- __FUNCTION__, dhd->bus_user_count));
- }
-exit:
- mutex_unlock(&dhd->bus_user_lock);
- return ret;
-}
-EXPORT_SYMBOL(dhd_bus_get);
-
-/* Return values:
- * Success: Returns 0
- * Failure: Returns -1 or errono code
- */
-int
-dhd_bus_put(wlan_bt_handle_t handle, bus_owner_t owner)
-{
- dhd_pub_t *dhdp = (dhd_pub_t *)handle;
- dhd_info_t *dhd = (dhd_info_t *)dhdp->info;
- int ret = 0;
- BCM_REFERENCE(owner);
-
- mutex_lock(&dhd->bus_user_lock);
- --dhd->bus_user_count;
- if (dhd->bus_user_count < 0) {
- DHD_ERROR(("%s(): bus_user_count is negative, which is invalid\n", __FUNCTION__));
- dhd->bus_user_count = 0;
- ret = -1;
- goto exit;
- }
-
- if (dhd->bus_user_count == 0) {
- /* Last user, stop the bus and turn Off WL_REG */
- DHD_ERROR(("%s(): There are no owners left Trunf Off WL_REG & stop the bus \r\n",
- __FUNCTION__));
-#ifdef PROP_TXSTATUS
- if (dhd->pub.wlfc_enabled) {
- dhd_wlfc_deinit(&dhd->pub);
- }
-#endif /* PROP_TXSTATUS */
-#ifdef PNO_SUPPORT
- if (dhd->pub.pno_state) {
- dhd_pno_deinit(&dhd->pub);
- }
-#endif /* PNO_SUPPORT */
-#ifdef RTT_SUPPORT
- if (dhd->pub.rtt_state) {
- dhd_rtt_deinit(&dhd->pub);
- }
-#endif /* RTT_SUPPORT */
- ret = dhd_bus_devreset(dhdp, TRUE);
- if (!ret) {
- dhd_bus_suspend(dhdp);
- wifi_platform_set_power(dhd->adapter, FALSE, WIFI_TURNOFF_DELAY);
- }
- } else {
- DHD_ERROR(("%s(): Other owners using bus, decrease the count %d \r\n",
- __FUNCTION__, dhd->bus_user_count));
- }
-exit:
- mutex_unlock(&dhd->bus_user_lock);
- return ret;
-}
-EXPORT_SYMBOL(dhd_bus_put);
-
-int
-dhd_net_bus_get(struct net_device *dev)
-{
- dhd_info_t *dhd = DHD_DEV_INFO(dev);
- return dhd_bus_get(&dhd->pub, WLAN_MODULE);
-}
-
-int
-dhd_net_bus_put(struct net_device *dev)
-{
- dhd_info_t *dhd = DHD_DEV_INFO(dev);
- return dhd_bus_put(&dhd->pub, WLAN_MODULE);
-}
-
-/*
- * Function to enable the Bus Clock
- * Returns BCME_OK on success and BCME_xxx on failure
- *
- * This function is not callable from non-sleepable context
- */
-int dhd_bus_clk_enable(wlan_bt_handle_t handle, bus_owner_t owner)
-{
- dhd_pub_t *dhdp = (dhd_pub_t *)handle;
-
- int ret;
-
- dhd_os_sdlock(dhdp);
- /*
- * The second argument is TRUE, that means, we expect
- * the function to "wait" until the clocks are really
- * available
- */
- ret = __dhdsdio_clk_enable(dhdp->bus, owner, TRUE);
- dhd_os_sdunlock(dhdp);
-
- return ret;
-}
-EXPORT_SYMBOL(dhd_bus_clk_enable);
-
-/*
- * Function to disable the Bus Clock
- * Returns BCME_OK on success and BCME_xxx on failure
- *
- * This function is not callable from non-sleepable context
- */
-int dhd_bus_clk_disable(wlan_bt_handle_t handle, bus_owner_t owner)
-{
- dhd_pub_t *dhdp = (dhd_pub_t *)handle;
-
- int ret;
-
- dhd_os_sdlock(dhdp);
- /*
- * The second argument is TRUE, that means, we expect
- * the function to "wait" until the clocks are really
- * disabled
- */
- ret = __dhdsdio_clk_disable(dhdp->bus, owner, TRUE);
- dhd_os_sdunlock(dhdp);
-
- return ret;
-}
-EXPORT_SYMBOL(dhd_bus_clk_disable);
-
-/*
- * Function to reset bt_use_count counter to zero.
- *
- * This function is not callable from non-sleepable context
- */
-void dhd_bus_reset_bt_use_count(wlan_bt_handle_t handle)
-{
- dhd_pub_t *dhdp = (dhd_pub_t *)handle;
-
- /* take the lock and reset bt use count */
- dhd_os_sdlock(dhdp);
- dhdsdio_reset_bt_use_count(dhdp->bus);
- dhd_os_sdunlock(dhdp);
-}
-EXPORT_SYMBOL(dhd_bus_reset_bt_use_count);
-
-void dhd_bus_retry_hang_recovery(wlan_bt_handle_t handle)
-{
- dhd_pub_t *dhdp = (dhd_pub_t *)handle;
- dhd_info_t *dhd = (dhd_info_t*)dhdp->info;
-
- dhdp->hang_was_sent = 0;
-
- dhd_os_send_hang_message(&dhd->pub);
-}
-EXPORT_SYMBOL(dhd_bus_retry_hang_recovery);
-
-#endif /* BT_OVER_SDIO */
-
static int
dhd_monitor_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
@@ -6702,6 +6466,230 @@
}
#endif /* DHD_PCIE_NATIVE_RUNTIMEPM */
+#if defined(BT_OVER_SDIO)
+
+void
+dhdsdio_bus_usr_cnt_inc(dhd_pub_t *dhdp)
+{
+ dhdp->info->bus_user_count++;
+}
+
+void
+dhdsdio_bus_usr_cnt_dec(dhd_pub_t *dhdp)
+{
+ dhdp->info->bus_user_count--;
+}
+
+/* Return values:
+ * Success: Returns 0
+ * Failure: Returns -1 or errono code
+ */
+int
+dhd_bus_get(wlan_bt_handle_t handle, bus_owner_t owner)
+{
+ dhd_pub_t *dhdp = (dhd_pub_t *)handle;
+ dhd_info_t *dhd = (dhd_info_t *)dhdp->info;
+ int ret = 0;
+
+ mutex_lock(&dhd->bus_user_lock);
+ ++dhd->bus_user_count;
+ if (dhd->bus_user_count < 0) {
+ DHD_ERROR(("%s(): bus_user_count is negative, which is invalid\n", __FUNCTION__));
+ ret = -1;
+ goto exit;
+ }
+
+ if (dhd->bus_user_count == 1) {
+
+ dhd->pub.hang_was_sent = 0;
+
+ /* First user, turn on WL_REG, start the bus */
+ DHD_ERROR(("%s(): First user Turn On WL_REG & start the bus", __FUNCTION__));
+
+ if (!wifi_platform_set_power(dhd->adapter, TRUE, WIFI_TURNON_DELAY)) {
+ /* Enable F1 */
+ ret = dhd_bus_resume(dhdp, 0);
+ if (ret) {
+ DHD_ERROR(("%s(): Failed to enable F1, err=%d\n",
+ __FUNCTION__, ret));
+ goto exit;
+ }
+ }
+
+ dhd_update_fw_nv_path(dhd);
+ /* update firmware and nvram path to sdio bus */
+ dhd_bus_update_fw_nv_path(dhd->pub.bus,
+ dhd->fw_path, dhd->nv_path);
+ /* download the firmware, Enable F2 */
+ /* TODO: Should be done only in case of FW switch */
+ ret = dhd_bus_devreset(dhdp, FALSE);
+ dhd_bus_resume(dhdp, 1);
+ if (!ret) {
+ if (dhd_sync_with_dongle(&dhd->pub) < 0) {
+ DHD_ERROR(("%s(): Sync with dongle failed!!\n", __FUNCTION__));
+ ret = -EFAULT;
+ }
+ } else {
+ DHD_ERROR(("%s(): Failed to download, err=%d\n", __FUNCTION__, ret));
+ }
+ } else {
+ DHD_ERROR(("%s(): BUS is already acquired, just increase the count %d \r\n",
+ __FUNCTION__, dhd->bus_user_count));
+ }
+exit:
+ mutex_unlock(&dhd->bus_user_lock);
+ return ret;
+}
+EXPORT_SYMBOL(dhd_bus_get);
+
+/* Return values:
+ * Success: Returns 0
+ * Failure: Returns -1 or errono code
+ */
+int
+dhd_bus_put(wlan_bt_handle_t handle, bus_owner_t owner)
+{
+ dhd_pub_t *dhdp = (dhd_pub_t *)handle;
+ dhd_info_t *dhd = (dhd_info_t *)dhdp->info;
+ int ret = 0;
+ BCM_REFERENCE(owner);
+
+ mutex_lock(&dhd->bus_user_lock);
+ --dhd->bus_user_count;
+ if (dhd->bus_user_count < 0) {
+ DHD_ERROR(("%s(): bus_user_count is negative, which is invalid\n", __FUNCTION__));
+ dhd->bus_user_count = 0;
+ ret = -1;
+ goto exit;
+ }
+
+ if (dhd->bus_user_count == 0) {
+ /* Last user, stop the bus and turn Off WL_REG */
+ DHD_ERROR(("%s(): There are no owners left Trunf Off WL_REG & stop the bus \r\n",
+ __FUNCTION__));
+#ifdef PROP_TXSTATUS
+ if (dhd->pub.wlfc_enabled) {
+ dhd_wlfc_deinit(&dhd->pub);
+ }
+#endif /* PROP_TXSTATUS */
+#ifdef PNO_SUPPORT
+ if (dhd->pub.pno_state) {
+ dhd_pno_deinit(&dhd->pub);
+ }
+#endif /* PNO_SUPPORT */
+#ifdef RTT_SUPPORT
+ if (dhd->pub.rtt_state) {
+ dhd_rtt_deinit(&dhd->pub);
+ }
+#endif /* RTT_SUPPORT */
+ ret = dhd_bus_devreset(dhdp, TRUE);
+ if (!ret) {
+ dhd_bus_suspend(dhdp);
+ wifi_platform_set_power(dhd->adapter, FALSE, WIFI_TURNOFF_DELAY);
+ }
+ } else {
+ DHD_ERROR(("%s(): Other owners using bus, decrease the count %d \r\n",
+ __FUNCTION__, dhd->bus_user_count));
+ }
+exit:
+ mutex_unlock(&dhd->bus_user_lock);
+ return ret;
+}
+EXPORT_SYMBOL(dhd_bus_put);
+
+int
+dhd_net_bus_get(struct net_device *dev)
+{
+ dhd_info_t *dhd = DHD_DEV_INFO(dev);
+ return dhd_bus_get(&dhd->pub, WLAN_MODULE);
+}
+
+int
+dhd_net_bus_put(struct net_device *dev)
+{
+ dhd_info_t *dhd = DHD_DEV_INFO(dev);
+ return dhd_bus_put(&dhd->pub, WLAN_MODULE);
+}
+
+/*
+ * Function to enable the Bus Clock
+ * Returns BCME_OK on success and BCME_xxx on failure
+ *
+ * This function is not callable from non-sleepable context
+ */
+int dhd_bus_clk_enable(wlan_bt_handle_t handle, bus_owner_t owner)
+{
+ dhd_pub_t *dhdp = (dhd_pub_t *)handle;
+
+ int ret;
+
+ dhd_os_sdlock(dhdp);
+ /*
+ * The second argument is TRUE, that means, we expect
+ * the function to "wait" until the clocks are really
+ * available
+ */
+ ret = __dhdsdio_clk_enable(dhdp->bus, owner, TRUE);
+ dhd_os_sdunlock(dhdp);
+
+ return ret;
+}
+EXPORT_SYMBOL(dhd_bus_clk_enable);
+
+/*
+ * Function to disable the Bus Clock
+ * Returns BCME_OK on success and BCME_xxx on failure
+ *
+ * This function is not callable from non-sleepable context
+ */
+int dhd_bus_clk_disable(wlan_bt_handle_t handle, bus_owner_t owner)
+{
+ dhd_pub_t *dhdp = (dhd_pub_t *)handle;
+
+ int ret;
+
+ dhd_os_sdlock(dhdp);
+ /*
+ * The second argument is TRUE, that means, we expect
+ * the function to "wait" until the clocks are really
+ * disabled
+ */
+ ret = __dhdsdio_clk_disable(dhdp->bus, owner, TRUE);
+ dhd_os_sdunlock(dhdp);
+
+ return ret;
+}
+EXPORT_SYMBOL(dhd_bus_clk_disable);
+
+/*
+ * Function to reset bt_use_count counter to zero.
+ *
+ * This function is not callable from non-sleepable context
+ */
+void dhd_bus_reset_bt_use_count(wlan_bt_handle_t handle)
+{
+ dhd_pub_t *dhdp = (dhd_pub_t *)handle;
+
+ /* take the lock and reset bt use count */
+ dhd_os_sdlock(dhdp);
+ dhdsdio_reset_bt_use_count(dhdp->bus);
+ dhd_os_sdunlock(dhdp);
+}
+EXPORT_SYMBOL(dhd_bus_reset_bt_use_count);
+
+void dhd_bus_retry_hang_recovery(wlan_bt_handle_t handle)
+{
+ dhd_pub_t *dhdp = (dhd_pub_t *)handle;
+ dhd_info_t *dhd = (dhd_info_t*)dhdp->info;
+
+ dhdp->hang_was_sent = 0;
+
+ dhd_os_send_hang_message(&dhd->pub);
+}
+EXPORT_SYMBOL(dhd_bus_retry_hang_recovery);
+
+#endif /* BT_OVER_SDIO */
+
static int
dhd_stop(struct net_device *net)
{
@@ -8127,14 +8115,20 @@
dhd_init_logstrs_array(osl_t *osh, dhd_event_log_t *temp)
{
struct file *filep = NULL;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
struct kstat stat;
+ int error = 0;
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0) */
+#if defined(KERNEL_DS) && defined(USER_DS)
mm_segment_t fs;
+#endif /* KERNEL_DS && USER_DS */
char *raw_fmts = NULL;
int logstrs_size = 0;
- int error = 0;
+#if defined(KERNEL_DS) && defined(USER_DS)
fs = get_fs();
set_fs(KERNEL_DS);
+#endif /* KERNEL_DS && USER_DS */
filep = filp_open(logstrs_path, O_RDONLY, 0);
@@ -8142,13 +8136,16 @@
DHD_ERROR_NO_HW4(("%s: Failed to open the file %s \n", __FUNCTION__, logstrs_path));
goto fail;
}
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0))
error = vfs_stat(logstrs_path, &stat);
if (error) {
DHD_ERROR_NO_HW4(("%s: Failed to stat file %s \n", __FUNCTION__, logstrs_path));
goto fail;
}
logstrs_size = (int) stat.size;
-
+#else
+ logstrs_size = i_size_read(file_inode(filep));
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(5, 10, 0) */
if (logstrs_size == 0) {
DHD_ERROR(("%s: return as logstrs_size is 0\n", __FUNCTION__));
goto fail1;
@@ -8168,7 +8165,9 @@
if (dhd_parse_logstrs_file(osh, raw_fmts, logstrs_size, temp)
== BCME_OK) {
filp_close(filep, NULL);
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(fs);
+#endif /* KERNEL_DS && USER_DS */
return BCME_OK;
}
@@ -8182,7 +8181,10 @@
if (!IS_ERR(filep))
filp_close(filep, NULL);
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(fs);
+#endif /* KERNEL_DS && USER_DS */
+
temp->fmts = NULL;
return BCME_ERROR;
}
@@ -8192,7 +8194,10 @@
uint32 *rodata_end)
{
struct file *filep = NULL;
+#if defined(KERNEL_DS) && defined(USER_DS)
mm_segment_t fs;
+#endif /* KERNEL_DS && USER_DS */
+
int err = BCME_ERROR;
if (fname == NULL) {
@@ -8200,8 +8205,10 @@
return BCME_ERROR;
}
+#if defined(KERNEL_DS) && defined(USER_DS)
fs = get_fs();
set_fs(KERNEL_DS);
+#endif /* KERNEL_DS && USER_DS */
filep = filp_open(fname, O_RDONLY, 0);
if (IS_ERR(filep)) {
@@ -8217,7 +8224,9 @@
if (!IS_ERR(filep))
filp_close(filep, NULL);
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(fs);
+#endif /* KERNEL_DS && USER_DS */
return err;
}
@@ -8226,7 +8235,9 @@
dhd_init_static_strs_array(osl_t *osh, dhd_event_log_t *temp, char *str_file, char *map_file)
{
struct file *filep = NULL;
+#if defined(KERNEL_DS) && defined(USER_DS)
mm_segment_t fs;
+#endif /* KERNEL_DS && USER_DS */
char *raw_fmts = NULL;
uint32 logstrs_size = 0;
int error = 0;
@@ -8249,8 +8260,10 @@
DHD_ERROR(("ramstart: 0x%x, rodata_start: 0x%x, rodata_end:0x%x\n",
ramstart, rodata_start, rodata_end));
+#if defined(KERNEL_DS) && defined(USER_DS)
fs = get_fs();
set_fs(KERNEL_DS);
+#endif /* KERNEL_DS && USER_DS */
filep = filp_open(str_file, O_RDONLY, 0);
if (IS_ERR(filep)) {
@@ -8302,7 +8315,9 @@
}
filp_close(filep, NULL);
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(fs);
+#endif /* KERNEL_DS && USER_DS */
return BCME_OK;
@@ -8316,7 +8331,9 @@
if (!IS_ERR(filep))
filp_close(filep, NULL);
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(fs);
+#endif /* KERNEL_DS && USER_DS */
if (strstr(str_file, ram_file_str) != NULL) {
temp->raw_sstr = NULL;
@@ -8404,6 +8421,10 @@
dhd_attach_states_t dhd_state = DHD_ATTACH_STATE_INIT;
DHD_TRACE(("%s: Enter\n", __FUNCTION__));
+#ifdef DHD_DISABLE_FWLOG_IN_CHIPBOOT
+ dhd_msg_level = (dhd_msg_level & (~DHD_FWLOG_VAL));
+ DHD_ERROR(("%s , dhd_msg_level: 0x%x\n",__FUNCTION__,dhd_msg_level));
+#endif
#ifdef PCIE_FULL_DONGLE
ASSERT(sizeof(dhd_pkttag_fd_t) <= OSL_PKTTAG_SZ);
ASSERT(sizeof(dhd_pkttag_fr_t) <= OSL_PKTTAG_SZ);
@@ -9149,7 +9170,6 @@
DHD_ERROR(("nvram path not found\n"));
return FALSE;
}
- DHD_ERROR(("2--firmware path [%s]-[%s]\n", dhdinfo->fw_path, dhdinfo->nv_path));
return TRUE;
}
@@ -12030,10 +12050,15 @@
net->netdev_ops = &dhd_ops_virt;
/* Ok, link into the network layer... */
+ DHD_ERROR(("%s , ifidx: %d\n", __FUNCTION__, ifidx));
if (ifidx == 0) {
/*
* device functions for the primary interface only
*/
+#ifdef DHD_DISABLE_FWLOG_IN_CHIPBOOT
+ dhd_msg_level = (dhd_msg_level | (DHD_FWLOG_VAL));
+ DHD_ERROR(("%s , dhd_msg_level: 0x%x\n", __FUNCTION__, dhd_msg_level));
+#endif
net->netdev_ops = &dhd_ops_pri;
if (!ETHER_ISNULLADDR(dhd->pub.mac.octet))
memcpy(temp_addr, dhd->pub.mac.octet, ETHER_ADDR_LEN);
@@ -15803,12 +15828,13 @@
{
int ret = 0;
struct file *fp = NULL;
- mm_segment_t old_fs;
loff_t pos = 0;
/* change to KERNEL_DS address limit */
+#if defined(KERNEL_DS) && defined(USER_DS)
+ mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
-
+#endif /* KERNEL_DS && USER_DS */
/* open file to write */
fp = filp_open(file_name, flags, 0664);
if (IS_ERR(fp)) {
@@ -15837,8 +15863,9 @@
filp_close(fp, current->files);
/* restore previous address limit */
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
-
+#endif /* KERNEL_DS && USER_DS */
return ret;
}
#endif // endif
@@ -17274,7 +17301,9 @@
int ret = BCME_ERROR;
char *filepath = RND_IN;
uint32 file_mode = O_RDONLY;
+#if defined(KERNEL_DS) && defined(USER_DS)
mm_segment_t old_fs;
+#endif /* KERNEL_DS && USER_DS */
loff_t pos = 0;
/* Read memdump info from the file */
@@ -17299,8 +17328,10 @@
#endif /* CONFIG_X86 && OEM_ANDROID */
}
+#if defined(KERNEL_DS) && defined(USER_DS)
old_fs = get_fs();
set_fs(KERNEL_DS);
+#endif /* KERNEL_DS && USER_DS */
/* Handle success case */
ret = vfs_read(fp, (char *)&dhd->rnd_len, sizeof(dhd->rnd_len), &pos);
@@ -17321,7 +17352,9 @@
goto err3;
}
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
filp_close(fp, NULL);
DHD_ERROR(("%s: RND read from %s\n", __FUNCTION__, filepath));
@@ -17331,7 +17364,9 @@
MFREE(dhd->osh, dhd->rnd_buf, dhd->rnd_len);
dhd->rnd_buf = NULL;
err2:
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
filp_close(fp, NULL);
err1:
return BCME_ERROR;
@@ -17344,7 +17379,9 @@
int ret = BCME_OK;
char *filepath = RND_OUT;
uint32 file_mode = O_CREAT | O_WRONLY | O_SYNC;
+#if defined(KERNEL_DS) && defined(USER_DS)
mm_segment_t old_fs;
+#endif /* KERNEL_DS && USER_DS */
loff_t pos = 0;
/* Read memdump info from the file */
@@ -17369,8 +17406,10 @@
#endif /* CONFIG_X86 && OEM_ANDROID */
}
+#if defined(KERNEL_DS) && defined(USER_DS)
old_fs = get_fs();
set_fs(KERNEL_DS);
+#endif /* KERNEL_DS && USER_DS */
/* Handle success case */
ret = vfs_write(fp, (char *)&rnd_len, sizeof(rnd_len), &pos);
@@ -17385,13 +17424,17 @@
goto err2;
}
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
filp_close(fp, NULL);
DHD_ERROR(("%s: RND written to %s\n", __FUNCTION__, filepath));
return BCME_OK;
err2:
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
filp_close(fp, NULL);
err1:
return BCME_ERROR;
@@ -18894,14 +18937,20 @@
{
int ret = 0, i = 0;
struct file *fp = NULL;
+#if defined(KERNEL_DS) && defined(USER_DS)
mm_segment_t old_fs;
+#endif /* KERNEL_DS && USER_DS */
loff_t pos = 0;
char dump_path[128];
uint32 file_mode;
unsigned long flags = 0;
size_t log_size = 0;
size_t fspace_remain = 0;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0))
+ int isize = 0;
+#else
struct kstat stat;
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0) */
char time_str[128];
unsigned int len = 0;
log_dump_section_hdr_t sec_hdr;
@@ -18921,9 +18970,10 @@
goto exit1;
}
/* change to KERNEL_DS address limit */
+#if defined(KERNEL_DS) && defined(USER_DS)
old_fs = get_fs();
set_fs(KERNEL_DS);
-
+#endif /* KERNEL_DS && USER_DS */
dhd_get_debug_dump_file_name(NULL, dhdp, dump_path, sizeof(dump_path));
DHD_ERROR(("debug_dump_path = %s\n", dump_path));
@@ -18968,6 +19018,15 @@
#endif /* CONFIG_X86 && OEM_ANDROID */
}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0))
+ isize = i_size_read(file_inode(fp));
+
+ /* if some one else has changed the file */
+ if (dhdp->last_file_posn != 0 &&
+ isize < dhdp->last_file_posn) {
+ dhdp->last_file_posn = 0;
+ }
+#else
ret = vfs_stat(dump_path, &stat);
if (ret < 0) {
DHD_ERROR(("file stat error, err = %d\n", ret));
@@ -18979,7 +19038,7 @@
stat.size < dhdp->last_file_posn) {
dhdp->last_file_posn = 0;
}
-
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0) */
if (dhdp->logdump_periodic_flush) {
log_size = strlen(time_str) + strlen(DHD_DUMP_LOG_HDR) + sizeof(sec_hdr);
/* calculate the amount of space required to dump all logs */
@@ -19114,7 +19173,9 @@
DHD_ERROR(("%s: Finished writing log dump to file - '%s' \n",
__FUNCTION__, dump_path));
}
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
exit1:
if (type) {
MFREE(dhdp->osh, type, sizeof(*type));
@@ -20604,12 +20665,13 @@
dhd_write_file(const char *filepath, char *buf, int buf_len)
{
struct file *fp = NULL;
- mm_segment_t old_fs;
int ret = 0;
-
/* change to KERNEL_DS address limit */
+#if defined(KERNEL_DS) && defined(USER_DS)
+ mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
+#endif /* KERNEL_DS && USER_DS */
/* File is always created. */
fp = filp_open(filepath, O_RDWR | O_CREAT, 0664);
@@ -20632,7 +20694,9 @@
}
/* restore previous address limit */
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
return ret;
}
@@ -20641,16 +20705,18 @@
dhd_read_file(const char *filepath, char *buf, int buf_len)
{
struct file *fp = NULL;
- mm_segment_t old_fs;
int ret;
-
/* change to KERNEL_DS address limit */
+#if defined(KERNEL_DS) && defined(USER_DS)
+ mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
-
+#endif /* KERNEL_DS && USER_DS */
fp = filp_open(filepath, O_RDONLY, 0);
if (IS_ERR(fp)) {
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
DHD_ERROR(("%s: File %s doesn't exist\n", __FUNCTION__, filepath));
return BCME_ERROR;
}
@@ -20659,7 +20725,9 @@
filp_close(fp, NULL);
/* restore previous address limit */
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(old_fs);
+#endif /* KERNEL_DS && USER_DS */
/* Return the number of bytes read */
if (ret > 0) {
@@ -21231,19 +21299,20 @@
void
get_debug_dump_time(char *str)
{
- struct timeval curtime;
- unsigned long local_time;
+ struct timespec64 curtime;
+ unsigned long long local_time;
+
struct rtc_time tm;
if (!strlen(str)) {
- do_gettimeofday(&curtime);
- local_time = (u32)(curtime.tv_sec -
+ ktime_get_real_ts64(&curtime);
+ local_time = (u64)(curtime.tv_sec -
(sys_tz.tz_minuteswest * DHD_LOG_DUMP_TS_MULTIPLIER_VALUE));
rtc_time_to_tm(local_time, &tm);
snprintf(str, DEBUG_DUMP_TIME_BUF_LEN, DHD_LOG_DUMP_TS_FMT_YYMMDDHHMMSSMSMS,
tm.tm_year - 100, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min,
- tm.tm_sec, (int)(curtime.tv_usec/NSEC_PER_USEC));
+ tm.tm_sec, (int)(curtime.tv_nsec/NSEC_PER_MSEC));
}
}
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.h
old mode 100644
new mode 100755
index 7b78578..53a727a
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux.h
@@ -1,7 +1,7 @@
/*
* DHD Linux header file (dhd_linux exports for cfg80211 and other components)
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
@@ -41,10 +41,6 @@
#include <linux/init.h>
#include <linux/fs.h>
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 1))
-#include <linux/time64.h>
-#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 1)) */
-
#include <dngl_stats.h>
#include <dhd.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 1))
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_exportfs.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_exportfs.c
old mode 100644
new mode 100755
index c9b63b2..9e96728
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_exportfs.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_exportfs.c
@@ -58,11 +58,19 @@
static int dhd_ring_proc_open(struct inode *inode, struct file *file);
ssize_t dhd_ring_proc_read(struct file *file, char *buffer, size_t tt, loff_t *loff);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
+static const struct proc_ops dhd_ring_proc_fops = {
+ .proc_open = dhd_ring_proc_open,
+ .proc_read = dhd_ring_proc_read,
+ .proc_release = single_release,
+};
+#else
static const struct file_operations dhd_ring_proc_fops = {
.open = dhd_ring_proc_open,
.read = dhd_ring_proc_read,
.release = single_release,
};
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0) */
static int
dhd_ring_proc_open(struct inode *inode, struct file *file)
@@ -749,11 +757,6 @@
filp_close(fp, NULL);
}
-#ifdef CUSTOMER_HW4_DEBUG
- mem_val = (mem_val >= 0) ? mem_val : 1;
-#else
- mem_val = (mem_val >= 0) ? mem_val : 0;
-#endif /* CUSTOMER_HW4_DEBUG */
return mem_val;
}
@@ -763,8 +766,8 @@
int mem_val = -1;
mem_val = get_assert_val_from_file();
-
- g_assert_type = mem_val;
+ if (mem_val != -1)
+ g_assert_type = mem_val;
#endif /* !DHD_EXPORT_CNTL_FILE */
}
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_lb.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_lb.c
old mode 100644
new mode 100755
index 1dc5c4e..f3ff91d
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_lb.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_lb.c
@@ -2,7 +2,7 @@
* Broadcom Dongle Host Driver (DHD), Linux-specific network interface
* Basically selected code segments from usb-cdc.c and usb-rndis.c
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
@@ -33,7 +33,6 @@
#include <dhd_linux_priv.h>
extern dhd_pub_t* g_dhd_pub;
-static int g_cpuhp_state = 0; //cy add to fix reboot when sleep 2022-05-23
#if defined(DHD_LB)
@@ -301,14 +300,17 @@
int dhd_register_cpuhp_callback(dhd_info_t *dhd)
{
- int cpuhp_ret = 0;
+ dhd->cpuhp_setup_state = 0;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0))
- cpuhp_ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "dhd",
+ dhd->cpuhp_setup_state = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "dhd",
dhd_cpu_startup_callback, dhd_cpu_teardown_callback);
- if (cpuhp_ret < 0) {
+ if (dhd->cpuhp_setup_state < 0) {
DHD_ERROR(("%s(): cpuhp_setup_state failed %d RX LB won't happen \r\n",
- __FUNCTION__, cpuhp_ret));
+ __FUNCTION__, dhd->cpuhp_setup_state));
+ } else {
+ DHD_INFO(("%s(): cpuhp_setup_state returned %d\n",
+ __FUNCTION__, dhd->cpuhp_setup_state));
}
#else
/*
@@ -319,20 +321,20 @@
dhd->cpu_notifier.notifier_call = dhd_cpu_callback;
register_hotcpu_notifier(&dhd->cpu_notifier); /* Register a callback */
#endif /* LINUX_VERSION_CODE < 4.10.0 */
- g_cpuhp_state = cpuhp_ret; //cy add to fix reboot when sleep 2022-05-23
- return cpuhp_ret;
+ return dhd->cpuhp_setup_state;
}
int dhd_unregister_cpuhp_callback(dhd_info_t *dhd)
{
int ret = 0;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0))
- /* Don't want to call tear down while unregistering */
- //cy add to fix reboot when sleep 2022-05-23 begin
- if (g_cpuhp_state != 0) {
- cpuhp_remove_state_nocalls(g_cpuhp_state);
+ DHD_INFO(("%s(): cpuhp_setup_state %d\n",
+ __FUNCTION__, dhd->cpuhp_setup_state));
+
+ if (dhd->cpuhp_setup_state >= 0) {
+ /* Don't want to call tear down while unregistering */
+ cpuhp_remove_state_nocalls(dhd->cpuhp_setup_state);
}
- //cy add to fix reboot when sleep 2022-05-23 end
#else
if (dhd->cpu_notifier.notifier_call != NULL) {
unregister_cpu_notifier(&dhd->cpu_notifier);
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_priv.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_priv.h
old mode 100644
new mode 100755
index 53dd103..7c0e53e
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_priv.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_priv.h
@@ -1,7 +1,7 @@
/*
* DHD Linux header file - contains private structure definition of the Linux specific layer
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
@@ -321,6 +321,9 @@
uint32 *napi_rx_hist[HIST_BIN_SIZE];
uint32 *txc_hist[HIST_BIN_SIZE];
uint32 *rxc_hist[HIST_BIN_SIZE];
+
+ /* State returned by kernel function cpuhp_setup_state(). */
+ int cpuhp_setup_state;
#endif /* DHD_LB */
#if defined(DNGL_AXI_ERROR_LOGGING) && defined(DHD_USE_WQ_FOR_DNGL_AXI_ERROR)
struct work_struct axi_error_dispatcher_work;
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_sched.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_sched.c
old mode 100644
new mode 100755
index e0bab98..6cc377d
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_sched.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_linux_sched.c
@@ -1,7 +1,7 @@
/*
* Expose some of the kernel scheduler routines
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
@@ -30,14 +30,41 @@
*/
#include <linux/kernel.h>
#include <linux/module.h>
+#include <linux/version.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0))
+#include <uapi/linux/sched/types.h>
+#else
#include <linux/sched.h>
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) */
#include <typedefs.h>
#include <linuxver.h>
int setScheduler(struct task_struct *p, int policy, struct sched_param *param)
{
int rc = 0;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0))
+ switch (policy) {
+ case SCHED_FIFO:
+ if (param->sched_priority >= MAX_RT_PRIO/2)
+ /* If the priority is MAX_RT_PRIO/2 or higher,
+ * it is considered as high priority.
+ * sched_priority of FIFO task dosen't
+ * exceed MAX_RT_PRIO/2.
+ */
+ sched_set_fifo(p);
+ else
+ /* For when you don't much care about FIFO,
+ * but want to be above SCHED_NORMAL.
+ */
+ sched_set_fifo_low(p);
+ break;
+ case SCHED_NORMAL:
+ sched_set_normal(p, PRIO_TO_NICE(p->static_prio));
+ break;
+ }
+#else
rc = sched_setscheduler(p, policy, param);
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0) */
return rc;
}
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_msgbuf.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_msgbuf.c
old mode 100644
new mode 100755
index 0e573c8..26638d4
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_msgbuf.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_msgbuf.c
@@ -7696,7 +7696,6 @@
timeleft = dhd_os_ioctl_resp_wait(dhd, (uint *)&prot->ioctl_received);
-#ifdef DHD_RECOVER_TIMEOUT
if (prot->ioctl_received == 0) {
uint32 intstatus = si_corereg(dhd->bus->sih,
dhd->bus->sih->buscoreidx, dhd->bus->pcie_mailbox_int, 0, 0);
@@ -7714,7 +7713,6 @@
dhdpcie_bus_clear_intstatus(dhd->bus);
}
}
-#endif /* DHD_RECOVER_TIMEOUT */
if (timeleft == 0 && (!dhd_query_bus_erros(dhd))) {
/* check if resumed on time out related to scheduling issue */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pcie.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pcie.c
index cf104e5..3cf7267 100755
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pcie.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pcie.c
@@ -3504,7 +3504,7 @@
if (idx == c->last)
return BCME_OK;
- DHD_ERROR(("cy2-conlog: addr=0x%x, idx=0x%x, last=0x%x \n", c->log.buf,
+ DHD_ERROR(("conlog: addr=0x%x, idx=0x%x, last=0x%x \n", c->log.buf,
idx, c->last));
/* Read the console buffer data to a local buffer */
@@ -10302,7 +10302,7 @@
#endif /* CHIPS_CUSTOMER_HW6 */
/* CYW55560 */
- if (device == CYW55560_WLAN_ID) {
+ if ((device == CYW55560_WLAN_ID) || (device == CYW89570_WLAN_ID)) {
return 0;
}
DHD_ERROR(("%s: Unsupported vendor %x device %x\n", __FUNCTION__, vendor, device));
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pno.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pno.c
old mode 100644
new mode 100755
index 8176ed3..37f88d4
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pno.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_pno.c
@@ -3448,7 +3448,11 @@
}
mutex_unlock(&_pno_state->pno_mutex);
exit_no_unlock:
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0))
+ if (swait_active(&_pno_state->get_batch_done.wait))
+#else
if (waitqueue_active(&_pno_state->get_batch_done.wait))
+#endif/* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0) */
complete(&_pno_state->get_batch_done);
return err;
}
@@ -4145,9 +4149,9 @@
gscan_results_cache_t *gscan_hotlist_cache;
u32 malloc_size = 0, i, total = 0;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0))
- struct timespec64 tm_spec;
+ struct timespec64 tm_spec;
#else
- struct timespec tm_spec;
+ struct timespec tm_spec;
#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)) */
uint16 fwstatus;
uint16 fwcount;
@@ -4334,7 +4338,11 @@
{
struct dhd_pno_batch_params *params_batch;
params_batch = &_pno_state->pno_params_arr[INDEX_OF_BATCH_PARAMS].params_batch;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0))
+ if (!swait_active(&_pno_state->get_batch_done.wait))
+#else
if (!waitqueue_active(&_pno_state->get_batch_done.wait)) {
+#endif/* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0) */
DHD_PNO(("%s : WLC_E_PFN_BEST_BATCHING\n", __FUNCTION__));
params_batch->get_batch.buf = NULL;
params_batch->get_batch.bufsize = 0;
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_sdio.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_sdio.c
old mode 100644
new mode 100755
index cda805f..c8a0d5a
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_sdio.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/dhd_sdio.c
@@ -243,6 +243,7 @@
#endif /* DHD_UCODE_DOWNLOAD */
#if defined(BT_OVER_SDIO)
+#define BTMEM_OFFSET_MASK 0xFF000000
#define BTMEM_OFFSET 0x19000000
/* BIT0 => WLAN Power UP and BIT1=> WLAN Wake */
#define BT2WLAN_PWRUP_WAKE 0x03
@@ -589,7 +590,11 @@
/* Try doing readahead */
static bool dhd_readahead;
-#define TXCTL_CREDITS 2
+#ifdef AUTOMOTIVE_FEATURE
+#define TXCTL_CREDITS 1
+#else
+#define TXCTL_CREDITS 2
+#endif /* AUTOMOTIVE_FEATURE */
/* To check if there's window offered */
#define DATAOK(bus) \
@@ -3054,6 +3059,9 @@
IOV_WATERMARK,
IOV_MESBUSYCTRL,
#endif /* USE_SDIOFIFO_IOVAR */
+#if defined(BT_OVER_SDIO)
+ IOV_SDF3,
+#endif /* defined (BT_OVER_SDIO) */
#ifdef SDTEST
IOV_PKTGEN,
IOV_EXTLOOP,
@@ -3127,6 +3135,9 @@
{"watermark", IOV_WATERMARK, 0, 0, IOVT_UINT32, 0 },
{"mesbusyctrl", IOV_MESBUSYCTRL, 0, 0, IOVT_UINT32, 0 },
#endif /* USE_SDIOFIFO_IOVAR */
+#if defined(BT_OVER_SDIO)
+ {"sdf3", IOV_SDF3, 0, 0, IOVT_UINT32, 0 },
+#endif /* defined (BT_OVER_SDIO) */
{"devcap", IOV_DEVCAP, 0, 0, IOVT_UINT32, 0 },
{"dngl_isolation", IOV_DONGLEISOLATION, 0, 0, IOVT_UINT32, 0 },
{"kso", IOV_KSO, 0, 0, IOVT_UINT32, 0 },
@@ -3614,7 +3625,7 @@
if (idx == c->last)
return BCME_OK;
- DHD_ERROR(("cy-conlog: addr=0x%x, idx=0x%x, last=0x%x \n", c->log.buf,
+ DHD_ERROR(("conlog: addr=0x%x, idx=0x%x, last=0x%x \n", c->log.buf,
idx, c->last));
/* Read the console buffer */
@@ -4186,7 +4197,13 @@
DHD_INFO(("%s: Request to %s %d bytes at address 0x%08x\n", __FUNCTION__,
(set ? "write" : "read"), size, address));
-
+#if defined(BT_OVER_SDIO)
+ /* Check if address is within BT range */
+ if ((address & BTMEM_OFFSET_MASK) == BTMEM_OFFSET) {
+ DHD_INFO(("%s: Access BTMEM, bypass check\n", __FUNCTION__));
+ }
+ else
+#endif // endif
/* check if CR4 */
if (si_setcore(bus->sih, ARMCR4_CORE_ID, 0)) {
/*
@@ -4507,6 +4524,33 @@
break;
#endif // endif
+#if defined(BT_OVER_SDIO)
+ case IOV_GVAL(IOV_SDF3):
+ case IOV_SVAL(IOV_SDF3):
+ {
+ uint8 *buf;
+ int ret = BCME_OK;
+ uint size;
+ bool set = (actionid == IOV_SVAL(IOV_SDF3));
+ ASSERT(plen >= sizeof(int));
+
+ size = (uint)int_val;
+ /* Generate the actual data pointer */
+ buf = set ? (uint8*)params + sizeof(int): (uint8*)arg;
+
+ if (actionid == IOV_SVAL(IOV_SDF3)) {
+ ret = dhd_bcmsdh_send_buf(bus, 0, SDIO_FUNC_3,
+ F2SYNC, buf, size, NULL, NULL, NULL, 1);
+ } else {
+ ret = dhd_bcmsdh_recv_buf(bus, 0, SDIO_FUNC_3,
+ F2SYNC, buf, size, NULL, NULL, NULL);
+ }
+ if (ret != BCME_OK) {
+ bcmerror = BCME_SDIO_ERROR;
+ }
+ break;
+ }
+#endif /* defined (BT_OVER_SDIO) */
case IOV_GVAL(IOV_DONGLEISOLATION):
int_val = bus->dhd->dongle_isolation;
bcopy(&int_val, arg, val_size);
@@ -10432,6 +10476,60 @@
} EXPORT_SYMBOL(dhd_bus_cfg_write);
+int dhd_bus_recv_buf(void *h, uint32 addr, uint fn, uint8 *buf, uint nbytes)
+{
+ int ret;
+ dhd_pub_t *dhdp = (dhd_pub_t *)h;
+ dhd_bus_t *bus = (dhd_bus_t *)dhdp->bus;
+ dhd_os_sdlock(bus->dhd);
+
+ ret = dhd_bcmsdh_recv_buf(bus, 0, fn,
+ F2SYNC, buf, nbytes, NULL, NULL, NULL);
+
+ dhd_os_sdunlock(bus->dhd);
+ DHD_ERROR(("\nEntering %s function is %d and no of bytes received %d\n",
+ __func__, fn, nbytes));
+
+ return ret;
+} EXPORT_SYMBOL(dhd_bus_recv_buf);
+
+int dhd_bus_send_buf(void *h, uint32 addr, uint fn, uint8 *buf, uint nbytes)
+{
+ int ret;
+ dhd_pub_t *dhdp = (dhd_pub_t *)h;
+ dhd_bus_t *bus = (dhd_bus_t *)dhdp->bus;
+ DHD_ERROR(("\nEntering %s function is %d and no of bytes sent is %d\n",
+ __func__, fn, nbytes));
+
+ dhd_os_sdlock(bus->dhd);
+
+ ret = dhd_bcmsdh_send_buf(bus, 0, fn,
+ F2SYNC, buf, nbytes, NULL, NULL, NULL, 1);
+
+ dhd_os_sdunlock(bus->dhd);
+
+ return ret;
+} EXPORT_SYMBOL(dhd_bus_send_buf);
+
+int dhd_bus_set_blocksize(void *h, unsigned int fun_num, unsigned int block_size)
+{
+ int bcmerr;
+ int func_blk_size = fun_num;
+ dhd_pub_t *dhd = (dhd_pub_t *)h;
+ dhd_bus_t *bus = (dhd_bus_t *)dhd->bus;
+
+#ifdef USE_DYNAMIC_F2_BLKSIZE
+ func_blk_size = fun_num << 16 | block_size;
+ bcmerr = bcmsdh_iovar_op(bus->sdh, "sd_blocksize", NULL, 0, &func_blk_size,
+ sizeof(func_blk_size), TRUE);
+ if (bcmerr != BCME_OK) {
+ DHD_ERROR(("%s: Set F%d Block size error\n", __FUNCTION__, fun_num));
+ return BCME_ERROR;
+ }
+#endif // endif
+ return bcmerr;
+} EXPORT_SYMBOL(dhd_bus_set_blocksize);
+
static int
extract_hex_field(char * line, uint16 start_pos, uint16 num_chars, uint16 * value)
{
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11.h
old mode 100644
new mode 100755
index 02f58c0..6cbdb45
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11.h
@@ -1372,9 +1372,11 @@
#define DOT11_SC_DECLINED 37 /* request declined */
#define DOT11_SC_INVALID_PARAMS 38 /* One or more params have invalid values */
+#define DOT11_SC_INVALID_GROUP_CIPHER 41 /* invalid group cipher */
#define DOT11_SC_INVALID_PAIRWISE_CIPHER 42 /* invalid pairwise cipher */
#define DOT11_SC_INVALID_AKMP 43 /* Association denied due to invalid AKMP */
#define DOT11_SC_INVALID_RSNIE_CAP 45 /* invalid RSN IE capabilities */
+#define DOT11_SC_CIPHER_OUT_OF_POLICY 46 /* Association denied due to cipher out of policy */
#define DOT11_SC_DLS_NOT_ALLOWED 48 /* DLS is not allowed in the BSS by policy */
#define DOT11_SC_INVALID_PMKID 53 /* Association denied due to invalid PMKID */
#define DOT11_SC_INVALID_MDID 54 /* Association denied due to invalid MDID */
@@ -1943,7 +1945,35 @@
#define DOT11_UWNM_ACTION_TIM 0
#define DOT11_UWNM_ACTION_TIMING_MEASUREMENT 1
-#define DOT11_MNG_COUNTRY_ID_LEN 3
+/*
+ * Fixed length of country information element
+ *
+ * 1Byte: Tag
+ * 1Byte: Length
+ * 2Byte: Country string as per ISO 3166-1
+ * 1Byte: Environment regulation feild
+ */
+#define DOT11_MNG_COUNTRY_ID_LEN 3
+#define DOT11_MNG_COUNTRY_IE_FIXED_LEN (TLV_HDR_LEN + DOT11_MNG_COUNTRY_ID_LEN)
+
+/*
+ * Length of one operating triplet field in country IE
+ *
+ * 1Byte: Operating Extension Identifier
+ * 1Byte: Operating class
+ * 1Byte: Coverage class
+ */
+#define DOT11_MNG_COUNTRY_IE_OPER_TRIP_LEN 3
+#define DOT11_MNG_COUNTRY_OPER_EXT_ID 255
+#define DOT11_MNG_COUNTRY_COVERAGE_CLASS 0
+/*
+ * Length of one subband triplet field in country IE
+ *
+ * 1Byte: First channel number
+ * 1Byte: Number of channels
+ * 1Byte: Maximum transmit power for this group of channels
+ */
+#define DOT11_MNG_COUNTRY_IE_SUBBAND_TRIP_LEN 3
/* VHT category action types - 802.11ac D3.0 - 8.5.23.1 */
#define DOT11_VHT_ACTION_CBF 0 /* Compressed Beamforming */
@@ -4443,6 +4473,9 @@
#define WFA_OUI_TYPE_MBO 0x16
#define WFA_OUI_TYPE_MBO_OCE 0x16
+/* DPP authenticated key managment suite */
+#define WFA_AKM_DPP 2
+
/* RSN authenticated key managment suite */
#define RSN_AKM_NONE 0 /* None (IBSS) */
#define RSN_AKM_UNSPECIFIED 1 /* Over 802.1x */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11e.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11e.h
old mode 100644
new mode 100755
index f8c3332..fc6bc80
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11e.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11e.h
@@ -1,7 +1,7 @@
/*
* 802.11e protocol header file
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11s.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11s.h
old mode 100644
new mode 100755
index 3ad38ba..384fbe6
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11s.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.11s.h
@@ -1,7 +1,7 @@
/*
* Fundamental types and constants relating to 802.11s Mesh
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.1d.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.1d.h
old mode 100644
new mode 100755
index fac083c..7fdaae9
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.1d.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.1d.h
@@ -1,7 +1,7 @@
/*
* Fundamental types and constants relating to 802.1D
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.3.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.3.h
old mode 100644
new mode 100755
index 27c73b0..b3b5edc
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.3.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/802.3.h
@@ -1,7 +1,7 @@
/*
* Fundamental constants relating to 802.3
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/aidmp.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/aidmp.h
old mode 100644
new mode 100755
index fac1f22..e915c5c
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/aidmp.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/aidmp.h
@@ -1,7 +1,7 @@
/*
* Broadcom AMBA Interconnect definitions.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_cfg.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_cfg.h
old mode 100644
new mode 100755
index f997bdc..110accc
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_cfg.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_cfg.h
@@ -1,7 +1,7 @@
/*
* BCM common config options
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_mpool_pub.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_mpool_pub.h
old mode 100644
new mode 100755
index 9bb0154..81a370c
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_mpool_pub.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_mpool_pub.h
@@ -35,7 +35,7 @@
* and instrumentation on top of the heap, without modifying the heap
* allocation implementation.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_ring.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_ring.h
old mode 100644
new mode 100755
index 9b0116e..63e41f4
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_ring.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcm_ring.h
@@ -6,7 +6,7 @@
*
* NOTE: A ring of size N, may only hold N-1 elements.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
@@ -103,7 +103,7 @@
* private L1 data cache.
* +----------------------------------------------------------------------------
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmarp.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmarp.h
old mode 100644
new mode 100755
index 747bc78..df28421
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmarp.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmarp.h
@@ -1,7 +1,7 @@
/*
* Fundamental constants relating to ARP Protocol
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmbloom.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmbloom.h
old mode 100644
new mode 100755
index 64b835d..263657f
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmbloom.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmbloom.h
@@ -1,7 +1,7 @@
/*
* Bloom filter support
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmcdc.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmcdc.h
old mode 100644
new mode 100755
index 3059b73..c4c0bd8
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmcdc.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmcdc.h
@@ -4,7 +4,7 @@
*
* Definitions subject to change without notice.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdefs.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdefs.h
old mode 100644
new mode 100755
index a52b065..014c7ce
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdefs.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdefs.h
@@ -1,7 +1,7 @@
/*
* Misc system wide definitions
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdevs.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdevs.h
old mode 100644
new mode 100755
index c49209f..b7acf2b
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdevs.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdevs.h
@@ -1,7 +1,7 @@
/*
* Broadcom device-specific manifest constants.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
@@ -358,6 +358,7 @@
#define BCM4373_D11AC5G_ID 0x441a /* 4373 802.11ac 5G device */
#define CYW55560_WLAN_ID 0xBD31 /* CYW55560 802.11ax WLAN device ID */
+#define CYW89570_WLAN_ID 0xBD3f /* CYW89570 802.11ax WLAN device ID */
#define CYW55560_BT_ID 0xBD37 /* CYW55560 802.11ax BT device ID */
#define BCMGPRS_UART_ID 0x4333 /* Uart id used by 4306/gprs card */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdhcp.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdhcp.h
old mode 100644
new mode 100755
index b2ee55e..e4f1d20
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdhcp.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmdhcp.h
@@ -1,7 +1,7 @@
/*
* Fundamental constants relating to DHCP Protocol
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmendian.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmendian.h
old mode 100644
new mode 100755
index 4f8754c..091ba18
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmendian.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmendian.h
@@ -1,7 +1,7 @@
/*
* Byte order utilities
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmeth.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmeth.h
old mode 100644
new mode 100755
index 5ec9aff..bf833e9
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmeth.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmeth.h
@@ -1,7 +1,7 @@
/*
* Broadcom Ethernettype protocol definitions
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmicmp.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmicmp.h
old mode 100644
new mode 100755
index d7539ba..807bf37
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmicmp.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmicmp.h
@@ -1,7 +1,7 @@
/*
* Fundamental constants relating to ICMP Protocol
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmiov.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmiov.h
old mode 100644
new mode 100755
index f4c2308..5bd754e
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmiov.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmiov.h
@@ -4,7 +4,7 @@
* To be used in firmware and host apps or dhd - reducing code size,
* duplication, and maintenance overhead.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmip.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmip.h
old mode 100644
new mode 100755
index 3fe93ad..ee0abe6
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmip.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmip.h
@@ -1,7 +1,7 @@
/*
* Fundamental constants relating to IP Protocol
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmipv6.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmipv6.h
old mode 100644
new mode 100755
index 5e0ef8e..db87441
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmipv6.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmipv6.h
@@ -1,7 +1,7 @@
/*
* Fundamental constants relating to Neighbor Discovery Protocol
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmmsgbuf.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmmsgbuf.h
old mode 100644
new mode 100755
index 366d686..6ebe60c
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmmsgbuf.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmmsgbuf.h
@@ -4,7 +4,7 @@
*
* Definitions subject to change without notice.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmnvram.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmnvram.h
old mode 100644
new mode 100755
index 78b0741..dd410b6
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmnvram.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmnvram.h
@@ -1,7 +1,7 @@
/*
* NVRAM variable manipulation
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcie.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcie.h
old mode 100644
new mode 100755
index 06e7861..5d16fed
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcie.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcie.h
@@ -3,7 +3,7 @@
* Software-specific definitions shared between device and host side
* Explains the shared area between host and dongle
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcispi.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcispi.h
old mode 100644
new mode 100755
index 5202018..2b5a2bb
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcispi.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmpcispi.h
@@ -1,7 +1,7 @@
/*
* Broadcom PCI-SPI Host Controller Register Definitions
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmperf.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmperf.h
old mode 100644
new mode 100755
index 65fff9f..55cfd34
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmperf.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmperf.h
@@ -1,7 +1,7 @@
/*
* Performance counters software interface.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdbus.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdbus.h
old mode 100644
new mode 100755
index b5815c7..bded9f7
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdbus.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdbus.h
@@ -2,7 +2,7 @@
* Definitions for API from sdio common code (bcmsdh) to individual
* host controller drivers.
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
@@ -83,7 +83,7 @@
/* callback function, taking one arg */
typedef void (*sdioh_cb_fn_t)(void *);
-#if defined(BT_OVER_SDIO)
+#if defined(BT_OVER_SDIO) && defined(BCMLXSDMMC)
extern
void sdioh_sdmmc_card_enable_func_f3(sdioh_info_t *sd, struct sdio_func *func);
#endif /* defined (BT_OVER_SDIO) */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh.h
old mode 100644
new mode 100755
index 66bd89c..efc8258
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh.h
@@ -3,7 +3,7 @@
* export functions to client drivers
* abstract OS and BUS specific details of SDIO
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh_sdmmc.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh_sdmmc.h
old mode 100644
new mode 100755
index 1da39f2..26c5bd2
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh_sdmmc.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/bcmsdh_sdmmc.h
@@ -1,7 +1,7 @@
/*
* BCMSDH Function Driver for the native SDIO/MMC driver in the Linux Kernel
*
- * Portions of this code are copyright (c) 2021 Cypress Semiconductor Corporation
+ * Portions of this code are copyright (c) 2022 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/epivers.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/epivers.h
old mode 100644
new mode 100755
index 9e8f463..46c98b9
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/epivers.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/epivers.h
@@ -11,30 +11,30 @@
#ifndef _epivers_h_
#define _epivers_h_
-#define EPI_MAJOR_VERSION 0
+#define EPI_MAJOR_VERSION 100
-#define EPI_MINOR_VERSION 0
+#define EPI_MINOR_VERSION 10
-#define EPI_RC_NUMBER 0
+#define EPI_RC_NUMBER 80
#define EPI_INCREMENTAL_NUMBER 0
#define EPI_BUILD_NUMBER 0
-#define EPI_VERSION 0, 0, 0, 0
+#define EPI_VERSION 100, 10, 80, 0
-#define EPI_VERSION_NUM 0x00000000
+#define EPI_VERSION_NUM 0x640a5000
-#define EPI_VERSION_DEV 0.0.0
+#define EPI_VERSION_DEV 100.10.80
/* Driver Version String, ASCII, 32 chars max */
#ifdef BCMINTERNAL
-#define EPI_VERSION_STR "manifest (4622e1d BCMINT)"
+#define EPI_VERSION_STR "100.10.80 (b285849 BCMINT)"
#else
#ifdef WLTEST
-#define EPI_VERSION_STR "manifest (4622e1d WLTEST)"
+#define EPI_VERSION_STR "100.10.80 (b285849 WLTEST)"
#else
-#define EPI_VERSION_STR "manifest (4622e1d)"
+#define EPI_VERSION_STR "100.10.80 (b285849)"
#endif
#endif /* BCMINTERNAL */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linux_osl.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linux_osl.h
old mode 100644
new mode 100755
index 1817601..de6785e
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linux_osl.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linux_osl.h
@@ -34,10 +34,6 @@
#include <typedefs.h>
#define DECLSPEC_ALIGN(x) __attribute__ ((aligned(x)))
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 1))
-#include <linux/time64.h>
-void do_gettimeofday(struct timeval *tv);
-#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 1) */
/* Linux Kernel: File Operations: start */
extern void * osl_os_open_image(char * filename);
extern int osl_os_get_image_block(char * buf, int len, void * image);
@@ -450,8 +446,12 @@
/* map/unmap physical to virtual I/O */
#if !defined(CONFIG_MMC_MSM7X00A)
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0))
#define REG_MAP(pa, size) ioremap_nocache((unsigned long)(pa), (unsigned long)(size))
#else
+#define REG_MAP(pa, size) ioremap((unsigned long)(pa), (unsigned long)(size))
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0) */
+#else
#define REG_MAP(pa, size) (void *)(0)
#endif /* !defined(CONFIG_MMC_MSM7X00A */
#define REG_UNMAP(va) iounmap((va))
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linuxver.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linuxver.h
old mode 100644
new mode 100755
index b2f045a..e6aa882
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linuxver.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/linuxver.h
@@ -641,7 +641,9 @@
return sem_up;
}
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0))
+#define SMP_RD_BARRIER_DEPENDS(x)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))
#define SMP_RD_BARRIER_DEPENDS(x) smp_read_barrier_depends(x)
#else
#define SMP_RD_BARRIER_DEPENDS(x) smp_rmb(x)
@@ -886,4 +888,14 @@
#define kernel_read_compat(file, offset, addr, count) kernel_read(file, offset, addr, count)
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 14, 0) */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0)
+#define timespec64 timespec
+#define ktime_get_real_ts64(timespec) ktime_get_real_ts(timespec)
+#define ktime_to_timespec64(timespec) ktime_to_timespec(timespec)
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0) */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0)
+#define rtc_time_to_tm(time, tm) rtc_time64_to_tm(time, tm)
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0) */
+
#endif /* _linuxver_h_ */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/sdio.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/sdio.h
old mode 100644
new mode 100755
index 1e9658b..a0d95d5
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/sdio.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/sdio.h
@@ -269,6 +269,7 @@
#define SDIO_FUNC_0 0
#define SDIO_FUNC_1 1
#define SDIO_FUNC_2 2
+#define SDIO_FUNC_3 3
#define SDIO_FUNC_4 4
#define SDIO_FUNC_5 5
#define SDIO_FUNC_6 6
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wlioctl_defs.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wlioctl_defs.h
old mode 100644
new mode 100755
index 0e07134..dc862a0
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wlioctl_defs.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wlioctl_defs.h
@@ -555,6 +555,10 @@
#define WPA3_AUTH_PSK_SHA384 0x800000 /* PSK with SHA384 key derivation */
#define WPA3_AUTH_1X_SHA384 0x2000000 /* 1x with SHA384 key derivation */
+/* WFA_AUTH_DPP */
+#define WPA2_WFA_AUTH_DPP 0x200000
+#define WFA_AUTH_DPP 0x100
+
/* WPA2_AUTH_SHA256 not used anymore. Just kept here to avoid build issue in DINGO */
#define WPA2_AUTH_SHA256 0x8000
#define WPA_AUTH_PFN_ANY 0xffffffff /* for PFN, match only ssid */
@@ -1049,6 +1053,7 @@
#define WL_CHAN_FREQ_RANGE_6G_BAND1 6
#define WL_CHAN_FREQ_RANGE_6G_BAND2 7
#define WL_CHAN_FREQ_RANGE_6G_BAND3 8
+#define WL_CHAN_FREQ_RANGE_6G_4BAND 18
/* SROM12 */
#define WL_CHAN_FREQ_RANGE_5G_BAND4 5
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wpa.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wpa.h
old mode 100644
new mode 100755
index 080f60cc..c6f4619
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wpa.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/include/wpa.h
@@ -190,6 +190,13 @@
(cipher) == WPA_CIPHER_BIP_GMAC_128 || \
(cipher) == WPA_CIPHER_BIP_GMAC_256 || \
(cipher) == WPA_CIPHER_BIP_CMAC_256)
+
+/* Unicast deprecated/invalid ciphers */
+#define IS_UNICAST_DEPRECATED_CIPHER(cipher) \
+ ((cipher) == WPA_CIPHER_WEP_40 || \
+ (cipher) == WPA_CIPHER_WEP_104 || \
+ (cipher) == WPA_CIPHER_TKIP)
+
/* WPA TKIP countermeasures parameters */
#define WPA_TKIP_CM_DETECT 60 /* multiple MIC failure window (seconds) */
#define WPA_TKIP_CM_BLOCK 60 /* countermeasures active window (seconds) */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/linux_osl.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/linux_osl.c
old mode 100644
new mode 100755
index e42b1ca..d7d0c79
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/linux_osl.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/linux_osl.c
@@ -1155,15 +1155,6 @@
}
}
#endif // endif
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 1))
-void do_gettimeofday(struct timeval *tv)
-{
- struct timespec64 ts;
- ktime_get_real_ts64(&ts);
- tv->tv_sec = ts.tv_sec;
- tv->tv_usec = ts.tv_nsec;
-}
-#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 1) */
void
osl_delay(uint usec)
{
@@ -1188,12 +1179,12 @@
uint64
osl_sysuptime_us(void)
{
- struct timeval tv;
+ struct timespec64 ts;
uint64 usec;
- do_gettimeofday(&tv);
+ ktime_get_real_ts64(&ts);
/* tv_usec content is fraction of a second */
- usec = (uint64)tv.tv_sec * 1000000ul + tv.tv_usec;
+ usec = (uint64)ts.tv_sec * 1000000ul + (ts.tv_nsec / NSEC_PER_USEC);
return usec;
}
@@ -1222,14 +1213,14 @@
uint64
osl_systztime_us(void)
{
- struct timeval tv;
+ struct timespec64 ts;
uint64 tzusec;
- do_gettimeofday(&tv);
+ ktime_get_real_ts64(&ts);
/* apply timezone */
- tzusec = (uint64)((tv.tv_sec - (sys_tz.tz_minuteswest * 60)) *
+ tzusec = (uint64)((ts.tv_sec - (sys_tz.tz_minuteswest * 60)) *
USEC_PER_SEC);
- tzusec += tv.tv_usec;
+ tzusec += ts.tv_nsec / NSEC_PER_USEC;
return tzusec;
}
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/siutils.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/siutils.c
old mode 100644
new mode 100755
index 8b17cb8..f2746a3
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/siutils.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/siutils.c
@@ -44,7 +44,7 @@
#include <pcie_core.h>
#endif // endif
#ifdef BCMPCIEDEV
-#include <pciedev.h>
+/
#endif /* BCMPCIEDEV */
#include <pcicfg.h>
#include <sbpcmcia.h>
@@ -224,6 +224,7 @@
{
switch (devid) {
case CYW55560_WLAN_ID:
+ case CYW89570_WLAN_ID:
return SI_ENUM_PCIE2_BASE;
}
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_android.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_android.c
old mode 100644
new mode 100755
index e53298b..15e0aeb
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_android.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_android.c
@@ -91,6 +91,13 @@
#define CMD_START "START"
#define CMD_STOP "STOP"
+#ifdef AUTOMOTIVE_FEATURE
+#define CMD_SCAN_ACTIVE "SCAN-ACTIVE"
+#define CMD_SCAN_PASSIVE "SCAN-PASSIVE"
+#define CMD_RSSI "RSSI"
+#define CMD_LINKSPEED "LINKSPEED"
+#endif /* AUTOMOTIVE_FEATURE */
+
#define CMD_RXFILTER_START "RXFILTER-START"
#define CMD_RXFILTER_STOP "RXFILTER-STOP"
#define CMD_RXFILTER_ADD "RXFILTER-ADD"
@@ -133,6 +140,11 @@
#endif /* WL_SUPPORT_AUTO_CHANNEL */
#define CMD_CHANSPEC "CHANSPEC"
+#ifdef AUTOMOTIVE_FEATURE
+#define CMD_DATARATE "DATARATE"
+#define CMD_80211_MODE "MODE" /* 802.11 mode a/b/g/n/ac */
+#define CMD_ASSOC_CLIENTS "ASSOCLIST"
+#endif /* AUTOMOTIVE_FEATURE */
#define CMD_SET_CSA "SETCSA"
#define CMD_RSDB_MODE "RSDB_MODE"
#ifdef WL_SUPPORT_AUTO_CHANNEL
@@ -176,6 +188,9 @@
#define CMD_WLS_BATCHING "WLS_BATCHING"
#endif /* PNO_SUPPORT */
+#ifdef AUTOMOTIVE_FEATURE
+#define CMD_HAPD_MAC_FILTER "HAPD_MAC_FILTER"
+#endif /* AUTOMOTIVE_FEATURE */
#define CMD_ADDIE "ADD_IE"
#define CMD_DELIE "DEL_IE"
@@ -190,6 +205,10 @@
#define CMD_ROAMSCANPERIOD_GET "GETROAMSCANPERIOD"
#define CMD_FULLROAMSCANPERIOD_SET "SETFULLROAMSCANPERIOD"
#define CMD_FULLROAMSCANPERIOD_GET "GETFULLROAMSCANPERIOD"
+#ifdef AUTOMOTIVE_FEATURE
+#define CMD_COUNTRYREV_SET "SETCOUNTRYREV"
+#define CMD_COUNTRYREV_GET "GETCOUNTRYREV"
+#endif /* AUTOMOTIVE_FEATURE */
#endif /* ROAM_API */
#if defined(SUPPORT_RANDOM_MAC_SCAN)
@@ -431,6 +450,8 @@
#define CMD_CHANNEL_WIDTH "CHANNEL_WIDTH"
#define CMD_TRANSITION_DISABLE "TRANSITION_DISABLE"
+#define CMD_SAE_PWE "SAE_PWE"
+#define CMD_MAXASSOC "MAXASSOC"
#ifdef ENABLE_HOGSQS
#define CMD_AP_HOGSQS "HOGSQS"
@@ -456,6 +477,8 @@
};
#endif /* CONNECTION_STATISTICS */
+#define CMD_SCAN_PROTECT_BSS "SCAN_PROTECT_BSS"
+
#ifdef SUPPORT_LQCM
#define CMD_SET_LQCM_ENABLE "SET_LQCM_ENABLE"
#define CMD_GET_LQCM_REPORT "GET_LQCM_REPORT"
@@ -1032,6 +1055,33 @@
}
#endif /* ENABLE_HOGSQS */
+/* The wl_android_scan_protect_bss function does both SET/GET based on parameters passed */
+static int wl_android_scan_protect_bss(struct net_device * dev, char * command, int total_len)
+{
+ int ret = 0, result = 0, bytes_written = 0;
+
+ if (*(command + strlen(CMD_SCAN_PROTECT_BSS)) == '\0') {
+ ret = wldev_iovar_getint(dev, "scan_protect_bss", &result);
+ if (ret) {
+ DHD_ERROR(("%s: Failed to get scan_protect_bss\n", __FUNCTION__));
+ return ret;
+ }
+ bytes_written = snprintf(command, total_len, "%s %d", CMD_SCAN_PROTECT_BSS, result);
+ return bytes_written;
+ }
+ command = (command + strlen(CMD_SCAN_PROTECT_BSS));
+ command++;
+ result = bcm_atoi(command);
+
+ DHD_INFO(("%s : scan_protect_bss = %d\n", __FUNCTION__, result));
+ ret = wldev_iovar_setint(dev, "scan_protect_bss", result);
+ if (ret) {
+ DHD_ERROR(("%s: Failed to set result to %d\n", __FUNCTION__, result));
+ return ret;
+ }
+ return 0;
+}
+
#ifdef DHD_BANDSTEER
static int
wl_android_set_bandsteer(struct net_device *dev, char *command, int total_len)
@@ -1134,6 +1184,33 @@
}
#endif /* DHD_BANDSTEER */
+static int
+wl_android_set_maxassoc_limit(struct net_device *dev, char *command, int total_len)
+{
+ int ret = 0, max_assoc = 0, bytes_written = 0;
+
+ if (*(command + strlen(CMD_MAXASSOC)) == '\0') {
+ ret = wldev_iovar_getint(dev, "maxassoc", &max_assoc);
+ if (ret) {
+ DHD_ERROR(("%s: Failed to get maxassoc limit\n", __FUNCTION__));
+ return ret;
+ }
+ bytes_written = snprintf(command, total_len, "%s %d", CMD_MAXASSOC, max_assoc);
+ return bytes_written;
+ }
+ command = (command + strlen(CMD_MAXASSOC));
+ command++;
+ max_assoc = bcm_atoi(command);
+
+ DHD_INFO(("%s : maxassoc limit = %d\n", __FUNCTION__, max_assoc));
+ ret = wldev_iovar_setint(dev, "maxassoc", max_assoc);
+ if (ret) {
+ DHD_ERROR(("%s: Failed to set maxassoc limit to %d\n", __FUNCTION__, max_assoc));
+ return ret;
+ }
+ return 0;
+}
+
#ifdef WLWFDS
static int wl_android_set_wfds_hash(
struct net_device *dev, char *command, bool enable)
@@ -1172,6 +1249,111 @@
}
#endif /* WLWFDS */
+#ifdef AUTOMOTIVE_FEATURE
+static int wl_android_get_link_speed(struct net_device *net, char *command, int total_len)
+{
+ int link_speed;
+ int bytes_written;
+ int error;
+
+ error = wldev_get_link_speed(net, &link_speed);
+ if (error) {
+ DHD_ERROR(("Get linkspeed failed \n"));
+ return -1;
+ }
+
+ /* Convert Kbps to Android Mbps */
+ link_speed = link_speed / 1000;
+ bytes_written = snprintf(command, total_len, "LinkSpeed %d", link_speed);
+ DHD_INFO(("wl_android_get_link_speed: command result is %s\n", command));
+ return bytes_written;
+}
+
+static int wl_android_get_rssi(struct net_device *net, char *command, int total_len)
+{
+ wlc_ssid_t ssid = {0, {0}};
+ int bytes_written = 0;
+ int error = 0;
+ scb_val_t scbval;
+ char *delim = NULL;
+ struct net_device *target_ndev = net;
+#ifdef WL_VIRTUAL_APSTA
+ char *pos = NULL;
+ struct bcm_cfg80211 *cfg;
+#endif /* WL_VIRTUAL_APSTA */
+
+ delim = strchr(command, ' ');
+ /* For Ap mode rssi command would be
+ * driver rssi <sta_mac_addr>
+ * for STA/GC mode
+ * driver rssi
+ */
+ if (delim) {
+ /* Ap/GO mode
+ * driver rssi <sta_mac_addr>
+ */
+ DHD_TRACE(("wl_android_get_rssi: cmd:%s\n", delim));
+ /* skip space from delim after finding char */
+ delim++;
+ if (!(bcm_ether_atoe((delim), &scbval.ea))) {
+ DHD_ERROR(("wl_android_get_rssi: address err\n"));
+ return -1;
+ }
+ scbval.val = htod32(0);
+ DHD_TRACE(("wl_android_get_rssi: address:"MACDBG, MAC2STRDBG(scbval.ea.octet)));
+#ifdef WL_VIRTUAL_APSTA
+ /* RSDB AP may have another virtual interface
+ * In this case, format of private command is as following,
+ * DRIVER rssi <sta_mac_addr> <AP interface name>
+ */
+
+ /* Current position is start of MAC address string */
+ pos = delim;
+ delim = strchr(pos, ' ');
+ if (delim) {
+ /* skip space from delim after finding char */
+ delim++;
+ if (strnlen(delim, IFNAMSIZ)) {
+ cfg = wl_get_cfg(net);
+ target_ndev = wl_get_ap_netdev(cfg, delim);
+ if (target_ndev == NULL)
+ target_ndev = net;
+ }
+ }
+#endif /* WL_VIRTUAL_APSTA */
+ }
+ else {
+ /* STA/GC mode */
+ bzero(&scbval, sizeof(scb_val_t));
+ }
+
+ error = wldev_get_rssi(target_ndev, &scbval);
+ if (error)
+ return -1;
+
+ error = wldev_get_ssid(target_ndev, &ssid);
+ if (error)
+ return -1;
+ if ((ssid.SSID_len == 0) || (ssid.SSID_len > DOT11_MAX_SSID_LEN)) {
+ DHD_ERROR(("wl_android_get_rssi: wldev_get_ssid failed\n"));
+ } else if (total_len <= ssid.SSID_len) {
+ return -ENOMEM;
+ } else {
+ memcpy(command, ssid.SSID, ssid.SSID_len);
+ bytes_written = ssid.SSID_len;
+ }
+ if ((total_len - bytes_written) < (strlen(" rssi -XXX") + 1))
+ return -ENOMEM;
+
+ bytes_written += scnprintf(&command[bytes_written], total_len - bytes_written,
+ " rssi %d", scbval.val);
+ command[bytes_written] = '\0';
+
+ DHD_TRACE(("wl_android_get_rssi: command result is %s (%d)\n", command, bytes_written));
+ return bytes_written;
+}
+#endif /* AUTOMOTIVE_FEATURE */
+
static int wl_android_set_suspendopt(struct net_device *dev, char *command)
{
int suspend_flag;
@@ -1217,6 +1399,25 @@
return ret;
}
+#ifdef AUTOMOTIVE_FEATURE
+int wl_android_get_80211_mode(struct net_device *dev, char *command, int total_len)
+{
+ uint8 mode[5];
+ int error = 0;
+ int bytes_written = 0;
+
+ error = wldev_get_mode(dev, mode, sizeof(mode));
+ if (error)
+ return -1;
+
+ DHD_INFO(("wl_android_get_80211_mode: mode:%s\n", mode));
+ bytes_written = snprintf(command, total_len, "%s %s", CMD_80211_MODE, mode);
+ DHD_INFO(("wl_android_get_80211_mode: command:%s EXIT\n", command));
+ return bytes_written;
+
+}
+#endif /* AUTOMOTIVE_FEATURE */
+
extern chanspec_t
wl_chspec_driver_to_host(chanspec_t chanspec);
int wl_android_get_chanspec(struct net_device *dev, char *command, int total_len)
@@ -1301,6 +1502,64 @@
}
/* returns current datarate datarate returned from firmware are in 500kbps */
+#ifdef AUTOMOTIVE_FEATURE
+int wl_android_get_datarate(struct net_device *dev, char *command, int total_len)
+{
+ int error = 0;
+ int datarate = 0;
+ int bytes_written = 0;
+
+ error = wldev_get_datarate(dev, &datarate);
+ if (error)
+ return -1;
+
+ DHD_INFO(("wl_android_get_datarate: datarate:%d\n", datarate));
+
+ bytes_written = snprintf(command, total_len, "%s %d", CMD_DATARATE, (datarate/2));
+ return bytes_written;
+}
+
+int wl_android_get_assoclist(struct net_device *dev, char *command, int total_len)
+{
+ int error = 0;
+ int bytes_written = 0;
+ uint i;
+ int len = 0;
+ char mac_buf[MAX_NUM_OF_ASSOCLIST *
+ sizeof(struct ether_addr) + sizeof(uint)] = {0};
+ struct maclist *assoc_maclist = (struct maclist *)mac_buf;
+
+ DHD_TRACE(("wl_android_get_assoclist: ENTER\n"));
+
+ assoc_maclist->count = htod32(MAX_NUM_OF_ASSOCLIST);
+
+ error = wldev_ioctl_get(dev, WLC_GET_ASSOCLIST, assoc_maclist, sizeof(mac_buf));
+ if (error)
+ return -1;
+
+ assoc_maclist->count = dtoh32(assoc_maclist->count);
+ bytes_written = snprintf(command, total_len, "%s listcount: %d Stations:",
+ CMD_ASSOC_CLIENTS, assoc_maclist->count);
+
+ for (i = 0; i < assoc_maclist->count; i++) {
+ len = snprintf(command + bytes_written, total_len - bytes_written, " " MACDBG,
+ MAC2STRDBG(assoc_maclist->ea[i].octet));
+ /* A return value of '(total_len - bytes_written)' or more means that the
+ * output was truncated
+ */
+ if ((len > 0) && (len < (total_len - bytes_written))) {
+ bytes_written += len;
+ } else {
+ DHD_ERROR(("wl_android_get_assoclist: Insufficient buffer %d,"
+ " bytes_written %d\n",
+ total_len, bytes_written));
+ bytes_written = -1;
+ break;
+ }
+ }
+ return bytes_written;
+}
+#endif /* AUTOMOTIVE_FEATURE */
static int wl_android_get_channel_list(struct net_device *dev, char *command, int total_len)
{
@@ -2058,6 +2317,83 @@
return bytes_written;
}
+#ifdef AUTOMOTIVE_FEATURE
+int wl_android_set_country_rev(
+ struct net_device *dev, char* command)
+{
+ int error = 0;
+ wl_country_t cspec = {{0}, 0, {0} };
+ char country_code[WLC_CNTRY_BUF_SZ];
+ char smbuf[WLC_IOCTL_SMLEN];
+ int rev = 0;
+
+ /*
+ * SETCOUNTRYREV driver command provides support setting the country.
+ * e.g US, DE, JP etc via supplicant. Once set, band and channels
+ * too automatically gets updated based on the country.
+ * Usage:
+ * > IFNAME=wlan0 DRIVER SETCOUNTRYREV JP
+ * OK
+ */
+
+ bzero(country_code, sizeof(country_code));
+ sscanf(command+sizeof("SETCOUNTRYREV"), "%3s %10d", country_code, &rev);
+ WL_TRACE(("country_code = %s, rev = %d\n", country_code, rev));
+
+ memcpy(cspec.country_abbrev, country_code, sizeof(country_code));
+ memcpy(cspec.ccode, country_code, sizeof(country_code));
+ cspec.rev = rev;
+
+ error = wldev_iovar_setbuf(dev, "country", (char *)&cspec,
+ sizeof(cspec), smbuf, sizeof(smbuf), NULL);
+
+ if (error) {
+ DHD_ERROR(("wl_android_set_country_rev: set country '%s/%d' failed code %d\n",
+ cspec.ccode, cspec.rev, error));
+ } else {
+ dhd_bus_country_set(dev, &cspec, true);
+ DHD_INFO(("wl_android_set_country_rev: set country '%s/%d'\n",
+ cspec.ccode, cspec.rev));
+ }
+
+ return error;
+}
+
+static int wl_android_get_country_rev(
+ struct net_device *dev, char *command, int total_len)
+{
+ int error;
+ int bytes_written;
+ char smbuf[WLC_IOCTL_SMLEN];
+ wl_country_t cspec;
+
+ /*
+ * GETCOUNTRYREV driver command provides support getting the country.
+ * e.g US, DE, JP etc via supplicant.
+ * Usage:
+ * > IFNAME=wlan0 DRIVER GETCOUNTRYREV
+ * GETCOUNTRYREV JP 0
+ */
+
+ error = wldev_iovar_getbuf(dev, "country", NULL, 0, smbuf,
+ sizeof(smbuf), NULL);
+
+ if (error) {
+ DHD_ERROR(("wl_android_get_country_rev: get country failed code %d\n",
+ error));
+ return -1;
+ } else {
+ memcpy(&cspec, smbuf, sizeof(cspec));
+ DHD_INFO(("wl_android_get_country_rev: get country '%c%c %d'\n",
+ cspec.ccode[0], cspec.ccode[1], cspec.rev));
+ }
+
+ bytes_written = snprintf(command, total_len, "%s %c%c %d",
+ CMD_COUNTRYREV_GET, cspec.ccode[0], cspec.ccode[1], cspec.rev);
+
+ return bytes_written;
+}
+#endif /* AUTOMOTIVE_FEATURE */
#endif /* ROAM_API */
#ifdef WES_SUPPORT
@@ -3767,6 +4103,87 @@
* HAPD_MAC_FILTER mac_mode mac_cnt mac_addr1 mac_addr2
*
*/
+#ifdef AUTOMOTIVE_FEATURE
+static int
+wl_android_set_mac_address_filter(struct net_device *dev, char* str)
+{
+ int i;
+ int ret = 0;
+ int macnum = 0;
+ int macmode = MACLIST_MODE_DISABLED;
+ struct maclist *list;
+ char eabuf[ETHER_ADDR_STR_LEN];
+ const char *token;
+ struct bcm_cfg80211 *cfg = wl_get_cfg(dev);
+
+ /* string should look like below (macmode/macnum/maclist) */
+ /* 1 2 00:11:22:33:44:55 00:11:22:33:44:ff */
+
+ /* get the MAC filter mode */
+ token = strsep((char**)&str, " ");
+ if (!token) {
+ return -1;
+ }
+ macmode = bcm_atoi(token);
+
+ if (macmode < MACLIST_MODE_DISABLED || macmode > MACLIST_MODE_ALLOW) {
+ DHD_ERROR(("wl_android_set_mac_address_filter: invalid macmode %d\n", macmode));
+ return -1;
+ }
+
+ token = strsep((char**)&str, " ");
+ if (!token) {
+ return -1;
+ }
+ macnum = bcm_atoi(token);
+ if (macnum < 0 || macnum > MAX_NUM_MAC_FILT) {
+ DHD_ERROR(("wl_android_set_mac_address_filter: invalid number of MAC"
+ " address entries %d\n",
+ macnum));
+ return -1;
+ }
+ /* allocate memory for the MAC list */
+ list = (struct maclist*) MALLOCZ(cfg->osh, sizeof(int) +
+ sizeof(struct ether_addr) * macnum);
+ if (!list) {
+ DHD_ERROR(("wl_android_set_mac_address_filter : failed to allocate memory\n"));
+ return -1;
+ }
+ /* prepare the MAC list */
+ list->count = htod32(macnum);
+ bzero((char *)eabuf, ETHER_ADDR_STR_LEN);
+ for (i = 0; i < list->count; i++) {
+ token = strsep((char**)&str, " ");
+ if (token == NULL) {
+ DHD_ERROR(("wl_android_set_mac_address_filter : No mac address present\n"));
+ ret = -EINVAL;
+ goto exit;
+ }
+ strlcpy(eabuf, token, sizeof(eabuf));
+ if (!(ret = bcm_ether_atoe(eabuf, &list->ea[i]))) {
+ DHD_ERROR(("wl_android_set_mac_address_filter : mac parsing err index=%d,"
+ " addr=%s\n",
+ i, eabuf));
+ list->count = i;
+ break;
+ }
+ DHD_INFO(("wl_android_set_mac_address_filter : %d/%d MACADDR=%s",
+ i, list->count, eabuf));
+ }
+ if (i == 0)
+ goto exit;
+
+ /* set the list */
+ if ((ret = wl_android_set_ap_mac_list(dev, macmode, list)) != 0)
+ DHD_ERROR(("wl_android_set_mac_address_filter: Setting MAC list failed error=%d\n",
+ ret));
+
+exit:
+ MFREE(cfg->osh, list, sizeof(int) + sizeof(struct ether_addr) * macnum);
+
+ return ret;
+}
+#endif /* AUTOMOTIVE_FEATURE */
/**
* Global function definitions (declared in wl_android.h)
*/
@@ -8780,6 +9197,20 @@
#endif /* BT_OVER_SDIO */
#endif /* SUPPORT_DEEP_SLEEP */
}
+#ifdef AUTOMOTIVE_FEATURE
+ else if (strnicmp(command, CMD_SCAN_ACTIVE, strlen(CMD_SCAN_ACTIVE)) == 0) {
+ wl_cfg80211_set_passive_scan(net, command);
+ }
+ else if (strnicmp(command, CMD_SCAN_PASSIVE, strlen(CMD_SCAN_PASSIVE)) == 0) {
+ wl_cfg80211_set_passive_scan(net, command);
+ }
+ else if (strnicmp(command, CMD_RSSI, strlen(CMD_RSSI)) == 0) {
+ bytes_written = wl_android_get_rssi(net, command, priv_cmd.total_len);
+ }
+ else if (strnicmp(command, CMD_LINKSPEED, strlen(CMD_LINKSPEED)) == 0) {
+ bytes_written = wl_android_get_link_speed(net, command, priv_cmd.total_len);
+ }
+#endif /* AUTOMOTIVE_FEATURE */
#ifdef PKT_FILTER_SUPPORT
else if (strnicmp(command, CMD_RXFILTER_START, strlen(CMD_RXFILTER_START)) == 0) {
bytes_written = net_os_enable_packet_filter(net, 1);
@@ -8902,6 +9333,15 @@
} else if (strnicmp(command, CMD_BLOCKASSOC, strlen(CMD_BLOCKASSOC)) == 0) {
bytes_written = wl_android_block_associations(net, command, priv_cmd.total_len);
}
+#ifdef AUTOMOTIVE_FEATURE
+ else if (strnicmp(command, CMD_DATARATE, strlen(CMD_DATARATE)) == 0) {
+ bytes_written = wl_android_get_datarate(net, command, priv_cmd.total_len);
+ } else if (strnicmp(command, CMD_80211_MODE, strlen(CMD_80211_MODE)) == 0) {
+ bytes_written = wl_android_get_80211_mode(net, command, priv_cmd.total_len);
+ } else if (strnicmp(command, CMD_ASSOC_CLIENTS, strlen(CMD_ASSOC_CLIENTS)) == 0) {
+ bytes_written = wl_android_get_assoclist(net, command, priv_cmd.total_len);
+ }
+#endif /* AUTOMOTIVE_FEATURE */
else if (strnicmp(command, CMD_RSDB_MODE, strlen(CMD_RSDB_MODE)) == 0) {
bytes_written = wl_android_get_rsdb_mode(net, command, priv_cmd.total_len);
}
@@ -8938,6 +9378,24 @@
bytes_written = wl_android_get_full_roam_scan_period(net, command,
priv_cmd.total_len);
}
+#ifdef AUTOMOTIVE_FEATURE
+ else if (strnicmp(command, CMD_COUNTRYREV_SET,
+ strlen(CMD_COUNTRYREV_SET)) == 0) {
+ bytes_written = wl_android_set_country_rev(net, command);
+#ifdef FCC_PWR_LIMIT_2G
+ if (wldev_iovar_setint(net, "fccpwrlimit2g", FALSE)) {
+ DHD_ERROR(("wl_handle_private_cmd: fccpwrlimit2g"
+ " deactivation is failed\n"));
+ } else {
+ DHD_ERROR(("wl_handle_private_cmd: fccpwrlimit2g is deactivated\n"));
+ }
+#endif /* FCC_PWR_LIMIT_2G */
+ } else if (strnicmp(command, CMD_COUNTRYREV_GET,
+ strlen(CMD_COUNTRYREV_GET)) == 0) {
+ bytes_written = wl_android_get_country_rev(net, command,
+ priv_cmd.total_len);
+ }
+#endif /* AUTOMOTIVE_FEATURE */
#endif /* ROAM_API */
#ifdef WES_SUPPORT
else if (strnicmp(command, CMD_GETROAMSCANCONTROL, strlen(CMD_GETROAMSCANCONTROL)) == 0) {
@@ -9249,6 +9707,12 @@
wl_android_set_hide_ssid(net, (const char*)(command+skip));
}
#endif /* SUPPORT_HIDDEN_AP */
+#ifdef AUTOMOTIVE_FEATURE
+ else if (strnicmp(command, CMD_HAPD_MAC_FILTER, strlen(CMD_HAPD_MAC_FILTER)) == 0) {
+ int skip = strlen(CMD_HAPD_MAC_FILTER) + 1;
+ wl_android_set_mac_address_filter(net, command+skip);
+ }
+#endif /* AUTOMOTIVE_FEATURE */
else if (strnicmp(command, CMD_SETROAMMODE, strlen(CMD_SETROAMMODE)) == 0)
bytes_written = wl_android_set_roam_mode(net, command);
#if defined(BCMFW_ROAM_ENABLE)
@@ -9654,6 +10118,16 @@
int transition_disabled = *(command + strlen(CMD_TRANSITION_DISABLE) + 1) - '0';
bytes_written = wl_cfg80211_set_transition_mode(net, transition_disabled);
}
+ else if (strnicmp(command, CMD_SAE_PWE, strlen(CMD_SAE_PWE)) == 0) {
+ u8 sae_pwe = *(command + strlen(CMD_SAE_PWE) + 1) - '0';
+ bytes_written = wl_cfg80211_set_sae_pwe(net, sae_pwe);
+ }
+ else if (strnicmp(command, CMD_MAXASSOC, strlen(CMD_MAXASSOC)) == 0) {
+ bytes_written = wl_android_set_maxassoc_limit(net, command, priv_cmd.total_len);
+ }
+ else if (strnicmp(command, CMD_SCAN_PROTECT_BSS, strlen(CMD_SCAN_PROTECT_BSS)) == 0) {
+ bytes_written = wl_android_scan_protect_bss(net, command, priv_cmd.total_len);
+ }
else {
DHD_ERROR(("Unknown PRIVATE command %s - ignored\n", command));
bytes_written = scnprintf(command, sizeof("FAIL"), "FAIL");
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.c
old mode 100644
new mode 100755
index 92a182b..c739529
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.c
@@ -168,6 +168,9 @@
uint fw_ap_select = false;
#endif /* WL_FW_OCE_AP_SELECT && (ROAM_ENABLE || BCMFW_ROAM_ENABLE) */
module_param(fw_ap_select, uint, 0660);
+/* this flag enable triggerrs bgscan method from supplicant */
+uint us_ap_select = false;
+module_param(us_ap_select, uint, 0660);
static struct device *cfg80211_parent_dev = NULL;
static struct bcm_cfg80211 *g_bcmcfg = NULL;
@@ -565,10 +568,10 @@
#endif // endif
static int wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_connect_params *sme);
-#if defined(WL_FILS)
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0))
static int wl_cfg80211_update_connect_params(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_connect_params *sme, u32 changed);
-#endif /* WL_FILS */
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0) */
static s32 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
u16 reason_code);
#if defined(WL_CFG80211_P2P_DEV_IF)
@@ -836,7 +839,7 @@
static s32 wl_get_assoc_ies(struct bcm_cfg80211 *cfg, struct net_device *ndev);
static s32 wl_ch_to_chanspec(struct net_device *dev, int ch,
- struct wl_join_params *join_params, size_t *join_params_size, uint32 center_freq);
+ struct wl_join_params *join_params, size_t *join_params_size, struct ieee80211_channel *chan);
void wl_cfg80211_clear_security(struct bcm_cfg80211 *cfg);
/*
@@ -947,7 +950,7 @@
void reset_roam_cache(struct bcm_cfg80211 *cfg);
void add_roam_cache(struct bcm_cfg80211 *cfg, wl_bss_info_t *bi);
int get_roam_channel_list(int target_chan, chanspec_t *channels,
- int n_channels, const wlc_ssid_t *ssid, int ioctl_ver, uint32 center_freq);
+ int n_channels, const wlc_ssid_t *ssid, int ioctl_ver, struct ieee80211_channel *chan);
void set_roam_band(int band);
#endif /* ESCAN_CHANNEL_CACHE */
@@ -1231,12 +1234,78 @@
};
#endif /* WL_6E */
+#ifdef WL11AX
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 21))
+static u32 he = 0;
+struct ieee80211_sband_iftype_data sdata[IEEE80211_NUM_BANDS];
+static int wl_update_he_cap(struct bcm_cfg80211 *cfg, struct ieee80211_sband_iftype_data *data, int band)
+{
+ int idx = 1;
+ struct ieee80211_sta_he_cap *he_cap = &data->he_cap;
+ struct ieee80211_he_cap_elem *he_cap_elem =
+ &he_cap->he_cap_elem;
+ struct ieee80211_he_mcs_nss_supp *he_mcs =
+ &he_cap->he_mcs_nss_supp;
+
+ if(data == NULL) {
+ WL_ERR(("failed to allco mem\n"));
+ return 0;
+ }
+
+ data->types_mask= BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);
+ he_cap->has_he = true;
+ he_cap_elem->mac_cap_info[0] =
+ IEEE80211_HE_MAC_CAP0_HTC_HE | IEEE80211_HE_MAC_CAP0_TWT_REQ;
+
+ he_cap_elem->mac_cap_info[2] =
+ IEEE80211_HE_MAC_CAP2_BSR;
+ if ((band == NL80211_BAND_5GHZ) || (band == NL80211_BAND_6GHZ))
+ he_cap_elem->phy_cap_info[0] =
+ IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
+ IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
+ IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G;
+ he_cap_elem->phy_cap_info[1] =
+ IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD;
+ he_cap_elem->phy_cap_info[2] =
+ IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US;
+ he_cap_elem->phy_cap_info[3] =
+ IEEE80211_HE_PHY_CAP3_SU_BEAMFORMER;
+ he_cap_elem->phy_cap_info[4] =
+ IEEE80211_HE_PHY_CAP4_SU_BEAMFORMEE |
+ IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_MASK |
+ IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_4;
+ he_cap_elem->phy_cap_info[5] =
+ IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_2;
+ he_cap_elem->phy_cap_info[6] =
+ IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_42_SU |
+ IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
+ IEEE80211_HE_PHY_CAP6_TRIG_SU_BEAMFORMER_FB |
+ IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMER_FB |
+ IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
+ IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT;
+ he_cap_elem->phy_cap_info[7] =
+ IEEE80211_HE_PHY_CAP7_MAX_NC_1;
+ he_cap_elem->phy_cap_info[8] =
+ IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU |
+ IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU;
+ he_cap_elem->phy_cap_info[9] =
+ IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
+ IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU;
+ he_mcs->rx_mcs_80 = cpu_to_le16(0xfffa);
+ he_mcs->tx_mcs_80 = cpu_to_le16(0xfffa);
+ he_mcs->rx_mcs_160 = cpu_to_le16((0xfffa));
+ he_mcs->tx_mcs_160 = cpu_to_le16((0xfffa));
+ return idx;
+}
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 21) */
+#endif /* WL11AX */
+
static struct ieee80211_supported_band __wl_band_2ghz = {
.band = IEEE80211_BAND_2GHZ,
.channels = __wl_2ghz_channels,
.n_channels = ARRAY_SIZE(__wl_2ghz_channels),
.bitrates = wl_g_rates,
- .n_bitrates = wl_g_rates_size
+ .n_bitrates = wl_g_rates_size,
};
static struct ieee80211_supported_band __wl_band_5ghz_a = {
@@ -1244,7 +1313,7 @@
.channels = __wl_5ghz_a_channels,
.n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
.bitrates = wl_a_rates,
- .n_bitrates = wl_a_rates_size
+ .n_bitrates = wl_a_rates_size,
};
#ifdef WL_6E
@@ -1384,7 +1453,7 @@
{WLAN_AKM_SUITE_SAE, WPA3_AUTH_SAE_PSK},
#endif /* WL_SAE */
{WLAN_AKM_SUITE_FT_8021X_SHA384, WPA3_AUTH_1X_SHA384 | WPA2_AUTH_FT},
- {WLAN_AKM_SUITE_DPP, WFA_AUTH_DPP}
+ {WLAN_AKM_SUITE_DPP, WPA2_WFA_AUTH_DPP}
};
#define BUFSZ 8
@@ -1934,6 +2003,13 @@
else {
bss = (wl_bss_info_t *) (buf + 4);
chspec = bss->chanspec;
+#ifdef WL_6E
+ /* Avoid p2p bring up in 6G based on bssinfo */
+ if (CHSPEC_IS6G(chspec)) {
+ channel = WL_P2P_TEMP_CHAN_5G;
+ chspec = wl_ch_host_to_driver(channel);
+ }
+#endif /* WL_6E */
WL_DBG(("Valid BSS Found. chanspec:%d \n", chspec));
}
@@ -1974,7 +2050,6 @@
dhd_wlfc_get_enable(dhd, &wlfc_enabled);
if (wlfc_enabled && cfg->wlfc_on && dhd->op_mode != DHD_FLAG_HOSTAP_MODE &&
dhd->op_mode != DHD_FLAG_IBSS_MODE) {
- dhd_wlfc_deinit(dhd);
cfg->wlfc_on = false;
}
}
@@ -6535,7 +6610,8 @@
}
#endif /* WL_FILS */
-#if defined(WL_FILS)
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0))
+#define UPDATE_ASSOC_IES BIT(0)
#ifndef UPDATE_FILS_ERP_INFO
#define UPDATE_FILS_ERP_INFO BIT(1)
#define UPDATE_AUTH_TYPE BIT(2)
@@ -6545,7 +6621,24 @@
wl_cfg80211_update_connect_params(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_connect_params *sme, u32 changed)
{
+ struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
+ s32 bssidx = -1;
s32 err = BCME_OK;
+
+ if (changed & UPDATE_ASSOC_IES) {
+ WL_DBG(("update assoc ies\n"));
+ bssidx = wl_get_bssidx_by_wdev(cfg, dev->ieee80211_ptr);
+
+ err = wl_cfg80211_set_mgmt_vndr_ies(cfg, ndev_to_cfgdev(dev), bssidx,
+ VNDR_IE_ASSOCREQ_FLAG, sme->ie, sme->ie_len);
+
+ if (err) {
+ WL_ERR(("error updating vndr ies\n"));
+ goto exit;
+ }
+ }
+
+#if defined(WL_FILS)
if (changed & UPDATE_FILS_ERP_INFO) {
err = wl_set_fils_params(dev, sme);
@@ -6564,11 +6657,12 @@
if ((changed & UPDATE_FILS_ERP_INFO) && !(changed & UPDATE_AUTH_TYPE)) {
WL_DBG(("Warning: FILS ERP params are set, but authentication type - not\n"));
}
+#endif // endif
exit:
return err;
}
-#endif /* WL_FILS */
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0) */
#ifdef WL_SAE
static int
@@ -6760,6 +6854,9 @@
if (skip_hints) {
/* Let fw choose the best AP */
WL_INFORM(("skipping bssid & channel hint\n"));
+ /* sme->channel can point to an invalid address
+ * which gets assigned to chan instead of NULL */
+ chan = NULL;
} else {
if (sme->channel_hint) {
chan = sme->channel_hint;
@@ -6989,7 +7086,7 @@
memcpy(ssid.SSID, sme->ssid, sme->ssid_len);
ssid.SSID_len = (uint32)sme->ssid_len;
chan_cnt = get_roam_channel_list(cfg->channel, chanspec_list,
- MAX_ROAM_CHANNEL, &ssid, ioctl_version, chan->center_freq);
+ MAX_ROAM_CHANNEL, &ssid, ioctl_version, chan);
WL_DBG(("RCC channel count:%d \n", chan_cnt));
}
#endif /* ESCAN_CHANNEL_CACHE */
@@ -7069,7 +7166,9 @@
* from target AP at a noisy air only during connect command
*/
#ifdef WL_6E
- if (chan->center_freq > FREQ_START_6G_CHANNEL) {
+ /* If chan is NULL in case of fw_ap_select=1
+ * avoiding dereferencing chan->center_freq */
+ if (chan && chan->center_freq > FREQ_START_6G_CHANNEL) {
ext_join_params->scan.active_time = chan_cnt ?
WL_SCAN_JOIN_ACTIVE_DWELL_TIME_MS_6E : -1;
ext_join_params->scan.passive_time = chan_cnt ?
@@ -7215,7 +7314,7 @@
memcpy(&join_params.params.bssid, ðer_bcast, ETH_ALEN);
if (wl_ch_to_chanspec(dev, cfg->channel, &join_params, &join_params_size,
- chan->center_freq) < 0) {
+ chan) < 0) {
WL_ERR(("Invalid chanspec\n"));
return -EINVAL;
}
@@ -10387,6 +10486,17 @@
return err;
}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0))
+static void
+wl_cfg80211_update_mgmt_frame_register(struct wiphy *wiphy, struct wireless_dev *wdev,
+ struct mgmt_frame_regs *upd)
+{
+ WL_DBG(("mgmt_frame_regs: %x %x %x %x\n", upd->global_stypes,upd->interface_stypes,
+ upd->global_mcast_stypes,upd->interface_mcast_stypes));
+
+ return;
+}
+#else
static void
wl_cfg80211_mgmt_frame_register(struct wiphy *wiphy, bcm_struct_cfgdev *cfgdev,
u16 frame, bool reg)
@@ -10399,6 +10509,7 @@
return;
}
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) */
static s32
wl_cfg80211_change_bss(struct wiphy *wiphy,
@@ -10934,7 +11045,7 @@
WL_ERR(("No Key Mgmt Info\n"));
}
} else if (!bcmp(mgmt->list[cnt].oui, WFA_OUI, WFA_OUI_LEN))
- wpa_auth |= WFA_AUTH_DPP;
+ wpa_auth |= WPA2_WFA_AUTH_DPP;
}
if ((len -= (WPA_IE_SUITE_COUNT_LEN + (WPA_SUITE_LEN * suite_count))) >= RSN_CAP_LEN) {
@@ -12706,9 +12817,6 @@
if ((err = wldev_iovar_setint(dev, "closednet", 1)) < 0)
WL_ERR(("failed to set hidden : %d\n", err));
WL_DBG(("hidden_ssid_enum_val: %d \n", info->hidden_ssid));
- } else {
- if ((err = wldev_iovar_setint(dev, "closednet", 0)) < 0)
- WL_ERR(("failed to set hidden : %d\n", err));
}
@@ -13505,7 +13613,11 @@
.remain_on_channel = wl_cfg80211_remain_on_channel,
.cancel_remain_on_channel = wl_cfg80211_cancel_remain_on_channel,
.mgmt_tx = wl_cfg80211_mgmt_tx,
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0))
+ .update_mgmt_frame_registrations = wl_cfg80211_update_mgmt_frame_register,
+#else
.mgmt_frame_register = wl_cfg80211_mgmt_frame_register,
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) */
.change_bss = wl_cfg80211_change_bss,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 6, 0)) || defined(WL_COMPAT_WIRELESS)
.set_channel = wl_cfg80211_set_channel,
@@ -13544,10 +13656,12 @@
.set_rekey_data = wl_cfg80211_set_rekey_data,
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 0) */
#endif /* GTK_OFFLOAD_SUPPORT */
-#if defined(WL_FILS)
+#if defined(WL_FILS) || defined(WL_OWE)
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0))
/* This should be enabled from kernel version which supports this */
.update_connect_params = wl_cfg80211_update_connect_params,
-#endif /* WL_FILS */
+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0) */
+#endif /* WL_FILS || defined(WL_OWE) */
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0))
.set_pmk = wl_cfg80211_set_pmk,
.del_pmk = wl_cfg80211_del_pmk,
@@ -13736,7 +13850,11 @@
* fw_ap_select variable determines whether FW selects the AP or the
* user space selects the target AP within the given ESS.
*/
- wdev->wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
+
+ if (!us_ap_select)
+ wdev->wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
+ else
+ WL_MEM(("upper layer roam is selected %s\n", __FUNCTION__));
#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 15, 0) */
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)) || defined(WL_COMPAT_WIRELESS)
wdev->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
@@ -13964,6 +14082,9 @@
struct wl_scan_req *sr = wl_to_sr(cfg);
struct beacon_proberesp *beacon_proberesp;
struct cfg80211_bss *cbss = NULL;
+#if defined(WL_SUPPORT_BSS_BOOTTIME) && (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ struct cfg80211_inform_bss bss_data = {0x00, };
+#endif /* WL_SUPPORT_BSS_BOOTTIME */
dhd_pub_t *dhdp = (dhd_pub_t *)(cfg->pub);
log_conn_event_t *event_data = NULL;
tlv_log *tlv_data = NULL;
@@ -14060,22 +14181,33 @@
notif_bss_info->frame_len));
signal = notif_bss_info->rssi * 100;
+#if defined(WL_SUPPORT_BSS_BOOTTIME) && (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ bss_data.chan = channel;
+ bss_data.scan_width = NL80211_BSS_CHAN_WIDTH_20;
+ bss_data.boottime_ns = ktime_to_ns(ktime_get_boottime());
+ bss_data.signal = signal;
+#endif /* WL_SUPPORT_BSS_BOOTTIME */
if (!mgmt->u.probe_resp.timestamp) {
+#if defined(WL_SUPPORT_BSS_BOOTTIME) && (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ mgmt->u.probe_resp.timestamp = bss_data.boottime_ns / 1000;
+#else
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 20, 0))
struct timespec ts;
+#else
+ struct timespec64 ts;
+#endif // endif
get_monotonic_boottime(&ts);
mgmt->u.probe_resp.timestamp = ((u64)ts.tv_sec*1000000)
+ ts.tv_nsec / 1000;
-#else
- struct timeval tv;
- do_gettimeofday(&tv);
- mgmt->u.probe_resp.timestamp = ((u64)tv.tv_sec*1000000)
- + tv.tv_usec;
-#endif // endif
+#endif /* WL_SUPPORT_BSS_BOOTTIME */
}
-
+#if defined(WL_SUPPORT_BSS_BOOTTIME) && (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ cbss = cfg80211_inform_bss_frame_data(wiphy, &bss_data, mgmt,
+ le16_to_cpu(notif_bss_info->frame_len), aflags);
+#else
cbss = cfg80211_inform_bss_frame(wiphy, channel, mgmt,
le16_to_cpu(notif_bss_info->frame_len), signal, aflags);
+#endif /* WL_SUPPORT_BSS_BOOTTIME */
if (unlikely(!cbss)) {
WL_ERR(("cfg80211_inform_bss_frame error bssid " MACDBG " channel %d \n",
MAC2STRDBG((u8*)(&bi->BSSID)), notif_bss_info->channel));
@@ -16363,7 +16495,7 @@
}
static s32 wl_ch_to_chanspec(struct net_device *dev, int ch, struct wl_join_params *join_params,
- size_t *join_params_size, uint32 center_freq)
+ size_t *join_params_size, struct ieee80211_channel *chan)
{
chanspec_t chanspec = 0, chspec;
struct bcm_cfg80211 *cfg =
@@ -16374,7 +16506,7 @@
join_params->params.chanspec_list[0] = ch;
#ifdef WL_6E
- if (center_freq > FREQ_START_6G_CHANNEL) {
+ if (chan->center_freq > FREQ_START_6G_CHANNEL) {
chanspec |= WL_CHANSPEC_BAND_6G;
} else
#endif /* WL_6E */
@@ -16410,7 +16542,7 @@
*/
int n_channels;
n_channels = get_roam_channel_list(ch, join_params->params.chanspec_list,
- MAX_ROAM_CHANNEL, &join_params->ssid, ioctl_version, center_freq);
+ MAX_ROAM_CHANNEL, &join_params->ssid, ioctl_version, chan);
join_params->params.chanspec_num = htod32(n_channels);
*join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
join_params->params.chanspec_num * sizeof(chanspec_t);
@@ -19420,16 +19552,28 @@
err = wldev_iovar_getint(dev, "bw_cap", &band);
if (likely(!err)) {
bw_cap[NL80211_BAND_2GHZ] = band;
+
band = WLC_BAND_5G;
err = wldev_iovar_getint(dev, "bw_cap", &band);
if (likely(!err)) {
bw_cap[NL80211_BAND_5GHZ] = band;
+
+#ifdef WL_6E
+ band = WLC_BAND_6G;
+ err = wldev_iovar_getint(dev, "bw_cap", &band);
+ if (likely(!err)) {
+ bw_cap[NL80211_BAND_6GHZ] = band;
+ return;
+ }
+ WARN_ON(1);
+#else
return;
+#endif /* WL_6E */
}
- bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
WARN_ON(1);
return;
}
+ WARN_ON(1);
WL_ERR(("fallback to mimo_bw_cap info\n"));
mimo_bwcap = 0;
@@ -19678,12 +19822,12 @@
return err;
}
-static int wl_construct_reginfo(struct bcm_cfg80211 *cfg, s32 bw_cap[])
+static int wl_construct_reginfo(struct bcm_cfg80211 *cfg, u32 bw_cap[])
{
struct net_device *dev = bcmcfg_to_prmry_ndev(cfg);
struct ieee80211_channel *band_chan_arr = NULL;
wl_uint32_list_t *list;
- u32 i, j, index, n_2g, n_5g, band, channel, array_size;
+ u32 i, j, index, n_2g, n_5g, n_6g, band, channel, array_size;
u32 *n_cnt = NULL;
chanspec_t c = 0;
s32 err = BCME_OK;
@@ -19708,7 +19852,7 @@
}
list = (wl_uint32_list_t *)(void *)pbuf;
- band = array_size = n_2g = n_5g = 0;
+ band = array_size = n_2g = n_5g = n_6g = 0;
for (i = 0; i < dtoh32(list->count); i++) {
index = 0;
update = false;
@@ -19734,8 +19878,17 @@
n_cnt = &n_5g;
band = IEEE80211_BAND_5GHZ;
ht40_allowed = (bw_cap[band] == WLC_N_BW_20ALL)? false : true;
+#ifdef WL_6E
+ } else if (CHSPEC_IS6G(c) && channel >= CH_MIN_6G_CHANNEL &&
+ (channel <= CH_MAX_6G_CHANNEL)) {
+ band_chan_arr = __wl_6ghz_a_channels;
+ array_size = ARRAYSIZE(__wl_6ghz_a_channels);
+ n_cnt = &n_6g;
+ band = IEEE80211_BAND_6GHZ;
+ ht40_allowed = (bw_cap[band] == WLC_N_BW_20ALL)? false : true;
+#endif /* WL_6E */
} else {
- WL_ERR(("Invalid channel Sepc. 0x%x.\n", c));
+ WL_ERR(("Invalid channel Spec. 0x%x.\n", c));
continue;
}
if (!ht40_allowed && CHSPEC_IS40(c))
@@ -19785,8 +19938,13 @@
if (!dfs_radar_disabled) {
if (band == IEEE80211_BAND_2GHZ)
channel |= WL_CHANSPEC_BAND_2G;
- else
+ else if (band == IEEE80211_BAND_5GHZ)
channel |= WL_CHANSPEC_BAND_5G;
+#ifdef WL_6E
+ else if (band == IEEE80211_BAND_6GHZ)
+ channel |= WL_CHANSPEC_BAND_6G;
+#endif /* WL_6E */
+
channel |= WL_CHANSPEC_BW_20;
channel = wl_chspec_host_to_driver(channel);
err = wldev_iovar_getint(dev, "per_chan_info", &channel);
@@ -19823,6 +19981,9 @@
}
__wl_band_2ghz.n_channels = n_2g;
__wl_band_5ghz_a.n_channels = n_5g;
+#ifdef WL_6E
+ __wl_band_6ghz.n_channels = n_6g;
+#endif /* WL_6E */
MFREE(cfg->osh, pbuf, LOCAL_BUF_LEN);
#undef LOCAL_BUF_LEN
@@ -19851,7 +20012,10 @@
#ifdef WL_SAE
dhd_pub_t *dhd = (dhd_pub_t *)(cfg->pub);
#endif /* WL_SAE */
- u32 bw_cap[2] = { WLC_BW_20MHZ_BIT, WLC_BW_20MHZ_BIT };
+ u32 bw_cap[4] = { WLC_BW_20MHZ_BIT, /* 2GHz */
+ WLC_BW_20MHZ_BIT, /* 5GHz */
+ 0, /* 60GHz */
+ WLC_BW_20MHZ_BIT }; /* 6GHz */
s32 cur_band = -1;
struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS] = {NULL, };
@@ -19906,6 +20070,14 @@
if (err != BCME_UNSUPPORTED)
return err;
}
+#ifdef WL11AX
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 21))
+ err = wldev_iovar_getint(dev, "he", &he);
+ if (unlikely(err)) {
+ WL_ERR(("error reading he (%d)\n", err));
+ }
+#endif // endif
+#endif // endif
wiphy = bcmcfg_to_wiphy(cfg);
nband = bandlist[0];
@@ -19920,15 +20092,39 @@
wl_update_vht_cap(cfg, bands[index], bw_cap[index]);
}
#endif // endif
+#ifdef WL11AX
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 21))
+ if(he) {
+ bands[index]->n_iftype_data = wl_update_he_cap(cfg, &sdata[index], NL80211_BAND_5GHZ);
+ bands[index]->iftype_data = &sdata[index];
+ }
+#endif // endif
+#endif // endif
}
else if (bandlist[i] == WLC_BAND_2G && __wl_band_2ghz.n_channels > 0) {
index = IEEE80211_BAND_2GHZ;
bands[index] = &__wl_band_2ghz;
+#ifdef WL11AX
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 21))
+ if(he) {
+ bands[index]->n_iftype_data = wl_update_he_cap(cfg, &sdata[index], NL80211_BAND_2GHZ);
+ bands[index]->iftype_data = &sdata[index];
+ }
+#endif // endif
+#endif // endif
}
#ifdef WL_6E
else if (bandlist[i] == WLC_BAND_6G && __wl_band_6ghz.n_channels > 0) {
index = IEEE80211_BAND_6GHZ;
bands[index] = &__wl_band_6ghz;
+#ifdef WL11AX
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 21))
+ if(he) {
+ bands[index]->n_iftype_data = wl_update_he_cap(cfg, &sdata[index], NL80211_BAND_6GHZ);
+ bands[index]->iftype_data = &sdata[index];
+ }
+#endif // endif
+#endif // endif
}
#endif /* WL_6E */
@@ -20509,7 +20705,7 @@
dhd->hang_reason));
dhd->hang_reason = HANG_REASON_UNKNOWN;
}
-#ifdef DHD_USE_EXTENDED_HANG_REASON
+#if defined(DHD_USE_EXTENDED_HANG_REASON) || defined(WL_CFGVENDOR_SEND_HANG_EVENT)
if (dhd->hang_reason != 0) {
reason = dhd->hang_reason;
}
@@ -20525,8 +20721,7 @@
{
if (dhd->up == TRUE) {
#ifdef WL_CFGVENDOR_SEND_HANG_EVENT
- wl_cfgvendor_send_hang_event(dev, reason,
- dhd->hang_info, dhd->hang_info_cnt);
+ wl_cfgvendor_send_hang_event(dev, reason);
#else
CFG80211_DISCONNECTED(dev, reason, NULL, 0, false, GFP_KERNEL);
#endif /* WL_CFGVENDOR_SEND_HANG_EVENT */
@@ -22143,6 +22338,17 @@
__FUNCTION__, vndrie->len));
goto end;
}
+
+ /*
+ * skip parsing the HE capab & oper IE from upper layer
+ * to avoid sending it to the FW, as these IEs will be
+ * added by the FW based on the MAC & PHY capab if HE
+ * is enabled.
+ */
+ if ((ie->data[0] == EXT_MNG_HE_CAP_ID) ||
+ (ie->data[0] == EXT_MNG_HE_OP_ID)) {
+ goto end;
+ }
} else {
/* len should be bigger than OUI length +
* one data length at least
@@ -24204,6 +24410,25 @@
}
s32
+wl_cfg80211_set_sae_pwe(struct net_device *ndev, u8 sae_pwe)
+{
+ int ret = BCME_UNSUPPORTED;
+ struct bcm_cfg80211 *cfg = wl_get_cfg(ndev);
+ dhd_pub_t *dhd = (dhd_pub_t *)(cfg->pub);
+
+ /* sae_pwe 0: HnP, 1: H2E, 2: Both HnP and H2E */
+ WL_DBG(("Set SAE PWE derivation machanisme %d\n", sae_pwe));
+
+ if (FW_SUPPORTED(dhd, sae_ext))
+ ret = wldev_iovar_setint(ndev, "extsae_pwe", sae_pwe);
+
+ if (ret < 0)
+ WL_ERR(("Failed set SAE PWE, ret=%d\n", ret));
+
+ return ret;
+}
+
+s32
wl_cfg80211_set_dbg_verbose(struct net_device *ndev, u32 level)
{
/* configure verbose level for debugging */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.h
old mode 100644
new mode 100755
index 9f13f01..a8557ed
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfg80211.h
@@ -349,7 +349,8 @@
#define WL_AF_SEARCH_TIME_MAX 450
#define WL_AF_TX_EXTRA_TIME_MAX 200
-#define WL_SCAN_TIMER_INTERVAL_MS 10000 /* Scan timeout */
+/* Increase SCAN_TIMER_INTERVAL to 15secs from 10secs to accomodate 6Ghz Channels */
+#define WL_SCAN_TIMER_INTERVAL_MS 15000 /* Scan timeout */
#ifdef WL_NAN
#define WL_SCAN_TIMER_INTERVAL_MS_NAN 15000 /* Scan timeout */
#endif /* WL_NAN */
@@ -410,12 +411,16 @@
/* TODO: even in upstream linux(v5.0), FT-1X-SHA384 isn't defined and supported yet.
* need to revisit here to sync correct name later.
*/
+#ifndef WLAN_AKM_SUITE_FT_8021X_SHA384
#define WLAN_AKM_SUITE_FT_8021X_SHA384 0x000FAC0D
+#endif /* WLAN_AKM_SUITE_FT_8021X_SHA384 */
#define WL_AKM_SUITE_SHA256_1X 0x000FAC05
#define WL_AKM_SUITE_SHA256_PSK 0x000FAC06
#define WLAN_AKM_SUITE_DPP 0x506F9A02
-#define WFA_AUTH_DPP 0x200000 /* WFA DPP AUTH */
+#ifndef WPA2_WFA_AUTH_DPP
+#define WPA2_WFA_AUTH_DPP 0x200000 /* WFA DPP AUTH */
+#endif /* WPA2_WFA_AUTH_DPP */
#ifndef WLAN_AKM_SUITE_FILS_SHA256
#define WLAN_AKM_SUITE_FILS_SHA256 0x000FAC0E
@@ -2615,6 +2620,7 @@
extern int wl_cfg80211_ifstats_counters(struct net_device *dev, wl_if_stats_t *if_stats);
extern s32 wl_cfg80211_set_dbg_verbose(struct net_device *ndev, u32 level);
extern s32 wl_cfg80211_set_transition_mode(struct net_device *ndev, u32 transition_disabled);
+extern s32 wl_cfg80211_set_sae_pwe(struct net_device *ndev, u8 sae_pwe);
extern int wl_cfg80211_deinit_p2p_discovery(struct bcm_cfg80211 * cfg);
extern int wl_cfg80211_set_frameburst(struct bcm_cfg80211 *cfg, bool enable);
extern int wl_cfg80211_determine_p2p_rsdb_mode(struct bcm_cfg80211 *cfg);
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgnan.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgnan.c
deleted file mode 100644
index f571219..0000000
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgnan.c
+++ /dev/null
@@ -1,5742 +0,0 @@
-/*
- * Neighbor Awareness Networking
- *
- * Copyright (C) 1999-2020, Broadcom.
- *
- * Unless you and Broadcom execute a separate written software license
- * agreement governing use of this software, this software is licensed to you
- * under the terms of the GNU General Public License version 2 (the "GPL"),
- * available at http://www.broadcom.com/licenses/GPLv2.php, with the
- * following added to such license:
- *
- * As a special exception, the copyright holders of this software give you
- * permission to link this software with independent modules, and to copy and
- * distribute the resulting executable under terms of your choice, provided that
- * you also meet, for each linked independent module, the terms and conditions of
- * the license of that module. An independent module is a module which is not
- * derived from this software. The special exception does not apply to any
- * modifications of the software.
- *
- * Notwithstanding the above, under no circumstances may you combine this
- * software in any way with any other Broadcom software provided under a license
- * other than the GPL, without Broadcom's express prior written consent.
- *
- * <<Broadcom-WL-IPTag/Open:>>
- *
- * $Id: wl_cfgnan.c 702817 2017-06-05 05:52:17Z $
- */
-
-#ifdef WL_NAN
-#include <bcmutils.h>
-#include <bcmendian.h>
-#include <bcmwifi_channels.h>
-#include <nan.h>
-#include <bcmiov.h>
-
-#include <wl_cfg80211.h>
-#include <wl_android.h>
-#include <wl_cfgnan.h>
-
-#include <dngl_stats.h>
-#include <dhd.h>
-#include <wl_cfgvendor.h>
-#include <bcmbloom.h>
-#include <wl_cfgp2p.h>
-
-#define NAN_RANGE_REQ_CMD 0
-#define NAN_RANGE_REQ_EVNT 1
-#define NAN_RAND_MAC_RETRIES 10
-#define NAN_SCAN_DWELL_TIME_DELTA_MS 10
-
-#ifdef WL_NAN_DISC_CACHE
-static int wl_cfgnan_cache_disc_result(struct bcm_cfg80211 *cfg, void * data);
-static int wl_cfgnan_remove_disc_result(struct bcm_cfg80211 * cfg, uint8 local_subid);
-static nan_disc_result_cache * wl_cfgnan_get_disc_result(struct bcm_cfg80211 *cfg,
- uint8 remote_pubid, struct ether_addr *peer);
-#endif /* WL_NAN_DISC_CACHE */
-static void wl_cfgnan_update_dp_mask(struct bcm_cfg80211 *cfg, bool enable, u8 nan_dp_id);
-
-static int wl_cfgnan_set_if_addr(struct bcm_cfg80211 *cfg);
-
-static const char *nan_role_to_str(u8 role)
-{
- switch (role) {
- C2S(WL_NAN_ROLE_AUTO)
- C2S(WL_NAN_ROLE_NON_MASTER_NON_SYNC)
- C2S(WL_NAN_ROLE_NON_MASTER_SYNC)
- C2S(WL_NAN_ROLE_MASTER)
- C2S(WL_NAN_ROLE_ANCHOR_MASTER)
- default:
- return "WL_NAN_ROLE_UNKNOWN";
- }
-}
-
-static const char *nan_event_to_str(u16 cmd)
-{
- switch (cmd) {
- C2S(WL_NAN_EVENT_START)
- C2S(WL_NAN_EVENT_DISCOVERY_RESULT)
- C2S(WL_NAN_EVENT_TERMINATED)
- C2S(WL_NAN_EVENT_RECEIVE)
- C2S(WL_NAN_EVENT_MERGE)
- C2S(WL_NAN_EVENT_STOP)
- C2S(WL_NAN_EVENT_PEER_DATAPATH_IND)
- C2S(WL_NAN_EVENT_DATAPATH_ESTB)
- C2S(WL_NAN_EVENT_SDF_RX)
- C2S(WL_NAN_EVENT_DATAPATH_END)
- C2S(WL_NAN_EVENT_RNG_REQ_IND)
- C2S(WL_NAN_EVENT_RNG_RPT_IND)
- C2S(WL_NAN_EVENT_RNG_TERM_IND)
- C2S(WL_NAN_EVENT_TXS)
- C2S(WL_NAN_EVENT_INVALID)
-
- default:
- return "WL_NAN_EVENT_UNKNOWN";
- }
-}
-
-static int wl_cfgnan_execute_ioctl(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, bcm_iov_batch_buf_t *nan_buf,
- uint16 nan_buf_size, uint32 *status, uint8 *resp_buf,
- uint16 resp_buf_len);
-#ifdef WL_NAN_DISC_CACHE
-/* ranging quest and response iovar handler */
-static int wl_cfgnan_trigger_ranging(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, void *event_data, nan_svc_info_t *svc, uint8 range_req);
-#endif /* WL_NAN_DISC_CACHE */
-
-int
-wl_cfgnan_generate_inst_id(struct bcm_cfg80211 *cfg, uint8 *p_inst_id)
-{
- s32 ret = BCME_OK;
- uint8 i = 0;
- if (p_inst_id == NULL) {
- WL_ERR(("Invalid arguments\n"));
- ret = -EINVAL;
- goto exit;
- }
-
- if (cfg->nancfg.inst_id_start == NAN_ID_MAX) {
- WL_ERR(("Consumed all IDs, resetting the counter\n"));
- cfg->nancfg.inst_id_start = 0;
- }
-
- for (i = cfg->nancfg.inst_id_start; i < NAN_ID_MAX; i++) {
- if (isclr(cfg->nancfg.svc_inst_id_mask, i)) {
- setbit(cfg->nancfg.svc_inst_id_mask, i);
- *p_inst_id = i + 1;
- cfg->nancfg.inst_id_start = *p_inst_id;
- WL_DBG(("Instance ID=%d\n", *p_inst_id));
- goto exit;
- }
- }
- WL_ERR(("Allocated maximum IDs\n"));
- ret = BCME_NORESOURCE;
-exit:
- return ret;
-}
-
-int
-wl_cfgnan_remove_inst_id(struct bcm_cfg80211 *cfg, uint8 inst_id)
-{
- s32 ret = BCME_OK;
- WL_DBG(("%s: Removing svc instance id %d\n", __FUNCTION__, inst_id));
- clrbit(cfg->nancfg.svc_inst_id_mask, inst_id-1);
- return ret;
-}
-s32 wl_cfgnan_parse_sdea_data(osl_t *osh, const uint8 *p_attr,
- uint16 len, nan_event_data_t *tlv_data)
-{
- const wifi_nan_svc_desc_ext_attr_t *nan_svc_desc_ext_attr = NULL;
- uint8 offset;
- s32 ret = BCME_OK;
-
- /* service descriptor ext attributes */
- nan_svc_desc_ext_attr = (const wifi_nan_svc_desc_ext_attr_t *)p_attr;
-
- /* attribute ID */
- WL_TRACE(("> attr id: 0x%02x\n", nan_svc_desc_ext_attr->id));
-
- /* attribute length */
- WL_TRACE(("> attr len: 0x%x\n", nan_svc_desc_ext_attr->len));
-
- tlv_data->sde_control_flag = nan_svc_desc_ext_attr->control;
- offset = sizeof(*nan_svc_desc_ext_attr);
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
-
- if (tlv_data->sde_control_flag & NAN_SC_RANGE_LIMITED) {
- WL_TRACE(("> svc_control: range limited present\n"));
- }
- if (tlv_data->sde_control_flag & NAN_SDE_CF_SVC_UPD_IND_PRESENT) {
- WL_TRACE(("> svc_control: sdea svc specific info present\n"));
- tlv_data->sde_svc_info.dlen = (p_attr[1] | (p_attr[2] << 8));
- WL_TRACE(("> sdea svc info len: 0x%02x\n", tlv_data->sde_svc_info.dlen));
- if (!tlv_data->sde_svc_info.dlen ||
- tlv_data->sde_svc_info.dlen > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
- /* must be able to handle null msg which is not error */
- tlv_data->sde_svc_info.dlen = 0;
- WL_ERR(("data length is invalid\n"));
- ret = BCME_BADLEN;
- goto fail;
- }
-
- if (tlv_data->sde_svc_info.dlen > 0) {
- tlv_data->sde_svc_info.data = MALLOCZ(osh, tlv_data->sde_svc_info.dlen);
- if (!tlv_data->sde_svc_info.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- tlv_data->sde_svc_info.dlen = 0;
- ret = BCME_NOMEM;
- goto fail;
- }
- /* advance read pointer, consider sizeof of Service Update Indicator */
- offset = sizeof(tlv_data->sde_svc_info.dlen) - 1;
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- memcpy(tlv_data->sde_svc_info.data, p_attr, tlv_data->sde_svc_info.dlen);
- } else {
- /* must be able to handle null msg which is not error */
- tlv_data->sde_svc_info.dlen = 0;
- WL_DBG(("%s: sdea svc info length is zero, null info data\n",
- __FUNCTION__));
- }
- }
- return ret;
-fail:
- if (tlv_data->sde_svc_info.data) {
- MFREE(osh, tlv_data->sde_svc_info.data,
- tlv_data->sde_svc_info.dlen);
- tlv_data->sde_svc_info.data = NULL;
- }
-
- WL_DBG(("Parse SDEA event data, status = %d\n", ret));
- return ret;
-}
-
-/*
- * This attribute contains some mandatory fields and some optional fields
- * depending on the content of the service discovery request.
- */
-s32
-wl_cfgnan_parse_sda_data(osl_t *osh, const uint8 *p_attr,
- uint16 len, nan_event_data_t *tlv_data)
-{
- uint8 svc_control = 0, offset = 0;
- s32 ret = BCME_OK;
- const wifi_nan_svc_descriptor_attr_t *nan_svc_desc_attr = NULL;
-
- /* service descriptor attributes */
- nan_svc_desc_attr = (const wifi_nan_svc_descriptor_attr_t *)p_attr;
- /* attribute ID */
- WL_TRACE(("> attr id: 0x%02x\n", nan_svc_desc_attr->id));
-
- /* attribute length */
- WL_TRACE(("> attr len: 0x%x\n", nan_svc_desc_attr->len));
-
- /* service ID */
- memcpy(tlv_data->svc_name, nan_svc_desc_attr->svc_hash, NAN_SVC_HASH_LEN);
- WL_TRACE(("> svc_hash_name: " MACDBG "\n", MAC2STRDBG(tlv_data->svc_name)));
-
- /* local instance ID */
- tlv_data->local_inst_id = nan_svc_desc_attr->instance_id;
- WL_TRACE(("> local instance id: 0x%02x\n", tlv_data->local_inst_id));
-
- /* requestor instance ID */
- tlv_data->requestor_id = nan_svc_desc_attr->requestor_id;
- WL_TRACE(("> requestor id: 0x%02x\n", tlv_data->requestor_id));
-
- /* service control */
- svc_control = nan_svc_desc_attr->svc_control;
- if ((svc_control & NAN_SVC_CONTROL_TYPE_MASK) == NAN_SC_PUBLISH) {
- WL_TRACE(("> Service control type: NAN_SC_PUBLISH\n"));
- } else if ((svc_control & NAN_SVC_CONTROL_TYPE_MASK) == NAN_SC_SUBSCRIBE) {
- WL_TRACE(("> Service control type: NAN_SC_SUBSCRIBE\n"));
- } else if ((svc_control & NAN_SVC_CONTROL_TYPE_MASK) == NAN_SC_FOLLOWUP) {
- WL_TRACE(("> Service control type: NAN_SC_FOLLOWUP\n"));
- }
- offset = sizeof(*nan_svc_desc_attr);
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
-
- /*
- * optional fields:
- * must be in order following by service descriptor attribute format
- */
-
- /* binding bitmap */
- if (svc_control & NAN_SC_BINDING_BITMAP_PRESENT) {
- uint16 bitmap = 0;
- WL_TRACE(("> svc_control: binding bitmap present\n"));
-
- /* Copy binding bitmap */
- memcpy(&bitmap, p_attr, NAN_BINDING_BITMAP_LEN);
- WL_TRACE(("> sc binding bitmap: 0x%04x\n", bitmap));
-
- if (NAN_BINDING_BITMAP_LEN > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += NAN_BINDING_BITMAP_LEN;
- len -= NAN_BINDING_BITMAP_LEN;
- }
-
- /* matching filter */
- if (svc_control & NAN_SC_MATCHING_FILTER_PRESENT) {
- WL_TRACE(("> svc_control: matching filter present\n"));
-
- tlv_data->tx_match_filter.dlen = *p_attr++;
- WL_TRACE(("> matching filter len: 0x%02x\n",
- tlv_data->tx_match_filter.dlen));
-
- if (!tlv_data->tx_match_filter.dlen ||
- tlv_data->tx_match_filter.dlen > MAX_MATCH_FILTER_LEN) {
- tlv_data->tx_match_filter.dlen = 0;
- WL_ERR(("tx match filter length is invalid\n"));
- ret = -EINVAL;
- goto fail;
- }
- tlv_data->tx_match_filter.data =
- MALLOCZ(osh, tlv_data->tx_match_filter.dlen);
- if (!tlv_data->tx_match_filter.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- tlv_data->tx_match_filter.dlen = 0;
- ret = -ENOMEM;
- goto fail;
- }
- memcpy(tlv_data->tx_match_filter.data, p_attr,
- tlv_data->tx_match_filter.dlen);
-
- /* advance read pointer */
- offset = tlv_data->tx_match_filter.dlen;
- if (offset > len) {
- WL_ERR(("Invalid event buffer\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- }
-
- /* service response filter */
- if (svc_control & NAN_SC_SR_FILTER_PRESENT) {
- WL_TRACE(("> svc_control: service response filter present\n"));
-
- tlv_data->rx_match_filter.dlen = *p_attr++;
- WL_TRACE(("> sr match filter len: 0x%02x\n",
- tlv_data->rx_match_filter.dlen));
-
- if (!tlv_data->rx_match_filter.dlen ||
- tlv_data->rx_match_filter.dlen > MAX_MATCH_FILTER_LEN) {
- tlv_data->rx_match_filter.dlen = 0;
- WL_ERR(("%s: sr matching filter length is invalid\n",
- __FUNCTION__));
- ret = BCME_BADLEN;
- goto fail;
- }
- tlv_data->rx_match_filter.data =
- MALLOCZ(osh, tlv_data->rx_match_filter.dlen);
- if (!tlv_data->rx_match_filter.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- tlv_data->rx_match_filter.dlen = 0;
- ret = BCME_NOMEM;
- goto fail;
- }
-
- memcpy(tlv_data->rx_match_filter.data, p_attr,
- tlv_data->rx_match_filter.dlen);
-
- /* advance read pointer */
- offset = tlv_data->rx_match_filter.dlen;
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- }
-
- /* service specific info */
- if (svc_control & NAN_SC_SVC_INFO_PRESENT) {
- WL_TRACE(("> svc_control: svc specific info present\n"));
-
- tlv_data->svc_info.dlen = *p_attr++;
- WL_TRACE(("> svc info len: 0x%02x\n", tlv_data->svc_info.dlen));
-
- if (!tlv_data->svc_info.dlen ||
- tlv_data->svc_info.dlen > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
- /* must be able to handle null msg which is not error */
- tlv_data->svc_info.dlen = 0;
- WL_ERR(("data length is invalid\n"));
- ret = BCME_BADLEN;
- goto fail;
- }
-
- if (tlv_data->svc_info.dlen > 0) {
- tlv_data->svc_info.data =
- MALLOCZ(osh, tlv_data->svc_info.dlen);
- if (!tlv_data->svc_info.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- tlv_data->svc_info.dlen = 0;
- ret = BCME_NOMEM;
- goto fail;
- }
- memcpy(tlv_data->svc_info.data, p_attr, tlv_data->svc_info.dlen);
-
- /* advance read pointer */
- offset = tlv_data->svc_info.dlen;
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- } else {
- /* must be able to handle null msg which is not error */
- tlv_data->svc_info.dlen = 0;
- WL_TRACE(("%s: svc info length is zero, null info data\n",
- __FUNCTION__));
- }
- }
-
- /*
- * discovery range limited:
- * If set to 1, the pub/sub msg is limited in range to close proximity.
- * If set to 0, the pub/sub msg is not limited in range.
- * Valid only when the message is either of a publish or a sub.
- */
- if (svc_control & NAN_SC_RANGE_LIMITED) {
- if (((svc_control & NAN_SVC_CONTROL_TYPE_MASK) == NAN_SC_PUBLISH) ||
- ((svc_control & NAN_SVC_CONTROL_TYPE_MASK) == NAN_SC_SUBSCRIBE)) {
- WL_TRACE(("> svc_control: range limited present\n"));
- } else {
- WL_TRACE(("range limited is only valid on pub or sub\n"));
- }
-
- /* TODO: send up */
-
- /* advance read pointer */
- p_attr++;
- }
- return ret;
-fail:
- if (tlv_data->tx_match_filter.data) {
- MFREE(osh, tlv_data->tx_match_filter.data,
- tlv_data->tx_match_filter.dlen);
- tlv_data->tx_match_filter.data = NULL;
- }
- if (tlv_data->rx_match_filter.data) {
- MFREE(osh, tlv_data->rx_match_filter.data,
- tlv_data->rx_match_filter.dlen);
- tlv_data->rx_match_filter.data = NULL;
- }
- if (tlv_data->svc_info.data) {
- MFREE(osh, tlv_data->svc_info.data,
- tlv_data->svc_info.dlen);
- tlv_data->svc_info.data = NULL;
- }
-
- WL_DBG(("Parse SDA event data, status = %d\n", ret));
- return ret;
-}
-
-static s32
-wl_cfgnan_parse_sd_attr_data(osl_t *osh, uint16 len, const uint8 *data,
- nan_event_data_t *tlv_data, uint16 type) {
- const uint8 *p_attr = data;
- uint16 offset = 0;
- s32 ret = BCME_OK;
- const wl_nan_event_disc_result_t *ev_disc = NULL;
- const wl_nan_event_replied_t *ev_replied = NULL;
- const wl_nan_ev_receive_t *ev_fup = NULL;
-
- /*
- * Mapping wifi_nan_svc_descriptor_attr_t, and svc controls are optional.
- */
- if (type == WL_NAN_XTLV_SD_DISC_RESULTS) {
- u8 iter;
- ev_disc = (const wl_nan_event_disc_result_t *)p_attr;
-
- WL_DBG((">> WL_NAN_XTLV_RESULTS: Discovery result\n"));
-
- tlv_data->pub_id = (wl_nan_instance_id_t)ev_disc->pub_id;
- tlv_data->sub_id = (wl_nan_instance_id_t)ev_disc->sub_id;
- tlv_data->publish_rssi = ev_disc->publish_rssi;
- memcpy(&tlv_data->remote_nmi, &ev_disc->pub_mac, ETHER_ADDR_LEN);
-
- WL_TRACE(("publish id: %d\n", ev_disc->pub_id));
- WL_TRACE(("subscribe d: %d\n", ev_disc->sub_id));
- WL_TRACE(("publish mac addr: " MACDBG "\n",
- MAC2STRDBG(ev_disc->pub_mac.octet)));
- WL_TRACE(("publish rssi: %d\n", (int8)ev_disc->publish_rssi));
- WL_TRACE(("attribute no: %d\n", ev_disc->attr_num));
- WL_TRACE(("attribute len: %d\n", (uint16)ev_disc->attr_list_len));
-
- /* advance to the service descricptor */
- offset = OFFSETOF(wl_nan_event_disc_result_t, attr_list[0]);
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
-
- iter = ev_disc->attr_num;
- while (iter) {
- if ((uint8)*p_attr == NAN_ATTR_SVC_DESCRIPTOR) {
- WL_TRACE(("> attr id: 0x%02x\n", (uint8)*p_attr));
- ret = wl_cfgnan_parse_sda_data(osh, p_attr, len, tlv_data);
- }
-
- if ((uint8)*p_attr == NAN_ATTR_SVC_DESC_EXTENSION) {
- WL_TRACE(("> attr id: 0x%02x\n", (uint8)*p_attr));
- ret = wl_cfgnan_parse_sdea_data(osh, p_attr, len, tlv_data);
- }
- offset = (sizeof(*p_attr) +
- sizeof(ev_disc->attr_list_len) +
- (p_attr[1] | (p_attr[2] << 8)));
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- iter--;
- }
- } else if (type == WL_NAN_XTLV_SD_FUP_RECEIVED) {
- uint8 iter;
- ev_fup = (const wl_nan_ev_receive_t *)p_attr;
-
- WL_TRACE((">> WL_NAN_XTLV_SD_FUP_RECEIVED: Transmit follow-up\n"));
-
- tlv_data->local_inst_id = (wl_nan_instance_id_t)ev_fup->local_id;
- tlv_data->requestor_id = (wl_nan_instance_id_t)ev_fup->remote_id;
- tlv_data->fup_rssi = ev_fup->fup_rssi;
- memcpy(&tlv_data->remote_nmi, &ev_fup->remote_addr, ETHER_ADDR_LEN);
-
- WL_TRACE(("local id: %d\n", ev_fup->local_id));
- WL_TRACE(("remote id: %d\n", ev_fup->remote_id));
- WL_TRACE(("peer mac addr: " MACDBG "\n",
- MAC2STRDBG(ev_fup->remote_addr.octet)));
- WL_TRACE(("peer rssi: %d\n", (int8)ev_fup->fup_rssi));
- WL_TRACE(("attribute no: %d\n", ev_fup->attr_num));
- WL_TRACE(("attribute len: %d\n", ev_fup->attr_list_len));
-
- /* advance to the service descriptor which is attr_list[0] */
- offset = OFFSETOF(wl_nan_ev_receive_t, attr_list[0]);
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
-
- iter = ev_fup->attr_num;
- while (iter) {
- if ((uint8)*p_attr == NAN_ATTR_SVC_DESCRIPTOR) {
- WL_TRACE(("> attr id: 0x%02x\n", (uint8)*p_attr));
- ret = wl_cfgnan_parse_sda_data(osh, p_attr, len, tlv_data);
- if (unlikely(ret)) {
- WL_ERR(("wl_cfgnan_parse_sda_data failed,"
- "error = %d \n", ret));
- goto fail;
- }
- }
-
- if ((uint8)*p_attr == NAN_ATTR_SVC_DESC_EXTENSION) {
- WL_TRACE(("> attr id: 0x%02x\n", (uint8)*p_attr));
- ret = wl_cfgnan_parse_sdea_data(osh, p_attr, len, tlv_data);
- if (unlikely(ret)) {
- WL_ERR(("wl_cfgnan_parse_sdea_data failed,"
- "error = %d \n", ret));
- goto fail;
- }
- }
- offset = (sizeof(*p_attr) +
- sizeof(ev_fup->attr_list_len) +
- (p_attr[1] | (p_attr[2] << 8)));
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- iter--;
- }
- } else if (type == WL_NAN_XTLV_SD_SDF_RX) {
- /*
- * SDF followed by nan2_pub_act_frame_t and wifi_nan_svc_descriptor_attr_t,
- * and svc controls are optional.
- */
- const nan2_pub_act_frame_t *nan_pub_af =
- (const nan2_pub_act_frame_t *)p_attr;
-
- WL_TRACE((">> WL_NAN_XTLV_SD_SDF_RX\n"));
-
- /* nan2_pub_act_frame_t */
- WL_TRACE(("pub category: 0x%02x\n", nan_pub_af->category_id));
- WL_TRACE(("pub action: 0x%02x\n", nan_pub_af->action_field));
- WL_TRACE(("nan oui: %2x-%2x-%2x\n",
- nan_pub_af->oui[0], nan_pub_af->oui[1], nan_pub_af->oui[2]));
- WL_TRACE(("oui type: 0x%02x\n", nan_pub_af->oui_type));
- WL_TRACE(("oui subtype: 0x%02x\n", nan_pub_af->oui_sub_type));
-
- offset = sizeof(*nan_pub_af);
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- } else if (type == WL_NAN_XTLV_SD_REPLIED) {
- ev_replied = (const wl_nan_event_replied_t *)p_attr;
-
- WL_TRACE((">> WL_NAN_XTLV_SD_REPLIED: Replied Event\n"));
-
- tlv_data->pub_id = (wl_nan_instance_id_t)ev_replied->pub_id;
- tlv_data->sub_id = (wl_nan_instance_id_t)ev_replied->sub_id;
- tlv_data->sub_rssi = ev_replied->sub_rssi;
- memcpy(&tlv_data->remote_nmi, &ev_replied->sub_mac, ETHER_ADDR_LEN);
-
- WL_TRACE(("publish id: %d\n", ev_replied->pub_id));
- WL_TRACE(("subscribe d: %d\n", ev_replied->sub_id));
- WL_TRACE(("Subscriber mac addr: " MACDBG "\n",
- MAC2STRDBG(ev_replied->sub_mac.octet)));
- WL_TRACE(("subscribe rssi: %d\n", (int8)ev_replied->sub_rssi));
- WL_TRACE(("attribute no: %d\n", ev_replied->attr_num));
- WL_TRACE(("attribute len: %d\n", (uint16)ev_replied->attr_list_len));
-
- /* advance to the service descriptor which is attr_list[0] */
- offset = OFFSETOF(wl_nan_event_replied_t, attr_list[0]);
- if (offset > len) {
- WL_ERR(("Invalid event buffer len\n"));
- ret = BCME_BUFTOOSHORT;
- goto fail;
- }
- p_attr += offset;
- len -= offset;
- ret = wl_cfgnan_parse_sda_data(osh, p_attr, len, tlv_data);
- }
-
-fail:
- return ret;
-}
-
-/* Based on each case of tlv type id, fill into tlv data */
-int
-wl_cfgnan_set_vars_cbfn(void *ctx, const uint8 *data, uint16 type, uint16 len)
-{
- nan_parse_event_ctx_t *ctx_tlv_data = ((nan_parse_event_ctx_t *)(ctx));
- nan_event_data_t *tlv_data = ((nan_event_data_t *)(ctx_tlv_data->nan_evt_data));
- int ret = BCME_OK;
-
- NAN_DBG_ENTER();
- if (!data || !len) {
- WL_ERR(("data length is invalid\n"));
- ret = BCME_ERROR;
- goto fail;
- }
-
- switch (type) {
- /*
- * Need to parse service descript attributes including service control,
- * when Follow up or Discovery result come
- */
- case WL_NAN_XTLV_SD_FUP_RECEIVED:
- case WL_NAN_XTLV_SD_DISC_RESULTS: {
- ret = wl_cfgnan_parse_sd_attr_data(ctx_tlv_data->cfg->osh,
- len, data, tlv_data, type);
- break;
- }
- case WL_NAN_XTLV_SD_SVC_INFO: {
- tlv_data->svc_info.data =
- MALLOCZ(ctx_tlv_data->cfg->osh, len);
- if (!tlv_data->svc_info.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- tlv_data->svc_info.dlen = 0;
- ret = BCME_NOMEM;
- goto fail;
- }
- tlv_data->svc_info.dlen = len;
- memcpy(tlv_data->svc_info.data, data, tlv_data->svc_info.dlen);
- break;
- }
- default:
- WL_ERR(("Not available for tlv type = 0x%x\n", type));
- ret = BCME_ERROR;
- break;
- }
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfg_nan_check_cmd_len(uint16 nan_iov_len, uint16 data_size,
- uint16 *subcmd_len)
-{
- s32 ret = BCME_OK;
-
- if (subcmd_len != NULL) {
- *subcmd_len = OFFSETOF(bcm_iov_batch_subcmd_t, data) +
- ALIGN_SIZE(data_size, 4);
- if (*subcmd_len > nan_iov_len) {
- WL_ERR(("%s: Buf short, requested:%d, available:%d\n",
- __FUNCTION__, *subcmd_len, nan_iov_len));
- ret = BCME_NOMEM;
- }
- } else {
- WL_ERR(("Invalid subcmd_len\n"));
- ret = BCME_ERROR;
- }
- return ret;
-}
-
-int
-wl_cfgnan_config_eventmask(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- uint8 event_ind_flag, bool disable_events)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint16 subcmd_len;
- uint32 event_mask = 0;
- uint32 status;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- bcm_iov_batch_subcmd_t *sub_cmd_resp = NULL;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
-
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
-
- NAN_DBG_ENTER();
-
- ret = wl_add_remove_eventmsg(ndev, WLC_E_NAN, true);
- if (unlikely(ret)) {
- WL_ERR((" nan event enable failed, error = %d \n", ret));
- goto fail;
- }
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
- sub_cmd = (bcm_iov_batch_subcmd_t*)(uint8 *)(&nan_buf->cmds[0]);
-
- ret = wl_cfg_nan_check_cmd_len(nan_buf_size,
- sizeof(event_mask), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_EVENT_MASK);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(event_mask);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- nan_buf_size -= subcmd_len;
- nan_buf->count = 1;
-
- if (disable_events) {
- WL_DBG(("Disabling all nan events..except stop event\n"));
- event_mask = NAN_EVENT_BIT(WL_NAN_EVENT_STOP);
- } else {
- /*
- * Android framework event mask configuration.
- */
- if (event_ind_flag) {
- nan_buf->is_set = false;
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("get nan event mask failed ret %d status %d \n",
- ret, status));
- goto fail;
- }
- sub_cmd_resp = &((bcm_iov_batch_buf_t *)(resp_buf))->cmds[0];
-
- /* check the response buff */
- event_mask = (*(uint8*)&sub_cmd_resp->data[0]);
-
- if (CHECK_BIT(event_ind_flag, WL_NAN_EVENT_DIC_MAC_ADDR_BIT)) {
- WL_DBG(("Need to add disc mac addr change event\n"));
- }
- /* BIT2 - Disable nan cluster join indication (OTA). */
- if (CHECK_BIT(event_ind_flag, WL_NAN_EVENT_JOIN_EVENT)) {
- event_mask &= ~NAN_EVENT_BIT(WL_NAN_EVENT_MERGE);
- }
- } else {
- /* enable only selected nan events to avoid unnecessary host wake up */
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_START);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_MERGE);
- }
-
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_DISCOVERY_RESULT);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_RECEIVE);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_TERMINATED);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_STOP);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_TXS);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_PEER_DATAPATH_IND);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_DATAPATH_ESTB);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_DATAPATH_END);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_RNG_RPT_IND);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_RNG_REQ_IND);
- event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_RNG_TERM_IND);
- }
-
- nan_buf->is_set = true;
- memcpy(sub_cmd->data, &event_mask, sizeof(event_mask));
- nan_buf_size = (NAN_IOCTL_BUF_SIZE - nan_buf_size);
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("set nan event mask failed ret %d status %d \n", ret, status));
- goto fail;
- }
- WL_DBG(("set nan event mask successfull\n"));
-
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_nan_avail(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_avail_cmd_data *cmd_data, uint8 avail_type)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint16 subcmd_len;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_iov_t *nan_iov_data = NULL;
- wl_avail_t *avail = NULL;
- wl_avail_entry_t *entry; /* used for filling entry structure */
- uint8 *p; /* tracking pointer */
- uint8 i;
- u32 status;
- int c;
- char ndc_id[ETHER_ADDR_LEN] = { 0x50, 0x6f, 0x9a, 0x01, 0x0, 0x0 };
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
- char *a = WL_AVAIL_BIT_MAP;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
-
- NAN_DBG_ENTER();
-
- /* Do not disturb avail if dam is supported */
- if (FW_SUPPORTED(dhdp, autodam)) {
- WL_DBG(("DAM is supported, avail modification not allowed\n"));
- return ret;
- }
-
- if (avail_type < WL_AVAIL_LOCAL || avail_type > WL_AVAIL_TYPE_MAX) {
- WL_ERR(("Invalid availability type\n"));
- ret = BCME_USAGE_ERROR;
- goto fail;
- }
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data = MALLOCZ(dhdp->osh, sizeof(*nan_iov_data));
- if (!nan_iov_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data->nan_iov_len = NAN_IOCTL_BUF_SIZE;
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*avail), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
- avail = (wl_avail_t *)sub_cmd->data;
-
- /* populate wl_avail_type */
- avail->flags = avail_type;
- if (avail_type == WL_AVAIL_RANGING) {
- memcpy(&avail->addr, &cmd_data->peer_nmi, ETHER_ADDR_LEN);
- }
-
- sub_cmd->len = sizeof(sub_cmd->u.options) + subcmd_len;
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_AVAIL);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_buf->is_set = false;
- nan_buf->count++;
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_buf_size = (NAN_IOCTL_BUF_SIZE - nan_iov_data->nan_iov_len);
-
- WL_TRACE(("Read wl nan avail status\n"));
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret)) {
- WL_ERR(("\n Get nan avail failed ret %d, status %d \n", ret, status));
- goto fail;
- }
-
- if (status == BCME_NOTFOUND) {
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- avail = (wl_avail_t *)sub_cmd->data;
- p = avail->entry;
-
- /* populate wl_avail fields */
- avail->length = OFFSETOF(wl_avail_t, entry);
- avail->flags = avail_type;
- avail->num_entries = 0;
- avail->id = 0;
- entry = (wl_avail_entry_t*)p;
- entry->flags = WL_AVAIL_ENTRY_COM;
-
- /* set default values for optional parameters */
- entry->start_offset = 0;
- entry->u.band = 0;
-
- if (cmd_data->avail_period) {
- entry->period = cmd_data->avail_period;
- } else {
- entry->period = WL_AVAIL_PERIOD_1024;
- }
-
- if (cmd_data->duration != NAN_BAND_INVALID) {
- entry->flags |= (3 << WL_AVAIL_ENTRY_USAGE_SHIFT) |
- (cmd_data->duration << WL_AVAIL_ENTRY_BIT_DUR_SHIFT);
- } else {
- entry->flags |= (3 << WL_AVAIL_ENTRY_USAGE_SHIFT) |
- (WL_AVAIL_BIT_DUR_16 << WL_AVAIL_ENTRY_BIT_DUR_SHIFT);
- }
- entry->bitmap_len = 0;
-
- if (avail_type == WL_AVAIL_LOCAL) {
- entry->flags |= 1 << WL_AVAIL_ENTRY_CHAN_SHIFT;
- /* Check for 5g support, based on that choose 5g channel */
- if (cfg->support_5g) {
- entry->u.channel_info =
- htod32(wf_channel2chspec(WL_AVAIL_CHANNEL_5G,
- WL_AVAIL_BANDWIDTH_5G));
- } else {
- entry->u.channel_info =
- htod32(wf_channel2chspec(WL_AVAIL_CHANNEL_2G,
- WL_AVAIL_BANDWIDTH_2G));
- }
- entry->flags = htod16(entry->flags);
- }
-
- if (cfg->support_5g) {
- a = WL_5G_AVAIL_BIT_MAP;
- }
-
- /* point to bitmap value for processing */
- if (cmd_data->bmap) {
- for (c = (WL_NAN_EVENT_CLEAR_BIT-1); c >= 0; c--) {
- i = cmd_data->bmap >> c;
- if (i & 1) {
- setbit(entry->bitmap, (WL_NAN_EVENT_CLEAR_BIT-c-1));
- }
- }
- } else {
- for (i = 0; i < strlen(WL_AVAIL_BIT_MAP); i++) {
- if (*a == '1') {
- setbit(entry->bitmap, i);
- }
- a++;
- }
- }
-
- /* account for partially filled most significant byte */
- entry->bitmap_len = ((WL_NAN_EVENT_CLEAR_BIT) + NBBY - 1) / NBBY;
- if (avail_type == WL_AVAIL_NDC) {
- memcpy(&avail->addr, ndc_id, ETHER_ADDR_LEN);
- } else if (avail_type == WL_AVAIL_RANGING) {
- memcpy(&avail->addr, &cmd_data->peer_nmi, ETHER_ADDR_LEN);
- }
- /* account for partially filled most significant byte */
-
- /* update wl_avail and populate wl_avail_entry */
- entry->length = OFFSETOF(wl_avail_entry_t, bitmap) + entry->bitmap_len;
- avail->num_entries++;
- avail->length += entry->length;
- /* advance pointer for next entry */
- p += entry->length;
-
- /* convert to dongle endianness */
- entry->length = htod16(entry->length);
- entry->start_offset = htod16(entry->start_offset);
- entry->u.channel_info = htod32(entry->u.channel_info);
- entry->flags = htod16(entry->flags);
- /* update avail_len only if
- * there are avail entries
- */
- if (avail->num_entries) {
- nan_iov_data->nan_iov_len -= avail->length;
- avail->length = htod16(avail->length);
- avail->flags = htod16(avail->flags);
- }
- avail->length = htod16(avail->length);
-
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_AVAIL);
- sub_cmd->len = sizeof(sub_cmd->u.options) + avail->length;
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_buf->is_set = true;
- nan_buf->count++;
-
- /* Reduce the iov_len size by subcmd_len */
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_buf_size = (NAN_IOCTL_BUF_SIZE - nan_iov_data->nan_iov_len);
-
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("\n set nan avail failed ret %d status %d \n", ret, status));
- ret = status;
- goto fail;
- }
- } else if (status == BCME_OK) {
- WL_DBG(("Avail type [%d] found to be configured\n", avail_type));
- } else {
- WL_ERR(("set nan avail failed ret %d status %d \n", ret, status));
- }
-
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- if (nan_iov_data) {
- MFREE(dhdp->osh, nan_iov_data, sizeof(*nan_iov_data));
- }
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_config_control_flag(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- uint32 flag, uint32 *status, bool set)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_iov_start, nan_iov_end;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint16 subcmd_len;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- bcm_iov_batch_subcmd_t *sub_cmd_resp = NULL;
- wl_nan_iov_t *nan_iov_data = NULL;
- uint32 cfg_ctrl;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
-
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
-
- NAN_DBG_ENTER();
- WL_INFORM_MEM(("%s: Modifying nan ctrl flag %x val %d",
- __FUNCTION__, flag, set));
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data = MALLOCZ(dhdp->osh, sizeof(*nan_iov_data));
- if (!nan_iov_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data->nan_iov_len = nan_iov_start = NAN_IOCTL_BUF_SIZE;
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(cfg_ctrl), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_NAN_CONFIG);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(cfg_ctrl);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_buf->is_set = false;
- nan_buf->count++;
-
- /* Reduce the iov_len size by subcmd_len */
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_end = nan_iov_data->nan_iov_len;
- nan_buf_size = (nan_iov_start - nan_iov_end);
-
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(*status)) {
- WL_ERR(("get nan cfg ctrl failed ret %d status %d \n", ret, *status));
- goto fail;
- }
- sub_cmd_resp = &((bcm_iov_batch_buf_t *)(resp_buf))->cmds[0];
-
- /* check the response buff */
- cfg_ctrl = (*(uint32 *)&sub_cmd_resp->data[0]);
- if (set) {
- cfg_ctrl |= flag;
- } else {
- cfg_ctrl &= ~flag;
- }
- memcpy(sub_cmd->data, &cfg_ctrl, sizeof(cfg_ctrl));
- nan_buf->is_set = true;
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(*status)) {
- WL_ERR(("set nan cfg ctrl failed ret %d status %d \n", ret, *status));
- goto fail;
- }
- WL_DBG(("set nan cfg ctrl successfull\n"));
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- if (nan_iov_data) {
- MFREE(dhdp->osh, nan_iov_data, sizeof(*nan_iov_data));
- }
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_get_iovars_status(void *ctx, const uint8 *data, uint16 type, uint16 len)
-{
- bcm_iov_batch_buf_t *b_resp = (bcm_iov_batch_buf_t *)ctx;
- uint32 status;
- /* if all tlvs are parsed, we should not be here */
- if (b_resp->count == 0) {
- return BCME_BADLEN;
- }
-
- /* cbfn params may be used in f/w */
- if (len < sizeof(status)) {
- return BCME_BUFTOOSHORT;
- }
-
- /* first 4 bytes consists status */
- memcpy(&status, data, sizeof(uint32));
- status = dtoh32(status);
-
- /* If status is non zero */
- if (status != BCME_OK) {
- printf("cmd type %d failed, status: %04x\n", type, status);
- goto exit;
- }
-
- if (b_resp->count > 0) {
- b_resp->count--;
- }
-
- if (!b_resp->count) {
- status = BCME_IOV_LAST_CMD;
- }
-exit:
- return status;
-}
-
-static int
-wl_cfgnan_execute_ioctl(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- bcm_iov_batch_buf_t *nan_buf, uint16 nan_buf_size, uint32 *status,
- uint8 *resp_buf, uint16 resp_buf_size)
-{
- int ret = BCME_OK;
- uint16 tlvs_len;
- int res = BCME_OK;
- bcm_iov_batch_buf_t *p_resp = NULL;
- char *iov = "nan";
- int max_resp_len = WLC_IOCTL_MAXLEN;
-
- WL_DBG(("Enter:\n"));
- if (nan_buf->is_set) {
- ret = wldev_iovar_setbuf(ndev, "nan", nan_buf, nan_buf_size,
- resp_buf, resp_buf_size, NULL);
- p_resp = (bcm_iov_batch_buf_t *)(resp_buf + strlen(iov) + 1);
- } else {
- ret = wldev_iovar_getbuf(ndev, "nan", nan_buf, nan_buf_size,
- resp_buf, resp_buf_size, NULL);
- p_resp = (bcm_iov_batch_buf_t *)(resp_buf);
- }
- if (unlikely(ret)) {
- WL_ERR((" nan execute ioctl failed, error = %d \n", ret));
- goto fail;
- }
-
- p_resp->is_set = nan_buf->is_set;
- tlvs_len = max_resp_len - OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- /* Extract the tlvs and print their resp in cb fn */
- res = bcm_unpack_xtlv_buf((void *)p_resp, (const uint8 *)&p_resp->cmds[0],
- tlvs_len, BCM_IOV_CMD_OPT_ALIGN32, wl_cfgnan_get_iovars_status);
-
- if (res == BCME_IOV_LAST_CMD) {
- res = BCME_OK;
- }
-fail:
- *status = res;
- WL_DBG((" nan ioctl ret %d status %d \n", ret, *status));
- return ret;
-
-}
-
-static int
-wl_cfgnan_if_addr_handler(void *p_buf, uint16 *nan_buf_size,
- struct ether_addr *if_addr)
-{
- /* nan enable */
- s32 ret = BCME_OK;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- if (p_buf != NULL) {
- bcm_iov_batch_subcmd_t *sub_cmd = (bcm_iov_batch_subcmd_t*)(p_buf);
-
- ret = wl_cfg_nan_check_cmd_len(*nan_buf_size,
- sizeof(*if_addr), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
-
- /* Fill the sub_command block */
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_IF_ADDR);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(*if_addr);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- memcpy(sub_cmd->data, (uint8 *)if_addr,
- sizeof(*if_addr));
-
- *nan_buf_size -= subcmd_len;
- } else {
- WL_ERR(("nan_iov_buf is NULL\n"));
- ret = BCME_ERROR;
- goto fail;
- }
-
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_if_addr(struct bcm_cfg80211 *cfg)
-{
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint32 status;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- struct ether_addr if_addr;
- uint8 buf[NAN_IOCTL_BUF_SIZE];
- bcm_iov_batch_buf_t *nan_buf = (bcm_iov_batch_buf_t*)buf;
- bool rand_mac = cfg->nancfg.mac_rand;
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
- if (rand_mac) {
- RANDOM_BYTES(if_addr.octet, 6);
- /* restore mcast and local admin bits to 0 and 1 */
- ETHER_SET_UNICAST(if_addr.octet);
- ETHER_SET_LOCALADDR(if_addr.octet);
- } else {
- /* Use primary MAC with the locally administered bit for the
- * NAN NMI I/F
- */
- if (wl_get_vif_macaddr(cfg, WL_IF_TYPE_NAN_NMI,
- if_addr.octet) != BCME_OK) {
- ret = -EINVAL;
- goto fail;
- }
- }
- WL_INFORM_MEM(("%s: NMI " MACDBG "\n",
- __FUNCTION__, MAC2STRDBG(if_addr.octet)));
- ret = wl_cfgnan_if_addr_handler(&nan_buf->cmds[0],
- &nan_buf_size, &if_addr);
- if (unlikely(ret)) {
- WL_ERR(("Nan if addr handler sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- nan_buf->is_set = true;
- nan_buf_size = NAN_IOCTL_BUF_SIZE - nan_buf_size;
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(bcmcfg_to_prmry_ndev(cfg), cfg,
- nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("nan if addr handler failed ret %d status %d\n",
- ret, status));
- goto fail;
- }
- memcpy(cfg->nan_nmi_mac, if_addr.octet, ETH_ALEN);
- return ret;
-fail:
- if (!rand_mac) {
- wl_release_vif_macaddr(cfg, if_addr.octet, WL_IF_TYPE_NAN_NMI);
- }
-
- return ret;
-}
-
-static int
-wl_cfgnan_init_handler(void *p_buf, uint16 *nan_buf_size, bool val)
-{
- /* nan enable */
- s32 ret = BCME_OK;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- if (p_buf != NULL) {
- bcm_iov_batch_subcmd_t *sub_cmd = (bcm_iov_batch_subcmd_t*)(p_buf);
-
- ret = wl_cfg_nan_check_cmd_len(*nan_buf_size,
- sizeof(val), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
-
- /* Fill the sub_command block */
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_NAN_INIT);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(uint8);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- memcpy(sub_cmd->data, (uint8*)&val, sizeof(uint8));
-
- *nan_buf_size -= subcmd_len;
- } else {
- WL_ERR(("nan_iov_buf is NULL\n"));
- ret = BCME_ERROR;
- goto fail;
- }
-
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_enable_handler(wl_nan_iov_t *nan_iov_data, bool val)
-{
- /* nan enable */
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(val), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- /* Fill the sub_command block */
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_NAN_ENAB);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(uint8);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- memcpy(sub_cmd->data, (uint8*)&val, sizeof(uint8));
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_warmup_time_handler(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data)
-{
- /* wl nan warm_up_time */
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_warmup_time_ticks_t *wup_ticks = NULL;
- uint16 subcmd_len;
- NAN_DBG_ENTER();
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
- wup_ticks = (wl_nan_warmup_time_ticks_t *)sub_cmd->data;
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*wup_ticks), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
- /* Fill the sub_command block */
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_WARMUP_TIME);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- sizeof(*wup_ticks);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- *wup_ticks = cmd_data->warmup_time;
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_election_metric(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data, uint32 nan_attr_mask)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_election_metric_config_t *metrics = NULL;
- uint16 subcmd_len;
- NAN_DBG_ENTER();
-
- sub_cmd =
- (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*metrics), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
-
- metrics = (wl_nan_election_metric_config_t *)sub_cmd->data;
-
- if (nan_attr_mask & NAN_ATTR_RAND_FACTOR_CONFIG) {
- metrics->random_factor = (uint8)cmd_data->metrics.random_factor;
- }
-
- if ((!cmd_data->metrics.master_pref) ||
- (cmd_data->metrics.master_pref > NAN_MAXIMUM_MASTER_PREFERENCE)) {
- WL_TRACE(("Master Pref is 0 or greater than 254, hence sending random value\n"));
- /* Master pref for mobile devices can be from 1 - 127 as per Spec AppendixC */
- metrics->master_pref = (RANDOM32()%(NAN_MAXIMUM_MASTER_PREFERENCE/2)) + 1;
- } else {
- metrics->master_pref = (uint8)cmd_data->metrics.master_pref;
- }
- sub_cmd->id = htod16(WL_NAN_CMD_ELECTION_METRICS_CONFIG);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- sizeof(*metrics);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_rssi_proximity(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data, uint32 nan_attr_mask)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_rssi_notif_thld_t *rssi_notif_thld = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- rssi_notif_thld = (wl_nan_rssi_notif_thld_t *)sub_cmd->data;
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*rssi_notif_thld), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
- if (nan_attr_mask & NAN_ATTR_RSSI_PROXIMITY_2G_CONFIG) {
- rssi_notif_thld->bcn_rssi_2g =
- cmd_data->rssi_attr.rssi_proximity_2dot4g_val;
- } else {
- /* Keeping RSSI threshold value to be -70dBm */
- rssi_notif_thld->bcn_rssi_2g = NAN_DEF_RSSI_NOTIF_THRESH;
- }
-
- if (nan_attr_mask & NAN_ATTR_RSSI_PROXIMITY_5G_CONFIG) {
- rssi_notif_thld->bcn_rssi_5g =
- cmd_data->rssi_attr.rssi_proximity_5g_val;
- } else {
- /* Keeping RSSI threshold value to be -70dBm */
- rssi_notif_thld->bcn_rssi_5g = NAN_DEF_RSSI_NOTIF_THRESH;
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_SYNC_BCN_RSSI_NOTIF_THRESHOLD);
- sub_cmd->len = htod16(sizeof(sub_cmd->u.options) + sizeof(*rssi_notif_thld));
- sub_cmd->u.options = htod32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_rssi_mid_or_close(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data, uint32 nan_attr_mask)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_rssi_thld_t *rssi_thld = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
- rssi_thld = (wl_nan_rssi_thld_t *)sub_cmd->data;
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*rssi_thld), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- /*
- * Keeping RSSI mid value -75dBm for both 2G and 5G
- * Keeping RSSI close value -60dBm for both 2G and 5G
- */
- if (nan_attr_mask & NAN_ATTR_RSSI_MIDDLE_2G_CONFIG) {
- rssi_thld->rssi_mid_2g =
- cmd_data->rssi_attr.rssi_middle_2dot4g_val;
- } else {
- rssi_thld->rssi_mid_2g = NAN_DEF_RSSI_MID;
- }
-
- if (nan_attr_mask & NAN_ATTR_RSSI_MIDDLE_5G_CONFIG) {
- rssi_thld->rssi_mid_5g =
- cmd_data->rssi_attr.rssi_middle_5g_val;
- } else {
- rssi_thld->rssi_mid_5g = NAN_DEF_RSSI_MID;
- }
-
- if (nan_attr_mask & NAN_ATTR_RSSI_CLOSE_CONFIG) {
- rssi_thld->rssi_close_2g =
- cmd_data->rssi_attr.rssi_close_2dot4g_val;
- } else {
- rssi_thld->rssi_close_2g = NAN_DEF_RSSI_CLOSE;
- }
-
- if (nan_attr_mask & NAN_ATTR_RSSI_CLOSE_5G_CONFIG) {
- rssi_thld->rssi_close_5g =
- cmd_data->rssi_attr.rssi_close_5g_val;
- } else {
- rssi_thld->rssi_close_5g = NAN_DEF_RSSI_CLOSE;
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_ELECTION_RSSI_THRESHOLD);
- sub_cmd->len = htod16(sizeof(sub_cmd->u.options) + sizeof(*rssi_thld));
- sub_cmd->u.options = htod32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_nan_soc_chans(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data, uint32 nan_attr_mask)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_social_channels_t *soc_chans = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
- soc_chans =
- (wl_nan_social_channels_t *)sub_cmd->data;
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*soc_chans), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_SYNC_SOCIAL_CHAN);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- sizeof(*soc_chans);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- if (nan_attr_mask & NAN_ATTR_2G_CHAN_CONFIG) {
- soc_chans->soc_chan_2g = cmd_data->chanspec[1];
- } else {
- soc_chans->soc_chan_2g = NAN_DEF_SOCIAL_CHAN_2G;
- }
-
- if (cmd_data->support_5g) {
- if (nan_attr_mask & NAN_ATTR_5G_CHAN_CONFIG) {
- soc_chans->soc_chan_5g = cmd_data->chanspec[2];
- } else {
- soc_chans->soc_chan_5g = NAN_DEF_SOCIAL_CHAN_5G;
- }
- } else {
- WL_DBG(("5G support is disabled\n"));
- }
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_nan_scan_params(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- nan_config_cmd_data_t *cmd_data, uint8 band_index, uint32 nan_attr_mask)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_iov_start, nan_iov_end;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint16 subcmd_len;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_iov_t *nan_iov_data = NULL;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- wl_nan_scan_params_t *scan_params = NULL;
- uint32 status;
-
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
-
- NAN_DBG_ENTER();
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data = MALLOCZ(dhdp->osh, sizeof(*nan_iov_data));
- if (!nan_iov_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data->nan_iov_len = nan_iov_start = NAN_IOCTL_BUF_SIZE;
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*scan_params), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
- scan_params = (wl_nan_scan_params_t *)sub_cmd->data;
-
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_SCAN_PARAMS);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(*scan_params);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- if (!band_index) {
- /* Fw default: Dwell time for 2G is 210 */
- if ((nan_attr_mask & NAN_ATTR_2G_DWELL_TIME_CONFIG) &&
- cmd_data->dwell_time[0]) {
- scan_params->dwell_time = cmd_data->dwell_time[0] +
- NAN_SCAN_DWELL_TIME_DELTA_MS;
- }
- /* Fw default: Scan period for 2G is 10 */
- if (nan_attr_mask & NAN_ATTR_2G_SCAN_PERIOD_CONFIG) {
- scan_params->scan_period = cmd_data->scan_period[0];
- }
- } else {
- if ((nan_attr_mask & NAN_ATTR_5G_DWELL_TIME_CONFIG) &&
- cmd_data->dwell_time[1]) {
- scan_params->dwell_time = cmd_data->dwell_time[1] +
- NAN_SCAN_DWELL_TIME_DELTA_MS;
- }
- if (nan_attr_mask & NAN_ATTR_5G_SCAN_PERIOD_CONFIG) {
- scan_params->scan_period = cmd_data->scan_period[1];
- }
- }
- scan_params->band_index = band_index;
- nan_buf->is_set = true;
- nan_buf->count++;
-
- /* Reduce the iov_len size by subcmd_len */
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_end = nan_iov_data->nan_iov_len;
- nan_buf_size = (nan_iov_start - nan_iov_end);
-
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("set nan scan params failed ret %d status %d \n", ret, status));
- goto fail;
- }
- WL_DBG(("set nan scan params successfull\n"));
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- if (nan_iov_data) {
- MFREE(dhdp->osh, nan_iov_data, sizeof(*nan_iov_data));
- }
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_cluster_id(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- (sizeof(cmd_data->clus_id) - sizeof(uint8)), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- cmd_data->clus_id.octet[0] = 0x50;
- cmd_data->clus_id.octet[1] = 0x6F;
- cmd_data->clus_id.octet[2] = 0x9A;
- cmd_data->clus_id.octet[3] = 0x01;
- WL_TRACE(("cluster_id = " MACDBG "\n", MAC2STRDBG(cmd_data->clus_id.octet)));
-
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_CID);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(cmd_data->clus_id);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- memcpy(sub_cmd->data, (uint8 *)&cmd_data->clus_id,
- sizeof(cmd_data->clus_id));
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_hop_count_limit(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_hop_count_t *hop_limit = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
- hop_limit = (wl_nan_hop_count_t *)sub_cmd->data;
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*hop_limit), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- *hop_limit = cmd_data->hop_count_limit;
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_HOP_LIMIT);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(*hop_limit);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_sid_beacon_val(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data, uint32 nan_attr_mask)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_sid_beacon_control_t *sid_beacon = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*sid_beacon), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- sid_beacon = (wl_nan_sid_beacon_control_t *)sub_cmd->data;
- sid_beacon->sid_enable = cmd_data->sid_beacon.sid_enable;
- /* Need to have separate flag for sub beacons
- * sid_beacon->sub_sid_enable = cmd_data->sid_beacon.sub_sid_enable;
- */
- if (nan_attr_mask & NAN_ATTR_SID_BEACON_CONFIG) {
- /* Limit for number of publish SIDs to be included in Beacons */
- sid_beacon->sid_count = cmd_data->sid_beacon.sid_count;
- }
- if (nan_attr_mask & NAN_ATTR_SUB_SID_BEACON_CONFIG) {
- /* Limit for number of subscribe SIDs to be included in Beacons */
- sid_beacon->sub_sid_count = cmd_data->sid_beacon.sub_sid_count;
- }
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_SID_BEACON);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- sizeof(*sid_beacon);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_nan_oui(nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- uint16 subcmd_len;
-
- NAN_DBG_ENTER();
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(cmd_data->nan_oui), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_CFG_OUI);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(cmd_data->nan_oui);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- memcpy(sub_cmd->data, (uint32 *)&cmd_data->nan_oui,
- sizeof(cmd_data->nan_oui));
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_set_awake_dws(struct net_device *ndev, nan_config_cmd_data_t *cmd_data,
- wl_nan_iov_t *nan_iov_data, struct bcm_cfg80211 *cfg, uint32 nan_attr_mask)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_awake_dws_t *awake_dws = NULL;
- uint16 subcmd_len;
- NAN_DBG_ENTER();
-
- sub_cmd =
- (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(*awake_dws), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- return ret;
- }
-
- awake_dws = (wl_nan_awake_dws_t *)sub_cmd->data;
-
- if (nan_attr_mask & NAN_ATTR_2G_DW_CONFIG) {
- awake_dws->dw_interval_2g = cmd_data->awake_dws.dw_interval_2g;
- if (!awake_dws->dw_interval_2g) {
- /* Set 2G awake dw value to fw default value 1 */
- awake_dws->dw_interval_2g = NAN_SYNC_DEF_AWAKE_DW;
- }
- } else {
- /* Set 2G awake dw value to fw default value 1 */
- awake_dws->dw_interval_2g = NAN_SYNC_DEF_AWAKE_DW;
- }
-
- if (cfg->support_5g) {
- if (nan_attr_mask & NAN_ATTR_5G_DW_CONFIG) {
- awake_dws->dw_interval_5g = cmd_data->awake_dws.dw_interval_5g;
- if (!awake_dws->dw_interval_5g) {
- /* disable 5g beacon ctrls */
- ret = wl_cfgnan_config_control_flag(ndev, cfg,
- WL_NAN_CTRL_DISC_BEACON_TX_5G,
- &(cmd_data->status), 0);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan control set config handler,"
- " ret = %d status = %d \n",
- ret, cmd_data->status));
- goto fail;
- }
- ret = wl_cfgnan_config_control_flag(ndev, cfg,
- WL_NAN_CTRL_SYNC_BEACON_TX_5G,
- &(cmd_data->status), 0);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan control set config handler,"
- " ret = %d status = %d \n",
- ret, cmd_data->status));
- goto fail;
- }
- }
- } else {
- /* Set 5G awake dw value to fw default value 1 */
- awake_dws->dw_interval_5g = NAN_SYNC_DEF_AWAKE_DW;
- }
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_SYNC_AWAKE_DWS);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- sizeof(*awake_dws);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_data->nan_iov_buf += subcmd_len;
-
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_start_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- nan_config_cmd_data_t *cmd_data, uint32 nan_attr_mask)
-{
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- bcm_iov_batch_buf_t *nan_buf = NULL;
- wl_nan_iov_t *nan_iov_data = NULL;
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- int i;
- s32 timeout = 0;
- bool mutex_locked = false;
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
- mutex_locked = true;
-
- if (!wl_cfg80211_check_for_nan_support(cfg)) {
- ret = BCME_UNSUPPORTED;
- goto fail;
- }
-
- /* disable P2P */
- ret = wl_cfg80211_deinit_p2p_discovery(cfg);
- if (ret != BCME_OK) {
- WL_ERR(("Failed to disable p2p_disc during nan_enab"));
- }
-
- /* set nmi addr */
- ret = wl_cfgnan_set_if_addr(cfg);
- if (ret) {
- WL_ERR(("Failed to nmi address \n"));
- goto fail;
- }
-
- for (i = 0; i < NAN_MAX_NDI; i++) {
- /* Create NDI using the information provided by user space */
- if (cfg->nancfg.ndi[i].in_use && !cfg->nancfg.ndi[i].created) {
- ret = wl_cfgnan_data_path_iface_create_delete_handler(ndev, cfg,
- cfg->nancfg.ndi[i].ifname,
- NAN_WIFI_SUBCMD_DATA_PATH_IFACE_CREATE, dhdp->up);
- if (ret) {
- WL_ERR(("failed to create ndp interface [%d]\n", ret));
- goto fail;
- }
- cfg->nancfg.ndi[i].created = true;
- }
- }
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data = MALLOCZ(dhdp->osh, sizeof(*nan_iov_data));
- if (!nan_iov_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data->nan_iov_len = NAN_IOCTL_BUF_SIZE;
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- if (nan_attr_mask & NAN_ATTR_SYNC_DISC_2G_BEACON_CONFIG) {
- /* config sync/discovery beacons on 2G band */
- /* 2g is mandatory */
- if (!cmd_data->beacon_2g_val) {
- WL_ERR(("Invalid NAN config...2G is mandatory\n"));
- ret = BCME_BADARG;
- }
- ret = wl_cfgnan_config_control_flag(ndev, cfg,
- WL_NAN_CTRL_DISC_BEACON_TX_2G | WL_NAN_CTRL_SYNC_BEACON_TX_2G,
- &(cmd_data->status), TRUE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan control set config handler, ret = %d status = %d \n",
- ret, cmd_data->status));
- goto fail;
- }
- }
- if (nan_attr_mask & NAN_ATTR_SYNC_DISC_5G_BEACON_CONFIG) {
- /* config sync/discovery beacons on 5G band */
- ret = wl_cfgnan_config_control_flag(ndev, cfg,
- WL_NAN_CTRL_DISC_BEACON_TX_5G | WL_NAN_CTRL_SYNC_BEACON_TX_5G,
- &(cmd_data->status), cmd_data->beacon_5g_val);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan control set config handler, ret = %d status = %d \n",
- ret, cmd_data->status));
- goto fail;
- }
- }
- /* Setting warm up time */
- cmd_data->warmup_time = 1;
- if (cmd_data->warmup_time) {
- ret = wl_cfgnan_warmup_time_handler(cmd_data, nan_iov_data);
- if (unlikely(ret)) {
- WL_ERR(("warm up time handler sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- }
- /* setting master preference and random factor */
- ret = wl_cfgnan_set_election_metric(cmd_data, nan_iov_data, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("election_metric sub_cmd set failed\n"));
- goto fail;
- } else {
- nan_buf->count++;
- }
-
- /* setting nan social channels */
- ret = wl_cfgnan_set_nan_soc_chans(cmd_data, nan_iov_data, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("nan social channels set failed\n"));
- goto fail;
- } else {
- /* Storing 5g capability which is reqd for avail chan config. */
- cfg->support_5g = cmd_data->support_5g;
- nan_buf->count++;
- }
-
- if ((cmd_data->support_2g) && ((cmd_data->dwell_time[0]) ||
- (cmd_data->scan_period[0]))) {
- /* setting scan params */
- ret = wl_cfgnan_set_nan_scan_params(ndev, cfg, cmd_data, 0, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("scan params set failed for 2g\n"));
- goto fail;
- }
- }
-
- if ((cmd_data->support_5g) && ((cmd_data->dwell_time[1]) ||
- (cmd_data->scan_period[1]))) {
- /* setting scan params */
- ret = wl_cfgnan_set_nan_scan_params(ndev, cfg, cmd_data,
- cmd_data->support_5g, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("scan params set failed for 5g\n"));
- goto fail;
- }
- }
-
- /*
- * A cluster_low value matching cluster_high indicates a request
- * to join a cluster with that value.
- * If the requested cluster is not found the
- * device will start its own cluster
- */
- /* For Debug purpose, using clust id compulsion */
- if (!ETHER_ISNULLADDR(&cmd_data->clus_id.octet)) {
- if ((cmd_data->clus_id.octet[4] == cmd_data->clus_id.octet[5])) {
- /* device will merge to configured CID only */
- ret = wl_cfgnan_config_control_flag(ndev, cfg,
- WL_NAN_CTRL_MERGE_CONF_CID_ONLY, &(cmd_data->status), true);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan control set config handler, ret = %d status = %d \n",
- ret, cmd_data->status));
- goto fail;
- }
- }
- /* setting cluster ID */
- ret = wl_cfgnan_set_cluster_id(cmd_data, nan_iov_data);
- if (unlikely(ret)) {
- WL_ERR(("cluster_id sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- }
-
- /* setting rssi proximaty values for 2.4GHz and 5GHz */
- ret = wl_cfgnan_set_rssi_proximity(cmd_data, nan_iov_data, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("2.4GHz/5GHz rssi proximity threshold set failed\n"));
- goto fail;
- } else {
- nan_buf->count++;
- }
-
- /* setting rssi middle/close values for 2.4GHz and 5GHz */
- ret = wl_cfgnan_set_rssi_mid_or_close(cmd_data, nan_iov_data, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("2.4GHz/5GHz rssi middle and close set failed\n"));
- goto fail;
- } else {
- nan_buf->count++;
- }
-
- /* setting hop count limit or threshold */
- if (nan_attr_mask & NAN_ATTR_HOP_COUNT_LIMIT_CONFIG) {
- ret = wl_cfgnan_set_hop_count_limit(cmd_data, nan_iov_data);
- if (unlikely(ret)) {
- WL_ERR(("hop_count_limit sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- }
-
- /* setting sid beacon val */
- if ((nan_attr_mask & NAN_ATTR_SID_BEACON_CONFIG) ||
- (nan_attr_mask & NAN_ATTR_SUB_SID_BEACON_CONFIG)) {
- ret = wl_cfgnan_set_sid_beacon_val(cmd_data, nan_iov_data, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("sid_beacon sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- }
-
- /* setting nan oui */
- if (nan_attr_mask & NAN_ATTR_OUI_CONFIG) {
- ret = wl_cfgnan_set_nan_oui(cmd_data, nan_iov_data);
- if (unlikely(ret)) {
- WL_ERR(("nan_oui sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- }
-
- /* setting nan awake dws */
- ret = wl_cfgnan_set_awake_dws(ndev, cmd_data,
- nan_iov_data, cfg, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("nan awake dws set failed\n"));
- goto fail;
- } else {
- nan_buf->count++;
- }
-
- /* enable events */
- ret = wl_cfgnan_config_eventmask(ndev, cfg, cmd_data->disc_ind_cfg, false);
- if (unlikely(ret)) {
- goto fail;
- }
-
- /* setting nan enable sub_cmd */
- ret = wl_cfgnan_enable_handler(nan_iov_data, true);
- if (unlikely(ret)) {
- WL_ERR(("enable handler sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- nan_buf->is_set = true;
-
- nan_buf_size -= nan_iov_data->nan_iov_len;
- memset(resp_buf, 0, sizeof(resp_buf));
- mutex_locked = false;
- /* Reset conditon variable */
- cfg->nancfg.nan_event_recvd = false;
- /* Releasing lock to allow event processing */
- NAN_MUTEX_UNLOCK();
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size,
- &(cmd_data->status), (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan start handler, enable failed, ret = %d status = %d \n",
- ret, cmd_data->status));
- goto fail;
- }
- timeout = wait_event_timeout(cfg->nancfg.nan_event_wait,
- cfg->nancfg.nan_event_recvd, msecs_to_jiffies(NAN_START_STOP_TIMEOUT));
- if (!timeout) {
- WL_ERR(("Timed out while Waiting for WL_NAN_EVENT_START event !!!\n"));
- ret = BCME_ERROR;
- goto fail;
- }
-
- /* If set, auto datapath confirms will be sent by FW */
- ret = wl_cfgnan_config_control_flag(ndev, cfg, WL_NAN_CTRL_AUTO_DPCONF,
- &(cmd_data->status), true);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan control set config handler, ret = %d status = %d \n",
- ret, cmd_data->status));
- goto fail;
- }
- WL_INFORM_MEM(("[NAN] Enable successfull \n"));
-fail:
- /* reset conditon variable */
- cfg->nancfg.nan_event_recvd = false;
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- for (i = 0; i < NAN_MAX_NDI; i++) {
- if (cfg->nancfg.ndi[i].in_use && cfg->nancfg.ndi[i].created) {
- WL_INFORM_MEM(("Deleting NAN NDI IDX:%d\n", i));
- ret = wl_cfgnan_data_path_iface_create_delete_handler(ndev, cfg,
- (char*)cfg->nancfg.ndi[i].ifname,
- NAN_WIFI_SUBCMD_DATA_PATH_IFACE_DELETE, dhdp->up);
- if (ret) {
- WL_ERR(("failed to delete ndp iface [%d]\n", ret));
- }
- }
- }
- }
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- if (nan_iov_data) {
- MFREE(dhdp->osh, nan_iov_data, sizeof(*nan_iov_data));
- }
-
- if (mutex_locked)
- NAN_MUTEX_UNLOCK();
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_stop_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, uint8 busstate, bool disable_events)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_ERROR;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- wl_nan_iov_t *nan_iov_data = NULL;
- uint32 status;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
- uint8 buf[NAN_IOCTL_BUF_SIZE];
- nan_event_data_t *nan_event_data = (nan_event_data_t*)buf;
- s32 timeout;
- bool mutex_locked = false;
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
- mutex_locked = true;
-
- if (!cfg->nan_enable) {
- WL_INFORM(("Nan is not enabled\n"));
- ret = BCME_OK;
- goto fail;
- }
-
- if (busstate != DHD_BUS_DOWN) {
- /*
- * Framework doing cleanup(iface remove) on disable command,
- * so avoiding event to prevent iface delete calls again
- */
- if (disable_events) {
- WL_INFORM_MEM(("[NAN] Disabling Nan events\n"));
- wl_cfgnan_config_eventmask(ndev, cfg, 0, true);
- }
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data = MALLOCZ(dhdp->osh, sizeof(*nan_iov_data));
- if (!nan_iov_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data->nan_iov_len = NAN_IOCTL_BUF_SIZE;
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- ret = wl_cfgnan_enable_handler(nan_iov_data, false);
- if (unlikely(ret)) {
- WL_ERR(("nan disable handler failed\n"));
- goto fail;
- }
- nan_buf->count++;
- nan_buf->is_set = true;
- nan_buf_size -= nan_iov_data->nan_iov_len;
- memset(resp_buf, 0, sizeof(resp_buf));
- mutex_locked = false;
- /* reset conditon variable */
- cfg->nancfg.nan_event_recvd = false;
- /* Releasing lock to allow event processing */
- NAN_MUTEX_UNLOCK();
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("nan disable failed ret = %d status = %d\n", ret, status));
- goto fail;
- }
- cfg->nan_enable = false;
- timeout = wait_event_timeout(cfg->nancfg.nan_event_wait,
- cfg->nancfg.nan_event_recvd, msecs_to_jiffies(NAN_START_STOP_TIMEOUT));
- if (!timeout) {
- WL_ERR(("Timed out while Waiting for WL_NAN_EVENT_STOP event !!!\n"));
- ret = BCME_ERROR;
- goto fail;
- }
- WL_INFORM_MEM(("[NAN] Disable done\n"));
- } else {
- /* Sending up NAN disabled event, to clear the nan state in framework */
- memset(nan_event_data, 0, NAN_IOCTL_BUF_SIZE);
- nan_event_data->status = NAN_STATUS_SUCCESS;
- memcpy(nan_event_data->nan_reason, "NAN_STATUS_SUCCESS",
- strlen("NAN_STATUS_SUCCESS"));
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT)
- ret = wl_cfgvendor_send_nan_event(cfg->wdev->wiphy, bcmcfg_to_prmry_ndev(cfg),
- GOOGLE_NAN_EVENT_DISABLED, nan_event_data);
- if (ret != BCME_OK) {
- WL_ERR(("Failed to send event to nan hal, (%d)\n",
- GOOGLE_NAN_EVENT_DISABLED));
- }
-#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT) */
- WL_INFORM(("Sending disabled event if Bus is down\n"));
- /* Resetting instance ID mask */
- cfg->nancfg.inst_id_start = 0;
- memset(cfg->nancfg.svc_inst_id_mask, 0, sizeof(cfg->nancfg.svc_inst_id_mask));
- cfg->nan_enable = false;
- }
-fail:
- if (!cfg->nancfg.mac_rand) {
- wl_release_vif_macaddr(cfg, cfg->nan_nmi_mac, WL_IF_TYPE_NAN_NMI);
- }
- /* reset conditon variable */
- cfg->nancfg.nan_event_recvd = false;
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- if (nan_iov_data) {
- MFREE(dhdp->osh, nan_iov_data, sizeof(*nan_iov_data));
- }
-
- if (mutex_locked)
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_config_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- nan_config_cmd_data_t *cmd_data, uint32 nan_attr_mask)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- wl_nan_iov_t *nan_iov_data = NULL;
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
-
- NAN_DBG_ENTER();
-
- /* Nan need to be enabled before configuring/updating params */
- if (cfg->nan_enable) {
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data = MALLOCZ(dhdp->osh, sizeof(*nan_iov_data));
- if (!nan_iov_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data->nan_iov_len = NAN_IOCTL_BUF_SIZE;
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- /* setting sid beacon val */
- if ((nan_attr_mask & NAN_ATTR_SID_BEACON_CONFIG) ||
- (nan_attr_mask & NAN_ATTR_SUB_SID_BEACON_CONFIG)) {
- ret = wl_cfgnan_set_sid_beacon_val(cmd_data, nan_iov_data, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("sid_beacon sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- }
-
- /* setting master preference and random factor */
- if (cmd_data->metrics.random_factor ||
- cmd_data->metrics.master_pref) {
- ret = wl_cfgnan_set_election_metric(cmd_data, nan_iov_data,
- nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("election_metric sub_cmd set failed\n"));
- goto fail;
- } else {
- nan_buf->count++;
- }
- }
-
- /* setting hop count limit or threshold */
- if (nan_attr_mask & NAN_ATTR_HOP_COUNT_LIMIT_CONFIG) {
- ret = wl_cfgnan_set_hop_count_limit(cmd_data, nan_iov_data);
- if (unlikely(ret)) {
- WL_ERR(("hop_count_limit sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- }
-
- /* setting rssi proximaty values for 2.4GHz and 5GHz */
- ret = wl_cfgnan_set_rssi_proximity(cmd_data, nan_iov_data,
- nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("2.4GHz/5GHz rssi proximity threshold set failed\n"));
- goto fail;
- } else {
- nan_buf->count++;
- }
-
- /* setting nan awake dws */
- ret = wl_cfgnan_set_awake_dws(ndev, cmd_data, nan_iov_data,
- cfg, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("nan awake dws set failed\n"));
- goto fail;
- } else {
- nan_buf->count++;
- }
-
- if (cmd_data->disc_ind_cfg) {
- /* Disable events */
- WL_TRACE(("Disable events based on flag\n"));
- ret = wl_cfgnan_config_eventmask(ndev, cfg,
- cmd_data->disc_ind_cfg, false);
- if (unlikely(ret)) {
- goto fail;
- }
- }
-
- if ((cfg->support_5g) && ((cmd_data->dwell_time[1]) ||
- (cmd_data->scan_period[1]))) {
- /* setting scan params */
- ret = wl_cfgnan_set_nan_scan_params(ndev, cfg,
- cmd_data, cfg->support_5g, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("scan params set failed for 5g\n"));
- goto fail;
- }
- }
- if ((cmd_data->dwell_time[0]) ||
- (cmd_data->scan_period[0])) {
- ret = wl_cfgnan_set_nan_scan_params(ndev, cfg, cmd_data, 0, nan_attr_mask);
- if (unlikely(ret)) {
- WL_ERR(("scan params set failed for 2g\n"));
- goto fail;
- }
- }
- nan_buf->is_set = true;
- nan_buf_size -= nan_iov_data->nan_iov_len;
-
- if (nan_buf->count) {
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size,
- &(cmd_data->status),
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR((" nan config handler failed ret = %d status = %d\n",
- ret, cmd_data->status));
- goto fail;
- }
- } else {
- WL_DBG(("No commands to send\n"));
- }
-
- if ((!cmd_data->bmap) || (cmd_data->avail_params.duration == NAN_BAND_INVALID) ||
- (!cmd_data->chanspec[0])) {
- WL_TRACE(("mandatory arguments are not present to set avail\n"));
- ret = BCME_OK;
- } else {
- cmd_data->avail_params.chanspec[0] = cmd_data->chanspec[0];
- cmd_data->avail_params.bmap = cmd_data->bmap;
- /* 1=local, 2=peer, 3=ndc, 4=immutable, 5=response, 6=counter */
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data->avail_params, WL_AVAIL_LOCAL);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type local\n"));
- goto fail;
- }
-
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data->avail_params, WL_AVAIL_NDC);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type ndc\n"));
- goto fail;
- }
- }
- } else {
- WL_INFORM(("nan is not enabled\n"));
- }
-
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- if (nan_iov_data) {
- MFREE(dhdp->osh, nan_iov_data, sizeof(*nan_iov_data));
- }
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_support_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_config_cmd_data_t *cmd_data)
-{
- /* TODO: */
- return BCME_OK;
-}
-
-int
-wl_cfgnan_status_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_config_cmd_data_t *cmd_data)
-{
- /* TODO: */
- return BCME_OK;
-}
-
-#ifdef WL_NAN_DISC_CACHE
-static
-nan_svc_info_t *
-wl_cfgnan_get_svc_inst(struct bcm_cfg80211 *cfg,
- wl_nan_instance_id svc_inst_id, uint8 ndp_id)
-{
- uint8 i, j;
- if (ndp_id) {
- for (i = 0; i < NAN_MAX_SVC_INST; i++) {
- for (j = 0; j < NAN_MAX_SVC_INST; j++) {
- if (cfg->svc_info[i].ndp_id[j] == ndp_id) {
- return &cfg->svc_info[i];
- }
- }
- }
- } else if (svc_inst_id) {
- for (i = 0; i < NAN_MAX_SVC_INST; i++) {
- if (cfg->svc_info[i].svc_id == svc_inst_id) {
- return &cfg->svc_info[i];
- }
- }
-
- }
- return NULL;
-}
-
-static
-nan_ranging_inst_t *
-wl_cfgnan_check_for_ranging(struct bcm_cfg80211 *cfg, struct ether_addr *peer)
-{
- uint8 i;
- if (peer) {
- for (i = 0; i < NAN_MAX_RANGING_INST; i++) {
- if (!memcmp(peer, &cfg->nan_ranging_info[i].peer_addr,
- ETHER_ADDR_LEN)) {
- return &(cfg->nan_ranging_info[i]);
- }
- }
- }
- return NULL;
-}
-
-static
-nan_ranging_inst_t *
-wl_cfgnan_get_ranging_inst(struct bcm_cfg80211 *cfg, struct ether_addr *peer,
- uint8 svc_id, bool create)
-{
- nan_ranging_inst_t *ranging_inst = NULL;
- uint8 i;
-
- ranging_inst = wl_cfgnan_check_for_ranging(cfg, peer);
- if (ranging_inst) {
- goto done;
- }
- if (create) {
- WL_TRACE(("Creating Ranging instance \n"));
- for (i = 0; i < NAN_MAX_RANGING_INST; i++) {
- if (cfg->nan_ranging_info[i].range_id == 0)
- break;
- }
- if (i == NAN_MAX_RANGING_INST) {
- WL_DBG(("No buffer available for the ranging instance"));
- goto done;
- }
- ranging_inst = &cfg->nan_ranging_info[i];
- memcpy(&ranging_inst->peer_addr, peer, ETHER_ADDR_LEN);
- ranging_inst->range_status = NAN_RANGING_REQUIRED;
- ranging_inst->svc_inst_id = svc_id;
- }
-
-done:
- return ranging_inst;
-}
-#endif /* WL_NAN_DISC_CACHE */
-
-static int
-process_resp_buf(void *iov_resp,
- uint8 *instance_id, uint16 sub_cmd_id)
-{
- int res = BCME_OK;
- NAN_DBG_ENTER();
-
- if (sub_cmd_id == WL_NAN_CMD_DATA_DATAREQ) {
- wl_nan_dp_req_ret_t *dpreq_ret = NULL;
- dpreq_ret = (wl_nan_dp_req_ret_t *)(iov_resp);
- *instance_id = dpreq_ret->ndp_id;
- WL_TRACE(("%s: Initiator NDI: " MACDBG "\n",
- __FUNCTION__, MAC2STRDBG(dpreq_ret->indi.octet)));
- } else if (sub_cmd_id == WL_NAN_CMD_RANGE_REQUEST) {
- wl_nan_range_id *range_id = NULL;
- range_id = (wl_nan_range_id *)(iov_resp);
- *instance_id = *range_id;
- WL_TRACE(("Range id: %d\n", *range_id));
- }
- WL_DBG(("instance_id: %d\n", *instance_id));
- NAN_DBG_EXIT();
- return res;
-}
-
-#ifdef WL_NAN_DISC_CACHE
-static int
-wl_cfgnan_cancel_ranging(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, uint8 range_id, uint32 *status)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_iov_start, nan_iov_end;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint16 subcmd_len;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- wl_nan_iov_t *nan_iov_data = NULL;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
-
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
-
- NAN_DBG_ENTER();
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data = MALLOCZ(dhdp->osh, sizeof(*nan_iov_data));
- if (!nan_iov_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_iov_data->nan_iov_len = nan_iov_start = NAN_IOCTL_BUF_SIZE;
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_iov_data->nan_iov_buf = (uint8 *)(&nan_buf->cmds[0]);
- nan_iov_data->nan_iov_len -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
- sub_cmd = (bcm_iov_batch_subcmd_t*)(nan_iov_data->nan_iov_buf);
-
- ret = wl_cfg_nan_check_cmd_len(nan_iov_data->nan_iov_len,
- sizeof(range_id), &subcmd_len);
- if (unlikely(ret)) {
- WL_ERR(("nan_sub_cmd check failed\n"));
- goto fail;
- }
-
- sub_cmd->id = htod16(WL_NAN_CMD_RANGE_CANCEL);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(range_id);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- /* Reduce the iov_len size by subcmd_len */
- nan_iov_data->nan_iov_len -= subcmd_len;
- nan_iov_end = nan_iov_data->nan_iov_len;
- nan_buf_size = (nan_iov_start - nan_iov_end);
-
- memcpy(sub_cmd->data, &range_id, sizeof(range_id));
-
- nan_buf->is_set = true;
- nan_buf->count++;
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size, status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(*status)) {
- WL_ERR(("Range cancel failed ret %d status %d \n", ret, *status));
- goto fail;
- }
- WL_INFORM(("Range cancel with Range ID [%d] successfull\n", range_id));
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
- if (nan_iov_data) {
- MFREE(dhdp->osh, nan_iov_data, sizeof(*nan_iov_data));
- }
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_cache_svc_info(struct bcm_cfg80211 *cfg,
- nan_discover_cmd_data_t *cmd_data, uint16 cmd_id)
-{
- int ret = BCME_OK;
- int i;
- nan_svc_info_t *svc_info;
-
- for (i = 0; i < NAN_MAX_SVC_INST; i++) {
- if (!cfg->svc_info[i].svc_id) {
- svc_info = &cfg->svc_info[i];
- break;
- }
- }
- if (i == NAN_MAX_SVC_INST) {
- WL_ERR(("%s:cannot accomodate ranging session\n", __FUNCTION__));
- ret = BCME_NORESOURCE;
- goto fail;
- }
- if (cmd_data->sde_control_flag & NAN_SDE_CF_RANGING_REQUIRED) {
- WL_TRACE(("%s:updating ranging info", __FUNCTION__));
- svc_info->status = 1;
- svc_info->ranging_interval = cmd_data->ranging_intvl_msec;
- svc_info->ranging_ind = cmd_data->ranging_indication;
- svc_info->ingress_limit = cmd_data->ingress_limit;
- svc_info->egress_limit = cmd_data->egress_limit;
- svc_info->ranging_required = 1;
- }
- if (cmd_id == WL_NAN_CMD_SD_SUBSCRIBE) {
- svc_info->svc_id = cmd_data->sub_id;
- if ((cmd_data->flags & WL_NAN_SUB_ACTIVE) &&
- (cmd_data->tx_match.dlen)) {
- memcpy(svc_info->tx_match_filter,
- cmd_data->tx_match.data, cmd_data->tx_match.dlen);
- svc_info->tx_match_filter_len = cmd_data->tx_match.dlen;
- }
- } else {
- svc_info->svc_id = cmd_data->pub_id;
- }
- memcpy(svc_info->svc_hash, cmd_data->svc_hash.data, WL_NAN_SVC_HASH_LEN);
-fail:
- return ret;
-
-}
-
-/* terminate all ranging sessions associated with a svc */
-static int
-wl_cfgnan_terminate_ranging_sessions(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, uint8 svc_id)
-{
- /* cancel all related ranging instances */
- uint8 i;
- int ret = BCME_OK;
- uint32 status;
- nan_ranging_inst_t *ranging_inst;
- nan_svc_info_t *svc;
- for (i = 0; i < NAN_MAX_RANGING_INST; i++) {
- ranging_inst = &cfg->nan_ranging_info[i];
- if (ranging_inst->range_id && ranging_inst->svc_inst_id == svc_id) {
- ret = wl_cfgnan_cancel_ranging(ndev, cfg, ranging_inst->range_id,
- &status);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("%s:nan range cancel failed ret = %d status = %d\n",
- __FUNCTION__, ret, status));
- }
- memset(ranging_inst, 0, sizeof(nan_ranging_inst_t));
- WL_DBG(("Range cancelled \n"));
- }
- }
-
- /* clear command ranging info */
- svc = wl_cfgnan_get_svc_inst(cfg, svc_id, 0);
- if (svc) {
- WL_DBG(("clearing cached svc info for svc id %d\n", svc_id));
- memset(svc, 0, sizeof(*svc));
- }
- return ret;
-}
-
-static int
-wl_cfgnan_check_disc_res_for_ranging(struct bcm_cfg80211 *cfg,
- nan_event_data_t* nan_event_data)
-{
- nan_svc_info_t *svc;
- int ret = BCME_OK;
-
- svc = wl_cfgnan_get_svc_inst(cfg, nan_event_data->sub_id, 0);
-
- if (svc && svc->ranging_required) {
- nan_ranging_inst_t *ranging_inst;
- ranging_inst = wl_cfgnan_get_ranging_inst(cfg,
- &nan_event_data->remote_nmi, nan_event_data->sub_id, TRUE);
- if (ranging_inst->range_status !=
- NAN_RANGING_IN_PROGRESS) {
- WL_DBG(("Trigger range request\n"));
- ret = wl_cfgnan_trigger_ranging(bcmcfg_to_prmry_ndev(cfg),
- cfg, ranging_inst, svc, NAN_RANGE_REQ_CMD);
- if (unlikely(ret)) {
- WL_ERR(("Failed to trigger ranging, ret = (%d)\n", ret));
- memset(ranging_inst, 0, sizeof(*ranging_inst));
- goto exit;
- }
- }
- /* Disc event will be given on receving range_rpt event */
- WL_TRACE(("Disc event will given when Range RPT event is recvd"));
- } else {
- ret = BCME_UNSUPPORTED;
- }
-exit:
- return ret;
-}
-
-/* ranging reqeust event handler */
-static int
-wl_cfgnan_handle_ranging_ind(struct bcm_cfg80211 *cfg,
- wl_nan_ev_rng_req_ind_t *rng_ind)
-{
- int ret = BCME_OK;
- nan_svc_info_t *svc = NULL;
- nan_ranging_inst_t *ranging_inst;
- uint8 i;
-
- WL_DBG(("Trigger range response\n"));
- for (i = 0; i < NAN_MAX_RANGING_INST; i++) {
- if (cfg->svc_info[i].ranging_required) {
- svc = &cfg->svc_info[i];
- }
- }
- if (!svc) {
- /*
- * no publisher indicated ranging support,
- * ignoring ranging request for now
- */
- WL_TRACE(("No publisher has ranging supported.so will reject in trigger api"));
- ret = BCME_OK;
- goto exit;
- } else {
- ranging_inst = wl_cfgnan_get_ranging_inst(cfg, &rng_ind->peer_m_addr,
- svc->svc_id, TRUE);
- if (ranging_inst && ranging_inst->range_status != NAN_RANGING_IN_PROGRESS) {
- ranging_inst->range_id = rng_ind->rng_id;
- ret = wl_cfgnan_trigger_ranging(bcmcfg_to_prmry_ndev(cfg), cfg,
- ranging_inst, svc, NAN_RANGE_REQ_EVNT);
-
- if (unlikely(ret)) {
- WL_ERR(("Failed to trigger range response, ret = (%d)\n", ret));
- memset(ranging_inst, 0, sizeof(*ranging_inst));
- goto exit;
- }
- } else {
- WL_INFORM(("Ranging for the peer already in progress"));
- }
- }
-
-exit:
- return ret;
-}
-
-/* ranging quest and response iovar handler */
-static int
-wl_cfgnan_trigger_ranging(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- void *ranging_ctxt, nan_svc_info_t *svc, uint8 range_cmd)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_buf_t *nan_buf = NULL;
- wl_nan_range_req_t *range_req = NULL;
- wl_nan_range_resp_t *range_resp = NULL;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint32 status;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE_MED];
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
- nan_ranging_inst_t *ranging_inst = (nan_ranging_inst_t *)ranging_ctxt;
- nan_avail_cmd_data cmd_data;
-
- NAN_DBG_ENTER();
-
- memset(&cmd_data, 0, sizeof(cmd_data));
- memcpy(&cmd_data.peer_nmi, &ranging_inst->peer_addr, ETHER_ADDR_LEN);
- cmd_data.avail_period = NAN_RANGING_PERIOD;
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data, WL_AVAIL_LOCAL);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type [WL_AVAIL_LOCAL]\n"));
- goto fail;
- }
-
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data, WL_AVAIL_RANGING);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type [WL_AVAIL_RANGING]\n"));
- goto fail;
- }
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(&nan_buf->cmds[0]);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- if (range_cmd == NAN_RANGE_REQ_CMD) {
- sub_cmd->id = htod16(WL_NAN_CMD_RANGE_REQUEST);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(wl_nan_range_req_t);
- range_req = (wl_nan_range_req_t *)(sub_cmd->data);
- /* ranging config */
- range_req->peer = ranging_inst->peer_addr;
- range_req->interval = svc->ranging_interval;
- /* Limits are in cm from host */
- range_req->ingress = (svc->ingress_limit*10);
- range_req->egress = (svc->egress_limit*10);
- range_req->indication = svc->ranging_ind;
- } else {
- /* range response config */
- sub_cmd->id = htod16(WL_NAN_CMD_RANGE_RESPONSE);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(wl_nan_range_resp_t);
- range_resp = (wl_nan_range_resp_t *)(sub_cmd->data);
- range_resp->range_id = ranging_inst->range_id;
- range_resp->status = svc->status;
- nan_buf->is_set = true;
- }
-
- nan_buf_size -= (sub_cmd->len +
- OFFSETOF(bcm_iov_batch_subcmd_t, u.options));
- nan_buf->count++;
-
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size,
- &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("nan ranging failed ret = %d status = %d\n",
- ret, status));
- ret = status;
- goto fail;
- }
- WL_TRACE(("nan ranging trigger successful\n"));
-
- /* check the response buff for request */
- if (range_cmd == NAN_RANGE_REQ_CMD) {
- ret = process_resp_buf(resp_buf + WL_NAN_OBUF_DATA_OFFSET,
- &ranging_inst->range_id, WL_NAN_CMD_RANGE_REQUEST);
- WL_TRACE(("\n ranging instance returned %d\n", ranging_inst->range_id));
- }
- /* Preventing continuous range requests */
- ranging_inst->range_status = NAN_RANGING_IN_PROGRESS;
-
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
-
- NAN_DBG_EXIT();
- return ret;
-}
-#endif /* WL_NAN_DISC_CACHE */
-
-static void *wl_nan_bloom_alloc(void *ctx, uint size)
-{
- uint8 *buf;
- BCM_REFERENCE(ctx);
-
- buf = kmalloc(size, GFP_KERNEL);
- if (!buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- buf = NULL;
- }
- return buf;
-}
-
-static void wl_nan_bloom_free(void *ctx, void *buf, uint size)
-{
- BCM_REFERENCE(ctx);
- BCM_REFERENCE(size);
- if (buf) {
- kfree(buf);
- }
-}
-
-#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
-#pragma GCC diagnostic ignored "-Wcast-qual"
-#endif // endif
-static uint wl_nan_hash(void *ctx, uint index, const uint8 *input, uint input_len)
-{
- uint8* filter_idx = (uint8*)ctx;
- uint8 i = (*filter_idx * WL_NAN_HASHES_PER_BLOOM) + (uint8)index;
- uint b = 0;
-
- /* Steps 1 and 2 as explained in Section 6.2 */
- /* Concatenate index to input and run CRC32 by calling hndcrc32 twice */
- b = hndcrc32(&i, sizeof(uint8), CRC32_INIT_VALUE);
- b = hndcrc32((uint8*)input, input_len, b);
- /* Obtain the last 2 bytes of the CRC32 output */
- b &= NAN_BLOOM_CRC32_MASK;
-
- /* Step 3 is completed by bcmbloom functions */
- return b;
-}
-
-static int wl_nan_bloom_create(bcm_bloom_filter_t **bp, uint *idx, uint size)
-{
- uint i;
- int err;
-
- err = bcm_bloom_create(wl_nan_bloom_alloc, wl_nan_bloom_free,
- idx, WL_NAN_HASHES_PER_BLOOM, size, bp);
- if (err != BCME_OK) {
- goto exit;
- }
-
- /* Populate bloom filter with hash functions */
- for (i = 0; i < WL_NAN_HASHES_PER_BLOOM; i++) {
- err = bcm_bloom_add_hash(*bp, wl_nan_hash, &i);
- if (err) {
- WL_ERR(("bcm_bloom_add_hash failed\n"));
- goto exit;
- }
- }
-exit:
- return err;
-}
-
-static int
-wl_cfgnan_sd_params_handler(struct net_device *ndev,
- nan_discover_cmd_data_t *cmd_data, uint16 cmd_id,
- void *p_buf, uint16 *nan_buf_size)
-{
- s32 ret = BCME_OK;
- uint8 *pxtlv, *srf = NULL, *srf_mac = NULL, *srftmp = NULL;
- uint16 buflen_avail;
- bcm_iov_batch_subcmd_t *sub_cmd = (bcm_iov_batch_subcmd_t*)(p_buf);
- wl_nan_sd_params_t *sd_params = (wl_nan_sd_params_t *)sub_cmd->data;
- uint16 srf_size = 0;
- uint bloom_size, a;
- bcm_bloom_filter_t *bp = NULL;
- /* Bloom filter index default, indicates it has not been set */
- uint bloom_idx = 0xFFFFFFFF;
- uint16 bloom_len = NAN_BLOOM_LENGTH_DEFAULT;
- /* srf_ctrl_size = bloom_len + src_control field */
- uint16 srf_ctrl_size = bloom_len + 1;
-
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
- struct bcm_cfg80211 *cfg = wl_get_cfg(ndev);
- BCM_REFERENCE(cfg);
-
- NAN_DBG_ENTER();
-
- if (cmd_data->period) {
- sd_params->awake_dw = cmd_data->period;
- }
- sd_params->period = 1;
-
- if (cmd_data->ttl) {
- sd_params->ttl = cmd_data->ttl;
- } else {
- sd_params->ttl = WL_NAN_TTL_UNTIL_CANCEL;
- }
-
- sd_params->flags = 0;
- sd_params->flags = cmd_data->flags;
-
- /* Nan Service Based event suppression Flags */
- if (cmd_data->recv_ind_flag) {
- /* BIT0 - If set, host wont rec event "terminated" */
- if (CHECK_BIT(cmd_data->recv_ind_flag, WL_NAN_EVENT_SUPPRESS_TERMINATE_BIT)) {
- sd_params->flags |= WL_NAN_SVC_CTRL_SUPPRESS_EVT_TERMINATED;
- }
-
- /* BIT1 - If set, host wont receive match expiry evt */
- /* TODO: Exp not yet supported */
- if (CHECK_BIT(cmd_data->recv_ind_flag, WL_NAN_EVENT_SUPPRESS_MATCH_EXP_BIT)) {
- WL_DBG(("Need to add match expiry event\n"));
- }
- /* BIT2 - If set, host wont rec event "receive" */
- if (CHECK_BIT(cmd_data->recv_ind_flag, WL_NAN_EVENT_SUPPRESS_RECEIVE_BIT)) {
- sd_params->flags |= WL_NAN_SVC_CTRL_SUPPRESS_EVT_RECEIVE;
- }
- /* BIT3 - If set, host wont rec event "replied" */
- if (CHECK_BIT(cmd_data->recv_ind_flag, WL_NAN_EVENT_SUPPRESS_REPLIED_BIT)) {
- sd_params->flags |= WL_NAN_SVC_CTRL_SUPPRESS_EVT_REPLIED;
- }
- }
- if (cmd_id == WL_NAN_CMD_SD_PUBLISH) {
- sd_params->instance_id = cmd_data->pub_id;
- if (cmd_data->service_responder_policy) {
- /* Do not disturb avail if dam is supported */
- if (FW_SUPPORTED(dhdp, autodam)) {
- /* Nan Accept policy: Per service basis policy
- * Based on this policy(ALL/NONE), responder side
- * will send ACCEPT/REJECT
- * If set, auto datapath responder will be sent by FW
- */
- sd_params->flags |= WL_NAN_SVC_CTRL_AUTO_DPRESP;
- } else {
- WL_ERR(("svc specifiv auto dp resp is not"
- " supported in non-auto dam fw\n"));
- }
- }
- } else if (cmd_id == WL_NAN_CMD_SD_SUBSCRIBE) {
- sd_params->instance_id = cmd_data->sub_id;
- } else {
- ret = BCME_USAGE_ERROR;
- WL_ERR(("wrong command id = %d \n", cmd_id));
- goto fail;
- }
-
- if ((cmd_data->svc_hash.dlen == WL_NAN_SVC_HASH_LEN) &&
- (cmd_data->svc_hash.data)) {
- memcpy((uint8*)sd_params->svc_hash, cmd_data->svc_hash.data,
- cmd_data->svc_hash.dlen);
-#ifdef WL_NAN_DEBUG
- prhex("hashed svc name", cmd_data->svc_hash.data,
- cmd_data->svc_hash.dlen);
-#endif /* WL_NAN_DEBUG */
- } else {
- ret = BCME_ERROR;
- WL_ERR(("invalid svc hash data or length = %d\n",
- cmd_data->svc_hash.dlen));
- goto fail;
- }
-
- /* check if ranging support is present in firmware */
- if ((cmd_data->sde_control_flag & NAN_SDE_CF_RANGING_REQUIRED) &&
- !FW_SUPPORTED(dhdp, nanrange)) {
- WL_ERR(("Service requires ranging but fw doesnt support it\n"));
- ret = BCME_UNSUPPORTED;
- goto fail;
- }
-
- /* Optional parameters: fill the sub_command block with service descriptor attr */
- sub_cmd->id = htod16(cmd_id);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- OFFSETOF(wl_nan_sd_params_t, optional[0]);
- pxtlv = (uint8*)&sd_params->optional[0];
-
- *nan_buf_size -= sub_cmd->len;
- buflen_avail = *nan_buf_size;
-
- if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {
- WL_TRACE(("optional svc_info present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_SD_SVC_INFO,
- cmd_data->svc_info.dlen,
- cmd_data->svc_info.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_SD_SVC_INFO\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->sde_svc_info.data && cmd_data->sde_svc_info.dlen) {
- WL_TRACE(("optional sdea svc_info present, pack it, %d\n",
- cmd_data->sde_svc_info.dlen));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_SD_SDE_SVC_INFO,
- cmd_data->sde_svc_info.dlen,
- cmd_data->sde_svc_info.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack sdea svc info\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->tx_match.dlen) {
- WL_TRACE(("optional tx match filter presnet (len=%d)\n",
- cmd_data->tx_match.dlen));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_CFG_MATCH_TX, cmd_data->tx_match.dlen,
- cmd_data->tx_match.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: failed on xtlv_pack for tx match filter\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->life_count) {
- WL_TRACE(("optional life count is present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size, WL_NAN_XTLV_CFG_SVC_LIFE_COUNT,
- sizeof(cmd_data->life_count), &cmd_data->life_count,
- BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: failed to WL_NAN_XTLV_CFG_SVC_LIFE_COUNT\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->use_srf) {
- uint8 srf_control = 0;
- /* set include bit */
- if (cmd_data->srf_include == true) {
- srf_control |= 0x2;
- }
-
- if (!ETHER_ISNULLADDR(&cmd_data->mac_list.list) &&
- (cmd_data->mac_list.num_mac_addr
- < NAN_SRF_MAX_MAC)) {
- if (cmd_data->srf_type == SRF_TYPE_SEQ_MAC_ADDR) {
- /* mac list */
- srf_size = (cmd_data->mac_list.num_mac_addr
- * ETHER_ADDR_LEN) + NAN_SRF_CTRL_FIELD_LEN;
- WL_TRACE(("srf size = %d\n", srf_size));
-
- srf_mac = MALLOCZ(dhdp->osh, srf_size);
- if (srf_mac == NULL) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- ret = -ENOMEM;
- goto fail;
- }
- memcpy(srf_mac, &srf_control, NAN_SRF_CTRL_FIELD_LEN);
- memcpy(srf_mac+1, cmd_data->mac_list.list,
- (srf_size - NAN_SRF_CTRL_FIELD_LEN));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_CFG_SR_FILTER, srf_size, srf_mac,
- BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: failed to WL_NAN_XTLV_CFG_SR_FILTER\n",
- __FUNCTION__));
- goto fail;
- }
- } else if (cmd_data->srf_type == SRF_TYPE_BLOOM_FILTER) {
- /* Create bloom filter */
- srf = MALLOCZ(dhdp->osh, srf_ctrl_size);
- if (srf == NULL) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- ret = -ENOMEM;
- goto fail;
- }
- /* Bloom filter */
- srf_control |= 0x1;
- /* Instance id must be from 0 to 254, 255 is vendor specific */
- if (sd_params->instance_id <= NAN_ID_MIN ||
- sd_params->instance_id > (NAN_ID_MAX - 1)) {
- WL_ERR(("Invalid instance id\n"));
- ret = BCME_BADARG;
- goto fail;
- }
- if (bloom_idx == 0xFFFFFFFF) {
- bloom_idx = sd_params->instance_id % 4;
- } else {
- WL_ERR(("Invalid bloom_idx\n"));
- ret = BCME_BADARG;
- goto fail;
-
- }
- srf_control |= bloom_idx << 2;
-
- ret = wl_nan_bloom_create(&bp, &bloom_idx, bloom_len);
- if (unlikely(ret)) {
- WL_ERR(("%s: Bloom create failed\n", __FUNCTION__));
- goto fail;
- }
-
- srftmp = cmd_data->mac_list.list;
- for (a = 0;
- a < cmd_data->mac_list.num_mac_addr; a++) {
- ret = bcm_bloom_add_member(bp, srftmp, ETHER_ADDR_LEN);
- if (unlikely(ret)) {
- WL_ERR(("%s: Cannot add to bloom filter\n",
- __FUNCTION__));
- goto fail;
- }
- srftmp += ETHER_ADDR_LEN;
- }
-
- memcpy(srf, &srf_control, NAN_SRF_CTRL_FIELD_LEN);
- ret = bcm_bloom_get_filter_data(bp, bloom_len,
- (srf + NAN_SRF_CTRL_FIELD_LEN),
- &bloom_size);
- if (unlikely(ret)) {
- WL_ERR(("%s: Cannot get filter data\n", __FUNCTION__));
- goto fail;
- }
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_CFG_SR_FILTER, srf_ctrl_size,
- srf, BCM_XTLV_OPTION_ALIGN32);
- if (ret != BCME_OK) {
- goto fail;
- }
- } else {
- WL_ERR(("Invalid SRF Type = %d !!!\n",
- cmd_data->srf_type));
- goto fail;
- }
- } else {
- WL_ERR(("Invalid MAC Addr/Too many mac addr = %d !!!\n",
- cmd_data->mac_list.num_mac_addr));
- goto fail;
- }
- }
-
- if (cmd_data->rx_match.dlen) {
- WL_TRACE(("optional rx match filter is present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_CFG_MATCH_RX, cmd_data->rx_match.dlen,
- cmd_data->rx_match.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: failed on xtlv_pack for rx match filter\n", __func__));
- goto fail;
- }
- }
-
- /* Security elements */
- if (cmd_data->csid) {
- WL_TRACE(("Cipher suite type is present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_CFG_SEC_CSID, sizeof(nan_sec_csid_e),
- (uint8*)&cmd_data->csid, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack on csid\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->ndp_cfg.security_cfg) {
- if ((cmd_data->key_type == NAN_SECURITY_KEY_INPUT_PMK) ||
- (cmd_data->key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE)) {
- if (cmd_data->key.data && cmd_data->key.dlen) {
- WL_TRACE(("optional pmk present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_CFG_SEC_PMK, cmd_data->key.dlen,
- cmd_data->key.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_CFG_SEC_PMK\n",
- __FUNCTION__));
- goto fail;
- }
- }
- } else {
- WL_ERR(("Invalid security key type\n"));
- ret = BCME_BADARG;
- goto fail;
- }
- }
-
- if (cmd_data->scid.data && cmd_data->scid.dlen) {
- WL_TRACE(("optional scid present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size, WL_NAN_XTLV_CFG_SEC_SCID,
- cmd_data->scid.dlen, cmd_data->scid.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_CFG_SEC_SCID\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->sde_control_flag) {
- ret = bcm_pack_xtlv_entry(&pxtlv, nan_buf_size,
- WL_NAN_XTLV_SD_SDE_CONTROL,
- sizeof(uint16), (uint8*)&cmd_data->sde_control_flag,
- BCM_XTLV_OPTION_ALIGN32);
- if (ret != BCME_OK) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_SD_SDE_CONTROL\n", __FUNCTION__));
- goto fail;
- }
- }
-
- sub_cmd->len += (buflen_avail - *nan_buf_size);
-
-fail:
- if (srf) {
- MFREE(dhdp->osh, srf, srf_ctrl_size);
- }
-
- if (srf_mac) {
- MFREE(dhdp->osh, srf_mac, srf_size);
- }
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_aligned_data_size_of_opt_disc_params(uint16 *data_size, nan_discover_cmd_data_t *cmd_data)
-{
- s32 ret = BCME_OK;
- if (cmd_data->svc_info.dlen)
- *data_size += ALIGN_SIZE(cmd_data->svc_info.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->sde_svc_info.dlen)
- *data_size += ALIGN_SIZE(cmd_data->sde_svc_info.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->tx_match.dlen)
- *data_size += ALIGN_SIZE(cmd_data->tx_match.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->rx_match.dlen)
- *data_size += ALIGN_SIZE(cmd_data->rx_match.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->use_srf) {
- if (cmd_data->srf_type == SRF_TYPE_SEQ_MAC_ADDR) {
- *data_size += (cmd_data->mac_list.num_mac_addr * ETHER_ADDR_LEN)
- + NAN_SRF_CTRL_FIELD_LEN;
- } else { /* Bloom filter type */
- *data_size += NAN_BLOOM_LENGTH_DEFAULT + 1;
- }
- *data_size += ALIGN_SIZE(*data_size + NAN_XTLV_ID_LEN_SIZE, 4);
- }
- if (cmd_data->csid)
- *data_size += ALIGN_SIZE(sizeof(nan_sec_csid_e) + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->key.dlen)
- *data_size += ALIGN_SIZE(cmd_data->key.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->scid.dlen)
- *data_size += ALIGN_SIZE(cmd_data->scid.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->sde_control_flag)
- *data_size += ALIGN_SIZE(sizeof(uint16) + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->life_count)
- *data_size += ALIGN_SIZE(sizeof(cmd_data->life_count) + NAN_XTLV_ID_LEN_SIZE, 4);
- return ret;
-}
-
-static int
-wl_cfgnan_aligned_data_size_of_opt_dp_params(uint16 *data_size, nan_datapath_cmd_data_t *cmd_data)
-{
- s32 ret = BCME_OK;
- if (cmd_data->svc_info.dlen)
- *data_size += ALIGN_SIZE(cmd_data->svc_info.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->key.dlen)
- *data_size += ALIGN_SIZE(cmd_data->key.dlen + NAN_XTLV_ID_LEN_SIZE, 4);
- if (cmd_data->csid)
- *data_size += ALIGN_SIZE(sizeof(nan_sec_csid_e) + NAN_XTLV_ID_LEN_SIZE, 4);
-
- *data_size += ALIGN_SIZE(WL_NAN_SVC_HASH_LEN + NAN_XTLV_ID_LEN_SIZE, 4);
- return ret;
-}
-int
-wl_cfgnan_svc_get_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, uint16 cmd_id, nan_discover_cmd_data_t *cmd_data)
-{
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- uint32 instance_id;
- s32 ret = BCME_OK;
- bcm_iov_batch_buf_t *nan_buf = NULL;
-
- uint8 *resp_buf = NULL;
- uint16 data_size = WL_NAN_OBUF_DATA_OFFSET + sizeof(instance_id);
-
- NAN_DBG_ENTER();
-
- nan_buf = MALLOCZ(cfg->osh, data_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- resp_buf = MALLOCZ(cfg->osh, NAN_IOCTL_BUF_SIZE_LARGE);
- if (!resp_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 1;
- /* check if service is present */
- nan_buf->is_set = false;
- sub_cmd = (bcm_iov_batch_subcmd_t*)(&nan_buf->cmds[0]);
- if (cmd_id == WL_NAN_CMD_SD_PUBLISH) {
- instance_id = cmd_data->pub_id;
- } else if (cmd_id == WL_NAN_CMD_SD_SUBSCRIBE) {
- instance_id = cmd_data->sub_id;
- } else {
- ret = BCME_USAGE_ERROR;
- WL_ERR(("wrong command id = %u\n", cmd_id));
- goto fail;
- }
- /* Fill the sub_command block */
- sub_cmd->id = htod16(cmd_id);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(instance_id);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- memcpy(sub_cmd->data, &instance_id, sizeof(instance_id));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, data_size,
- &(cmd_data->status), resp_buf, NAN_IOCTL_BUF_SIZE_LARGE);
-
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan svc check failed ret = %d status = %d\n", ret, cmd_data->status));
- goto fail;
- } else {
- WL_DBG(("nan svc check successful..proceed to update\n"));
- }
-
-fail:
- if (nan_buf) {
- MFREE(cfg->osh, nan_buf, data_size);
- }
-
- if (resp_buf) {
- MFREE(cfg->osh, resp_buf, NAN_IOCTL_BUF_SIZE_LARGE);
- }
- NAN_DBG_EXIT();
- return ret;
-
-}
-
-int
-wl_cfgnan_svc_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, uint16 cmd_id, nan_discover_cmd_data_t *cmd_data)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_buf_t *nan_buf = NULL;
- uint16 nan_buf_size;
- uint8 *resp_buf = NULL;
- /* Considering fixed params */
- uint16 data_size = WL_NAN_OBUF_DATA_OFFSET +
- OFFSETOF(wl_nan_sd_params_t, optional[0]);
-
- if (cmd_data->svc_update) {
- ret = wl_cfgnan_svc_get_handler(ndev, cfg, cmd_id, cmd_data);
- if (ret != BCME_OK) {
- goto fail;
- } else {
- /* Ignoring any other svc get error */
- if (cmd_data->status == WL_NAN_E_BAD_INSTANCE) {
- goto fail;
- }
- }
- }
-
- ret = wl_cfgnan_aligned_data_size_of_opt_disc_params(&data_size, cmd_data);
- if (unlikely(ret)) {
- WL_ERR(("Failed to get alligned size of optional params\n"));
- goto fail;
- }
- nan_buf_size = data_size;
- NAN_DBG_ENTER();
-
- nan_buf = MALLOCZ(cfg->osh, data_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- resp_buf = MALLOCZ(cfg->osh, data_size + NAN_IOVAR_NAME_SIZE);
- if (!resp_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf->is_set = true;
-
- ret = wl_cfgnan_sd_params_handler(ndev, cmd_data, cmd_id,
- &nan_buf->cmds[0], &nan_buf_size);
- if (unlikely(ret)) {
- WL_ERR((" Service discovery params handler failed, ret = %d\n", ret));
- goto fail;
- }
-
- nan_buf->count++;
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, data_size,
- &(cmd_data->status), resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- if (cmd_data->svc_update && (cmd_data->status == BCME_DATA_NOTFOUND)) {
- /* return OK if update tlv data is not present
- * which means nothing to update
- */
- cmd_data->status = BCME_OK;
- }
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan svc failed ret = %d status = %d\n", ret, cmd_data->status));
- goto fail;
- } else {
- WL_DBG(("nan svc successful\n"));
-#ifdef WL_NAN_DISC_CACHE
- if (!cmd_data->svc_update) { /* cache new service */
- ret = wl_cfgnan_cache_svc_info(cfg, cmd_data, cmd_id);
- if (ret < 0) {
- WL_ERR(("%s: fail to cache svc info, ret=%d\n",
- __FUNCTION__, ret));
- goto fail;
- }
- } else {
- WL_DBG(("skipping caching for update of svc %d\n", cmd_id));
- }
-#endif /* WL_NAN_DISC_CACHE */
- }
-
-fail:
- if (nan_buf) {
- MFREE(cfg->osh, nan_buf, data_size);
- }
-
- if (resp_buf) {
- MFREE(cfg->osh, resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- }
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_publish_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data)
-{
- int ret = BCME_OK;
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- /*
- * proceed only if mandatory arguments are present - subscriber id,
- * service hash
- */
- if ((!cmd_data->pub_id) || (!cmd_data->svc_hash.data) ||
- (!cmd_data->svc_hash.dlen)) {
- WL_ERR(("mandatory arguments are not present\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- ret = wl_cfgnan_svc_handler(ndev, cfg, WL_NAN_CMD_SD_PUBLISH, cmd_data);
- if (ret < 0) {
- WL_ERR(("%s: fail to handle pub, ret=%d\n", __FUNCTION__, ret));
- goto fail;
- }
- WL_INFORM_MEM(("[NAN] Service published for instance id:%d\n", cmd_data->pub_id));
-
-fail:
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_subscribe_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data)
-{
- int ret = BCME_OK;
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- /*
- * proceed only if mandatory arguments are present - subscriber id,
- * service hash
- */
- if ((!cmd_data->sub_id) || (!cmd_data->svc_hash.data) ||
- (!cmd_data->svc_hash.dlen)) {
- WL_ERR(("mandatory arguments are not present\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- ret = wl_cfgnan_svc_handler(ndev, cfg, WL_NAN_CMD_SD_SUBSCRIBE, cmd_data);
- if (ret < 0) {
- WL_ERR(("%s: fail to handle svc, ret=%d\n", __FUNCTION__, ret));
- goto fail;
- }
- WL_INFORM_MEM(("[NAN] Service subscribed for instance id:%d\n", cmd_data->sub_id));
-
-fail:
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_cancel_handler(nan_discover_cmd_data_t *cmd_data,
- uint16 cmd_id, void *p_buf, uint16 *nan_buf_size)
-{
- s32 ret = BCME_OK;
-
- NAN_DBG_ENTER();
-
- if (p_buf != NULL) {
- bcm_iov_batch_subcmd_t *sub_cmd = (bcm_iov_batch_subcmd_t*)(p_buf);
- wl_nan_instance_id_t instance_id;
-
- if (cmd_id == WL_NAN_CMD_SD_CANCEL_PUBLISH) {
- instance_id = cmd_data->pub_id;
- } else if (cmd_id == WL_NAN_CMD_SD_CANCEL_SUBSCRIBE) {
- instance_id = cmd_data->sub_id;
- } else {
- ret = BCME_USAGE_ERROR;
- WL_ERR(("wrong command id = %u\n", cmd_id));
- goto fail;
- }
-
- /* Fill the sub_command block */
- sub_cmd->id = htod16(cmd_id);
- sub_cmd->len = sizeof(sub_cmd->u.options) + sizeof(instance_id);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- memcpy(sub_cmd->data, &instance_id, sizeof(instance_id));
- /* adjust iov data len to the end of last data record */
- *nan_buf_size -= (sub_cmd->len +
- OFFSETOF(bcm_iov_batch_subcmd_t, u.options));
- WL_INFORM_MEM(("[NAN] Service with instance id:%d cancelled\n", instance_id));
- } else {
- WL_ERR(("nan_iov_buf is NULL\n"));
- ret = BCME_ERROR;
- goto fail;
- }
-
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_cancel_pub_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- /* proceed only if mandatory argument is present - publisher id */
- if (!cmd_data->pub_id) {
- WL_ERR(("mandatory argument is not present\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
-#ifdef WL_NAN_DISC_CACHE
- /* terminate ranging sessions for this svc */
- wl_cfgnan_terminate_ranging_sessions(ndev, cfg, cmd_data->pub_id);
-#endif /* WL_NAN_DISC_CACHE */
- ret = wl_cfgnan_cancel_handler(cmd_data, WL_NAN_CMD_SD_CANCEL_PUBLISH,
- &nan_buf->cmds[0], &nan_buf_size);
- if (unlikely(ret)) {
- WL_ERR(("cancel publish failed\n"));
- goto fail;
- }
- nan_buf->is_set = true;
- nan_buf->count++;
-
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size,
- &(cmd_data->status),
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan cancel publish failed ret = %d status = %d\n",
- ret, cmd_data->status));
- goto fail;
- }
- WL_DBG(("nan cancel publish successfull\n"));
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
-
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_cancel_sub_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- /* proceed only if mandatory argument is present - subscriber id */
- if (!cmd_data->sub_id) {
- WL_ERR(("mandatory argument is not present\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
-#ifdef WL_NAN_DISC_CACHE
- /* terminate ranging sessions for this svc */
- wl_cfgnan_terminate_ranging_sessions(ndev, cfg, cmd_data->sub_id);
-#endif /* WL_NAN_DISC_CACHE */
-
- ret = wl_cfgnan_cancel_handler(cmd_data, WL_NAN_CMD_SD_CANCEL_SUBSCRIBE,
- &nan_buf->cmds[0], &nan_buf_size);
- if (unlikely(ret)) {
- WL_ERR(("cancel subscribe failed\n"));
- goto fail;
- }
- nan_buf->is_set = true;
- nan_buf->count++;
-
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size,
- &(cmd_data->status),
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan cancel subscribe failed ret = %d status = %d\n",
- ret, cmd_data->status));
- goto fail;
- }
- WL_DBG(("subscribe cancel successfull\n"));
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
-
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_transmit_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_buf_t *nan_buf = NULL;
- wl_nan_sd_transmit_t *sd_xmit = NULL;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- bool is_lcl_id = FALSE;
- bool is_dest_id = FALSE;
- bool is_dest_mac = FALSE;
- uint16 buflen_avail;
- uint8 *pxtlv;
- uint16 nan_buf_size;
- uint8 *resp_buf = NULL;
- /* Considering fixed params */
- uint16 data_size = WL_NAN_OBUF_DATA_OFFSET +
- OFFSETOF(wl_nan_sd_transmit_t, opt_tlv);
- data_size = ALIGN_SIZE(data_size, 4);
- ret = wl_cfgnan_aligned_data_size_of_opt_disc_params(&data_size, cmd_data);
- if (unlikely(ret)) {
- WL_ERR(("Failed to get alligned size of optional params\n"));
- goto fail;
- }
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
- nan_buf_size = data_size;
- nan_buf = MALLOCZ(cfg->osh, data_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- resp_buf = MALLOCZ(cfg->osh, data_size + NAN_IOVAR_NAME_SIZE);
- if (!resp_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- /* nan transmit */
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
- /*
- * proceed only if mandatory arguments are present - subscriber id,
- * publisher id, mac address
- */
- if ((!cmd_data->local_id) || (!cmd_data->remote_id) ||
- ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) {
- WL_ERR(("mandatory arguments are not present\n"));
- ret = -EINVAL;
- goto fail;
- }
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(&nan_buf->cmds[0]);
- sd_xmit = (wl_nan_sd_transmit_t *)(sub_cmd->data);
-
- /* local instance id must be from 0 to 254, 255 is vendor specific */
- if (cmd_data->local_id <= NAN_ID_MIN ||
- cmd_data->local_id > (NAN_ID_MAX - 1)) {
- WL_ERR(("Invalid local instance id\n"));
- ret = BCME_BADARG;
- goto fail;
- }
- sd_xmit->local_service_id = cmd_data->local_id;
- is_lcl_id = TRUE;
-
- /* remote instance id must be from 0 to 254, 255 is vendor specific */
- if (cmd_data->remote_id <= NAN_ID_MIN ||
- cmd_data->remote_id > (NAN_ID_MAX - 1)) {
- WL_ERR(("Invalid remote instance id\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- sd_xmit->requestor_service_id = cmd_data->remote_id;
- is_dest_id = TRUE;
-
- if (!ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) {
- memcpy(&sd_xmit->destination_addr, &cmd_data->mac_addr, ETHER_ADDR_LEN);
- } else {
- WL_ERR(("Invalid ether addr provided\n"));
- ret = BCME_BADARG;
- goto fail;
- }
- is_dest_mac = TRUE;
-
- if (cmd_data->priority) {
- sd_xmit->priority = cmd_data->priority;
- }
- sd_xmit->token = cmd_data->token;
-
- if (cmd_data->recv_ind_flag) {
- /* BIT0 - If set, host wont rec event "txs" */
- if (CHECK_BIT(cmd_data->recv_ind_flag,
- WL_NAN_EVENT_SUPPRESS_FOLLOWUP_RECEIVE_BIT)) {
- sd_xmit->flags = WL_NAN_FUP_SUPR_EVT_TXS;
- }
- }
- /* Optional parameters: fill the sub_command block with service descriptor attr */
- sub_cmd->id = htod16(WL_NAN_CMD_SD_TRANSMIT);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- OFFSETOF(wl_nan_sd_transmit_t, opt_tlv);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- pxtlv = (uint8 *)&sd_xmit->opt_tlv;
-
- nan_buf_size -= (sub_cmd->len +
- OFFSETOF(bcm_iov_batch_subcmd_t, u.options));
-
- buflen_avail = nan_buf_size;
-
- if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {
- bcm_xtlv_t *pxtlv_svc_info = (bcm_xtlv_t *)pxtlv;
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_SD_SVC_INFO, cmd_data->svc_info.dlen,
- cmd_data->svc_info.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack on bcm_pack_xtlv_entry, ret=%d\n",
- __FUNCTION__, ret));
- goto fail;
- }
-
- /* 0xFF is max length for svc_info */
- if (pxtlv_svc_info->len > 0xFF) {
- WL_ERR(("Invalid service info length %d\n",
- (pxtlv_svc_info->len)));
- ret = BCME_USAGE_ERROR;
- goto fail;
- }
- sd_xmit->opt_len = (uint8)(pxtlv_svc_info->len);
- }
- if (cmd_data->sde_svc_info.data && cmd_data->sde_svc_info.dlen) {
- WL_TRACE(("optional sdea svc_info present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_SD_SDE_SVC_INFO, cmd_data->sde_svc_info.dlen,
- cmd_data->sde_svc_info.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack sdea svc info\n", __FUNCTION__));
- goto fail;
- }
- }
-
- /* Check if all mandatory params are provided */
- if (is_lcl_id && is_dest_id && is_dest_mac) {
- nan_buf->count++;
- sub_cmd->len += (buflen_avail - nan_buf_size);
- } else {
- WL_ERR(("Missing parameters\n"));
- ret = BCME_USAGE_ERROR;
- }
- nan_buf->is_set = TRUE;
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, data_size,
- &(cmd_data->status), resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan transmit failed for token %d ret = %d status = %d\n",
- sd_xmit->token, ret, cmd_data->status));
- goto fail;
- }
- WL_MEM(("nan transmit successful for token %d\n", sd_xmit->token));
-fail:
- if (nan_buf) {
- MFREE(cfg->osh, nan_buf, data_size);
- }
- if (resp_buf) {
- MFREE(cfg->osh, resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- }
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_get_capablities_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_hal_capabilities_t *capabilities)
-{
- s32 ret = BCME_OK;
-
- NAN_DBG_ENTER();
-
- /* Populate get capability */
- capabilities->max_concurrent_nan_clusters = MAX_CONCURRENT_NAN_CLUSTERS;
- capabilities->max_publishes = MAX_PUBLISHES;
- capabilities->max_subscribes = MAX_SUBSCRIBES;
- capabilities->max_service_name_len = MAX_SVC_NAME_LEN;
- capabilities->max_match_filter_len = MAX_MATCH_FILTER_LEN;
- capabilities->max_total_match_filter_len = MAX_TOTAL_MATCH_FILTER_LEN;
- capabilities->max_service_specific_info_len = NAN_MAX_SERVICE_SPECIFIC_INFO_LEN;
- capabilities->max_ndi_interfaces = MAX_NDI_INTERFACES;
- capabilities->max_ndp_sessions = MAX_NDP_SESSIONS;
- capabilities->max_app_info_len = MAX_APP_INFO_LEN;
- capabilities->max_queued_transmit_followup_msgs = MAX_QUEUED_TX_FOLLOUP_MSGS;
- capabilities->max_sdea_service_specific_info_len = MAX_SDEA_SVC_INFO_LEN;
- capabilities->max_subscribe_address = MAX_SUBSCRIBE_ADDRESS;
- capabilities->cipher_suites_supported = CIPHER_SUITE_SUPPORTED;
- capabilities->max_scid_len = MAX_SCID_LEN;
- capabilities->is_ndp_security_supported = true;
- capabilities->ndp_supported_bands = NDP_SUPPORTED_BANDS;
-
- NAN_DBG_EXIT();
- return ret;
-}
-
-bool wl_cfgnan_check_state(struct bcm_cfg80211 *cfg)
-{
- return cfg->nan_enable;
-}
-
-int
-wl_cfgnan_init(struct bcm_cfg80211 *cfg)
-{
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint32 status;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- uint8 buf[NAN_IOCTL_BUF_SIZE];
- bcm_iov_batch_buf_t *nan_buf = (bcm_iov_batch_buf_t*)buf;
-
- NAN_DBG_ENTER();
- if (cfg->nan_init_state) {
- WL_ERR(("nan initialized/nmi exists\n"));
- return BCME_OK;
- }
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
- ret = wl_cfgnan_init_handler(&nan_buf->cmds[0], &nan_buf_size, true);
- if (unlikely(ret)) {
- WL_ERR(("init handler sub_cmd set failed\n"));
- goto fail;
- }
- nan_buf->count++;
- nan_buf->is_set = true;
-
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(bcmcfg_to_prmry_ndev(cfg), cfg,
- nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("nan init handler failed ret %d status %d\n",
- ret, status));
- goto fail;
- }
-
-#ifdef WL_NAN_DISC_CACHE
- /* malloc for disc result */
- cfg->nan_disc_cache = MALLOCZ(cfg->osh,
- NAN_MAX_CACHE_DISC_RESULT * sizeof(nan_disc_result_cache));
- if (!cfg->nan_disc_cache) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-#endif /* WL_NAN_DISC_CACHE */
- cfg->nan_init_state = true;
- return ret;
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_deinit(struct bcm_cfg80211 *cfg, uint8 busstate)
-{
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint32 status;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
- uint8 buf[NAN_IOCTL_BUF_SIZE];
- bcm_iov_batch_buf_t *nan_buf = (bcm_iov_batch_buf_t*)buf;
- uint8 i = 0;
- nan_event_data_t *nan_event_data = (nan_event_data_t*)buf;
-
- BCM_REFERENCE(i);
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- if (!cfg->nan_init_state) {
- WL_ERR(("nan is not initialized/nmi doesnt exists\n"));
- ret = BCME_OK;
- goto fail;
- }
-
- if (busstate != DHD_BUS_DOWN) {
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- WL_DBG(("nan deinit\n"));
- ret = wl_cfgnan_init_handler(&nan_buf->cmds[0], &nan_buf_size, false);
- if (unlikely(ret)) {
- WL_ERR(("deinit handler sub_cmd set failed\n"));
- } else {
- nan_buf->count++;
- nan_buf->is_set = true;
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(cfg->wdev->netdev, cfg,
- nan_buf, nan_buf_size, &status,
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(status)) {
- WL_ERR(("nan init handler failed ret %d status %d\n",
- ret, status));
- }
- }
- }
-
- for (i = 0; i < NAN_MAX_NDI; i++) {
- /* clean NDI data */
- cfg->nancfg.ndi[i].in_use = false;
- cfg->nancfg.ndi[i].created = false;
- memset(&cfg->nancfg.ndi[i].ifname, 0x0, IFNAMSIZ);
- }
-
- cfg->nan_dp_mask = 0;
- cfg->nan_init_state = false;
-#ifdef WL_NAN_DISC_CACHE
- if (cfg->nan_disc_cache) {
- for (i = 0; i < NAN_MAX_CACHE_DISC_RESULT; i++) {
- if (cfg->nan_disc_cache[i].tx_match_filter.data) {
- MFREE(cfg->osh, cfg->nan_disc_cache[i].tx_match_filter.data,
- cfg->nan_disc_cache[i].tx_match_filter.dlen);
- }
- if (cfg->nan_disc_cache[i].svc_info.data) {
- MFREE(cfg->osh, cfg->nan_disc_cache[i].svc_info.data,
- cfg->nan_disc_cache[i].svc_info.dlen);
- }
- }
- MFREE(cfg->osh, cfg->nan_disc_cache,
- NAN_MAX_CACHE_DISC_RESULT * sizeof(nan_disc_result_cache));
- cfg->nan_disc_cache = NULL;
- }
-#endif /* WL_NAN_DISC_CACHE */
-
- /* Sending up NAN disabled event, to clear the nan state in framework */
- if (cfg->nan_enable) {
- memset(nan_event_data, 0, NAN_IOCTL_BUF_SIZE);
- nan_event_data->status = NAN_STATUS_SUCCESS;
- memcpy(nan_event_data->nan_reason, "NAN_STATUS_SUCCESS",
- strlen("NAN_STATUS_SUCCESS"));
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT)
- ret = wl_cfgvendor_send_nan_event(cfg->wdev->wiphy, bcmcfg_to_prmry_ndev(cfg),
- GOOGLE_NAN_EVENT_DISABLED, nan_event_data);
- if (ret != BCME_OK) {
- WL_ERR(("Failed to send event to nan hal, (%d)\n",
- GOOGLE_NAN_EVENT_DISABLED));
- }
-#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT) */
- WL_INFORM(("Sending disabled event\n"));
- /* Resetting instance ID mask */
- cfg->nancfg.inst_id_start = 0;
- memset(cfg->nancfg.svc_inst_id_mask, 0, sizeof(cfg->nancfg.svc_inst_id_mask));
- cfg->nan_enable = false;
- }
-fail:
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-static int
-wl_cfgnan_get_ndi_macaddr(struct bcm_cfg80211 *cfg, u8* mac_addr)
-{
- int i = 0;
- int ret = BCME_OK;
- bool rand_mac = cfg->nancfg.mac_rand;
- BCM_REFERENCE(i);
-
- if (rand_mac) {
- /* ensure nmi != ndi */
- do {
- RANDOM_BYTES(mac_addr, ETHER_ADDR_LEN);
- /* restore mcast and local admin bits to 0 and 1 */
- ETHER_SET_UNICAST(mac_addr);
- ETHER_SET_LOCALADDR(mac_addr);
- i++;
- if (i == NAN_RAND_MAC_RETRIES) {
- break;
- }
- } while (eacmp(cfg->nan_nmi_mac, mac_addr) == 0);
-
- if (i == NAN_RAND_MAC_RETRIES) {
- if (eacmp(cfg->nan_nmi_mac, mac_addr) == 0) {
- WL_ERR(("\nCouldn't generate rand NDI which != NMI\n"));
- ret = BCME_NORESOURCE;
- goto fail;
- }
- }
- } else {
- if (wl_get_vif_macaddr(cfg, WL_IF_TYPE_NAN,
- mac_addr) != BCME_OK) {
- ret = -EINVAL;
- goto fail;
- }
- }
-
-fail:
- return ret;
-}
-
-int
-wl_cfgnan_data_path_iface_create_delete_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, char *ifname, uint16 type, uint8 busstate)
-{
- u8 mac_addr[ETH_ALEN];
- s32 ret = BCME_OK;
- NAN_DBG_ENTER();
-
- if (busstate != DHD_BUS_DOWN) {
- if (type == NAN_WIFI_SUBCMD_DATA_PATH_IFACE_CREATE) {
- ret = wl_cfgnan_get_ndi_macaddr(cfg, mac_addr);
- if (ret != BCME_OK) {
- WL_ERR(("Couldn't get mac addr for NDI ret %d\n", ret));
- goto fail;
- }
- if (wl_cfg80211_add_if(cfg, ndev, WL_IF_TYPE_NAN,
- ifname, mac_addr) == NULL) {
- ret = -ENODEV;
- goto fail;
- }
- } else if (type == NAN_WIFI_SUBCMD_DATA_PATH_IFACE_DELETE) {
- ret = wl_cfg80211_del_if(cfg, ndev, NULL, ifname);
- }
- } else {
- ret = -ENODEV;
- WL_ERR(("Bus is already down, no dev found to remove, ret = %d\n", ret));
- }
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_data_path_request_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_datapath_cmd_data_t *cmd_data,
- uint8 *ndp_instance_id)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_buf_t *nan_buf = NULL;
- wl_nan_dp_req_t *datareq = NULL;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- uint16 buflen_avail;
- uint8 *pxtlv;
- struct wireless_dev *wdev;
-
- uint16 nan_buf_size;
- uint8 *resp_buf = NULL;
- /* Considering fixed params */
- uint16 data_size = WL_NAN_OBUF_DATA_OFFSET +
- OFFSETOF(wl_nan_dp_req_t, tlv_params);
- data_size = ALIGN_SIZE(data_size, 4);
-
- ret = wl_cfgnan_aligned_data_size_of_opt_dp_params(&data_size, cmd_data);
- if (unlikely(ret)) {
- WL_ERR(("Failed to get alligned size of optional params\n"));
- goto fail;
- }
-
- nan_buf_size = data_size;
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- nan_buf = MALLOCZ(cfg->osh, data_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- resp_buf = MALLOCZ(cfg->osh, data_size + NAN_IOVAR_NAME_SIZE);
- if (!resp_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data->avail_params, WL_AVAIL_LOCAL);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type local\n"));
- goto fail;
- }
-
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data->avail_params, WL_AVAIL_NDC);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type ndc\n"));
- goto fail;
- }
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(&nan_buf->cmds[0]);
- datareq = (wl_nan_dp_req_t *)(sub_cmd->data);
-
- /* setting default data path type to unicast */
- datareq->type = WL_NAN_DP_TYPE_UNICAST;
-
- if (cmd_data->pub_id) {
- datareq->pub_id = cmd_data->pub_id;
- }
-
- if (!ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) {
- memcpy(&datareq->peer_mac, &cmd_data->mac_addr, ETHER_ADDR_LEN);
- } else {
- WL_ERR(("Invalid ether addr provided\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- /* Retrieve mac from given iface name */
- wdev = wl_cfg80211_get_wdev_from_ifname(cfg,
- (char *)cmd_data->ndp_iface);
- if (!wdev || ETHER_ISNULLADDR(wdev->netdev->dev_addr)) {
- ret = -EINVAL;
- goto fail;
- }
-
- if (!ETHER_ISNULLADDR(wdev->netdev->dev_addr)) {
- memcpy(&datareq->ndi, wdev->netdev->dev_addr, ETHER_ADDR_LEN);
- WL_TRACE(("%s: Retrieved ndi mac " MACDBG "\n",
- __FUNCTION__, MAC2STRDBG(datareq->ndi.octet)));
- } else {
- WL_ERR(("Invalid NDI addr retrieved\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- datareq->ndl_qos.min_slots = NAN_NDL_QOS_MIN_SLOT_NO_PREF;
- datareq->ndl_qos.max_latency = NAN_NDL_QOS_MAX_LAT_NO_PREF;
-
- /* Fill the sub_command block */
- sub_cmd->id = htod16(WL_NAN_CMD_DATA_DATAREQ);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- OFFSETOF(wl_nan_dp_req_t, tlv_params);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- pxtlv = (uint8 *)&datareq->tlv_params;
-
- nan_buf_size -= (sub_cmd->len +
- OFFSETOF(bcm_iov_batch_subcmd_t, u.options));
- buflen_avail = nan_buf_size;
-
- if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_SD_SVC_INFO, cmd_data->svc_info.dlen,
- cmd_data->svc_info.data,
- BCM_XTLV_OPTION_ALIGN32);
- if (ret != BCME_OK) {
- WL_ERR(("unable to process svc_spec_info: %d\n", ret));
- goto fail;
- }
- datareq->flags |= WL_NAN_DP_FLAG_SVC_INFO;
- }
-
- /* Security elements */
-
- if (cmd_data->csid) {
- WL_TRACE(("Cipher suite type is present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_CFG_SEC_CSID, sizeof(nan_sec_csid_e),
- (uint8*)&cmd_data->csid, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack on csid\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->ndp_cfg.security_cfg) {
- if ((cmd_data->key_type == NAN_SECURITY_KEY_INPUT_PMK) ||
- (cmd_data->key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE)) {
- if (cmd_data->key.data && cmd_data->key.dlen) {
- WL_TRACE(("optional pmk present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_CFG_SEC_PMK, cmd_data->key.dlen,
- cmd_data->key.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack on WL_NAN_XTLV_CFG_SEC_PMK\n",
- __FUNCTION__));
- goto fail;
- }
- }
- } else {
- WL_ERR(("Invalid security key type\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- if ((cmd_data->svc_hash.dlen == WL_NAN_SVC_HASH_LEN) &&
- (cmd_data->svc_hash.data)) {
- WL_TRACE(("svc hash present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_CFG_SVC_HASH, WL_NAN_SVC_HASH_LEN,
- cmd_data->svc_hash.data, BCM_XTLV_OPTION_ALIGN32);
- if (ret != BCME_OK) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_CFG_SVC_HASH\n",
- __FUNCTION__));
- goto fail;
- }
- } else {
-#ifdef WL_NAN_DISC_CACHE
- /* check in cache */
- nan_disc_result_cache *cache;
- cache = wl_cfgnan_get_disc_result(cfg,
- datareq->pub_id, &datareq->peer_mac);
- if (!cache) {
- ret = BCME_ERROR;
- WL_ERR(("invalid svc hash data or length = %d\n",
- cmd_data->svc_hash.dlen));
- goto fail;
- }
- WL_TRACE(("svc hash present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_CFG_SVC_HASH, WL_NAN_SVC_HASH_LEN,
- cache->svc_hash, BCM_XTLV_OPTION_ALIGN32);
- if (ret != BCME_OK) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_CFG_SVC_HASH\n",
- __FUNCTION__));
- goto fail;
- }
-#else
- ret = BCME_ERROR;
- WL_ERR(("invalid svc hash data or length = %d\n",
- cmd_data->svc_hash.dlen));
- goto fail;
-#endif /* WL_NAN_DISC_CACHE */
- }
- /* If the Data req is for secure data connection */
- datareq->flags |= WL_NAN_DP_FLAG_SECURITY;
- }
-
- sub_cmd->len += (buflen_avail - nan_buf_size);
- nan_buf->is_set = false;
- nan_buf->count++;
-
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, data_size,
- &(cmd_data->status), resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan data path request handler failed, ret = %d status %d\n",
- ret, cmd_data->status));
- goto fail;
- }
-
- /* check the response buff */
- if (ret == BCME_OK) {
- ret = process_resp_buf(resp_buf + WL_NAN_OBUF_DATA_OFFSET,
- ndp_instance_id, WL_NAN_CMD_DATA_DATAREQ);
- cmd_data->ndp_instance_id = *ndp_instance_id;
- }
- WL_INFORM_MEM(("[NAN] DP request successfull (ndp_id:%d)\n",
- cmd_data->ndp_instance_id));
-
-fail:
- if (nan_buf) {
- MFREE(cfg->osh, nan_buf, data_size);
- }
-
- if (resp_buf) {
- MFREE(cfg->osh, resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- }
-
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-int
-wl_cfgnan_data_path_response_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_datapath_cmd_data_t *cmd_data)
-{
- s32 ret = BCME_OK;
- bcm_iov_batch_buf_t *nan_buf = NULL;
- wl_nan_dp_resp_t *dataresp = NULL;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- uint16 buflen_avail;
- uint8 *pxtlv;
- struct wireless_dev *wdev;
- uint16 nan_buf_size;
- uint8 *resp_buf = NULL;
-
- /* Considering fixed params */
- uint16 data_size = WL_NAN_OBUF_DATA_OFFSET +
- OFFSETOF(wl_nan_dp_resp_t, tlv_params);
- data_size = ALIGN_SIZE(data_size, 4);
- ret = wl_cfgnan_aligned_data_size_of_opt_dp_params(&data_size, cmd_data);
- if (unlikely(ret)) {
- WL_ERR(("Failed to get alligned size of optional params\n"));
- goto fail;
- }
- nan_buf_size = data_size;
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- nan_buf = MALLOCZ(cfg->osh, data_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- resp_buf = MALLOCZ(cfg->osh, data_size + NAN_IOVAR_NAME_SIZE);
- if (!resp_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data->avail_params, WL_AVAIL_LOCAL);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type local\n"));
- goto fail;
- }
-
- ret = wl_cfgnan_set_nan_avail(bcmcfg_to_prmry_ndev(cfg),
- cfg, &cmd_data->avail_params, WL_AVAIL_NDC);
- if (unlikely(ret)) {
- WL_ERR(("Failed to set avail value with type ndc\n"));
- goto fail;
- }
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(&nan_buf->cmds[0]);
- dataresp = (wl_nan_dp_resp_t *)(sub_cmd->data);
-
- /* Setting default data path type to unicast */
- dataresp->type = WL_NAN_DP_TYPE_UNICAST;
- /* Changing status value as per fw convention */
- dataresp->status = cmd_data->rsp_code ^= 1;
- dataresp->reason_code = 0;
-
- /* ndp instance id must be from 0 to 255 */
- if (cmd_data->ndp_instance_id <= NAN_ID_MIN ||
- cmd_data->ndp_instance_id > NAN_ID_MAX) {
- WL_ERR(("Invalid ndp instance id\n"));
- ret = BCME_BADARG;
- goto fail;
- }
- dataresp->ndp_id = cmd_data->ndp_instance_id;
-
- /* Retrieved initiator ndi from NanDataPathRequestInd */
- if (!ETHER_ISNULLADDR(&cfg->initiator_ndi.octet)) {
- memcpy(&dataresp->mac_addr, &cfg->initiator_ndi, ETHER_ADDR_LEN);
- } else {
- WL_ERR(("Invalid ether addr retrieved\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- /* Retrieve mac from given iface name */
- wdev = wl_cfg80211_get_wdev_from_ifname(cfg,
- (char *)cmd_data->ndp_iface);
- if (!wdev || ETHER_ISNULLADDR(wdev->netdev->dev_addr)) {
- ret = -EINVAL;
- goto fail;
- }
-
- if (!ETHER_ISNULLADDR(wdev->netdev->dev_addr)) {
- memcpy(&dataresp->ndi, wdev->netdev->dev_addr, ETHER_ADDR_LEN);
- WL_TRACE(("%s: Retrieved ndi mac " MACDBG "\n",
- __FUNCTION__, MAC2STRDBG(dataresp->ndi.octet)));
- } else {
- WL_ERR(("Invalid NDI addr retrieved\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- dataresp->ndl_qos.min_slots = NAN_NDL_QOS_MIN_SLOT_NO_PREF;
- dataresp->ndl_qos.max_latency = NAN_NDL_QOS_MAX_LAT_NO_PREF;
-
- /* Fill the sub_command block */
- sub_cmd->id = htod16(WL_NAN_CMD_DATA_DATARESP);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- OFFSETOF(wl_nan_dp_resp_t, tlv_params);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
- pxtlv = (uint8 *)&dataresp->tlv_params;
-
- nan_buf_size -= (sub_cmd->len +
- OFFSETOF(bcm_iov_batch_subcmd_t, u.options));
- buflen_avail = nan_buf_size;
-
- if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_SD_SVC_INFO, cmd_data->svc_info.dlen,
- cmd_data->svc_info.data,
- BCM_XTLV_OPTION_ALIGN32);
- if (ret != BCME_OK) {
- WL_ERR(("unable to process svc_spec_info: %d\n", ret));
- goto fail;
- }
- dataresp->flags |= WL_NAN_DP_FLAG_SVC_INFO;
- }
-
- /* Security elements */
- if (cmd_data->csid) {
- WL_TRACE(("Cipher suite type is present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_CFG_SEC_CSID, sizeof(nan_sec_csid_e),
- (uint8*)&cmd_data->csid, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack csid\n", __FUNCTION__));
- goto fail;
- }
- }
-
- if (cmd_data->ndp_cfg.security_cfg) {
- if ((cmd_data->key_type == NAN_SECURITY_KEY_INPUT_PMK) ||
- (cmd_data->key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE)) {
- if (cmd_data->key.data && cmd_data->key.dlen) {
- WL_TRACE(("optional pmk present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_CFG_SEC_PMK, cmd_data->key.dlen,
- cmd_data->key.data, BCM_XTLV_OPTION_ALIGN32);
- if (unlikely(ret)) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_CFG_SEC_PMK\n",
- __FUNCTION__));
- goto fail;
- }
- }
- } else {
- WL_ERR(("Invalid security key type\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- if ((cmd_data->svc_hash.dlen == WL_NAN_SVC_HASH_LEN) &&
- (cmd_data->svc_hash.data)) {
- WL_TRACE(("svc hash present, pack it\n"));
- ret = bcm_pack_xtlv_entry(&pxtlv, &nan_buf_size,
- WL_NAN_XTLV_CFG_SVC_HASH, WL_NAN_SVC_HASH_LEN,
- cmd_data->svc_hash.data,
- BCM_XTLV_OPTION_ALIGN32);
- if (ret != BCME_OK) {
- WL_ERR(("%s: fail to pack WL_NAN_XTLV_CFG_SVC_HASH\n",
- __FUNCTION__));
- goto fail;
- }
- }
- /* If the Data resp is for secure data connection */
- dataresp->flags |= WL_NAN_DP_FLAG_SECURITY;
- }
-
- sub_cmd->len += (buflen_avail - nan_buf_size);
-
- nan_buf->is_set = false;
- nan_buf->count++;
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, data_size,
- &(cmd_data->status), resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan data path response handler failed, error = %d, status %d\n",
- ret, cmd_data->status));
- goto fail;
- }
-
- WL_INFORM_MEM(("[NAN] DP response successfull (ndp_id:%d)\n", dataresp->ndp_id));
-
-fail:
- if (nan_buf) {
- MFREE(cfg->osh, nan_buf, data_size);
- }
-
- if (resp_buf) {
- MFREE(cfg->osh, resp_buf, data_size + NAN_IOVAR_NAME_SIZE);
- }
-
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-int wl_cfgnan_data_path_end_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_datapath_cmd_data_t *cmd_data)
-{
- bcm_iov_batch_buf_t *nan_buf = NULL;
- wl_nan_dp_end_t *dataend = NULL;
- bcm_iov_batch_subcmd_t *sub_cmd = NULL;
- s32 ret = BCME_OK;
- uint16 nan_buf_size = NAN_IOCTL_BUF_SIZE;
- uint8 resp_buf[NAN_IOCTL_BUF_SIZE];
-
- dhd_pub_t *dhdp = wl_cfg80211_get_dhdp(ndev);
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- if (!dhdp->up) {
- WL_ERR(("bus is already down, hence blocking nan dp end\n"));
- ret = BCME_OK;
- goto fail;
- }
-
- if (!cfg->nan_enable) {
- WL_ERR(("nan is not enabled, nan dp end blocked\n"));
- ret = BCME_OK;
- goto fail;
- }
-
- /* ndp instance id must be from 0 to 255 */
- if (cmd_data->ndp_instance_id <= NAN_ID_MIN ||
- cmd_data->ndp_instance_id > NAN_ID_MAX) {
- WL_ERR(("Invalid ndp instance id\n"));
- ret = BCME_BADARG;
- goto fail;
- }
-
- nan_buf = MALLOCZ(dhdp->osh, nan_buf_size);
- if (!nan_buf) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- ret = BCME_NOMEM;
- goto fail;
- }
-
- nan_buf->version = htol16(WL_NAN_IOV_BATCH_VERSION);
- nan_buf->count = 0;
- nan_buf_size -= OFFSETOF(bcm_iov_batch_buf_t, cmds[0]);
-
- sub_cmd = (bcm_iov_batch_subcmd_t*)(&nan_buf->cmds[0]);
- dataend = (wl_nan_dp_end_t *)(sub_cmd->data);
-
- /* Fill sub_cmd block */
- sub_cmd->id = htod16(WL_NAN_CMD_DATA_DATAEND);
- sub_cmd->len = sizeof(sub_cmd->u.options) +
- sizeof(*dataend);
- sub_cmd->u.options = htol32(BCM_XTLV_OPTION_ALIGN32);
-
- dataend->lndp_id = cmd_data->ndp_instance_id;
-
- /*
- * Currently fw requires ndp_id and reason to end the data path
- * But wifi_nan.h takes ndp_instances_count and ndp_id.
- * Will keep reason = accept always.
- */
-
- dataend->status = 1;
-
- nan_buf->is_set = true;
- nan_buf->count++;
-
- nan_buf_size -= (sub_cmd->len +
- OFFSETOF(bcm_iov_batch_subcmd_t, u.options));
- memset(resp_buf, 0, sizeof(resp_buf));
- ret = wl_cfgnan_execute_ioctl(ndev, cfg, nan_buf, nan_buf_size,
- &(cmd_data->status),
- (void*)resp_buf, NAN_IOCTL_BUF_SIZE);
- if (unlikely(ret) || unlikely(cmd_data->status)) {
- WL_ERR(("nan data path end handler failed, error = %d status %d\n",
- ret, cmd_data->status));
- goto fail;
- }
- WL_INFORM_MEM(("[NAN] DP end successfull (ndp_id:%d)\n",
- dataend->lndp_id));
-
-fail:
- if (nan_buf) {
- MFREE(dhdp->osh, nan_buf, NAN_IOCTL_BUF_SIZE);
- }
-
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-#ifdef WL_NAN_DISC_CACHE
-int wl_cfgnan_sec_info_handler(struct bcm_cfg80211 *cfg,
- nan_datapath_sec_info_cmd_data_t *cmd_data, nan_hal_resp_t *nan_req_resp)
-{
- s32 ret = BCME_OK;
- /* check in cache */
- nan_disc_result_cache *disc_cache = NULL;
- nan_svc_info_t *svc_info = NULL;
-
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- if (!cfg->nan_init_state) {
- WL_ERR(("nan is not initialized/nmi doesnt exists\n"));
- ret = BCME_OK;
- goto fail;
- }
-
- if (cmd_data->pub_id && !ETHER_ISNULLADDR(&cmd_data->mac_addr)) {
- disc_cache = wl_cfgnan_get_disc_result(cfg,
- cmd_data->pub_id, &cmd_data->mac_addr);
- if (disc_cache) {
- WL_TRACE(("svc hash present, pack it\n"));
- memcpy(nan_req_resp->svc_hash, disc_cache->svc_hash, WL_NAN_SVC_HASH_LEN);
- }
- } if (cmd_data->ndp_instance_id) {
- svc_info = wl_cfgnan_get_svc_inst(cfg, 0, cmd_data->ndp_instance_id);
- if (svc_info) {
- WL_TRACE(("svc hash present, pack it\n"));
- memcpy(nan_req_resp->svc_hash, svc_info->svc_hash, WL_NAN_SVC_HASH_LEN);
- }
- /* Always send NMI */
- memcpy(nan_req_resp->pub_nmi, cfg->nan_nmi_mac, ETH_ALEN);
- }
-fail:
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-static s32 wl_nan_cache_to_event_data(nan_disc_result_cache *cache,
- nan_event_data_t *nan_event_data, osl_t *osh)
-{
- s32 ret = BCME_OK;
- NAN_DBG_ENTER();
-
- nan_event_data->pub_id = cache->pub_id;
- nan_event_data->sub_id = cache->sub_id;
- nan_event_data->publish_rssi = cache->publish_rssi;
- nan_event_data->peer_cipher_suite = cache->peer_cipher_suite;
- memcpy(&nan_event_data->remote_nmi, &cache->peer, ETHER_ADDR_LEN);
-
- if (cache->svc_info.dlen && cache->svc_info.data) {
- nan_event_data->svc_info.dlen = cache->svc_info.dlen;
- nan_event_data->svc_info.data =
- MALLOCZ(osh, nan_event_data->svc_info.dlen);
- if (!nan_event_data->svc_info.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- nan_event_data->svc_info.dlen = 0;
- ret = -ENOMEM;
- goto fail;
- }
- memcpy(nan_event_data->svc_info.data,
- cache->svc_info.data, cache->svc_info.dlen);
- }
- if (cache->tx_match_filter.dlen && cache->tx_match_filter.data) {
- nan_event_data->tx_match_filter.dlen = cache->tx_match_filter.dlen;
- nan_event_data->tx_match_filter.data =
- MALLOCZ(osh, nan_event_data->tx_match_filter.dlen);
- if (!nan_event_data->tx_match_filter.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- nan_event_data->tx_match_filter.dlen = 0;
- ret = -ENOMEM;
- goto fail;
- }
- memcpy(nan_event_data->tx_match_filter.data,
- cache->tx_match_filter.data, cache->tx_match_filter.dlen);
- }
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-#endif /* WL_NAN_DISC_CACHE */
-static s32
-wl_nan_dp_cmn_event_data(struct bcm_cfg80211 *cfg, void *event_data,
- uint16 data_len, uint16 *tlvs_offset,
- uint16 *nan_opts_len, uint32 event_num,
- int *hal_event_id, nan_event_data_t *nan_event_data)
-{
- s32 ret = BCME_OK;
- uint8 i;
- wl_nan_ev_datapath_cmn_t *ev_dp;
- nan_svc_info_t *svc_info;
- bcm_xtlv_t *xtlv = (bcm_xtlv_t *)event_data;
- if (xtlv->id == WL_NAN_XTLV_DATA_DP_INFO) {
- ev_dp = (wl_nan_ev_datapath_cmn_t *)xtlv->data;
- NAN_DBG_ENTER();
-
- BCM_REFERENCE(svc_info);
- BCM_REFERENCE(i);
- /* Mapping to common struct between DHD and HAL */
- WL_TRACE(("Event type: %d\n", ev_dp->type));
- nan_event_data->type = ev_dp->type;
- WL_TRACE(("pub_id: %d\n", ev_dp->pub_id));
- nan_event_data->pub_id = ev_dp->pub_id;
- WL_TRACE(("security: %d\n", ev_dp->security));
- nan_event_data->security = ev_dp->security;
-
- /* Store initiator_ndi, required for data_path_response_request */
- memcpy(&cfg->initiator_ndi, &ev_dp->initiator_ndi,
- ETHER_ADDR_LEN);
- if (ev_dp->type == NAN_DP_SESSION_UNICAST) {
- WL_INFORM_MEM(("NDP ID: %d\n", ev_dp->ndp_id));
- nan_event_data->ndp_id = ev_dp->ndp_id;
- WL_TRACE(("INITIATOR_NDI: " MACDBG "\n",
- MAC2STRDBG(ev_dp->initiator_ndi.octet)));
- WL_TRACE(("RESPONDOR_NDI: " MACDBG "\n",
- MAC2STRDBG(ev_dp->responder_ndi.octet)));
- WL_TRACE(("PEER NMI: " MACDBG "\n",
- MAC2STRDBG(ev_dp->peer_nmi.octet)));
- memcpy(&nan_event_data->remote_nmi, &ev_dp->peer_nmi,
- ETHER_ADDR_LEN);
- } else {
- /* type is multicast */
- WL_INFORM_MEM(("NDP ID: %d\n", ev_dp->mc_id));
- nan_event_data->ndp_id = ev_dp->mc_id;
- WL_TRACE(("PEER NMI: " MACDBG "\n",
- MAC2STRDBG(ev_dp->peer_nmi.octet)));
- memcpy(&nan_event_data->remote_nmi, &ev_dp->peer_nmi,
- ETHER_ADDR_LEN);
- }
- *tlvs_offset = OFFSETOF(wl_nan_ev_datapath_cmn_t, opt_tlvs) +
- OFFSETOF(bcm_xtlv_t, data);
- *nan_opts_len = data_len - *tlvs_offset;
- if (event_num == WL_NAN_EVENT_PEER_DATAPATH_IND) {
- *hal_event_id = GOOGLE_NAN_EVENT_DATA_REQUEST;
-#ifdef WL_NAN_DISC_CACHE
- svc_info = wl_cfgnan_get_svc_inst(cfg, nan_event_data->pub_id, 0);
- if (svc_info) {
- for (i = 0; i < NAN_MAX_SVC_INST; i++) {
- if (!svc_info->ndp_id[i]) {
- WL_TRACE(("Found empty field\n"));
- break;
- }
- }
- if (i == NAN_MAX_SVC_INST) {
- WL_ERR(("%s:cannot accommadate ndp id\n", __FUNCTION__));
- ret = BCME_NORESOURCE;
- goto fail;
- }
- svc_info->ndp_id[i] = nan_event_data->ndp_id;
- ret = BCME_OK;
- }
-#endif /* WL_NAN_DISC_CACHE */
- } else if (event_num == WL_NAN_EVENT_DATAPATH_ESTB) {
- *hal_event_id = GOOGLE_NAN_EVENT_DATA_CONFIRMATION;
- if (ev_dp->role == NAN_DP_ROLE_INITIATOR) {
- memcpy(&nan_event_data->responder_ndi, &ev_dp->responder_ndi,
- ETHER_ADDR_LEN);
- WL_TRACE(("REMOTE_NDI: " MACDBG "\n",
- MAC2STRDBG(ev_dp->responder_ndi.octet)));
- WL_TRACE(("Initiator status %d\n", nan_event_data->status));
- } else {
- memcpy(&nan_event_data->responder_ndi, &ev_dp->initiator_ndi,
- ETHER_ADDR_LEN);
- WL_TRACE(("REMOTE_NDI: " MACDBG "\n",
- MAC2STRDBG(ev_dp->initiator_ndi.octet)));
- }
- if (ev_dp->status == NAN_NDP_STATUS_ACCEPT) {
- nan_event_data->status = NAN_DP_REQUEST_ACCEPT;
- } else if (ev_dp->status == NAN_NDP_STATUS_REJECT) {
- nan_event_data->status = NAN_DP_REQUEST_REJECT;
- } else {
- WL_ERR(("%s:Status code = %x not expected\n",
- __FUNCTION__, ev_dp->status));
- ret = BCME_ERROR;
- goto fail;
- }
- WL_TRACE(("Responder status %d\n", nan_event_data->status));
- wl_cfgnan_update_dp_mask(cfg, true, nan_event_data->ndp_id);
- } else if (event_num == WL_NAN_EVENT_DATAPATH_END) {
- /* Mapping to common struct between DHD and HAL */
- *hal_event_id = GOOGLE_NAN_EVENT_DATA_END;
- wl_cfgnan_update_dp_mask(cfg, false, nan_event_data->ndp_id);
-#ifdef WL_NAN_DISC_CACHE
- if (ev_dp->role != NAN_DP_ROLE_INITIATOR) {
- /* Only at Responder side,
- * If dp is ended,
- * clear the resp ndp id from the svc info cache
- */
- svc_info = wl_cfgnan_get_svc_inst(cfg, 0, nan_event_data->ndp_id);
- if (svc_info) {
- for (i = 0; i < NAN_MAX_SVC_INST; i++) {
- if (svc_info->ndp_id[i] == nan_event_data->ndp_id) {
- svc_info->ndp_id[i] = 0;
- }
- }
- } else {
- WL_DBG(("couldn't find entry for ndp id = %d\n",
- nan_event_data->ndp_id));
- }
- }
-#endif /* WL_NAN_DISC_CACHE */
- }
- } else {
- /* Follow though, not handling other IDs as of now */
- WL_DBG(("%s:ID = 0x%02x not supported\n", __FUNCTION__, xtlv->id));
- }
-fail:
- NAN_DBG_EXIT();
- return ret;
-}
-
-static void
-wl_nan_print_status(wl_nan_conf_status_t *nstatus)
-{
- printf("> enabled: %d\n", nstatus->enabled);
- printf("> Current NMI: " MACDBG "\n", MAC2STRDBG(nstatus->nmi.octet));
- printf("> Current cluster_id: " MACDBG "\n", MAC2STRDBG(nstatus->cid.octet));
-
- switch (nstatus->role) {
- case WL_NAN_ROLE_AUTO:
- printf("> role: %s (%d)\n", "auto", nstatus->role);
- break;
- case WL_NAN_ROLE_NON_MASTER_NON_SYNC:
- printf("> role: %s (%d)\n", "non-master-non-sync", nstatus->role);
- break;
- case WL_NAN_ROLE_NON_MASTER_SYNC:
- printf("> role: %s (%d)\n", "non-master-sync", nstatus->role);
- break;
- case WL_NAN_ROLE_MASTER:
- printf("> role: %s (%d)\n", "master", nstatus->role);
- break;
- case WL_NAN_ROLE_ANCHOR_MASTER:
- printf("> role: %s (%d)\n", "anchor-master", nstatus->role);
- break;
- default:
- printf("> role: %s (%d)\n", "undefined", nstatus->role);
- break;
- }
-
- printf("> social channels: %d, %d\n",
- nstatus->social_chans[0], nstatus->social_chans[1]);
- printf("> master_rank: " NMRSTR "\n", NMR2STR(nstatus->mr));
- printf("> amr : " NMRSTR "\n", NMR2STR(nstatus->amr));
- printf("> hop_count: %d\n", nstatus->hop_count);
- printf("> ambtt: %d\n", nstatus->ambtt);
-}
-
-s32
-wl_cfgnan_notify_nan_status(struct bcm_cfg80211 *cfg,
- bcm_struct_cfgdev *cfgdev, const wl_event_msg_t *event, void *event_data)
-{
- uint16 data_len;
- uint32 event_num;
- s32 event_type;
- int hal_event_id = 0;
- nan_event_data_t *nan_event_data = NULL;
- nan_parse_event_ctx_t nan_event_ctx;
- uint16 tlvs_offset = 0;
- uint16 nan_opts_len = 0;
- uint8 *tlv_buf;
- s32 ret = BCME_OK;
- bcm_xtlv_opts_t xtlv_opt = BCM_IOV_CMD_OPT_ALIGN32;
- nan_svc_info_t *svc;
-
- UNUSED_PARAMETER(wl_nan_print_status);
- NAN_DBG_ENTER();
- NAN_MUTEX_LOCK();
-
- if (!cfg->nan_init_state) {
- WL_ERR(("nan is not in initialized state, dropping nan related events\n"));
- ret = BCME_OK;
- goto exit;
- }
- if (!event || !event_data) {
- WL_ERR(("event data is NULL\n"));
- ret = -EINVAL;
- goto exit;
- }
-
- event_type = ntoh32(event->event_type);
- event_num = ntoh32(event->reason);
- data_len = ntoh32(event->datalen);
- nan_event_data = MALLOCZ(cfg->osh, sizeof(*nan_event_data));
- if (!nan_event_data) {
- WL_ERR(("%s: memory allocation failed\n", __func__));
- goto exit;
- }
-
- if (NAN_INVALID_EVENT(event_num)) {
- WL_ERR(("unsupported event, num: %d, event type: %d\n", event_num, event_type));
- ret = -EINVAL;
- goto exit;
- }
- WL_DBG((">> Nan Event Received: %s (num=%d, len=%d)\n",
- nan_event_to_str(event_num), event_num, data_len));
-
-#ifdef WL_NAN_DEBUG
- prhex("nan_event_data:", event_data, data_len);
-#endif /* WL_NAN_DEBUG */
-
- nan_event_ctx.cfg = cfg;
- nan_event_ctx.nan_evt_data = nan_event_data;
- /*
- * send as preformatted hex string
- * EVENT_NAN <event_type> <tlv_hex_string>
- */
- switch (event_num) {
- case WL_NAN_EVENT_START:
- case WL_NAN_EVENT_MERGE:
- case WL_NAN_EVENT_ROLE: {
- /* get nan status info as-is */
- bcm_xtlv_t *xtlv = (bcm_xtlv_t *)event_data;
- wl_nan_conf_status_t *nstatus = (wl_nan_conf_status_t *)xtlv->data;
- WL_INFORM_MEM((">> Nan Mac Event Received: %s (num=%d, len=%d)\n",
- nan_event_to_str(event_num), event_num, data_len));
- WL_INFORM_MEM(("Nan Device Role %s\n", nan_role_to_str(nstatus->role)));
- /* Mapping to common struct between DHD and HAL */
- nan_event_data->enabled = nstatus->enabled;
- memcpy(&nan_event_data->local_nmi, &nstatus->nmi,
- ETHER_ADDR_LEN);
- memcpy(&nan_event_data->clus_id, &nstatus->cid,
- ETHER_ADDR_LEN);
- nan_event_data->nan_de_evt_type = event_num;
-#ifdef WL_NAN_DEBUG
- wl_nan_print_status(nstatus);
-#endif /* WL_NAN_DEBUG */
- if (event_num == WL_NAN_EVENT_START) {
- cfg->nan_enable = true;
- OSL_SMP_WMB();
- cfg->nancfg.nan_event_recvd = true;
- OSL_SMP_WMB();
- wake_up(&cfg->nancfg.nan_event_wait);
- }
- hal_event_id = GOOGLE_NAN_EVENT_DE_EVENT;
- break;
- }
-
- case WL_NAN_EVENT_STOP: {
- WL_INFORM_MEM((">> Nan Mac Stop Event Received\n"));
- hal_event_id = GOOGLE_NAN_EVENT_DISABLED;
- nan_event_data->status = NAN_STATUS_SUCCESS;
- OSL_SMP_WMB();
- cfg->nancfg.nan_event_recvd = true;
- OSL_SMP_WMB();
- wake_up(&cfg->nancfg.nan_event_wait);
- cfg->nancfg.inst_id_start = 0;
- memset(cfg->nancfg.svc_inst_id_mask, 0, sizeof(cfg->nancfg.svc_inst_id_mask));
- memset(cfg->svc_info, 0, NAN_MAX_SVC_INST * sizeof(nan_svc_info_t));
- if (cfg->nancfg.disable_pending) {
- /* do not event to host if command is from host */
- cfg->nancfg.disable_pending = FALSE;
- goto exit;
- }
- break;
- }
- case WL_NAN_EVENT_TERMINATED: {
- bcm_xtlv_t *xtlv = (bcm_xtlv_t *)event_data;
- wl_nan_ev_terminated_t *pev = (wl_nan_ev_terminated_t *)xtlv->data;
-
- /* Mapping to common struct between DHD and HAL */
- WL_TRACE(("Instance ID: %d\n", pev->instance_id));
- nan_event_data->local_inst_id = pev->instance_id;
- WL_TRACE(("Service Type: %d\n", pev->svctype));
-
-#ifdef WL_NAN_DISC_CACHE
- if (pev->svctype == NAN_SC_SUBSCRIBE) {
- wl_cfgnan_remove_disc_result(cfg, pev->instance_id);
- }
-#endif /* WL_NAN_DISC_CACHE */
- /* Mapping reason code of FW to status code of framework */
- if (pev->reason == NAN_TERM_REASON_TIMEOUT ||
- pev->reason == NAN_TERM_REASON_USER_REQ ||
- pev->reason == NAN_TERM_REASON_COUNT_REACHED) {
- nan_event_data->status = NAN_STATUS_SUCCESS;
- memcpy(nan_event_data->nan_reason, "NAN_STATUS_SUCCESS",
- strlen("NAN_STATUS_SUCCESS"));
- } else {
- nan_event_data->status = NAN_STATUS_INTERNAL_FAILURE;
- memcpy(nan_event_data->nan_reason, "NAN_STATUS_INTERNAL_FAILURE",
- strlen("NAN_STATUS_INTERNAL_FAILURE"));
- }
-
- if (pev->svctype == NAN_SC_SUBSCRIBE) {
- hal_event_id = GOOGLE_NAN_EVENT_SUBSCRIBE_TERMINATED;
- } else {
- hal_event_id = GOOGLE_NAN_EVENT_PUBLISH_TERMINATED;
- }
-#ifdef WL_NAN_DISC_CACHE
- /* terminate ranging sessions */
- wl_cfgnan_terminate_ranging_sessions(bcmcfg_to_prmry_ndev(cfg),
- cfg, pev->instance_id);
-#endif /* WL_NAN_DISC_CACHE */
- break;
- }
-
- case WL_NAN_EVENT_RECEIVE: {
- nan_opts_len = data_len;
- hal_event_id = GOOGLE_NAN_EVENT_FOLLOWUP;
- xtlv_opt = BCM_IOV_CMD_OPT_ALIGN_NONE;
- break;
- }
-
- case WL_NAN_EVENT_TXS: {
- bcm_xtlv_t *xtlv = (bcm_xtlv_t *)event_data;
- wl_nan_event_txs_t *txs = (wl_nan_event_txs_t *)xtlv->data;
- wl_nan_event_sd_txs_t *txs_sd = NULL;
- if (txs->status == WL_NAN_TXS_SUCCESS) {
- WL_MEM(("TXS success for type %d token %d",
- txs->type, txs->host_seq));
- nan_event_data->status = NAN_STATUS_SUCCESS;
- memcpy(nan_event_data->nan_reason, "NAN_STATUS_SUCCESS",
- strlen("NAN_STATUS_SUCCESS"));
- } else {
- /* TODO : populate status based on reason codes
- For now adding it as no ACK, so that app/framework can retry
- */
- WL_INFORM_MEM(("TXS failed for type %d status %d token %d",
- txs->type, txs->status, txs->host_seq));
- nan_event_data->status = NAN_STATUS_NO_OTA_ACK;
- memcpy(nan_event_data->nan_reason, "NAN_STATUS_NO_OTA_ACK",
- strlen("NAN_STATUS_NO_OTA_ACK"));
- }
- nan_event_data->reason = txs->reason_code;
- nan_event_data->token = txs->host_seq;
- if (txs->type == WL_NAN_FRM_TYPE_FOLLOWUP) {
- hal_event_id = GOOGLE_NAN_EVENT_TRANSMIT_FOLLOWUP_IND;
- xtlv = (bcm_xtlv_t *)(txs->opt_tlvs);
- if (txs->opt_tlvs_len && xtlv->id == WL_NAN_XTLV_SD_TXS) {
- txs_sd = (wl_nan_event_sd_txs_t*)xtlv->data;
- nan_event_data->local_inst_id = txs_sd->inst_id;
- } else {
- WL_ERR(("Invalid params in TX status for trasnmit followup"));
- ret = -EINVAL;
- goto exit;
- }
- } else { /* TODO: add for other frame types if required */
- ret = -EINVAL;
- goto exit;
- }
- break;
- }
-
- case WL_NAN_EVENT_DISCOVERY_RESULT: {
- nan_opts_len = data_len;
- hal_event_id = GOOGLE_NAN_EVENT_SUBSCRIBE_MATCH;
- xtlv_opt = BCM_IOV_CMD_OPT_ALIGN_NONE;
- break;
- }
-#ifdef WL_NAN_DISC_CACHE
- case WL_NAN_EVENT_RNG_RPT_IND: {
- bcm_xtlv_t *xtlv = (bcm_xtlv_t *)event_data;
- wl_nan_ev_rng_rpt_ind_t *range_res = (wl_nan_ev_rng_rpt_ind_t *)xtlv->data;
- nan_disc_result_cache *cache;
- nan_event_data->ranging_result_present = 1;
- nan_event_data->range_measurement_cm = range_res->dist_mm/10;
- memcpy(&nan_event_data->remote_nmi, &range_res->peer_m_addr, ETHER_ADDR_LEN);
- nan_event_data->ranging_ind = range_res->indication;
- WL_TRACE(("ranging ind = %d\n", range_res->indication));
- /* check in cache */
- cache = wl_cfgnan_get_disc_result(cfg,
- 0, &range_res->peer_m_addr);
- if (!cache) {
- ret = BCME_ERROR;
- WL_ERR(("Disc Cache entry not present for peer: " MACDBG "\n",
- MAC2STRDBG(range_res->peer_m_addr.octet)));
- goto exit;
- }
- WL_TRACE(("Disc cache entry, populate it\n"));
- ret = wl_nan_cache_to_event_data(cache,
- nan_event_data, cfg->osh);
- if (ret != BCME_OK) {
- goto exit;
- }
- break;
- }
- case WL_NAN_EVENT_RNG_REQ_IND: {
- wl_nan_ev_rng_req_ind_t *rng_ind;
- bcm_xtlv_t *xtlv = (bcm_xtlv_t *)event_data;
-
- nan_opts_len = data_len;
- rng_ind = (wl_nan_ev_rng_req_ind_t *)xtlv->data;
- xtlv_opt = BCM_IOV_CMD_OPT_ALIGN_NONE;
- WL_TRACE(("Received WL_NAN_EVENT_RNG_REQ_IND range_id %d\n",
- rng_ind->rng_id));
- ret = wl_cfgnan_handle_ranging_ind(cfg, rng_ind);
- /* no need to event to HAL */
- goto exit;
- }
-
- case WL_NAN_EVENT_RNG_TERM_IND: {
- bcm_xtlv_t *xtlv = (bcm_xtlv_t *)event_data;
- nan_ranging_inst_t *rng_inst;
- wl_nan_ev_rng_term_ind_t *range_term = (wl_nan_ev_rng_term_ind_t *)xtlv->data;
- WL_TRACE(("Peer_NMI: " MACDBG "\n",
- MAC2STRDBG(range_term->peer_m_addr.octet)));
- WL_TRACE(("Reason code:%d\n", range_term->reason_code));
- WL_TRACE(("Received WL_NAN_EVENT_RNG_TERM_IND\n"));
- rng_inst = wl_cfgnan_check_for_ranging(cfg, &range_term->peer_m_addr);
- if (rng_inst) {
- /* clear ranging instance */
- WL_TRACE(("reset the ranging instance"));
- memset(rng_inst, 0, sizeof(*rng_inst));
- }
- break;
- }
-#endif /* WL_NAN_DISC_CACHE */
- /*
- * Data path events data are received in common event struct,
- * Handling all the events as part of one case, hence fall through is intentional
- */
- case WL_NAN_EVENT_PEER_DATAPATH_IND:
- case WL_NAN_EVENT_DATAPATH_ESTB:
- case WL_NAN_EVENT_DATAPATH_END: {
- ret = wl_nan_dp_cmn_event_data(cfg, event_data, data_len,
- &tlvs_offset, &nan_opts_len,
- event_num, &hal_event_id, nan_event_data);
- /* Avoiding optional param parsing for DP END Event */
- if (event_num == WL_NAN_EVENT_DATAPATH_END) {
- nan_opts_len = 0;
- xtlv_opt = BCM_IOV_CMD_OPT_ALIGN_NONE;
- }
- if (unlikely(ret)) {
- WL_ERR(("nan dp common event data parse failed\n"));
- goto exit;
- }
- break;
- }
- default:
- WL_ERR(("WARNING: unimplemented NAN APP EVENT = %d\n", event_num));
- ret = BCME_ERROR;
- goto exit;
- }
-
- if (nan_opts_len) {
- tlv_buf = (uint8 *)event_data + tlvs_offset;
- /* Extract event data tlvs and pass their resp to cb fn */
- ret = bcm_unpack_xtlv_buf((void *)&nan_event_ctx, (const uint8*)tlv_buf,
- nan_opts_len, xtlv_opt, wl_cfgnan_set_vars_cbfn);
- if (ret != BCME_OK) {
- WL_ERR(("Failed to unpack tlv data, ret=%d\n", ret));
- }
- }
-
-#ifdef WL_NAN_DISC_CACHE
- if (hal_event_id == GOOGLE_NAN_EVENT_SUBSCRIBE_MATCH) {
- WL_TRACE(("Cache disc res\n"));
- wl_cfgnan_cache_disc_result(cfg, nan_event_data);
- if (nan_event_data->sde_control_flag & NAN_SDE_CF_RANGING_REQUIRED) {
- ret = wl_cfgnan_check_disc_res_for_ranging(cfg, nan_event_data);
- if (ret == BCME_OK) {
- /* disc result to HAL will be given on ranging report */
- goto exit;
- } else {
- /* TODO: should we terminate service if ranging fails ? */
- WL_ERR(("Ranging failed or not required"));
- }
- } else {
- WL_TRACE(("Ranging not required\n"));
- }
- /*
- * If tx match filter is present as part of active subscribe, keep same filter
- * values in discovery results also.
- */
- if (nan_event_data->sub_id == nan_event_data->requestor_id) {
- svc = wl_cfgnan_get_svc_inst(cfg, nan_event_data->sub_id, 0);
- if (svc && svc->tx_match_filter_len) {
- nan_event_data->tx_match_filter.dlen = svc->tx_match_filter_len;
- nan_event_data->tx_match_filter.data =
- MALLOCZ(cfg->osh, svc->tx_match_filter_len);
- if (!nan_event_data->tx_match_filter.data) {
- WL_ERR(("%s: tx_match_filter_data alloc failed\n",
- __FUNCTION__));
- nan_event_data->tx_match_filter.dlen = 0;
- ret = -ENOMEM;
- goto exit;
- }
- memcpy(nan_event_data->tx_match_filter.data,
- svc->tx_match_filter, svc->tx_match_filter_len);
- }
- }
- }
-#endif /* WL_NAN_DISC_CACHE */
-
- /* Send up range result as subscribe match event */
- if (event_num == WL_NAN_EVENT_RNG_RPT_IND) {
- WL_TRACE(("Send up range result as subscribe match event\n"));
- hal_event_id = GOOGLE_NAN_EVENT_SUBSCRIBE_MATCH;
- }
-
- WL_TRACE(("Send up %s (%d) data to HAL, hal_event_id=%d\n",
- nan_event_to_str(event_num), event_num, hal_event_id));
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT)
- ret = wl_cfgvendor_send_nan_event(cfg->wdev->wiphy, bcmcfg_to_prmry_ndev(cfg),
- hal_event_id, nan_event_data);
- if (ret != BCME_OK) {
- WL_ERR(("Failed to send event to nan hal, %s (%d)\n",
- nan_event_to_str(event_num), event_num));
- }
-#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT) */
-
-exit:
- if (nan_event_data) {
- if (nan_event_data->tx_match_filter.data) {
- MFREE(cfg->osh, nan_event_data->tx_match_filter.data,
- nan_event_data->tx_match_filter.dlen);
- nan_event_data->tx_match_filter.data = NULL;
- }
- if (nan_event_data->rx_match_filter.data) {
- MFREE(cfg->osh, nan_event_data->rx_match_filter.data,
- nan_event_data->rx_match_filter.dlen);
- nan_event_data->rx_match_filter.data = NULL;
- }
- if (nan_event_data->svc_info.data) {
- MFREE(cfg->osh, nan_event_data->svc_info.data,
- nan_event_data->svc_info.dlen);
- nan_event_data->svc_info.data = NULL;
- }
- if (nan_event_data->sde_svc_info.data) {
- MFREE(cfg->osh, nan_event_data->sde_svc_info.data,
- nan_event_data->sde_svc_info.dlen);
- nan_event_data->sde_svc_info.data = NULL;
- }
- MFREE(cfg->osh, nan_event_data, sizeof(*nan_event_data));
- }
-
- NAN_MUTEX_UNLOCK();
- NAN_DBG_EXIT();
- return ret;
-}
-
-#ifdef WL_NAN_DISC_CACHE
-static int
-wl_cfgnan_cache_disc_result(struct bcm_cfg80211 *cfg, void * data)
-{
- nan_event_data_t* disc = (nan_event_data_t*)data;
- int i, add_index = 0;
- int ret = BCME_OK;
- nan_disc_result_cache *disc_res = cfg->nan_disc_cache;
-
- if (!cfg->nan_enable) {
- WL_DBG(("nan not enabled"));
- return BCME_NOTENABLED;
- }
- if (cfg->nan_disc_count == NAN_MAX_CACHE_DISC_RESULT) {
- WL_DBG(("cache full"));
- ret = BCME_NORESOURCE;
- goto done;
- }
-
- for (i = 0; i < NAN_MAX_CACHE_DISC_RESULT; i++) {
- if (!disc_res[i].valid) {
- add_index = i;
- continue;
- }
- if (!memcmp(&disc_res[i].peer, &disc->remote_nmi, ETHER_ADDR_LEN) &&
- !memcmp(disc_res[i].svc_hash, disc->svc_name, WL_NAN_SVC_HASH_LEN)) {
- WL_TRACE(("cache entry already present"));
- ret = BCME_OK; /* entry already present */
- goto done;
- }
- }
- WL_TRACE(("adding cache entry"));
- disc_res[add_index].valid = 1;
- disc_res[add_index].pub_id = disc->pub_id;
- disc_res[add_index].sub_id = disc->sub_id;
- disc_res[add_index].publish_rssi = disc->publish_rssi;
- disc_res[add_index].peer_cipher_suite = disc->peer_cipher_suite;
- memcpy(&disc_res[add_index].peer, &disc->remote_nmi, ETHER_ADDR_LEN);
- memcpy(disc_res[add_index].svc_hash, disc->svc_name, WL_NAN_SVC_HASH_LEN);
-
- if (disc->svc_info.dlen && disc->svc_info.data) {
- disc_res[add_index].svc_info.dlen = disc->svc_info.dlen;
- disc_res[add_index].svc_info.data =
- MALLOCZ(cfg->osh, disc_res[add_index].svc_info.dlen);
- if (!disc_res[add_index].svc_info.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- disc_res[add_index].svc_info.dlen = 0;
- ret = -ENOMEM;
- goto done;
- }
- memcpy(disc_res[add_index].svc_info.data,
- disc->svc_info.data, disc->svc_info.dlen);
- }
- if (disc->tx_match_filter.dlen && disc->tx_match_filter.data) {
- disc_res[add_index].tx_match_filter.dlen = disc->tx_match_filter.dlen;
- disc_res[add_index].tx_match_filter.data =
- MALLOCZ(cfg->osh, disc_res[add_index].tx_match_filter.dlen);
- if (!disc_res[add_index].tx_match_filter.data) {
- WL_ERR(("%s: memory allocation failed\n", __FUNCTION__));
- disc_res[add_index].tx_match_filter.dlen = 0;
- ret = -ENOMEM;
- goto done;
- }
- memcpy(disc_res[add_index].tx_match_filter.data,
- disc->tx_match_filter.data, disc->tx_match_filter.dlen);
- }
- cfg->nan_disc_count++;
-
-done:
- return ret;
-}
-
-static int wl_cfgnan_remove_disc_result(struct bcm_cfg80211 *cfg,
- uint8 local_subid)
-{
- int i;
- int ret = BCME_NOTFOUND;
- nan_disc_result_cache *disc_res = cfg->nan_disc_cache;
- if (!cfg->nan_enable) {
- WL_DBG(("nan not enabled\n"));
- ret = BCME_NOTENABLED;
- goto done;
- }
- for (i = 0; i < NAN_MAX_CACHE_DISC_RESULT; i++) {
- if (disc_res[i].sub_id == local_subid) {
- WL_TRACE(("make cache entry invalid\n"));
- disc_res[i].valid = 0;
- cfg->nan_disc_count--;
- ret = BCME_OK;
- }
- }
- WL_DBG(("couldn't find entry\n"));
-done:
- return ret;
-}
-
-static nan_disc_result_cache *
-wl_cfgnan_get_disc_result(struct bcm_cfg80211 *cfg, uint8 remote_pubid,
- struct ether_addr *peer)
-{
- int i;
- nan_disc_result_cache *disc_res = cfg->nan_disc_cache;
- if (remote_pubid) {
- for (i = 0; i < NAN_MAX_CACHE_DISC_RESULT; i++) {
- if ((disc_res[i].pub_id == remote_pubid) &&
- !memcmp(&disc_res[i].peer, peer, ETHER_ADDR_LEN)) {
- WL_TRACE(("Found entry"));
- return &disc_res[i];
- }
- }
- } else {
- for (i = 0; i < NAN_MAX_CACHE_DISC_RESULT; i++) {
- if (!memcmp(&disc_res[i].peer, peer, ETHER_ADDR_LEN)) {
- WL_TRACE(("Found entry"));
- return &disc_res[i];
- }
- }
- }
- return NULL;
-}
-#endif /* WL_NAN_DISC_CACHE */
-
-static void
-wl_cfgnan_update_dp_mask(struct bcm_cfg80211 *cfg, bool enable, u8 nan_dp_id)
-{
-#ifdef ARP_OFFLOAD_SUPPORT
- dhd_pub_t *dhd = (struct dhd_pub *)(cfg->pub);
-#endif /* ARP_OFFLOAD_SUPPORT */
- /* As of now, we don't see a need to know which ndp is active.
- * so just keep tracking of ndp via count. If we need to know
- * the status of each ndp based on ndp id, we need to change
- * this implementation to use a bit mask.
- */
- if (!dhd) {
- WL_ERR(("dhd pub null!\n"));
- return;
- }
-
- if (enable) {
- /* On first NAN DP indication, disable ARP. */
-#ifdef ARP_OFFLOAD_SUPPORT
- if (!cfg->nan_dp_mask) {
- dhd_arp_offload_set(dhd, 0);
- dhd_arp_offload_enable(dhd, false);
- }
-#endif /* ARP_OFFLOAD_SUPPORT */
- cfg->nan_dp_mask |= (0x1 << nan_dp_id);
- } else {
- cfg->nan_dp_mask &= ~(0x1 << nan_dp_id);
-#ifdef ARP_OFFLOAD_SUPPORT
- if (!cfg->nan_dp_mask) {
- /* If NAN DP count becomes zero and if there
- * are no conflicts, enable back ARP offload.
- * As of now, the conflicting interfaces are AP
- * and P2P. But NAN + P2P/AP concurrency is not
- * supported.
- */
- dhd_arp_offload_set(dhd, dhd_arp_mode);
- dhd_arp_offload_enable(dhd, true);
- }
-#endif /* ARP_OFFLOAD_SUPPORT */
- }
- WL_INFORM_MEM(("NAN_DP_MASK:0x%x\n", cfg->nan_dp_mask));
-}
-
-bool
-wl_cfgnan_is_dp_active(struct net_device *ndev)
-{
- struct bcm_cfg80211 *cfg;
- bool nan_dp;
-
- if (!ndev || !ndev->ieee80211_ptr) {
- WL_ERR(("ndev/wdev null\n"));
- return false;
- }
-
- cfg = wiphy_priv(ndev->ieee80211_ptr->wiphy);
- nan_dp = cfg->nan_dp_mask ? true : false;
-
- WL_DBG(("NAN DP status:%d\n", nan_dp));
- return nan_dp;
-}
-
-s32
-wl_cfgnan_get_ndi_idx(struct bcm_cfg80211 *cfg)
-{
- int i;
- for (i = 0; i < NAN_MAX_NDI; i++) {
- if (!cfg->nancfg.ndi[i].in_use) {
- /* Free interface, use it */
- return i;
- }
- }
- /* Don't have a free interface */
- return WL_INVALID;
-}
-
-s32
-wl_cfgnan_add_ndi_data(struct bcm_cfg80211 *cfg, s32 idx, char *name)
-{
- u16 len;
- if (!name || (idx < 0) || (idx >= NAN_MAX_NDI)) {
- return -EINVAL;
- }
-
- /* Ensure ifname string size <= IFNAMSIZ including null termination */
- len = MIN(strlen(name), (IFNAMSIZ - 1));
- strncpy(cfg->nancfg.ndi[idx].ifname, name, len);
- cfg->nancfg.ndi[idx].ifname[len] = '\0';
- cfg->nancfg.ndi[idx].in_use = true;
- cfg->nancfg.ndi[idx].created = false;
-
- /* Don't have a free interface */
- return WL_INVALID;
-}
-
-s32
-wl_cfgnan_del_ndi_data(struct bcm_cfg80211 *cfg, char *name)
-{
- u16 len;
- int i;
- if (!name) {
- return -EINVAL;
- }
-
- len = MIN(strlen(name), IFNAMSIZ);
- for (i = 0; i < NAN_MAX_NDI; i++) {
- if (strncmp(cfg->nancfg.ndi[i].ifname, name, len) == 0) {
- memset(&cfg->nancfg.ndi[i].ifname, 0x0, IFNAMSIZ);
- cfg->nancfg.ndi[i].in_use = false;
- cfg->nancfg.ndi[i].created = false;
- return i;
- }
- }
- return -EINVAL;
-}
-
-struct wl_ndi_data *
-wl_cfgnan_get_ndi_data(struct bcm_cfg80211 *cfg, char *name)
-{
- u16 len;
- int i;
- if (!name) {
- return NULL;
- }
-
- len = MIN(strlen(name), IFNAMSIZ);
- for (i = 0; i < NAN_MAX_NDI; i++) {
- if (strncmp(cfg->nancfg.ndi[i].ifname, name, len) == 0) {
- return &cfg->nancfg.ndi[i];
- }
- }
- return NULL;
-}
-#endif /* WL_NAN */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgnan.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgnan.h
deleted file mode 100644
index c5d3f7a..0000000
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgnan.h
+++ /dev/null
@@ -1,775 +0,0 @@
-/*
- * Neighbor Awareness Networking
- *
- * Copyright (C) 1999-2020, Broadcom.
- *
- * Unless you and Broadcom execute a separate written software license
- * agreement governing use of this software, this software is licensed to you
- * under the terms of the GNU General Public License version 2 (the "GPL"),
- * available at http://www.broadcom.com/licenses/GPLv2.php, with the
- * following added to such license:
- *
- * As a special exception, the copyright holders of this software give you
- * permission to link this software with independent modules, and to copy and
- * distribute the resulting executable under terms of your choice, provided that
- * you also meet, for each linked independent module, the terms and conditions of
- * the license of that module. An independent module is a module which is not
- * derived from this software. The special exception does not apply to any
- * modifications of the software.
- *
- * Notwithstanding the above, under no circumstances may you combine this
- * software in any way with any other Broadcom software provided under a license
- * other than the GPL, without Broadcom's express prior written consent.
- *
- * <<Broadcom-WL-IPTag/Open:>>
- *
- * $Id: wl_cfgnan.h 702817 2017-06-05 05:52:17Z $
- */
-
-#ifndef _wl_cfgnan_h_
-#define _wl_cfgnan_h_
-
-/* NAN structs versioning b/w DHD and HAL
-* define new version if any change in any of the shared structs
-*/
-#define NAN_HAL_VERSION_1 0x1
-
-#define NAN_EVENT_BUFFER_SIZE_LARGE 1024u
-
-#define WL_NAN_IOV_BATCH_VERSION 0x8000
-#define WL_NAN_AVAIL_REPEAT_INTVL 0x0200
-#define WL_NAN_AVAIL_START_INTVL 160
-#define WL_NAN_AVAIL_DURATION_INTVL 336
-#define NAN_IOCTL_BUF_SIZE 256u
-#define NAN_IOCTL_BUF_SIZE_MED 512u
-#define NAN_IOCTL_BUF_SIZE_LARGE 1024u
-#define NAN_EVENT_NAME_MAX_LEN 40u
-#define NAN_RTT_IOVAR_BUF_SIZE 1024u
-#define WL_NAN_EVENT_CLEAR_BIT 32
-#define NAN_EVENT_MASK_ALL 0x7fffffff
-#define NAN_MAX_AWAKE_DW_INTERVAL 5
-#define NAN_MAXIMUM_ID_NUMBER 255
-#define NAN_MAXIMUM_MASTER_PREFERENCE 254
-#define NAN_ID_MIN 0
-#define NAN_ID_MAX 255
-#define NAN_DEF_SOCIAL_CHAN_2G 6
-#define NAN_DEF_SOCIAL_CHAN_5G 149
-#define NAN_MAX_SOCIAL_CHANNELS 3
-/* Keeping RSSI threshold value to be -70dBm */
-#define NAN_DEF_RSSI_NOTIF_THRESH -70
-/* Keeping default RSSI mid value to be -70dBm */
-#define NAN_DEF_RSSI_MID -75
-/* Keeping default RSSI close value to be -60dBm */
-#define NAN_DEF_RSSI_CLOSE -60
-#define WL_AVAIL_BIT_MAP "1111111111111111111111111111111100000000000000000000000000000000"
-#define WL_5G_AVAIL_BIT_MAP "0000000011111111111111111111111111111111000000000000000000000000"
-#define WL_AVAIL_CHANNEL_2G 6
-#define WL_AVAIL_BANDWIDTH_2G WL_CHANSPEC_BW_20
-#define WL_AVAIL_CHANNEL_5G 149
-#define WL_AVAIL_BANDWIDTH_5G WL_CHANSPEC_BW_80
-#define NAN_RANGING_PERIOD WL_AVAIL_PERIOD_1024
-#define NAN_SYNC_DEF_AWAKE_DW 1
-
-#define NAN_BLOOM_LENGTH_DEFAULT 240u
-#define NAN_SRF_MAX_MAC (NAN_BLOOM_LENGTH_DEFAULT / ETHER_ADDR_LEN)
-#define NAN_SRF_CTRL_FIELD_LEN 1u
-
-#define MAX_IF_ADD_WAIT_TIME 1000
-#define NAN_DP_ROLE_INITIATOR 0x0001
-#define NAN_DP_ROLE_RESPONDER 0x0002
-
-#define WL_NAN_OBUF_DATA_OFFSET (OFFSETOF(bcm_iov_batch_buf_t, cmds[0]) + \
- OFFSETOF(bcm_iov_batch_subcmd_t, data[0]))
-#define NAN_INVALID_ROLE(role) (role > WL_NAN_ROLE_ANCHOR_MASTER)
-#define NAN_INVALID_CHANSPEC(chanspec) ((chanspec == INVCHANSPEC) || \
- (chanspec == 0))
-#define NAN_INVALID_EVENT(num) ((num < WL_NAN_EVENT_START) || \
- (num >= WL_NAN_EVENT_INVALID))
-#define NAN_INVALID_PROXD_EVENT(num) (num != WLC_E_PROXD_NAN_EVENT)
-#define NAN_EVENT_BIT(event) (1U << (event - WL_NAN_EVENT_START))
-#define NAME_TO_STR(name) #name
-#define NAN_ID_CTRL_SIZE ((NAN_MAXIMUM_ID_NUMBER/8) + 1)
-
-#define tolower(c) bcm_tolower(c)
-
-#define NMR2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5], (a)[6], (a)[7]
-#define NMRSTR "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x"
-
-#define NAN_DBG_ENTER() {WL_DBG(("Enter: %s\n", __FUNCTION__));}
-#define NAN_DBG_EXIT() {WL_DBG(("Exit: %s\n", __FUNCTION__));}
-
-/* Service Control Type length */
-#define NAN_SVC_CONTROL_TYPE_MASK ((1 << NAN_SVC_CONTROL_TYPE_LEN) - 1)
-
-#ifndef strtoul
-#define strtoul(nptr, endptr, base) bcm_strtoul((nptr), (endptr), (base))
-#endif // endif
-
-#define NAN_MAC_ADDR_LEN 6u
-#define NAN_DP_MAX_APP_INFO_LEN 512u
-
-#define NAN_SDE_CF_DP_REQUIRED (1 << 2)
-#define NAN_SDE_CF_DP_TYPE (1 << 3)
-#define NAN_SDE_CF_MULTICAST_TYPE (1 << 4)
-#define NAN_SDE_CF_SECURITY_REQUIRED (1 << 6)
-#define NAN_SDE_CF_RANGING_REQUIRED (1 << 7)
-#define NAN_SDE_CF_RANGE_PRESENT (1 << 8)
-
-#define CHECK_BIT(m, n) ((m >> n) & 1)? 1 : 0
-#define WL_NAN_EVENT_DIC_MAC_ADDR_BIT 0
-#define WL_NAN_EVENT_START_EVENT 1
-#define WL_NAN_EVENT_JOIN_EVENT 2
-
-/* Disabling svc specific(as per part of sub & pub calls) events based on below bits */
-#define WL_NAN_EVENT_SUPPRESS_TERMINATE_BIT 0
-#define WL_NAN_EVENT_SUPPRESS_MATCH_EXP_BIT 1
-#define WL_NAN_EVENT_SUPPRESS_RECEIVE_BIT 2
-#define WL_NAN_EVENT_SUPPRESS_REPLIED_BIT 3
-
-/* Disabling tranmsit followup events based on below bit */
-#define WL_NAN_EVENT_SUPPRESS_FOLLOWUP_RECEIVE_BIT 0
-
-#define C2S(x) case x: return #x;
-#define NAN_BLOOM_LENGTH_DEFAULT 240u
-#define NAN_SRF_MAX_MAC (NAN_BLOOM_LENGTH_DEFAULT / ETHER_ADDR_LEN)
-#define NAN_MAX_PMK_LEN 32u
-#define NAN_ERROR_STR_LEN 255u
-
-/* NAN related Capabilities */
-#define MAX_CONCURRENT_NAN_CLUSTERS 1
-#define MAX_PUBLISHES 8u
-#define MAX_SUBSCRIBES 8u
-#define MAX_SVC_NAME_LEN 255u
-#define MAX_MATCH_FILTER_LEN 255u
-#define MAX_TOTAL_MATCH_FILTER_LEN 510u
-#define NAN_MAX_SERVICE_SPECIFIC_INFO_LEN 255u
-#define MAX_NDI_INTERFACES 1
-#define MAX_NDP_SESSIONS 5
-#define MAX_APP_INFO_LEN 255u
-#define MAX_QUEUED_TX_FOLLOUP_MSGS 10
-#define MAX_SDEA_SVC_INFO_LEN 255u
-#define MAX_SUBSCRIBE_ADDRESS 10
-#define CIPHER_SUITE_SUPPORTED 1
-#define MAX_SCID_LEN 0
-#define IS_NDP_SECURITY_SUPPORTED true
-#define NDP_SUPPORTED_BANDS 2
-
-#define NAN_MAX_RANGING_INST 8u
-#define NAN_MAX_SVC_INST (MAX_PUBLISHES + MAX_SUBSCRIBES)
-#define NAN_SVC_INST_SIZE 32u
-#define NAN_START_STOP_TIMEOUT 5000
-
-#ifdef WL_NAN_DEBUG
-#define NAN_MUTEX_LOCK() {WL_DBG(("Mutex Lock: Enter: %s\n", __FUNCTION__)); \
- mutex_lock(&cfg->nancfg.nan_sync);}
-#define NAN_MUTEX_UNLOCK() {mutex_unlock(&cfg->nancfg.nan_sync); \
- WL_DBG(("Mutex Unlock: Exit: %s\n", __FUNCTION__));}
-#else
-#define NAN_MUTEX_LOCK() {mutex_lock(&cfg->nancfg.nan_sync);}
-#define NAN_MUTEX_UNLOCK() {mutex_unlock(&cfg->nancfg.nan_sync);}
-#endif /* WL_NAN_DEBUG */
-#define NAN_ATTR_SUPPORT_2G_CONFIG (1<<0)
-#define NAN_ATTR_SYNC_DISC_2G_BEACON_CONFIG (1<<1)
-#define NAN_ATTR_SDF_2G_SUPPORT_CONFIG (1<<2)
-#define NAN_ATTR_SUPPORT_5G_CONFIG (1<<3)
-#define NAN_ATTR_SYNC_DISC_5G_BEACON_CONFIG (1<<4)
-#define NAN_ATTR_SDF_5G_SUPPORT_CONFIG (1<<5)
-#define NAN_ATTR_2G_DW_CONFIG (1<<6)
-#define NAN_ATTR_5G_DW_CONFIG (1<<7)
-#define NAN_ATTR_2G_CHAN_CONFIG (1<<8)
-#define NAN_ATTR_5G_CHAN_CONFIG (1<<9)
-#define NAN_ATTR_2G_DWELL_TIME_CONFIG (1<<10)
-#define NAN_ATTR_5G_DWELL_TIME_CONFIG (1<<11)
-#define NAN_ATTR_2G_SCAN_PERIOD_CONFIG (1<<12)
-#define NAN_ATTR_5G_SCAN_PERIOD_CONFIG (1<<13)
-#define NAN_ATTR_RSSI_CLOSE_CONFIG (1<<14)
-#define NAN_ATTR_RSSI_MIDDLE_2G_CONFIG (1<<15)
-#define NAN_ATTR_RSSI_PROXIMITY_2G_CONFIG (1<<16)
-#define NAN_ATTR_RSSI_CLOSE_5G_CONFIG (1<<17)
-#define NAN_ATTR_RSSI_MIDDLE_5G_CONFIG (1<<18)
-#define NAN_ATTR_RSSI_PROXIMITY_5G_CONFIG (1<<19)
-#define NAN_ATTR_RSSI_WINDOW_SIZE_CONFIG (1<<20)
-#define NAN_ATTR_HOP_COUNT_LIMIT_CONFIG (1<<21)
-#define NAN_ATTR_SID_BEACON_CONFIG (1<<22)
-#define NAN_ATTR_HOP_COUNT_FORCE_CONFIG (1<<23)
-#define NAN_ATTR_RAND_FACTOR_CONFIG (1<<24)
-#define NAN_ATTR_CLUSTER_VAL_CONFIG (1<<25)
-#define NAN_ATTR_IF_ADDR_CONFIG (1<<26)
-#define NAN_ATTR_OUI_CONFIG (1<<27)
-#define NAN_ATTR_SUB_SID_BEACON_CONFIG (1<<28)
-#define NAN_IOVAR_NAME_SIZE 4u
-#define NAN_XTLV_ID_LEN_SIZE OFFSETOF(bcm_xtlv_t, data)
-
-typedef uint32 nan_data_path_id;
-
-typedef enum nan_range_status {
- NAN_RANGING_INVALID = 0,
- NAN_RANGING_REQUIRED = 1,
- NAN_RANGING_IN_PROGRESS = 2
-} nan_range_status_t;
-
-typedef struct nan_svc_inst {
- uint8 inst_id; /* publisher/subscriber id */
- uint8 inst_type; /* publisher/subscriber */
-} nan_svc_inst_t;
-
-typedef struct nan_svc_info {
- bool valid;
- nan_data_path_id ndp_id[NAN_MAX_SVC_INST];
- uint8 svc_hash[WL_NAN_SVC_HASH_LEN]; /* service hash */
- uint8 svc_id;
- uint8 ranging_required;
- uint8 ranging_ind;
- uint8 status;
- uint32 ranging_interval;
- uint32 ingress_limit;
- uint32 egress_limit;
- uint8 tx_match_filter[MAX_MATCH_FILTER_LEN]; /* TX match filter */
- uint8 tx_match_filter_len;
-} nan_svc_info_t;
-
-typedef struct nan_ranging_inst {
- uint8 svc_inst_id;
- uint8 range_id;
- nan_range_status_t range_status;
- struct ether_addr peer_addr;
-} nan_ranging_inst_t;
-
-/*
- * Data request Initiator/Responder
- * app/service related info
- */
-typedef struct nan_data_path_app_info {
- uint16 ndp_app_info_len;
- uint8 ndp_app_info[NAN_DP_MAX_APP_INFO_LEN];
-} nan_data_path_app_info_t;
-
-/* QoS configuration */
-typedef enum {
- NAN_DP_CONFIG_NO_QOS = 0,
- NAN_DP_CONFIG_QOS
-} nan_data_path_qos_cfg_t;
-
-/* Data request Responder's response */
-typedef enum {
- NAN_DP_REQUEST_ACCEPT = 0,
- NAN_DP_REQUEST_REJECT
-} nan_data_path_response_code_t;
-
-/* NAN DP security Configuration */
-typedef enum {
- NAN_DP_CONFIG_NO_SECURITY = 0,
- NAN_DP_CONFIG_SECURITY
-} nan_data_path_security_cfg_status_t;
-
-/* NAN Security Key Input Type */
-typedef enum {
- NAN_SECURITY_KEY_INPUT_PMK = 1,
- NAN_SECURITY_KEY_INPUT_PASSPHRASE
-} nan_security_key_input_type;
-
-/* Configuration params of Data request Initiator/Responder */
-typedef struct nan_data_path_cfg {
- /* Status Indicating Security/No Security */
- nan_data_path_security_cfg_status_t security_cfg;
- nan_data_path_qos_cfg_t qos_cfg;
-} nan_data_path_cfg_t;
-
-enum nan_dp_states {
- NAN_DP_STATE_DISABLED = 0,
- NAN_DP_STATE_ENABLED = 1
-};
-
-enum {
- SRF_TYPE_BLOOM_FILTER = 0,
- SRF_TYPE_SEQ_MAC_ADDR = 1
-};
-
-/* NAN Match indication type */
-typedef enum {
- NAN_MATCH_ALG_MATCH_ONCE = 0,
- NAN_MATCH_ALG_MATCH_CONTINUOUS = 1,
- NAN_MATCH_ALG_MATCH_NEVER = 2
-} nan_match_alg;
-
-typedef struct nan_str_data {
- uint32 dlen;
- uint8 *data;
-} nan_str_data_t;
-
-typedef struct nan_mac_list {
- uint32 num_mac_addr;
- uint8 *list;
-} nan_mac_list_t;
-
-typedef struct wl_nan_sid_beacon_tune {
- uint8 sid_enable; /* flag for sending service id in beacon */
- uint8 sid_count; /* Limit for number of SIDs to be included in Beacons */
- uint8 sub_sid_enable; /* flag for sending subscribe service id in beacon */
- uint8 sub_sid_count; /* Limit for number of SUb SIDs to be included in Beacons */
-} wl_nan_sid_beacon_ctrl_t;
-
-typedef struct nan_avail_cmd_data {
- chanspec_t chanspec[NAN_MAX_SOCIAL_CHANNELS]; /* channel */
- uint32 bmap; /* bitmap */
- uint8 duration;
- uint8 avail_period;
- /* peer mac address reqd for ranging avail type */
- struct ether_addr peer_nmi;
- bool no_config_avail;
-} nan_avail_cmd_data;
-
-typedef struct nan_discover_cmd_data {
- nan_str_data_t svc_info; /* service information */
- nan_str_data_t sde_svc_info; /* extended service information */
- nan_str_data_t svc_hash; /* service hash */
- nan_str_data_t rx_match; /* matching filter rx */
- nan_str_data_t tx_match; /* matching filter tx */
- nan_str_data_t key; /* Security key information */
- nan_str_data_t scid; /* security context information */
- nan_data_path_cfg_t ndp_cfg;
- struct ether_addr mac_addr; /* mac address */
- nan_mac_list_t mac_list; /* mac list */
- wl_nan_instance_id_t pub_id; /* publisher id */
- wl_nan_instance_id_t sub_id; /* subscriber id */
- wl_nan_instance_id_t local_id; /* Local id */
- wl_nan_instance_id_t remote_id; /* Remote id */
- uint32 status;
- uint32 ttl; /* time to live */
- uint32 period; /* publish period */
- uint32 flags; /* Flag bits */
- uint16 sde_control_flag;
- uint16 token; /* transmit fup token id */
- uint8 csid; /* cipher suite type */
- nan_security_key_input_type key_type; /* cipher suite type */
- uint8 priority; /* Priority of Transmit */
- uint8 life_count; /* life count of the instance */
- uint8 srf_type; /* SRF type */
- uint8 srf_include; /* SRF include */
- uint8 use_srf; /* use SRF */
- uint8 recv_ind_flag; /* Receive Indication Flag */
- uint8 disc_ind_cfg; /* Discovery Ind cfg */
- uint8 ranging_indication;
- uint32 ranging_intvl_msec; /* ranging interval in msec */
- uint32 ingress_limit;
- uint32 egress_limit;
- bool response;
- uint8 service_responder_policy;
- bool svc_update;
-} nan_discover_cmd_data_t;
-
-typedef struct nan_datapath_cmd_data {
- nan_avail_cmd_data avail_params; /* Avail config params */
- nan_str_data_t svc_hash; /* service hash */
- nan_str_data_t svc_info; /* service information */
- nan_str_data_t key; /* security key information */
- nan_data_path_response_code_t rsp_code;
- nan_data_path_id ndp_instance_id;
- nan_data_path_cfg_t ndp_cfg;
- wl_nan_instance_id_t pub_id; /* publisher id */
- nan_security_key_input_type key_type; /* cipher suite type */
- struct ether_addr if_addr; /* if addr */
- struct ether_addr mac_addr; /* mac address */
- chanspec_t chanspec[NAN_MAX_SOCIAL_CHANNELS]; /* channel */
- uint32 status;
- uint32 bmap; /* bitmap */
- uint16 service_instance_id;
- uint16 sde_control_flag;
- uint8 csid; /* cipher suite type */
- uint8 peer_disc_mac_addr[ETHER_ADDR_LEN];
- uint8 peer_ndi_mac_addr[ETHER_ADDR_LEN];
- uint8 num_ndp_instances;
- uint8 duration;
- char ndp_iface[IFNAMSIZ+1];
-} nan_datapath_cmd_data_t;
-
-typedef struct nan_rssi_cmd_data {
- int8 rssi_middle_2dot4g_val;
- int8 rssi_close_2dot4g_val;
- int8 rssi_proximity_2dot4g_val;
- int8 rssi_proximity_5g_val;
- int8 rssi_middle_5g_val;
- int8 rssi_close_5g_val;
- uint16 rssi_window_size; /* Window size over which rssi calculated */
-} nan_rssi_cmd_data_t;
-
-typedef struct election_metrics {
- uint8 random_factor; /* Configured random factor */
- uint8 master_pref; /* configured master preference */
-} election_metrics_t;
-
-typedef struct nan_awake_dws {
- uint8 dw_interval_2g; /* 2G DW interval */
- uint8 dw_interval_5g; /* 5G DW interval */
-} nan_awake_dws_t;
-
-typedef struct nan_config_cmd_data {
- nan_rssi_cmd_data_t rssi_attr; /* RSSI related data */
- election_metrics_t metrics;
- nan_awake_dws_t awake_dws; /* Awake DWs */
- nan_avail_cmd_data avail_params; /* Avail config params */
- nan_str_data_t p2p_info; /* p2p information */
- nan_str_data_t scid; /* security context information */
- struct ether_addr clus_id; /* cluster id */
- struct ether_addr mac_addr; /* mac address */
- wl_nan_sid_beacon_ctrl_t sid_beacon; /* sending service id in beacon */
- chanspec_t chanspec[NAN_MAX_SOCIAL_CHANNELS]; /* channel */
- uint32 status;
- uint32 bmap; /* bitmap */
- uint32 nan_oui; /* configured nan oui */
- uint32 warmup_time; /* Warm up time */
- uint8 duration;
- uint8 hop_count_limit; /* hop count limit */
- uint8 support_5g; /* To decide dual band support */
- uint8 support_2g; /* To decide dual band support */
- uint8 beacon_2g_val;
- uint8 beacon_5g_val;
- uint8 sdf_2g_val;
- uint8 sdf_5g_val;
- uint8 dwell_time[NAN_MAX_SOCIAL_CHANNELS];
- uint8 scan_period[NAN_MAX_SOCIAL_CHANNELS];
- uint8 config_cluster_val;
- uint8 disc_ind_cfg; /* Discovery Ind cfg */
- uint8 csid; /* cipher suite type */
- uint32 nmi_rand_intvl; /* nmi randomization interval */
-} nan_config_cmd_data_t;
-
-typedef struct nan_event_hdr {
- uint32 flags; /* future use */
- uint16 event_subtype;
-} nan_event_hdr_t;
-
-typedef struct nan_event_data {
- uint8 svc_name[WL_NAN_SVC_HASH_LEN]; /* service name */
- uint8 enabled; /* NAN Enabled */
- uint8 nan_de_evt_type; /* DE event type */
- uint8 status; /* status */
- uint8 ndp_id; /* data path instance id */
- uint8 security; /* data path security */
- uint8 type;
- uint8 attr_num;
- uint8 reason; /* reason */
- wl_nan_instance_id_t pub_id; /* publisher id */
- wl_nan_instance_id_t sub_id; /* subscriber id */
- wl_nan_instance_id_t local_inst_id; /* local instance id */
- wl_nan_instance_id_t requestor_id; /* Requestor instance id */
- int publish_rssi; /* discovery rssi value */
- int sub_rssi; /* Sub rssi value */
- int fup_rssi; /* followup rssi */
- uint16 attr_list_len; /* sizeof attributes attached to payload */
- nan_str_data_t svc_info; /* service info */
- nan_str_data_t vend_info; /* vendor info */
- nan_str_data_t sde_svc_info; /* extended service information */
- nan_str_data_t tx_match_filter; /* tx match filter */
- nan_str_data_t rx_match_filter; /* rx match filter */
- struct ether_addr local_nmi; /* local nmi */
- struct ether_addr clus_id; /* cluster id */
- struct ether_addr remote_nmi; /* remote nmi */
- struct ether_addr initiator_ndi; /* initiator_ndi */
- struct ether_addr responder_ndi; /* responder_ndi */
- uint16 token; /* transmit fup token id */
- uint8 peer_cipher_suite; /* peer cipher suite type */
- nan_str_data_t scid; /* security context information */
- char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */
- uint16 sde_control_flag;
- uint8 ranging_result_present;
- uint32 range_measurement_cm;
- uint32 ranging_ind;
- uint8 rng_id;
-} nan_event_data_t;
-
-/*
- * Various NAN Protocol Response code
-*/
-typedef enum {
- /* NAN Protocol Response Codes */
- NAN_STATUS_SUCCESS = 0,
- /* NAN Discovery Engine/Host driver failures */
- NAN_STATUS_INTERNAL_FAILURE = 1,
- /* NAN OTA failures */
- NAN_STATUS_PROTOCOL_FAILURE = 2,
- /* if the publish/subscribe id is invalid */
- NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID = 3,
- /* If we run out of resources allocated */
- NAN_STATUS_NO_RESOURCE_AVAILABLE = 4,
- /* if invalid params are passed */
- NAN_STATUS_INVALID_PARAM = 5,
- /* if the requestor instance id is invalid */
- NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID = 6,
- /* if the ndp id is invalid */
- NAN_STATUS_INVALID_NDP_ID = 7,
- /* if NAN is enabled when wifi is turned off */
- NAN_STATUS_NAN_NOT_ALLOWED = 8,
- /* if over the air ack is not received */
- NAN_STATUS_NO_OTA_ACK = 9,
- /* If NAN is already enabled and we are try to re-enable the same */
- NAN_STATUS_ALREADY_ENABLED = 10,
- /* If followup message internal queue is full */
- NAN_STATUS_FOLLOWUP_QUEUE_FULL = 11,
- /* Unsupported concurrency session enabled, NAN disabled notified */
- NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED = 12
-} nan_status_type_t;
-
-typedef struct {
- nan_status_type_t status;
- char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */
-} nan_hal_status_t;
-
-typedef struct nan_parse_event_ctx {
- struct bcm_cfg80211 *cfg;
- nan_event_data_t *nan_evt_data;
-} nan_parse_event_ctx_t;
-
-/* Capabilities info supported by FW */
-typedef struct nan_hal_capabilities {
- uint32 max_concurrent_nan_clusters;
- uint32 max_publishes;
- uint32 max_subscribes;
- uint32 max_service_name_len;
- uint32 max_match_filter_len;
- uint32 max_total_match_filter_len;
- uint32 max_service_specific_info_len;
- uint32 max_vsa_data_len;
- uint32 max_mesh_data_len;
- uint32 max_ndi_interfaces;
- uint32 max_ndp_sessions;
- uint32 max_app_info_len;
- uint32 max_queued_transmit_followup_msgs;
- uint32 ndp_supported_bands;
- uint32 cipher_suites_supported;
- uint32 max_scid_len;
- bool is_ndp_security_supported;
- uint32 max_sdea_service_specific_info_len;
- uint32 max_subscribe_address;
-} nan_hal_capabilities_t;
-
-typedef struct _nan_hal_resp {
- uint16 instance_id;
- uint16 subcmd;
- int32 status;
- int32 value;
- /* Identifier for the instance of the NDP */
- uint16 ndp_instance_id;
- nan_hal_capabilities_t capabilities;
- /* Publisher NMI */
- uint8 pub_nmi[NAN_MAC_ADDR_LEN];
- /* SVC_HASH */
- uint8 svc_hash[WL_NAN_SVC_HASH_LEN];
- char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */
-} nan_hal_resp_t;
-
-typedef struct wl_nan_iov {
- uint16 nan_iov_len;
- uint8 *nan_iov_buf;
-} wl_nan_iov_t;
-
-#ifdef WL_NAN_DISC_CACHE
-
-#define NAN_MAX_CACHE_DISC_RESULT 16
-typedef struct {
- bool valid;
- wl_nan_instance_id_t pub_id;
- wl_nan_instance_id_t sub_id;
- uint8 svc_hash[WL_NAN_SVC_HASH_LEN];
- struct ether_addr peer;
- int8 publish_rssi;
- uint8 peer_cipher_suite;
- uint8 security;
- nan_str_data_t svc_info; /* service info */
- nan_str_data_t vend_info; /* vendor info */
- nan_str_data_t sde_svc_info; /* extended service information */
- nan_str_data_t tx_match_filter; /* tx match filter */
- uint16 sde_control_flag;
-} nan_disc_result_cache;
-
-typedef struct nan_datapath_sec_info {
- nan_data_path_id ndp_instance_id;
- wl_nan_instance_id_t pub_id; /* publisher id */
- struct ether_addr mac_addr; /* mac address */
-} nan_datapath_sec_info_cmd_data_t;
-#endif /* WL_NAN_DISC_CACHE */
-
-typedef enum {
- NAN_RANGING_AUTO_RESPONSE_ENABLE = 0,
- NAN_RANGING_AUTO_RESPONSE_DISABLE
-} NanRangingAutoResponseCfg;
-
-extern int wl_cfgnan_set_vars_cbfn(void *ctx, const uint8 *tlv_buf,
- uint16 type, uint16 len);
-extern int wl_cfgnan_config_eventmask(struct net_device *ndev, struct bcm_cfg80211 *cfg,
- uint8 event_ind_flag, bool disable_events);
-extern int wl_cfgnan_start_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_config_cmd_data_t *cmd_data, uint32 nan_attr_mask);
-extern int wl_cfgnan_stop_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, uint8 busstate, bool disable_events);
-extern int wl_cfgnan_config_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_config_cmd_data_t *cmd_data, uint32 nan_attr_mask);
-extern int wl_cfgnan_support_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_config_cmd_data_t *cmd_data);
-extern int wl_cfgnan_status_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_config_cmd_data_t *cmd_data);
-extern int wl_cfgnan_publish_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data);
-extern int wl_cfgnan_subscribe_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data);
-extern int wl_cfgnan_cancel_pub_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data);
-extern int wl_cfgnan_cancel_sub_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data);
-extern int wl_cfgnan_transmit_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_discover_cmd_data_t *cmd_data);
-extern s32 wl_cfgnan_notify_nan_status(struct bcm_cfg80211 *cfg,
- bcm_struct_cfgdev *cfgdev, const wl_event_msg_t *e, void *data);
-extern int wl_cfgnan_generate_inst_id(struct bcm_cfg80211 *cfg, uint8 *p_inst_id);
-extern int wl_cfgnan_remove_inst_id(struct bcm_cfg80211 *cfg, uint8 inst_id);
-extern int bcm_xtlv_size_for_data(int dlen, bcm_xtlv_opts_t opts);
-extern int wl_cfgnan_get_capablities_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_hal_capabilities_t *capabilities);
-
-extern int wl_cfgnan_data_path_iface_create_delete_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, char *ifname, uint16 type, uint8 busstate);
-extern int wl_cfgnan_data_path_request_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_datapath_cmd_data_t *cmd_data,
- uint8 *ndp_instance_id);
-extern int wl_cfgnan_data_path_response_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_datapath_cmd_data_t *cmd_data);
-extern int wl_cfgnan_data_path_end_handler(struct net_device *ndev,
- struct bcm_cfg80211 *cfg, nan_datapath_cmd_data_t *cmd_data);
-
-#ifdef WL_NAN_DISC_CACHE
-extern int wl_cfgnan_sec_info_handler(struct bcm_cfg80211 *cfg,
- nan_datapath_sec_info_cmd_data_t *cmd_data, nan_hal_resp_t *nan_req_resp);
-#endif /* WL_NAN_DISC_CACHE */
-extern bool wl_cfgnan_is_dp_active(struct net_device *ndev);
-extern s32 wl_cfgnan_get_ndi_idx(struct bcm_cfg80211 *cfg);
-extern s32 wl_cfgnan_add_ndi_data(struct bcm_cfg80211 *cfg, s32 idx, char *name);
-extern s32 wl_cfgnan_del_ndi_data(struct bcm_cfg80211 *cfg, char *name);
-extern struct wl_ndi_data *wl_cfgnan_get_ndi_data(struct bcm_cfg80211 *cfg, char *name);
-
-typedef enum {
- NAN_ATTRIBUTE_HEADER = 100,
- NAN_ATTRIBUTE_HANDLE = 101,
- NAN_ATTRIBUTE_TRANSAC_ID = 102,
-
- /* NAN Enable request attributes */
- NAN_ATTRIBUTE_2G_SUPPORT = 103,
- NAN_ATTRIBUTE_5G_SUPPORT = 104,
- NAN_ATTRIBUTE_CLUSTER_LOW = 105,
- NAN_ATTRIBUTE_CLUSTER_HIGH = 106,
- NAN_ATTRIBUTE_SID_BEACON = 107,
- NAN_ATTRIBUTE_SYNC_DISC_2G_BEACON = 108,
- NAN_ATTRIBUTE_SYNC_DISC_5G_BEACON = 109,
- NAN_ATTRIBUTE_SDF_2G_SUPPORT = 110,
- NAN_ATTRIBUTE_SDF_5G_SUPPORT = 111,
- NAN_ATTRIBUTE_RSSI_CLOSE = 112,
- NAN_ATTRIBUTE_RSSI_MIDDLE = 113,
- NAN_ATTRIBUTE_RSSI_PROXIMITY = 114,
- NAN_ATTRIBUTE_HOP_COUNT_LIMIT = 115,
- NAN_ATTRIBUTE_RANDOM_TIME = 116,
- NAN_ATTRIBUTE_MASTER_PREF = 117,
- NAN_ATTRIBUTE_PERIODIC_SCAN_INTERVAL = 118,
-
- /* Nan Publish/Subscribe request attributes */
- NAN_ATTRIBUTE_PUBLISH_ID = 119,
- NAN_ATTRIBUTE_TTL = 120,
- NAN_ATTRIBUTE_PERIOD = 121,
- NAN_ATTRIBUTE_REPLIED_EVENT_FLAG = 122,
- NAN_ATTRIBUTE_PUBLISH_TYPE = 123,
- NAN_ATTRIBUTE_TX_TYPE = 124,
- NAN_ATTRIBUTE_PUBLISH_COUNT = 125,
- NAN_ATTRIBUTE_SERVICE_NAME_LEN = 126,
- NAN_ATTRIBUTE_SERVICE_NAME = 127,
- NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN = 128,
- NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO = 129,
- NAN_ATTRIBUTE_RX_MATCH_FILTER_LEN = 130,
- NAN_ATTRIBUTE_RX_MATCH_FILTER = 131,
- NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN = 132,
- NAN_ATTRIBUTE_TX_MATCH_FILTER = 133,
- NAN_ATTRIBUTE_SUBSCRIBE_ID = 134,
- NAN_ATTRIBUTE_SUBSCRIBE_TYPE = 135,
- NAN_ATTRIBUTE_SERVICERESPONSEFILTER = 136,
- NAN_ATTRIBUTE_SERVICERESPONSEINCLUDE = 137,
- NAN_ATTRIBUTE_USESERVICERESPONSEFILTER = 138,
- NAN_ATTRIBUTE_SSIREQUIREDFORMATCHINDICATION = 139,
- NAN_ATTRIBUTE_SUBSCRIBE_MATCH = 140,
- NAN_ATTRIBUTE_SUBSCRIBE_COUNT = 141,
- NAN_ATTRIBUTE_MAC_ADDR = 142,
- NAN_ATTRIBUTE_MAC_ADDR_LIST = 143,
- NAN_ATTRIBUTE_MAC_ADDR_LIST_NUM_ENTRIES = 144,
- NAN_ATTRIBUTE_PUBLISH_MATCH = 145,
-
- /* Nan Event attributes */
- NAN_ATTRIBUTE_ENABLE_STATUS = 146,
- NAN_ATTRIBUTE_JOIN_STATUS = 147,
- NAN_ATTRIBUTE_ROLE = 148,
- NAN_ATTRIBUTE_MASTER_RANK = 149,
- NAN_ATTRIBUTE_ANCHOR_MASTER_RANK = 150,
- NAN_ATTRIBUTE_CNT_PEND_TXFRM = 151,
- NAN_ATTRIBUTE_CNT_BCN_TX = 152,
- NAN_ATTRIBUTE_CNT_BCN_RX = 153,
- NAN_ATTRIBUTE_CNT_SVC_DISC_TX = 154,
- NAN_ATTRIBUTE_CNT_SVC_DISC_RX = 155,
- NAN_ATTRIBUTE_AMBTT = 156,
- NAN_ATTRIBUTE_CLUSTER_ID = 157,
- NAN_ATTRIBUTE_INST_ID = 158,
- NAN_ATTRIBUTE_OUI = 159,
- NAN_ATTRIBUTE_STATUS = 160,
- NAN_ATTRIBUTE_DE_EVENT_TYPE = 161,
- NAN_ATTRIBUTE_MERGE = 162,
- NAN_ATTRIBUTE_IFACE = 163,
- NAN_ATTRIBUTE_CHANNEL = 164,
- NAN_ATTRIBUTE_PEER_ID = 165,
- NAN_ATTRIBUTE_NDP_ID = 167,
- NAN_ATTRIBUTE_SECURITY = 168,
- NAN_ATTRIBUTE_QOS = 169,
- NAN_ATTRIBUTE_RSP_CODE = 170,
- NAN_ATTRIBUTE_INST_COUNT = 171,
- NAN_ATTRIBUTE_PEER_DISC_MAC_ADDR = 172,
- NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR = 173,
- NAN_ATTRIBUTE_IF_ADDR = 174,
- NAN_ATTRIBUTE_WARMUP_TIME = 175,
- NAN_ATTRIBUTE_RECV_IND_CFG = 176,
- NAN_ATTRIBUTE_RSSI_CLOSE_5G = 177,
- NAN_ATTRIBUTE_RSSI_MIDDLE_5G = 178,
- NAN_ATTRIBUTE_RSSI_PROXIMITY_5G = 179,
- NAN_ATTRIBUTE_CONNMAP = 180,
- NAN_ATTRIBUTE_24G_CHANNEL = 181,
- NAN_ATTRIBUTE_5G_CHANNEL = 182,
- NAN_ATTRIBUTE_DWELL_TIME = 183,
- NAN_ATTRIBUTE_SCAN_PERIOD = 184,
- NAN_ATTRIBUTE_RSSI_WINDOW_SIZE = 185,
- NAN_ATTRIBUTE_CONF_CLUSTER_VAL = 186,
- NAN_ATTRIBUTE_AVAIL_BIT_MAP = 187,
- NAN_ATTRIBUTE_ENTRY_CONTROL = 188,
- NAN_ATTRIBUTE_CIPHER_SUITE_TYPE = 189,
- NAN_ATTRIBUTE_KEY_TYPE = 190,
- NAN_ATTRIBUTE_KEY_LEN = 191,
- NAN_ATTRIBUTE_SCID = 192,
- NAN_ATTRIBUTE_SCID_LEN = 193,
- NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP = 194,
- NAN_ATTRIBUTE_SDE_CONTROL_SECURITY = 195,
- NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE = 196,
- NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT = 197,
- NAN_ATTRIBUTE_NO_CONFIG_AVAIL = 198,
- NAN_ATTRIBUTE_2G_AWAKE_DW = 199,
- NAN_ATTRIBUTE_5G_AWAKE_DW = 200,
- NAN_ATTRIBUTE_RANGING_INTERVAL = 201,
- NAN_ATTRIBUTE_RANGING_INDICATION = 202,
- NAN_ATTRIBUTE_RANGING_INGRESS_LIMIT = 203,
- NAN_ATTRIBUTE_RANGING_EGRESS_LIMIT = 204,
- NAN_ATTRIBUTE_RANGING_AUTO_ACCEPT = 205,
- NAN_ATTRIBUTE_RANGING_RESULT = 206,
- NAN_ATTRIBUTE_DISC_IND_CFG = 207,
- NAN_ATTRIBUTE_RSSI_THRESHOLD_FLAG = 208,
- NAN_ATTRIBUTE_KEY_DATA = 209,
- NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN = 210,
- NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO = 211,
- NAN_ATTRIBUTE_REASON = 212,
- NAN_ATTRIBUTE_DWELL_TIME_5G = 215,
- NAN_ATTRIBUTE_SCAN_PERIOD_5G = 216,
- NAN_ATTRIBUTE_SVC_RESPONDER_POLICY = 217,
- NAN_ATTRIBUTE_EVENT_MASK = 218,
- NAN_ATTRIBUTE_SUB_SID_BEACON = 219,
- NAN_ATTRIBUTE_RANDOMIZATION_INTERVAL = 220
-} NAN_ATTRIBUTE;
-#endif /* _wl_cfgnan_h_ */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgscan.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgscan.c
old mode 100644
new mode 100755
index 96cf7a5..ba5cc7e
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgscan.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgscan.c
@@ -247,7 +247,12 @@
s32 err = BCME_OK;
struct wiphy *wiphy = NULL;
wl_bcnrecv_result_t *bcn_recv = NULL;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0))
+ struct timespec64 ts;
+#else
struct timespec ts;
+#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)) */
+
if (!bi) {
WL_ERR(("%s: bi is NULL\n", __func__));
err = BCME_NORESOURCE;
@@ -1060,7 +1065,7 @@
{
wl_scan_params_t *params = NULL;
wl_scan_params_v2_t *params_v2 = NULL;
- u32 scan_type = 0;
+ u32 scan_type = htod32(scan_type);
u32 scan_param_size = 0;
u32 n_channels = 0;
u32 n_ssids = 0;
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.c
old mode 100644
new mode 100755
index b21ba31..3dd8083
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.c
@@ -9584,108 +9584,62 @@
#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(3, 13, 0)) || defined(WL_VENDOR_EXT_SUPPORT) */
#ifdef WL_CFGVENDOR_SEND_HANG_EVENT
+#define WL_VENDOR_STR_MAX_LEN 128
void
-wl_cfgvendor_send_hang_event(struct net_device *dev, u16 reason, char *string, int hang_info_cnt)
+wl_cfgvendor_send_hang_event(struct net_device *dev, u16 reason)
{
- struct bcm_cfg80211 *cfg = wl_get_cfg(dev);
+ struct bcm_cfg80211 *cfg;
struct wiphy *wiphy;
- char *hang_info;
+ struct sk_buff *skb;
+ dhd_pub_t *dhdp;
+ gfp_t kflags;
int len = 0;
- int bytes_written;
- uint32 dummy_data = 0;
- int reason_hang_info = 0;
- int cnt = 0;
- dhd_pub_t *dhd;
- int hang_reason_mismatch = FALSE;
+ char reason_str[WL_VENDOR_STR_MAX_LEN] = {0x00, };
+ cfg = wl_cfg80211_get_bcmcfg();
if (!cfg || !cfg->wdev) {
WL_ERR(("cfg=%p wdev=%p\n", cfg, (cfg ? cfg->wdev : NULL)));
return;
}
wiphy = cfg->wdev->wiphy;
-
if (!wiphy) {
WL_ERR(("wiphy is NULL\n"));
return;
}
- hang_info = MALLOCZ(cfg->osh, VENDOR_SEND_HANG_EXT_INFO_LEN);
- if (hang_info == NULL) {
- WL_ERR(("alloc hang_info failed\n"));
+ dhdp = (dhd_pub_t *)(cfg->pub);
+ if (!dhdp) {
+ WL_ERR(("dhdp is NULL\n"));
return;
}
- dhd = (dhd_pub_t *)(cfg->pub);
+ kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
-#ifdef WL_BCNRECV
- /* check fakeapscan in progress then stop scan */
- if (cfg->bcnrecv_info.bcnrecv_state == BEACON_RECV_STARTED) {
- wl_android_bcnrecv_stop(dev, WL_BCNRECV_HANG);
+#ifdef DHD_FW_COREDUMP
+ len = snprintf(reason_str, WL_VENDOR_STR_MAX_LEN,
+ "memdump_type = 0x%x, ", dhdp->memdump_type);
+#endif // endif
+ len = snprintf(reason_str + len, WL_VENDOR_STR_MAX_LEN,
+ "HANG reason = 0x%x", reason);
+
+ /* Alloc the SKB for vendor_event */
+#if (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || \
+ LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0)
+ skb = cfg80211_vendor_event_alloc(wiphy, ndev_to_wdev(dev), WL_VENDOR_STR_MAX_LEN,
+ BRCM_VENDOR_EVENT_HANGED, kflags);
+#else
+ skb = cfg80211_vendor_event_alloc(wiphy, len, BRCM_VENDOR_EVENT_HANGED, kflags);
+#endif /* (defined(CONFIG_ARCH_MSM) && defined(SUPPORT_WDEV_CFG80211_VENDOR_EVENT_ALLOC)) || */
+ /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
+
+ if (!skb) {
+ WL_ERR(("skb allocation is failed\n"));
+ return;
}
-#endif /* WL_BCNRECV */
- sscanf(string, "%d", &reason_hang_info);
- bytes_written = 0;
- len = VENDOR_SEND_HANG_EXT_INFO_LEN - bytes_written;
- if (strlen(string) == 0 || (reason_hang_info != reason)) {
- WL_ERR(("hang reason mismatch: string len %d reason_hang_info %d\n",
- (int)strlen(string), reason_hang_info));
- hang_reason_mismatch = TRUE;
- if (dhd) {
- get_debug_dump_time(dhd->debug_dump_time_hang_str);
- copy_debug_dump_time(dhd->debug_dump_time_str,
- dhd->debug_dump_time_hang_str);
- }
- bytes_written += scnprintf(&hang_info[bytes_written], len,
- "%d %d %s %08x %08x %08x %08x %08x %08x %08x",
- reason, VENDOR_SEND_HANG_EXT_INFO_VER,
- dhd->debug_dump_time_hang_str,
- 0, 0, 0, 0, 0, 0, 0);
- if (dhd) {
- clear_debug_dump_time(dhd->debug_dump_time_hang_str);
- }
- } else {
- bytes_written += scnprintf(&hang_info[bytes_written], len, "%s", string);
- }
-
- WL_ERR(("hang reason: %d info cnt: %d\n", reason, hang_info_cnt));
-
- if (hang_reason_mismatch == FALSE) {
- cnt = hang_info_cnt;
- } else {
- cnt = HANG_FIELD_MISMATCH_CNT;
- }
-
- while (cnt < HANG_FIELD_CNT_MAX) {
- len = VENDOR_SEND_HANG_EXT_INFO_LEN - bytes_written;
- if (len <= 0) {
- break;
- }
- bytes_written += scnprintf(&hang_info[bytes_written], len,
- "%c%08x", HANG_RAW_DEL, dummy_data);
- cnt++;
- }
-
- WL_ERR(("hang info cnt: %d len: %d\n", cnt, (int)strlen(hang_info)));
- WL_ERR(("hang info data: %s\n", hang_info));
-
- wl_cfgvendor_send_async_event(wiphy,
- bcmcfg_to_prmry_ndev(cfg), BRCM_VENDOR_EVENT_HANGED,
- hang_info, (int)strlen(hang_info));
-
- memset(string, 0, VENDOR_SEND_HANG_EXT_INFO_LEN);
-
- if (hang_info) {
- MFREE(cfg->osh, hang_info, VENDOR_SEND_HANG_EXT_INFO_LEN);
- }
-
-#ifdef DHD_LOG_DUMP
- dhd_logdump_cookie_save(dhd, dhd->debug_dump_time_hang_str, "HANG");
-#endif /* DHD_LOG_DUMP */
-
- if (dhd) {
- clear_debug_dump_time(dhd->debug_dump_time_str);
- }
+ WL_INFORM_MEM(("%s\n", reason_str));
+ nla_put(skb, DEBUG_ATTRIBUTE_HANG_REASON, strlen(reason_str), reason_str);
+ cfg80211_vendor_event(skb, kflags);
}
void
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.h b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.h
old mode 100644
new mode 100755
index 05a4fee..c275efa
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.h
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_cfgvendor.h
@@ -894,8 +894,7 @@
/* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0) */
#ifdef WL_CFGVENDOR_SEND_HANG_EVENT
-void wl_cfgvendor_send_hang_event(struct net_device *dev, u16 reason,
- char *string, int hang_info_cnt);
+void wl_cfgvendor_send_hang_event(struct net_device *dev, u16 reason);
void wl_copy_hang_info_if_falure(struct net_device *dev, u16 reason, s32 ret);
#endif /* WL_CFGVENDOR_SEND_HANG_EVENT */
#endif /* _wl_cfgvendor_h_ */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_iw.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_iw.c
old mode 100644
new mode 100755
index 769eaa6..c16478f
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_iw.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_iw.c
@@ -240,7 +240,9 @@
{
struct ifreq ifr;
wl_ioctl_t ioc;
+#if defined(KERNEL_DS) && defined(USER_DS)
mm_segment_t fs;
+#endif /* KERNEL_DS && USER_DS */
int ret;
memset(&ioc, 0, sizeof(ioc));
@@ -252,16 +254,20 @@
ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
ifr.ifr_data = (caddr_t) &ioc;
+#if defined(KERNEL_DS) && defined(USER_DS)
fs = get_fs();
#if LINUX_VERSION_CODE <= KERNEL_VERSION(5, 0, 21)
set_fs(get_ds());
#endif // endif
+#endif /* KERNEL_DS && USER_DS */
#if defined(WL_USE_NETDEV_OPS)
ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
#else
ret = dev->do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
#endif // endif
+#if defined(KERNEL_DS) && defined(USER_DS)
set_fs(fs);
+#endif /* KERNEL_DS && USER_DS */
return ret;
}
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_roam.c b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_roam.c
old mode 100644
new mode 100755
index 43786b4..e3be4aa
--- a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_roam.c
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd/wl_roam.c
@@ -271,7 +271,7 @@
int get_roam_channel_list(int target_chan,
chanspec_t *channels, int n_channels, const wlc_ssid_t *ssid, int ioctl_ver,
- uint32 center_freq)
+ struct ieee80211_channel *chan)
{
int i, n = 1;
char chanbuf[CHANSPEC_STR_LEN];
@@ -279,7 +279,7 @@
/* first index is filled with the given target channel */
if (target_chan) {
channels[0] = (target_chan & WL_CHANSPEC_CHAN_MASK) |
- (center_freq > FREQ_START_6G_CHANNEL ?
+ (chan->center_freq > FREQ_START_6G_CHANNEL ?
band6G : (target_chan <= CH_MAX_2G_CHANNEL ? band2G : band5G)) | band_bw;
} else {
/* If target channel is not provided, set the index to 0 */
diff --git a/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd_89570_temp_disable_fwlog.diff b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd_89570_temp_disable_fwlog.diff
new file mode 100755
index 0000000..b744ef9
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/net/wireless/bcmdhd_89570_temp_disable_fwlog.diff
@@ -0,0 +1,42 @@
+diff -urN bcmdhd_headhight_89570_bak/dhd_linux.c bcmdhd/dhd_linux.c
+--- bcmdhd_headhight_89570_bak/dhd_linux.c 2022-09-18 19:32:16.209593494 +0800
++++ bcmdhd/dhd_linux.c 2022-09-18 19:58:09.449580833 +0800
+@@ -8420,6 +8420,11 @@
+
+ dhd_attach_states_t dhd_state = DHD_ATTACH_STATE_INIT;
+ DHD_TRACE(("%s: Enter\n", __FUNCTION__));
++
++#ifdef DHD_DISABLE_FWLOG_IN_CHIPBOOT
++ dhd_msg_level = (dhd_msg_level & (~DHD_FWLOG_VAL));
++ DHD_ERROR(("%s , dhd_msg_level: 0x%x\n", __FUNCTION__, dhd_msg_level));
++#endif
+
+ #ifdef PCIE_FULL_DONGLE
+ ASSERT(sizeof(dhd_pkttag_fd_t) <= OSL_PKTTAG_SZ);
+@@ -12077,10 +12082,15 @@
+ net->netdev_ops = &dhd_ops_virt;
+
+ /* Ok, link into the network layer... */
++ DHD_ERROR(("%s , ifidx: %d\n", __FUNCTION__, ifidx));
+ if (ifidx == 0) {
+ /*
+ * device functions for the primary interface only
+ */
++#ifdef DHD_DISABLE_FWLOG_IN_CHIPBOOT
++ dhd_msg_level = (dhd_msg_level | (DHD_FWLOG_VAL));
++ DHD_ERROR(("%s , dhd_msg_level: 0x%x\n", __FUNCTION__, dhd_msg_level));
++#endif
+ net->netdev_ops = &dhd_ops_pri;
+ if (!ETHER_ISNULLADDR(dhd->pub.mac.octet))
+ memcpy(temp_addr, dhd->pub.mac.octet, ETHER_ADDR_LEN);
+diff -urN bcmdhd_headhight_89570_bak/Makefile bcmdhd/Makefile
+--- bcmdhd_headhight_89570_bak/Makefile 2022-09-18 19:32:16.285593494 +0800
++++ bcmdhd/Makefile 2022-09-18 19:51:12.753584229 +0800
+@@ -38,6 +38,7 @@
+ # DHDCFLAGS += -DCUSTOM_AMPDU_MPDU=16
+
+ DHDCFLAGS += -DDHD_FORCE_MSI
++DHDCFLAGS += -DDHD_DISABLE_FWLOG_IN_CHIPBOOT
+ #####################
+ # SDIO Basic feature
+ #####################
diff --git a/src/kernel/linux/v4.19/fs/ubifs/lpt.c b/src/kernel/linux/v4.19/fs/ubifs/lpt.c
index 3139337..22ba82e 100644
--- a/src/kernel/linux/v4.19/fs/ubifs/lpt.c
+++ b/src/kernel/linux/v4.19/fs/ubifs/lpt.c
@@ -1334,6 +1334,11 @@
buf = vmalloc(c->ltab_sz);
if (!buf)
return -ENOMEM;
+ /*jb.qi change for ubi problem on 20221026 start*/
+ /* check the whole LEB */
+ ubifs_err(c, "check the LEB of ltab!\n");
+ ubifs_leb_read(c, c->ltab_lnum, c->sbuf, 0, c->leb_size, 1);
+ /*jb.qi change for ubi problem on 20221026 end*/
err = ubifs_leb_read(c, c->ltab_lnum, buf, c->ltab_offs, c->ltab_sz, 1);
if (err)
goto out;
diff --git a/src/kernel/linux/v4.19/fs/ubifs/recovery.c b/src/kernel/linux/v4.19/fs/ubifs/recovery.c
index 984e30e..36107ee 100644
--- a/src/kernel/linux/v4.19/fs/ubifs/recovery.c
+++ b/src/kernel/linux/v4.19/fs/ubifs/recovery.c
@@ -933,7 +933,7 @@
/* Read at the head location and check it is empty flash */
err = ubifs_leb_read(c, lnum, sbuf, offs, len, 1);
if (err || !is_empty(sbuf, len)) {
- dbg_rcvry("cleaning head at %d:%d", lnum, offs);
+ ubifs_err(c, "cleaning head at %d:%d", lnum, offs); //jb.qi change for ubi problem on 20221026
if (offs == 0)
return ubifs_leb_unmap(c, lnum);
err = ubifs_leb_read(c, lnum, sbuf, 0, offs, 1);
@@ -968,12 +968,12 @@
ubifs_assert(c, !c->ro_mount || c->remounting_rw);
- dbg_rcvry("checking index head at %d:%d", c->ihead_lnum, c->ihead_offs);
+ ubifs_err(c, "checking index head at %d:%d", c->ihead_lnum, c->ihead_offs);//jb.qi change for ubi problem on 20221026
err = recover_head(c, c->ihead_lnum, c->ihead_offs, sbuf);
if (err)
return err;
- dbg_rcvry("checking LPT head at %d:%d", c->nhead_lnum, c->nhead_offs);
+ ubifs_err(c, "checking LPT head at %d:%d", c->nhead_lnum, c->nhead_offs);//jb.qi change for ubi problem on 20221026
return recover_head(c, c->nhead_lnum, c->nhead_offs, sbuf);
}
diff --git a/src/kernel/linux/v4.19/net/wireless/nl80211.c b/src/kernel/linux/v4.19/net/wireless/nl80211.c
index 7870225..ae91a89 100644
--- a/src/kernel/linux/v4.19/net/wireless/nl80211.c
+++ b/src/kernel/linux/v4.19/net/wireless/nl80211.c
@@ -9558,9 +9558,6 @@
if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) {
if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
-//tianyan@2021.7.27 modify for add wifi6 module start
- //kzfree(connkeys);
-//tianyan@2021.7.27 modify for add wifi6 module end
GENL_SET_ERR_MSG(info,
"external auth requires connection ownership");
return -EINVAL;
diff --git a/src/kernel/linux/v4.19/net/wireless/rdev-ops.h b/src/kernel/linux/v4.19/net/wireless/rdev-ops.h
index 4cff76f..33999c4 100644
--- a/src/kernel/linux/v4.19/net/wireless/rdev-ops.h
+++ b/src/kernel/linux/v4.19/net/wireless/rdev-ops.h
@@ -1222,7 +1222,7 @@
return ret;
}
-static inline int
+static inline int
rdev_external_auth(struct cfg80211_registered_device *rdev,
struct net_device *dev,
struct cfg80211_external_auth_params *params)
diff --git a/src/kernel/linux/v4.19/oe-logs b/src/kernel/linux/v4.19/oe-logs
new file mode 120000
index 0000000..7c64d2b
--- /dev/null
+++ b/src/kernel/linux/v4.19/oe-logs
@@ -0,0 +1 @@
+/mnt/sdc/qs.xiong/work_space/up_drv/build/tmp/work/auto2735evb_ivt_main-poky-linux/linux-mtk-extension/4.19-r0/temp
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/oe-workdir b/src/kernel/linux/v4.19/oe-workdir
new file mode 120000
index 0000000..e87e9b6
--- /dev/null
+++ b/src/kernel/linux/v4.19/oe-workdir
@@ -0,0 +1 @@
+/mnt/sdc/qs.xiong/work_space/up_drv/build/tmp/work/auto2735evb_ivt_main-poky-linux/linux-mtk-extension/4.19-r0
\ No newline at end of file
diff --git a/src/lynq/framework/lynq-ril-service/src/mtk_ril_unsol_commands.h b/src/lynq/framework/lynq-ril-service/src/mtk_ril_unsol_commands.h
index de50775..5c461f4 100755
--- a/src/lynq/framework/lynq-ril-service/src/mtk_ril_unsol_commands.h
+++ b/src/lynq/framework/lynq-ril-service/src/mtk_ril_unsol_commands.h
@@ -32,7 +32,7 @@
* have been modified by MediaTek Inc. All revisions are subject to any receiver's
* applicable license agreements with MediaTek Inc.
*/
-
+{ RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED, responseVoid, WAKE_PARTIAL},
{ RIL_UNSOL_MAL_AT_INFO, responseString, WAKE_PARTIAL},
{ RIL_UNSOL_ECONF_SRVCC_INDICATION, responseInts, WAKE_PARTIAL},
{ RIL_UNSOL_ECONF_RESULT_INDICATION, responseStrings, WAKE_PARTIAL},
diff --git a/src/lynq/framework/lynq-ril-service/src/ril.cpp b/src/lynq/framework/lynq-ril-service/src/ril.cpp
index 80e7a76..01386a2 100755
--- a/src/lynq/framework/lynq-ril-service/src/ril.cpp
+++ b/src/lynq/framework/lynq-ril-service/src/ril.cpp
@@ -5673,6 +5673,7 @@
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return 1;
case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return 1;
case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return 1;
+ case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED: return 1;
case RIL_UNSOL_RESPONSE_NEW_SMS: return 1;
case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return 1;
case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return 1;
diff --git a/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
index f1cf502..b9efae9 100755
--- a/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
+++ b/src/lynq/lib/liblynq-call/include/libcall/lynq_call.h
@@ -8,6 +8,9 @@
( ( (alpha_char >= '0') && (alpha_char <= '9') ) ? 1 : 0 )
#define LYNQ_CALL_MAX 10
#define LYNQ_CALL_FAIL_VENDOR_CAUSE 64
+#define MAX_IP_LENGTH 128
+#define MAX_VLAN_INFO_LENGTH 128
+
typedef enum {
LYNQ_CALL_FAIL_UNOBTAINABLE_NUMBER = 1,
LYNQ_CALL_FAIL_NORMAL = 16,
@@ -89,6 +92,8 @@
LYNQ_ECALL_LLACK_RECEIVED = 3,
LYNQ_ECALL_ALACK_POSITIVE_RECEIVED = 4,
LYNQ_ECALL_ALACK_CLEARDOWN_RECEIVED = 5,
+ LYNQ_ECALL_DAILING = 9,
+ LYNQ_ECALL_ALERTING = 10,
LYNQ_ECALL_ACTIVE = 11,
LYNQ_ECALL_DISCONNECTED = 12,
LYNQ_ECALL_IMS_ACTIVE = 13,
@@ -147,6 +152,8 @@
int lynq_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port);
int lynq_get_rtp_param(int* clock_rate,int* channels, int* latency);//only for client
/*Audio Path setting end*/
+
+void lynq_set_test_mode(const int test_mode);
#ifdef __cplusplus
}
#endif
diff --git a/src/lynq/lib/liblynq-call/lynq_call.cpp b/src/lynq/lib/liblynq-call/lynq_call.cpp
index 0e46e6e..0270aa1 100755
--- a/src/lynq/lib/liblynq-call/lynq_call.cpp
+++ b/src/lynq/lib/liblynq-call/lynq_call.cpp
@@ -18,23 +18,23 @@
#include <vendor-ril/telephony/mtk_ril_sp.h>
#include <vendor-ril/telephony/mtk_ril_ivt.h>
#include "lynq_call.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+#include "lynq_call_common.h"
-
-#define LYNQ_SERVICE_PORT 8088
-#define DSET_IP_ADDRESS "127.0.0.1"
-#define LYNQ_URC_SERVICE_PORT 8086
-#define LYNQ_REC_BUF 8192
-#define LYNQ_REQUEST_PARAM_BUF 8192
-#define LYQN_SEDN_BUF 1024*8+sizeof(int)*3
-#define INVALID_ID (-1)
-#define RTP_FROM_CMD "gst-launch-1.0 -v udpsrc port=%d caps=\'application/x-rtp, media=(string)audio, clock-rate=(int)%d, channels=(int)%d\' ! rtpjitterbuffer latency=%d ! rtppcmadepay ! alawdec ! audioresample ! audioconvert ! alsasink device=\'hw:0,2\'"
-#define RTP_TO_CMD "gst-launch-1.0 -v alsasrc device=\'hw:0,6\' ! audioconvert ! audioresample ! alawenc ! rtppcmapay ! udpsink host=%s %s auto-multicast=true port=%d"
-#define RTP_VLAN_INFO_FORMAT "multicast-iface=\"%s\""
-#define MAX_IP_LENGTH 128
-#define MAX_VLAN_INFO_LENGTH 128
+#define CALL_OFF (0)
+#define CALL_ON (1)
#define USER_LOG_TAG "LYNQ_CALL"
using ::android::Parcel;
+
+/**
+ * @brief mark call initialization state
+ * 0: deinit state
+ * 1: init state
+ */
+int g_module_init_flag = 0;
+
typedef enum {
LYNQ_CALL_ACTIVE = 0,
LYNQ_CALL_HOLDING = 1,
@@ -47,12 +47,6 @@
/*warren add for T800 platform 2022/04/26 end*/
}lynq_call_state_t;
-typedef struct{
- int uToken;
- int request;
- int paramLen;
- char param[LYNQ_REQUEST_PARAM_BUF];
-}lynq_client_t;
typedef struct
{
int used;
@@ -71,175 +65,28 @@
char addr[LYNQ_PHONE_NUMBER_MAX];
}lynq_call_list_t;
-lynq_call_list_e_t lynq_call_lists[LYNQ_CALL_MAX]={};
+static lynq_call_list_e_t s_call_lists[LYNQ_CALL_MAX]={};
+static bool s_call_list_loop = 0;
+static pthread_t s_call_list_loop_tid = -1;
+static pthread_mutex_t s_notice_get_call_list_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_notice_get_call_list_cond = PTHREAD_COND_INITIALIZER;
+
+static int s_module_isDial = 0;
static pthread_mutex_t call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t call_state_change_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t *s_urc_call_state_change_mutex = NULL;
-static pthread_cond_t *s_urc_call_state_change_cond = NULL;
+static int s_IncomingCallId = 0;
static pthread_mutex_t s_incoming_call_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_incoming_call_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t g_lynq_call_sendto_mutex;
-pthread_t lynq_call_urc_tid = -1;
-pthread_t lynq_call_list_loop_tid = -1;
-/*lei add*/
-/* socket文件描述符 */
-int len_addr_serv;
-struct sockaddr_in addr_serv;
-lynq_client_t client_t;
-int client_size = 0;
-/*lei add*/
+static int s_module_call_state =CALL_OFF;
+static int s_call_auto_answer = 0;
-int s_call_urc_event_complete = 0;
-
-enum{
- CALL_OFF=0,
- CALL_ON=1
-}call_state;
-typedef enum{
- LYNQ_E_CARDSTATE_ERROR=8000,
- /* The voice service state is out of service*/
- LYNQ_E_STATE_OUT_OF_SERVICE=8001,
- /* The voice service state is EMERGENCY_ONLY*/
- LYNQ_E_STATE_EMERGENCY_ONLY=8002,
- /* The radio power is power off*/
- LYNQ_E_STATE_POWER_OFF=8003,
- LYNQ_E_TIME_OUT=8004,
- /*create or open sms DB fail */
- LYNQ_E_SMS_DB_FAIL=8005,
- /*Failed to execute sql statement*/
- LYNQ_E_SMS_SQL_FAIL = 8006,
- LYNQ_E_SMS_NOT_FIND = 8007,
- /* The logic conflict*/
- LYNQ_E_CONFLICT=9000,
- /*Null anomaly*/
- LYNQ_E_NULL_ANONALY=9001,
- /*Invalid id anomaly*/
- LYNQ_E_INVALID_ID_ANONALY=9002,
-#ifdef ECALL_SUPPORT
- LYNQ_E_ECALL_BEING_RUNNING =9003,
- LYNQ_E_ECALL_MSD_LENGTH_ERROR =9004,
- LYNQ_E_ECALL_DAILING_NO_ANSWER =9005,
-#endif
-}LYNQ_E;
typedef enum{
LYNQ_E_VOLUMN_SET_DTMF,
LYNQ_E_VOLUMN_SET_SPEECH
-}LYNQ_E_VOLUMN_SET;
+}LYNQ_E_VOLUMN_SET;
-int lynq_call_state =CALL_OFF;
-int lynq_call_client_sockfd = 0;
-int Global_uToken_call = 0;
-int global_call_count =0;
-int global_call_auto_answer = 0;
-bool urc_call_recive_status = 1;
-bool call_list_loop = 0;
-int isDial = 0;
-int lynqIncomingCallId = 0;
-
-/*rtp begin*/
-typedef struct
-{
- char ip[MAX_IP_LENGTH];
- int port;
- char vlan_info[MAX_VLAN_INFO_LENGTH];
-}lynq_rtp_server_info;
-
-typedef struct
-{
- int port;
- int clockrate;
- int latency;
- int channels;
-}lynq_rtp_client_info;
-
-static lynq_rtp_client_info g_rtp_client_info;
-static lynq_rtp_server_info g_rtp_server_info;
-
-static pthread_t g_rtp_thread[RTP_MODE_MAX];
-static bool g_rtp_thread_valid[RTP_MODE_MAX];
-
-/*rtp end*/
-
-#ifdef ECALL_SUPPORT
-int lynq_set_common_request(int request_id, int argc, const char* format,...);
-int g_ecallId = INVALID_ID;
-typedef enum{
- LYNQ_ECALL_TYPE_TEST = 0, /* Test eCall */
- LYNQ_ECALL_TYPE_RECONFIG = 1, /* Reconfiguration eCall */
- LYNQ_ECALL_MANUAL_EMERGENCY = 2, /*Manual Emergency eCall */
- LYNQ_ECALL_TYPE_AUTO_EMERGENCY = 3, /* Automatic Emergency eCall */
-}LYNQ_ECall_Type;
-
-typedef enum{
- LYNQ_ECALL_DAILING_STATE_NONE =0,
- LYNQ_ECALL_DAILING_STATE_STARTED = 1,
- LYNQ_ECALL_DAILING_STATE_ANSWERED = 2,
-}LYNQ_ECall_Dailing_State;
-
-LYNQ_ECall_Dailing_State is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
-char e_call_addr[LYNQ_ECALL_VAR_MAX][LYNQ_PHONE_NUMBER_MAX]={"test_ecall","emergency_ecall","reconf_ecall"};
-
-static pthread_mutex_t s_incoming_e_call_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t s_incoming_e_call_cond = PTHREAD_COND_INITIALIZER;
-static pthread_mutex_t s_ecall_variable_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-LYNQ_ECall_Indication g_lynqIncomingEcallIndication;
-int g_lynqIncomingEcallId=INVALID_ID;
-LYNQ_ECall_Variant g_lynqEcallVariant=LYNQ_ECALL_VAR_NONE;
-int g_ecall_whether_preempt=0;
-
-void sendSignalIncomingECallEvent()
-{
- LYINFLOG("send incoming ecall event signal");
- pthread_mutex_lock(&s_incoming_e_call_mutex);
- pthread_cond_signal(&s_incoming_e_call_cond);
- pthread_mutex_unlock(&s_incoming_e_call_mutex);
-}
-
-int lynq_is_msd_suc(LYNQ_ECall_Indication lynqIncomingEcallIndication)
-{
- if(LYNQ_ECALL_LLACK_RECEIVED == lynqIncomingEcallIndication ||
- LYNQ_ECALL_ALACK_POSITIVE_RECEIVED == lynqIncomingEcallIndication ||
- LYNQ_ECALL_ALACK_CLEARDOWN_RECEIVED == lynqIncomingEcallIndication ||
- //LYNQ_ECALL_T5_TIMER_OUT == lynqIncomingEcallIndication ||
- LYNQ_ECALL_T6_TIMER_OUT == lynqIncomingEcallIndication ||
- LYNQ_ECALL_T7_TIMER_OUT == lynqIncomingEcallIndication)
- {
- return 1;
- }
-
- return 0;
-}
-
-int lynq_ecall_is_running()
-{
- return (is_ecall_dial!=LYNQ_ECALL_DAILING_STATE_NONE) || (g_ecallId !=INVALID_ID || g_lynqEcallVariant == LYNQ_ECALL_CALLBACK);
-}
-
-void print_ecall_info()
-{
- LYERRLOG("%s is ecall dial is %d, ecall id is %d, ecall vairant is %d, incoming ecall ind is %d, incoming ecall id is %d, whether preempt is %d",__func__,is_ecall_dial,g_ecallId,g_lynqEcallVariant,g_lynqIncomingEcallIndication,g_lynqIncomingEcallId,g_ecall_whether_preempt);
-}
-
-int lynq_ecall_is_permit_in_call(int ecall_id)
-{
- return g_lynqEcallVariant == LYNQ_ECALL_CALLBACK && (g_ecallId ==INVALID_ID || g_ecallId ==ecall_id);
-}
-
-int lynq_ecall_is_in_voice()
-{
- return (is_ecall_dial==LYNQ_ECALL_DAILING_STATE_NONE) && (g_ecallId !=INVALID_ID);
-}
-#endif
-
-/**
- * @brief mark call initialization state
- * 0: deinit state
- * 1: init state
- */
-int g_lynq_call_init_flag = 0;
-
+#if 0
int JumpHeader(Parcel &p,int *resp_type,int* token,int *request,int *slot_id,int *error)
{
if(p.dataAvail() > 0)
@@ -286,15 +133,91 @@
}
return 0;
}
-static char *strdupReadString(Parcel &p) {
+#endif
+static char *strdupReadString(Parcel* &p) {
size_t stringlen;
const char16_t *s16;
- s16 = p.readString16Inplace(&stringlen);
+ s16 = p->readString16Inplace(&stringlen);
return strndup16to8(s16, stringlen);
}
int lynq_get_current_call_list(lynq_call_list_t call_list[LYNQ_CALL_MAX])
{
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,8,RIL_REQUEST_GET_CURRENT_CALLS,0,"");
+ if(ret!=0)
+ {
+ return ret;
+ }
+
+ int call_num = 0;
+ int temp = 0;
+ char *remote_phoneNum;
+ char *remote_name;
+ char uusData[128];
+
+ p->readInt32(&call_num);
+
+ if(call_num<=0)
+ {
+ s_module_call_state = CALL_OFF;
+ LYINFLOG("lynq_call_state:%d",s_module_call_state);
+ delete p;
+ return RESULT_OK;
+ }
+ s_module_call_state = CALL_ON;
+ LYINFLOG("lynq_call_state:%d, call num is %d ",s_module_call_state,call_num);
+ for(int i = 0;i < call_num;i++)
+ {
+ p->readInt32(&temp);
+ call_list[i].call_state = temp;
+ p->readInt32(&call_list[i].call_id);
+ p->readInt32(&call_list[i].toa);
+ p->readInt32(&temp);
+ p->readInt32(&temp);
+ call_list[i].direction = temp;
+ p->readInt32(&temp);
+ p->readInt32(&temp);
+ p->readInt32(&temp);
+ remote_phoneNum = strdupReadString(p);
+ memcpy(call_list[i].addr,remote_phoneNum,strlen(remote_phoneNum));
+ if(remote_phoneNum !=NULL)
+ {
+ free(remote_phoneNum);
+ }
+ LYINFLOG("call_id=%d,call_state=%d,direction=%d,addr=%s,toa=%d",call_list[i].call_id,call_list[i].call_state,
+ call_list[i].direction,call_list[i].addr,call_list[i].toa);
+ p->readInt32(&temp);
+ remote_name = strdupReadString(p);
+ if(remote_name !=NULL)
+ {
+ free(remote_name);
+ }
+ p->readInt32(&temp);
+ p->readInt32(&temp);
+ if(temp==0)
+ {
+ continue;
+ }
+ p->readInt32(&temp); /* UUS Information is present */
+ p->readInt32(&temp);
+ p->readInt32(&temp);
+ if(temp<=128)
+ {
+ p->read(uusData,temp);
+ }
+ else
+ {
+ LYERRLOG("%s len %d is too great",__func__,temp);
+ delete p;
+ return LYNQ_E_MALLOC_ERROR;
+ }
+ }
+
+ delete p;
+ return RESULT_OK;
+
+#if 0
Parcel p;
lynq_client_t client;
int resp_type = -1;
@@ -360,40 +283,40 @@
p.readInt32(&temp);
p.readInt32(&temp);
p.read(uusData,temp);
- free(remote_phoneNum);
- free(remote_name);
}
}
return 0;
+#endif
}
void cleanCallList(int lynq_call_id)
{
- LYINFLOG("cleanCall local idx is %d, id is %d",lynq_call_id,lynq_call_lists[lynq_call_id].call_id);
- lynq_call_lists[lynq_call_id].call_id = 0;
- lynq_call_lists[lynq_call_id].call_state = (int)LYNQ_CALL_END;
- lynq_call_lists[lynq_call_id].toa = 0;
- lynq_call_lists[lynq_call_id].direction = 0;
- lynq_call_lists[lynq_call_id].used = 0;
- memset(lynq_call_lists[lynq_call_id].addr,0,sizeof(lynq_call_lists[lynq_call_id].addr));
+ LYINFLOG("cleanCall local idx is %d, id is %d",lynq_call_id,s_call_lists[lynq_call_id].call_id);
+ s_call_lists[lynq_call_id].call_id = 0;
+ s_call_lists[lynq_call_id].call_state = (int)LYNQ_CALL_END;
+ s_call_lists[lynq_call_id].toa = 0;
+ s_call_lists[lynq_call_id].direction = 0;
+ s_call_lists[lynq_call_id].used = 0;
+ memset(s_call_lists[lynq_call_id].addr,0,sizeof(s_call_lists[lynq_call_id].addr));
}
int getUnusedElement()
{
for(int i=0;i < LYNQ_CALL_MAX; i++)
{
- if(lynq_call_lists[i].used!=1)
+ if(s_call_lists[i].used!=1)
{
return i;
}
}
- return -1;
+ return INVALID_ID;
}
-int addAddr(char addr[])
+int addAddr(char addr[], int call_id)
{
int ret = 0;
ret = getUnusedElement();
- memcpy(lynq_call_lists[ret].addr,addr,strlen(addr)+1);
- lynq_call_lists[ret].used = 1;
+ memcpy(s_call_lists[ret].addr,addr,strlen(addr)+1);
+ s_call_lists[ret].call_id=call_id;
+ s_call_lists[ret].used = 1;
LYINFLOG("add local idx is %d addr is %s",ret,addr);
return ret;
}
@@ -406,24 +329,6 @@
callList->direction = direction;
return;
}
-int waitCallstateChange(int mtime)
-{
- LYINFLOG("wait Call state Change");
- int ret = 0;
- int sec = 0;
- int usec = 0;
- struct timeval now;
- struct timespec timeout;
- gettimeofday(&now,NULL);
- sec = mtime/1000;
- usec = mtime%1000;
- timeout.tv_sec = now.tv_sec+sec;
- timeout.tv_nsec = now.tv_usec*1000+usec*1000000;
- pthread_mutex_lock(&call_state_change_mutex);
- ret = pthread_cond_timedwait(&call_state_change_cond,&call_state_change_mutex,&timeout);
- pthread_mutex_unlock(&call_state_change_mutex);
- return ret;
-}
int waitIncomingCall()
{
LYINFLOG("wait incming call");
@@ -437,35 +342,35 @@
{
for(int i = 0;i<LYNQ_CALL_MAX;i++)
{
- if(strcmp(lynq_call_lists[i].addr,addr)==0)
+ if(strcmp(s_call_lists[i].addr,addr)==0)
{
- LYINFLOG("checkHasCall addr is %s idx is %d id is %d",addr,i,lynq_call_lists[i].call_id);
- return 1;
+ LYINFLOG("checkHasCall addr is %s idx is %d id is %d",addr,i,s_call_lists[i].call_id);
+ return true;
}
}
LYINFLOG("checkHasCall addr is %s , no idx is found",addr);
- return 0;
+ return false;
}
int find_call_id_with_addr(char *addr)
{
for(int id = 0; id < LYNQ_CALL_MAX; id++)
{
- if(lynq_call_lists[id].used && (strcmp(lynq_call_lists[id].addr,addr) == 0))
+ if(s_call_lists[id].used && (strcmp(s_call_lists[id].addr,addr) == 0))
{
- LYINFLOG("find addr %s in local list, local idx is %d id is %d",addr,id,lynq_call_lists[id].call_id);
+ LYINFLOG("find addr %s in local list, local idx is %d id is %d",addr,id,s_call_lists[id].call_id);
return id;
}
}
LYINFLOG("find addr %s in local list , not found",addr);
- return -1;
+ return INVALID_ID;
}
int find_call_id_with_call_id(int call_id)
{
for(int id = 0; id < LYNQ_CALL_MAX; id++)
{
- if(lynq_call_lists[id].used && (lynq_call_lists[id].call_id == call_id))
+ if(s_call_lists[id].used && (s_call_lists[id].call_id == call_id))
{
- LYINFLOG("find id %d in local list, local idx is %d, addr is %s",call_id,id,lynq_call_lists[id].addr);
+ LYINFLOG("find id %d in local list, local idx is %d, addr is %s",call_id,id,s_call_lists[id].addr);
return id;
}
}
@@ -487,17 +392,10 @@
pthread_mutex_unlock(&s_incoming_call_mutex);
}
-void addCallListToLynqCallList(lynq_call_list_e_t *callList, int call_id,int call_state,int toa,int direction,char addr[LYNQ_PHONE_NUMBER_MAX])
+void cleanup_call_list_mutex(void *arg)
{
- callList->call_id = call_id;
- callList->call_state = call_state;
- callList->toa = toa;
- callList->direction = direction;
- memcpy(callList->addr,addr,strlen(addr)+1);
- callList->used = 1;
- return;
+ pthread_mutex_unlock(&s_notice_get_call_list_mutex);
}
-
void *triggerGetCallList(void *parg)
{
int ret=0;
@@ -509,18 +407,18 @@
#ifdef ECALL_SUPPORT
int handupIncomingMT=0;
#endif
-
- while(call_list_loop)
+ pthread_mutex_lock(&s_notice_get_call_list_mutex);
+ pthread_cleanup_push(cleanup_call_list_mutex, NULL); // thread cleanup handler
+ while(s_call_list_loop)
{
- update=0;
- pthread_mutex_lock(s_urc_call_state_change_mutex);
- pthread_cond_wait(s_urc_call_state_change_cond, s_urc_call_state_change_mutex);
+ update=0;
+ pthread_cond_wait(&s_notice_get_call_list_cond, &s_notice_get_call_list_mutex);
LYDBGLOG("triggerGetCallList event!!!");
memset(call_list,0,sizeof(call_list));
ret = lynq_get_current_call_list(call_list);
- if(ret != 0)
+ if(ret != RESULT_OK)
{
- LYDBGLOG("get current call list failure!!!");
+ LYDBGLOG("get current call list failure!!!");
continue;
}
LYINFLOG("++++++++++++++triggerGetCallList++++++++++++++");
@@ -528,28 +426,28 @@
cnt=0;
for(i = 0;i < LYNQ_CALL_MAX;i++)
{
- if(lynq_call_lists[i].used ==0)
+ if(s_call_lists[i].used ==0)
{
continue;
}
cnt++;
- LYINFLOG("local idx is %d id is %d addr is %s state is %d direction is %d",i,lynq_call_lists[i].call_id,lynq_call_lists[i].addr,lynq_call_lists[i].call_state,lynq_call_lists[i].direction);
+ LYINFLOG("local idx is %d id is %d addr is %s state is %d direction is %d",i,s_call_lists[i].call_id,s_call_lists[i].addr,s_call_lists[i].call_state,s_call_lists[i].direction);
- if(lynq_call_lists[i].call_id > 0)
+ if(s_call_lists[i].call_id > 0)
{
call_end = 0;
for(n = 0; n < LYNQ_CALL_MAX; n++)
{
- if(call_list[n].call_id == lynq_call_lists[i].call_id)
+ if(call_list[n].call_id == s_call_lists[i].call_id)
{
call_end = 1;
- LYINFLOG("find lynq call local idx %d, service idx %d id is %d!!!",i,n,lynq_call_lists[i].call_id);
+ LYINFLOG("find lynq call local idx %d, service idx %d id is %d!!!",i,n,s_call_lists[i].call_id);
break;
}
}
if(call_end == 0)
{
- LYINFLOG("MT hungup,then clean call info local idx is %d id is %d",i, lynq_call_lists[i].call_id);
+ LYINFLOG("MT hungup,then clean call info local idx is %d id is %d",i, s_call_lists[i].call_id);
cleanCallList(i);
}
} //fix bug API-54
@@ -581,10 +479,7 @@
#ifdef ECALL_SUPPORT
if((call_list[i].call_state ==4) || (call_list[i].call_state ==5))
{
-
- pthread_mutex_lock(&s_ecall_variable_mutex);
- handupIncomingMT=lynq_ecall_is_running() && (lynq_ecall_is_permit_in_call(call_list[i].call_id)==false);
- pthread_mutex_unlock(&s_ecall_variable_mutex);
+ handupIncomingMT=Is_handup_IncomingMT(call_list[i].call_id);
LYINFLOG("handupIncomingMT is %d",handupIncomingMT);
if(handupIncomingMT)
{
@@ -597,12 +492,12 @@
n = find_call_id_with_addr(call_list[i].addr);
if(n ==INVALID_ID)
{
- n = addAddr(call_list[i].addr);
- updateCallList(&lynq_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
- lynqIncomingCallId = call_list[i].call_id;
+ n = addAddr(call_list[i].addr,call_list[i].call_id);
+ updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
+ s_IncomingCallId = call_list[i].call_id;
sendSignalIncomingCall();
}
- else if(lynq_call_lists[n].call_state == call_list[i].call_state)
+ else if(s_call_lists[n].call_state == call_list[i].call_state)
{
LYINFLOG("state not changed, state is %d ",call_list[i].call_state);
if(call_list[i].call_state ==4 || call_list[i].call_state ==5)
@@ -617,9 +512,9 @@
}
else
{
- LYINFLOG("state changed from %d to %d",lynq_call_lists[n].call_state,call_list[i].call_state);
+ LYINFLOG("state changed from %d to %d",s_call_lists[n].call_state,call_list[i].call_state);
- updateCallList(&lynq_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
+ updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
}
}
else
@@ -628,15 +523,15 @@
call_end = 0;
for(n = 0 ; n < LYNQ_CALL_MAX; n++)
{
- if(lynq_call_lists[n].used && ((strcmp(call_list[i].addr,lynq_call_lists[n].addr)==0)||(call_list[i].call_id==lynq_call_lists[n].call_id)))
+ if(s_call_lists[n].used && ((strcmp(call_list[i].addr,s_call_lists[n].addr)==0)||(call_list[i].call_id==s_call_lists[n].call_id)))
{
- if(lynq_call_lists[n].call_id==0)
+ if(s_call_lists[n].call_id==0)
{
LYINFLOG("add a call id");
update=1;
}
- LYINFLOG("local idx %d updated, original call id is %d origial addr is %s original state is %d",n,lynq_call_lists[n].call_id,lynq_call_lists[n].addr,lynq_call_lists[n].call_state);
- updateCallList(&lynq_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
+ LYINFLOG("local idx %d updated, original call id is %d origial addr is %s original state is %d",n,s_call_lists[n].call_id,s_call_lists[n].addr,s_call_lists[n].call_state);
+ updateCallList(&s_call_lists[n],call_list[i].call_id,call_list[i].call_state,call_list[i].toa,call_list[i].direction);
call_end = 1;
break;
}
@@ -646,7 +541,7 @@
{
LYINFLOG("need to hangup id %d", call_list[i].call_id);
#ifdef ECALL_SUPPORT
- if(is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
+ if(IsECallDialing())
{
LYINFLOG("ecall is dialing, for the timebeing, don't huangup");
continue;
@@ -658,16 +553,15 @@
}
LYDBGLOG("servie idx %d end",i);
}
- LYINFLOG("add or update local index end ");
- s_call_urc_event_complete = 1;
- if(isDial==1)
+ LYINFLOG("add or update local index end ");
+ if(s_module_isDial==1)
{
LYINFLOG("now is dialing");
if(update==1)
{
LYINFLOG("find added call");
sendSignalToWaitCallStateChange();
- isDial = 0;
+ s_module_isDial = 0;
}
else
{
@@ -677,24 +571,22 @@
else
{
LYINFLOG("now is not dialing");
- }
- pthread_mutex_unlock(s_urc_call_state_change_mutex);
+ }
}
+ pthread_cleanup_pop(0);
+ pthread_mutex_unlock(&s_notice_get_call_list_mutex);
return NULL;
}
-void lynqRespWatingEvent()
+void lynqNoticeGetModuleCallList()
{
- if(s_call_urc_event_complete==1)
- {
- pthread_mutex_lock(s_urc_call_state_change_mutex);
- pthread_cond_signal(s_urc_call_state_change_cond);
- s_call_urc_event_complete = 0;
- pthread_mutex_unlock(s_urc_call_state_change_mutex);
- }
- return;
+ pthread_mutex_lock(&s_notice_get_call_list_mutex);
+ pthread_cond_signal(&s_notice_get_call_list_cond);
+ pthread_mutex_unlock(&s_notice_get_call_list_mutex);
+
}
+#if 0
/*Warren add for T800 platform 2021/11/19 start*/
int lynq_socket_client_start()
{
@@ -741,236 +633,7 @@
len_addr_serv = sizeof(addr_serv);
return 0;
}
-int lynq_update_call_list_loop()
-{
- int ret = 0;
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&lynq_call_list_loop_tid,&attr,triggerGetCallList,NULL);
- if(ret < 0)
- {
- LYERRLOG("lynq_update_call_list_loop fail!!!");
- return -1;
- }
- LYDBGLOG("lynq_update_call_list_loop success!!!");
- return 0;
-}
-
-void *thread_urc_recv(void *parg)
-{
- int socket_fd = (int64_t)parg;
- int len=0;
- socklen_t addr_len=0;
- uint8_t *dataLength = NULL;
- char urc_data[LYNQ_REC_BUF];
- int slot_id = -1;
- int resp_type = -1;
- int urcid = -1;
- Parcel *p = NULL;
- struct sockaddr_in dest_addr;
-#ifdef ECALL_SUPPORT
- int ecall_ind;
- int ecallId;
- int unused_callid;
- int send_signal_to_wait_call_state;
- int handup_ecall_id;
-#endif
-
- LYINFLOG("thread_urc_recv in running....");
- while(urc_call_recive_status)
- {
- bzero(urc_data,LYNQ_REC_BUF);
- //get data msg
- len = recvfrom(socket_fd,urc_data,LYNQ_REC_BUF,0,(struct sockaddr *)&dest_addr,&addr_len);
- if(len <= 0)
- {
- LYERRLOG("thread_urc_recv step2 fail");
- break;
- }
- LYDBGLOG("=====>urc data len<=====:%d",len);
- p = new Parcel();
- if(p==NULL)
- {
- LYERRLOG("new parcel failure!!!");
- break;
- }
- p->setData((uint8_t *)urc_data,len); // p.setData((uint8_t *) buffer, buflen);
- p->setDataPosition(0);
- if(p->dataAvail() > 0)
- {
- p->readInt32(&resp_type);
- p->readInt32(&urcid);
- p->readInt32(&slot_id);
- //LYDBGLOG("*******Warren test*******:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
- switch (urcid)
- {
- case 1001://RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED
- {
- LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
- lynqRespWatingEvent();
- break;
- }
- case 1018://RIL_UNSOL_CALL_RING
- {
- if(global_call_auto_answer==1)
- {
- lynq_call_answer();
- }
- break;
- }
- case 1029://RIL_UNSOL_RINGBACK_TONE
- case 3049://RIL_UNSOL_CALL_INFO_INDICATION
- {
- LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
- break;
- }
-#ifdef ECALL_SUPPORT
- case RIL_UNSOL_ECALL_INDICATIONS:
- {
- pthread_mutex_lock(&s_ecall_variable_mutex);
- send_signal_to_wait_call_state = false;
- handup_ecall_id=false;
- p->readInt32(&ecall_ind);
- g_lynqIncomingEcallIndication = ecall_ind;
- p->readInt32(&ecallId);
- g_lynqIncomingEcallId = ecallId;
- LYINFLOG("**************:RIL_UNSOL_ECALL_INDICATIONS ,Id %d, ind %d, ecall dialing is %d, normal dialing is %d, local ecall id is %d",ecallId,ecall_ind,is_ecall_dial,isDial,g_ecallId);
- switch (g_lynqIncomingEcallIndication)
- {
- case LYNQ_ECALL_ACTIVE:
- if(is_ecall_dial)
- {
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_ANSWERED;
- }
- break;
- case LYNQ_ECALL_SENDING_START:
- if(lynq_ecall_is_in_voice())
- {
- LYINFLOG("recv msd in voice, ind is changed to %d",LYNQ_ECALL_SENDING_START_IN_VOICE);
- g_lynqIncomingEcallIndication = LYNQ_ECALL_SENDING_START_IN_VOICE;
- }
- break;
- case LYNQ_ECALL_LLACK_RECEIVED:
- case LYNQ_ECALL_ALACK_POSITIVE_RECEIVED:
- case LYNQ_ECALL_ALACK_CLEARDOWN_RECEIVED:
- //case LYNQ_ECALL_T5_TIMER_OUT: /*when Certificate CP 1.1.10.2, no msd start (ind 1), so T5 timeout is not regard as success*/
- case LYNQ_ECALL_T6_TIMER_OUT:
- case LYNQ_ECALL_T7_TIMER_OUT:
- if(is_ecall_dial)
- {
- LYINFLOG("ecall is dialing, recv suc indication");
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
- if(ecallId >0 && find_call_id_with_call_id(ecallId)==INVALID_ID)
- {
- LYINFLOG("add ecall in loacl list");
- g_ecallId = ecallId;
- unused_callid=addAddr("ecall");
- lynq_call_lists[unused_callid].call_id=g_ecallId;
- }
- send_signal_to_wait_call_state=true;
- }
- else if(ecallId >0 && (find_call_id_with_call_id(ecallId)==INVALID_ID) && (g_lynqEcallVariant != LYNQ_ECALL_CALLBACK))
- {
- LYERRLOG("ecall is not in dialing and first recv suc indication, hangup");
- handup_ecall_id=true;
- }
- else
- {
- LYERRLOG("ecall is not in dialing and not first recv suc indication");
- }
- break;
- case LYNQ_ECALL_PSAP_CALLBACK_START:
- if(lynq_ecall_is_running()==0)
- {
- if(ecallId>0)
- {
- LYINFLOG("ecall is not running, recv psap call back msd start, set ecall running");
- g_lynqEcallVariant = LYNQ_ECALL_CALLBACK;
- g_ecallId = ecallId;
- if(isDial)
- {
- LYINFLOG("stop normal dial");
- send_signal_to_wait_call_state=true;
- }
- else
- {
- LYINFLOG("no normal dial");
- }
- }
- else
- {
- LYERRLOG("ecallId is abnormal in psap callback");
- }
- }
- else
- {
- LYERRLOG("ecall is running, recv psap call back msd start");
- }
- break;
- case LYNQ_ECALL_ABNORMAL_HANGUP:
- if(is_ecall_dial == LYNQ_ECALL_DAILING_STATE_NONE)
- {
- LYERRLOG("ecall is not in dialing , recv abnormal hangup");
- g_ecallId = INVALID_ID;
- }
- else if (is_ecall_dial == LYNQ_ECALL_DAILING_STATE_STARTED)
- {
- LYERRLOG("ecall is in dialing state, recv no answer, recv abnormal hangup, dont' redial");
- g_ecallId = INVALID_ID;
- send_signal_to_wait_call_state=true;
- }
- else {
- LYINFLOG("ecall is in dialing and recv answer, recv abnormal hangup");
- }
- break;
- case LYNQ_ECALL_DISCONNECTED:
- case LYNQ_ECALL_REDIAL_TIMER_OUT:
- case LYNQ_ECALL_T2_TIMER_OUT :
- case LYNQ_ECALL_IMS_DISCONNECTED:
- g_ecallId = INVALID_ID;
- if(g_lynqEcallVariant == LYNQ_ECALL_CALLBACK)
- {
- g_lynqEcallVariant = LYNQ_ECALL_VAR_NONE; /*other type, needn't re-initialize*/
- }
- if(is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
- {
- LYERRLOG("ecall is in dialing, recv like disconnect indication");
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
- send_signal_to_wait_call_state=true;
- }
- else
- {
- LYINFLOG("ecall is not in dialing, recv like disconnect indication");
- }
- break;
- default:
- LYINFLOG("not special indication");
- }
- pthread_mutex_unlock(&s_ecall_variable_mutex);
- if(send_signal_to_wait_call_state)
- {
- sendSignalToWaitCallStateChange();
- }
- sendSignalIncomingECallEvent();
- if(handup_ecall_id)
- {
- lynq_call_hungup(&ecallId);
- }
- LYINFLOG("**************:RIL_UNSOL_ECALL_INDICATIONS, local ecall id is %d", g_ecallId);
- break;
- }
-#endif
- default:
- break;
- }
- }
- delete p;
- p = NULL;
- }
- close(socket_fd);
-}
int lynq_socket_urc_start()
{
int socket_fd=0;
@@ -1012,131 +675,134 @@
LYDBGLOG("urc loop success!!!");
return 0;
}
-int getSelfElement(char addr[])
-{
- for(int i=0;i < LYNQ_CALL_MAX; i++)
- {
- if(lynq_call_lists[i].used==1)
- {
- if(strcmp(lynq_call_lists[i].addr,addr)==0)
- {
- return i;
- }
-
- }
- }
- return -1;
-}
+#endif
void lynq_call_state_change_test(int soc_id)
{
LYDBGLOG("call state change,sim:%d",soc_id);
}
-void lynq_init_rtp()
-{
- memset(&g_rtp_client_info,0,sizeof(g_rtp_client_info));
- memset(&g_rtp_server_info,0,sizeof(g_rtp_server_info));
-
+int lynq_start_call_list_loop()
+{
+#if 0
+ int ret = 0;
+ pthread_attr_t attr;
+ pthread_attr_init(&attr);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- lynq_set_rtp_param(8000,1,400);
+ s_notice_get_call_list_mutex = new pthread_mutex_t;
+ pthread_mutex_init(s_notice_get_call_list_mutex, NULL);
+ s_notice_get_call_list_cond = new pthread_cond_t;
+ LYINFLOG("liulei s_notice_get_call_list_mutex\n");
+ pthread_cond_init(s_notice_get_call_list_cond, NULL);
+ LYINFLOG("liulei s_notice_get_call_list_cond\n");
+#endif
- for(int i=0;i<RTP_MODE_MAX;i++)
+ s_call_list_loop = 1;
+ int ret = pthread_create(&s_call_list_loop_tid,/*&attr*/NULL,triggerGetCallList,NULL);
+ if(ret < 0)
{
- lynq_set_rtp_port(i,6666);
- g_rtp_thread_valid[i] = 0;
- }
-
- LYDBGLOG("lynq init rtp success!!!");
- return;
-}
-
-int lynq_init_call(int uToken)
-{
- if(g_lynq_call_init_flag == 1){
- LYDBGLOG("lynq init call failed!!!");
+ LYERRLOG("lynq_update_call_list_loop fail!!!");
return -1;
}
- g_lynq_call_init_flag = 1;
- s_call_urc_event_complete = 1;
- call_list_loop = 1;
- LYINFLOG("liulei call_list_loop %d\n", call_list_loop);
- s_urc_call_state_change_mutex = new pthread_mutex_t;
- pthread_mutex_init(s_urc_call_state_change_mutex, NULL);
- s_urc_call_state_change_cond = new pthread_cond_t;
- LYINFLOG("liulei s_urc_call_state_change_mutex\n");
- pthread_cond_init(s_urc_call_state_change_cond, NULL);
- LYINFLOG("liulei s_urc_call_state_change_cond\n");
- int result = 0;
- Global_uToken_call = uToken;
- urc_call_recive_status = 1;
- client_size = sizeof(client_t);
- LYLOGSET(LOG_INFO);
- LYLOGEINIT(USER_LOG_TAG);
- result = lynq_socket_client_start();
- if(result!=0)
- {
- return -1;
- }
- result = lynq_socket_urc_start();
- if(result!=0)
- {
- return -1;
- }
- result = lynq_update_call_list_loop();
- if(result!=0)
- {
- return -1;
- }
- memset(lynq_call_lists,0,sizeof(lynq_call_lists));
+ LYINFLOG("lynq_update_call_list_loop success!!!");
- lynq_init_rtp();
-
- LYDBGLOG("lynq init call success!!!");
+ memset(s_call_lists,0,sizeof(s_call_lists));
return 0;
}
-int lynq_deinit_call()
+
+int lynq_stop_call_list_loop()
{
int ret;
- if(g_lynq_call_init_flag == 0)
- {
- LYDBGLOG("lynq_deinit_call failed!!!");
- return -1;
- }
- else
- {
- g_lynq_call_init_flag = 0;
- lynq_call_hungup_all();
- if(lynq_call_client_sockfd>0)
- {
- close(lynq_call_client_sockfd);
- }
- urc_call_recive_status = 0;
- call_list_loop = 0;
- lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
- if(lynq_call_urc_tid == -1 || lynq_call_list_loop_tid == -1)
- {
- return -1;
- }
- ret = pthread_cancel(lynq_call_urc_tid);
- LYDBGLOG("pthread cancel ret = %d",ret);
- ret = pthread_cancel(lynq_call_list_loop_tid);
- LYDBGLOG("pthread cancel ret = %d",ret);
- ret = pthread_join(lynq_call_urc_tid,NULL);
- LYDBGLOG("pthread join ret = %d",ret);
- ret = pthread_join(lynq_call_list_loop_tid,NULL);
- LYDBGLOG("pthread join ret = %d",ret);
- pthread_mutex_destroy(s_urc_call_state_change_mutex);
- pthread_cond_destroy(s_urc_call_state_change_cond);
- delete s_urc_call_state_change_mutex;
- //s_urc_call_state_change_mutex = NULL;
- delete s_urc_call_state_change_cond;
- //s_urc_call_state_change_cond = NULL;
-
- return 0;
- }
+ pthread_mutex_lock(&s_notice_get_call_list_mutex);
+ s_call_list_loop = 0;
+ ret = pthread_cancel(s_call_list_loop_tid);
+ LYINFLOG("pthread cancel w_c_list ret = %d",ret);
+ pthread_mutex_unlock(&s_notice_get_call_list_mutex);
+ ret = pthread_join(s_call_list_loop_tid,NULL);
+ LYINFLOG("pthread join w_c_list ret = %d",ret);
+ s_call_list_loop_tid=-1;
+#if 0
+ pthread_mutex_destroy(s_notice_get_call_list_mutex);
+ pthread_cond_destroy(s_notice_get_call_list_cond);
+ delete s_notice_get_call_list_mutex;
+ //s_notice_get_call_list_mutex = NULL;
+ delete s_notice_get_call_list_cond;
+ //s_notice_get_call_list_cond = NULL;
+#endif
+
+ return 0;
}
+int lynq_init_call(int utoken){
+ if(g_module_init_flag != MODULE_CLOSED)
+ {
+ LYERRLOG("module state is %d",g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ if(utoken <0){
+ LYERRLOG("utoken is less than 0",utoken);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ g_module_init_flag = MODULE_SWITCHING;
+
+ LYLOGSET(LOG_INFO);
+ LYLOGEINIT(USER_LOG_TAG);
+
+ g_module_Global_uToken = utoken;
+
+ int ret = lynq_urc_socket_start();
+ if(ret != RESULT_OK)
+ {
+ LYERRLOG("init socket urc fail!!!");
+ g_module_init_flag = MODULE_CLOSED;
+ return LYNQ_E_INNER_ERROR;
+ }
+
+ ret = lynq_server_socket_start();
+ if(ret !=RESULT_OK)
+ {
+ LYERRLOG("init socket client fail!!!");
+ lynq_close_urc_thread();
+ g_module_init_flag = MODULE_CLOSED;
+ return LYNQ_E_INNER_ERROR;
+ }
+
+
+ int result = lynq_start_call_list_loop();
+ if(ret != RESULT_OK)
+ {
+ LYERRLOG("lynq_start_call_list_loop fail!!!");
+ lynq_close_urc_thread();
+ lynq_close_rc_thread();
+ g_module_init_flag = MODULE_CLOSED;
+ return LYNQ_E_INNER_ERROR;
+ }
+
+ lynq_init_rtp();
+
+ g_module_init_flag = MODULE_RUNNING;
+ return 0;
+}
+
+int lynq_deinit_call(void){
+
+ if (g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("module state is %d",g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ lynq_call_hungup_all();
+ lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
+ g_module_init_flag = MODULE_SWITCHING;
+ lynq_close_urc_thread();
+ lynq_close_rc_thread();
+ lynq_stop_call_list_loop();
+ g_module_init_flag = MODULE_CLOSED;
+ return 0;
+}
+
+#if 0
int lynq_set_common_request(int request_id, int argc, const char* format,...)
{
Parcel p;
@@ -1147,6 +813,14 @@
int slot_id = -1;
int error = -1;
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(request_id,5,p,argc,format,...);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+
client.uToken = Global_uToken_call;
client.request = request_id;
client.paramLen = argc;
@@ -1170,61 +844,68 @@
LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
}
return error;
+
+
}
+#endif
int lynq_get_common_request(int request_id, int* status)
{
- Parcel p;
- lynq_client_t client;
- int resp_type = -1;
- int token;
- int request = -1;
- int slot_id = -1;
- int error = -1;
if(status==NULL)
{
LYERRLOG("status is null");
- return -1;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- client.uToken = Global_uToken_call;
- client.request = request_id;
- client.paramLen = 0;
- bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
- LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
- if(send_request(lynq_call_client_sockfd,&client)==-1)
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,request_id,0,"");
+ if(ret==RESULT_OK)
{
- LYERRLOG("send request fail");
- return -1;
+ p->readInt32(status);
+ delete p;
}
- if(get_response(lynq_call_client_sockfd,p)==0)
- {
- JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
- p.readInt32(status);
- LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
- }
- return error;
+ return ret;
+}
+
+int waitCallstateChange(int mtime)
+{
+ LYINFLOG("wait Call state Change");
+ int ret = 0;
+ int sec = 0;
+ int usec = 0;
+ struct timeval now;
+ struct timespec timeout;
+ gettimeofday(&now,NULL);
+ sec = mtime/1000;
+ usec = mtime%1000;
+ timeout.tv_sec = now.tv_sec+sec;
+ timeout.tv_nsec = now.tv_usec*1000+usec*1000000;
+ pthread_mutex_lock(&call_state_change_mutex);
+ ret = pthread_cond_timedwait(&call_state_change_cond,&call_state_change_mutex,&timeout);
+ pthread_mutex_unlock(&call_state_change_mutex);
+ return ret;
+}
+
+int IsNormalCallDailing()
+{
+ return s_module_isDial;
}
int lynq_call(int* handle,char addr[])
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
- Parcel p;
- lynq_client_t client;
- int resp_type = -1;
- int token;
- int request = -1;
- int slot_id = -1;
- int error = -1;
+
int lynq_call_id = -1;
LYINFLOG("lynq_call begin addr %s",addr);
if(addr==NULL)
{
LYERRLOG("Phone num is null!!!");
- return -1;
+ return LYNQ_E_PARAMETER_ANONALY;
}
if(find_call_id_with_addr(addr)!=INVALID_ID)
@@ -1240,209 +921,151 @@
return LYNQ_E_ECALL_BEING_RUNNING;
}
#endif
+
+ Parcel* p=NULL;
+ lynq_call_id = addAddr(addr,0);
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_DIAL,2,"%s %d",addr, 0);
+ if(ret!=0)
+ {
+ cleanCallList(lynq_call_id);
+ return ret;
+ }
- client.uToken = Global_uToken_call;
- client.request = 10;//RIL_REQUEST_DIAL
- client.paramLen = 2;
- bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
- memcpy(client.param,addr,strlen(addr)+1);
- strcat(client.param," 0");
- lynq_call_id = addAddr(addr);
- LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
- pthread_mutex_lock(&g_lynq_call_sendto_mutex);
- if(send_request(lynq_call_client_sockfd,&client)==-1)
+ delete p;
+
+ s_module_isDial = 1;
+ if(waitCallstateChange(6000)==ETIMEDOUT)//6000ms
{
- LYERRLOG("send request fail");
- cleanCallList(lynq_call_id);
- return -1;
+ //if timeout,this call need destroy.
+ s_module_isDial = 0;
+ LYERRLOG("lynq_call timeout:wait Call state fail!!! clear local idx %d",lynq_call_id);
+ cleanCallList(lynq_call_id);
+ return LYNQ_E_TIME_OUT;
}
- get_response(lynq_call_client_sockfd,p);
- pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
- JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
- LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
- if(error==0)
+ s_module_isDial = 0;
+ *handle = s_call_lists[lynq_call_id].call_id;
+ if(*handle > 0)
{
- isDial = 1;
- if(waitCallstateChange(6000)==ETIMEDOUT)//6000ms
- {
- //if timeout,this call need destroy.
- isDial = 0;
- error = LYNQ_E_TIME_OUT;
- LYERRLOG("lynq_call timeout:wait Call state fail!!! clear local idx %d",lynq_call_id);
- cleanCallList(lynq_call_id);
- return error;
- }
- isDial = 0;
- *handle = lynq_call_lists[lynq_call_id].call_id;
- if(*handle > 0)
- {
- LYINFLOG("lynq_call dial addr %s suc, id is %d",addr,*handle);
- return 0;
- }
- else
- {
- LYERRLOG("lynq_call dial addr %s fail, invalid id",addr);
- cleanCallList(lynq_call_id);
- return LYNQ_E_INVALID_ID_ANONALY;
- }
-
+ LYINFLOG("lynq_call dial addr %s suc, id is %d",addr,*handle);
+ return RESULT_OK;
}
- LYERRLOG("lynq_call dial addr %s fail, service error %d",addr, error);
- cleanCallList(lynq_call_id);
- return error;
+ else
+ {
+ LYERRLOG("lynq_call dial addr %s fail, invalid id",addr);
+ cleanCallList(lynq_call_id);
+ return LYNQ_E_INVALID_ID_ANONALY;
+ }
}
int lynq_call_answer()
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
- }
- Parcel p;
- lynq_client_t client;
- int resp_type = -1;
- int token;
- int request = -1;
- int slot_id = -1;
- int error = -1;
- client.uToken = Global_uToken_call;
- client.request = 40;//RIL_REQUEST_DIAL
- client.paramLen = 0;
- bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
- LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
- pthread_mutex_lock(&g_lynq_call_sendto_mutex);
- if(send_request(lynq_call_client_sockfd,&client)==-1)
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ANSWER,0,"");
+ if(ret==RESULT_OK)
{
- LYERRLOG("send request fail");
- return -1;
- }
- get_response(lynq_call_client_sockfd,p);
- pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
- JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
- LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
- return error;
+ delete p;
+ }
+ return ret;
}
int lynq_call_hungup(int* handle)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
- }
- Parcel p;
- lynq_client_t client;
- int resp_type = -1;
- int request = -1;
- int token;
- int slot_id = -1;
- int error = -1;
- int call_id = 0;
- int lynq_call_id;
+ return LYNQ_E_CONFLICT;
+ }
+
if(handle==NULL||!((*handle>=0)&&(*handle<10)))
{
- LYERRLOG("[%s] illegal input!!!!",__FUNCTION__);
- return LYNQ_E_CONFLICT;
+ LYERRLOG("%s illegal input!!!!",__func__);
+ return LYNQ_E_PARAMETER_ANONALY;
}
- client.uToken = Global_uToken_call;
- client.request = 12;//RIL_REQUEST_HUNGUP
- client.paramLen = 1;
- bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
- call_id = *handle;
- sprintf(client.param,"%d",call_id);
- LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
- pthread_mutex_lock(&g_lynq_call_sendto_mutex);
- if(send_request(lynq_call_client_sockfd,&client)==-1)
+
+ int call_id = *handle;
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_HANGUP,1,"%d",call_id);
+ if(ret!=0)
{
- LYERRLOG("send request fail");
- return -1;
- }
- get_response(lynq_call_client_sockfd,p);
- pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
- JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
- LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
- if(error==0)
+ return ret;
+ }
+ delete p;
+
+ int lynq_call_id=find_call_id_with_call_id(call_id);
+ if(lynq_call_id!=INVALID_ID)
{
- lynq_call_id=find_call_id_with_call_id(call_id);
- if(lynq_call_id!=INVALID_ID)
- {
- cleanCallList(lynq_call_id);
- }
- }
- return error;
+ cleanCallList(lynq_call_id);
+ }
+
+ return RESULT_OK;
}
int lynq_call_hungup_all()
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
- Parcel p;
- lynq_client_t client;
- int resp_type = -1;
- int token=-1;
- int request = -1;
- int slot_id = -1;
- int error = -1;
- client.uToken = Global_uToken_call;
- client.request = 17;//RIL_REQUEST_UDUB
- client.paramLen = 0;
- bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
- LYDBGLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
- pthread_mutex_lock(&g_lynq_call_sendto_mutex);
- if(send_request(lynq_call_client_sockfd,&client)==-1)
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_UDUB,0,"");
+ if(ret==RESULT_OK)
{
- LYERRLOG("send request fail");
- return -1;
- }
- get_response(lynq_call_client_sockfd,p);
- pthread_mutex_unlock(&g_lynq_call_sendto_mutex);
- JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
- LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
- return error;
+ delete p;
+ }
+ return ret;
}
int lynq_wait_incoming_call(int *handle)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
waitIncomingCall();
- *handle = lynqIncomingCallId;
- LYINFLOG("lynq incoming call id:%d",lynqIncomingCallId);
- return 0;
+ *handle = s_IncomingCallId;
+ LYINFLOG("lynq incoming call id:%d",s_IncomingCallId);
+ return RESULT_OK;
}
int lynq_set_auto_answercall(const int mode)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
- global_call_auto_answer = mode;
+ s_call_auto_answer = mode;
LYINFLOG("auto answer call mode =%d",mode);
- return 0;
+ return RESULT_OK;
}
int lynq_get_current_call_state(int *handle, int *call_state,int *toa,int *direction,char addr[])
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
int lynq_call_id = 0;
LYINFLOG("lynq_get_current_call_state begin ");
if(handle==NULL)
{
LYERRLOG("handle is NULL");
- return LYNQ_E_NULL_ANONALY;
+ return LYNQ_E_PARAMETER_ANONALY;
}
lynq_call_id = find_call_id_with_call_id(*handle);
if(lynq_call_id==INVALID_ID)
{
return LYNQ_E_INVALID_ID_ANONALY;
}
- *call_state = lynq_call_lists[lynq_call_id].call_state;
- *toa = lynq_call_lists[lynq_call_id].toa;
- *direction = lynq_call_lists[lynq_call_id].direction;
- memcpy(addr,lynq_call_lists[lynq_call_id].addr,strlen(lynq_call_lists[lynq_call_id].addr)+1);
- return 0;
+ *call_state = s_call_lists[lynq_call_id].call_state;
+ *toa = s_call_lists[lynq_call_id].toa;
+ *direction = s_call_lists[lynq_call_id].direction;
+ memcpy(addr,s_call_lists[lynq_call_id].addr,strlen(s_call_lists[lynq_call_id].addr)+1);
+ return RESULT_OK;
}
int lynq_get_current_call_number()
@@ -1451,7 +1074,7 @@
int i;
for(i = 0;i < LYNQ_CALL_MAX;i++)
{
- if(lynq_call_lists[i].used !=0)
+ if(s_call_lists[i].used !=0)
{
cnt++;
}
@@ -1464,32 +1087,42 @@
static int judge_mic(const int enable){
switch(enable){
case 0:
- return 1;
+ return true;
case 1:
- return 1;
+ return true;
default:
- return 0;
+ return false;
}
}
int lynq_set_mute_mic(const int enable)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
- }
- if(!judge_mic(enable)){
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
return LYNQ_E_CONFLICT;
}
- return lynq_set_common_request(53,1,"%d",enable); //RIL_REQUEST_SET_MUTE
+ if(!judge_mic(enable)){
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ // return lynq_set_common_request(53,1,"%d",enable); //RIL_REQUEST_SET_MUTE
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_MUTE,1,"%d",enable);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
}
int lynq_get_mute_mic(int *status)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
- return lynq_get_common_request(54,status);//RIL_REQUEST_GET_MUTE
+ return lynq_get_common_request(RIL_REQUEST_GET_MUTE,status);//54
}
/**
@@ -1502,25 +1135,36 @@
{
if(callnum == '#')
{
- return 1;
+ return true;
}
if(callnum == '*')
{
- return 1;
+ return true;
}
if(callnum >= '0'&& callnum <= '9')
{
- return 1;
+ return true;
}
- return 0;
+ return false;
}
int lynq_switch_waiting_or_holding_and_active(void)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE,0,"");
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+
+#if 0
Parcel p;
lynq_client_t client;
int resp_type = -1;
@@ -1544,14 +1188,25 @@
JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
return error;
+#endif
}
int lynq_hangup_waiting_or_background(void)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND,0,"");
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+#if 0
Parcel p;
lynq_client_t client;
int resp_type = -1;
@@ -1575,14 +1230,25 @@
JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
return error;
+#endif
}
int lynq_hangup_foreground_resume_background(void)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND,0,"");
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+#if 0
Parcel p;
lynq_client_t client;
int resp_type = -1;
@@ -1606,24 +1272,35 @@
JumpHeader(p,&resp_type,&token,&request,&slot_id,&error);
LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
return error;
+#endif
}
int lynq_set_DTMF(const char callnum)
{
- if(g_lynq_call_init_flag == 0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- return -1;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
if(!judge_dtmf(callnum))
{
return LYNQ_E_CONFLICT;
}
- if(!lynq_call_state)
+ if(s_module_call_state!=CALL_ON)
{
LYERRLOG("LYNQ_E_CONFLICT");
return LYNQ_E_CONFLICT;
}
- return lynq_set_common_request(24,1,"%c",callnum); //RIL_REQUEST_DTMF
+
+// return lynq_set_common_request(24,1,"%c",callnum); //RIL_REQUEST_DTMF
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_DTMF,1,"%c",callnum);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
}
static int judge_volume(LYNQ_E_VOLUMN_SET set,const int volume){
if(set==LYNQ_E_VOLUMN_SET_DTMF){
@@ -1641,716 +1318,119 @@
}
int lynq_set_DTMF_volume(const int volume)
{
- if(!judge_volume(LYNQ_E_VOLUMN_SET_DTMF,volume)){
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
return LYNQ_E_CONFLICT;
}
- return lynq_set_common_request(8003,1,"%d",volume);//LYNQ_REQUEST_SET_DTMF_VOLUME
+ if(!judge_volume(LYNQ_E_VOLUMN_SET_DTMF,volume)){
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+// return lynq_set_common_request(8003,1,"%d",volume);//LYNQ_REQUEST_SET_DTMF_VOLUME
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_DTMF_VOLUME,1,"%d",volume);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
}
int lynq_set_speech_volume(const int volume)//mixer_set_volume
{
- if(!judge_volume(LYNQ_E_VOLUMN_SET_SPEECH,volume))
+ if(g_module_init_flag != MODULE_RUNNING)
{
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
return LYNQ_E_CONFLICT;
}
- return lynq_set_common_request(8009,1,"%d",volume); //LYNQ_REQUEST_SET_SPEECH_VOLUME
+ if(!judge_volume(LYNQ_E_VOLUMN_SET_SPEECH,volume))
+ {
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+// return lynq_set_common_request(8009,1,"%d",volume); //LYNQ_REQUEST_SET_SPEECH_VOLUME
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_SET_SPEECH_VOLUME,1,"%d",volume);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
}
int lynq_get_speech_volume(int* volumn)//mixer_get_volume
{
- return lynq_get_common_request(8010,volumn);//LYNQ_REQUEST_GET_SPEECH_VOLUME
+ return lynq_get_common_request(LYNQ_REQUEST_GET_SPEECH_VOLUME,volumn);//8010
}
int lynq_incall_record_start(const char* file_path)
{
- return lynq_set_common_request(8011,2,"%s %s","1",file_path); //LYNQ_REQUEST_RECORD
+// return lynq_set_common_request(8011,2,"%s %s","1",file_path); //LYNQ_REQUEST_RECORD
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_RECORD,2,"%s %s","1",file_path);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
}
int lynq_incall_record_stop()
{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
const char* unused_file="just_ocuupy_paramter_postion";
- return lynq_set_common_request(8011,2,"%s %s","0",unused_file); //LYNQ_REQUEST_RECORD
+// return lynq_set_common_request(8011,2,"%s %s","0",unused_file); //LYNQ_REQUEST_RECORD
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,LYNQ_REQUEST_RECORD,2,"%s %s","0",unused_file);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
}
/*audio end*/
+void urc_msg_process(Parcel *p)
+{
+ int resp_type;
+ int urcid;
+ int slot_id;
+
+ p->readInt32(&resp_type);
+ p->readInt32(&urcid);
+ p->readInt32(&slot_id);
+ LYINFLOG("urc id = %d, slot_id = %d",urcid,slot_id);
+ switch (urcid)
+ {
+ case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED://1001
+ {
+ LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
+ lynqNoticeGetModuleCallList();
+ break;
+ }
+ case RIL_UNSOL_CALL_RING: //1018
+ {
+ if(s_call_auto_answer==1)
+ {
+ lynq_call_answer();
+ }
+ break;
+ }
+ case RIL_UNSOL_RINGBACK_TONE: //1029
+ case RIL_UNSOL_CALL_INFO_INDICATION://3049
+ {
+ LYINFLOG("**************:resp_type=%d,urcid=%d,slot_id=%d",resp_type,urcid,slot_id);
+ break;
+ }
#ifdef ECALL_SUPPORT
-LYNQ_ECall_Variant lynq_get_lynq_ecall_variant_from_lynq_type(LYNQ_ECall_Type type)
-{
- switch(type)
- {
- case LYNQ_ECALL_TYPE_TEST:
- return LYNQ_ECALL_TEST;
- case LYNQ_ECALL_TYPE_RECONFIG:
- return LYNQ_ECALL_RECONFIG;
- default:
- return LYNQ_ECALL_EMERGENCY;
- }
-}
-
-RIL_ECall_Variant lynq_get_ril_ecall_variant_from_lynq_variant(LYNQ_ECall_Variant type)
-{
- switch(type)
- {
- case LYNQ_ECALL_TEST:
- return ECALL_TEST;
- case LYNQ_ECALL_RECONFIG:
- return ECALL_RECONFIG;
- default:
- return ECALL_EMERGENCY;
- }
-}
-
-RIL_ECall_Category lynq_get_ril_ecall_cat_from_lynq_cat(LYNQ_ECall_Category cat)
-{
- switch(cat)
- {
- case LYNQ_EMER_CAT_MANUAL_ECALL:
- return EMER_CAT_MANUAL_ECALL;
- default:
- return EMER_CAT_AUTO_ECALL;
- }
-}
-
-
-int lynq_set_test_num(LYNQ_ECall_Set_Type type, const char *test_num, int test_num_length)
-{
- int error;
-
- if(test_num==NULL || test_num_length > LYNQ_PHONE_NUMBER_MAX )
- {
- LYERRLOG("test_num is null or test_num_length %d s greater than %d ",test_num_length,LYNQ_PHONE_NUMBER_MAX);
- return -1;
- }
-
- error=lynq_set_common_request(RIL_REQUEST_ECALL_SET_TEST_NUM,2,"%d %s",type,test_num);
-
- if(error==0)
- {
- snprintf(e_call_addr[LYNQ_ECALL_TEST],LYNQ_PHONE_NUMBER_MAX,"%s",test_num);
- }
-
- return error;
-}
-
-int lynq_ecall_can_be_preempted(LYNQ_ECall_Variant old_variant,LYNQ_ECall_Variant new_variant)
-{
- int ret;
-
- if(old_variant == LYNQ_ECALL_EMERGENCY)
- {
- return false;
- }
- else if(new_variant == LYNQ_ECALL_EMERGENCY)
- {
- return true;
- }
- else if(old_variant==LYNQ_ECALL_DAILING_STATE_NONE)
- {
- return true;
- }
- else
- {
- ret = (g_ecall_whether_preempt & 0x01);
- }
- LYINFLOG("ecall clear conflict call, lynq_ecall_can_be_preempted is true");
- return ret;
-}
-
-int lynq_clear_current_call()
-{
- int cnt;
- if(lynq_call_hungup_all()!=0)
- {
- LYERRLOG("ecall clear conflict call, hangup all failure");
- return -1;
- }
- cnt=0;
- while(lynq_get_current_call_number()!=0 && cnt<80)
- {
- lynqRespWatingEvent();
- usleep(200 * 1000);//200ms
- cnt++;
- }
- if(lynq_get_current_call_number()!=0)
- {
- LYERRLOG("ecall clear conflict call, current call list can't cleared after 15s");
- return -2;
- }
-
- LYINFLOG("ecall clear conflict call, after %d 0.2s, call list is cleared", cnt);
- return 0;
-}
-
-int lynq_clear_current_conflict_call(LYNQ_ECall_Variant old_variant,LYNQ_ECall_Variant new_variant)
-{
- int cnt;
- int ret;
-
- if(lynq_ecall_is_running()==false)
- {
- if(lynq_get_current_call_number()==0)
+ case RIL_UNSOL_ECALL_INDICATIONS://9502
{
- LYINFLOG("ecall clear conflict call, no conflict ecall and normal call");
+ urc_ecall_msg_process(p);
}
- else if(g_ecall_whether_preempt & 0x02)
- {
- ret=lynq_clear_current_call();
- LYERRLOG("ecall clear conflict call, relase current normal call ret is %d",ret);
- }
- return 0;
- }
-
- LYINFLOG("ecall clear conflict call, two ecall occure at the same time, new is %d, old is %d, g_preempt is %d",new_variant,old_variant,g_ecall_whether_preempt);
-
- if(lynq_ecall_can_be_preempted(old_variant,new_variant)==false)
- {
- LYERRLOG("ecall clear conflict call, new ecall %d can't preempt old ecall %d",new_variant,old_variant);
- return -1;
- }
-
- ret=lynq_clear_current_call();
- LYINFLOG("ecall clear conflict call, relase current call(including ecall) ret is %d",ret);
-
- if(is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
- {
- sendSignalToWaitCallStateChange();
- LYINFLOG("ecall clear conflict call, stop ecall in dailing status");
- }
-
- cnt=0;
- while(lynq_ecall_is_running() && cnt<80)
- {
- usleep(200 * 1000);//200ms
- cnt++;
- }
-
- if(lynq_ecall_is_running())
- {
- LYERRLOG("ecall clear conflict call, after 16s, lynq ecall is still running");
- }
- else
- {
- LYINFLOG("ecall clear conflict call, after %d 0.2s, ecall info is cleared", cnt);
- }
-
- sleep(3);// for ecall disconnect
- print_ecall_info();
- return 0;
-}
-
-int lynq_fast_ecall(int* handle, LYNQ_ECall_Category lynq_ecall_cat, LYNQ_ECall_Variant lynq_ecall_variant, const char *addr, int addr_length, const unsigned char *msd_data,int msd_length)
-{
- int error;
- RIL_ECall_Variant ril_ecall_variant = lynq_get_ril_ecall_variant_from_lynq_variant (lynq_ecall_variant);
- RIL_ECall_Category ril_ecall_cat = lynq_get_ril_ecall_cat_from_lynq_cat(lynq_ecall_cat);
- char lynq_msd_data[MSD_MAX_LENGTH*2+1]={0};
- unsigned int i;
-
- if(msd_length > MSD_MAX_LENGTH || msd_length <=0 || lynq_ecall_variant >=LYNQ_ECALL_MO_MAX)
- {
- LYERRLOG("lynq_fast_ecall msd_length %d or ecall variant %d parameter error",msd_length,lynq_ecall_variant);
- return LYNQ_E_ECALL_MSD_LENGTH_ERROR;
- }
-
- if(lynq_clear_current_conflict_call(g_lynqEcallVariant,lynq_ecall_variant)!=0)
- {
- LYERRLOG("%s call lynq_clear_current_conflict_call false, old is %d, new is %d",__func__,g_lynqEcallVariant,lynq_ecall_variant);
- return LYNQ_E_ECALL_BEING_RUNNING;
- }
-
- pthread_mutex_lock(&s_ecall_variable_mutex);
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_STARTED;
- g_lynqEcallVariant = lynq_ecall_variant;
- g_ecallId = INVALID_ID;
- pthread_mutex_unlock(&s_ecall_variable_mutex);
-
- for(i =0; i<msd_length;i++)
- {
- sprintf(&(lynq_msd_data[i<<1]),"%02x",msd_data[i]);
- }
-
-
- LYINFLOG("lynq_fast_ecall addr is %s",e_call_addr[lynq_ecall_variant]);
-
- error=lynq_set_common_request(RIL_REQUEST_ECALL_FAST_MAKE_ECALL,4,"%d %d %s %s",ril_ecall_cat, ril_ecall_variant, "null", lynq_msd_data);
-
- if(error==0)
- {
- if(waitCallstateChange(270000)==ETIMEDOUT)//4.5 min, dailing 1 min, alerting 1 min, sending msd 30s, redial 2min
- {
- pthread_mutex_lock(&s_ecall_variable_mutex);
- LYERRLOG("lynq_fast_ecall timeout:wait Call state time out!!!");
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
- lynqRespWatingEvent();
- pthread_mutex_unlock(&s_ecall_variable_mutex);
- return LYNQ_E_TIME_OUT;
- }
- pthread_mutex_lock(&s_ecall_variable_mutex);
- if(is_ecall_dial == LYNQ_ECALL_DAILING_STATE_STARTED)
- {
- /*just dail, no recv answer*/
- LYERRLOG("lynq_fast_ecall, no answer!");
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
- lynqRespWatingEvent();
- pthread_mutex_unlock(&s_ecall_variable_mutex);
- return LYNQ_E_ECALL_DAILING_NO_ANSWER;
- }
-
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
- lynqRespWatingEvent();
-
- if(g_ecallId != INVALID_ID)
- {
- *handle=g_ecallId;
- LYINFLOG("lynq_fast_ecall id is %d",g_ecallId);
- pthread_mutex_unlock(&s_ecall_variable_mutex);
- return 0;
- }
-
- LYERRLOG("lynq_fast_ecall service return fail");
- pthread_mutex_unlock(&s_ecall_variable_mutex);
- return LYNQ_E_INVALID_ID_ANONALY;
- }
-
- pthread_mutex_lock(&s_ecall_variable_mutex);
- is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
- g_lynqEcallVariant = LYNQ_ECALL_VAR_NONE;
- g_ecallId = INVALID_ID;
- pthread_mutex_unlock(&s_ecall_variable_mutex);
-
- return error;
-}
-
-int lynq_set_psap(int enable)
-{
- return lynq_set_common_request(RIL_REQUEST_ECALL_SET_PSAP,1,"%d",enable);
-}
-
-int lynq_psap_pull_msd()
-{
- return lynq_set_common_request(RIL_REQUEST_ECALL_PSAP_PULL_MSD,0,"");
-}
-
-int lynq_make_ecall(int* handle, LYNQ_ECall_Type type)
-{
- LYNQ_ECall_Variant lynq_ecall_variant;
- int error = -1;
- int lynq_call_id = -1;
-
- if(handle==NULL)
- {
- LYERRLOG("handle is NULL, parameter error ");
- return -1;
- }
-
- error=lynq_set_common_request(RIL_REQUEST_ECALL_MAKE_ECALL,1,"%d",type);
-
- if(error==0)
- {
- lynq_ecall_variant=lynq_get_lynq_ecall_variant_from_lynq_type(type);
-
- lynq_call_id = addAddr(e_call_addr[lynq_ecall_variant]);
- isDial = 1;
- if(waitCallstateChange(10000)==ETIMEDOUT)//10000ms
- {
- error = LYNQ_E_TIME_OUT;
- LYERRLOG("timeout:wait Call state fail!!!");
- return error;
- }
-
- *handle = lynq_call_id;
- }
-
- return error;
-}
-
-
-int lynq_set_msd(int* handle, const unsigned char *msd_data, int msd_length)
-{
- char lynq_msd_data[MSD_MAX_LENGTH*2+1]={0};
- unsigned int i;
-
- if(handle==NULL || ((*handle) >= LYNQ_CALL_MAX) || msd_length > MSD_MAX_LENGTH || msd_length <= 0 || msd_data ==NULL)
- {
- LYERRLOG("lynq_set_msd handle is NULL or *handle %d is greater or equeal to %d or msd_length %d is greater than %d or msd_data %s is NULL, parameter error",*handle,LYNQ_CALL_MAX,msd_length,MSD_MAX_LENGTH, msd_data);
- return -1;
- }
-
- for(i=0; i<msd_length;i++)
- {
- sprintf(&(lynq_msd_data[i<<1]),"%02x",msd_data[i]);
- }
-
- LYINFLOG("lynq_set_msd ");
-
- return lynq_set_common_request(RIL_REQUEST_ECALL_SET_MSD,2,"%d %s",*handle,lynq_msd_data);
-}
-
-int lynq_set_ivs(int enable)
-{
-#ifdef ECALL_SUPPORT
- if(enable<0)
- {
- if(enable >-100)
- {
- lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
- }
- else if(enable== -1000)
- {
- print_ecall_info();
- }
- else
- {
- g_ecall_whether_preempt= ((-100-enable) & 0x11);
- }
- return 0;
- }
#endif
-
- return lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
-}
-
-int lynq_reset_ivs()
-{
- return lynq_set_common_request(RIL_REQUEST_ECALL_RESET_IVS,0,"");
-}
-
-int lynq_ivs_push_msd()
-{
- return lynq_set_common_request(RIL_REQUEST_ECALL_IVS_PUSH_MSD,0,"");
-}
-
-int wait_ecall_event()
-{
- int ret = 0;
- pthread_mutex_lock(&s_incoming_e_call_mutex);
- ret = pthread_cond_wait(&s_incoming_e_call_cond,&s_incoming_e_call_mutex);
- pthread_mutex_unlock(&s_incoming_e_call_mutex);
- return ret;
-}
-
-int lynq_wait_ecall_indication(int* handle, LYNQ_ECall_Indication *eCall_Indication)
-{
- wait_ecall_event();
- *handle = g_lynqIncomingEcallId;
- *eCall_Indication = g_lynqIncomingEcallIndication;
- LYINFLOG("lynq_wait_ecall_indication handle %d, Ind id: %d", *handle, *eCall_Indication);
- return 0;
-}
-
-#endif
-
-/*Audio Path setting begin*/
-/*sub function*/
-void lynq_set_rtp_mixer_ctrl(int enable_rtp)
-{
- char cmd[256];
- LYINFLOG("set_rtp_mixer_ctrl %d", enable_rtp);
- if(enable_rtp)
- {
- sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 0);
- system(cmd);
- sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 1);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 1);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 1);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 1);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 1);
- system(cmd);
- }
- else
- {
- sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 1);
- system(cmd);
- sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 0);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 0);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 0);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 0);
- system(cmd);
- sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 0);
- system(cmd);
- }
-}
-
-void* lynq_start_rtp_cmd(void *arg)
-{
- if(g_lynq_call_init_flag == 0)
- {
- return -1;
- }
- int* rtp_mode= (int*) arg;
- char cmd[384];
- char vlan_para_string[sizeof(RTP_VLAN_INFO_FORMAT)+MAX_VLAN_INFO_LENGTH-2/*sizeof "%s"*/]={0};
- LYINFLOG("lynq_start_rtp_cmd: rtp_mode is %d",(*rtp_mode));
- if ((*rtp_mode) == RTP_CLIENT)
- {
- sprintf(cmd,RTP_FROM_CMD, \
- g_rtp_client_info.port,g_rtp_client_info.clockrate,g_rtp_client_info.channels, \
- g_rtp_client_info.latency);
- // LYINFLOG("start from rtp play: cmd is %s",cmd);
- system(cmd);
- }
- else if ((*rtp_mode) == RTP_SERVER)
- {
- if(strlen(g_rtp_server_info.vlan_info)>0)
- {
- sprintf(vlan_para_string,RTP_VLAN_INFO_FORMAT,g_rtp_server_info.vlan_info);
- }
- sprintf(cmd,RTP_TO_CMD, \
- g_rtp_server_info.ip,vlan_para_string,g_rtp_server_info.port);
- // LYINFLOG("start to rtp play: cmd is %s",cmd);
- system(cmd);
- }
- return NULL;
-}
-
-int lynq_start_rtp_thread(int rtp_mode)
-{
- int ret;
- pthread_attr_t attr;
- static int start_mode[RTP_MODE_MAX]={0,1};
-
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&(g_rtp_thread[rtp_mode]),&attr,lynq_start_rtp_cmd,&(start_mode[rtp_mode]));
- if(ret != 0)
- {
- g_rtp_thread_valid[rtp_mode]=0;
- LYERRLOG("rtp create %d pthread error, ret is %d",rtp_mode, ret);
- return ret;
- }
- g_rtp_thread_valid[rtp_mode]=1;
- return 0;
-}
-
-/*set*/
-int lynq_set_voice_audio_mode(const LYNQ_Audio_Mode audio_mode)
-{
- if(g_lynq_call_init_flag == 0)
- {
- return -1;
- }
- int ret;
- int i;
-
- if(audio_mode==AUDIO_MODE_RTP)
- {
- lynq_set_rtp_mixer_ctrl(1);
- for(i=0;i<RTP_MODE_MAX;i++)
- {
- if(!g_rtp_thread_valid[i])
- {
- if(lynq_start_rtp_thread(i)!= 0)
- {
- LYERRLOG("start rtp %d fail",i);
- break;
- }
- else
- {
- LYINFLOG("start rtp %d suc",i);
- }
- }
- else
- {
- LYERRLOG("rtp %d needn't start",i);
- }
- }
- if(i!= RTP_MODE_MAX)
- {
- LYERRLOG("start rtp whole fail");
- lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
- return 1;
- }
- LYINFLOG("start rtp whole suc");
- return 0;
- }
- else if(audio_mode==AUDIO_MODE_CODEC)
- {
- for(i=0;i<RTP_MODE_MAX;i++)
- {
- if(g_rtp_thread_valid[i])
- {
- ret = pthread_cancel(g_rtp_thread[i]);
- LYINFLOG("pthread cancel rtp %d ret = %d",i,ret);
- ret = pthread_join(g_rtp_thread[i],NULL);
- LYINFLOG("pthread join rtp %d ret = %d",i,ret);
- g_rtp_thread_valid[i] = 0;
- }
- else
- {
- LYINFLOG("rtp %d needn't stop",i);
- }
- }
- lynq_set_rtp_mixer_ctrl(0);
- LYINFLOG("stop rtp suc");
- }
- return 0;
-}
-int lynq_set_remote_rtp_ip(const char* ip, const int ip_length)
-{
- if (NULL == ip)
- {
- LYERRLOG("ip is NULL!!!");
- return -1;
- }
- if ((ip_length < strlen(ip)+1) || (ip_length > MAX_IP_LENGTH))
- {
- LYERRLOG("incoming ip length error %d", ip_length);
- return -1;
- }
-
- bzero(g_rtp_server_info.ip,MAX_IP_LENGTH);
- strcpy(g_rtp_server_info.ip,ip);
-
- LYINFLOG("lynq_set_remote_rtp_ip suc: ip is %s, length is %d", ip,ip_length);
-
- return 0;
-}
-int lynq_set_vlan_info(const char* vlan_info, const int vlan_info_length)
-{
- if (NULL == vlan_info)
- {
- LYERRLOG("vlan_info is NULL!!!");
- return -1;
- }
-
- if ((vlan_info_length < strlen(vlan_info)+1) || (vlan_info_length > MAX_VLAN_INFO_LENGTH))
- {
- LYERRLOG("incoming vlan_info error, vlan info length %d", vlan_info_length);
- return -1;
- }
-
-
- bzero(g_rtp_server_info.vlan_info,MAX_VLAN_INFO_LENGTH);
- strcpy(g_rtp_server_info.vlan_info,vlan_info);
-
- LYINFLOG("lynq_set_vlan_info suc: vlan is %s, length is %d", vlan_info,vlan_info_length);
-
- return 0;
-}
-int lynq_set_rtp_port(const LYNQ_Rtp_Mode rtp_mode, const int port)
-{
- if (port < 0)
- {
- LYERRLOG("invalid port number %d", port);
- return -1;
- }
- if (rtp_mode == 0)
- {
- g_rtp_client_info.port = port;
- }
- else if (rtp_mode == 1)
- {
- g_rtp_server_info.port = port;
- }
- LYINFLOG("lynq_set_rtp_port suc: LYNQ_Rtp_Mode is %d, port is %d", rtp_mode, port);
- return 0;
-}
-int lynq_set_rtp_param(const int clock_rate,const int channels,const int latency) //only for client mode
-{
- g_rtp_client_info.clockrate = clock_rate;
- g_rtp_client_info.channels = channels;
- g_rtp_client_info.latency = latency;
- LYINFLOG("lynq_set_rtp_param suc: clockrate is %d, channels is %d, latency is %d", clock_rate, channels, latency);
- return 0;
-}
-/*get*/
-LYNQ_Audio_Mode lynq_get_voice_audio_mode()
-{
- if(g_lynq_call_init_flag == 0)
- {
- return -1;
- }
- if(g_rtp_thread_valid[0])
- {
- return AUDIO_MODE_RTP;
- }
- else
- {
- return AUDIO_MODE_CODEC;
+ default:
+ break;
}
}
-int lynq_get_remote_rtp_ip(char* ip, const int ip_length)
-{
- if(g_lynq_call_init_flag == 0)
- {
- return -1;
- }
- if(ip==NULL)
- {
- LYERRLOG("ip is NULL");
- return 1;
- }
-
- if(ip_length < strlen(g_rtp_server_info.ip)+1)
- {
- LYERRLOG("ip lenght %d is shorter than saved ip length %d",ip_length,strlen(g_rtp_server_info.ip)+1);
- return 1;
- }
- bzero(ip,ip_length);
- strcpy(ip,g_rtp_server_info.ip);
- return 0;
-}
-int lynq_get_vlan_info(char* vlan_info, const int vlan_info_length)
-{
- if(vlan_info==NULL)
- {
- LYERRLOG("vlan info is NULL");
- return -1;
- }
-
- if(vlan_info_length < strlen(g_rtp_server_info.vlan_info)+1)
- {
- LYERRLOG("vlan info length %d is shorter than saved vlan info length %d",vlan_info_length,strlen(g_rtp_server_info.vlan_info)+1);
- return -1;
- }
-
- bzero(vlan_info,vlan_info_length);
- strcpy(vlan_info,g_rtp_server_info.vlan_info);
-
- return 0;
-}
-int lynq_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port)
-{
- if(g_lynq_call_init_flag == 0)
- {
- return -1;
- }
- if(port==NULL)
- {
- return 1;
- }
- if (rtp_mode == 0)
- {
- *port = g_rtp_client_info.port;
- }
- else if (rtp_mode == 1)
- {
- *port = g_rtp_server_info.port;
- }
- return 0;
-}
-int lynq_get_rtp_param(int* clock_rate, int* channels, int* latency)//only for client mode
-{
- if(g_lynq_call_init_flag == 0)
- {
- return -1;
- }
- if(clock_rate == NULL || channels ==NULL || latency ==NULL)
- {
- LYERRLOG("input parameter is NULL");
- return 1;
- }
-
- *clock_rate = g_rtp_client_info.clockrate;
- *channels = g_rtp_client_info.channels ;
- *latency = g_rtp_client_info.latency;
-
- return 0;
-}
-/*Audio Path setting end*/
#if 0
int main(int argc,char **argv)
diff --git a/src/lynq/lib/liblynq-call/lynq_call_common.h b/src/lynq/lib/liblynq-call/lynq_call_common.h
new file mode 100755
index 0000000..21077df
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/lynq_call_common.h
@@ -0,0 +1,23 @@
+#ifndef LYNQ_CALL_COMMON_H
+#define LYNQ_CALL_COMMON_H
+
+#define INVALID_ID (-1)
+
+int find_call_id_with_call_id(int call_id);
+int addAddr(char addr[], int call_id);
+int waitCallstateChange(int mtime);
+void sendSignalToWaitCallStateChange();
+void lynqNoticeGetModuleCallList();
+int IsNormalCallDailing();
+int lynq_get_current_call_number();
+
+#ifdef ECALL_SUPPORT
+int lynq_ecall_is_running();
+int IsECallDialing();
+int Is_handup_IncomingMT(int ecall_id);
+using ::android::Parcel;
+void urc_ecall_msg_process(Parcel *p);
+#endif
+
+void lynq_init_rtp();
+#endif
diff --git a/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp b/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
new file mode 100755
index 0000000..0c76262
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/lynq_call_ecall.cpp
@@ -0,0 +1,703 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include "liblog/lynq_deflog.h"
+#include <sys/time.h>
+#include <string.h>
+#include <vendor-ril/telephony/ril.h>
+#include <vendor-ril/telephony/mtk_ril_sp.h>
+#include <vendor-ril/telephony/mtk_ril_ivt.h>
+#include "lynq_call.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+#include "lynq_call_common.h"
+
+#define USER_LOG_TAG "LYNQ_CALL"
+
+using ::android::Parcel;
+
+#ifdef ECALL_SUPPORT
+typedef enum{
+ LYNQ_ECALL_TYPE_TEST = 0, /* Test eCall */
+ LYNQ_ECALL_TYPE_RECONFIG = 1, /* Reconfiguration eCall */
+ LYNQ_ECALL_MANUAL_EMERGENCY = 2, /*Manual Emergency eCall */
+ LYNQ_ECALL_TYPE_AUTO_EMERGENCY = 3, /* Automatic Emergency eCall */
+}LYNQ_ECall_Type;
+typedef enum{
+ LYNQ_ECALL_DAILING_STATE_NONE =0,
+ LYNQ_ECALL_DAILING_STATE_STARTED = 1,
+ LYNQ_ECALL_DAILING_STATE_ANSWERED = 2,
+}LYNQ_ECall_Dailing_State;
+static LYNQ_ECall_Dailing_State s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
+int IsECallDialing()
+{
+ return s_module_is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE;
+}
+static int s_ecallId = INVALID_ID;
+char e_call_addr[LYNQ_ECALL_VAR_MAX][LYNQ_PHONE_NUMBER_MAX]={"test_ecall","emergency_ecall","reconf_ecall"};
+
+static pthread_mutex_t s_incoming_e_call_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_incoming_e_call_cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t s_ecall_variable_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static LYNQ_ECall_Indication s_IncomingEcallIndication;
+int s_IncomingEcallId=INVALID_ID;
+LYNQ_ECall_Variant s_EcallVariant=LYNQ_ECALL_VAR_NONE;
+int s_ecall_whether_preempt=0;
+
+void sendSignalIncomingECallEvent()
+{
+ LYINFLOG("send incoming ecall event signal");
+ pthread_mutex_lock(&s_incoming_e_call_mutex);
+ pthread_cond_signal(&s_incoming_e_call_cond);
+ pthread_mutex_unlock(&s_incoming_e_call_mutex);
+}
+
+int lynq_is_msd_suc(LYNQ_ECall_Indication lynqIncomingEcallIndication)
+{
+ if(LYNQ_ECALL_LLACK_RECEIVED == lynqIncomingEcallIndication ||
+ LYNQ_ECALL_ALACK_POSITIVE_RECEIVED == lynqIncomingEcallIndication ||
+ LYNQ_ECALL_ALACK_CLEARDOWN_RECEIVED == lynqIncomingEcallIndication ||
+ //LYNQ_ECALL_T5_TIMER_OUT == lynqIncomingEcallIndication ||
+ LYNQ_ECALL_T6_TIMER_OUT == lynqIncomingEcallIndication ||
+ LYNQ_ECALL_T7_TIMER_OUT == lynqIncomingEcallIndication)
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+int lynq_ecall_is_running()
+{
+ return (s_module_is_ecall_dial!=LYNQ_ECALL_DAILING_STATE_NONE) || (s_ecallId !=INVALID_ID || s_EcallVariant == LYNQ_ECALL_CALLBACK);
+}
+
+void print_ecall_info()
+{
+ LYERRLOG("%s is ecall dial is %d, ecall id is %d, ecall vairant is %d, incoming ecall ind is %d, incoming ecall id is %d, whether preempt is %d",__func__,s_module_is_ecall_dial,s_ecallId,s_EcallVariant,s_IncomingEcallIndication,s_IncomingEcallId,s_ecall_whether_preempt);
+}
+
+int lynq_ecall_is_permit_in_call(int ecall_id)
+{
+ return s_EcallVariant == LYNQ_ECALL_CALLBACK && (s_ecallId ==INVALID_ID || s_ecallId ==ecall_id);
+}
+
+int Is_handup_IncomingMT(int ecall_id)
+{
+ pthread_mutex_lock(&s_ecall_variable_mutex);
+ int handupIncomingMT=lynq_ecall_is_running() && (lynq_ecall_is_permit_in_call(ecall_id)==false);
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+ return handupIncomingMT;
+}
+
+int lynq_ecall_is_in_voice()
+{
+ return (s_module_is_ecall_dial==LYNQ_ECALL_DAILING_STATE_NONE) && (s_ecallId !=INVALID_ID);
+}
+
+LYNQ_ECall_Variant lynq_get_lynq_ecall_variant_from_lynq_type(LYNQ_ECall_Type type)
+{
+ switch(type)
+ {
+ case LYNQ_ECALL_TYPE_TEST:
+ return LYNQ_ECALL_TEST;
+ case LYNQ_ECALL_TYPE_RECONFIG:
+ return LYNQ_ECALL_RECONFIG;
+ default:
+ return LYNQ_ECALL_EMERGENCY;
+ }
+}
+
+RIL_ECall_Variant lynq_get_ril_ecall_variant_from_lynq_variant(LYNQ_ECall_Variant type)
+{
+ switch(type)
+ {
+ case LYNQ_ECALL_TEST:
+ return ECALL_TEST;
+ case LYNQ_ECALL_RECONFIG:
+ return ECALL_RECONFIG;
+ default:
+ return ECALL_EMERGENCY;
+ }
+}
+
+RIL_ECall_Category lynq_get_ril_ecall_cat_from_lynq_cat(LYNQ_ECall_Category cat)
+{
+ switch(cat)
+ {
+ case LYNQ_EMER_CAT_MANUAL_ECALL:
+ return EMER_CAT_MANUAL_ECALL;
+ default:
+ return EMER_CAT_AUTO_ECALL;
+ }
+}
+
+
+int lynq_set_test_num(LYNQ_ECall_Set_Type type, const char *test_num, int test_num_length)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ if(test_num==NULL || test_num_length > LYNQ_PHONE_NUMBER_MAX )
+ {
+ LYERRLOG("test_num is null or test_num_length %d s greater than %d ",test_num_length,LYNQ_PHONE_NUMBER_MAX);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+// error=lynq_set_common_request(RIL_REQUEST_ECALL_SET_TEST_NUM,2,"%d %s",type,test_num);
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_SET_TEST_NUM,2,"%d %s",type,test_num);
+ if(ret==RESULT_OK)
+ {
+ snprintf(e_call_addr[LYNQ_ECALL_TEST],LYNQ_PHONE_NUMBER_MAX,"%s",test_num);
+ delete p;
+ }
+ return ret;
+}
+
+int lynq_ecall_can_be_preempted(LYNQ_ECall_Variant old_variant,LYNQ_ECall_Variant new_variant)
+{
+ int ret;
+
+ if(old_variant == LYNQ_ECALL_EMERGENCY)
+ {
+ return false;
+ }
+ else if(new_variant == LYNQ_ECALL_EMERGENCY)
+ {
+ return true;
+ }
+ else if(old_variant==LYNQ_ECALL_DAILING_STATE_NONE)
+ {
+ return true;
+ }
+ else
+ {
+ ret = (s_ecall_whether_preempt & 0x01);
+ }
+ LYINFLOG("ecall clear conflict call, lynq_ecall_can_be_preempted is true");
+ return ret;
+}
+
+int lynq_clear_current_call()
+{
+ int cnt;
+ int ret=lynq_call_hungup_all();
+
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("ecall clear conflict call, hangup all failure");
+ return ret;
+ }
+ cnt=0;
+ while(lynq_get_current_call_number()!=0 && cnt<80)
+ {
+ lynqNoticeGetModuleCallList();
+ usleep(200 * 1000);//200ms
+ cnt++;
+ }
+ if(lynq_get_current_call_number()!=0)
+ {
+ LYERRLOG("ecall clear conflict call, current call list can't cleared after 15s");
+ return LYNQ_E_INNER_ERROR;
+ }
+
+ LYINFLOG("ecall clear conflict call, after %d 0.2s, call list is cleared", cnt);
+ return RESULT_OK;
+}
+
+int lynq_clear_current_conflict_call(LYNQ_ECall_Variant old_variant,LYNQ_ECall_Variant new_variant)
+{
+ int cnt;
+ int ret;
+
+ if(lynq_ecall_is_running()==false)
+ {
+ if(lynq_get_current_call_number()==0)
+ {
+ LYINFLOG("ecall clear conflict call, no conflict ecall and normal call");
+ }
+ else if(s_ecall_whether_preempt & 0x02)
+ {
+ ret=lynq_clear_current_call();
+ LYERRLOG("ecall clear conflict call, relase current normal call ret is %d",ret);
+ }
+ return RESULT_OK;
+ }
+
+ LYINFLOG("ecall clear conflict call, two ecall occure at the same time, new is %d, old is %d, g_preempt is %d",new_variant,old_variant,s_ecall_whether_preempt);
+
+ if(lynq_ecall_can_be_preempted(old_variant,new_variant)==false)
+ {
+ LYERRLOG("ecall clear conflict call, new ecall %d can't preempt old ecall %d",new_variant,old_variant);
+ return LYNQ_E_CONFLICT;
+ }
+
+ ret=lynq_clear_current_call();
+ LYINFLOG("ecall clear conflict call, relase current call(including ecall) ret is %d",ret);
+
+ if(s_module_is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
+ {
+ sendSignalToWaitCallStateChange();
+ LYINFLOG("ecall clear conflict call, stop ecall in dailing status");
+ }
+
+ cnt=0;
+ while(lynq_ecall_is_running() && cnt<80)
+ {
+ usleep(200 * 1000);//200ms
+ cnt++;
+ }
+
+ if(lynq_ecall_is_running())
+ {
+ LYERRLOG("ecall clear conflict call, after 16s, lynq ecall is still running");
+ }
+ else
+ {
+ LYINFLOG("ecall clear conflict call, after %d 0.2s, ecall info is cleared", cnt);
+ }
+
+ sleep(3);// for ecall disconnect
+ print_ecall_info();
+ return RESULT_OK;
+}
+
+int lynq_fast_ecall(int* handle, LYNQ_ECall_Category lynq_ecall_cat, LYNQ_ECall_Variant lynq_ecall_variant, const char *addr, int addr_length, const unsigned char *msd_data,int msd_length)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ RIL_ECall_Variant ril_ecall_variant = lynq_get_ril_ecall_variant_from_lynq_variant (lynq_ecall_variant);
+ RIL_ECall_Category ril_ecall_cat = lynq_get_ril_ecall_cat_from_lynq_cat(lynq_ecall_cat);
+ char lynq_msd_data[MSD_MAX_LENGTH*2+1]={0};
+ unsigned int i;
+
+ if(msd_length > MSD_MAX_LENGTH || msd_length <=0 || lynq_ecall_variant >=LYNQ_ECALL_MO_MAX)
+ {
+ LYERRLOG("lynq_fast_ecall msd_length %d or ecall variant %d parameter error",msd_length,lynq_ecall_variant);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ if(lynq_clear_current_conflict_call(s_EcallVariant,lynq_ecall_variant)!=0)
+ {
+ LYERRLOG("%s call lynq_clear_current_conflict_call false, old is %d, new is %d",__func__,s_EcallVariant,lynq_ecall_variant);
+ return LYNQ_E_CONFLICT;
+ }
+
+ pthread_mutex_lock(&s_ecall_variable_mutex);
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_STARTED;
+ s_EcallVariant = lynq_ecall_variant;
+ s_ecallId = INVALID_ID;
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+
+ for(i =0; i<msd_length;i++)
+ {
+ sprintf(&(lynq_msd_data[i<<1]),"%02x",msd_data[i]);
+ }
+
+
+ LYINFLOG("lynq_fast_ecall addr is %s",e_call_addr[lynq_ecall_variant]);
+
+// error=lynq_set_common_request(RIL_REQUEST_ECALL_FAST_MAKE_ECALL,4,"%d %d %s %s",ril_ecall_cat, ril_ecall_variant, "null", lynq_msd_data);
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_FAST_MAKE_ECALL,4,"%d %d %s %s",ril_ecall_cat, ril_ecall_variant, "null", lynq_msd_data);
+ if(ret!=RESULT_OK)
+ {
+ pthread_mutex_lock(&s_ecall_variable_mutex);
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
+ s_EcallVariant = LYNQ_ECALL_VAR_NONE;
+ s_ecallId = INVALID_ID;
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+ return ret;
+ }
+
+ delete p;
+ if(waitCallstateChange(270000)==ETIMEDOUT)//4.5 min, dailing 1 min, alerting 1 min, sending msd 30s, redial 2min
+ {
+ pthread_mutex_lock(&s_ecall_variable_mutex);
+ LYERRLOG("lynq_fast_ecall timeout:wait Call state time out!!!");
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
+ lynqNoticeGetModuleCallList();
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+ return LYNQ_E_TIME_OUT;
+ }
+ pthread_mutex_lock(&s_ecall_variable_mutex);
+ if(s_module_is_ecall_dial == LYNQ_ECALL_DAILING_STATE_STARTED)
+ {
+ /*just dail, no recv answer*/
+ LYERRLOG("lynq_fast_ecall, no answer!");
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
+ lynqNoticeGetModuleCallList();
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+ return LYNQ_E_ECALL_DAILING_NO_ANSWER;
+ }
+
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
+ lynqNoticeGetModuleCallList();
+
+ if(s_ecallId != INVALID_ID)
+ {
+ *handle=s_ecallId;
+ LYINFLOG("lynq_fast_ecall id is %d",s_ecallId);
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+ return RESULT_OK;
+ }
+
+ LYERRLOG("lynq_fast_ecall service return fail");
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+ return LYNQ_E_INVALID_ID_ANONALY;
+
+}
+
+int lynq_set_psap(int enable)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+// return lynq_set_common_request(RIL_REQUEST_ECALL_SET_PSAP,1,"%d",enable);
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_SET_PSAP,1,"%d",enable);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+}
+
+int lynq_psap_pull_msd()
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+// return lynq_set_common_request(RIL_REQUEST_ECALL_PSAP_PULL_MSD,0,"");
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_PSAP_PULL_MSD,0,"");
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+}
+
+int lynq_make_ecall(int* handle, LYNQ_ECall_Type type)
+{
+ return RESULT_OK;
+#if 0
+ LYNQ_ECall_Variant lynq_ecall_variant;
+ int error = -1;
+ int lynq_call_id = -1;
+
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is NULL, parameter error ");
+ return -1;
+ }
+
+ error=lynq_set_common_request(RIL_REQUEST_ECALL_MAKE_ECALL,1,"%d",type);
+
+ if(error==0)
+ {
+ lynq_ecall_variant=lynq_get_lynq_ecall_variant_from_lynq_type(type);
+
+ lynq_call_id = addAddr(e_call_addr[lynq_ecall_variant]);
+ s_module_isDial = 1;
+ if(waitCallstateChange(10000)==ETIMEDOUT)//10000ms
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("timeout:wait Call state fail!!!");
+ return error;
+ }
+
+ *handle = lynq_call_id;
+ }
+
+ return error;
+#endif
+}
+
+
+int lynq_set_msd(int* handle, const unsigned char *msd_data, int msd_length)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ char lynq_msd_data[MSD_MAX_LENGTH*2+1]={0};
+ unsigned int i;
+
+ if(handle==NULL || ((*handle) >= LYNQ_CALL_MAX) || msd_length > MSD_MAX_LENGTH || msd_length <= 0 || msd_data ==NULL)
+ {
+ LYERRLOG("lynq_set_msd handle is NULL or *handle %d is greater or equeal to %d or msd_length %d is greater than %d or msd_data %s is NULL, parameter error",*handle,LYNQ_CALL_MAX,msd_length,MSD_MAX_LENGTH, msd_data);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ for(i=0; i<msd_length;i++)
+ {
+ sprintf(&(lynq_msd_data[i<<1]),"%02x",msd_data[i]);
+ }
+
+ LYINFLOG("lynq_set_msd ");
+
+// return lynq_set_common_request(RIL_REQUEST_ECALL_SET_MSD,2,"%d %s",*handle,lynq_msd_data);
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_SET_MSD,2,"%d %s",*handle,lynq_msd_data);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+}
+
+int lynq_set_ivs(int enable)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ if(enable<0)
+ {
+ if(enable >-100)
+ {
+ goto set_ivs_end;
+// lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
+ }
+ else if(enable== -1000)
+ {
+ print_ecall_info();
+ }
+ else
+ {
+ s_ecall_whether_preempt= ((-100-enable) & 0x11);
+ }
+ return RESULT_OK;
+ }
+
+// return lynq_set_common_request(RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
+set_ivs_end:
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_SET_IVS,1,"%d",enable);
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+}
+
+int lynq_reset_ivs()
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+// return lynq_set_common_request(RIL_REQUEST_ECALL_RESET_IVS,0,"");
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_RESET_IVS,0,"");
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+}
+
+int lynq_ivs_push_msd()
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+// return lynq_set_common_request(RIL_REQUEST_ECALL_IVS_PUSH_MSD,0,"");
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_ECALL_IVS_PUSH_MSD,0,"");
+ if(ret==RESULT_OK)
+ {
+ delete p;
+ }
+ return ret;
+}
+
+int wait_ecall_event()
+{
+ int ret = 0;
+ pthread_mutex_lock(&s_incoming_e_call_mutex);
+ ret = pthread_cond_wait(&s_incoming_e_call_cond,&s_incoming_e_call_mutex);
+ pthread_mutex_unlock(&s_incoming_e_call_mutex);
+ return ret;
+}
+
+int lynq_wait_ecall_indication(int* handle, LYNQ_ECall_Indication *eCall_Indication)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ wait_ecall_event();
+ *handle = s_IncomingEcallId;
+ *eCall_Indication = s_IncomingEcallIndication;
+ LYINFLOG("lynq_wait_ecall_indication handle %d, Ind id: %d", *handle, *eCall_Indication);
+ return RESULT_OK;
+}
+void urc_ecall_msg_process(Parcel *p)
+{
+ int ecall_ind;
+ int ecallId;
+ int send_signal_to_wait_call_state;
+ int handup_ecall_id;
+
+ pthread_mutex_lock(&s_ecall_variable_mutex);
+ send_signal_to_wait_call_state = false;
+ handup_ecall_id=false;
+ p->readInt32(&ecall_ind);
+ s_IncomingEcallIndication = ecall_ind;
+ p->readInt32(&ecallId);
+ s_IncomingEcallId = ecallId;
+ LYINFLOG("**************:RIL_UNSOL_ECALL_INDICATIONS ,Id %d, ind %d, ecall dialing is %d, normal dialing is %d, local ecall id is %d",ecallId,ecall_ind,s_module_is_ecall_dial,IsNormalCallDailing(),s_ecallId);
+ switch (s_IncomingEcallIndication)
+ {
+ case LYNQ_ECALL_ACTIVE:
+ if(s_module_is_ecall_dial)
+ {
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_ANSWERED;
+ }
+ break;
+ case LYNQ_ECALL_SENDING_START:
+ if(lynq_ecall_is_in_voice())
+ {
+ LYINFLOG("recv msd in voice, ind is changed to %d",LYNQ_ECALL_SENDING_START_IN_VOICE);
+ s_IncomingEcallIndication = LYNQ_ECALL_SENDING_START_IN_VOICE;
+ }
+ break;
+ case LYNQ_ECALL_LLACK_RECEIVED:
+ case LYNQ_ECALL_ALACK_POSITIVE_RECEIVED:
+ case LYNQ_ECALL_ALACK_CLEARDOWN_RECEIVED:
+ //case LYNQ_ECALL_T5_TIMER_OUT: /*when Certificate CP 1.1.10.2, no msd start (ind 1), so T5 timeout is not regard as success*/
+ case LYNQ_ECALL_T6_TIMER_OUT:
+ case LYNQ_ECALL_T7_TIMER_OUT:
+ if(s_module_is_ecall_dial)
+ {
+ LYINFLOG("ecall is dialing, recv suc indication");
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
+ if(ecallId >0 && find_call_id_with_call_id(ecallId)==INVALID_ID)
+ {
+ LYINFLOG("add ecall in loacl list");
+ s_ecallId = ecallId;
+ addAddr("ecall",s_ecallId);
+ }
+ send_signal_to_wait_call_state=true;
+ }
+ else if(ecallId >0 && (find_call_id_with_call_id(ecallId)==INVALID_ID) && (s_EcallVariant != LYNQ_ECALL_CALLBACK))
+ {
+ LYERRLOG("ecall is not in dialing and first recv suc indication, hangup");
+ handup_ecall_id=true;
+ }
+ else
+ {
+ LYERRLOG("ecall is not in dialing and not first recv suc indication");
+ }
+ break;
+ case LYNQ_ECALL_PSAP_CALLBACK_START:
+ if(lynq_ecall_is_running()==0)
+ {
+ if(ecallId>0)
+ {
+ LYINFLOG("ecall is not running, recv psap call back msd start, set ecall running");
+ s_EcallVariant = LYNQ_ECALL_CALLBACK;
+ s_ecallId = ecallId;
+ if(IsNormalCallDailing())
+ {
+ LYINFLOG("stop normal dial");
+ send_signal_to_wait_call_state=true;
+ }
+ else
+ {
+ LYINFLOG("no normal dial");
+ }
+ }
+ else
+ {
+ LYERRLOG("ecallId is abnormal in psap callback");
+ }
+ }
+ else
+ {
+ LYERRLOG("ecall is running, recv psap call back msd start");
+ }
+ break;
+ case LYNQ_ECALL_ABNORMAL_HANGUP:
+ if(s_module_is_ecall_dial == LYNQ_ECALL_DAILING_STATE_NONE)
+ {
+ LYERRLOG("ecall is not in dialing , recv abnormal hangup");
+ s_ecallId = INVALID_ID;
+ }
+ else if (s_module_is_ecall_dial == LYNQ_ECALL_DAILING_STATE_STARTED)
+ {
+ LYERRLOG("ecall is in dialing state, recv no answer, recv abnormal hangup, dont' redial");
+ s_ecallId = INVALID_ID;
+ send_signal_to_wait_call_state=true;
+ }
+ else {
+ LYINFLOG("ecall is in dialing and recv answer, recv abnormal hangup");
+ }
+ break;
+ case LYNQ_ECALL_DISCONNECTED:
+ case LYNQ_ECALL_REDIAL_TIMER_OUT:
+ case LYNQ_ECALL_T2_TIMER_OUT :
+ case LYNQ_ECALL_IMS_DISCONNECTED:
+ s_ecallId = INVALID_ID;
+ if(s_EcallVariant == LYNQ_ECALL_CALLBACK)
+ {
+ s_EcallVariant = LYNQ_ECALL_VAR_NONE; /*other type, needn't re-initialize*/
+ }
+ if(s_module_is_ecall_dial != LYNQ_ECALL_DAILING_STATE_NONE)
+ {
+ LYERRLOG("ecall is in dialing, recv like disconnect indication");
+ s_module_is_ecall_dial = LYNQ_ECALL_DAILING_STATE_NONE;
+ send_signal_to_wait_call_state=true;
+ }
+ else
+ {
+ LYINFLOG("ecall is not in dialing, recv like disconnect indication");
+ }
+ break;
+ default:
+ LYINFLOG("not special indication");
+ }
+ pthread_mutex_unlock(&s_ecall_variable_mutex);
+ if(send_signal_to_wait_call_state)
+ {
+ sendSignalToWaitCallStateChange();
+ }
+ sendSignalIncomingECallEvent();
+ if(handup_ecall_id)
+ {
+ lynq_call_hungup(&ecallId);
+ }
+ LYINFLOG("**************:RIL_UNSOL_ECALL_INDICATIONS, local ecall id is %d", s_ecallId);
+ return;
+}
+#endif
diff --git a/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp b/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
new file mode 100755
index 0000000..f217c25
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/lynq_call_rtp.cpp
@@ -0,0 +1,357 @@
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include "liblog/lynq_deflog.h"
+#include <sys/time.h>
+#include <string.h>
+#include "lynq_call.h"
+#include "lynq_module_common.h"
+#include "lynq_call_common.h"
+
+#define RTP_FROM_CMD "gst-launch-1.0 -v udpsrc port=%d caps=\'application/x-rtp, media=(string)audio, clock-rate=(int)%d, channels=(int)%d\' ! rtpjitterbuffer latency=%d ! rtppcmadepay ! alawdec ! audioresample ! audioconvert ! alsasink device=\'hw:0,2\'"
+#define RTP_TO_CMD "gst-launch-1.0 -v alsasrc device=\'hw:0,6\' ! audioconvert ! audioresample ! alawenc ! rtppcmapay ! udpsink host=%s %s auto-multicast=true port=%d"
+#define RTP_VLAN_INFO_FORMAT "multicast-iface=\"%s\""
+#define USER_LOG_TAG "LYNQ_CALL"
+
+typedef struct
+{
+ char ip[MAX_IP_LENGTH];
+ int port;
+ char vlan_info[MAX_VLAN_INFO_LENGTH];
+}lynq_rtp_server_info;
+
+typedef struct
+{
+ int port;
+ int clockrate;
+ int latency;
+ int channels;
+}lynq_rtp_client_info;
+
+static lynq_rtp_client_info g_rtp_client_info;
+static lynq_rtp_server_info g_rtp_server_info;
+
+static pthread_t g_rtp_thread[RTP_MODE_MAX];
+static bool g_rtp_thread_valid[RTP_MODE_MAX];
+
+void lynq_init_rtp()
+{
+ memset(&g_rtp_client_info,0,sizeof(g_rtp_client_info));
+ memset(&g_rtp_server_info,0,sizeof(g_rtp_server_info));
+
+
+ lynq_set_rtp_param(8000,1,400);
+
+ for(int i=0;i<RTP_MODE_MAX;i++)
+ {
+ lynq_set_rtp_port(i,6666);
+ g_rtp_thread_valid[i] = 0;
+ }
+
+ LYDBGLOG("lynq init rtp success!!!");
+ return;
+}
+
+/*Audio Path setting begin*/
+/*sub function*/
+void lynq_set_rtp_mixer_ctrl(int enable_rtp)
+{
+ char cmd[256];
+ LYINFLOG("set_rtp_mixer_ctrl %d", enable_rtp);
+ if(enable_rtp)
+ {
+ sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 0);
+ system(cmd);
+ sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 1);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 1);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 1);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 1);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 1);
+ system(cmd);
+ }
+ else
+ {
+ sprintf(cmd, "amixer -D mtk_phonecall cset name=\"Speech_on\" %d", 1);
+ system(cmd);
+ sprintf(cmd, "amixer -D mtk_phonecall cset name=\"M2M_Speech_on\" %d", 0);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH1 DL2_CH1\" %d", 0);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"PCM_2_PB_CH2 DL2_CH2\" %d", 0);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"UL2_CH1 PCM_2_CAP_CH1\" %d", 0);
+ system(cmd);
+ sprintf(cmd, "amixer -c0 cset name=\"UL2_CH2 PCM_2_CAP_CH1\" %d", 0);
+ system(cmd);
+ }
+}
+
+void* lynq_start_rtp_cmd(void *arg)
+{
+ int* rtp_mode= (int*) arg;
+ char cmd[384];
+ char vlan_para_string[sizeof(RTP_VLAN_INFO_FORMAT)+MAX_VLAN_INFO_LENGTH-2/*sizeof "%s"*/]={0};
+ LYINFLOG("lynq_start_rtp_cmd: rtp_mode is %d",(*rtp_mode));
+ if ((*rtp_mode) == RTP_CLIENT)
+ {
+ sprintf(cmd,RTP_FROM_CMD, \
+ g_rtp_client_info.port,g_rtp_client_info.clockrate,g_rtp_client_info.channels, \
+ g_rtp_client_info.latency);
+ // LYINFLOG("start from rtp play: cmd is %s",cmd);
+ system(cmd);
+ }
+ else if ((*rtp_mode) == RTP_SERVER)
+ {
+ if(strlen(g_rtp_server_info.vlan_info)>0)
+ {
+ sprintf(vlan_para_string,RTP_VLAN_INFO_FORMAT,g_rtp_server_info.vlan_info);
+ }
+ sprintf(cmd,RTP_TO_CMD, \
+ g_rtp_server_info.ip,vlan_para_string,g_rtp_server_info.port);
+
+ // LYINFLOG("start to rtp play: cmd is %s",cmd);
+ system(cmd);
+ }
+ return NULL;
+}
+
+int lynq_start_rtp_thread(int rtp_mode)
+{
+ int ret;
+ pthread_attr_t attr;
+ static int start_mode[RTP_MODE_MAX]={0,1};
+
+ pthread_attr_init(&attr);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&(g_rtp_thread[rtp_mode]),&attr,lynq_start_rtp_cmd,&(start_mode[rtp_mode]));
+ if(ret != 0)
+ {
+ g_rtp_thread_valid[rtp_mode]=0;
+ LYERRLOG("rtp create %d pthread error, ret is %d",rtp_mode, ret);
+ return ret;
+ }
+ g_rtp_thread_valid[rtp_mode]=1;
+ return RESULT_OK;
+}
+
+/*set*/
+int lynq_set_voice_audio_mode(const LYNQ_Audio_Mode audio_mode)
+{
+ int ret;
+ int i;
+
+ if(audio_mode==AUDIO_MODE_RTP)
+ {
+ lynq_set_rtp_mixer_ctrl(1);
+ for(i=0;i<RTP_MODE_MAX;i++)
+ {
+ if(!g_rtp_thread_valid[i])
+ {
+ if(lynq_start_rtp_thread(i)!= 0)
+ {
+ LYERRLOG("start rtp %d fail",i);
+ break;
+ }
+ else
+ {
+ LYINFLOG("start rtp %d suc",i);
+ }
+ }
+ else
+ {
+ LYERRLOG("rtp %d needn't start",i);
+ }
+ }
+ if(i!= RTP_MODE_MAX)
+ {
+ LYERRLOG("start rtp whole fail");
+ lynq_set_voice_audio_mode(AUDIO_MODE_CODEC);
+ return RESULT_ERROR;
+ }
+ LYINFLOG("start rtp whole suc");
+ return RESULT_OK;
+ }
+ else if(audio_mode==AUDIO_MODE_CODEC)
+ {
+ for(i=0;i<RTP_MODE_MAX;i++)
+ {
+ if(g_rtp_thread_valid[i])
+ {
+ ret = pthread_cancel(g_rtp_thread[i]);
+ LYINFLOG("pthread cancel rtp %d ret = %d",i,ret);
+ ret = pthread_join(g_rtp_thread[i],NULL);
+ LYINFLOG("pthread join rtp %d ret = %d",i,ret);
+ g_rtp_thread_valid[i] = 0;
+ }
+ else
+ {
+ LYINFLOG("rtp %d needn't stop",i);
+ }
+ }
+ lynq_set_rtp_mixer_ctrl(0);
+ LYINFLOG("stop rtp suc");
+ }
+ return RESULT_OK;
+}
+int lynq_set_remote_rtp_ip(const char* ip, const int ip_length)
+{
+ if (NULL == ip)
+ {
+ LYERRLOG("ip is NULL!!!");
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ if ((ip_length < strlen(ip)+1) || (ip_length > MAX_IP_LENGTH))
+ {
+ LYERRLOG("incoming ip length error %d", ip_length);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ bzero(g_rtp_server_info.ip,MAX_IP_LENGTH);
+ strcpy(g_rtp_server_info.ip,ip);
+
+ LYINFLOG("lynq_set_remote_rtp_ip suc: ip is %s, length is %d", ip,ip_length);
+
+ return RESULT_OK;
+}
+int lynq_set_vlan_info(const char* vlan_info, const int vlan_info_length)
+{
+ if (NULL == vlan_info)
+ {
+ LYERRLOG("vlan_info is NULL!!!");
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ if ((vlan_info_length < strlen(vlan_info)+1) || (vlan_info_length > MAX_VLAN_INFO_LENGTH))
+ {
+ LYERRLOG("incoming vlan_info error, vlan info length %d", vlan_info_length);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+
+ bzero(g_rtp_server_info.vlan_info,MAX_VLAN_INFO_LENGTH);
+ strcpy(g_rtp_server_info.vlan_info,vlan_info);
+
+ LYINFLOG("lynq_set_vlan_info suc: vlan is %s, length is %d", vlan_info,vlan_info_length);
+
+ return RESULT_OK;
+}
+int lynq_set_rtp_port(const LYNQ_Rtp_Mode rtp_mode, const int port)
+{
+ if (port < 0)
+ {
+ LYERRLOG("invalid port number %d", port);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ if (rtp_mode == 0)
+ {
+ g_rtp_client_info.port = port;
+ }
+ else if (rtp_mode == 1)
+ {
+ g_rtp_server_info.port = port;
+ }
+ LYINFLOG("lynq_set_rtp_port suc: LYNQ_Rtp_Mode is %d, port is %d", rtp_mode, port);
+ return RESULT_OK;
+}
+int lynq_set_rtp_param(const int clock_rate,const int channels,const int latency) //only for client mode
+{
+ g_rtp_client_info.clockrate = clock_rate;
+ g_rtp_client_info.channels = channels;
+ g_rtp_client_info.latency = latency;
+ LYINFLOG("lynq_set_rtp_param suc: clockrate is %d, channels is %d, latency is %d", clock_rate, channels, latency);
+ return RESULT_OK;
+}
+/*get*/
+LYNQ_Audio_Mode lynq_get_voice_audio_mode()
+{
+ if(g_rtp_thread_valid[0])
+ {
+ return AUDIO_MODE_RTP;
+ }
+ else
+ {
+ return AUDIO_MODE_CODEC;
+ }
+}
+int lynq_get_remote_rtp_ip(char* ip, const int ip_length)
+{
+ if(ip==NULL)
+ {
+ LYERRLOG("ip is NULL");
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ if(ip_length < strlen(g_rtp_server_info.ip)+1)
+ {
+ LYERRLOG("ip length %d is shorter than saved ip length %d",ip_length,strlen(g_rtp_server_info.ip)+1);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ bzero(ip,ip_length);
+ strcpy(ip,g_rtp_server_info.ip);
+
+ return RESULT_OK;
+}
+int lynq_get_vlan_info(char* vlan_info, const int vlan_info_length)
+{
+ if(vlan_info==NULL)
+ {
+ LYERRLOG("vlan info is NULL");
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ if(vlan_info_length < strlen(g_rtp_server_info.vlan_info)+1)
+ {
+ LYERRLOG("vlan info length %d is shorter than saved vlan info length %d",vlan_info_length,strlen(g_rtp_server_info.vlan_info)+1);
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ bzero(vlan_info,vlan_info_length);
+ strcpy(vlan_info,g_rtp_server_info.vlan_info);
+
+ return RESULT_OK;
+}
+int lynq_get_rtp_port(const LYNQ_Rtp_Mode rtp_mode, int* port)
+{
+ if(port==NULL)
+ {
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ if (rtp_mode == 0)
+ {
+ *port = g_rtp_client_info.port;
+ }
+ else if (rtp_mode == 1)
+ {
+ *port = g_rtp_server_info.port;
+ }
+ return RESULT_OK;
+}
+int lynq_get_rtp_param(int* clock_rate, int* channels, int* latency)//only for client mode
+{
+ if(clock_rate == NULL || channels ==NULL || latency ==NULL)
+ {
+ LYERRLOG("input parameter is NULL");
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+
+ *clock_rate = g_rtp_client_info.clockrate;
+ *channels = g_rtp_client_info.channels ;
+ *latency = g_rtp_client_info.latency;
+
+ return RESULT_OK;
+}
diff --git a/src/lynq/lib/liblynq-call/lynq_module_common.h b/src/lynq/lib/liblynq-call/lynq_module_common.h
new file mode 100755
index 0000000..9e70d6c
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/lynq_module_common.h
@@ -0,0 +1,73 @@
+#ifndef LYNQ_MODULE_COMMON_H
+#define LYNQ_MODULE_COMMON_H
+
+#define RESULT_OK (0)
+#define RESULT_ERROR (-1)
+
+/*the same with lynq_interface.h begin*/
+#define LYNQ_REQUEST_VENDOR_BASE 8000
+#define LYNQ_URC_VENDOR_BASE 9000
+#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
+#define LYNQ_URC_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+1)
+#define LYNQ_URC_DATA_STATUS_IND (LYNQ_URC_VENDOR_BASE+2)
+#define LYNQ_URC_DATA_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+3)
+#define LYNQ_AUTO_ANSWER_CALL (LYNQ_REQUEST_VENDOR_BASE +2)
+#define LYNQ_REQUEST_SET_DTMF_VOLUME (LYNQ_REQUEST_VENDOR_BASE +3)
+#define LYNQ_URC_MODIFY_APNDB (LYNQ_URC_VENDOR_BASE+4)
+#define LYNQ_URC_RESET_APNDB (LYNQ_URC_VENDOR_BASE+5)
+
+
+#define LYNQ_REQUEST_WRITE_SMS_TO_MEMORY (LYNQ_REQUEST_VENDOR_BASE +4)
+#define LYNQ_REQUEST_READ_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 5)
+#define LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 6)
+#define LYNQ_REQUEST_LIST_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 7)
+#define LYNQ_REQUEST_SET_DEFAULT_SIM_ALL (LYNQ_REQUEST_VENDOR_BASE + 8)
+
+#define LYNQ_REQUEST_SET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +9)
+#define LYNQ_REQUEST_GET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +10)
+#define LYNQ_REQUEST_RECORD (LYNQ_REQUEST_VENDOR_BASE +11)
+#define LYNQ_REQUEST_OOS_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +12)
+#define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
+/*the same with lynq_interface.h end*/
+
+typedef enum{
+ /*base abnormal*/
+ LYNQ_E_PARAMETER_ANONALY=7000,
+ LYNQ_E_SEND_REQUEST_FAIL=7001,
+ LYNQ_E_GET_HEAD_ERROR=7002,
+ LYNQ_E_INNER_ERROR=7100,
+ LYNQ_E_MALLOC_ERROR=7101,
+ /**/
+ LYNQ_E_CARDSTATE_ERROR=8000,
+ /* The voice service state is out of service*/
+ LYNQ_E_STATE_OUT_OF_SERVICE=8001,
+ /* The voice service state is EMERGENCY_ONLY*/
+ LYNQ_E_STATE_EMERGENCY_ONLY=8002,
+ /* The radio power is power off*/
+ LYNQ_E_STATE_POWER_OFF=8003,
+ LYNQ_E_TIME_OUT=8004,
+ /*create or open sms DB fail */
+ LYNQ_E_SMS_DB_FAIL=8005,
+ /*Failed to execute sql statement*/
+ LYNQ_E_SMS_SQL_FAIL = 8006,
+ LYNQ_E_SMS_NOT_FIND = 8007,
+ /* The logic conflict*/
+ LYNQ_E_CONFLICT=9000,
+ /*Null anomaly*/
+ LYNQ_E_NULL_ANONALY=9001,
+ /*Invalid id anomaly*/
+ LYNQ_E_INVALID_ID_ANONALY=9002,
+#ifdef ECALL_SUPPORT
+ LYNQ_E_ECALL_BEING_RUNNING =9003,
+ LYNQ_E_ECALL_MSD_LENGTH_ERROR =9004,
+ LYNQ_E_ECALL_DAILING_NO_ANSWER =9005,
+#endif
+}LYNQ_E;
+
+#define MODULE_CLOSED (0)
+#define MODULE_SWITCHING (1)
+#define MODULE_RUNNING (2)
+
+extern int g_module_init_flag;
+
+#endif
diff --git a/src/lynq/lib/liblynq-call/lynq_module_socket.cpp b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
new file mode 100755
index 0000000..71862a8
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/lynq_module_socket.cpp
@@ -0,0 +1,547 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include <list>
+#include <vendor-ril/telephony/ril.h>
+#include <vendor-ril/telephony/mtk_ril_sp.h>
+#include "lynq_call.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+#include "liblog/lynq_deflog.h"
+
+#define LYNQ_SERVICE_PORT 8088
+#define LYNQ_ADDRESS "127.0.0.1"
+#define LYNQ_URC_SERVICE_PORT 8086
+#define LYNQ_URC_ADDRESS "0.0.0.0"
+#define LYNQ_REQUEST_PARAM_BUF 8192
+#define LYNQ_REC_BUF 8192
+
+#define USER_LOG_TAG "LYNQ_NETWORK"
+
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[LYNQ_REQUEST_PARAM_BUF];
+}lynq_client_t;
+
+typedef struct{
+ int resp_type;
+ int token;
+ int request;
+ int slot_id;
+ int error;
+}lynq_resp_t;
+
+lynq_client_t client_t;
+lynq_resp_t response;
+
+int module_len_rc_addr_serv;
+int module_len_urc_addr_serv;
+struct sockaddr_in module_rc_addr_serv;
+struct sockaddr_in module_urc_addr_serv;
+static int module_rc_sock_fd = -1;
+static int module_urc_sock_fd = -1;
+int module_urc_status = 1;
+int module_rc_status = 1;
+pthread_t module_urc_tid = -1;
+pthread_t module_rc_tid = -1;
+static pthread_mutex_t s_urc_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/*hq add for set waiting time 2022/09/13 begin*/
+static pthread_mutex_t s_sendto_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_RecvMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_WaitRecvMsgCond = PTHREAD_COND_INITIALIZER;
+#define BLOCK_RECV_MSG_LOCK() pthread_mutex_lock(&s_RecvMsgBlockMutex)
+#define BLOCK_RECV_MSG_UNLOCK() pthread_mutex_unlock(&s_RecvMsgBlockMutex)
+#define BLOCK_WAIT_RECV_MSG_TIME_OUT(a) pthread_cond_timedwait(&s_WaitRecvMsgCond, &s_RecvMsgBlockMutex,(a))
+#define BLOCK_WAKEUP_RECV_MSG() pthread_cond_broadcast(&s_WaitRecvMsgCond)
+static std::list<Parcel*> s_recv_parcel_list;
+const int waitResponse(int token,int time_out);
+/*hq add for set waiting time 2022/09/13 end*/
+
+int g_module_Global_uToken = 0;
+int g_wait_time=5;
+
+/*inner test*/
+static int s_inner_test=0;
+
+/**@brief just for inner test
+* @param test_mode [IN]: test mode
+* 0:success
+* other:failure
+*/
+void lynq_set_test_mode(const int test_mode)
+{
+ if(test_mode<0)
+ {
+ g_wait_time = -test_mode;
+ }
+ else if(test_mode==9999)
+ {
+ LYERRLOG("%s inner test para %d %d",__func__,s_inner_test,g_wait_time);
+ }
+ else
+ {
+ s_inner_test = test_mode;
+ }
+}
+
+void cleanup_RecvMsgBlock_mutex(void *arg)
+{
+ BLOCK_RECV_MSG_UNLOCK();
+}
+
+/**@brief wait response with expected token and write msg to parcel in some time
+* @param p [IN]: pointer the parcel
+* @param token [IN]: the expected token for the response msg
+* @param time_out [IN]: timeout.
+* @return
+* 0:success
+* other:failure
+*/
+const int waitResponse(Parcel*& p, int token,int time_out)
+{
+ int waitToken = token;
+ int wakeup_token=-1;
+ int resp_type;
+ struct timeval now;
+ struct timespec timeout;
+ int ret;
+ std::list<Parcel*>::iterator iter;
+ int cnt=0;
+
+ gettimeofday(&now,NULL);
+ timeout.tv_sec = now.tv_sec+time_out; //timeout is 1min
+ timeout.tv_nsec = now.tv_usec*1000;
+
+ LYINFLOG("%s wait token is %d, wait time is %d",__func__,waitToken,time_out);
+
+ BLOCK_RECV_MSG_LOCK();
+ pthread_cleanup_push(cleanup_RecvMsgBlock_mutex, NULL); // thread cleanup handler
+ while(module_rc_status) {
+ cnt++;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ (*iter)->setDataPosition(0);
+ (*iter)->readInt32(&resp_type);
+ (*iter)->readInt32(&wakeup_token);
+ if(wakeup_token==waitToken)
+ {
+ LYINFLOG("%s get waitToken",__func__);
+ p=(*iter);
+ p->setDataPosition(0);
+ s_recv_parcel_list.erase(iter);
+ goto waitResponse_end;
+ }
+ }
+ LYINFLOG("%s no wait Token in msg list, list size is %d",__func__,s_recv_parcel_list.size());
+ ret=BLOCK_WAIT_RECV_MSG_TIME_OUT(&timeout);
+ if(ret!=0)
+ {
+ LYERRLOG("%s no expected token %d after %d second",__func__,waitToken,time_out);
+ break;
+ }
+ }
+waitResponse_end:
+ LYINFLOG("%s wait token is %d wakeup_token is %d, cnt is %d",__func__,waitToken,wakeup_token,cnt);
+ pthread_cleanup_pop(0);
+ BLOCK_RECV_MSG_UNLOCK();
+ return wakeup_token==waitToken ? 0:LYNQ_E_TIME_OUT;
+}
+
+/**@brief print solicied response msg's head information
+* @param head [IN]: head information
+* @return none
+*/
+void PrintHeader(lynq_resp_t& head)
+{
+ LYINFLOG("resp_type=%d,token=%d,request=%d,slot_id=%d,error_code=%d",head.resp_type,head.token,head.request,head.slot_id,head.error);
+}
+
+/**@brief get solicied response msg's head
+* @param head [OUT]: head information
+* @return
+* 0:success
+* other:failure
+*/
+int GetHeader(Parcel* &p, lynq_resp_t& head)
+{
+ LYINFLOG("get header");
+ if(p->dataAvail() > 0)
+ {
+ p->readInt32(&(head.resp_type));
+ p->readInt32(&(head.token));
+ p->readInt32(&(head.request));
+ p->readInt32(&(head.slot_id));
+ p->readInt32(&(head.error));
+ PrintHeader(head);
+ return RESULT_OK;
+ }
+ else
+ {
+ return RESULT_ERROR;
+ }
+}
+
+/**@brief send msg to service and get response from service
+* @param request_id [IN]: request id
+* @param time_out [IN]: wait time uplimit
+* @param p [IN]: point to response msg's parcel
+* @param argc [IN]: how many parameters in parameter string
+* @param format [IN]: parameter string's format
+* @param ... [IN]: the specific parameter
+* @return
+* 0:success
+* other:failure
+*/
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...)
+{
+ lynq_client_t client;
+ int ret;
+ int send_num;
+
+ client.uToken = g_module_Global_uToken;
+ g_module_Global_uToken=(g_module_Global_uToken+1)%10000;/*0-10000*/
+ client.request = request_id;
+ client.paramLen = argc;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ if(argc!=0)
+ {
+ va_list args;
+ va_start(args, format);
+ vsnprintf(client.param, LYNQ_REQUEST_PARAM_BUF, format, args);
+ va_end(args);
+ }
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&s_sendto_mutex);
+ if(s_inner_test==1)
+ {
+ send_num = 1;
+ }
+ else
+ {
+ send_num = sendto(module_rc_sock_fd,&client,sizeof(client),0,(struct sockaddr *)&module_rc_addr_serv,module_len_rc_addr_serv);
+ }
+ if(s_inner_test>=1000)
+ {
+ time_out = s_inner_test-1000;
+ }
+ pthread_mutex_unlock(&s_sendto_mutex);
+
+ if(send_num <= 0)
+ {
+ LYERRLOG("send request fail, send num is %d", send_num);
+ return LYNQ_E_SEND_REQUEST_FAIL;
+ }
+ ret = waitResponse(p, client.uToken,time_out);
+
+ if(ret==0)
+ {
+ lynq_resp_t head;
+ ret=GetHeader(p,head);
+ if(ret!=0)
+ {
+ LYERRLOG("%s %d get head error %d",__func__,client.uToken,ret);
+ delete p;
+ return LYNQ_E_GET_HEAD_ERROR;
+ }
+ if(head.error!=0)
+ {
+ LYERRLOG("%s %d mdm return head error %d",__func__,client.uToken,head.error);
+ delete p;
+ return head.error;
+ }
+ LYERRLOG("%s %d suc",__func__,client.uToken);
+ return RESULT_OK;
+ }
+
+ LYERRLOG("%s %d fail, ret is %d",__func__,client.uToken,ret);
+
+ return ret;
+}
+
+/**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
+* @param p [IN]: no meaning
+* @return
+* always null
+*/
+void *thread_rc_recv(void *p)
+{
+ Parcel* rc_p;
+ std::list<Parcel*>::iterator iter;
+ int resp_type = -1;
+ char rc_data[LYNQ_REC_BUF];
+ int rc_len;
+ int null_cnt=0;
+ int wakeup_token;
+
+ LYINFLOG("rc thread is running");
+ while(module_rc_status)
+ {
+ bzero(rc_data,LYNQ_REC_BUF);
+ while(true)
+ {
+ rc_len = recvfrom(module_rc_sock_fd,rc_data,sizeof(rc_data),0,(struct sockaddr *)&module_rc_addr_serv,(socklen_t *)&module_len_rc_addr_serv);
+ if(rc_len<sizeof(int32_t)*2)
+ {
+ LYERRLOG("%s recv len %d less %d",__func__, rc_len,sizeof(int)*2);
+ continue;
+ }
+ rc_p= new Parcel;
+ if(rc_p==NULL)
+ {
+ null_cnt++;
+ LYERRLOG("%s rc_p is NULL, cnt is %d",__func__, null_cnt);
+ if(null_cnt>20)
+ {
+ goto rc_recv_end;
+ }
+ continue;
+ }
+ else
+ {
+ null_cnt=0;
+ }
+
+ rc_p->setData((uint8_t *)rc_data,rc_len); // p.setData((uint8_t *) buffer, buflen);
+ rc_p->setDataPosition(0);
+ if(rc_p->dataAvail()>0)
+ {
+ rc_p->readInt32(&resp_type);
+ rc_p->readInt32(&wakeup_token);
+ BLOCK_RECV_MSG_LOCK();
+ s_recv_parcel_list.push_back(rc_p);
+ LYINFLOG("%s wakeup token is %d, list size is %d!",__func__,wakeup_token,s_recv_parcel_list.size());
+ if(s_recv_parcel_list.size()>20) //max 20
+ {
+ iter=s_recv_parcel_list.begin();
+ (*iter)->setDataPosition(0);
+ (*iter)->readInt32(&resp_type);
+ (*iter)->readInt32(&wakeup_token);
+ delete (*(s_recv_parcel_list.begin()));
+ LYERRLOG("%s wakeup token %d is deleted!",__func__,wakeup_token);
+ s_recv_parcel_list.erase(iter);
+ }
+ BLOCK_WAKEUP_RECV_MSG();
+ BLOCK_RECV_MSG_UNLOCK();
+ break;
+ }
+ else
+ {
+ LYERRLOG("%s rc_p data Avail %d not greater than 0",__func__, rc_p->dataAvail());
+ delete rc_p;
+ }
+ }
+ }
+
+rc_recv_end:
+ LYINFLOG("rc thread ended");
+ return NULL;
+}
+
+void *thread_urc_recv(void *p)
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int res = 0;
+
+ LYINFLOG("urc thread is running");
+ while(module_urc_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
+ if(res<=0)
+ {
+ LYERRLOG("thread_urc_recv step2 fail:");
+ break;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ break;
+ }
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_urc_mutex);
+ urc_msg_process(urc_p);
+ pthread_mutex_unlock(&s_urc_mutex);
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ LYINFLOG("urc thread ended");
+ return NULL;
+}
+
+int lynq_server_socket_start()
+{
+ module_rc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if(module_rc_sock_fd < 0)
+ {
+ LYERRLOG("socket open error");
+ return -1;
+ }
+
+ LYINFLOG("module_rc_sock_fd = %d",module_rc_sock_fd);
+
+ memset(&module_rc_addr_serv, 0, sizeof(module_rc_addr_serv));
+ module_rc_addr_serv.sin_family = AF_INET;
+ module_rc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_ADDRESS);
+ module_rc_addr_serv.sin_port = htons(LYNQ_SERVICE_PORT);
+ module_len_rc_addr_serv = sizeof(module_rc_addr_serv);
+
+ BLOCK_RECV_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_parcel_list.clear();
+ BLOCK_RECV_MSG_UNLOCK();
+
+// pthread_attr_t attr;
+ int ret;
+
+ pthread_mutex_init(&s_sendto_mutex, NULL);
+ pthread_mutex_init(&s_RecvMsgBlockMutex, NULL);
+
+ module_rc_status = 1;
+// pthread_attr_init(&attr);
+// pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_rc_tid,/*&attr*/NULL,thread_rc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("rc pthread create error");
+ module_rc_status =0;
+ close(module_rc_sock_fd);
+ module_rc_sock_fd =-1;
+ return ret;
+ }
+
+ LYINFLOG("rc start success");
+
+ return RESULT_OK;
+}
+
+int lynq_urc_socket_start()
+{
+// pthread_t tid;
+// pthread_attr_t attr;
+ int on = 1;
+ int ret = 0;
+ module_len_urc_addr_serv = sizeof(sockaddr_in);
+ module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (module_urc_sock_fd <0){
+ LYERRLOG("urc socket error");
+ return RESULT_ERROR;
+ }
+ module_urc_addr_serv.sin_family = AF_INET;
+ module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(ret <0)
+ {
+ LYERRLOG("urc socket set error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
+ if(ret <0)
+ {
+ LYERRLOG("urc socket bind error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+
+ module_urc_status = 1;
+ // pthread_attr_init(&attr);
+ // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc pthread create error");
+ module_urc_status = 0;
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ LYINFLOG("urc start success");
+
+ return RESULT_OK;
+}
+
+void lynq_close_urc_thread()
+{
+ int ret;
+
+ pthread_mutex_lock(&s_urc_mutex); //just cancel urc tid when recvfrom avoid mutual lock for tid may call pthread_cond_wait
+ module_urc_status = 0;
+ if(module_urc_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_tid);
+ LYINFLOG("pthread cancel urc ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_urc_mutex);
+ if(module_urc_tid != -1)
+ {
+ ret = pthread_join(module_urc_tid,NULL);
+ LYINFLOG("pthread join urc tid ret = %d",ret);
+ module_urc_tid =-1;
+ }
+ if (module_urc_sock_fd > 0)
+ {
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ }
+}
+
+void lynq_close_rc_thread()
+{
+ int ret;
+ BLOCK_RECV_MSG_LOCK();
+ module_rc_status = 0;
+ BLOCK_WAKEUP_RECV_MSG();
+ if(module_rc_tid != -1)
+ {
+ ret = pthread_cancel(module_rc_tid);
+ LYINFLOG("pthread cancel rc ret = %d",ret);
+ }
+ BLOCK_RECV_MSG_UNLOCK();
+ if(module_rc_tid != -1)
+ {
+ ret = pthread_join(module_rc_tid,NULL);
+ module_rc_tid =-1;
+ LYINFLOG("pthread join rc tid ret = %d",ret);
+ }
+
+
+ if (module_rc_sock_fd > 0)
+ {
+ close(module_rc_sock_fd);
+ module_rc_sock_fd =-1;
+ }
+
+ BLOCK_RECV_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_parcel_list.clear();
+ BLOCK_RECV_MSG_UNLOCK();
+}
+
diff --git a/src/lynq/lib/liblynq-call/lynq_module_socket.h b/src/lynq/lib/liblynq-call/lynq_module_socket.h
new file mode 100755
index 0000000..57466f6
--- /dev/null
+++ b/src/lynq/lib/liblynq-call/lynq_module_socket.h
@@ -0,0 +1,18 @@
+#ifndef LYNQ_MODULE_SOCKET_H
+#define LYNQ_MODULE_SOCKET_H
+
+using ::android::Parcel;
+
+int lynq_set_test_network(const int test_mode);
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
+int lynq_server_socket_start();
+int lynq_urc_socket_start();
+void lynq_close_urc_thread();
+void lynq_close_rc_thread();
+
+extern int g_module_Global_uToken;
+extern int g_wait_time;
+
+void urc_msg_process(Parcel *p);
+
+#endif
diff --git a/src/lynq/lib/liblynq-data/lynq_data.cpp b/src/lynq/lib/liblynq-data/lynq_data.cpp
index 0d76f53..5473fb2 100755
--- a/src/lynq/lib/liblynq-data/lynq_data.cpp
+++ b/src/lynq/lib/liblynq-data/lynq_data.cpp
@@ -851,7 +851,6 @@
p.readInt32(&request);
p.readInt32(&slot_id);
p.readInt32(&error);
- return 0;
}
else
{
diff --git a/src/lynq/lib/liblynq-gnss/src/lynq_prop.c b/src/lynq/lib/liblynq-gnss/src/lynq_prop.c
index 3e53b59..deaacc2 100755
--- a/src/lynq/lib/liblynq-gnss/src/lynq_prop.c
+++ b/src/lynq/lib/liblynq-gnss/src/lynq_prop.c
@@ -67,6 +67,7 @@
LYNQ_STRNCPY(buffer2, val, PROPBUF_SIZE);
strncat(buffer1, "=", PROPBUF_SIZE - strlen(buffer1) - 1);
strncat(buffer1, buffer2, PROPBUF_SIZE - strlen(buffer1) - 1);
+ strncat(buffer1, "\n", PROPBUF_SIZE - strlen(buffer1) - 1);
RLOGD("After modify [%s] in file [%s]", buffer1, file_name);
changed = 1;
fprintf(fp, "%s", buffer1);
@@ -80,6 +81,7 @@
strncat(linebuffer, key, PROPBUF_SIZE - strlen(linebuffer) - 1);
strncat(linebuffer, "=", PROPBUF_SIZE - strlen(linebuffer) - 1);
strncat(linebuffer, val, PROPBUF_SIZE - strlen(linebuffer) - 1);
+ strncat(linebuffer, "\n", PROPBUF_SIZE - strlen(buffer1) - 1);
RLOGD("Add config [%s] to file [%s]", linebuffer, file_name);
res = fseek(fp, 0, SEEK_END);
if(res < 0) {
diff --git a/src/lynq/lib/liblynq-network/include/lynq_network/lynq_network.h b/src/lynq/lib/liblynq-network/include/lynq_network/lynq_network.h
index 9f32bed..5b2ce3c 100755
--- a/src/lynq/lib/liblynq-network/include/lynq_network/lynq_network.h
+++ b/src/lynq/lib/liblynq-network/include/lynq_network/lynq_network.h
@@ -72,12 +72,15 @@
int lynq_set_ims(const int ims_mode);
int lynq_wait_signalchanges(int *handle);
int lynq_get_urc_info(const int handle,signalStrength_t *solSigStren,int *slot_id);
-void lynq_set_voice_registration_valid_period(int valid_period);
-void lynq_set_data_registration_valid_period(int valid_period);
-void lynq_set_ims_registration_valid_period(int valid_period);
-int lynq_get_voice_registration_valid_period();
-int lynq_get_data_registration_valid_period();
-int lynq_get_ims_registration_valid_period();
+
+typedef enum {
+ NETWORK_STATE_BUFFER_TYPE_VOICE_REG,
+ NETWORK_STATE_BUFFER_TYPE_DATA_REG,
+ NETWORK_STATE_BUFFER_TYPE_IMS_REG,
+ NETWORK_STATE_BUFFER_TYPE_MAX,
+}lynq_network_state_buffer_type;
+int lynq_set_state_buffer_valid_period_of_network(lynq_network_state_buffer_type type,int valid_period);
+int lynq_get_state_buffer_valid_period_of_network(lynq_network_state_buffer_type type);
#ifdef MODEM_GEN97
/**@brief set or get OOS recover timer interval
* @param mode [IN] <mode>:
@@ -113,6 +116,7 @@
*/
int lynq_oos_deep_sleep_recover_timer_interval(int recovery_threshold,int fullband_timer,int sniffer_timer,int inactive_mode);
#endif
+void lynq_set_test_mode(const int test_mode);
#ifdef __cplusplus
}
#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_module_common.h b/src/lynq/lib/liblynq-network/lynq_module_common.h
new file mode 100755
index 0000000..a582538
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/lynq_module_common.h
@@ -0,0 +1,63 @@
+#ifndef LYNQ_MODULE_COMMON_H
+#define LYNQ_MODULE_COMMON_H
+
+#define RESULT_OK (0)
+#define RESULT_ERROR (-1)
+
+/*the same with lynq_interface.h begin*/
+#define LYNQ_REQUEST_VENDOR_BASE 8000
+#define LYNQ_URC_VENDOR_BASE 9000
+#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
+#define LYNQ_URC_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+1)
+#define LYNQ_URC_DATA_STATUS_IND (LYNQ_URC_VENDOR_BASE+2)
+#define LYNQ_URC_DATA_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+3)
+#define LYNQ_AUTO_ANSWER_CALL (LYNQ_REQUEST_VENDOR_BASE +2)
+#define LYNQ_REQUEST_SET_DTMF_VOLUME (LYNQ_REQUEST_VENDOR_BASE +3)
+#define LYNQ_URC_MODIFY_APNDB (LYNQ_URC_VENDOR_BASE+4)
+#define LYNQ_URC_RESET_APNDB (LYNQ_URC_VENDOR_BASE+5)
+
+
+#define LYNQ_REQUEST_WRITE_SMS_TO_MEMORY (LYNQ_REQUEST_VENDOR_BASE +4)
+#define LYNQ_REQUEST_READ_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 5)
+#define LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 6)
+#define LYNQ_REQUEST_LIST_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 7)
+#define LYNQ_REQUEST_SET_DEFAULT_SIM_ALL (LYNQ_REQUEST_VENDOR_BASE + 8)
+
+#define LYNQ_REQUEST_SET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +9)
+#define LYNQ_REQUEST_GET_SPEECH_VOLUME (LYNQ_REQUEST_VENDOR_BASE +10)
+#define LYNQ_REQUEST_RECORD (LYNQ_REQUEST_VENDOR_BASE +11)
+#define LYNQ_REQUEST_OOS_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +12)
+#define LYNQ_REQUEST_OOS_DEEP_SLEEP_RECOVER_TIMER_INTERVAL (LYNQ_REQUEST_VENDOR_BASE +13)
+/*the same with lynq_interface.h end*/
+
+typedef enum{
+ /*base abnormal*/
+ LYNQ_E_PARAMETER_ANONALY=7000,
+ LYNQ_E_SEND_REQUEST_FAIL=7001,
+ LYNQ_E_GET_HEAD_ERROR=7002,
+ LYNQ_E_INNER_ERROR=7100,
+ LYNQ_E_MALLOC_ERROR=7101,
+ /**/
+ LYNQ_E_CARDSTATE_ERROR=8000,
+ /* The voice service state is out of service*/
+ LYNQ_E_STATE_OUT_OF_SERVICE=8001,
+ /* The voice service state is EMERGENCY_ONLY*/
+ LYNQ_E_STATE_EMERGENCY_ONLY=8002,
+ /* The radio power is power off*/
+ LYNQ_E_STATE_POWER_OFF=8003,
+ LYNQ_E_TIME_OUT=8004,
+ /*create or open sms DB fail */
+ LYNQ_E_SMS_DB_FAIL=8005,
+ /*Failed to execute sql statement*/
+ LYNQ_E_SMS_SQL_FAIL = 8006,
+ LYNQ_E_SMS_NOT_FIND = 8007,
+ /* The logic conflict*/
+ LYNQ_E_CONFLICT=9000,
+ /*Null anomaly*/
+ LYNQ_E_NULL_ANONALY=9001,
+}LYNQ_E;
+
+#define MODULE_CLOSED (0)
+#define MODULE_SWITCHING (1)
+#define MODULE_RUNNING (2)
+#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_module_socket.cpp b/src/lynq/lib/liblynq-network/lynq_module_socket.cpp
new file mode 100755
index 0000000..fa71d82
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/lynq_module_socket.cpp
@@ -0,0 +1,547 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include <list>
+#include <vendor-ril/telephony/ril.h>
+#include <vendor-ril/telephony/mtk_ril_sp.h>
+#include "lynq_network.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+#include "liblog/lynq_deflog.h"
+
+#define LYNQ_SERVICE_PORT 8088
+#define LYNQ_ADDRESS "127.0.0.1"
+#define LYNQ_URC_SERVICE_PORT 8086
+#define LYNQ_URC_ADDRESS "0.0.0.0"
+#define LYNQ_REQUEST_PARAM_BUF 8192
+#define LYNQ_REC_BUF 8192
+
+#define USER_LOG_TAG "LYNQ_NETWORK"
+
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[LYNQ_REQUEST_PARAM_BUF];
+}lynq_client_t;
+
+typedef struct{
+ int resp_type;
+ int token;
+ int request;
+ int slot_id;
+ int error;
+}lynq_resp_t;
+
+lynq_client_t client_t;
+lynq_resp_t response;
+
+int module_len_rc_addr_serv;
+int module_len_urc_addr_serv;
+struct sockaddr_in module_rc_addr_serv;
+struct sockaddr_in module_urc_addr_serv;
+static int module_rc_sock_fd = -1;
+static int module_urc_sock_fd = -1;
+int module_urc_status = 1;
+int module_rc_status = 1;
+pthread_t module_urc_tid = -1;
+pthread_t module_rc_tid = -1;
+static pthread_mutex_t s_urc_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/*hq add for set waiting time 2022/09/13 begin*/
+static pthread_mutex_t s_sendto_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_RecvMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_WaitRecvMsgCond = PTHREAD_COND_INITIALIZER;
+#define BLOCK_RECV_MSG_LOCK() pthread_mutex_lock(&s_RecvMsgBlockMutex)
+#define BLOCK_RECV_MSG_UNLOCK() pthread_mutex_unlock(&s_RecvMsgBlockMutex)
+#define BLOCK_WAIT_RECV_MSG_TIME_OUT(a) pthread_cond_timedwait(&s_WaitRecvMsgCond, &s_RecvMsgBlockMutex,(a))
+#define BLOCK_WAKEUP_RECV_MSG() pthread_cond_broadcast(&s_WaitRecvMsgCond)
+static std::list<Parcel*> s_recv_parcel_list;
+const int waitResponse(int token,int time_out);
+/*hq add for set waiting time 2022/09/13 end*/
+
+int g_module_Global_uToken = 0;
+int g_wait_time=5;
+
+/*inner test*/
+static int s_inner_test=0;
+
+/**@brief just for inner test
+* @param test_mode [IN]: test mode
+* 0:success
+* other:failure
+*/
+void lynq_set_test_mode(const int test_mode)
+{
+ if(test_mode<0)
+ {
+ g_wait_time = -test_mode;
+ }
+ else if(test_mode==9999)
+ {
+ LYERRLOG("%s inner test para %d %d",__func__,s_inner_test,g_wait_time);
+ }
+ else
+ {
+ s_inner_test = test_mode;
+ }
+}
+
+void cleanup_RecvMsgBlock_mutex(void *arg)
+{
+ BLOCK_RECV_MSG_UNLOCK();
+}
+
+/**@brief wait response with expected token and write msg to parcel in some time
+* @param p [IN]: pointer the parcel
+* @param token [IN]: the expected token for the response msg
+* @param time_out [IN]: timeout.
+* @return
+* 0:success
+* other:failure
+*/
+const int waitResponse(Parcel*& p, int token,int time_out)
+{
+ int waitToken = token;
+ int wakeup_token=-1;
+ int resp_type;
+ struct timeval now;
+ struct timespec timeout;
+ int ret;
+ std::list<Parcel*>::iterator iter;
+ int cnt=0;
+
+ gettimeofday(&now,NULL);
+ timeout.tv_sec = now.tv_sec+time_out; //timeout is 1min
+ timeout.tv_nsec = now.tv_usec*1000;
+
+ LYINFLOG("%s wait token is %d, wait time is %d",__func__,waitToken,time_out);
+
+ BLOCK_RECV_MSG_LOCK();
+ pthread_cleanup_push(cleanup_RecvMsgBlock_mutex, NULL); // thread cleanup handler
+ while(module_rc_status) {
+ cnt++;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ (*iter)->setDataPosition(0);
+ (*iter)->readInt32(&resp_type);
+ (*iter)->readInt32(&wakeup_token);
+ if(wakeup_token==waitToken)
+ {
+ LYINFLOG("%s get waitToken",__func__);
+ p=(*iter);
+ p->setDataPosition(0);
+ s_recv_parcel_list.erase(iter);
+ goto waitResponse_end;
+ }
+ }
+ LYINFLOG("%s no wait Token in msg list, list size is %d",__func__,s_recv_parcel_list.size());
+ ret=BLOCK_WAIT_RECV_MSG_TIME_OUT(&timeout);
+ if(ret!=0)
+ {
+ LYERRLOG("%s no expected token %d after %d second",__func__,waitToken,time_out);
+ break;
+ }
+ }
+waitResponse_end:
+ LYINFLOG("%s wait token is %d wakeup_token is %d, cnt is %d",__func__,waitToken,wakeup_token,cnt);
+ pthread_cleanup_pop(0);
+ BLOCK_RECV_MSG_UNLOCK();
+ return wakeup_token==waitToken ? 0:LYNQ_E_TIME_OUT;
+}
+
+/**@brief print solicied response msg's head information
+* @param head [IN]: head information
+* @return none
+*/
+void PrintHeader(lynq_resp_t& head)
+{
+ LYINFLOG("resp_type=%d,token=%d,request=%d,slot_id=%d,error_code=%d",head.resp_type,head.token,head.request,head.slot_id,head.error);
+}
+
+/**@brief get solicied response msg's head
+* @param head [OUT]: head information
+* @return
+* 0:success
+* other:failure
+*/
+int GetHeader(Parcel* &p, lynq_resp_t& head)
+{
+ LYINFLOG("get header");
+ if(p->dataAvail() > 0)
+ {
+ p->readInt32(&(head.resp_type));
+ p->readInt32(&(head.token));
+ p->readInt32(&(head.request));
+ p->readInt32(&(head.slot_id));
+ p->readInt32(&(head.error));
+ PrintHeader(head);
+ return RESULT_OK;
+ }
+ else
+ {
+ return RESULT_ERROR;
+ }
+}
+
+/**@brief send msg to service and get response from service
+* @param request_id [IN]: request id
+* @param time_out [IN]: wait time uplimit
+* @param p [IN]: point to response msg's parcel
+* @param argc [IN]: how many parameters in parameter string
+* @param format [IN]: parameter string's format
+* @param ... [IN]: the specific parameter
+* @return
+* 0:success
+* other:failure
+*/
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...)
+{
+ lynq_client_t client;
+ int ret;
+ int send_num;
+
+ client.uToken = g_module_Global_uToken;
+ g_module_Global_uToken=(g_module_Global_uToken+1)%10000;/*0-10000*/
+ client.request = request_id;
+ client.paramLen = argc;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ if(argc!=0)
+ {
+ va_list args;
+ va_start(args, format);
+ vsnprintf(client.param, LYNQ_REQUEST_PARAM_BUF, format, args);
+ va_end(args);
+ }
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&s_sendto_mutex);
+ if(s_inner_test==1)
+ {
+ send_num = 1;
+ }
+ else
+ {
+ send_num = sendto(module_rc_sock_fd,&client,sizeof(client),0,(struct sockaddr *)&module_rc_addr_serv,module_len_rc_addr_serv);
+ }
+ if(s_inner_test>=1000)
+ {
+ time_out = s_inner_test-1000;
+ }
+ pthread_mutex_unlock(&s_sendto_mutex);
+
+ if(send_num <= 0)
+ {
+ LYERRLOG("send request fail, send num is %d", send_num);
+ return LYNQ_E_SEND_REQUEST_FAIL;
+ }
+ ret = waitResponse(p, client.uToken,time_out);
+
+ if(ret==0)
+ {
+ lynq_resp_t head;
+ ret=GetHeader(p,head);
+ if(ret!=0)
+ {
+ LYERRLOG("%s %d get head error %d",__func__,client.uToken,ret);
+ delete p;
+ return LYNQ_E_GET_HEAD_ERROR;
+ }
+ if(head.error!=0)
+ {
+ LYERRLOG("%s %d mdm return head error %d",__func__,client.uToken,head.error);
+ delete p;
+ return head.error;
+ }
+ LYERRLOG("%s %d suc",__func__,client.uToken);
+ return RESULT_OK;
+ }
+
+ LYERRLOG("%s %d fail, ret is %d",__func__,client.uToken,ret);
+
+ return ret;
+}
+
+/**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
+* @param p [IN]: no meaning
+* @return
+* always null
+*/
+void *thread_rc_recv(void *p)
+{
+ Parcel* rc_p;
+ std::list<Parcel*>::iterator iter;
+ int resp_type = -1;
+ char rc_data[LYNQ_REC_BUF];
+ int rc_len;
+ int null_cnt=0;
+ int wakeup_token;
+
+ LYINFLOG("rc thread is running");
+ while(module_rc_status)
+ {
+ bzero(rc_data,LYNQ_REC_BUF);
+ while(true)
+ {
+ rc_len = recvfrom(module_rc_sock_fd,rc_data,sizeof(rc_data),0,(struct sockaddr *)&module_rc_addr_serv,(socklen_t *)&module_len_rc_addr_serv);
+ if(rc_len<sizeof(int32_t)*2)
+ {
+ LYERRLOG("%s recv len %d less %d",__func__, rc_len,sizeof(int)*2);
+ continue;
+ }
+ rc_p= new Parcel;
+ if(rc_p==NULL)
+ {
+ null_cnt++;
+ LYERRLOG("%s rc_p is NULL, cnt is %d",__func__, null_cnt);
+ if(null_cnt>20)
+ {
+ goto rc_recv_end;
+ }
+ continue;
+ }
+ else
+ {
+ null_cnt=0;
+ }
+
+ rc_p->setData((uint8_t *)rc_data,rc_len); // p.setData((uint8_t *) buffer, buflen);
+ rc_p->setDataPosition(0);
+ if(rc_p->dataAvail()>0)
+ {
+ rc_p->readInt32(&resp_type);
+ rc_p->readInt32(&wakeup_token);
+ BLOCK_RECV_MSG_LOCK();
+ s_recv_parcel_list.push_back(rc_p);
+ LYINFLOG("%s wakeup token is %d, list size is %d!",__func__,wakeup_token,s_recv_parcel_list.size());
+ if(s_recv_parcel_list.size()>20) //max 20
+ {
+ iter=s_recv_parcel_list.begin();
+ (*iter)->setDataPosition(0);
+ (*iter)->readInt32(&resp_type);
+ (*iter)->readInt32(&wakeup_token);
+ delete (*(s_recv_parcel_list.begin()));
+ LYERRLOG("%s wakeup token %d is deleted!",__func__,wakeup_token);
+ s_recv_parcel_list.erase(iter);
+ }
+ BLOCK_WAKEUP_RECV_MSG();
+ BLOCK_RECV_MSG_UNLOCK();
+ break;
+ }
+ else
+ {
+ LYERRLOG("%s rc_p data Avail %d not greater than 0",__func__, rc_p->dataAvail());
+ delete rc_p;
+ }
+ }
+ }
+
+rc_recv_end:
+ LYINFLOG("rc thread ended");
+ return NULL;
+}
+
+void *thread_urc_recv(void *p)
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int res = 0;
+
+ LYINFLOG("urc thread is running");
+ while(module_urc_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(module_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&module_urc_addr_serv,(socklen_t*)&module_len_urc_addr_serv);
+ if(res<=0)
+ {
+ LYERRLOG("thread_urc_recv step2 fail:");
+ break;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ break;
+ }
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_urc_mutex);
+ urc_msg_process(urc_p);
+ pthread_mutex_unlock(&s_urc_mutex);
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ LYINFLOG("urc thread ended");
+ return NULL;
+}
+
+int lynq_server_socket_start()
+{
+ module_rc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if(module_rc_sock_fd < 0)
+ {
+ LYERRLOG("socket open error");
+ return -1;
+ }
+
+ LYINFLOG("module_rc_sock_fd = %d",module_rc_sock_fd);
+
+ memset(&module_rc_addr_serv, 0, sizeof(module_rc_addr_serv));
+ module_rc_addr_serv.sin_family = AF_INET;
+ module_rc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_ADDRESS);
+ module_rc_addr_serv.sin_port = htons(LYNQ_SERVICE_PORT);
+ module_len_rc_addr_serv = sizeof(module_rc_addr_serv);
+
+ BLOCK_RECV_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_parcel_list.clear();
+ BLOCK_RECV_MSG_UNLOCK();
+
+// pthread_attr_t attr;
+ int ret;
+
+ pthread_mutex_init(&s_sendto_mutex, NULL);
+ pthread_mutex_init(&s_RecvMsgBlockMutex, NULL);
+
+ module_rc_status = 1;
+// pthread_attr_init(&attr);
+// pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_rc_tid,/*&attr*/NULL,thread_rc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("rc pthread create error");
+ module_rc_status =0;
+ close(module_rc_sock_fd);
+ module_rc_sock_fd =-1;
+ return ret;
+ }
+
+ LYINFLOG("rc start success");
+
+ return RESULT_OK;
+}
+
+int lynq_urc_socket_start()
+{
+// pthread_t tid;
+// pthread_attr_t attr;
+ int on = 1;
+ int ret = 0;
+ module_len_urc_addr_serv = sizeof(sockaddr_in);
+ module_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (module_urc_sock_fd <0){
+ LYERRLOG("urc socket error");
+ return RESULT_ERROR;
+ }
+ module_urc_addr_serv.sin_family = AF_INET;
+ module_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ module_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ ret = setsockopt(module_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(ret <0)
+ {
+ LYERRLOG("urc socket set error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ ret = bind(module_urc_sock_fd ,(struct sockaddr*)&module_urc_addr_serv, sizeof(module_urc_addr_serv));
+ if(ret <0)
+ {
+ LYERRLOG("urc socket bind error");
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+
+ module_urc_status = 1;
+ // pthread_attr_init(&attr);
+ // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&module_urc_tid,/*&attr*/NULL,thread_urc_recv,NULL);
+ if(ret <0)
+ {
+ LYERRLOG("urc pthread create error");
+ module_urc_status = 0;
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ return RESULT_ERROR;
+ }
+ LYINFLOG("urc start success");
+
+ return RESULT_OK;
+}
+
+void lynq_close_urc_thread()
+{
+ int ret;
+
+ pthread_mutex_lock(&s_urc_mutex); //just cancel urc tid when recvfrom avoid mutual lock for tid may call pthread_cond_wait
+ module_urc_status = 0;
+ if(module_urc_tid!=-1)
+ {
+ ret = pthread_cancel(module_urc_tid);
+ LYINFLOG("pthread cancel urc ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_urc_mutex);
+ if(module_urc_tid != -1)
+ {
+ ret = pthread_join(module_urc_tid,NULL);
+ LYINFLOG("pthread join urc tid ret = %d",ret);
+ module_urc_tid =-1;
+ }
+ if (module_urc_sock_fd > 0)
+ {
+ close(module_urc_sock_fd);
+ module_urc_sock_fd =-1;
+ }
+}
+
+void lynq_close_rc_thread()
+{
+ int ret;
+ BLOCK_RECV_MSG_LOCK();
+ module_rc_status = 0;
+ BLOCK_WAKEUP_RECV_MSG();
+ if(module_rc_tid != -1)
+ {
+ ret = pthread_cancel(module_rc_tid);
+ LYINFLOG("pthread cancel rc ret = %d",ret);
+ }
+ BLOCK_RECV_MSG_UNLOCK();
+ if(module_rc_tid != -1)
+ {
+ ret = pthread_join(module_rc_tid,NULL);
+ module_rc_tid =-1;
+ LYINFLOG("pthread join rc tid ret = %d",ret);
+
+ }
+
+ if (module_rc_sock_fd > 0)
+ {
+ close(module_rc_sock_fd);
+ module_rc_sock_fd =-1;
+ }
+
+ BLOCK_RECV_MSG_LOCK();
+ std::list<Parcel*>::iterator iter;
+ for(iter=s_recv_parcel_list.begin();iter!=s_recv_parcel_list.end();++iter)
+ {
+ delete (*iter);
+ }
+ s_recv_parcel_list.clear();
+ BLOCK_RECV_MSG_UNLOCK();
+}
+
diff --git a/src/lynq/lib/liblynq-network/lynq_module_socket.h b/src/lynq/lib/liblynq-network/lynq_module_socket.h
new file mode 100755
index 0000000..fb1785a
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/lynq_module_socket.h
@@ -0,0 +1,18 @@
+#ifndef LYNQ_MODULE_SOCKET_H
+#define LYNQ_MODULE_SOCKET_H
+
+using ::android::Parcel;
+
+int lynq_set_test_network(const int test_mode);
+int lynq_send_common_request(Parcel*& p, int time_out, int request_id, int argc, const char* format,...);
+int lynq_server_socket_start();
+int lynq_urc_socket_start();
+void lynq_close_urc_thread();
+void lynq_close_rc_thread();
+
+extern int g_module_Global_uToken;
+extern int g_wait_time;
+
+void urc_msg_process(Parcel *p);
+
+#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_module_state_buffer.cpp b/src/lynq/lib/liblynq-network/lynq_module_state_buffer.cpp
new file mode 100755
index 0000000..d7c9111
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/lynq_module_state_buffer.cpp
@@ -0,0 +1,387 @@
+#include <stdio.h>
+#include <stdint.h> /*just for uint64_t in lynq_query_cell_info 20220819 hq*/
+#include <sys/types.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <signal.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <climits>
+#include "liblog/lynq_deflog.h"
+#include "lynq_network.h"
+#include "lynq_module_common.h"
+#include "lynq_module_state_buffer.h"
+
+#define USER_LOG_TAG "LYNQ_NETWORK"
+
+static timer_t s_state_buffer_timer[NETWORK_STATE_BUFFER_TYPE_MAX];
+
+static int s_state_buffer_sig_value[NETWORK_STATE_BUFFER_TYPE_MAX]={2,3,4};
+
+static int s_state_buffer_valid[NETWORK_STATE_BUFFER_TYPE_MAX]={false,false,false};
+
+static char* s_state_buffer_file[NETWORK_STATE_BUFFER_TYPE_MAX]={
+ "/data/ril/network/.network_register_voice_buffer",
+ "/data/ril/network/.network_register_data_buffer",
+ "/data/ril/network/.network_register_ims_buffer"
+};
+
+#define STATE_BUFFER_CONFIG_FILE "/data/ril/network/.state_buffer_cfg"
+typedef struct{
+ int valid_period[NETWORK_STATE_BUFFER_TYPE_MAX];
+}network_state_buffer_cfg;
+static network_state_buffer_cfg s_state_buffer_cfg;
+static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
+
+void get_state_buffer_timer_length_from_file()
+{
+ int fd_backup;
+ int ret;
+ memset(&s_state_buffer_cfg,0,sizeof (s_state_buffer_cfg));
+ fd_backup = open(STATE_BUFFER_CONFIG_FILE,O_RDONLY | O_CREAT,0777);
+ if (fd_backup < 0) {
+ LYERRLOG("%s open file faile, error is %s\n",__func__,strerror(errno));
+ return;
+ }
+
+ ret = read(fd_backup,&s_state_buffer_cfg,sizeof (s_state_buffer_cfg));
+ if(ret<=0)
+ {
+ LYERRLOG("%s read fail, ret is %d",__func__,ret);
+ memset(&s_state_buffer_cfg,0,sizeof (s_state_buffer_cfg));
+ }
+ else
+ {
+ LYINFLOG("%s suc",__func__);
+ }
+ close(fd_backup);
+
+ return;
+}
+
+int set_state_buffer_timer_length_to_file()
+{
+ int fd_backup;
+ int ret;
+ fd_backup = open(STATE_BUFFER_CONFIG_FILE,O_WRONLY | O_CREAT,0777);
+ if (fd_backup < 0) {
+ LYERRLOG("%s open file fail, error is %s\n",__func__,strerror(errno));
+ return -1;
+ }
+
+ ret = write(fd_backup,&s_state_buffer_cfg,sizeof (s_state_buffer_cfg));
+ if(ret<=0)
+ {
+ LYERRLOG("%s write fail, ret is %d",__func__,ret);
+ }
+ else
+ {
+ LYINFLOG("%s suc",__func__);
+ }
+ close(fd_backup);
+
+ return ret>0? 0:-2;
+}
+
+void start_network_timer(timer_t timer, int signal_value, int milliseconds) {
+ LYINFLOG("start_network_timer(), timer_id=%ld, signal_value=%d, time=%d",(long)timer, signal_value, milliseconds);
+
+ struct itimerspec expire;
+ expire.it_interval.tv_sec = 0;
+ expire.it_interval.tv_nsec = 0;
+ expire.it_value.tv_sec = milliseconds/1000;
+ expire.it_value.tv_nsec = (milliseconds%1000)*1000000;
+ if (timer_settime(timer, 0, &expire, NULL) == -1) {
+ LYERRLOG("timer_settime failed reason=[%s]", strerror(errno));
+ }
+}
+
+void stop_network_timer(timer_t timer, int signal_value) {
+ LYINFLOG("stop_network_timer(), timer_id=%ld, signal_value=%d", (long)timer, signal_value);
+ struct itimerspec timespec;
+ if(timer_gettime(timer, ×pec) == -1) {
+ LYERRLOG("stop_network_timer(), get time fail(%s)", strerror(errno));
+ return;
+ }
+ LYINFLOG("stop_network_timer(), tv_sec=%ld, tv_nsec=%ld",timespec.it_value.tv_sec, timespec.it_value.tv_nsec);
+ if((timespec.it_value.tv_sec == 0) && (timespec.it_value.tv_nsec == 0) ) {
+ LYINFLOG("stop_network_timer(), timer_id(%ld) had stopped, just return", (long)timer);
+ return;
+ } else {
+ start_network_timer(timer, signal_value, 0);
+ }
+}
+
+void network_timer_handler(sigval_t sig) {
+ LYINFLOG("network_timer_handler, sig_value: %d", sig.sival_int);
+ int s;
+ s = pthread_mutex_lock(&mtx);
+ if(s != 0) {
+ LYERRLOG("network_timer_handler, pthead_mutex_lock fail");
+ }
+ for(int i=0;i<NETWORK_STATE_BUFFER_TYPE_MAX;i++)
+ {
+ if(sig.sival_int == s_state_buffer_sig_value[i])
+ {
+ s_state_buffer_valid[i]=false;
+ break;
+ }
+ }
+ s = pthread_mutex_unlock(&mtx);
+ if(s != 0) {
+ LYERRLOG("network_timer_handler, pthread_mutex_unlock fail");
+ }
+}
+
+void init_network_timer(timer_t* timer, int signal_value)
+{
+ struct sigevent sevp;
+ memset(&sevp, 0, sizeof(sevp));
+ sevp.sigev_value.sival_int = signal_value;
+ sevp.sigev_notify = SIGEV_THREAD;
+ sevp.sigev_notify_function = network_timer_handler;
+
+ if(timer_create(CLOCK_MONOTONIC, &sevp, timer) == -1) {
+ LYERRLOG("init_network_timer() failed reason=[%s]", strerror(errno));
+ }
+ LYINFLOG("init_network_timer(), timer_Id = %ld, signal_value=%d", (long)(*timer), signal_value);
+}
+
+void init_network_timer_all() {
+
+ for(int i=0;i<NETWORK_STATE_BUFFER_TYPE_MAX;i++){
+ init_network_timer(&s_state_buffer_timer[i],s_state_buffer_sig_value[i]);
+ s_state_buffer_valid[i] = false;
+ }
+ get_state_buffer_timer_length_from_file();
+}
+
+void deinit_network_timer_all()
+{
+ for(int i=0;i<NETWORK_STATE_BUFFER_TYPE_MAX;i++){
+ stop_network_timer(&s_state_buffer_timer[i],s_state_buffer_sig_value[i]);
+ s_state_buffer_valid[i] = false;
+ }
+}
+
+int is_period_equal_not_valid(int period)
+{
+ return period<=0 || (period > INT_MAX/1000);
+}
+
+void set_state_buffer_valid(lynq_network_state_buffer_type type,int valid)
+{
+ if(is_period_equal_not_valid(s_state_buffer_cfg.valid_period[type]))
+ {
+ valid=false;
+ }
+ s_state_buffer_valid[type] = valid;
+ if(s_state_buffer_valid[type]==false)
+ {
+ stop_network_timer(s_state_buffer_timer[type], s_state_buffer_sig_value[type]);
+ }
+ else
+ {
+ start_network_timer(s_state_buffer_timer[type], s_state_buffer_sig_value[type],s_state_buffer_cfg.valid_period[type]*1000);
+ }
+ LYINFLOG("%s type %d valid is %d",__func__,type,valid);
+}
+
+int get_state_buffer_valid(lynq_network_state_buffer_type type)
+{
+ return s_state_buffer_valid[type];
+}
+
+void set_state_to_buf(lynq_network_state_buffer_type type,...)
+{
+ int ret;
+ int fd_backup;
+
+ if(is_period_equal_not_valid(s_state_buffer_cfg.valid_period[type]))
+ {
+ LYINFLOG("%s type %d timer length %d is equal not valid",__func__,type,s_state_buffer_cfg.valid_period[type]);
+ return;
+ }
+
+ fd_backup = open(s_state_buffer_file[type],O_WRONLY | O_CREAT,0777);
+
+ if (fd_backup < 0) {
+ LYERRLOG("%s Error opening registrate buffer file: %s\n",__func__,strerror(errno));
+ return ;
+ }
+
+ va_list pArgs;
+ va_start(pArgs, type);
+
+ int int_num;
+ int i,int_value;
+
+ int_num = va_arg(pArgs, int);
+ LYINFLOG("%s int_num is %d",__func__,int_num);
+ for(i=0;i<int_num;i++)
+ {
+ int_value=va_arg(pArgs, int);
+ LYINFLOG("%s int_value is %d",__func__,int_value);
+ ret = write(fd_backup,&int_value,sizeof (int));
+ if(ret<=0)
+ {
+ LYERRLOG("%s write int %d value %d fail, ret is %d",__func__,i,int_value,ret);
+ goto set_state_error_done;
+ }
+
+ }
+
+ int stringNum;
+ char * p_value;
+ int stringLen;
+
+ stringNum = va_arg(pArgs, int);
+ LYINFLOG("%s stringNum is %d",__func__,stringNum);
+ for(i=0;i<stringNum;i++)
+ {
+ p_value=va_arg(pArgs, char*);
+ stringLen=strlen(p_value)+1;
+ LYINFLOG("%s p_value is %s,stringlen is %d",__func__,p_value,stringLen);
+ ret = write(fd_backup,&stringLen,sizeof(int));
+ if(ret<=0)
+ {
+ LYERRLOG("%s write %i stringlen %d fail, ret is %d",__func__,i,stringLen,ret);
+ goto set_state_error_done;
+ }
+ ret = write(fd_backup,p_value,stringLen);
+ if(ret<=0)
+ {
+ LYERRLOG("%s write string %d stringlen %d fail, ret is %d",__func__,i, stringLen,ret);
+ goto set_state_error_done;
+ }
+ }
+
+ va_end(pArgs);
+
+ sync();
+ close(fd_backup);
+ set_state_buffer_valid(type,true);
+ LYINFLOG("%s type %d suc",__func__,type);
+ return;
+
+set_state_error_done:
+ set_state_buffer_valid(type,false);
+ close(fd_backup);
+ return;
+}
+
+int get_state_from_buf(lynq_network_state_buffer_type type,...)
+{
+ int ret;
+ int fd_backup;
+
+ if(!get_state_buffer_valid(type))
+ {
+ LYINFLOG("%s type %d buffer not valid",__func__,type);
+ return 1;
+ }
+
+ fd_backup = open(s_state_buffer_file[type], O_RDONLY);
+
+ if (fd_backup < 0) {
+ LYERRLOG("%s Error opening type %d buffer file: %s\n",__func__,type,strerror(errno));
+ set_state_buffer_valid(type,false);
+ return -1;
+ }
+
+ va_list pArgs;
+ va_start(pArgs, type);
+ int int_p_num;
+ int i;
+ int* int_p_value;
+
+ int_p_num= va_arg(pArgs, int);
+ LYINFLOG("%s int_num is %d",__func__,int_p_num);
+ for(i=0;i<int_p_num;i++)
+ {
+ int_p_value=va_arg(pArgs, int*);
+ ret = read(fd_backup,int_p_value,sizeof (int));
+ LYINFLOG("%s int_p_value is %d",__func__,(*int_p_value));
+ if(ret<=0)
+ {
+ LYERRLOG("%s read int %d fail, ret is %d",__func__,i,ret);
+ goto get_state_error_done;
+ }
+
+ }
+
+ int stringNum;
+ char * p_value;
+ int stringLen;
+
+ stringNum = va_arg(pArgs, int);
+ LYINFLOG("%s stringNum is %d",__func__,stringNum);
+ for(i=0;i<stringNum;i++)
+ {
+ ret = read(fd_backup,&stringLen,sizeof (int));
+ if(ret<=0)
+ {
+ LYERRLOG("%s get %d string len fail, ret is %d",__func__,i,ret);
+ goto get_state_error_done;
+ }
+ LYINFLOG("%s stringlen is %d",__func__,stringLen);
+ p_value=va_arg(pArgs, char*);
+ ret = read(fd_backup,p_value,stringLen);
+ if(ret<=0)
+ {
+ LYERRLOG("%s get %d string fail, stringlen is %d, ret is %d",__func__, stringLen,ret);
+ goto get_state_error_done;
+ }
+ LYINFLOG("%s p_value is %s",__func__,p_value);
+ }
+ va_end(pArgs);
+
+ close(fd_backup);
+ LYINFLOG("%s type %d suc",__func__,type);
+ return 0;
+
+get_state_error_done:
+ set_state_buffer_valid(type,false);
+ close(fd_backup);
+ return -1;
+}
+
+int lynq_set_state_buffer_valid_period_of_network(lynq_network_state_buffer_type type,int valid_period)
+{
+ if(type>NETWORK_STATE_BUFFER_TYPE_MAX || type <0)
+ {
+ LYERRLOG("%s type %d error",__func__,type);
+ return -1;
+ }
+ if(valid_period>INT_MAX/1000 || valid_period <0)
+ {
+ LYERRLOG("%s type %d error",__func__,valid_period);
+ return -2;
+ }
+
+ network_state_buffer_cfg cfg_back=s_state_buffer_cfg;
+ s_state_buffer_cfg.valid_period[type]=valid_period;
+ int ret=set_state_buffer_timer_length_to_file();
+ if(ret!=0)
+ {
+ s_state_buffer_cfg=cfg_back;
+ }
+ else
+ {
+ set_state_buffer_valid(type,false);
+ }
+ LYINFLOG("%s type %d period %d ret is %d",__func__,type,valid_period,ret);
+ return ret;
+}
+
+int lynq_get_state_buffer_valid_period_of_network(lynq_network_state_buffer_type type)
+{
+ if(type>NETWORK_STATE_BUFFER_TYPE_MAX || type <0)
+ {
+ LYERRLOG("%s type %d error",__func__,type);
+ return 0;
+ }
+ return s_state_buffer_cfg.valid_period[type];
+}
diff --git a/src/lynq/lib/liblynq-network/lynq_module_state_buffer.h b/src/lynq/lib/liblynq-network/lynq_module_state_buffer.h
new file mode 100755
index 0000000..35357a3
--- /dev/null
+++ b/src/lynq/lib/liblynq-network/lynq_module_state_buffer.h
@@ -0,0 +1,17 @@
+#ifndef LYNQ_MODULE_STATE_BUFFER_H
+#define LYNQ_MODULE_STATE_BUFFER_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void set_state_buffer_valid(lynq_network_state_buffer_type type,int valid);
+void set_state_to_buf(lynq_network_state_buffer_type type,...);
+int get_state_from_buf(lynq_network_state_buffer_type type,...);
+void init_network_timer_all();
+void deinit_network_timer_all();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_network.cpp b/src/lynq/lib/liblynq-network/lynq_network.cpp
index 2212648..cca772f 100755
--- a/src/lynq/lib/liblynq-network/lynq_network.cpp
+++ b/src/lynq/lib/liblynq-network/lynq_network.cpp
@@ -8,688 +8,89 @@
#include <log/log.h>
#include <cutils/jstring.h>
#include <pthread.h>
-#include <list>
#include <vendor-ril/telephony/ril.h>
#include <vendor-ril/telephony/mtk_ril_sp.h>
-
-#include "lynq_network.h"
#include "liblog/lynq_deflog.h"
-#include "lynq_network_state_buffer.h"
-#define LYNQ_SERVICE_PORT 8088
-#define LYNQ_URC_SERVICE_PORT 8086
-#define LYNQ_URC_ADDRESS "0.0.0.0"
-#define LYNQ_ADDRESS "127.0.0.1"
-#define LYNQ_REQUEST_PARAM_BUF 8192
-#define LYNQ_REC_BUF 8192
-#define LYNQ_RESP_BUF 128
+#include "lynq_network.h"
+#include "lynq_module_common.h"
+#include "lynq_module_socket.h"
+#include "lynq_module_state_buffer.h"
+
+#define LYNQ_RESP_STRING_MAX_NUM 128
#define LYNQ_TYPE_BUF 10
#define USER_LOG_TAG "LYNQ_NETWORK"
-
using ::android::Parcel;
+static int s_module_wait_urc_id;
+static int s_module_urc_slot_id;
+static signalStrength_t s_network_urc_solSigStren;
-typedef struct{
- int uToken;
- int request;
- int paramLen;
- char param[LYNQ_REQUEST_PARAM_BUF];
-}lynq_client_t;
-
-typedef struct{
- int resp_type;
- int token;
- int request;
- int slot_id;
- int error;
-}lynq_resp_t;
-
-lynq_client_t client_t;
-lynq_resp_t response;
-
-int network_len_addr_serv;
-int network_len_urc_addr_serv;
-struct sockaddr_in network_addr_serv;
-struct sockaddr_in network_urc_addr_serv;
-static int network_sock_fd = 0;
-int network_urc_sock_fd = 0;
-int network_Global_uToken = 0;
-int network_slot_id = -1;
-int network_urc_slot_id = -1;
-int network_urc_status = 1;
-int network_wait_urc_id = 0;
-signalStrength_t network_urc_solSigStren;
-/**g_lynq_network_init_flag
+/**g_module_init_flag
* @brief mark network initialization state
* 0:deinit status
* 1:init state
*/
-static int g_lynq_network_init_flag = 0;
-
-static pthread_mutex_t signal_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t signal_state_change_cond = PTHREAD_COND_INITIALIZER;
-
-/**g_lynq_network_sendto_mutex
-* @brief mark network send request mutex
-*/
-static pthread_mutex_t g_lynq_network_sendto_mutex;
-
-
-/*hq add for set waiting time 2022/09/13 begin*/
-int network_rc_status = 1;
-static pthread_mutex_t s_RecvMsgBlockMutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t s_WaitRecvMsgCond = PTHREAD_COND_INITIALIZER;
-#define BLOCK_RC_MSG_LOCK() pthread_mutex_lock(&s_RecvMsgBlockMutex)
-#define BLOCK_RC_MSG_UNLOCK() pthread_mutex_unlock(&s_RecvMsgBlockMutex)
-#define BLOCK_WAIT_RECV_MSG_TIME_OUT(a) pthread_cond_timedwait(&s_WaitRecvMsgCond, &s_RecvMsgBlockMutex,(a))
-#define BLOCK_WAKEUP_RECV_MSG() pthread_cond_broadcast(&s_WaitRecvMsgCond)
-std::list<Parcel*> g_recv_parcel_list;
-const int waitResponse(int token,int time_out);
-int g_inner_test=0;
-/*hq add for set waiting time 2022/09/13 end*/
-
-
-//static pthread_mutex_t g_lynq_network_recv_mutex;
-
-typedef enum{
- LYNQ_E_CARDSTATE_ERROR=8000,
- /* The voice service state is out of service*/
- LYNQ_E_STATE_OUT_OF_SERVICE=8001,
- /* The voice service state is EMERGENCY_ONLY*/
- LYNQ_E_STATE_EMERGENCY_ONLY=8002,
- /* The radio power is power off*/
- LYNQ_E_STATE_POWER_OFF=8003,
- LYNQ_E_TIME_OUT=8004,
- /*create or open sms DB fail */
- LYNQ_E_SMS_DB_FAIL=8005,
- /*Failed to execute sql statement*/
- LYNQ_E_SMS_SQL_FAIL = 8006,
- LYNQ_E_SMS_NOT_FIND = 8007,
- /* The logic conflict*/
- LYNQ_E_CONFLICT=9000,
- /*Null anomaly*/
- LYNQ_E_NULL_ANONALY=9001
-}LYNQ_E;
-
-
-/**@brief get response and write msg to parcel
-* @param p [IN] <p>: the parcel
-*
-* @param time_out [IN] <time_out>: timeout.
-* < 0:use defult timeout(5s)
-* >=0:use this timeout
-* @return
-* 0:success
-* other:failure
-*/
-int get_response(Parcel &p,int time_out)
-{
- int len = 0;
- char recvline[LYNQ_REC_BUF];
- bzero(recvline,LYNQ_REC_BUF);
- LYINFLOG("get response");
- /* receive data from server */
- struct timeval timeOut;
- timeOut.tv_sec = 30; //defualt 5s
- timeOut.tv_usec = 0;
- if(time_out >= 0)
- {
- LYINFLOG("use time out %d",time_out);
- timeOut.tv_sec = time_out; //just set second
- }
- if(setsockopt(network_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) < 0)
- {
- LYERRLOG("time out setting failed");
- return -1;
- }
- len = recvfrom(network_sock_fd,recvline,sizeof(recvline),0,(struct sockaddr *)&network_addr_serv,(socklen_t *)&network_len_addr_serv);
- if(len == -1 && errno == EAGAIN)
- {
- LYERRLOG("read error,maybe timeout: %s",strerror(errno));
- return LYNQ_E_TIME_OUT;
- }
- if (recvline != NULL)
- {
- p.setData((uint8_t *)recvline,len); // p.setData((uint8_t *) buffer, buflen);
- p.setDataPosition(0);
- }
- return 0;
-}
-
-/**@brief wait response with expected token and write msg to parcel in some time
-* @param p [IN]: pointer the parcel
-* @param token [IN]: the expected token for the response msg
-* @param time_out [IN]: timeout.
-* @return
-* 0:success
-* other:failure
-*/
-const int waitResponse(Parcel*& p, int token,int time_out)
-{
- int waitToken = token;
- int wakeup_token=-1;
- int resp_type;
- struct timeval now;
- struct timespec timeout;
- int ret;
- std::list<Parcel*>::iterator iter;
- int cnt=0;
-
- gettimeofday(&now,NULL);
- timeout.tv_sec = now.tv_sec+time_out; //timeout is 1min
- timeout.tv_nsec = now.tv_usec*1000;
-
- LYINFLOG("%s wait token is %d",__func__,waitToken);
-
- BLOCK_RC_MSG_LOCK();
- while(true) {
- cnt++;
- for(iter=g_recv_parcel_list.begin();iter!=g_recv_parcel_list.end();++iter)
- {
- (*iter)->setDataPosition(0);
- (*iter)->readInt32(&resp_type);
- (*iter)->readInt32(&wakeup_token);
- if(wakeup_token==waitToken)
- {
- LYINFLOG("%s get waitToken",__func__);
- p=(*iter);
- p->setDataPosition(0);
- g_recv_parcel_list.erase(iter);
- goto waitResponse_end;
- }
- }
- LYINFLOG("%s no wait Token in msg list, list size is %d",__func__,g_recv_parcel_list.size());
- ret=BLOCK_WAIT_RECV_MSG_TIME_OUT(&timeout);
- if(ret!=0)
- {
- LYERRLOG("%s no expected token after %d second",__func__,time_out);
- break;
- }
- }
-waitResponse_end:
- LYINFLOG("%s wait token is %d wakeup_token is %d, cnt is %d",__func__,waitToken,wakeup_token,cnt);
- BLOCK_RC_MSG_UNLOCK();
- return wakeup_token==waitToken ? 0:LYNQ_E_TIME_OUT;
-}
-
-int JumpHeader(Parcel &p,int *resp_type,int* token,int *request,int *slot_id,int *error)
-{
- LYINFLOG("jump header");
- if(p.dataAvail() > 0)
- {
- p.readInt32(resp_type);
- p.readInt32(token);
- p.readInt32(request);
- p.readInt32(slot_id);
- p.readInt32(error);
- LYINFLOG("resp_type=%d,token=%d,request=%d,slot_id=%d,error_code=%d",*resp_type,*token,*request,*slot_id,*error);
- return 0;
- }
- else
- {
- return -1;
- }
-}
-
-/**@brief print solicied response msg's head information
-* @param head [IN]: head information
-* @return none
-*/
-void PrintHeader(lynq_resp_t& head)
-{
- LYINFLOG("resp_type=%d,token=%d,request=%d,slot_id=%d,error_code=%d",head.resp_type,head.token,head.request,head.slot_id,head.error);
-}
-
-/**@brief get solicied response msg's head
-* @param head [OUT]: head information
-* @return
-* 0:success
-* other:failure
-*/
-int GetHeader(Parcel* &p, lynq_resp_t& head)
-{
- LYINFLOG("get header");
- if(p->dataAvail() > 0)
- {
- p->readInt32(&(head.resp_type));
- p->readInt32(&(head.token));
- p->readInt32(&(head.request));
- p->readInt32(&(head.slot_id));
- p->readInt32(&(head.error));
- PrintHeader(head);
- return 0;
- }
- else
- {
- return -1;
- }
-}
-
-/**@brief send msg to service and get response from service
-* @param request_id [IN]: request id
-* @param time_out [IN]: wait time uplimit
-* @param p [IN]: point to response msg's parcel
-* @param argc [IN]: how many parameters in parameter string
-* @param format [IN]: parameter string's format
-* @param ... [IN]: the specific parameter
-* @return
-* 0:success
-* other:failure
-*/
-int lynq_get_common_request(int request_id, int time_out, Parcel*& p, int argc, const char* format,...)
-{
- lynq_client_t client;
- int ret;
- int send_num;
-
- client.uToken = network_Global_uToken;
- network_Global_uToken=(network_Global_uToken+1)%10000;/*0-10000*/
- client.request = request_id;
- client.paramLen = argc;
- bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
- if(argc!=0)
- {
- va_list args;
- va_start(args, format);
- vsnprintf(client.param, LYNQ_REQUEST_PARAM_BUF, format, args);
- va_end(args);
- }
- LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
- pthread_mutex_lock(&g_lynq_network_sendto_mutex);
- if(g_inner_test==0)
- {
- send_num = sendto(network_sock_fd,&client,sizeof(client),0,(struct sockaddr *)&network_addr_serv,network_len_addr_serv);
- }
- else
- {
- send_num = 1;
- g_inner_test = 0;
- }
- pthread_mutex_unlock(&g_lynq_network_sendto_mutex);
-
- if(send_num <= 0)
- {
- LYERRLOG("send request fail, send num is %d", send_num);
- return -1;
- }
- ret = waitResponse(p, client.uToken,time_out);
-
- return ret;
-}
-
-
-int wait_signal_changes()
-{
- int ret = 0;
- pthread_mutex_lock(&signal_state_change_mutex);
- ret = pthread_cond_wait(&signal_state_change_cond,&signal_state_change_mutex);
- pthread_mutex_unlock(&signal_state_change_mutex);
- return 0;
-}
-
-void send_signal_changes()
-{
- pthread_mutex_lock(&signal_state_change_mutex);
- pthread_cond_signal(&signal_state_change_cond);
- pthread_mutex_unlock(&signal_state_change_mutex);
- return;
-}
-
-/**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
-* @param p [IN]: no meaning
-* @return
-* always null
-*/
-void *thread_rc_recv(void *p)
-{
- Parcel* rc_p;
- std::list<Parcel*>::iterator iter;
- int resp_type = -1;
- char rc_data[LYNQ_REC_BUF];
- int rc_len;
- int null_cnt=0;
- int wakeup_token;
-
- LYINFLOG("rc thread is running");
- while(network_rc_status)
- {
- bzero(rc_data,LYNQ_REC_BUF);
- while(true)
- {
- rc_len = recvfrom(network_sock_fd,rc_data,sizeof(rc_data),0,(struct sockaddr *)&network_addr_serv,(socklen_t *)&network_len_addr_serv);
- if(rc_len<sizeof(int32_t)*2)
- {
- LYERRLOG("%s recv len %d less %d",__func__, rc_len,sizeof(int)*2);
- continue;
- }
- rc_p= new Parcel;
- if(rc_p==NULL)
- {
- null_cnt++;
- LYERRLOG("%s rc_p is NULL, cnt is %d",__func__, null_cnt);
- if(null_cnt>20)
- {
- goto rc_recv_end;
- }
- continue;
- }
- else
- {
- null_cnt=0;
- }
-
- rc_p->setData((uint8_t *)rc_data,rc_len); // p.setData((uint8_t *) buffer, buflen);
- rc_p->setDataPosition(0);
- if(rc_p->dataAvail()>0)
- {
- rc_p->readInt32(&resp_type);
- rc_p->readInt32(&wakeup_token);
- BLOCK_RC_MSG_LOCK();
- g_recv_parcel_list.push_back(rc_p);
- LYINFLOG("%s wakeup token is %d, list size is %d!",__func__,wakeup_token,g_recv_parcel_list.size());
- if(g_recv_parcel_list.size()>20) //max 20
- {
- iter=g_recv_parcel_list.begin();
- (*iter)->setDataPosition(0);
- (*iter)->readInt32(&resp_type);
- (*iter)->readInt32(&wakeup_token);
- delete (*(g_recv_parcel_list.begin()));
- LYERRLOG("%s wakeup token %d is deleted!",__func__,wakeup_token);
- g_recv_parcel_list.erase(iter);
- }
- BLOCK_WAKEUP_RECV_MSG();
- BLOCK_RC_MSG_UNLOCK();
- break;
- }
- else
- {
- LYERRLOG("%s rc_p data Avail %d not greater than 0",__func__, rc_p->dataAvail());
- delete rc_p;
- }
- }
- }
-
-rc_recv_end:
- return NULL;
-}
-
-void *thread_urc_recv(void *p)
-{
- Parcel *urc_p =NULL;
- char urc_data[LYNQ_REC_BUF];
- int resp_type = -1;
- int urc_id = -1;
- int res = 0;
- int none = 0;
- int NR_sum = 0;
- int urc_LTE_signalstrength = 0;
- int urc_WCDMA_signalstrength = 0;
- LYINFLOG("urc thread is running");
- while(network_urc_status)
- {
- bzero(urc_data,LYNQ_REC_BUF);
- res = recvfrom(network_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&network_urc_addr_serv,(socklen_t*)&network_len_urc_addr_serv);
- if(res<=0)
- {
- LYERRLOG("thread_urc_recv step2 fail:");
- break;
- }
- urc_p = new Parcel();
- if(urc_p == NULL)
- {
- LYERRLOG("new parcel failure!!!");
- break;
- }
- urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
- urc_p->setDataPosition(0);
- if(urc_p->dataAvail()>0)
- {
- urc_p->readInt32(&resp_type);
- urc_p->readInt32(&urc_id);
- urc_p->readInt32(&network_urc_slot_id);
- switch(urc_id)
- {
- case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED:
- {
- set_register_voice_buffer_valid(false);
- network_wait_urc_id = urc_id;
- LYINFLOG("slot_id = %d",network_urc_slot_id);
- send_signal_changes();
- break;
- }
- case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED:
- {
- set_register_data_buffer_valid(false);
- network_wait_urc_id = urc_id;
- LYINFLOG("slot_id = %d",network_urc_slot_id);
- send_signal_changes();
- break;
- }
- case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED:
- {
- set_register_ims_buffer_valid(false);
- network_wait_urc_id = urc_id;
- LYINFLOG("slot_id = %d",network_urc_slot_id);
- send_signal_changes();
- break;
- }
- case RIL_UNSOL_SIGNAL_STRENGTH:
- {
- urc_p->readInt32(&network_urc_solSigStren.rssi);
- if((network_urc_solSigStren.rssi!=99)&&(network_urc_solSigStren.rssi!=0))
- {
- network_urc_solSigStren.gw_sig_valid = 1;
- }else{
- network_urc_solSigStren.gw_sig_valid = 0;
- }
- if(network_urc_solSigStren.gw_sig_valid == 1)
- {
- LYINFLOG("urc_GSM_signalstrength:%d",network_urc_solSigStren.rssi);
- }
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&urc_LTE_signalstrength);
- // p.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
- urc_p->readInt32(&network_urc_solSigStren.rsrp);
- urc_p->readInt32(&network_urc_solSigStren.rsrq);
- urc_p->readInt32(&network_urc_solSigStren.rssnr);
- if((urc_LTE_signalstrength!=99)&&(urc_LTE_signalstrength!=0))
- {
- network_urc_solSigStren.lte_sig_valid = 1;
- }else{
- network_urc_solSigStren.lte_sig_valid = 0;
- }
- if(network_urc_solSigStren.lte_sig_valid == 1)
- {
- LYINFLOG("urc_LTE_signalstrength:%d",urc_LTE_signalstrength);
- }
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&none);
- urc_p->readInt32(&urc_WCDMA_signalstrength);
- urc_p->readInt32(&none);
- urc_p->readInt32(&network_urc_solSigStren.rscp);
- urc_p->readInt32(&network_urc_solSigStren.ecno);
- if((urc_WCDMA_signalstrength!=99)&&(urc_WCDMA_signalstrength!=0))
- {
- network_urc_solSigStren.wcdma_sig_valid = 1;
- }else{
- network_urc_solSigStren.wcdma_sig_valid = 0;
- }
- if(network_urc_solSigStren.wcdma_sig_valid == 1)
- {
- LYINFLOG("urc_WCDMA_signalstrength:%d",urc_WCDMA_signalstrength);
- }
- urc_p->readInt32(&network_urc_solSigStren.ssRsrp);
- urc_p->readInt32(&network_urc_solSigStren.ssRsrq);
- urc_p->readInt32(&network_urc_solSigStren.ssSinr);
- urc_p->readInt32(&network_urc_solSigStren.csiRsrp);
- urc_p->readInt32(&network_urc_solSigStren.csiRsrq);
- urc_p->readInt32(&network_urc_solSigStren.csiSinr);
- NR_sum = (network_urc_solSigStren.ssRsrp) + (network_urc_solSigStren.ssRsrq) + (network_urc_solSigStren.ssSinr) + (network_urc_solSigStren.csiRsrp)+\
- (network_urc_solSigStren.csiRsrq) + (network_urc_solSigStren.csiSinr);
- if(NR_sum != 0)
- {
- network_urc_solSigStren.nr_sig_valid = 1;
- }else{
- network_urc_solSigStren.nr_sig_valid = 0;
- }
- if(network_urc_solSigStren.nr_sig_valid == 1)
- {
- LYINFLOG("[NR signal]ssRsrp is %d , ssRsrq is %d , ssSinr is %d , csiRsrp is %d , csiRsrq is %d , csiSinr is %d",\
- network_urc_solSigStren.ssRsrp,network_urc_solSigStren.ssRsrq,network_urc_solSigStren.ssSinr, \
- network_urc_solSigStren.csiRsrp,network_urc_solSigStren.csiRsrq,network_urc_solSigStren.csiSinr);
- }
- network_wait_urc_id = urc_id;
- send_signal_changes();
- break;
- }
- }
- }
- delete urc_p;
- urc_p = NULL;
- }
- return NULL;
-}
-
-int lynq_server_socket_start()
-{
-// struct timeval timeOut;
- network_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
- if(-1 == network_sock_fd)
- {
- LYERRLOG("socket open error");
- return -1;
- }
-# if 0
- timeOut.tv_sec = 5;
- timeOut.tv_usec = 0;
- if (setsockopt(network_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) < 0)
- {
- LYERRLOG("time out setting failed\n");
- return -1;
- }
-#endif
-
- LYINFLOG("network_sock_fd = %d",network_sock_fd);
-
- memset(&network_addr_serv, 0, sizeof(network_addr_serv));
- network_addr_serv.sin_family = AF_INET;
- network_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_ADDRESS);
- network_addr_serv.sin_port = htons(LYNQ_SERVICE_PORT);
- network_len_addr_serv = sizeof(network_addr_serv);
-
- BLOCK_RC_MSG_LOCK();
- std::list<Parcel*>::iterator iter;
- for(iter=g_recv_parcel_list.begin();iter!=g_recv_parcel_list.end();++iter)
- {
- delete (*iter);
- }
- g_recv_parcel_list.clear();
- BLOCK_RC_MSG_UNLOCK();
-
- pthread_t tid;
- pthread_attr_t attr;
- int ret;
-
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&tid,&attr,thread_rc_recv,NULL);
- if(ret <0)
- {
- LYERRLOG("rc pthread create error");
- return -1;
- }
- LYINFLOG("rc start success");
-
- return 0;
-}
-
-int lynq_urc_socket_start()
-{
- pthread_t tid;
- pthread_attr_t attr;
- int on = 1;
- network_urc_sock_fd = -1;
- int ret = 0;
- network_len_urc_addr_serv = sizeof(sockaddr_in);
- network_urc_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
- if (network_urc_sock_fd <0){
- LYERRLOG("urc socket error");
- ret = -1;
- }
- network_urc_addr_serv.sin_family = AF_INET;
- network_urc_addr_serv.sin_port = htons(LYNQ_URC_SERVICE_PORT);
- network_urc_addr_serv.sin_addr.s_addr = inet_addr(LYNQ_URC_ADDRESS);
- /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
- ret = setsockopt(network_urc_sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
- if(ret <0)
- {
- LYERRLOG("urc socket set error");
- return -1;
- }
- ret = bind(network_urc_sock_fd ,(struct sockaddr*)&network_urc_addr_serv, sizeof(network_urc_addr_serv));
- if(ret <0)
- {
- LYERRLOG("urc socket bind error");
- return -1;
- }
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&tid,&attr,thread_urc_recv,(void *)network_urc_sock_fd);
- if(ret <0)
- {
- LYERRLOG("urc pthread create error");
- return -1;
- }
- LYINFLOG("urc start success");
-
- return 0;
-}
+int g_module_init_flag = 0;
int lynq_network_init(int utoken){
- if(g_lynq_network_init_flag == 1)
+ if(g_module_init_flag != MODULE_CLOSED)
{
- LYERRLOG("init twice is not allowed");
- return -1;
+ LYERRLOG("module state is %d",g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
- g_lynq_network_init_flag = 1;
- if(utoken <0){
- LYERRLOG("init err");
- return -1;
+
+ if(utoken <0){
+ LYERRLOG("utoken is less than 0",utoken);
+ return LYNQ_E_PARAMETER_ANONALY;
}
- network_urc_status = 1;
- network_rc_status = 1;
- network_Global_uToken = utoken;
+
+ g_module_init_flag = MODULE_SWITCHING;
+
+ g_module_Global_uToken = utoken;
LYLOGSET(LOG_INFO);
LYLOGEINIT(USER_LOG_TAG);
- int ret = 0;
+
+ int ret;
init_network_timer_all();
+ ret = lynq_urc_socket_start();
+ if(ret != 0)
+ {
+ LYERRLOG("init socket urc fail!!!");
+ g_module_init_flag = MODULE_CLOSED;
+ return LYNQ_E_INNER_ERROR;
+ }
+
ret = lynq_server_socket_start();
if(ret !=0)
{
LYERRLOG("init socket client fail!!!");
- return -1;
+ lynq_close_urc_thread();
+ g_module_init_flag = MODULE_CLOSED;
+ return LYNQ_E_INNER_ERROR;
}
- ret = lynq_urc_socket_start();
- if(ret != 0)
- {
- LYERRLOG("init socket urc fail!!!");
- return -1;
- }
- pthread_mutex_init(&g_lynq_network_sendto_mutex, NULL);
- pthread_mutex_init(&s_RecvMsgBlockMutex, NULL);
+ g_module_init_flag = MODULE_RUNNING;
- return 0;
+ return RESULT_OK;
+}
+
+int lynq_network_deinit(void){
+
+ if (g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("module state is %d",g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ g_module_init_flag = MODULE_SWITCHING;
+
+ lynq_close_urc_thread();
+ lynq_close_rc_thread();
+ deinit_network_timer_all();
+
+ g_module_init_flag = MODULE_CLOSED;
+ return RESULT_OK;
}
int strUpper(char * str)
@@ -707,7 +108,7 @@
}
i++;
}
- return 0;
+ return RESULT_OK;
}
int copyCellInfoList(Parcel* &p,uint64_t *cellinfo,int *tac,int *earfcn)
@@ -717,6 +118,7 @@
if(NULL == cellinfo)
{
LYERRLOG("*cellinfo error");
+ return LYNQ_E_PARAMETER_ANONALY;
}
int nothing = 0;
@@ -820,35 +222,7 @@
LYINFLOG("CID in fUNC :%llu",*cellinfo);
LYINFLOG("tac in fUNC :%d",*tac);
LYINFLOG("earfcn in fUNC :%d",*earfcn);
- return 0;
-}
-
-int lynq_network_deinit(void){
- if (g_lynq_network_init_flag == 0)
- {
- LYERRLOG("deinit twice is not allowed");
- return -1;
- }
- if (network_sock_fd > 0)
- {
- close(network_sock_fd);
- }
- g_lynq_network_init_flag = 0;
- network_urc_status = 0;
- network_rc_status = 0;
-
- deinit_network_timer_all();
-
- BLOCK_RC_MSG_LOCK();
- std::list<Parcel*>::iterator iter;
- for(iter=g_recv_parcel_list.begin();iter!=g_recv_parcel_list.end();++iter)
- {
- delete (*iter);
- }
- g_recv_parcel_list.clear();
- BLOCK_RC_MSG_UNLOCK();
-
- return 0;
+ return RESULT_OK;
}
static char * lynqStrdupReadString(Parcel* &p) {
@@ -861,123 +235,112 @@
int lynq_query_operater(char *OperatorFN,char *OperatorSH,char *MccMnc)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+
if(NULL == OperatorFN||NULL == OperatorSH|| NULL == MccMnc)
{
LYERRLOG("%s some parameter OperatorFN OperatorSH MccMnc %s %s %s is NULL",__func__,OperatorFN,OperatorSH,MccMnc);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
+
Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_OPERATOR,5,p,0,"");
- if(ret==0)
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_OPERATOR,0,"");
+
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ int num ;
+ char *resp[LYNQ_RESP_STRING_MAX_NUM];
- int num ;
- char *resp[LYNQ_RESP_BUF];
-
- p->readInt32(&num);
- if(num == 0)
+ p->readInt32(&num);
+ if(num == 0 || num > LYNQ_RESP_STRING_MAX_NUM)
+ {
+ LYERRLOG("no paramters or num %d too great",num);
+ delete p;
+ return LYNQ_E_INNER_ERROR;
+ }else{
+ int i;
+ for(i = 0; i<num;i++)
{
- LYERRLOG("no paramters");
- }else{
- for(int i = 0; i<num;i++)
- {
- resp[i] = lynqStrdupReadString(p);
- }
- if(NULL != resp[0])
- {
- strcpy(OperatorFN,resp[0]);
- }
- if(NULL != resp[1])
- {
- strcpy(OperatorSH,resp[1]);
- }
- if(NULL != resp[2])
- {
- strcpy(MccMnc,resp[2]);
- }
+ resp[i] = lynqStrdupReadString(p);
}
-
- LYINFLOG("%s suc",__func__);
- delete p;
- return 0;
+ if(NULL != resp[0])
+ {
+ strcpy(OperatorFN,resp[0]);
+ }
+ if(NULL != resp[1])
+ {
+ strcpy(OperatorSH,resp[1]);
+ }
+ if(NULL != resp[2])
+ {
+ strcpy(MccMnc,resp[2]);
+ }
+ for(i = 0; i<num;i++)
+ {
+ if(resp[i]!=NULL)
+ {
+ free(resp[i]);
+ }
+ }
}
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_query_network_selection_mode(int *netselMode)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+
if(NULL == netselMode)
{
LYERRLOG("%s parameter is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
- Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE,600,p,0,"");
- if(ret==0)
+
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE,0,"");
+
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ int readnum;
+ p->readInt32(&readnum);
+ p->readInt32(netselMode);
- int readnum;
- p->readInt32(&readnum);
- p->readInt32(netselMode);
-
- LYINFLOG("%s suc",__func__);
- delete p;
- return 0;
- }
- return ret;
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_set_network_selection_mode(const char *mode,const char* mccmnc)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+
if(NULL == mode || (strlen(mode) == 0))
{
LYERRLOG("%s parameter mod %s is error",__func__,mode);
- return -1;
+ return LYNQ_E_PARAMETER_ANONALY;
}
if(!strcmp(mode,"Manual"))
@@ -985,145 +348,120 @@
if(mccmnc == NULL || strlen(mccmnc) == 0)
{
LYERRLOG("%s parameter mccmnc %s is error",__func__,mccmnc);
- return -1;
+ return LYNQ_E_PARAMETER_ANONALY;
}
}
- lynq_resp_t head;
Parcel* p=NULL;
+ int ret;
if(!strcmp(mode,"Auto"))
{
- ret=lynq_get_common_request(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC,5,p,0,"");
+ ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC,0,"");
}
else if(!strcmp(mode,"Manual"))
{
- ret=lynq_get_common_request(RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL,5,p,1,"%s",mccmnc);
+ ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL,1,"%s",mccmnc);
}
else
{
- LYERRLOG("%s parameter mode %s is NULL",__func__,mode);
- return -1;
- }
-
-
- if(ret==0)
- {
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- LYINFLOG("%s set mode %s mccmnc %s suc",__func__,mode,mccmnc);
- delete p;
- return 0;
+ LYERRLOG("%s parameter mode %s is errir",__func__,mode);
+ return LYNQ_E_PARAMETER_ANONALY;
}
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ LYINFLOG("%s set mode %s mccmnc %s suc",__func__,mode,mccmnc);
+ delete p;
+ return RESULT_OK;
}
int lynq_query_available_network(char *OperatorFN,char *OperatorSH,char *MccMnc,char * NetStatus)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(NULL == OperatorFN||NULL == OperatorSH||NULL == MccMnc||NULL == NetStatus)
{
LYERRLOG("%s there is parameter is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
-
- lynq_resp_t head;
+
Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,600,RIL_REQUEST_QUERY_AVAILABLE_NETWORKS,0,"");
- ret=lynq_get_common_request(RIL_REQUEST_QUERY_AVAILABLE_NETWORKS,600,p,0,"");
- if(ret==0)
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
-
- int num =p->readInt32();
- char *resp[128];
- if(num == 0)
- {
- LYERRLOG("%s get num is 0",__func__);
- delete p;
- return -1;
- }else{
- for(int i = 0; i<num;i++)
- {
- resp[i] = lynqStrdupReadString(p);
- }
- if(NULL != resp[0])
- {
- strcpy(OperatorFN,resp[0]);
- }
- if(NULL != resp[1])
- {
- strcpy(OperatorSH,resp[1]);
- }
- if(NULL != resp[2])
- {
- strcpy(MccMnc,resp[2]);
- }
- if(NULL != resp[3])
- {
- strcpy(NetStatus,resp[2]);
- }
- }
- delete p;
- LYINFLOG("%s suc",__func__);
- return 0;
- }
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ int num =p->readInt32();
+ char *resp[LYNQ_RESP_STRING_MAX_NUM];
+ if(num == 0 || num > LYNQ_RESP_STRING_MAX_NUM)
+ {
+ LYERRLOG("no paramters or num %d too great",num);
+ delete p;
+ return LYNQ_E_INNER_ERROR;
+ }else{
+ int i;
+ for(i = 0; i<num;i++)
+ {
+ resp[i] = lynqStrdupReadString(p);
+ }
+ if(NULL != resp[0])
+ {
+ strcpy(OperatorFN,resp[0]);
+ }
+ if(NULL != resp[1])
+ {
+ strcpy(OperatorSH,resp[1]);
+ }
+ if(NULL != resp[2])
+ {
+ strcpy(MccMnc,resp[2]);
+ }
+ if(NULL != resp[3])
+ {
+ strcpy(NetStatus,resp[3]);
+ }
+ for(i = 0; i<num;i++)
+ {
+ if(resp[i]!=NULL)
+ {
+ free(resp[i]);
+ }
+ }
+ }
+ delete p;
+ LYINFLOG("%s suc",__func__);
+ return RESULT_OK;
}
int lynq_query_registration_state(const char *type,int* regState,int* imsRegState,char * LAC,char * CID,int *netType,int *radioTechFam,int *netRejected)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+
if(NULL == type || NULL ==regState ||NULL ==imsRegState ||NULL ==LAC ||NULL ==CID ||NULL ==netType ||NULL ==radioTechFam || NULL == netRejected)
{
LYERRLOG("%s there is parameter is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
if(strlen(type)>LYNQ_TYPE_BUF)
{
LYERRLOG("[%s]the parameter is inavaliable !",__FUNCTION__);
- return ret;
- }
-
- lynq_resp_t head;
- Parcel* p=NULL;
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
int request;
char str[LYNQ_TYPE_BUF];
@@ -1131,439 +469,319 @@
strUpper(str);
if(!strcmp(str,"VOICE"))
{
- if(lynq_get_registration_state_to_buf_voice(regState,netType,netRejected)==0)
+ if(get_state_from_buf(NETWORK_STATE_BUFFER_TYPE_VOICE_REG,3,regState,netType,netRejected,0)==0)
{
- return 0;
+ return RESULT_OK;
}
request = RIL_REQUEST_VOICE_REGISTRATION_STATE;
}else if(!strcmp(str,"DATA")){
- if(lynq_get_registration_state_to_buf_data(regState,LAC,CID,netType)==0)
+ if(get_state_from_buf(NETWORK_STATE_BUFFER_TYPE_DATA_REG,2,regState,netType,2,LAC,CID)==0)
{
- return 0;
+ return RESULT_OK;
}
request = RIL_REQUEST_DATA_REGISTRATION_STATE;
}else if(!strcmp(str,"IMS")){
- if(lynq_get_registration_state_to_buf_ims(imsRegState,radioTechFam)==0)
+ if(get_state_from_buf(NETWORK_STATE_BUFFER_TYPE_IMS_REG,2,imsRegState,radioTechFam,0)==0)
{
- return 0;
+ return RESULT_OK;
}
request = RIL_REQUEST_IMS_REGISTRATION_STATE;
}else{
LYERRLOG("request error");
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- ret=lynq_get_common_request(request,5,p,0,"");
- if(ret==0)
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,request,0,"");
+
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ int num,i;
+ char *resp[LYNQ_RESP_STRING_MAX_NUM];
+ if(!strcmp(str,"VOICE"))
+ {
+ p->readInt32(&num);
+ if(num == 15)
{
- LYERRLOG("%s get p error",__func__);
- return -1;
+ for(i=0;i<15;i++)
+ {
+ resp[i]=lynqStrdupReadString(p);
+ }
+ *regState = atoi(resp[0]);
+ *netType = atoi(resp[3]);
+ *netRejected = atoi(resp[14]);
+ for(i=0;i<15;i++)
+ {
+ if(resp[i]!=NULL)
+ {
+ free(resp[i]);
+ }
+ }
+ set_state_to_buf(NETWORK_STATE_BUFFER_TYPE_VOICE_REG,3,*regState,*netType,*netRejected,0);
}
- ret=GetHeader(p,head);
- if(ret!=0)
+ else
{
- LYERRLOG("%s get head error %d",__func__,ret);
+ LYERRLOG("%s type %s num %d error",__func__,str,num);
delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- int num;
- if(!strcmp(str,"VOICE"))
- {
- p->readInt32(&num);
- if(num == 15)
- {
- *regState = atoi(lynqStrdupReadString(p));
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- *netType = atoi(lynqStrdupReadString(p));
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- lynqStrdupReadString(p);
- *netRejected = atoi(lynqStrdupReadString(p));
- lynq_set_registration_state_to_buf_voice(*regState,*netType,*netRejected);
- }
- else
- {
- LYERRLOG("%s type %s num %d error",__func__,str,num);
- delete p;
- return -1;
- }
- }
- else if(!strcmp(str,"DATA")){
- p->readInt32(&num);
- if(num == 11)
- {
- char *resp[LYNQ_RESP_BUF];
- *regState = atoi(lynqStrdupReadString(p));
- resp[0] = lynqStrdupReadString(p);
- strcpy(LAC,resp[0]);
-
- resp[1] = lynqStrdupReadString(p);
- strcpy(CID,resp[1]);
- *netType = atoi(lynqStrdupReadString(p));
- lynq_set_registration_state_to_buf_data(*regState,LAC,CID,*netType);
- }
- else
- {
- LYERRLOG("%s type %s num %d error",__func__,str,num);
- delete p;
- return -1;
- }
-
- }
- else // "IMS"
- {
- p->readInt32(&num);
- if(num == 2)
- {
- p->readInt32(imsRegState);
- p->readInt32(radioTechFam);
- lynq_set_registration_state_to_buf_ims(*imsRegState,*radioTechFam);
- }
- else
- {
- LYERRLOG("%s type %s num %d error",__func__,str,num);
- delete p;
- return -1;
- }
- }
- LYINFLOG("%s suc",__func__);
- delete p;
- return 0;
+ return LYNQ_E_INNER_ERROR;
+ }
}
+ else if(!strcmp(str,"DATA")){
+ p->readInt32(&num);
+ if(num == 11)
+ {
+ for(i=0;i<4;i++)
+ {
+ resp[i]=lynqStrdupReadString(p);
+ }
+ *regState = atoi(resp[0]);
+ strcpy(LAC,resp[1]);
+ strcpy(CID,resp[2]);
+ *netType = atoi(resp[3]);
+ for(i=0;i<4;i++)
+ {
+ if(resp[i]!=NULL)
+ {
+ free(resp[i]);
+ }
+ }
+ set_state_to_buf(NETWORK_STATE_BUFFER_TYPE_DATA_REG,2,*regState,*netType,2,LAC,CID);
+ }
+ else
+ {
+ LYERRLOG("%s type %s num %d error",__func__,str,num);
+ delete p;
+ return LYNQ_E_INNER_ERROR;
+ }
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ }
+ else // "IMS"
+ {
+ p->readInt32(&num);
+ if(num == 2)
+ {
+ p->readInt32(imsRegState);
+ p->readInt32(radioTechFam);
+ set_state_to_buf(NETWORK_STATE_BUFFER_TYPE_IMS_REG,2,*imsRegState,*radioTechFam,0);
+ }
+ else
+ {
+ LYERRLOG("%s type %s num %d error",__func__,str,num);
+ delete p;
+ return LYNQ_E_INNER_ERROR;
+ }
+ }
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_query_prefferred_networktype(int *preNetType)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(NULL == preNetType)
{
LYERRLOG("%s there is parameter is NULL",__func__);
- return ret;
- }
-
- lynq_resp_t head;
- Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE,5,p,0,"");
- if(ret==0)
- {
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- int num;
- p->readInt32(&num);
- p->readInt32(preNetType);
- LYINFLOG("%s suc",__func__);
- delete p;
- return 0;
- }
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE,0,"");
+
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ int num;
+ p->readInt32(&num);
+ p->readInt32(preNetType);
+
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_set_prefferred_networktype(const int preffertype)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(preffertype < 0||preffertype >33)
{
LYERRLOG("%s parameter %d error",__func__,preffertype);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
-
- lynq_resp_t head;
+
Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,5,p,1,"%d",preffertype);
- if(ret==0)
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,1,"%d",preffertype);
+
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- LYINFLOG("%s set %d suc",__func__,preffertype);
- delete p;
- return 0;
- }
-
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
-
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ LYINFLOG("%s set %d suc",__func__,preffertype);
+ delete p;
+ return RESULT_OK;
+
}
int lynq_query_cell_info(uint64_t cellinfo[CELLINFO_MAX_NUM],int tac[CELLINFO_MAX_NUM],int earfcn[CELLINFO_MAX_NUM],int * realNum)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(NULL == realNum)
{
LYERRLOG("%s there is parameter is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
- Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_GET_CELL_INFO_LIST,5,p,0,"");
- if(ret==0)
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_GET_CELL_INFO_LIST,0,"");
+
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ int num;
- int num;
-
- p->readInt32(&num);
- LYINFLOG("cell info num:%d",num);
- *realNum = num;
- for(int i = 0;i<num;i++)
- {
- copyCellInfoList(p,&cellinfo[i],&tac[i],&earfcn[i]);
- }
-
- LYINFLOG("%s suc",__func__);
- delete p;
- return 0;
+ p->readInt32(&num);
+ LYINFLOG("cell info num:%d",num);
+ *realNum = num;
+ for(int i = 0;i<num;i++)
+ {
+ copyCellInfoList(p,&cellinfo[i],&tac[i],&earfcn[i]);
}
-
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
-
+
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_set_unsol_cell_info_listrate(const int rate)
{
- int ret = -1;
- lynq_resp_t head;
- Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE,5,p,1,"%d",rate);
- if(ret==0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- LYINFLOG("%s set %d suc",__func__,rate);
- delete p;
- return 0;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE,1,"%d",rate);
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ LYINFLOG("%s set %d suc",__func__,rate);
+ delete p;
+ return RESULT_OK;
}
int lynq_set_band_mode(const int bandmode)
{
- int ret = -1;
- lynq_resp_t head;
- Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_SET_BAND_MODE,5,p,1,"%d",bandmode);
- if(ret==0)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- LYINFLOG("%s set %d suc",__func__,bandmode);
- delete p;
- return 0;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SET_BAND_MODE,1,"%d",bandmode);
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ LYINFLOG("%s set %d suc",__func__,bandmode);
+ delete p;
+ return RESULT_OK;
}
int lynq_query_available_bandmode(int availBanMode[])
{
- int ret=-1;
-
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(NULL == availBanMode)
{
LYERRLOG("%s parameter is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE,5,p,0,"");
- if(ret==0)
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE,0,"");
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
-
- int num = 0;
- int res = 0;
- int i;
-
- p->readInt32(&num);
- LYINFLOG("num = %d",num);
- availBanMode[0] = num;
- for(i=1 ;i<=num;i++)
- {
- p->readInt32(&res);
- availBanMode[i]=res;
- }
-
- LYINFLOG("%s suc",__func__);
- delete p;
- return 0;
- }
-
- LYERRLOG("%s send request error %d",__func__,ret);
-
- return ret;
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+ int num = 0;
+ int res = 0;
+ int i;
+
+ p->readInt32(&num);
+ LYINFLOG("num = %d",num);
+ availBanMode[0] = num;
+ for(i=1 ;i<=num;i++)
+ {
+ p->readInt32(&res);
+ availBanMode[i]=res;
+ }
+
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_radio_on(const int data)
-{
- int ret = -1;
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if (data < 0 || data > 1)
{
LYERRLOG("%s parameter %d error",__func__,data);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
- Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_RADIO_POWER,65,p,1,"%d",data);
- if(ret==0)
- {
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- LYINFLOG("%s set %d suc",__func__,data);
- delete p;
- return 0;
- }
+ Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,65,RIL_REQUEST_RADIO_POWER,1,"%d",data);
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ LYINFLOG("%s set %d suc",__func__,data);
+ delete p;
+ return RESULT_OK;
}
const char * lynq_get_raw_data(Parcel* &p, int* data_len)
@@ -1597,305 +815,415 @@
int lynq_query_radio_state(int *radio_state)
{
- int ret=-1;
-
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(NULL == radio_state)
{
LYERRLOG("%s radio state is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_OEM_HOOK_RAW,5,p,1,"%s","AT+CFUN");
- if(ret==0)
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_OEM_HOOK_RAW,1,"%s","AT+CFUN");
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
- int bfind=false;
- const char* data;
- int data_len;
- char* data_str;
- char* start;
- int length;
- int i;
- int num_start;
- data = lynq_get_raw_data(p,&data_len);
- if(data==NULL || data_len == 0)
- {
- LYERRLOG("%s lynq_get_raw_data NULL or data_len is 0",__func__);
- delete p;
- return -1;
- }
- data_str = (char*) calloc(1,data_len+1);
- if (NULL == data_str)
- {
- LYERRLOG("%s alloc mem error, data_len is %d",__func__,data_len+1);
- delete p;
- return -1;
- }
- memmove(data_str, data, data_len);
- data_str[data_len]='\0';
- LYINFLOG("%s return string is %s",__func__,data_str);
- start = strstr(data_str,"CFUN");
- if(start!=NULL)
- {
- start=start+4;
- length=strlen(start);
- for(i=0; i<length;i++)
- {
- if((!bfind) && (start[i] >= '0') && (start[i] <= '9'))
- {
- bfind=true;
- num_start=i;
- }
- else if(bfind && ((start[i] < '0') || (start[i] > '9')))
- {
- start[i]='\0';
- break;
- }
- }
- if(bfind)
- {
- (*radio_state) = atoi(start+num_start);
- LYINFLOG("%s, radio state is %s %d",__func__,start+num_start,*radio_state);
- free(data_str);
- delete p;
- return 0;
- }
- }
- LYERRLOG("%s return string %s no cfun or no digit",__func__,data_str);
- free(data_str);
+ int bfind=false;
+ const char* data;
+ int data_len;
+ char* data_str;
+ char* start;
+ int length;
+ int i;
+ int num_start;
+ data = lynq_get_raw_data(p,&data_len);
+ if(data==NULL || data_len == 0)
+ {
+ LYERRLOG("%s lynq_get_raw_data NULL or data_len is 0",__func__);
delete p;
- return -1;
+ return LYNQ_E_INNER_ERROR;
}
-
- LYERRLOG("%s send request error %d",__func__,ret);
-
- return ret;
+ data_str = (char*) calloc(1,data_len+1);
+ if (NULL == data_str)
+ {
+ LYERRLOG("%s alloc mem error, data_len is %d",__func__,data_len+1);
+ delete p;
+ return LYNQ_E_MALLOC_ERROR;
+ }
+ memmove(data_str, data, data_len);
+ data_str[data_len]='\0';
+ LYINFLOG("%s return string is %s",__func__,data_str);
+ start = strstr(data_str,"CFUN");
+ if(start!=NULL)
+ {
+ start=start+4;
+ length=strlen(start);
+ for(i=0; i<length;i++)
+ {
+ if((!bfind) && (start[i] >= '0') && (start[i] <= '9'))
+ {
+ bfind=true;
+ num_start=i;
+ }
+ else if(bfind && ((start[i] < '0') || (start[i] > '9')))
+ {
+ start[i]='\0';
+ break;
+ }
+ }
+ if(bfind)
+ {
+ (*radio_state) = atoi(start+num_start);
+ LYINFLOG("%s, radio state is %s %d",__func__,start+num_start,*radio_state);
+ free(data_str);
+ delete p;
+ return RESULT_OK;
+ }
+ }
+ LYERRLOG("%s return string %s no cfun or no digit",__func__,data_str);
+ free(data_str);
+ delete p;
+ return LYNQ_E_INNER_ERROR;
}
int lynq_query_radio_tech(int* radioTech)
{
- int ret = -1;
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(NULL == radioTech)
{
LYERRLOG("%s radio tech is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_VOICE_RADIO_TECH,5,p,0,"");
- if(ret==0)
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_VOICE_RADIO_TECH,0,"");
+
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
- int num;
- p->readInt32(&num);
- p->readInt32(radioTech);
+ int num;
+ p->readInt32(&num);
+ p->readInt32(radioTech);
- LYINFLOG("%s suc",__func__);
- delete p;
- return head.error;
- }
- return ret;
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_solicited_signal_strength(signalStrength_t *solSigStren)
{
- int ret=-1;
-
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
if(NULL == solSigStren)
{
LYERRLOG("%s parameter is NULL",__func__);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_SIGNAL_STRENGTH,8,p,0,"");
- if(ret==0)
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_SIGNAL_STRENGTH,0,"");
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ int sum = 0;
+ int LTE_signalstrength = 0;
+ int WCDMA_signalstrength = 0;
+ int none = 0;
- int sum = 0;
- int LTE_signalstrength = 0;
- int WCDMA_signalstrength = 0;
- int none = 0;
-
- p->readInt32(&solSigStren->rssi);
- if((solSigStren->rssi!=99)&&(solSigStren->rssi!=0))
- {
- solSigStren->gw_sig_valid = 1;
- }else{
- solSigStren->gw_sig_valid = 0;
- }
-
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(<E_signalstrength);
- // p->readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
- p->readInt32(&solSigStren->rsrp);
- p->readInt32(&solSigStren->rsrq);
- p->readInt32(&solSigStren->rssnr);
- LYINFLOG("LTE_signalstrength:%d",LTE_signalstrength);
- if((LTE_signalstrength!=99)&&(LTE_signalstrength!=0))
- {
- solSigStren->lte_sig_valid = 1;
- }else{
- solSigStren->lte_sig_valid = 0;
- }
-
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&none);
- p->readInt32(&WCDMA_signalstrength);
- p->readInt32(&none);
- p->readInt32(&solSigStren->rscp);
- p->readInt32(&solSigStren->ecno);
- LYINFLOG("WCDMA_signalstrength:%d",WCDMA_signalstrength);
- if((WCDMA_signalstrength!=99)&&(WCDMA_signalstrength!=0))
- {
- solSigStren->wcdma_sig_valid = 1;
- }else{
- solSigStren->wcdma_sig_valid = 0;
- }
- /*bug fix*/
- p->readInt32(&solSigStren->ssRsrp);
- p->readInt32(&solSigStren->ssRsrq);
- p->readInt32(&solSigStren->ssSinr);
- p->readInt32(&solSigStren->csiRsrp);
- p->readInt32(&solSigStren->csiRsrq);
- p->readInt32(&solSigStren->csiSinr);
- sum = (solSigStren->ssRsrp) + (solSigStren->ssRsrq) + (solSigStren->ssSinr) + (solSigStren->csiRsrp)+\
- (solSigStren->csiRsrq) + (solSigStren->csiSinr);
- if(sum != 0)
- {
- solSigStren->nr_sig_valid = 1;
- }else{
- LYERRLOG("None of NR signal info");
- }
-
- LYINFLOG("%s suc",__func__);
- delete p;
- return 0;
+ p->readInt32(&solSigStren->rssi);
+ if((solSigStren->rssi!=99)&&(solSigStren->rssi!=0))
+ {
+ solSigStren->gw_sig_valid = 1;
+ }else{
+ solSigStren->gw_sig_valid = 0;
}
- LYERRLOG("%s send request error %d",__func__,ret);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(<E_signalstrength);
+ // p->readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
+ p->readInt32(&solSigStren->rsrp);
+ p->readInt32(&solSigStren->rsrq);
+ p->readInt32(&solSigStren->rssnr);
+ LYINFLOG("LTE_signalstrength:%d",LTE_signalstrength);
+ if((LTE_signalstrength!=99)&&(LTE_signalstrength!=0))
+ {
+ solSigStren->lte_sig_valid = 1;
+ }else{
+ solSigStren->lte_sig_valid = 0;
+ }
- return ret;
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&WCDMA_signalstrength);
+ p->readInt32(&none);
+ p->readInt32(&solSigStren->rscp);
+ p->readInt32(&solSigStren->ecno);
+ LYINFLOG("WCDMA_signalstrength:%d",WCDMA_signalstrength);
+ if((WCDMA_signalstrength!=99)&&(WCDMA_signalstrength!=0))
+ {
+ solSigStren->wcdma_sig_valid = 1;
+ }else{
+ solSigStren->wcdma_sig_valid = 0;
+ }
+ /*bug fix*/
+ p->readInt32(&solSigStren->ssRsrp);
+ p->readInt32(&solSigStren->ssRsrq);
+ p->readInt32(&solSigStren->ssSinr);
+ p->readInt32(&solSigStren->csiRsrp);
+ p->readInt32(&solSigStren->csiRsrq);
+ p->readInt32(&solSigStren->csiSinr);
+ sum = (solSigStren->ssRsrp) + (solSigStren->ssRsrq) + (solSigStren->ssSinr) + (solSigStren->csiRsrp)+\
+ (solSigStren->csiRsrq) + (solSigStren->csiSinr);
+ if(sum != 0)
+ {
+ solSigStren->nr_sig_valid = 1;
+ }else{
+ LYERRLOG("None of NR signal info");
+ }
+
+ LYINFLOG("%s suc",__func__);
+ delete p;
+ return RESULT_OK;
}
int lynq_set_ims(const int ims_mode)
{
- if(ims_mode == -1000)
+ if(g_module_init_flag != MODULE_RUNNING)
{
- g_inner_test = 1;
- return 0;
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
}
-
- int ret = -1;
if (ims_mode < 0 || ims_mode > 1)
{
LYERRLOG("%s parameter %d error",__func__,ims_mode);
- return ret;
+ return LYNQ_E_PARAMETER_ANONALY;
}
-
- lynq_resp_t head;
- Parcel* p=NULL;
-
- ret=lynq_get_common_request(RIL_REQUEST_SET_IMS_ENABLE,65,p,1,"%d",ims_mode);
- if(ret==0)
- {
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error %d",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
- LYINFLOG("%s set %d suc",__func__,ims_mode);
- delete p;
- return 0;
- }
- LYERRLOG("%s get response from modem failure, ret is %d",__func__,ret);
- return ret;
+ Parcel* p=NULL;
+ int ret = lynq_send_common_request(p,65,RIL_REQUEST_SET_IMS_ENABLE,1,"%d",ims_mode);
+ if(ret!=RESULT_OK)
+ {
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ LYINFLOG("%s set %d suc",__func__,ims_mode);
+ delete p;
+ return RESULT_OK;
}
+/*Used to get urc info*/
+int lynq_get_urc_info(const int handle,signalStrength_t *solSigStren,int *slot_id)
+{
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ LYDBGLOG("start get urc info");
+ if(handle != RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED &&handle != RIL_UNSOL_SIGNAL_STRENGTH)
+ {
+ LYINFLOG("invalid handle!!!");
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ if((handle ==RIL_UNSOL_SIGNAL_STRENGTH && NULL == solSigStren) ||
+ (handle ==RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED && NULL == slot_id))
+ {
+ LYINFLOG("incoming solSigStren or slot_id is NULL!!!");
+ return LYNQ_E_PARAMETER_ANONALY;
+ }
+ switch(handle)
+ {
+ case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: //1002
+ {
+ LYDBGLOG("get state update to VOICE");
+ *slot_id = s_module_urc_slot_id;
+ LYINFLOG("slot_id = %d",s_module_urc_slot_id);
+ break;
+ }
+ case RIL_UNSOL_SIGNAL_STRENGTH: //1009
+ {
+ LYDBGLOG("get state update to signal info");
+ solSigStren->gw_sig_valid = s_network_urc_solSigStren.gw_sig_valid;
+ solSigStren->rssi = s_network_urc_solSigStren.rssi;
+ solSigStren->wcdma_sig_valid = s_network_urc_solSigStren.wcdma_sig_valid;
+ solSigStren->rscp = s_network_urc_solSigStren.rscp;
+ solSigStren->ecno = s_network_urc_solSigStren.ecno;
+ solSigStren->lte_sig_valid = s_network_urc_solSigStren.lte_sig_valid;
+ solSigStren->rsrp = s_network_urc_solSigStren.rsrp;
+ solSigStren->rsrq = s_network_urc_solSigStren.rsrq;
+ solSigStren->rssnr = s_network_urc_solSigStren.rssnr;
+ solSigStren->nr_sig_valid = s_network_urc_solSigStren.nr_sig_valid;
+ solSigStren->ssRsrp = s_network_urc_solSigStren.ssRsrp;
+ solSigStren->ssRsrq = s_network_urc_solSigStren.ssRsrq;
+ solSigStren->ssSinr = s_network_urc_solSigStren.ssSinr;
+ solSigStren->csiRsrp = s_network_urc_solSigStren.csiRsrp;
+ solSigStren->csiRsrq = s_network_urc_solSigStren.csiRsrq;
+ solSigStren->csiSinr = s_network_urc_solSigStren.csiSinr;
+ break;
+ }
+ }
+ return RESULT_OK;
+}
+
+static pthread_mutex_t urc_signal_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t urc_signal_state_change_cond = PTHREAD_COND_INITIALIZER;
+
+int wait_urc_signal_changes()
+{
+ pthread_mutex_lock(&urc_signal_state_change_mutex);
+ pthread_cond_wait(&urc_signal_state_change_cond,&urc_signal_state_change_mutex);
+ pthread_mutex_unlock(&urc_signal_state_change_mutex);
+ return RESULT_OK;
+}
+
+void send_urc_signal_changes()
+{
+ pthread_mutex_lock(&urc_signal_state_change_mutex);
+ pthread_cond_signal(&urc_signal_state_change_cond);
+ pthread_mutex_unlock(&urc_signal_state_change_mutex);
+ return;
+}
+
+void urc_msg_process(Parcel *p)
+{
+ int resp_type;
+ int none = 0;
+ int NR_sum = 0;
+ int urc_LTE_signalstrength = 0;
+ int urc_WCDMA_signalstrength = 0;
+
+ p->readInt32(&resp_type);
+ p->readInt32(&s_module_wait_urc_id);
+ p->readInt32(&s_module_urc_slot_id);
+ LYINFLOG("urc id = %d, slot_id = %d",s_module_wait_urc_id,s_module_urc_slot_id);
+ switch(s_module_wait_urc_id)
+ {
+ case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED:
+ {
+ set_state_buffer_valid(NETWORK_STATE_BUFFER_TYPE_VOICE_REG,false);
+ send_urc_signal_changes();
+ break;
+ }
+ case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED:
+ {
+ set_state_buffer_valid(NETWORK_STATE_BUFFER_TYPE_DATA_REG,false);
+ send_urc_signal_changes();
+ break;
+ }
+ case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED:
+ {
+ set_state_buffer_valid(NETWORK_STATE_BUFFER_TYPE_IMS_REG,false);
+ send_urc_signal_changes();
+ break;
+ }
+ case RIL_UNSOL_SIGNAL_STRENGTH:
+ {
+ p->readInt32(&s_network_urc_solSigStren.rssi);
+ if((s_network_urc_solSigStren.rssi!=99)&&(s_network_urc_solSigStren.rssi!=0))
+ {
+ s_network_urc_solSigStren.gw_sig_valid = 1;
+ }else{
+ s_network_urc_solSigStren.gw_sig_valid = 0;
+ }
+ if(s_network_urc_solSigStren.gw_sig_valid == 1)
+ {
+ LYINFLOG("urc_GSM_signalstrength:%d",s_network_urc_solSigStren.rssi);
+ }
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&urc_LTE_signalstrength);
+ // p.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
+ p->readInt32(&s_network_urc_solSigStren.rsrp);
+ p->readInt32(&s_network_urc_solSigStren.rsrq);
+ p->readInt32(&s_network_urc_solSigStren.rssnr);
+ if((urc_LTE_signalstrength!=99)&&(urc_LTE_signalstrength!=0))
+ {
+ s_network_urc_solSigStren.lte_sig_valid = 1;
+ }else{
+ s_network_urc_solSigStren.lte_sig_valid = 0;
+ }
+ if(s_network_urc_solSigStren.lte_sig_valid == 1)
+ {
+ LYINFLOG("urc_LTE_signalstrength:%d",urc_LTE_signalstrength);
+ }
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&none);
+ p->readInt32(&urc_WCDMA_signalstrength);
+ p->readInt32(&none);
+ p->readInt32(&s_network_urc_solSigStren.rscp);
+ p->readInt32(&s_network_urc_solSigStren.ecno);
+ if((urc_WCDMA_signalstrength!=99)&&(urc_WCDMA_signalstrength!=0))
+ {
+ s_network_urc_solSigStren.wcdma_sig_valid = 1;
+ }else{
+ s_network_urc_solSigStren.wcdma_sig_valid = 0;
+ }
+ if(s_network_urc_solSigStren.wcdma_sig_valid == 1)
+ {
+ LYINFLOG("urc_WCDMA_signalstrength:%d",urc_WCDMA_signalstrength);
+ }
+ p->readInt32(&s_network_urc_solSigStren.ssRsrp);
+ p->readInt32(&s_network_urc_solSigStren.ssRsrq);
+ p->readInt32(&s_network_urc_solSigStren.ssSinr);
+ p->readInt32(&s_network_urc_solSigStren.csiRsrp);
+ p->readInt32(&s_network_urc_solSigStren.csiRsrq);
+ p->readInt32(&s_network_urc_solSigStren.csiSinr);
+ NR_sum = (s_network_urc_solSigStren.ssRsrp) + (s_network_urc_solSigStren.ssRsrq) + (s_network_urc_solSigStren.ssSinr) + (s_network_urc_solSigStren.csiRsrp)+\
+ (s_network_urc_solSigStren.csiRsrq) + (s_network_urc_solSigStren.csiSinr);
+ if(NR_sum != 0)
+ {
+ s_network_urc_solSigStren.nr_sig_valid = 1;
+ }else{
+ s_network_urc_solSigStren.nr_sig_valid = 0;
+ }
+ if(s_network_urc_solSigStren.nr_sig_valid == 1)
+ {
+ LYINFLOG("[NR signal]ssRsrp is %d , ssRsrq is %d , ssSinr is %d , csiRsrp is %d , csiRsrq is %d , csiSinr is %d",\
+ s_network_urc_solSigStren.ssRsrp,s_network_urc_solSigStren.ssRsrq,s_network_urc_solSigStren.ssSinr, \
+ s_network_urc_solSigStren.csiRsrp,s_network_urc_solSigStren.csiRsrq,s_network_urc_solSigStren.csiSinr);
+ }
+ send_urc_signal_changes();
+ break;
+ }
+ }
+}
/*Used to wait for an update signal*/
int lynq_wait_signalchanges(int *handle)
@@ -1904,61 +1232,15 @@
if(NULL == handle)
{
LYERRLOG("illegal input");
- return -1;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- wait_signal_changes();
+ wait_urc_signal_changes();
LYDBGLOG("get signalchanges");
- *handle = network_wait_urc_id;
- return 0;
-}
-/*Used to get urc info*/
-int lynq_get_urc_info(const int handle,signalStrength_t *solSigStren,int *slot_id)
-{
- LYDBGLOG("start get urc info");
- if(handle != 1002&&handle != 1009)
- {
- LYINFLOG("invalid handle!!!");
- return -1;
- }
- if(NULL == solSigStren && NULL == slot_id)
- {
- LYINFLOG("incoming solSigStren or slot_id is NULL!!!");
- return -1;
- }
- switch(handle)
- {
- case 1002: //RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED
- {
- LYDBGLOG("get state update to VOICE");
- *slot_id = network_urc_slot_id;
- LYINFLOG("slot_id = %d",network_urc_slot_id);
- break;
- }
- case 1009: //RIL_UNSOL_SIGNAL_STRENGTH
- {
- LYDBGLOG("get state update to signal info");
- solSigStren->gw_sig_valid = network_urc_solSigStren.gw_sig_valid;
- solSigStren->rssi = network_urc_solSigStren.rssi;
- solSigStren->wcdma_sig_valid = network_urc_solSigStren.wcdma_sig_valid;
- solSigStren->rscp = network_urc_solSigStren.rscp;
- solSigStren->ecno = network_urc_solSigStren.ecno;
- solSigStren->lte_sig_valid = network_urc_solSigStren.lte_sig_valid;
- solSigStren->rsrp = network_urc_solSigStren.rsrp;
- solSigStren->rsrq = network_urc_solSigStren.rsrq;
- solSigStren->rssnr = network_urc_solSigStren.rssnr;
- solSigStren->nr_sig_valid = network_urc_solSigStren.nr_sig_valid;
- solSigStren->ssRsrp = network_urc_solSigStren.ssRsrp;
- solSigStren->ssRsrq = network_urc_solSigStren.ssRsrq;
- solSigStren->ssSinr = network_urc_solSigStren.ssSinr;
- solSigStren->csiRsrp = network_urc_solSigStren.csiRsrp;
- solSigStren->csiRsrq = network_urc_solSigStren.csiRsrq;
- solSigStren->csiSinr = network_urc_solSigStren.csiSinr;
- break;
- }
- }
- return 0;
+ *handle = s_module_wait_urc_id;
+ return RESULT_OK;
}
+#ifdef MODEM_GEN97
/**@brief parse at response,return error code,and the response
* @param response [IN] <response>:original at response,This parameter must be a character array.
@@ -1976,7 +1258,7 @@
if(response == NULL || value == NULL)
{
LYERRLOG("parameter invalid");
- return -1;
+ return LYNQ_E_PARAMETER_ANONALY;
}
if(strstr(response,"ERROR"))
{
@@ -2064,158 +1346,123 @@
memcpy(value,temp_buf,strlen(temp_buf));
}
}
- return 0;
+ return RESULT_OK;
}
else
{
LYINFLOG("%s this response invalid\n",response);
- return -1;
+ return LYNQ_E_INNER_ERROR;
}
}
-#ifdef MODEM_GEN97
int lynq_oos_recover_timer_interval(int mode, char interval[LY_RECOVER_TIMER_INTERVAL],char result[LY_RECOVER_TIMER_INTERVAL])
{
- int ret=-1;
-
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+
if((mode < 0) || (mode >1) || (mode == 0 && NULL == interval) || (NULL == result))
{
LYERRLOG("%s mode %d interval %s result %s error",__func__,mode,interval,result);
- return -1;
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
Parcel* p=NULL;
+ int ret;
if(mode == 0)
{
- ret=lynq_get_common_request(RIL_REQUEST_OEM_HOOK_RAW,5,p,1,"AT+ERSCFG=%s",interval);
+ ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_OEM_HOOK_RAW,1,"AT+ERSCFG=%s",interval);
}
else
{
- ret=lynq_get_common_request(RIL_REQUEST_OEM_HOOK_RAW,5,p,1,"AT+ERSCFG?");
+ ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_OEM_HOOK_RAW,1,"AT+ERSCFG?");
}
- if(ret==0)
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
-
- int recv_len;
- char res_data[LY_RECOVER_TIMER_INTERVAL] = {0};
- char response_interval[LY_RECOVER_TIMER_INTERVAL*2] = {0};
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+ int recv_len;
+ char res_data[LY_RECOVER_TIMER_INTERVAL] = {0};
+ char response_interval[LY_RECOVER_TIMER_INTERVAL*2] = {0};
- LYINFLOG("get recover timer interval");
- p->readInt32(&recv_len);
- if(recv_len == -1)
- {
- LYINFLOG("no responset");
- delete p;
- return -1;
- }
- else
- {
- LYINFLOG("recv_len:%d",recv_len);
- p->read(response_interval,recv_len);
- }
- LYINFLOG("response_interval:%s",response_interval);
- ret = parse_at_result(response_interval,res_data,LY_RECOVER_TIMER_INTERVAL);
- if(mode == 1)
- {
- if(strlen(res_data) <= LY_RECOVER_TIMER_INTERVAL)
- {
- memcpy(result,res_data,strlen(res_data));
- }
- }
- LYERRLOG("%s ret:%d",__func__,ret);
+ LYINFLOG("get recover timer interval");
+ p->readInt32(&recv_len);
+ if(recv_len == -1)
+ {
+ LYINFLOG("no responset");
delete p;
- return ret;
+ return LYNQ_E_INNER_ERROR;
}
-
- LYERRLOG("%s send request error %d",__func__,ret);
-
- return ret;
+ else
+ {
+ LYINFLOG("recv_len:%d",recv_len);
+ p->read(response_interval,recv_len);
+ }
+ LYINFLOG("response_interval:%s",response_interval);
+ ret = parse_at_result(response_interval,res_data,LY_RECOVER_TIMER_INTERVAL);
+ if(mode == 1)
+ {
+ if(strlen(res_data) <= LY_RECOVER_TIMER_INTERVAL)
+ {
+ memcpy(result,res_data,strlen(res_data));
+ }
+ }
+ LYERRLOG("%s ret:%d",__func__,ret);
+ delete p;
+ return ret;
}
int lynq_oos_deep_sleep_recover_timer_interval(int recovery_threshold,int fullband_timer,int sniffer_timer,int inactive_mode)
{
- int ret=-1;
-
- if(((recovery_threshold < 2) || (recovery_threshold > 10)) || ((fullband_timer < 90) || (fullband_timer > 360)) ||
+ if(g_module_init_flag != MODULE_RUNNING)
+ {
+ LYERRLOG("%s module state %d error",__func__,g_module_init_flag);
+ return LYNQ_E_CONFLICT;
+ }
+ if(((recovery_threshold < 2) || (recovery_threshold > 10)) || ((fullband_timer < 90) || (fullband_timer > 360)) ||
((sniffer_timer < 10) || (sniffer_timer > 60)) || ((inactive_mode < 0) || (inactive_mode > 1)))
{
- LYERRLOG("%s paramter recovery_threshold %d fullband_timer %d sniffer_timer %d inactive_mode %d fail!",__func__,recovery_threshold,fullband_timer,sniffer_timer,inactive_mode);
- return ret;
+ LYERRLOG("%s paramter recovery_threshold %d fullband_timer %d sniffer_timer %d inactive_mode %d error!",__func__,recovery_threshold,fullband_timer,sniffer_timer,inactive_mode);
+ return LYNQ_E_PARAMETER_ANONALY;
}
- lynq_resp_t head;
Parcel* p=NULL;
+ int ret=lynq_send_common_request(p,g_wait_time,RIL_REQUEST_OEM_HOOK_RAW,1,"AT+ESRVREC=%d,%d,%d,%d",recovery_threshold,fullband_timer,sniffer_timer,inactive_mode);
- ret=lynq_get_common_request(RIL_REQUEST_OEM_HOOK_RAW,5,p,1,"AT+ESRVREC=%d,%d,%d,%d",recovery_threshold,fullband_timer,sniffer_timer,inactive_mode);
- if(ret==0)
+ if(ret!=RESULT_OK)
{
- if(p==NULL)
- {
- LYERRLOG("%s get p error",__func__);
- return -1;
- }
- ret=GetHeader(p,head);
- if(ret!=0)
- {
- LYERRLOG("%s get head error",__func__,ret);
- delete p;
- return -1;
- }
- if(head.error!=0)
- {
- LYERRLOG("%s mdm return head error %d",__func__,head.error);
- delete p;
- return head.error;
- }
-
- int recv_len;
- char res_data[LY_RECOVER_TIMER_INTERVAL] = {0};
- char response_interval[LY_RECOVER_TIMER_INTERVAL*2] = {0};
-
- p->readInt32(&recv_len);
- if(recv_len == -1)
- {
- LYINFLOG("no responset");
- delete p;
- return -1;
- }
- else
- {
- LYINFLOG("recv_len:%d",recv_len);
- p->read(response_interval,recv_len);
- }
- LYINFLOG("response_interval:%s",response_interval);
- ret = parse_at_result(response_interval,res_data,LY_RECOVER_TIMER_INTERVAL);
- LYERRLOG("%s ret:%d",__func__,ret);
+ LYERRLOG("%s call lynq_send_common_request failure, ret is %d",__func__,ret);
+ return ret;
+ }
+
+ int recv_len;
+ char res_data[LY_RECOVER_TIMER_INTERVAL] = {0};
+ char response_interval[LY_RECOVER_TIMER_INTERVAL*2] = {0};
+
+ p->readInt32(&recv_len);
+ if(recv_len == -1)
+ {
+ LYINFLOG("no responset");
delete p;
- return ret;
+ return LYNQ_E_INNER_ERROR;
}
-
- LYERRLOG("%s send request error %d",__func__,ret);
-
- return ret;
+ else
+ {
+ LYINFLOG("recv_len:%d",recv_len);
+ p->read(response_interval,recv_len);
+ }
+ LYINFLOG("response_interval:%s",response_interval);
+ ret = parse_at_result(response_interval,res_data,LY_RECOVER_TIMER_INTERVAL);
+ LYERRLOG("%s ret:%d",__func__,ret);
+ delete p;
+ return ret;
+
}
#endif
diff --git a/src/lynq/lib/liblynq-network/lynq_network_state_buffer.cpp b/src/lynq/lib/liblynq-network/lynq_network_state_buffer.cpp
deleted file mode 100755
index 2fdea32..0000000
--- a/src/lynq/lib/liblynq-network/lynq_network_state_buffer.cpp
+++ /dev/null
@@ -1,581 +0,0 @@
-#include <stdio.h>
-#include <stdint.h> /*just for uint64_t in lynq_query_cell_info 20220819 hq*/
-#include <sys/types.h>
-#include <string.h>
-#include <unistd.h>
-#include <pthread.h>
-#include <signal.h>
-#include <errno.h>
-#include <fcntl.h>
-#include "liblog/lynq_deflog.h"
-#include "lynq_network.h"
-#include "lynq_network_state_buffer.h"
-
-#define USER_LOG_TAG "LYNQ_NETWORK"
-
-typedef struct{
- int voice_valid_period;
- int data_valid_period;
- int ims_valid_period;
-}lynq_network_register_buf_cfg;
-
-lynq_network_register_buf_cfg s_register_cfg;
-static timer_t s_register_timer_voice;
-static timer_t s_register_timer_data;
-static timer_t s_register_timer_ims;
-static int register_sig_value_voice = 2;
-static int register_sig_value_data = 3;
-static int register_sig_value_ims = 4;
-static int s_register_voice_valid=false;
-static int s_register_data_valid=false;
-static int s_register_ims_valid=false;
-static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
-#define VOICE_REG_BUFFER_FILE "/data/ril/network/.network_register_voice_buffer"
-#define DATA_REG_BUFFER_FILE "/data/ril/network/.network_register_data_buffer"
-#define IMS_REG_BUFFER_FILE "/data/ril/network/.network_register_ims_buffer"
-#define REG_CONFIG_FILE "/data/ril/network/.network_cfg"
-
-void get_network_register_timer_length_from_file()
-{
- int fd_backup;
- int ret;
- memset(&s_register_cfg,0,sizeof (s_register_cfg));
- fd_backup = open(REG_CONFIG_FILE,O_RDONLY | O_CREAT,0777);
- if (fd_backup < 0) {
- LYERRLOG("when get, Error opening register cfg file: %s\n",strerror(errno));
- return;
- }
-
- ret = read(fd_backup,&s_register_cfg,sizeof (s_register_cfg));
- if(ret<=0)
- {
- LYERRLOG("%s get register cfg fail, ret is %d",__func__,ret);
- }
- else
- {
- LYINFLOG("%s get register cfg suc %d",__func__);
- }
- close(fd_backup);
-
- return;
-}
-
-void set_network_register_timer_length_to_file()
-{
- int fd_backup;
- int ret;
- fd_backup = open(REG_CONFIG_FILE,O_WRONLY | O_CREAT,0777);
- if (fd_backup < 0) {
- LYERRLOG("when set, Error opening register cfg file: %s\n",strerror(errno));
- return;
- }
-
- ret = write(fd_backup,&s_register_cfg,sizeof (s_register_cfg));
- if(ret<=0)
- {
- LYERRLOG("%s set register cfg fail, ret is %d",__func__,ret);
- }
- else
- {
- LYINFLOG("%s set register cfg suc %d",__func__);
- }
- close(fd_backup);
-
- return;
-}
-
-void set_register_voice_buffer_valid(int valid)
-{
- s_register_voice_valid = valid;
- if(valid==false)
- {
- stop_network_timer(s_register_timer_voice, register_sig_value_voice);
- }
-}
-
-void set_register_data_buffer_valid(int valid)
-{
- s_register_data_valid = valid;
- if(valid==false)
- {
- stop_network_timer(s_register_timer_data, register_sig_value_data);
- }
-}
-
-void set_register_ims_buffer_valid(int valid)
-{
- s_register_ims_valid = valid;
- if(valid==false)
- {
- stop_network_timer(s_register_timer_ims, register_sig_value_ims);
- }
-}
-
-void start_network_timer(timer_t timer, int signal_value, int milliseconds) {
- LYINFLOG("start_network_timer(), timer_id=%ld, signal_value=%d, time=%d",(long)timer, signal_value, milliseconds);
-
- struct itimerspec expire;
- expire.it_interval.tv_sec = 0;
- expire.it_interval.tv_nsec = 0;
- expire.it_value.tv_sec = milliseconds/1000;
- expire.it_value.tv_nsec = (milliseconds%1000)*1000000;
- if (timer_settime(timer, 0, &expire, NULL) == -1) {
- LYERRLOG("timer_settime failed reason=[%s]", strerror(errno));
- }
-}
-
-void stop_network_timer(timer_t timer, int signal_value) {
- LYINFLOG("stop_network_timer(), timer_id=%ld, signal_value=%d", (long)timer, signal_value);
- struct itimerspec timespec;
- if(timer_gettime(timer, ×pec) == -1) {
- LYERRLOG("stop_network_timer(), get time fail(%s)", strerror(errno));
- return;
- }
- LYINFLOG("stop_network_timer(), tv_sec=%ld, tv_nsec=%ld",timespec.it_value.tv_sec, timespec.it_value.tv_nsec);
- if((timespec.it_value.tv_sec == 0) && (timespec.it_value.tv_nsec == 0) ) {
- LYINFLOG("stop_network_timer(), timer_id(%ld) had stopped, just return", (long)timer);
- return;
- } else {
- start_network_timer(timer, signal_value, 0);
- }
-}
-
-void network_timer_handler(sigval_t sig) {
- LYINFLOG("network_timer_handler, sig_value: %d", sig.sival_int);
- int s;
- s = pthread_mutex_lock(&mtx);
- if(s != 0) {
- LYERRLOG("network_timer_handler, pthead_mutex_lock fail");
- }
- if(sig.sival_int == register_sig_value_voice)
- {
- s_register_voice_valid=false;
- }
- else if(sig.sival_int == register_sig_value_data)
- {
- s_register_data_valid=false;
- }
- else if(sig.sival_int == register_sig_value_ims)
- {
- s_register_ims_valid=false;
- }
- s = pthread_mutex_unlock(&mtx);
- if(s != 0) {
- LYERRLOG("network_timer_handler, pthread_mutex_unlock fail");
- }
-}
-
-void init_network_timer(timer_t* timer, int signal_value)
-{
- struct sigevent sevp;
- memset(&sevp, 0, sizeof(sevp));
- sevp.sigev_value.sival_int = signal_value;
- sevp.sigev_notify = SIGEV_THREAD;
- sevp.sigev_notify_function = network_timer_handler;
-
- if(timer_create(CLOCK_MONOTONIC, &sevp, timer) == -1) {
- LYERRLOG("init_network_timer() failed reason=[%s]", strerror(errno));
- }
- LYINFLOG("init_network_timer(), timer_Id = %ld, signal_value=%d", (long)(*timer), signal_value);
-}
-
-void init_network_timer_all() {
- init_network_timer(&s_register_timer_voice,register_sig_value_voice);
- init_network_timer(&s_register_timer_data,register_sig_value_data);
- init_network_timer(&s_register_timer_ims,register_sig_value_ims);
- s_register_voice_valid = false;
- s_register_data_valid = false;
- s_register_ims_valid = false;
-
- get_network_register_timer_length_from_file();
-}
-
-void deinit_network_timer_all()
-{
- stop_network_timer(s_register_timer_voice, register_sig_value_voice);
- stop_network_timer(s_register_timer_data, register_sig_value_data);
- stop_network_timer(s_register_timer_ims, register_sig_value_ims);
- s_register_voice_valid = false;
- s_register_data_valid = false;
- s_register_ims_valid = false;
-}
-
-void lynq_set_registration_state_to_buf_voice(int regState,int netType,int netRejected)
-{
- int ret;
- int fd_backup;
-
- if(s_register_cfg.voice_valid_period<=0)
- {
- LYINFLOG("%s timer length is not greater than 0",__func__);
- return;
- }
-
- fd_backup = open(VOICE_REG_BUFFER_FILE,O_WRONLY | O_CREAT,0777);
-
- if (fd_backup < 0) {
- LYERRLOG("Error opening registrate voice buffer file: %s\n",strerror(errno));
- return ;
- }
-
- ret = write(fd_backup,®State,sizeof (regState));
- if(ret<=0)
- {
- LYERRLOG("%s set regState fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = write(fd_backup,&netType,sizeof (netType));
- if(ret<=0)
- {
- LYERRLOG("%s set netType fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = write(fd_backup,&netRejected,sizeof (netRejected));
- if(ret<=0)
- {
- LYERRLOG("%s set netRejected fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- sync();
- close(fd_backup);
- start_network_timer(s_register_timer_voice,register_sig_value_voice,s_register_cfg.voice_valid_period*1000);
- s_register_voice_valid=true;
-
- LYINFLOG("set_registration_state voice suc, regState is %d, netType is %d, netRejected is %d",regState,netType,netRejected);
- return;
-
-error_done:
-
- close(fd_backup);
- return;
-}
-void lynq_set_registration_state_to_buf_data(int regState,char * LAC,char * CID,int netType)
-{
- int ret;
- int stringLen;
- int fd_backup;
-
- if(s_register_cfg.data_valid_period <=0)
- {
- LYINFLOG("%s timer length is not greater than 0",__func__);
- return;
- }
-
- fd_backup = open(DATA_REG_BUFFER_FILE,O_WRONLY | O_CREAT,0777);
-
- if (fd_backup < 0) {
- LYERRLOG("Error opening registrate data buffer file: %s\n",strerror(errno));
- return ;
- }
-
- ret = write(fd_backup,®State,sizeof (regState));
- if(ret<=0)
- {
- LYERRLOG("%s set regState fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = write(fd_backup,&netType,sizeof (netType));
- if(ret<=0)
- {
- LYERRLOG("%s set netType fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- stringLen=strlen(LAC)+1;
- ret = write(fd_backup,&stringLen,sizeof (stringLen));
- if(ret<=0)
- {
- LYERRLOG("%s set lac stringLen %d fail, ret is %d",__func__, stringLen, ret);
- goto error_done;
- }
-
- ret = write(fd_backup,LAC,stringLen);
- if(ret<=0)
- {
- LYERRLOG("%s set lac fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- stringLen=strlen(CID)+1;
- ret = write(fd_backup,&stringLen,sizeof (stringLen));
- if(ret<=0)
- {
- LYERRLOG("%s set cid stringLen %d fail, ret is %d",__func__, stringLen, ret);
- goto error_done;
- }
-
- ret = write(fd_backup,CID,stringLen);
- if(ret<=0)
- {
- LYERRLOG("%s set cid fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- sync();
- close(fd_backup);
- start_network_timer(s_register_timer_data,register_sig_value_data,s_register_cfg.data_valid_period*1000);
- s_register_data_valid=true;
-
- LYINFLOG("set_registration_state data suc, regState is %d, netType is %d, LAC is %s, CID is %s",regState,netType,LAC,CID);
- return;
-
-error_done:
-
- close(fd_backup);
- return;
-}
-void lynq_set_registration_state_to_buf_ims(int imsRegState,int radioTechFam)
-{
- int ret;
- int fd_backup;
-
- if(s_register_cfg.ims_valid_period<=0)
- {
- LYINFLOG("%s timer length is not greater than 0",__func__);
- return;
- }
-
- fd_backup = open(IMS_REG_BUFFER_FILE,O_WRONLY | O_CREAT,0777);
-
- if (fd_backup < 0) {
- LYERRLOG("Error opening registrate ims buffer file: %s\n",strerror(errno));
- return ;
- }
-
- ret = write(fd_backup,&imsRegState,sizeof (imsRegState));
- if(ret<=0)
- {
- LYERRLOG("%s set imsRegState fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = write(fd_backup,&radioTechFam,sizeof (radioTechFam));
- if(ret<=0)
- {
- LYERRLOG("%s set radioTechFam fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- sync();
- close(fd_backup);
- start_network_timer(s_register_timer_ims,register_sig_value_ims,s_register_cfg.ims_valid_period*1000);
- s_register_ims_valid=true;
-
- LYINFLOG("set_registration_state ims suc, imsRegState is %d, radioTechFam is %d",imsRegState,radioTechFam);
- return;
-
-error_done:
-
- close(fd_backup);
- return;
-}
-
-int lynq_get_registration_state_to_buf_voice(int* regState,int *netType,int *netRejected)
-{
- int ret;
- int fd_backup;
-
- if(!s_register_voice_valid)
- {
- LYINFLOG("registration voice buffer is false");
- return 1;
- }
-
- fd_backup = open(VOICE_REG_BUFFER_FILE, O_RDONLY);
-
- if (fd_backup < 0) {
- LYERRLOG("Error opening registrate voice buffer file: %s\n",strerror(errno));
- s_register_voice_valid=false;
- return -1;
- }
-
- ret = read(fd_backup,regState,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get regState fail, ret is %d",__func__,ret);
- goto error_done;
- }
-
- ret = read(fd_backup,netType,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get netType fail, ret is %d",__func__,ret);
- goto error_done;
- }
-
- ret = read(fd_backup,netRejected,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get netRejected fail, ret is %d",__func__,ret);
- goto error_done;
- }
-
-
- close(fd_backup);
- LYINFLOG("get_registration_state voice suc, regState is %d, netType is %d, netRejected is %d",*regState,*netType,*netRejected);
- return 0;
-
-error_done:
- s_register_voice_valid=false;
- close(fd_backup);
- return -1;
-}
-int lynq_get_registration_state_to_buf_data(int* regState,char * LAC,char * CID,int *netType)
-{
- int ret;
- int stringLen;
- int fd_backup;
-
- if(!s_register_data_valid)
- {
- LYINFLOG("registration data buffer is false");
- return 1;
- }
-
- fd_backup = open(DATA_REG_BUFFER_FILE,O_RDONLY);
-
- if (fd_backup < 0) {
- LYERRLOG("Error opening registrate data buffer file: %s\n",strerror(errno));
- return -1;
- }
-
- ret = read(fd_backup,regState,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get regState fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = read(fd_backup,netType,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get netType fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = read(fd_backup,&stringLen,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get lac stringLen fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = read(fd_backup,LAC,stringLen);
- if(ret<=0)
- {
- LYERRLOG("%s get lac fail, ret is %d, stringLen is %d",__func__, ret,stringLen);
- goto error_done;
- }
-
-
- ret = read(fd_backup,&stringLen,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get cid stringLen fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = read(fd_backup,CID,stringLen);
- if(ret<=0)
- {
- LYERRLOG("%s get cid fail, ret is %d, stringLen is %d",__func__, ret,stringLen);
- goto error_done;
- }
-
- close(fd_backup);
-
- LYINFLOG("get_registration_state data suc, regState is %d, netType is %d, LAC is %s, CID is %s",*regState,*netType,LAC,CID);
- return 0;
-
-error_done:
- s_register_data_valid =false;
- close(fd_backup);
- return -1;
-
-}
-int lynq_get_registration_state_to_buf_ims(int* imsRegState,int *radioTechFam)
-{
- int ret;
- int fd_backup;
-
- if(!s_register_ims_valid)
- {
- LYINFLOG("registration ims buffer is false");
- return 1;
- }
-
- fd_backup = open(IMS_REG_BUFFER_FILE,O_RDONLY);
-
- if (fd_backup < 0) {
- LYERRLOG("Error opening registrate ims buffer file: %s\n",strerror(errno));
- return -1;
- }
-
- ret = read(fd_backup,imsRegState,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get imsRegState fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- ret = read(fd_backup,radioTechFam,sizeof (int));
- if(ret<=0)
- {
- LYERRLOG("%s get radioTechFam fail, ret is %d",__func__, ret);
- goto error_done;
- }
-
- close(fd_backup);
-
- LYINFLOG("get_registration_state ims suc, imsRegState is %d, radioTechFam is %d",*imsRegState,*radioTechFam);
- return 0;
-
-error_done:
- s_register_ims_valid =false;
- close(fd_backup);
- return -1;
-}
-
-void lynq_set_voice_registration_valid_period(int valid_period)
-{
- s_register_cfg.voice_valid_period=valid_period;
- stop_network_timer(s_register_timer_voice, register_sig_value_voice);
- s_register_voice_valid=false;
- set_network_register_timer_length_to_file();
-}
-
-void lynq_set_data_registration_valid_period(int valid_period)
-{
- s_register_cfg.data_valid_period = valid_period;
- stop_network_timer(s_register_timer_data, register_sig_value_data);
- s_register_data_valid=false;
- set_network_register_timer_length_to_file();
-}
-
-void lynq_set_ims_registration_valid_period(int valid_period)
-{
- s_register_cfg.ims_valid_period=valid_period;
- stop_network_timer(s_register_timer_ims, register_sig_value_ims);
- s_register_ims_valid=false;
- set_network_register_timer_length_to_file();
-}
-
-int lynq_get_voice_registration_valid_period()
-{
- return s_register_cfg.voice_valid_period;
-}
-
-int lynq_get_data_registration_valid_period()
-{
- return s_register_cfg.data_valid_period;
-}
-
-int lynq_get_ims_registration_valid_period()
-{
- return s_register_cfg.ims_valid_period;
-}
-
diff --git a/src/lynq/lib/liblynq-network/lynq_network_state_buffer.h b/src/lynq/lib/liblynq-network/lynq_network_state_buffer.h
deleted file mode 100755
index c0e20be..0000000
--- a/src/lynq/lib/liblynq-network/lynq_network_state_buffer.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef LYNQ_NETWORK_STATE_BUFFER_H
-#define LYNQ_NETWORK_STATE_BUFFER_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-void set_register_voice_buffer_valid(int valid);
-void set_register_data_buffer_valid(int valid);
-void set_register_ims_buffer_valid(int valid);
-void stop_network_timer(timer_t timer, int signal_value);
-void start_network_timer(timer_t timer, int signal_value, int milliseconds);
-void init_network_timer_all();
-void deinit_network_timer_all();
-void lynq_set_registration_state_to_buf_voice(int regState,int netType,int netRejected);
-void lynq_set_registration_state_to_buf_data(int regState,char * LAC,char * CID,int netType);
-void lynq_set_registration_state_to_buf_ims(int imsRegState,int radioTechFam);
-int lynq_get_registration_state_to_buf_voice(int* regState,int *netType,int *netRejected);
-int lynq_get_registration_state_to_buf_data(int* regState,char * LAC,char * CID,int *netType);
-int lynq_get_registration_state_to_buf_ims(int* imsRegState,int *radioTechFam);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/lynq/lib/liblynq-sim/include/lynq_sim.h b/src/lynq/lib/liblynq-sim/include/lynq_sim.h
index 570b5f4..c2d7793 100755
--- a/src/lynq/lib/liblynq-sim/include/lynq_sim.h
+++ b/src/lynq/lib/liblynq-sim/include/lynq_sim.h
@@ -28,6 +28,7 @@
int lynq_switch_card(int slot);
int lynq_screen(int num);
int lynq_get_imei(char buf[]);
+int lynq_get_imei_and_sv(char imei[],char sv[]);
/**
* @brief Request SIM I/O operation.
diff --git a/src/lynq/lib/liblynq-sim/src/lynq_sim.cpp b/src/lynq/lib/liblynq-sim/src/lynq_sim.cpp
index 539837b..1fa5578 100755
--- a/src/lynq/lib/liblynq-sim/src/lynq_sim.cpp
+++ b/src/lynq/lib/liblynq-sim/src/lynq_sim.cpp
@@ -764,23 +764,6 @@
return error1;
}
-/**
- * @brief To handle comma-separated strings, take the character before the first comma eg:123456,78 ->123456
- *
- * @param buf Type:[IN]
- */
-static void parse_imei(char buf[])
-{
- if(NULL == buf)
- {
- return;
- }
- const char s[2] = ",";
- char *token;
- token = strtok(buf, s);
- return;
-}
-
int lynq_get_imei(char buf[])
{
if(g_lynq_sim_init_flag == 0)
@@ -829,8 +812,7 @@
p.readInt32(&error1);
if(!error1){
p.readInt32(&num);
- char * test = lynqStrdupReadString(p);
- parse_imei(test);
+ char * test = lynqStrdupReadString(p);
memcpy(buf, test, strlen(test));
free(test);
}
@@ -838,6 +820,99 @@
return error1;
}
+int lynq_get_imei_and_sv(char imei[],char sv[])
+{
+ RLOGD("%s called",__func__);
+ if(g_lynq_sim_init_flag == 0)
+ {
+ RLOGD("%s init_flag is %d",__func__,g_lynq_sim_init_flag);
+ return -2;
+ }
+ int ret = -1;
+ if(imei == NULL || sv== NULL)
+ {
+ RLOGD("%s imei is NULL or sv is NULL",__func__);
+ return ret;
+ }
+
+ int send_num = 0;
+ int recv_num = 0;
+ int len = 0;
+ lynq_client_t client_t1;
+ memset(&client_t1, 0, sizeof(client_t1) );
+ client_t1.request = RIL_REQUEST_DEVICE_IDENTITY;
+ client_t1.paramLen = 0;
+ client_t1.uToken = Global_uToken;
+ char res_data[MAX_LEN] = {0};
+ memset(client_t1.param, 0, sizeof(client_t1.param));
+ pthread_mutex_lock(&g_lynq_sim_sendto_mutex);
+ send_num = sendto(sock_fd, &client_t1, sizeof(client_t1), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
+ if(send_num < 0)
+ {
+ RLOGD("%s sendto error: %d",__func__,send_num);
+ pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
+ return send_num;
+ }
+ //get data msg
+ recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
+ pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
+ if(recv_num < 0 || recv_num == 0)
+ {
+ RLOGD("%s recvfrom step2 fail:%d",__func__,recv_num);
+ return recv_num;
+ }
+ Parcel p;
+ p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ int num = 0;
+ if(p.dataAvail() > 0)
+ {
+ p.readInt32(&resp_type);
+ p.readInt32(&solicited_token);
+ p.readInt32(&request);
+ p.readInt32(&slot_id);
+ p.readInt32(&error1);
+ if(!error1){
+ p.readInt32(&num);
+ if(num<2)
+ {
+ RLOGD("%s num %d error, should greater than 1",__func__,num);
+ return -1;
+ }
+ char *resp[2]={NULL,NULL};
+ int i;
+ for(i=0;i<2;i++)
+ {
+ resp[i]= lynqStrdupReadString(p);
+ if(resp[i]==NULL)
+ {
+ break;
+ }
+ }
+
+ if(i==2){
+ memcpy(imei, resp[0], strlen(resp[0])+1);
+ memcpy(sv, resp[1], strlen(resp[1])+1);
+ }
+ else
+ {
+ RLOGD("%s resp[%d] is null",__func__,i);
+ }
+
+ for(i=0;i<2;i++)
+ {
+ if(resp[i]!=NULL)
+ {
+ free(resp[i]);
+ }
+ }
+ return i==2? 0:-1;
+ }
+ }
+ RLOGD("%s called failed %d",__func__,error1);
+ return error1;
+}
+
static int judge(int slot){
switch(slot){
case 0:
@@ -1151,6 +1226,7 @@
static void wait_reset_mipc_response(int *response)
{
+ usleep(500*1000);
int outfd = open("/data/tp",O_RDONLY);
if(outfd == -1){
RLOGD("open error");
diff --git a/src/lynq/lib/liblynq-wifi6/include/libwifi6.h b/src/lynq/lib/liblynq-wifi6/include/libwifi6.h
index c6e4803..c6ad362 100755
--- a/src/lynq/lib/liblynq-wifi6/include/libwifi6.h
+++ b/src/lynq/lib/liblynq-wifi6/include/libwifi6.h
@@ -218,4 +218,23 @@
int lynq_get_connect_ap_band(lynq_wifi_index_e idx,lynq_wifi_band_m * band);
int lynq_get_connect_ap_ip(lynq_wifi_index_e idx,char *ip);
+/*****add limit of connected ap device number 2022.10.12 by qs.xiong
+ *
+ *sta_number:
+ * ap max be connected no more than 15
+ * so sta_number : [1-15]
+ */
+int lynq_ap_connect_num(int sta_number);
+
+/****add acs contrl api*****************
+ *
+ *idx:
+ * 1 is ap and only 1 is legal in this api
+ *acs_mode:
+ * 2 is open acs at 2.4GHz
+ * 5 is open acs at 5GHz
+ * didnt ssuport 2.4G&5G together
+ * add by qs.xiong 20221012*************/
+int lynq_enable_acs(lynq_wifi_index_e idx,int acs_mode);
+
#endif
diff --git a/src/lynq/lib/liblynq-wifi6/libwifi6.c b/src/lynq/lib/liblynq-wifi6/libwifi6.c
index cc14e8a..5ea342a 100755
--- a/src/lynq/lib/liblynq-wifi6/libwifi6.c
+++ b/src/lynq/lib/liblynq-wifi6/libwifi6.c
@@ -801,16 +801,44 @@
return 0;
}
+/*****
+ *frequency <------>channel
+ *
+ *frequency 1 2 3 4 5 6 7 8 9 10 11 12 13 36 40 44 48 149 153 157 161 165
+ *
+ *
+ *channel 2412,2417,2422,2427,2532,2437,2442,2447,2452,2457,2462,2467,2472,5180,5200,5220,5240,5745,5765,5785,5805,5825
+ *
+ *
+ * */
+static int lynq_check_set_frequency(int input_frequency){
+ static int legitimate_frequency[21]={2412,2417,2422,2427,2432,2437,2442,2447,2452,2457,2462,2467,2472,5180,5200,5220,5240,5745,5765,5785,5805,5825};
+ int i = 0;
+ int flag_check = 0;
+ for(i=0 ;i<= 21; i++){
+ if(input_frequency == legitimate_frequency[i]){
+ flag_check = 1;
+ break;
+ }
+ }
+ if(flag_check == 1){
+ printf("input frequency in range\n");
+ }else{
+ printf("input frequency is eero--->%d,please check it\n",input_frequency);
+ return -1;
+ }
+ return 0;
+}
int lynq_wifi_ap_frequency_set(lynq_wifi_index_e idx,int lynq_wifi_frequency)
{
- char lynq_wifi_frequency_cmd[128]={0};
- char lynq_cmd_mode[128]={0};
+ char lynq_wifi_frequency_cmd[128]={0};
+ char lynq_cmd_mode[128]={0};
char lynq_cmd_slect[128]={0};
- if((lynq_wifi_frequency != 2437) && (lynq_wifi_frequency != 5180)){
- PRINT_AND_RETURN_VALUE("set frequency not in range",-1);
+ //@do check input frequency
+ if((lynq_check_set_frequency(lynq_wifi_frequency)) != 0){
+ return -1;
}
-
if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != 0) {
return -1;
}
@@ -2494,4 +2522,50 @@
return -1;
}
+int lynq_ap_connect_num(int sta_number)
+{
+ char lynq_limit_cmd[32]={0};
+ int ret;
+ if((sta_number < 1 ) && (sta_number > 15)){
+ printf("sta_number: not in range\n",sta_number);
+ return -1;
+ }
+ sprintf(lynq_limit_cmd,"wl maxassoc %d", sta_number);
+ ret = system(lynq_limit_cmd);
+ if(ret != 0){
+ printf("cmd of limit ap devices number error\n");
+ }
+ return 0;
+}
+int lynq_enable_acs(lynq_wifi_index_e idx,int acs_mode)
+{
+
+ char lynq_wifi_acs_cmd[128]={0};
+ char lynq_cmd_mode[128]={0};
+ char lynq_cmd_slect[128]={0};
+
+ if((acs_mode != 2) && (acs_mode != 5)){
+ PRINT_AND_RETURN_VALUE("set acs_mode is error",-1);
+ }
+
+ if (lynq_check_network_number(idx, CTRL_AP, AP_NETWORK_0) != 0) {
+ return -1;
+ }
+
+ CHECK_IDX(idx, CTRL_AP);
+
+ CHECK_WPA_CTRL(CTRL_AP);
+
+ sprintf(lynq_wifi_acs_cmd,"SET_NETWORK %d frequency %d", AP_NETWORK_0, acs_mode);
+ sprintf(lynq_cmd_mode, "SET_NETWORK %d mode 2", AP_NETWORK_0);
+ sprintf(lynq_cmd_slect, "SELECT_NETWORK %d", AP_NETWORK_0);
+
+ DO_OK_FAIL_REQUEST(cmd_disconnect);
+ DO_OK_FAIL_REQUEST(lynq_wifi_acs_cmd);
+ DO_OK_FAIL_REQUEST(lynq_cmd_mode);
+ DO_OK_FAIL_REQUEST(cmd_save_config);
+ DO_OK_FAIL_REQUEST(lynq_cmd_slect);
+
+ return 0;
+}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/conf/hostapd.conf b/src/lynq/packages/thirdpart/lynq-wg870/conf/hostapd.conf
new file mode 100755
index 0000000..a765b5c
--- /dev/null
+++ b/src/lynq/packages/thirdpart/lynq-wg870/conf/hostapd.conf
@@ -0,0 +1,14 @@
+interface=wlan0
+driver=nl80211
+hw_mode=g
+ieee80211n=1
+ctrl_interface=/var/run/hostapd
+ssid=cyp
+channel=36
+wpa_passphrase=12345678
+auth_algs=1 #1=wpa,2=wep,3=both
+wpa=2 #WPA2 only
+wpa_key_mgmt=WPA-PSK
+sae_groups=19
+sae_pwe=2
+
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/conf/p2p_supplicant.conf b/src/lynq/packages/thirdpart/lynq-wg870/conf/p2p_supplicant.conf
index 32e3354..16da2d0 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/conf/p2p_supplicant.conf
+++ b/src/lynq/packages/thirdpart/lynq-wg870/conf/p2p_supplicant.conf
@@ -4,8 +4,8 @@
ap_scan=1
fast_reauth=1
driver_param=use_p2p_group_interface=1p2p_device=1
-device_name=NUC-LINUX
+device_name=BRIX-FC19
device_type=10-0050F204-5
config_methods=virtual_push_button physical_display keypad
-p2p_ssid_postfix=-NUC-SSID
+p2p_ssid_postfix=-BRIX-SSID
persistent_reconnect=1
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/conf/sta.conf b/src/lynq/packages/thirdpart/lynq-wg870/conf/sta.conf
new file mode 100755
index 0000000..8df9980
--- /dev/null
+++ b/src/lynq/packages/thirdpart/lynq-wg870/conf/sta.conf
@@ -0,0 +1,12 @@
+ctrl_interface=/var/run/wpa_supplicant
+driver_param=use_p2p_group_interface=1p2p_device=1
+update_config=1
+device_name=BRIX-FC19
+manufacturer=Intel
+model_name=bigcore platform
+model_number=bigcore platform
+serial_number=
+device_type=10-0050F204-1
+config_methods=keypad display push_button
+p2p_ssid_postfix=-BRIX-SSID
+persistent_reconnect=1
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant.conf b/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant.conf
index 2e00f00..833ae20 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant.conf
+++ b/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant.conf
@@ -4,7 +4,10 @@
ap_scan=1
fast_reauth=1
driver_param=use_p2p_group_interface=1p2p_device=1
-device_name=NUC-LINUX
+device_name=BRIX-FC19
device_type=10-0050F204-5
config_methods=virtual_push_button physical_display keyboard
+hs20=1
interworking=1
+sae_groups=19
+sae_pwe=2
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant_ap.conf b/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant_ap.conf
index 307f567..f39ec98 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant_ap.conf
+++ b/src/lynq/packages/thirdpart/lynq-wg870/conf/wpa_supplicant_ap.conf
@@ -1,3 +1,4 @@
ctrl_interface=/var/run/wpa_supplicant
update_config=1
-p2p_disabled=1
+sae_groups=19
+sae_pwe=2
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/.config b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/.config
index 04f0b34..1c02c16 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/.config
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/.config
@@ -177,7 +177,7 @@
# Note: This is experimental and work in progress. The definitions are still
# subject to change and this should not be expected to interoperate with the
# final IEEE 802.11ax version.
-#CONFIG_IEEE80211AX=y
+CONFIG_IEEE80211AX=y
# Remove debugging code that is printing out debug messages to stdout.
# This can be used to reduce the size of the hostapd considerably if debugging
@@ -204,7 +204,7 @@
#CONFIG_NO_RADIUS=y
# Remove support for VLANs
-#CONFIG_NO_VLAN=y
+CONFIG_NO_VLAN=y
# Enable support for fully dynamic VLANs. This enables hostapd to
# automatically create bridge and VLAN interfaces if necessary.
@@ -409,3 +409,11 @@
# Host SAE via Vendor commands
#CONFIG_WL_SAE=y
+
+# Enable all IFX/Cypress changes
+CONFIG_DRIVER_NL80211_IFX=y
+
+# WPA3 Enterprise Mode
+CONFIG_SUITEB192=y
+CONFIG_SUITEB=y
+#
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/config_file.c b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/config_file.c
index 1226191..0d3c6fd 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/config_file.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/config_file.c
@@ -700,14 +700,6 @@
*end = '\0';
if (os_strcmp(start, "WPA-PSK") == 0)
val |= WPA_KEY_MGMT_PSK;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- else if (os_strcmp(start, "WAPI-PSK") == 0) {
- val |= WPA_KEY_MGMT_WAPI_PSK;
- wpa_printf(MSG_INFO, "%s: key mgmt is set to WPA_KEY_MGMT_WAPI_PSK\n", __FUNCTION__);
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
else if (os_strcmp(start, "WPA-EAP") == 0)
val |= WPA_KEY_MGMT_IEEE8021X;
#ifdef CONFIG_IEEE80211R_AP
@@ -2252,7 +2244,6 @@
pw->password[end - val] = '\0';
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef WL_SAE
if (strlen(pw->password) < 8 || strlen(pw->password) > 63) {
wpa_printf(MSG_ERROR, "invalid SAE passphrase length %d (expected 8..63)",
@@ -2260,7 +2251,6 @@
goto fail;
}
#endif /* WL_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_SAE_PK
if (pw->pk &&
#ifdef CONFIG_TESTING_OPTIONS
@@ -2860,7 +2850,6 @@
} else if (os_strcmp(buf, "wpa_ptk_rekey") == 0) {
bss->wpa_ptk_rekey = atoi(pos);
} else if (os_strcmp(buf, "wpa_deny_ptk0_rekey") == 0) {
-#if defined(CONFIG_DRIVER_NL80211_IFX)
/* Fix compilation error for unsigned enum comparision */
int val = atoi(pos);
@@ -2871,16 +2860,6 @@
return 1;
}
bss->wpa_deny_ptk0_rekey = val;
-#else
- bss->wpa_deny_ptk0_rekey = atoi(pos);
- if (bss->wpa_deny_ptk0_rekey < 0 ||
- bss->wpa_deny_ptk0_rekey > 2) {
- wpa_printf(MSG_ERROR,
- "Line %d: Invalid wpa_deny_ptk0_rekey=%d; allowed range 0..2",
- line, bss->wpa_deny_ptk0_rekey);
- return 1;
- }
-#endif /* CONFIG_DRIVER_NL80211_IFX */
} else if (os_strcmp(buf, "wpa_group_update_count") == 0) {
char *endp;
unsigned long val = strtoul(pos, &endp, 0);
@@ -3441,12 +3420,10 @@
conf->require_ht = atoi(pos);
} else if (os_strcmp(buf, "obss_interval") == 0) {
conf->obss_interval = atoi(pos);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
} else if (os_strcmp(buf, "replay_cntrs") == 0) {
bss->replay_cntrs = atoi(pos);
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_IEEE80211AC
} else if (os_strcmp(buf, "ieee80211ac") == 0) {
conf->ieee80211ac = atoi(pos);
@@ -4472,12 +4449,10 @@
#endif /* CONFIG_OWE */
} else if (os_strcmp(buf, "coloc_intf_reporting") == 0) {
bss->coloc_intf_reporting = atoi(pos);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_SUPP_ACS
} else if (os_strcmp(buf, "autochannel_enabled") == 0) {
conf->autochannel_enabled = atoi(pos);
#endif /* BRCM_SUPP_ACS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
} else if (os_strcmp(buf, "multi_ap") == 0) {
int val = atoi(pos);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.c b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.c
index f11fa78..0cb7607 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.c
@@ -2770,7 +2770,6 @@
return ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VENDOR_IE
static int hostapd_ctrl_iface_vendor_ie(struct hostapd_data *hapd, char *cmd)
{
@@ -2852,7 +2851,6 @@
return ret;
}
#endif /* ANDROID || BCM_LINUX_BUILD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int hostapd_ctrl_iface_eapol_reauth(struct hostapd_data *hapd,
const char *cmd)
@@ -3654,13 +3652,11 @@
} else if (os_strncmp(buf, "VENDOR ", 7) == 0) {
reply_len = hostapd_ctrl_iface_vendor(hapd, buf + 7, reply,
reply_size);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VENDOR_IE
} else if (os_strncmp(buf, "VENDOR_IE ", 10) == 0) {
if (hostapd_ctrl_iface_vendor_ie(hapd, buf + 10))
reply_len = -1;
#endif /* CONFIG_BRCM_VENDOR_IE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
} else if (os_strcmp(buf, "ERP_FLUSH") == 0) {
ieee802_1x_erp_flush(hapd);
#ifdef RADIUS_SERVER
@@ -3754,13 +3750,11 @@
&hapd->conf->deny_mac,
&hapd->conf->num_deny_mac);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
} else if (os_strncmp(buf, "DRIVER ", 7) == 0) {
reply_len = hostapd_driver_cmd(hapd, buf + 7, reply,
reply_size);
#endif /* ANDROID || BCM_LINUX_BUILD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DPP
} else if (os_strncmp(buf, "DPP_QR_CODE ", 12) == 0) {
res = hostapd_dpp_qr_code(hapd, buf + 12);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.h b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.h
index a4d013e..4430c9f 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/ctrl_iface.h
@@ -14,12 +14,10 @@
void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd);
int hostapd_global_ctrl_iface_init(struct hapd_interfaces *interface);
void hostapd_global_ctrl_iface_deinit(struct hapd_interfaces *interface);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
int hostapd_driver_cmd(struct hostapd_data *hapd, char *cmd,
char *buf, size_t buflen);
#endif /* ANDROID || BCM_LINUX_BUILD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#else /* CONFIG_NO_CTRL_IFACE */
static inline int hostapd_ctrl_iface_init(struct hostapd_data *hapd)
{
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/defconfig_auto b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/defconfig_auto
index 805741e..1c02c16 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/defconfig_auto
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/defconfig_auto
@@ -177,7 +177,7 @@
# Note: This is experimental and work in progress. The definitions are still
# subject to change and this should not be expected to interoperate with the
# final IEEE 802.11ax version.
-#CONFIG_IEEE80211AX=y
+CONFIG_IEEE80211AX=y
# Remove debugging code that is printing out debug messages to stdout.
# This can be used to reduce the size of the hostapd considerably if debugging
@@ -204,7 +204,7 @@
#CONFIG_NO_RADIUS=y
# Remove support for VLANs
-#CONFIG_NO_VLAN=y
+CONFIG_NO_VLAN=y
# Enable support for fully dynamic VLANs. This enables hostapd to
# automatically create bridge and VLAN interfaces if necessary.
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/hostapd_cli.c b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/hostapd_cli.c
index 37e010f..58d92a5 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/hostapd_cli.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/hostapd_cli.c
@@ -1244,7 +1244,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VENDOR_IE
static int hostapd_cli_cmd_vendor_ie(struct wpa_ctrl *ctrl, int argc, char *argv[])
{
@@ -1261,7 +1260,6 @@
return wpa_ctrl_command(ctrl, cmd);
}
#endif /* CONFIG_BRCM_VENDOR_IE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int hostapd_cli_cmd_erp_flush(struct wpa_ctrl *ctrl, int argc,
char *argv[])
{
@@ -1269,7 +1267,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
static int hostapd_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
{
@@ -1290,7 +1287,6 @@
return wpa_ctrl_command(ctrl, cmd);
}
#endif /* ANDROID || BCM_LINUX_BUILD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int hostapd_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc,
char *argv[])
{
@@ -1704,14 +1700,12 @@
" = send FTM range request"},
{ "driver_flags", hostapd_cli_cmd_driver_flags, NULL,
" = show supported driver flags"},
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VENDOR_IE
{ "vendor_ie", hostapd_cli_cmd_vendor_ie, NULL, NULL },
#endif /* CONFIG_BRCM_VENDOR_IE */
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
{ "driver", hostapd_cli_cmd_driver, NULL, NULL },
#endif /* ANDROID || BCM_LINUX_BUILD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DPP
{ "dpp_qr_code", hostapd_cli_cmd_dpp_qr_code, NULL,
"report a scanned DPP URI from a QR Code" },
@@ -2139,11 +2133,7 @@
printf("%s\n\n%s\n\n", hostapd_cli_version, cli_license);
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI_AP)
- if (eloop_init(NULL))
-#else
if (eloop_init())
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI_AP */
return -1;
for (;;) {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/main.c b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/main.c
index fa42160..7e385d6 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hostapd/main.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hostapd/main.c
@@ -30,11 +30,9 @@
#include "config_file.h"
#include "eap_register.h"
#include "ctrl_iface.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
#include "hidl.h"
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#endif /*CONFIG_DRIVER_NL80211_IFX */
struct hapd_global {
@@ -218,7 +216,6 @@
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_SUPP_ACS
if (iface->conf->autochannel_enabled) {
char buf[64];
@@ -245,7 +242,6 @@
}
}
#endif /* BRCM_SUPP_ACS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (hapd->driver->get_capa &&
hapd->driver->get_capa(hapd->drv_priv, &capa) == 0) {
struct wowlan_triggers *triggs;
@@ -378,11 +374,7 @@
return -1;
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI_AP)
- if (eloop_init(NULL)) {
-#else
if (eloop_init()) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI_AP */
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
@@ -801,17 +793,11 @@
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef CONFIG_CTRL_IFACE_HIDL
if (optind == argc && interfaces.global_iface_path == NULL &&
num_bss_configs == 0)
usage();
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#else
- if (optind == argc && interfaces.global_iface_path == NULL &&
- num_bss_configs == 0)
- usage();
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_msg_register_ifname_cb(hostapd_msg_ifname_cb);
@@ -932,14 +918,12 @@
goto out;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
if (hostapd_hidl_init(&interfaces)) {
wpa_printf(MSG_ERROR, "Failed to initialize HIDL interface");
goto out;
}
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
hostapd_global_ctrl_iface_init(&interfaces);
if (hostapd_global_run(&interfaces, daemonize, pid_file)) {
@@ -950,11 +934,9 @@
ret = 0;
out:
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
hostapd_hidl_deinit(&interfaces);
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
hostapd_global_ctrl_iface_deinit(&interfaces);
/* Deinitialize all interfaces */
for (i = 0; i < interfaces.count; i++) {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/hs20/client/oma_dm_client.c b/src/lynq/packages/thirdpart/lynq-wg870/hs20/client/oma_dm_client.c
index bcd68b8..1a72a79 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/hs20/client/oma_dm_client.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/hs20/client/oma_dm_client.c
@@ -1109,12 +1109,6 @@
os_free(locuri);
xml_node_get_text_free(ctx->xml, value);
resp_needed = 1;
-#if 0 /* TODO: MUST support */
- } else if (os_strcasecmp(name, "Delete") == 0) {
-#endif
-#if 0 /* TODO: MUST support */
- } else if (os_strcasecmp(name, "Sequence") == 0) {
-#endif
} else if (os_strcasecmp(name, "Final") == 0) {
final = 1;
break;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/libbcmdhd/driver_cmd_nl80211.c b/src/lynq/packages/thirdpart/lynq-wg870/libbcmdhd/driver_cmd_nl80211.c
index 2a275b9..68ee5b5 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/libbcmdhd/driver_cmd_nl80211.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/libbcmdhd/driver_cmd_nl80211.c
@@ -43,20 +43,9 @@
#include "android_drv.h"
#endif
-#ifdef BCM_GENL
-#include <netlink/genl/genl.h>
-#include <netlink/genl/family.h>
-#include <netlink/genl/ctrl.h>
-#include <linux/rtnetlink.h>
-#endif /* BCM_GENL */
#ifdef ANDROID_P2P
/* If any feature requires enabling of BCM_GENL code, put it here */
-#ifdef BCM_SDO
-#ifndef BCM_GENL
-#define BCM_GENL
-#endif /* BCM_GENL */
-#endif /* BCM_SDO */
#endif /* ANDROID_P2P */
#ifndef IFF_LOWER_UP
@@ -77,14 +66,7 @@
#define WPA_PS_DISABLED 1
#define MAX_WPSP2PIE_CMD_SIZE 1024
-#ifdef BCM_MAP_SDCMDS_2_SDOCMDS
-#define SD_REQ_ASCII_HEADER_LEN 11 //space after P2P_SD_REQ is included
-#define MAC_ADDR_ASCII_LEN 18 //space after Mac address is included
-#endif
-#ifdef BRCM_DRV_ROAM
-#define MAX_NUM_SUITES 10
-#endif /* BRCM_DRV_ROAM */
typedef struct android_wifi_priv_cmd {
char *buf;
@@ -147,74 +129,7 @@
struct i802_bss *bss, int, char *,
size_t len, int vendor_id);
-#if defined(BCM_GENL) && defined(BCM_GENL_UNICAST)
-/* Only required, if you need to support GENL UNICAST*/
-static int wpa_driver_set_supplicant_pid(void *priv);
-#endif /* BCM_GENL && BCM_GENL_UNICAST */
-#ifdef BCM_GENL
-struct family_data {
- const char *group;
- int id;
-};
-
-extern int nl_get_multicast_id(void *priv,
- const char *family, const char *group);
-/* attributes (variables): the index in this enum is used as a reference for the type,
- * userspace application has to indicate the corresponding type
- * the policy is used for security considerations
- */
-enum {
- BCM_EVENT_UNSPEC,
- BCM_EVENT_SVC_FOUND,
- BCM_EVENT_DEV_FOUND,
- BCM_EVENT_DEV_LOST,
- BCM_EVENT_DEV_BT_WIFI_HO_REQ,
- BCM_EVENT_MAX
-};
-
-enum {
- BCM_GENL_ATTR_UNSPEC,
- BCM_GENL_ATTR_STRING,
- BCM_GENL_ATTR_MSG,
- __BCM_GENL_ATTR_MAX,
-};
-
-#define BCM_GENL_ATTR_MAX (__BCM_GENL_ATTR_MAX - 1)
-
-/* commands: enumeration of all commands (functions),
- * used by userspace application to identify command to be ececuted
- */
-enum {
- BCM_GENL_CMD_UNSPEC,
- BCM_GENL_CMD_MSG,
- __BCM_GENL_CMD_MAX,
-};
-#define BCM_GENL_CMD_MAX (__BCM_GENL_CMD_MAX - 1)
-
-typedef struct bcm_event_hdr {
- u16 type;
- u16 len;
-} bcm_hdr_t;
-
-typedef struct bcm_dev_info {
- u16 band;
- u16 freq;
- s16 rssi;
- u16 ie_len;
- u8 bssid[ETH_ALEN];
-} bcm_dev_info_t;
-
-static int wpa_driver_handle_attr_data(struct wpa_driver_nl80211_data *drv,
- char *data, unsigned int len);
-int wpa_driver_register_genl(void *priv);
-int wpa_driver_unregister_genl(void *priv);
-static int family_handler(struct nl_msg *msg, void *arg);
-static int no_seq_check(struct nl_msg *msg, void *arg);
-#define GENLMSG_DATA(glh) ((char *)(NLMSG_DATA(glh) + GENL_HDRLEN))
-#define GENLMSG_PAYLOAD(glh) ((char *)(NLMSG_PAYLOAD(glh, 0) - GENL_HDRLEN))
-#define NLA_DATA(na) (void *) ((char *)(na) + NLA_HDRLEN)
-#endif /* BCM_GENL */
static int drv_errors = 0;
@@ -307,43 +222,6 @@
return ret;
}
-#if defined(BCM_GENL) && defined(BCM_GENL_UNICAST)
-static int wpa_driver_set_supplicant_pid(void *priv)
-{
- struct i802_bss *bss = priv;
- struct wpa_driver_nl80211_data *drv = bss->drv;
- struct wpa_supplicant *wpa_s;
- struct ifreq ifr;
- android_wifi_priv_cmd priv_cmd;
- int ret = 0, i = 0, bp;
- char buf[30];
- int len = 0;
-
- memset(buf, 0, sizeof(buf));
- sprintf(buf, "SUPP_PID %d", getpid());
- len = strlen(buf);
-
- memset(&ifr, 0, sizeof(ifr));
- memset(&priv_cmd, 0, sizeof(priv_cmd));
- os_memcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
-
- priv_cmd.buf = buf;
- priv_cmd.used_len = len;
- priv_cmd.total_len = len;
- ifr.ifr_data = &priv_cmd;
-
- ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
-
- if (ret < 0) {
- wpa_printf(MSG_ERROR, "ioctl[SIOCSIWPRIV] SUPP_PID: %d", ret);
- wpa_driver_send_hang_msg(drv);
- } else {
- drv_errors = 0;
- }
-
- return ret;
-}
-#endif /* BCM_GENL && BCM_GENL_UNICAST */
static int wpa_driver_set_backgroundscan_params(void *priv)
{
struct i802_bss *bss = priv;
@@ -424,173 +302,7 @@
return ret;
}
-#ifdef BRCM_DRV_ROAM
-static int wpa_driver_set_roampref(void *priv)
-{
- struct i802_bss *bss = priv;
- struct wpa_driver_nl80211_data *drv = bss->drv;
- struct wpa_supplicant *wpa_s;
- struct ifreq ifr;
- android_wifi_priv_cmd priv_cmd;
- struct wpa_ssid *ssid;
- int ret = 0;
- char buf[MAX_DRV_CMD_SIZE];
- int num_akm_suites = 0;
- int num_ucipher_suites = 0;
- u32 akm_suites[MAX_NUM_SUITES];
- u32 ucipher_suites[MAX_NUM_SUITES];
- int i, bp = 0;
- if (drv == NULL) {
- wpa_printf(MSG_ERROR, "%s: drv is NULL. Exiting", __func__);
- return -1;
- }
- if (drv->ctx == NULL) {
- wpa_printf(MSG_ERROR, "%s: drv->ctx is NULL. Exiting", __func__);
- return -1;
- }
- wpa_s = (struct wpa_supplicant *)(drv->ctx);
- if (wpa_s->conf == NULL) {
- wpa_printf(MSG_ERROR, "%s: wpa_s->conf is NULL. Exiting", __func__);
- return -1;
- }
- ssid = wpa_s->conf->ssid;
-
- /* If the key_mgmt is set for open network only, then num_akm_suites=0 is passed
- * to the driver which in turn resets the previously configured join preferences.
- * If the key_mgmt is not set in *.conf file, then it gets set to default
- * (WPA_KEY_MGMT_PSK and WPA_KEY_MGMT_IEEE8021X).
- */
-#if defined(CONFIG_IEEE80211R) && defined(BRCM_VE)
- if (ssid->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
- akm_suites[num_akm_suites++] = WLAN_AKM_SUITE_FT_8021X;
- if (ssid->key_mgmt & WPA_KEY_MGMT_FT_PSK)
- akm_suites[num_akm_suites++] = WLAN_AKM_SUITE_FT_PSK;
-#endif /* CONFIG_IEEE80211 && BRCM_VE */
- if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X)
- akm_suites[num_akm_suites++] = WLAN_AKM_SUITE_8021X;
- if (ssid->key_mgmt & WPA_KEY_MGMT_PSK)
- akm_suites[num_akm_suites++] = WLAN_AKM_SUITE_PSK;
-
- /* If the pairwise cipher is not set in *.conf file, then it gets set to
- * default (WPA_CIPHER_CCMP and WPA_CIPHER_TKIP).
- */
- if (ssid->pairwise_cipher & WPA_CIPHER_CCMP)
- ucipher_suites[num_ucipher_suites++] = WLAN_CIPHER_SUITE_CCMP;
- if (ssid->pairwise_cipher & WPA_CIPHER_GCMP)
- ucipher_suites[num_ucipher_suites++] = WLAN_CIPHER_SUITE_GCMP;
- if (ssid->pairwise_cipher & WPA_CIPHER_TKIP)
- ucipher_suites[num_ucipher_suites++] = WLAN_CIPHER_SUITE_TKIP;
- if (ssid->pairwise_cipher & WPA_CIPHER_WEP104)
- ucipher_suites[num_ucipher_suites++] = WLAN_CIPHER_SUITE_WEP104;
- if (ssid->pairwise_cipher & WPA_CIPHER_WEP40)
- ucipher_suites[num_ucipher_suites++] = WLAN_CIPHER_SUITE_WEP40;
-
- if (num_ucipher_suites * num_akm_suites > 16) {
- wpa_printf(MSG_ERROR, "%s: Exceeds max supported wpa configs ", __func__);
- return -1;
- }
-
- os_memset(buf, 0, sizeof(buf));
- bp += os_snprintf(&buf[bp], sizeof(buf), "%s ", "SET_ROAMPREF");
- bp += os_snprintf(&buf[bp], sizeof(buf), "%02x ", num_akm_suites);
- for (i = 0; i < num_akm_suites; i++)
- bp += os_snprintf(&buf[bp], sizeof(buf), "%08x", akm_suites[i]);
-
- bp += os_snprintf(&buf[bp], sizeof(buf), "%02x ", num_ucipher_suites);
- for (i = 0; i < num_ucipher_suites; i++)
- bp += os_snprintf(&buf[bp], sizeof(buf), "%08x", ucipher_suites[i]);
-
- /* Increment the pointer to copy the null character to ioctl buffer */
- bp++;
-
- memset(&ifr, 0, sizeof(ifr));
- memset(&priv_cmd, 0, sizeof(priv_cmd));
- os_memcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
- priv_cmd.buf = buf;
- priv_cmd.used_len = bp;
- priv_cmd.total_len = bp;
- ifr.ifr_data = (char *)&priv_cmd;
-
- ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
- if (ret < 0) {
- wpa_printf(MSG_ERROR, "ioctl[SIOCSIWPRIV] SET_ROAMPREF: %d", ret);
- wpa_driver_send_hang_msg(drv);
- } else {
- drv_errors = 0;
- }
- return ret;
-}
-#endif /* BRCM_DRV_ROAM */
-
-#ifdef BCM_MAP_SDCMDS_2_SDOCMDS
-int wpa_driver_sdo_req(char *buf)
-{
- unsigned char pos[50] = {0};
- char temp[1000] = {0};
- int len = 0;
- if (os_strstr(buf, "upnp")) {
- /* So the request after change in ctrl_iface.c must be in below string format for QR pair
- * P2P_SD_REQ xx:xx:xx:xx:xx:xx upnp 10 urn:schemas-upnp-org:service:ContentDirectory:1
- * And our format to driver should be P2P SD_REQ upnp 0x10urn:schemas-upnporg:service:Con
- * tentDirectory:1
- */
- os_snprintf(temp, sizeof(temp), "%s%s", "upnp 0x10",
- (buf + SD_REQ_ASCII_HEADER_LEN + MAC_ADDR_ASCII_LEN + os_strlen("upnp 10 ")));
- /*"P2P_SD_REQ " is already in buf, so start copy to 11th position*/
- os_snprintf(buf + 11, sizeof(temp), "%s", temp);
- } else if (os_strstr(buf, "bonjour")) {
- /* Code to be added Later*/
- } else {
- /* So the request after change in ctrl_iface.c must be in below ASCII format for QR pair
- * P2P_SD_REQ 00:00:00:00:00:00 320002011075726e3a736368656d61732d75706e702d6f72673a736
- * 572766963653a436f6e74656e744469726563746f72793a31
- * Lets calculate the buf len starting from the actual qr pair, so 29 bytes includes
- * P2P_SD_REQ and len, transactionid and proto */
- len = os_strlen(buf + 29);
- /*length should contains proto and transaction ID*/
- if ((len & 1) || (len < 8))
- return -1;
- len /= 2;
- /* we may get request with or without version so verifying for 4 byte only*/
- if (hexstr2bin(buf + 29, pos, 4) < 0) {
- wpa_printf(MSG_DEBUG, "error in len proto parsing");
- return -1;
- }
- /* pos[3] is Transaction ID */
- wpa_printf(MSG_DEBUG, "len %d proto %d transaction_id %d\n", pos[0], pos[2], pos[3]);
- /* check is required to verify data exists or not */
- if(pos[0] > 3) {
- /* substracting 3 to exclude length and proto, Passing transaction ID and
- * version with request
- */
- len -= 3;
- /* we need to move 39 bytes to get start pointer of data buffer of P2P_SD_REQ
- * we reached upto this pointer after excluding initial 10 bytes which are length,
- * proto and transaction ID
- */
- //transaction_id to be included
- if (hexstr2bin((buf + (SD_REQ_ASCII_HEADER_LEN + MAC_ADDR_ASCII_LEN + 6)), pos, len) < 0) {
- wpa_printf(MSG_DEBUG, "error in string parsing\n");
- return -1;
- }
- wpa_printf(MSG_DEBUG, "pos:%s\n", pos);
- os_snprintf(temp, sizeof(temp), "%s %x %s", "upnp", pos[3], "0x10");
- } else {
- /*upnp*/
- if(pos[2] == 2) {
- wpa_printf(MSG_DEBUG, "upnp\n");
- os_snprintf(temp, sizeof(temp), "%s %x", "upnp", pos[3]);
- }
- }
- /*"P2P_SD_REQ " is already in buf, so start copy to 11th position*/
- os_snprintf(buf + 11, sizeof(temp), "%s", temp);
- wpa_printf(MSG_DEBUG, "Control interface command '%s'", buf);
- }
- return 0;
-}
-
-#endif /* BCM_MAP_SDCMDS_2_SDOCMDS */
static int wpa_get_best_channels(void *drv_ctx, char *buf)
{
@@ -703,22 +415,6 @@
}
return ret;
}
-#ifdef BCM_SDO
- else if (os_strncasecmp(cmd, "P2P_SD_REQ", 10) == 0) {
-#ifdef BCM_MAP_SDCMDS_2_SDOCMDS
- wpa_driver_sdo_req(cmd);
-#endif /* BCM_MAP_SDCMDS_2_SDOCMDS */
- } else if ((os_strncasecmp(cmd, "P2P_SD_FIND", 11) == 0) ||
- (os_strncasecmp(cmd, "P2P_SD_LISTEN", 13) == 0)) {
- u8 channel = 0;
- char tmp[250] = {0};
- channel = wpas_get_listen_channel(drv->ctx);
- os_snprintf(tmp, sizeof(tmp), "%s%s%d", cmd, " chan=", channel);
- os_snprintf(cmd, sizeof(tmp), "%s", tmp);
- wpa_printf(MSG_DEBUG, "cmd:%s\n", cmd);
- wpas_set_probe_resp_ies(drv->ctx);
- }
-#endif /* BCM_SDO */
if (os_strcasecmp(cmd, "BGSCAN-START") == 0) {
ret = wpa_driver_set_backgroundscan_params(priv);
@@ -728,20 +424,7 @@
os_memcpy(buf, "PNOFORCE 1", 11);
} else if (os_strcasecmp(cmd, "BGSCAN-STOP") == 0) {
os_memcpy(buf, "PNOFORCE 0", 11);
-#ifdef BRCM_DRV_ROAM
- } else if (os_strcasecmp(cmd, "SET_ROAMPREF") == 0) {
- ret = wpa_driver_set_roampref(priv);
- return ret;
-#endif /* BRCM_DRV_ROAM */
}
-#if defined(BCM_GENL) && defined(BCM_GENL_UNICAST)
- else if (os_strcasecmp(cmd, "SET_SUPP_ID") == 0) {
- if((ret = wpa_driver_set_supplicant_pid(bss)) < 0) {
- wpa_printf(MSG_ERROR, "libbcmdhd: GENL will not be enabled");
- return ret;
- }
- }
-#endif /* BCM_GENL && BCM_GENL_UNICAST */
else {
os_memcpy(buf, cmd, strlen(cmd) + 1);
}
@@ -764,13 +447,6 @@
if (os_strncasecmp(cmd, "COUNTRY", 7) == 0) {
wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED,
NULL);
-#if !defined(HOSTAPD) && defined(BCM_SDO)
- } else if ((os_strncasecmp(cmd, "P2P_SD_FIND", 11) == 0) ||
- (os_strncasecmp(cmd, "P2P_SD_LISTEN", 13) == 0)) {
- wpas_enable_dd_offload(drv->ctx, 1);
- } else if ((os_strncasecmp(cmd, "P2P_SD_STOP", 11) == 0)){
- wpas_enable_dd_offload(drv->ctx, 0);
-#endif /* !HOSTAPD && BCM_SDO */
} else if (os_strcasecmp(cmd, "GET_BEST_CHANNELS") == 0) {
wpa_get_best_channels(drv->ctx, buf);
} else if (os_strncasecmp(cmd, "SETBAND", 7) == 0) {
@@ -878,14 +554,6 @@
wpa_printf(MSG_INFO, "libbcmdhd: priv_lib_init");
-#ifdef BCM_GENL
- if((ret = wpa_driver_register_genl(global)) < 0) {
- /* GENL init failed. Driver probably doesn't have the GENL support
- * But don't fail the supplicant/hostapd initialization.
- */
- wpa_printf(MSG_ERROR, "libbcmdhd: GENL will not be enabled");
- }
-#endif /* BCM_GENL */
return 0;
}
@@ -894,478 +562,6 @@
{
wpa_printf(MSG_INFO, "libbcmdhd: priv_lib_deinit");
-#ifdef BCM_GENL
- wpa_driver_unregister_genl(global);
-#endif /* BCM_GENL */
return 0;
}
-
-#ifdef BCM_GENL /* GENERIC NETLINK RECEIVE PATH */
-static int no_seq_check(struct nl_msg *msg, void *arg)
-{
- return NL_OK;
-}
-
-static void wpa_driver_recv_genl(int sock, void *eloop_ctx, void *handle)
-{
- struct nl80211_global *global = eloop_ctx;
-
- wpa_printf(MSG_ERROR, "BCM-GENL event available");
-
- if(global->event_sock)
- nl_recvmsgs(global->event_sock, nl_socket_get_cb(global->event_sock));
- else
- wpa_printf(MSG_ERROR, "BCM-GENL event on wrong driver interface");
-}
-
-static int wpa_driver_handle_svc_found(struct wpa_driver_nl80211_data *drv, char *data, u32 len)
-{
- u16 frag_no = 0;
- u16 more_frag = 0;
- sdo_hdr_t *hdr;
- char *proto = NULL;
- char *data_ptr = data + sizeof(sdo_hdr_t);
- u8 first_frag = 0;
- sd_tlv_t *tlv_hdr;
- u8 *tlv_end = NULL;
- union wpa_event_data event;
- s32 tot_len = len - sizeof(sdo_hdr_t);
- int tlv_num = 0;
-
- if (!data || tot_len <= 0) {
- wpa_printf(MSG_ERROR, "BCM-GENL [SERVICE-FOUND] Invalid length");
- return -1;
- }
-
- tot_len = len - sizeof(sdo_hdr_t);
- memset(&event, 0, sizeof(union wpa_event_data));
- hdr = (sdo_hdr_t *)data;
- tlv_hdr = (sd_tlv_t *) (data + sizeof(sdo_hdr_t));
-
- if (!hdr || !tlv_hdr) {
- wpa_printf(MSG_ERROR, "BCM-GENL [SERVICE-FOUND] Invalid header");
- return -1;
- }
-#if BCM_SDIO
- event.p2p_sd_resp.sa = hdr->addr;
- event.p2p_sd_resp.update_indic = hdr->update_ind;
- event.p2p_sd_resp.tlvs = (const u8 *)tlv_hdr;
-#ifdef BCM_MAP_SDCMDS_2_SDOCMDS
- /* Response should contains 5 bytes and we need not to handle the case of NULL
- * response so check if lenth is 5
- */
- if (tot_len != 5) {
- /*We are adding two in tlv_hdr to add transaction id and proto*/
- wpa_printf(MSG_DEBUG, "hdr->update_ind = %d tlv_num = %d", hdr->update_ind, tlv_num);
- event.p2p_sd_resp.tlvs_len = tlv_hdr->length + 2;
- }
-#else
- /* This is temperory code for Testing purpose. Will be removed. */
- tlv_end = (u8 *)tlv_hdr + tot_len;
- while (((u8 *)tlv_hdr < tlv_end) && (tlv_num++ < hdr->count)) {
- wpa_printf(MSG_DEBUG, "BCM-GENL [SERVICE-FOUND] "MACSTR" tlv:%d %s",
- MAC2STR(hdr->addr), tlv_num, tlv_hdr->data);
- if (tlv_hdr->protocol == SVC_RPOTYPE_UPNP) {
- /* Upnp version is in binary format */
- u16 version = tlv_hdr->data[0];
- wpa_msg(drv->ctx, MSG_INFO, P2P_EVENT_SERV_DISC_RESP MACSTR" %u 0x%x%s",
- MAC2STR(hdr->addr), hdr->freq, version,(char *)(tlv_hdr->data + 1));
- } else {
- wpa_msg(drv->ctx, MSG_INFO, P2P_EVENT_SERV_DISC_RESP MACSTR" %u %s",
- MAC2STR(hdr->addr), hdr->freq, (char *)tlv_hdr->data);
- }
- tlv_hdr = (sd_tlv_t *)(tlv_hdr->data + tlv_hdr->length);
- }
-#endif /* BCM_MAP_SDCMDS_2_SDOCMDS */
- wpa_supplicant_event(drv->ctx, EVENT_P2P_SD_RESPONSE, &event);
-#endif /* BCM_SDO */
-
- return 0;
-}
-
-static int wpa_driver_handle_attr_data(struct wpa_driver_nl80211_data *drv,
- char *data, unsigned int len)
-{
- bcm_hdr_t *hdr;
- u8 *addr = NULL;
-
- if(len <= sizeof(bcm_hdr_t))
- return -EINVAL;
-
-
- hdr = (bcm_hdr_t *)data;
-
- wpa_printf(MSG_DEBUG, "BCM-GENL event_type:%x event_len: %x", hdr->type, hdr->len);
-
- wpa_hexdump(MSG_DEBUG, "Event_data dump:", (const u8 *)data, len);
-
- switch (hdr->type) {
-#ifndef HOSTAPD
-#ifdef BCM_SDO
- case BCM_EVENT_SVC_FOUND:
- {
- wpa_printf(MSG_DEBUG, "BCM-GENL [SERVICE-FOUND]");
- if (wpa_driver_handle_svc_found(drv,
- ((char *)data + sizeof(bcm_hdr_t)), hdr->len) < 0)
- return -1;
- break;
- }
- case BCM_EVENT_DEV_FOUND:
- {
- struct wpa_scan_results scan_res;
- struct wpa_scan_res *bss;
- u16 tot_len = 0;
- u8 *ptr = NULL;
- bcm_dev_info_t *info = (bcm_dev_info_t *)((u8 *)data +
- sizeof(bcm_hdr_t));
-
- wpa_printf(MSG_DEBUG, "BCM-GENL [DEV-FOUND] band:%x Freq %d"
- " rssi:%d ie_len:%x Mac:"MACSTR"\n",
- info->band, info->freq, info->rssi,
- info->ie_len, MAC2STR(info->bssid));
-
- if (info->ie_len > 2000) {
- wpa_printf(MSG_ERROR, "Invalid IE_LEN");
- return -EINVAL;
- }
-
- tot_len = sizeof(struct wpa_scan_res) + info->ie_len;
- ptr = malloc(tot_len);
- if(!ptr) {
- wpa_printf(MSG_ERROR, "Malloc failed");
- return -ENOMEM;
- }
- memset(ptr, 0, tot_len);
-
- bss = (struct wpa_scan_res *)ptr;
- memcpy(bss->bssid, info->bssid, ETH_ALEN);
- bss->freq = info->freq;
- bss->level = info->rssi;
- bss->ie_len = info->ie_len;
-
- /* Copy the IE's immeditately after the wpas_scan_res memory */
- memcpy(ptr+sizeof(struct wpa_scan_res),
- data+sizeof(bcm_hdr_t)+sizeof(bcm_dev_info_t),
- info->ie_len);
-
- scan_res.res = &bss;
- scan_res.num = 1;
-
- wpas_p2p_scan_res_handler(drv->ctx, &scan_res);
-
- if(ptr)
- free(ptr);
- break;
- }
-
- case BCM_EVENT_DEV_LOST:
- {
- if(hdr->len != 6) {
- wpa_printf(MSG_ERROR, "DEV_LOST: invalid data"
- " (hdr_len != ETH_ALEN)");
- return -EINVAL;
-
- }
-
- wpa_printf(MSG_DEBUG, "BCM-GENL [DEV-LOST] "MACSTR,
- MAC2STR((u8 *)data + sizeof(bcm_hdr_t)));
- wpas_expire_p2p_peer(drv->ctx, ((u8 *)data + sizeof(bcm_hdr_t)));
- break;
- }
-#endif /* BCM_SDO */
-#endif /* HOSTAPD */
-
-#ifdef CONFIG_BRCM_BT_WIFI_HO
- case BCM_EVENT_DEV_BT_WIFI_HO_REQ:
- {
- union wpa_event_data event;
- setup_netinfo_t *ho_cmd = (setup_netinfo_t *)((u8 *)data +
- sizeof(bcm_hdr_t));
- wpa_printf(MSG_DEBUG, "BT WIFI HANDOVER REQ RECEIVED FROM WPA_SUP: %d\n", ho_cmd->opmode);
- if (ho_cmd->opmode == HO_MODE_GO) {
- wpa_printf(MSG_DEBUG, "Start GO SSID length is %d"
- "and passphrs len is %d",
- ho_cmd->ssid_len, ho_cmd->passphrase_len);
- wpas_p2p_group_add_ho(drv->ctx, ho_cmd->channel, ho_cmd->ssid_len,
- (char *)ho_cmd->ssid, ho_cmd->passphrase_len,
- (char *)ho_cmd->passphrase, (char *)ho_cmd->macaddr);
- } else if (ho_cmd->opmode == HO_MODE_STA) {
- wpa_printf(MSG_DEBUG, "Start STA to connect to GO");
- wpa_supplicant_ho_connect(drv->ctx, ho_cmd->channel,
- ho_cmd->ssid_len, (char *)ho_cmd->ssid,
- ho_cmd->passphrase_len, (char *)ho_cmd->passphrase);
- } else if (ho_cmd->opmode == HO_MODE_GC) {
- wpa_printf(MSG_DEBUG, "Start GC to connect to GO");
- p2p_gc_connect(drv->ctx, ho_cmd->channel,
- ho_cmd->ssid_len, (char *)ho_cmd->ssid,
- ho_cmd->passphrase_len, (char *)ho_cmd->passphrase,
- ho_cmd->macaddr);
- } else if (ho_cmd->opmode == HO_MODE_STOP_GO) {
- wpa_printf(MSG_DEBUG, "STOP GO");
- wpas_p2p_group_remove_ho(drv->ctx);
- } else {
- wpa_printf(MSG_DEBUG, "Unknown Handover Msg: %d\n", ho_cmd->opmode);
- }
- break;
- }
-#endif /* CONFIG_BRCM_BT_WIFI_HO */
-
- default:
- wpa_printf(MSG_ERROR, "UNKNOWN Event Msg Type:%d len:%d", hdr->type, hdr->len);
- break;
- }
-
- return 0;
-}
-
-#ifdef CONFIG_BRCM_NAN
-
-void add_nan_p2p_device(char *p2p_ie_data, int len, void *ctx)
-{
- unsigned char macadrr[ETH_ALEN];
- unsigned char p2p_data_hex[P2P_IE_LEN_MAX];
- struct wpa_supplicant *wpa_s = ctx;
- hwaddr_aton(p2p_ie_data,(u8* )macadrr);
- p2p_ie_data += 17+8; /* MAc address +p2p_ie= */
- len = len - (17+8);
- if (hexstr2bin(p2p_ie_data, p2p_data_hex, len/2) != 0)
- return;
- len = strlen(p2p_ie_data)/2;
- p2p_add_device(wpa_s->global->p2p, macadrr, 0, 0, 0, (const u8 *)p2p_data_hex, len, 0);
-}
-
-#endif /* CONFIG_BRCM_NAN */
-
-static int wpa_driver_handle_genl_event(struct nl_msg *msg, void *arg)
-{
- struct nlmsghdr *nlh = nlmsg_hdr(msg);
- struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
- struct nlattr *attrs[BCM_GENL_ATTR_MAX + 1];
- struct wpa_driver_nl80211_data *drv = NULL;
- struct nl80211_global *global = (struct nl80211_global *)arg;
-#ifdef CONFIG_BRCM_NAN
- char p2p_ie_data[2000];
- int len = 0;
-#endif /* CONFIG_BRCM_NAN */
- wpa_printf(MSG_DEBUG, "%s: Enter", __func__);
-
- if (nla_parse(attrs, BCM_GENL_ATTR_MAX,
- genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL) < 0) {
- wpa_printf(MSG_ERROR, "GENL msg parse failed");
- return -1;
- }
-
- drv = dl_list_last(&global->interfaces, struct wpa_driver_nl80211_data, list);
- if (drv == NULL)
- return -1;
-
- if(attrs[BCM_GENL_ATTR_STRING]) {
- wpa_printf(MSG_ERROR, "BCM-GENL ATTR_STRING FOUND. Dumping the string");
-#ifdef CONFIG_BRCM_NAN
- if (strncmp((char *)nla_data(attrs[BCM_GENL_ATTR_STRING]),
- "CTRL-EVENT-NAN-P2P-RX", 21) == 0) {
- len = nla_len(attrs[BCM_GENL_ATTR_STRING]);
- memcpy(p2p_ie_data, (char *)nla_data(attrs[BCM_GENL_ATTR_STRING]), len);
- add_nan_p2p_device(p2p_ie_data+31, len - 31, drv->ctx);
- /* 31 = CTRL-EVENT-NAN-P2P-RX MAC_ADDR= */
- }
- wpa_msg(drv->ctx, MSG_INFO, "%s", (char *)nla_data(attrs[BCM_GENL_ATTR_STRING]));
-#endif /* CONFIG_BRCM_NAN */
- } else if(attrs[BCM_GENL_ATTR_MSG]) {
- wpa_printf(MSG_ERROR, "BCM-GENL ATTR_MSG FOUND. Calling the handler");
- wpa_driver_handle_attr_data(drv, (char *)nla_data(attrs[BCM_GENL_ATTR_MSG]),
- nla_len(attrs[BCM_GENL_ATTR_MSG]));
- } else
- wpa_printf(MSG_ERROR, "BCM-GENL NOT Present");
-
- return NL_SKIP;
-
-}
-
-static int driver_genl_ctrl_resolve(struct nl_sock *handle,
- const char *name)
-{
- /*
- * Android ICS has very minimal genl_ctrl_resolve() implementation, so
- * need to work around that.
- */
- struct nl_cache *cache = NULL;
- struct genl_family *nl80211 = NULL;
- int id = -1;
-
- if (genl_ctrl_alloc_cache(handle, &cache) < 0) {
- wpa_printf(MSG_ERROR, "nl80211: Failed to allocate generic "
- "netlink cache");
- goto fail;
- }
-
- nl80211 = genl_ctrl_search_by_name(cache, name);
- if (nl80211 == NULL)
- goto fail;
-
- id = genl_family_get_id(nl80211);
-
- wpa_printf(MSG_ERROR, "Family id:%d", id);
-
-fail:
- if (nl80211)
- genl_family_put(nl80211);
- if (cache)
- nl_cache_free(cache);
-
- return id;
-}
-
-/* XXX Not yet tested */
-int driver_send_msg(void *priv, int len, const void *data)
-{
- struct i802_bss *bss = priv;
- struct wpa_driver_nl80211_data *drv = bss->drv;
- struct nl_msg *msg;
-
- msg = nlmsg_alloc();
- genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, drv->event_family, 0, NLM_F_REQUEST,
- BCM_GENL_CMD_MSG, 1);
-
- nla_put(msg, BCM_GENL_ATTR_MSG, (size_t)len, data);
-
- // Send message over netlink socket
- nl_send_auto_complete(drv->event_sock, msg);
-
- nlmsg_free(msg);
-
- return 0;
-}
-static int wpa_driver_register_genl_multicast(void *priv)
-{
- struct nl80211_global *global = priv;
- int mcast_id = 0;
-
- mcast_id = nl_get_multicast_id(priv,
- "bcm-genl", "bcm-genl-mcast");
-
- if (mcast_id >= 0) {
- if(nl_socket_add_membership(global->event_sock, mcast_id) < 0) {
- wpa_printf(MSG_ERROR, "%s: MULTICAST ID"
- " add membership failed\n", __func__);
- return -1;
- }
-
- }
-
- return mcast_id;
-
-}
-
-int wpa_driver_register_genl(void *priv)
-{
- struct nl80211_global *global = priv;
- int ret = 0;
- static int family;
- struct sockaddr_nl src_addr;
-
- wpa_printf(MSG_DEBUG, "%s: Enter (PID: %d)", __func__, getpid());
-
- if(global->event_sock && global->event_family) {
- wpa_printf(MSG_ERROR, "GENL Already registered/Initialized");
- return 0;
- }
-
- global->event_sock = nl_socket_alloc();
- if(!global->event_sock) {
- wpa_printf(MSG_ERROR, "nl_socket_alloc failed");
- return -1;
- }
-
- if(genl_connect(global->event_sock) < 0) {
- wpa_printf(MSG_ERROR, "genl_connect failed");
- ret = -1;
- goto fail;
- }
-
- global->event_family = genl_ctrl_resolve(global->event_sock, "bcm-genl");
- if(global->event_family < 0) {
- wpa_printf(MSG_ERROR, "genl_ctrl_resolve failed ret:%d", global->event_family);
- ret = -1;
- goto fail;
- }
-
- nl_cb_set(nl_socket_get_cb(global->event_sock),
- NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, global);
- nl_cb_set(nl_socket_get_cb(global->event_sock),
- NL_CB_VALID, NL_CB_CUSTOM, wpa_driver_handle_genl_event, global);
-
- if (wpa_driver_register_genl_multicast(global) < 0) {
- wpa_printf(MSG_ERROR, "genl_multicast register failed");
- ret = -1;
- goto fail;
- }
-
- eloop_register_read_sock(nl_socket_get_fd(global->event_sock),
- wpa_driver_recv_genl, global, NULL);
-
- wpa_printf(MSG_INFO, "libbcmdhd: GENL Interface enabled");
-
- return 0;
-
-fail:
- wpa_printf(MSG_ERROR, "%s: Failed. GENL register failed", __func__);
-
- if(global->event_sock)
- nl_socket_free(global->event_sock);
- global->event_sock = 0;
- global->event_family = 0;
- return ret;
-
-}
-
-int wpa_driver_unregister_genl(void *priv)
-{
- struct nl80211_global *global = priv;
-
- if(!global || !global->event_sock || !global->event_family) {
- wpa_printf(MSG_ERROR, " No socket initialized on this interface");
- return -1;
- }
-
- eloop_unregister_read_sock(nl_socket_get_fd(global->event_sock));
-
- nl_socket_free(global->event_sock);
- global->event_sock = NULL;
-
- wpa_printf(MSG_INFO, "libbcmdhd: GENL Interface disabled");
-
- return 0;
-}
-
-static int family_handler(struct nl_msg *msg, void *arg)
-{
- struct family_data *res = arg;
- struct nlattr *tb[CTRL_ATTR_MAX + 1];
- struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
- struct nlattr *mcgrp;
- int i;
-
- nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
- genlmsg_attrlen(gnlh, 0), NULL);
- if (!tb[CTRL_ATTR_MCAST_GROUPS])
- return NL_SKIP;
-
- nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {
- struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];
- nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, nla_data(mcgrp),
- nla_len(mcgrp), NULL);
- if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] ||
- !tb2[CTRL_ATTR_MCAST_GRP_ID] ||
- os_strncmp(nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]),
- res->group,
- nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME])) != 0)
- continue;
- res->id = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]);
- break;
- };
-
- return NL_SKIP;
-}
-#endif /* BCM_GENL */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.c
index 0d52a0d..04535a1 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.c
@@ -1494,13 +1494,7 @@
bss->wpa_group = WPA_CIPHER_NONE;
bss->wpa_pairwise = WPA_CIPHER_NONE;
bss->rsn_pairwise = WPA_CIPHER_NONE;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifndef WAPI_AP
bss->wpa_key_mgmt = WPA_KEY_MGMT_NONE;
-#endif
-#else /* CONFIG_DRIVER_NL80211_IFX */
- bss->wpa_key_mgmt = WPA_KEY_MGMT_NONE;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
}
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.h b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.h
index 4d68c52..52c70a1 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_config.h
@@ -719,11 +719,9 @@
int ftm_responder;
int ftm_initiator;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
u8 replay_cntrs;
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_FILS
u8 fils_cache_id[FILS_CACHE_ID_LEN];
int fils_cache_id_set;
@@ -943,15 +941,7 @@
unsigned int track_sta_max_num;
unsigned int track_sta_max_age;
- char country[3]; /* first two octets: country code as described in
- * ISO/IEC 3166-1. Third octet:
- * ' ' (ascii 32): all environments
- * 'O': Outdoor environemnt only
- * 'I': Indoor environment only
- * 'X': Used with noncountry entity ("XXX")
- * 0x00..0x31: identifying IEEE 802.11 standard
- * Annex E table (0x04 = global table)
- */
+ char country[3];
int ieee80211d;
@@ -1056,11 +1046,9 @@
unsigned int airtime_update_interval;
#define AIRTIME_MODE_MAX (__AIRTIME_MODE_MAX - 1)
#endif /* CONFIG_AIRTIME_POLICY */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_SUPP_ACS
u8 autochannel_enabled;
#endif /* BRCM_SUPP_ACS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_drv_ops.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_drv_ops.c
index cd36833..a1bf445 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_drv_ops.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ap_drv_ops.c
@@ -202,7 +202,6 @@
add_buf(&proberesp, hapd->conf->vendor_elements);
add_buf(&assocresp, hapd->conf->assocresp_elements);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VENDOR_IE
if(hapd->vendor_ies) {
size_t add = wpabuf_len(hapd->vendor_ies);
@@ -214,7 +213,6 @@
wpabuf_put_buf(assocresp, hapd->vendor_ies);
}
#endif /* CONFIG_BRCM_VENDOR_IE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
*beacon_ret = beacon;
*proberesp_ret = proberesp;
*assocresp_ret = assocresp;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/beacon.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/beacon.c
index 53d66f0..e773615 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/beacon.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/beacon.c
@@ -1359,7 +1359,6 @@
#endif /* NEED_AP_MLME */
os_memset(params, 0, sizeof(*params));
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
if (hapd->conf->ssid.wpa_passphrase) {
params->sae_passphrase_len = os_strlen(hapd->conf->ssid.wpa_passphrase);
@@ -1369,7 +1368,6 @@
}
}
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
params->head = (u8 *) head;
params->head_len = head_len;
params->tail = tail;
@@ -1430,7 +1428,6 @@
else
params->ht_opmode = hapd->iface->ht_op_mode;
#endif /* NEED_AP_MLME */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef CONFIG_BRCM_AUTOMOTIVE
params->interworking = hapd->conf->interworking;
if (hapd->conf->interworking &&
@@ -1438,13 +1435,6 @@
params->hessid = hapd->conf->hessid;
params->access_network_type = hapd->conf->access_network_type;
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- params->interworking = hapd->conf->interworking;
- if (hapd->conf->interworking &&
- !is_zero_ether_addr(hapd->conf->hessid))
- params->hessid = hapd->conf->hessid;
- params->access_network_type = hapd->conf->access_network_type;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
params->ap_max_inactivity = hapd->conf->ap_max_inactivity;
#ifdef CONFIG_P2P
params->p2p_go_ctwindow = hapd->iconf->p2p_go_ctwindow;
@@ -1470,14 +1460,16 @@
}
}
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
if ((hapd->iface->drv_flags2 &
WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK) &&
(params->key_mgmt_suites &
(WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_PSK_SHA256))) {
if (hapd->conf->ssid.wpa_passphrase)
params->passphrase = hapd->conf->ssid.wpa_passphrase;
- if (hapd->conf->ssid.wpa_psk->psk)
+ if (hapd->conf->ssid.wpa_psk->psk[0] != '\0')
params->psk = hapd->conf->ssid.wpa_psk->psk;
}
@@ -1491,7 +1483,6 @@
params->passphrase = hapd->conf->ssid.wpa_passphrase;
}
#endif /* CONFIG_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return 0;
}
@@ -1507,6 +1498,39 @@
params->proberesp = NULL;
}
+#if defined(CONFIG_SAE)
+#define SAE_PWE_CMD_SIZE 32
+void ifx_private_set_sae_pwe(struct hostapd_data *hapd, int sae_pwe)
+{
+ int res;
+
+ char cmd[SAE_PWE_CMD_SIZE];
+ char reply[SAE_PWE_CMD_SIZE];
+ char *p = cmd;
+
+ if (hapd == NULL) {
+ wpa_printf(MSG_ERROR, "Failed to set SAE PWE hapd is null");
+ return;
+ }
+
+ if ((sae_pwe < 0) || (sae_pwe > 2)) {
+ wpa_printf(MSG_ERROR, "Failed to set SAE PWE, unexpected sae pwe %d", sae_pwe);
+ return;
+ }
+
+ memset(cmd, 0, sizeof(cmd));
+ memset(reply, 0, sizeof(reply));
+
+ res = os_snprintf(p, SAE_PWE_CMD_SIZE, "SAE_PWE %d", sae_pwe);
+ p += res;
+ *p = '\0';
+
+ if (!hapd->driver->driver_cmd ||
+ hapd->driver->driver_cmd(hapd->drv_priv, cmd, reply, sizeof(reply))) {
+ wpa_printf(MSG_ERROR, "Failed to set SAE PWE");
+ }
+}
+#endif /* CONFIG_SAE && CONFIG_DRIVER_NL80211_IFX */
int ieee802_11_set_beacon(struct hostapd_data *hapd)
{
@@ -1553,6 +1577,8 @@
hapd->reenable_beacon = 0;
#ifdef CONFIG_SAE
params.sae_pwe = hapd->conf->sae_pwe;
+ if (params.key_mgmt_suites & WPA_KEY_MGMT_SAE)
+ ifx_private_set_sae_pwe(hapd, params.sae_pwe);
#endif /* CONFIG_SAE */
if (cmode &&
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/drv_callbacks.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/drv_callbacks.c
index 3cbe072..5ead4e4 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/drv_callbacks.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/drv_callbacks.c
@@ -42,11 +42,6 @@
#include "dpp_hostapd.h"
#include "fils_hlp.h"
#include "neighbor_db.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
-#include "ap/hostapd.h"
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_FILS
@@ -200,31 +195,6 @@
ielen = elems.osen_len + 2;
wpa_printf(MSG_DEBUG, "STA included OSEN IE in (Re)AssocReq");
#endif /* CONFIG_HS20 */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- } else if (elems.wapiap_ie) {
- ie = elems.wapiap_ie - 2;
- ielen = elems.wapiap_ie_len + 2;
- wpa_printf(MSG_INFO, "%s : STA included WAPI IE in (Re)AssocReq"
- "calling funciton in HAL wapiie len is %zu\n", __FUNCTION__, ielen);
- sta = ap_get_sta(hapd, addr);
- if (!sta) {
- wpa_printf(MSG_ERROR, "hostapd_notif_assoc: No sta info\n");
- sta = ap_sta_add(hapd, addr);
- if (!sta) {
- wpa_printf(MSG_ERROR, "hostapd_notif_assoc: Failed to add sta info for addr " MACSTR"\n", MAC2STR(addr));
- return -1;
- }
- else
- wpa_printf(MSG_INFO, "hostapd_notif_assoc: Added sta info for addr " MACSTR"\n", MAC2STR(addr));
- }
- res = brcm_wapiap_startassoc(ie, ielen, addr, hapd->ifname);
- if (res != 0) {
- wpa_printf(MSG_ERROR, "%s:brcm_wapiap_startassoc failed with error %d\n", __FUNCTION__, res);
- return res;
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
} else {
ie = NULL;
ielen = 0;
@@ -916,7 +886,7 @@
channel = hostapd_hw_get_channel(hapd, freq);
if (!channel) {
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_SUPP)
+#if defined(BRCM_SUPP)
if (hapd->iface->conf->hw_mode == HOSTAPD_MODE_IEEE80211ANY) {
struct hostapd_hw_modes *newmode = NULL;
@@ -1039,15 +1009,6 @@
hostapd_enable_iface(hapd->iface);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
- else {
- /* Inform CSA event even if it is not triggered from the host */
- wpa_msg(hapd->msg_ctx, MSG_INFO, AP_CSA_FINISHED "freq=%d",
- freq);
- }
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
for (i = 0; i < hapd->iface->num_bss; i++)
hostapd_neighbor_set_own_report(hapd->iface->bss[i]);
@@ -1066,12 +1027,8 @@
if (check_sa_query) {
wpa_printf(MSG_DEBUG,
-#ifdef CONFIG_DRIVER_NL80211_IFX
"OCV: Check post-CSA SA Query initiation in"
" 15 seconds");
-#else
- "OCV: Check post-CSA SA Query initiation in 15 seconds");
-#endif /* CONFIG_DRIVER_NL80211_IFX */
eloop_register_timeout(15, 0,
hostapd_ocv_check_csa_sa_query,
hapd, NULL);
@@ -1915,14 +1872,12 @@
#endif /* CONFIG_NO_STDOUT_DEBUG */
switch (event) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
case EVENT_SAE_KEY:
wpa_auth_pmksa_add_sae(hapd->wpa_auth, data->sae_key_info.peer_mac,
data->sae_key_info.psk, data->sae_key_info.pmkid);
break;
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case EVENT_MICHAEL_MIC_FAILURE:
michael_mic_failure(hapd, data->michael_mic_failure.src, 1);
break;
@@ -1996,11 +1951,6 @@
case EVENT_ASSOC:
if (!data)
return;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- os_memcpy(hapd->ifname, hapd->conf->iface, os_strlen(hapd->conf->iface));
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
hostapd_notif_assoc(hapd, data->assoc_info.addr,
data->assoc_info.req_ies,
data->assoc_info.req_ies_len,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.c
index 96c2001..5eed686 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.c
@@ -67,11 +67,6 @@
static void hostapd_interface_setup_failure_handler(void *eloop_ctx,
void *timeout_ctx);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
-void brcm_wapiap_inithostapd(struct hostapd_data *hapd, char *ifname);
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int hostapd_for_each_interface(struct hapd_interfaces *interfaces,
int (*cb)(struct hostapd_iface *iface,
@@ -436,7 +431,6 @@
hapd->tmp_eap_user.password_len);
#endif /* CONFIG_SQLITE */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VENDOR_IE
for (i = 0; i < MAX_VENDOR_IES; i++ ) {
wpabuf_free(hapd->vendor_ie[i]);
@@ -445,7 +439,6 @@
wpabuf_free(hapd->vendor_ies);
hapd->vendor_ies = NULL;
#endif /* CONFIG_BRCM_VENDOR_IE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_MESH
wpabuf_free(hapd->mesh_pending_auth);
hapd->mesh_pending_auth = NULL;
@@ -1128,15 +1121,6 @@
wpa_printf(MSG_DEBUG, "%s(hapd=%p (%s), first=%d)",
__func__, hapd, conf->iface, first);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (conf->wpa_key_mgmt == WPA_KEY_MGMT_WAPI_PSK) {
- /* initialize the hostapd structure for wapilib_softap for setting ucast/mcastkey*/
- wpa_printf(MSG_INFO, "%s: calling brcm_wapiap_inithostapd\n", __FUNCTION__);
- brcm_wapiap_inithostapd(hapd, conf->iface);
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef EAP_SERVER_TNC
if (conf->tnc && tncs_global_init() < 0) {
wpa_printf(MSG_ERROR, "Failed to initialize TNCS");
@@ -1691,7 +1675,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef CONFIG_ACS
#ifdef CONFIG_BRCM_AUTOMOTIVE
void bcm_private_acs(struct hostapd_iface *iface)
@@ -1737,7 +1720,6 @@
}
#endif
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int setup_interface2(struct hostapd_iface *iface)
{
iface->wait_channel_update = 0;
@@ -1746,14 +1728,12 @@
/* Not all drivers support this yet, so continue without hw
* feature data. */
} else {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef CONFIG_ACS
#ifdef CONFIG_BRCM_AUTOMOTIVE
if(!iface->conf->channel)
bcm_private_acs(iface);
#endif
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int ret;
ret = configured_fixed_chan_to_freq(iface);
@@ -3233,9 +3213,10 @@
void hostapd_new_assoc_sta(struct hostapd_data *hapd, struct sta_info *sta,
int reassoc)
{
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
int key_mgmt = wpa_auth_sta_key_mgmt(sta->wpa_sm);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (hapd->tkip_countermeasures) {
hostapd_drv_sta_deauth(hapd, sta->addr,
@@ -3270,15 +3251,14 @@
/* Start IEEE 802.1X authentication process for new stations */
ieee802_1x_new_station(hapd, sta);
if (reassoc) {
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
if ((hapd->iface->drv_flags2 &
WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK) &&
wpa_key_mgmt_wpa_psk(key_mgmt))
wpa_auth_sta_associated(hapd->wpa_auth, sta->wpa_sm);
else if (sta->auth_alg != WLAN_AUTH_FT &&
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (sta->auth_alg != WLAN_AUTH_FT &&
-#endif /* CONFIG_DRIVER_NL80211_IFX */
sta->auth_alg != WLAN_AUTH_FILS_SK &&
sta->auth_alg != WLAN_AUTH_FILS_SK_PFS &&
sta->auth_alg != WLAN_AUTH_FILS_PK &&
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.h b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.h
index 20fb3bd..109b9af 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hostapd.h
@@ -161,11 +161,6 @@
u8 own_addr[ETH_ALEN];
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- char ifname[100];
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int num_sta; /* number of entries in sta_list */
struct sta_info *sta_list; /* STA info list head */
#define STA_HASH_SIZE 256
@@ -430,13 +425,11 @@
#endif /* CONFIG_CTRL_IFACE_UDP */
};
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VENDOR_IE
#define MAX_VENDOR_IES 4
struct wpabuf *vendor_ie[MAX_VENDOR_IES];
struct wpabuf *vendor_ies;
#endif /* CONFIG_BRCM_VENDOR_IE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct hostapd_sta_info {
struct dl_list list;
@@ -448,7 +441,6 @@
#endif /* CONFIG_TAXONOMY */
};
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
enum hostapd_iface_state {
HAPD_IFACE_UNINITIALIZED,
@@ -460,7 +452,6 @@
HAPD_IFACE_ENABLED
};
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* struct hostapd_iface - hostapd per-interface data structure
*/
@@ -471,21 +462,9 @@
struct hostapd_config *conf;
char phy[16]; /* Name of the PHY (radio) */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
enum hostapd_iface_state state;
#endif /* CONFIG_BRCM_MERGES */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- enum hostapd_iface_state {
- HAPD_IFACE_UNINITIALIZED,
- HAPD_IFACE_DISABLED,
- HAPD_IFACE_COUNTRY_UPDATE,
- HAPD_IFACE_ACS,
- HAPD_IFACE_HT_SCAN,
- HAPD_IFACE_DFS,
- HAPD_IFACE_ENABLED
- } state;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_MESH
struct mesh_conf *mconf;
@@ -699,13 +678,6 @@
hostapd_get_eap_user(struct hostapd_data *hapd, const u8 *identity,
size_t identity_len, int phase2);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
-void brcm_wapiap_handshakepkt_from_sta(u8 *sta_mac, void *buf, int len, char *ifname);
-int brcm_wapiap_startassoc(const u8 *ie, int ielen, const u8 *sta_mac, char *ifname);
-void handle_wapi(int sock, void *eloop_ctx, void *sock_ctx);
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct hostapd_data * hostapd_get_iface(struct hapd_interfaces *interfaces,
const char *ifname);
void hostapd_event_sta_opmode_changed(struct hostapd_data *hapd, const u8 *addr,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.c
index 9e05ba4..bfaded2 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.c
@@ -1038,7 +1038,6 @@
iface->current_mode = mode;
break;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_SUPP
if (iface->conf->hw_mode == HOSTAPD_MODE_IEEE80211ANY) {
if (((iface->conf->channel > 14) && (mode->mode == HOSTAPD_MODE_IEEE80211A)) ||
@@ -1048,7 +1047,6 @@
}
}
#endif /* BRCM_SUPP */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
if (iface->current_mode == NULL) {
@@ -1154,7 +1152,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_SUPP
int hostapd_hw_get_channel_by_hw_features(struct hostapd_data *hapd, int freq,
struct hostapd_hw_modes **newmode)
@@ -1179,4 +1176,3 @@
return channel;
}
#endif /* BRCM_SUPP */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.h b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.h
index ecc246e..a250875 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/hw_features.h
@@ -20,12 +20,10 @@
const char * hostapd_hw_mode_txt(int mode);
int hostapd_hw_get_freq(struct hostapd_data *hapd, int chan);
int hostapd_hw_get_channel(struct hostapd_data *hapd, int freq);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_SUPP
int hostapd_hw_get_channel_by_hw_features(struct hostapd_data *hapd, int freq,
struct hostapd_hw_modes **newmode);
#endif /* #ifdef BRCM_SUPP */
-#endif /* CONFIG_DRIVER_NL80211_IFX && BRCM_SUPP */
int hostapd_check_ht_capab(struct hostapd_iface *iface);
int hostapd_check_edmg_capab(struct hostapd_iface *iface);
int hostapd_prepare_rates(struct hostapd_iface *iface,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11.c
index d2a99ef..57c6903 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11.c
@@ -70,12 +70,10 @@
int rssi, int from_queue);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_WPA3_SAE_AUTH_EARLY_SET
static void sae_sme_send_external_auth_status(struct hostapd_data *hapd,
struct sta_info *sta, u16 status);
#endif /* CONFIG_WPA3_SAE_AUTH_EARLY_SET */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
u8 * hostapd_eid_multi_ap(struct hostapd_data *hapd, u8 *eid)
{
u8 multi_ap_val = 0;
@@ -640,12 +638,10 @@
if (data == NULL)
return WLAN_STATUS_UNSPECIFIED_FAILURE;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_WPA3_SAE_AUTH_EARLY_SET
wpa_printf(MSG_DEBUG, "\nCalling sae_sme_send_external_auth_status\n");
sae_sme_send_external_auth_status(hapd, sta, WLAN_STATUS_SUCCESS);
#endif /* CONFIG_WPA3_SAE_AUTH_EARLY_SET */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
reply_res = send_auth_reply(hapd, sta, sta->addr, bssid,
WLAN_AUTH_SAE, 2,
WLAN_STATUS_SUCCESS, wpabuf_head(data),
@@ -924,13 +920,9 @@
wpa_auth_set_pmk_life_time(hapd->wpa_auth,hapd->conf->dot11RSNAConfigPMKLifetime);
wpa_auth_pmksa_add_sae(hapd->wpa_auth, sta->addr,
sta->sae->pmk, sta->sae->pmkid);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef CONFIG_WPA3_SAE_AUTH_EARLY_SET
sae_sme_send_external_auth_status(hapd, sta, WLAN_STATUS_SUCCESS);
#endif /* CONFIG_WPA3_SAE_AUTH_EARLY_SET */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- sae_sme_send_external_auth_status(hapd, sta, WLAN_STATUS_SUCCESS);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -3608,7 +3600,6 @@
tx_chanwidth, tx_seg1_idx);
if (wpa_auth_uses_ocv(sta->wpa_sm) == 2 &&
res == OCI_NOT_FOUND) {
- /* Work around misbehaving STAs */
wpa_printf(MSG_INFO,
"FILS: Disable OCV with a STA that does not send OCI");
wpa_auth_set_ocv(sta->wpa_sm, 0);
@@ -4608,11 +4599,9 @@
return;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CY_AP_RX_MGMT_DISCONNECT
sta->disassoc_reason = le_to_host16(mgmt->u.disassoc.reason_code);
#endif /* CONFIG_CY_AP_RX_MGMT_DISCONNECT */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
ap_sta_set_authorized(hapd, sta, 0);
sta->last_seq_ctrl = WLAN_INVALID_MGMT_SEQ;
sta->flags &= ~(WLAN_STA_ASSOC | WLAN_STA_ASSOC_REQ_OK);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_shared.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_shared.c
index 0f4a797..5110270 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_shared.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_shared.c
@@ -18,11 +18,9 @@
#include "ap_drv_ops.h"
#include "wpa_auth.h"
#include "ieee802_11.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
#include "p2p/p2p_i.h"
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
u8 * hostapd_eid_assoc_comeback_time(struct hostapd_data *hapd,
@@ -554,7 +552,6 @@
u8 * hostapd_eid_interworking(struct hostapd_data *hapd, u8 *eid)
{
u8 *pos = eid;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_P2P)
struct p2p_data *p2p = hapd->p2p;
#endif /* CONFIG_BRCM_AUTOMOTIVE && CONFIG_P2P */
@@ -624,40 +621,6 @@
*len = pos - len - 1;
}
#endif /* CONFIG_BRCM_AUTOMOTIVE && CONFIG_P2P */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef CONFIG_INTERWORKING
- u8 *len;
-
- if (!hapd->conf->interworking)
- return eid;
-
- *pos++ = WLAN_EID_INTERWORKING;
- len = pos++;
-
- *pos = hapd->conf->access_network_type;
- if (hapd->conf->internet)
- *pos |= INTERWORKING_ANO_INTERNET;
- if (hapd->conf->asra)
- *pos |= INTERWORKING_ANO_ASRA;
- if (hapd->conf->esr)
- *pos |= INTERWORKING_ANO_ESR;
- if (hapd->conf->uesa)
- *pos |= INTERWORKING_ANO_UESA;
- pos++;
-
- if (hapd->conf->venue_info_set) {
- *pos++ = hapd->conf->venue_group;
- *pos++ = hapd->conf->venue_type;
- }
-
- if (!is_zero_ether_addr(hapd->conf->hessid)) {
- os_memcpy(pos, hapd->conf->hessid, ETH_ALEN);
- pos += ETH_ALEN;
- }
-
- *len = pos - len - 1;
-#endif /* CONFIG_INTERWORKING */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return pos;
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_vht.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_vht.c
index c925bf1..8a70eb4 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_vht.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_11_vht.c
@@ -97,10 +97,6 @@
oper->vht_op_info_chwidth = hapd->iconf->vht_oper_chwidth;
if (hapd->iconf->vht_oper_chwidth == 2) {
- /*
- * Convert 160 MHz channel width to new style as interop
- * workaround.
- */
oper->vht_op_info_chwidth = 1;
oper->vht_op_info_chan_center_freq_seg1_idx =
oper->vht_op_info_chan_center_freq_seg0_idx;
@@ -110,10 +106,6 @@
else
oper->vht_op_info_chan_center_freq_seg0_idx += 8;
} else if (hapd->iconf->vht_oper_chwidth == 3) {
- /*
- * Convert 80+80 MHz channel width to new style as interop
- * workaround.
- */
oper->vht_op_info_chwidth = 1;
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_1x.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_1x.c
index b942691..1bc19b3 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_1x.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/ieee802_1x.c
@@ -39,6 +39,11 @@
#include "ieee802_1x.h"
#include "wpa_auth_kay.h"
+#if !defined(HOSTAPD)
+#include <wpa_supplicant_i.h>
+#include <config_ssid.h>
+#include <config.h>
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_HS20
static void ieee802_1x_wnm_notif_send(void *eloop_ctx, void *timeout_ctx);
@@ -108,7 +113,12 @@
struct sta_info *sta, int authorized)
{
int res;
-
+#if !defined(HOSTAPD)
+ int i;
+ struct wpa_supplicant *wpa_s, *wpa_last;
+ struct wpa_global *global;
+ struct wpa_ssid *ssid;
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
if (sta->flags & WLAN_STA_PREAUTH)
return;
@@ -133,6 +143,29 @@
if (authorized) {
os_get_reltime(&sta->connected_time);
accounting_sta_start(hapd, sta);
+#if !defined(HOSTAPD)
+ for(i=0;i < hapd->iface->num_bss;i++)
+ wpa_s = (struct wpa_supplicant *)hapd->iface->bss[i]->msg_ctx;
+
+ if (!wpa_s->global->rsdb_flag) {
+ global = wpa_s->global;
+
+ for (wpa_last = global->ifaces; wpa_last; wpa_last = wpa_last->next) {
+ if(os_strcmp(hapd->conf->iface, wpa_last->ifname) == 0 ||
+ os_strcmp(wpa_last->ifname, "wlan0") == 0 ||
+ os_strcmp(wpa_last->ifname, "p2p-dev-wlan0") == 0)
+ continue;
+ else {
+ ssid = wpa_config_get_network(wpa_last->conf, 0);
+ if (ssid == NULL)
+ return;
+ if (ssid->disabled == 2)
+ return;
+ wpa_supplicant_disable_network(wpa_last, ssid);
+ }
+ }
+ }
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
}
}
@@ -189,10 +222,6 @@
key->key_index = idx | (broadcast ? 0 : BIT(7));
if (hapd->conf->eapol_key_index_workaround) {
- /* According to some information, WinXP Supplicant seems to
- * interpret bit7 as an indication whether the key is to be
- * activated, so make it possible to enable workaround that
- * sets this bit for all keys. */
key->key_index |= BIT(7);
}
@@ -2348,12 +2377,8 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Wapi related merges from 137 branch */
void ieee802_1x_set_port_authorized(void *ctx, void *sta_ctx,
-#else /* CONFIG_DRIVER_NL80211_IFX */
-static void ieee802_1x_set_port_authorized(void *ctx, void *sta_ctx,
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int authorized)
{
struct hostapd_data *hapd = ctx;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.c
index fe5f817..8222aa4 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.c
@@ -28,7 +28,8 @@
struct rsn_pmksa_cache_entry *pmksa;
int pmksa_count;
- void (*free_cb)(struct rsn_pmksa_cache_entry *entry, void *ctx);
+ void (*free_cb)(struct rsn_pmksa_cache_entry *entry, void *ctx,
+ enum pmksa_free_reason reason);
void *ctx;
};
@@ -49,13 +50,14 @@
void pmksa_cache_free_entry(struct rsn_pmksa_cache *pmksa,
- struct rsn_pmksa_cache_entry *entry)
+ struct rsn_pmksa_cache_entry *entry,
+ enum pmksa_free_reason reason)
{
struct rsn_pmksa_cache_entry *pos, *prev;
unsigned int hash;
pmksa->pmksa_count--;
- pmksa->free_cb(entry, pmksa->ctx);
+ pmksa->free_cb(entry, pmksa->ctx, reason);
/* unlink from hash list */
hash = PMKID_HASH(entry->pmkid);
@@ -101,7 +103,7 @@
while (pmksa->pmksa) {
wpa_printf(MSG_DEBUG, "RSN: Flush PMKSA cache entry for "
MACSTR, MAC2STR(pmksa->pmksa->spa));
- pmksa_cache_free_entry(pmksa, pmksa->pmksa);
+ pmksa_cache_free_entry(pmksa, pmksa->pmksa, PMKSA_FREE);
}
}
@@ -113,9 +115,10 @@
os_get_reltime(&now);
while (pmksa->pmksa && pmksa->pmksa->expiration <= now.sec) {
+ struct rsn_pmksa_cache_entry *entry = pmksa->pmksa;
wpa_printf(MSG_DEBUG, "RSN: expired PMKSA cache entry for "
MACSTR, MAC2STR(pmksa->pmksa->spa));
- pmksa_cache_free_entry(pmksa, pmksa->pmksa);
+ pmksa_cache_free_entry(pmksa, entry, PMKSA_EXPIRE);
}
pmksa_cache_set_expiration(pmksa);
@@ -374,14 +377,14 @@
*/
pos = pmksa_cache_auth_get(pmksa, entry->spa, NULL);
if (pos)
- pmksa_cache_free_entry(pmksa, pos);
+ pmksa_cache_free_entry(pmksa, pos, PMKSA_REPLACE);
if (pmksa->pmksa_count >= pmksa_cache_max_entries && pmksa->pmksa) {
/* Remove the oldest entry to make room for the new entry */
wpa_printf(MSG_DEBUG, "RSN: removed the oldest PMKSA cache "
"entry (for " MACSTR ") to make room for new one",
MAC2STR(pmksa->pmksa->spa));
- pmksa_cache_free_entry(pmksa, pmksa->pmksa);
+ pmksa_cache_free_entry(pmksa, pmksa->pmksa, PMKSA_FREE);
}
pmksa_cache_link_entry(pmksa, entry);
@@ -538,7 +541,8 @@
*/
struct rsn_pmksa_cache *
pmksa_cache_auth_init(void (*free_cb)(struct rsn_pmksa_cache_entry *entry,
- void *ctx), void *ctx)
+ void *ctx, enum pmksa_free_reason reason),
+ void *ctx)
{
struct rsn_pmksa_cache *pmksa;
@@ -612,7 +616,7 @@
found++;
prev = entry;
entry = entry->next;
- pmksa_cache_free_entry(pmksa, prev);
+ pmksa_cache_free_entry(pmksa, prev, PMKSA_FREE);
continue;
}
entry = entry->next;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.h b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.h
index 2ef2174..ed532dd 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/pmksa_cache_auth.h
@@ -37,9 +37,16 @@
struct rsn_pmksa_cache;
struct radius_das_attrs;
+enum pmksa_free_reason {
+ PMKSA_FREE,
+ PMKSA_REPLACE,
+ PMKSA_EXPIRE,
+};
+
struct rsn_pmksa_cache *
pmksa_cache_auth_init(void (*free_cb)(struct rsn_pmksa_cache_entry *entry,
- void *ctx), void *ctx);
+ void *ctx, enum pmksa_free_reason reason),
+ void *ctx);
void pmksa_cache_auth_deinit(struct rsn_pmksa_cache *pmksa);
struct rsn_pmksa_cache_entry *
pmksa_cache_auth_get(struct rsn_pmksa_cache *pmksa,
@@ -68,7 +75,8 @@
struct rsn_pmksa_cache_entry *entry,
struct eapol_state_machine *eapol);
void pmksa_cache_free_entry(struct rsn_pmksa_cache *pmksa,
- struct rsn_pmksa_cache_entry *entry);
+ struct rsn_pmksa_cache_entry *entry,
+ enum pmksa_free_reason reason);
int pmksa_cache_auth_radius_das_disconnect(struct rsn_pmksa_cache *pmksa,
struct radius_das_attrs *attr);
int pmksa_cache_auth_list(struct rsn_pmksa_cache *pmksa, char *buf, size_t len);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.c
index f5bdb1d..64fa276 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.c
@@ -39,7 +39,11 @@
#include "sta_info.h"
#include "vlan.h"
#include "wps_hostapd.h"
-
+#if !defined(HOSTAPD)
+#include <wpa_supplicant_i.h>
+#include <config_ssid.h>
+#include <config.h>
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
static void ap_sta_remove_in_other_bss(struct hostapd_data *hapd,
struct sta_info *sta);
static void ap_handle_session_timer(void *eloop_ctx, void *timeout_ctx);
@@ -159,7 +163,12 @@
void ap_free_sta(struct hostapd_data *hapd, struct sta_info *sta)
{
int set_beacon = 0;
-
+#if !defined(HOSTAPD)
+ int i;
+ struct wpa_supplicant *wpa_s,*wpa_last;
+ struct wpa_global *global;
+ struct wpa_ssid *ssid;
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
accounting_sta_stop(hapd, sta);
/* just in case */
@@ -187,6 +196,31 @@
~BIT((sta->aid - 1) % 32);
hapd->num_sta--;
+#if !defined(HOSTAPD)
+ if (hapd->num_sta == 0) {
+ for (i=0;i < hapd->iface->num_bss;i++)
+ wpa_s = (struct wpa_supplicant *)hapd->iface->bss[i]->msg_ctx;
+
+ if (!wpa_s->global->rsdb_flag) {
+ global = wpa_s->global;
+
+ for (wpa_last = global->ifaces; wpa_last; wpa_last = wpa_last->next) {
+ if(os_strcmp(hapd->conf->iface, wpa_last->ifname) == 0 ||
+ os_strcmp(wpa_last->ifname, "wlan0") == 0 ||
+ os_strcmp(wpa_last->ifname, "p2p-dev-wlan0") == 0)
+ continue;
+ else {
+ ssid = wpa_config_get_network(wpa_last->conf, 0);
+ if (ssid == NULL)
+ return;
+ if (ssid->disabled == 2)
+ return;
+ wpa_supplicant_enable_network(wpa_last, ssid);
+ }
+ }
+ }
+ }
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
if (sta->nonerp_set) {
sta->nonerp_set = 0;
hapd->iface->num_sta_non_erp--;
@@ -750,13 +784,6 @@
wpa_printf(MSG_DEBUG, "%s: Could not remove station " MACSTR
" from kernel driver",
hapd->conf->iface, MAC2STR(sta->addr));
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- wpa_printf(MSG_INFO,"Removing WAPI STA(" MACSTR ") from wapilib_softap",
- MAC2STR(sta->addr));
- wapiap_lib_disassoc(sta->addr, hapd->ifname);
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return -1;
}
sta->added_unassoc = 0;
@@ -1190,8 +1217,7 @@
ieee802_11_send_sa_query_req(hapd, sta->addr, trans_id);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_AUTOMOTIVE) && defined (CONFIG_BRCM_BANDSTEER)
+#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_BRCM_BANDSTEER)
static void wpa_brcm_trigger_bandsteer(struct hostapd_data *hapd,
u8 *mac_addr)
{
@@ -1212,7 +1238,6 @@
}
}
#endif /* CONFIG_BRCM_AUTOMOTIVE && CONFIG_BRCM_BANDSTEER */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void ap_sta_start_sa_query(struct hostapd_data *hapd, struct sta_info *sta)
{
@@ -1282,7 +1307,7 @@
dev_addr = p2p_group_get_dev_addr(hapd->p2p_group, sta->addr);
if (dev_addr)
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_AUTOMOTIVE)
+#if defined(CONFIG_BRCM_AUTOMOTIVE)
os_snprintf(buf, sizeof(buf), MACSTR " p2p_dev_addr=" MACSTR " peer=P2P",
MAC2STR(sta->addr), MAC2STR(dev_addr));
#else
@@ -1291,7 +1316,7 @@
#endif /* CONFIG_DRIVER_NL80211_IFX && CONFIG_BRCM_AUTOMOTIVE */
else
#endif /* CONFIG_P2P */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_AUTOMOTIVE)
+#if defined(CONFIG_BRCM_AUTOMOTIVE)
{
os_snprintf(buf, sizeof(buf), MACSTR " peer=LEGACY", MAC2STR(sta->addr));
#ifdef CONFIG_BRCM_BANDSTEER
@@ -1339,7 +1364,7 @@
AP_STA_CONNECTED "%s%s%s",
buf, ip_addr, keyid_buf);
} else {
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_CY_AP_RX_MGMT_DISCONNECT)
+#if defined(CONFIG_CY_AP_RX_MGMT_DISCONNECT)
wpa_msg(hapd->msg_ctx, MSG_INFO, AP_STA_DISCONNECTED "%s reason=%d",
buf, sta->disassoc_reason);
#else
@@ -1348,7 +1373,7 @@
if (hapd->msg_ctx_parent &&
hapd->msg_ctx_parent != hapd->msg_ctx)
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_CY_AP_RX_MGMT_DISCONNECT)
+#if defined(CONFIG_CY_AP_RX_MGMT_DISCONNECT)
wpa_msg_no_global(hapd->msg_ctx_parent, MSG_INFO,
AP_STA_DISCONNECTED "%s reason=%d", buf, sta->disassoc_reason);
#else
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.h b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.h
index 98380e7..ef48561 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/sta_info.h
@@ -304,11 +304,6 @@
/* Number of seconds to keep STA entry after it has been deauthenticated. */
#define AP_MAX_INACTIVITY_AFTER_DEAUTH (1 * 5)
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
-int wapiap_lib_disassoc(const unsigned char *sta_mac, char *ifname);
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int ap_for_each_sta(struct hostapd_data *hapd,
int (*cb)(struct hostapd_data *hapd, struct sta_info *sta,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wapiap_interface.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wapiap_interface.c
index 05966fc..ac4ab13 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wapiap_interface.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wapiap_interface.c
@@ -108,4 +108,3 @@
wpa_printf(MSG_INFO, "%s : unsetting hostapd\n", __FUNCTION__);
hostapd = NULL;
}
-
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wmm.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wmm.c
index 9ebb01e..2414c5a 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wmm.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wmm.c
@@ -373,16 +373,6 @@
wmm_addts_req(hapd, mgmt, (struct wmm_tspec_element *)
(elems.wmm_tspec - 2), len);
return;
-#if 0
- /* TODO: needed for client implementation */
- case WMM_ACTION_CODE_ADDTS_RESP:
- wmm_setup_request(hapd, mgmt, len);
- return;
- /* TODO: handle station teardown requests */
- case WMM_ACTION_CODE_DELTS:
- wmm_teardown(hapd, mgmt, len);
- return;
-#endif
}
hostapd_logger(hapd, mgmt->sa, HOSTAPD_MODULE_IEEE80211,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.c
index 432cc24..1b084b4 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.c
@@ -370,10 +370,19 @@
static void wpa_auth_pmksa_free_cb(struct rsn_pmksa_cache_entry *entry,
- void *ctx)
+ void *ctx, enum pmksa_free_reason reason)
{
struct wpa_authenticator *wpa_auth = ctx;
- wpa_sta_disconnect(wpa_auth, entry->spa, WLAN_REASON_PREV_AUTH_NOT_VALID);
+
+ if (reason == PMKSA_EXPIRE) {
+ /*
+ * Once when the PMK cache entry for a STA expires in the SoftAP,
+ * send a deauth to the STA from the SoftAP to make the STA reconnect
+ * to the network and derive a new PMK.
+ */
+ wpa_sta_disconnect(wpa_auth, entry->spa, WLAN_REASON_PREV_AUTH_NOT_VALID);
+ }
+
wpa_auth_for_each_sta(wpa_auth, wpa_auth_pmksa_clear_cb, entry);
}
@@ -680,7 +689,9 @@
}
#endif /* CONFIG_FILS */
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
if (wpa_auth->conf.psk_4way_hs_offload) {
wpa_auth_logger(wpa_auth, sm->addr, LOGGER_DEBUG,
"4-way handshake offloading for WPA/WPA2-PSK");
@@ -696,7 +707,6 @@
WPA_EAPOL_keyDone, 1);
return 0;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (sm->started) {
os_memset(&sm->key_replay, 0, sizeof(sm->key_replay));
@@ -1156,13 +1166,6 @@
sm->wpa_ptk_state == WPA_PTK_PTKINITNEGOTIATING &&
os_memcmp(sm->SNonce, key->key_nonce, WPA_NONCE_LEN) != 0)
{
- /*
- * Some supplicant implementations (e.g., Windows XP
- * WZC) update SNonce for each EAPOL-Key 2/4. This
- * breaks the workaround on accepting any of the
- * pending requests, so allow the SNonce to be updated
- * even if we have already sent out EAPOL-Key 3/4.
- */
wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
"Process SNonce update from STA based on retransmitted EAPOL-Key 1/4");
sm->update_snonce = 1;
@@ -1378,13 +1381,6 @@
key->replay_counter);
if (msg == PAIRWISE_2) {
- /*
- * Maintain a copy of the pending EAPOL-Key frames in
- * case the EAPOL-Key frame was retransmitted. This is
- * needed to allow EAPOL-Key msg 2/4 reply to another
- * pending msg 1/4 to update the SNonce to work around
- * unexpected supplicant behavior.
- */
os_memcpy(sm->prev_key_replay, sm->key_replay,
sizeof(sm->key_replay));
} else {
@@ -2117,14 +2113,6 @@
forced_memzero(msk, sizeof(msk));
sm->req_replay_counter_used = 0;
- /* IEEE 802.11i does not set keyRun to false, but not doing this
- * will break reauthentication since EAPOL state machines may not be
- * get into AUTHENTICATING state that clears keyRun before WPA state
- * machine enters AUTHENTICATION2 state and goes immediately to INITPMK
- * state and takes PMK from the previously used AAA Key. This will
- * eventually fail in 4-Way Handshake because Supplicant uses PMK
- * derived from the new AAA Key. Setting keyRun = false here seems to
- * be good workaround for this issue. */
wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_keyRun, false);
}
@@ -3073,7 +3061,6 @@
res = ocv_verify_tx_params(kde.oci, kde.oci_len, &ci,
tx_chanwidth, tx_seg1_idx);
if (wpa_auth_uses_ocv(sm) == 2 && res == OCI_NOT_FOUND) {
- /* Work around misbehaving STAs */
wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_INFO,
"Disable OCV with a STA that does not send OCI");
wpa_auth_set_ocv(sm, 0);
@@ -3435,14 +3422,6 @@
gtk_len = 0;
_rsc = NULL;
if (sm->rx_eapol_key_secure) {
- /*
- * It looks like Windows 7 supplicant tries to use
- * Secure bit in msg 2/4 after having reported Michael
- * MIC failure and it then rejects the 4-way handshake
- * if msg 3/4 does not set Secure bit. Work around this
- * by setting the Secure bit here even in the case of
- * WPA if the supplicant used it first.
- */
wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
"STA used Secure bit in WPA msg 2/4 - set Secure for 3/4 as workaround");
secure = 1;
@@ -4835,7 +4814,7 @@
if (pmksa) {
wpa_printf(MSG_DEBUG, "WPA: Remove PMKSA cache entry for "
MACSTR " based on request", MAC2STR(sta_addr));
- pmksa_cache_free_entry(wpa_auth->pmksa, pmksa);
+ pmksa_cache_free_entry(wpa_auth->pmksa, pmksa, PMKSA_FREE);
}
}
@@ -5400,14 +5379,6 @@
gtk_len = 0;
_rsc = NULL;
if (sm->rx_eapol_key_secure) {
- /*
- * It looks like Windows 7 supplicant tries to use
- * Secure bit in msg 2/4 after having reported Michael
- * MIC failure and it then rejects the 4-way handshake
- * if msg 3/4 does not set Secure bit. Work around this
- * by setting the Secure bit here even in the case of
- * WPA if the supplicant used it first.
- */
wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
"STA used Secure bit in WPA msg 2/4 - set Secure for 3/4 as workaround");
secure = 1;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.h b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.h
index f2e0788..48970a8 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth.h
@@ -179,11 +179,9 @@
int wpa_gmk_rekey;
int wpa_ptk_rekey;
int wpa_deny_ptk0_rekey;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
int peerkey;
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
u32 wpa_group_update_count;
u32 wpa_pairwise_update_count;
int wpa_disable_eapol_key_retries;
@@ -256,11 +254,9 @@
u8 ip_addr_start[4];
u8 ip_addr_end[4];
#endif /* CONFIG_P2P */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
u8 replay_cntrs;
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_FILS
unsigned int fils_cache_id_set:1;
u8 fils_cache_id[FILS_CACHE_ID_LEN];
@@ -272,12 +268,13 @@
#ifdef CONFIG_DPP2
int dpp_pfs;
#endif /* CONFIG_DPP2 */
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
int psk_4way_hs_offload;
#ifdef CONFIG_SAE
int sae_offload;
#endif /* CONFIG_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
typedef enum {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ft.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ft.c
index 5aa363e..ab00db6 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ft.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ft.c
@@ -107,9 +107,6 @@
if (enc_len < AES_BLOCK_SIZE + 2)
goto err;
- /* Try to work around Ethernet devices that add extra
- * two octet padding even if the frame is longer than
- * the minimum Ethernet frame. */
enc_len -= 2;
if (aes_siv_decrypt(key, key_len, enc, enc_len, 3, ad, ad_len,
*plain) < 0)
@@ -3522,7 +3519,6 @@
res = ocv_verify_tx_params(parse.oci, parse.oci_len, &ci,
tx_chanwidth, tx_seg1_idx);
if (wpa_auth_uses_ocv(sm) == 2 && res == OCI_NOT_FOUND) {
- /* Work around misbehaving STAs */
wpa_printf(MSG_INFO,
"Disable OCV with a STA that does not send OCI");
wpa_auth_set_ocv(sm, 0);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_glue.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_glue.c
index a2278df..bb67087 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_glue.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_glue.c
@@ -187,11 +187,9 @@
os_memcpy(wconf->ip_addr_start, conf->ip_addr_start, 4);
os_memcpy(wconf->ip_addr_end, conf->ip_addr_end, 4);
#endif /* CONFIG_P2P */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
wconf->replay_cntrs = conf->replay_cntrs;
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_FILS
wconf->fils_cache_id_set = conf->fils_cache_id_set;
os_memcpy(wconf->fils_cache_id, conf->fils_cache_id,
@@ -1485,7 +1483,9 @@
else
_conf.extended_key_id = 0;
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
if (!hapd->conf->p2p &&
(hapd->iface->drv_flags2 & WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK))
_conf.psk_4way_hs_offload = 1;
@@ -1494,7 +1494,6 @@
if (hapd->iface->drv_flags2 & WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP)
_conf.sae_offload = 1;
#endif /* CONFIG_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
hapd->wpa_auth = wpa_init(hapd->own_addr, &_conf, &cb, hapd);
if (hapd->wpa_auth == NULL) {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ie.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ie.c
index ca5a2d3..0b57158 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ie.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wpa_auth_ie.c
@@ -280,15 +280,13 @@
capab = 0;
if (conf->rsn_preauth)
capab |= WPA_CAPABILITY_PREAUTH;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
if (conf->peerkey)
capab |= WPA_CAPABILITY_PEERKEY_ENABLED;
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (conf->wmm_enabled) {
/* 4 PTKSA replay counters when using WMM */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSN_CNTRS)
+#if defined(CONFIG_BRCM_RSN_CNTRS)
if (conf->replay_cntrs) {
capab |= (conf->replay_cntrs << 2);
} else {
@@ -392,6 +390,9 @@
{
u8 *pos = buf;
+ /* Refer commit 7ce7b05cda: WPA3 R3 client fails to associate AP
+ * * configured in Mixed mode (WPA2+WPA3) security
+ * */
if ((conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE) != WPA_KEY_MGMT_SAE &&
(conf->sae_pwe != 1 || conf->sae_pwe != 2) && !conf->sae_pk)
return 0; /* no supported extended RSN capabilities */
@@ -609,9 +610,6 @@
if (wpa_key_mgmt_ft(data.key_mgmt) && !mdie &&
!wpa_key_mgmt_only_ft(data.key_mgmt)) {
- /* Workaround for some HP and Epson printers that seem
- * to incorrectly copy the FT-PSK + WPA-PSK AKMs from AP
- * advertised RSNE to Association Request frame. */
wpa_printf(MSG_DEBUG,
"RSN: FT set in RSNE AKM but MDE is missing from "
MACSTR
@@ -825,11 +823,6 @@
#ifdef CONFIG_OCV
if (wpa_auth->conf.ocv && (data.capabilities & WPA_CAPABILITY_OCVC) &&
!(data.capabilities & WPA_CAPABILITY_MFPC)) {
- /* Some legacy MFP incapable STAs wrongly copy OCVC bit from
- * AP RSN capabilities. To improve interoperability with such
- * legacy STAs allow connection without enabling OCV when the
- * workaround mode (ocv=2) is enabled.
- */
if (wpa_auth->conf.ocv == 2) {
wpa_printf(MSG_DEBUG,
"Allow connecting MFP incapable and OCV capable STA without enabling OCV");
@@ -921,7 +914,6 @@
#endif /* CONFIG_IEEE80211R_AP && CONFIG_FILS */
sm->pmksa = NULL;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
if (data.num_pmkid == 0) {
if (wpa_key_mgmt_sae(sm->wpa_key_mgmt)) {
@@ -934,7 +926,6 @@
}
else {
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
for (i = 0; i < data.num_pmkid; i++) {
wpa_hexdump(MSG_DEBUG, "RSN IE: STA PMKID",
&data.pmkid[i * PMKID_LEN], PMKID_LEN);
@@ -945,11 +936,9 @@
break;
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
}
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
for (i = 0; sm->pmksa == NULL && wpa_auth->conf.okc &&
i < data.num_pmkid; i++) {
struct wpa_auth_okc_iter_data idata;
@@ -982,13 +971,12 @@
}
#ifdef CONFIG_SAE
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
if (!wpa_auth->conf.psk_4way_hs_offload &&
!wpa_auth->conf.sae_offload &&
sm->wpa_key_mgmt == WPA_KEY_MGMT_SAE && data.num_pmkid &&
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (sm->wpa_key_mgmt == WPA_KEY_MGMT_SAE && data.num_pmkid &&
-#endif /* CONFIG_DRIVER_NL80211_IFX */
!sm->pmksa) {
wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
"No PMKSA cache entry found for SAE");
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wps_hostapd.c b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wps_hostapd.c
index dc8aa8f..a4fd208 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wps_hostapd.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/ap/wps_hostapd.c
@@ -1624,11 +1624,6 @@
sta = ap_get_sta(hapd, mac_addr);
#ifndef CONFIG_WPS_STRICT
if (!sta) {
- /*
- * Workaround - Intel wsccmd uses bogus NewWLANEventMAC:
- * Pick STA that is in an ongoing WPS registration without
- * checking the MAC address.
- */
wpa_printf(MSG_DEBUG, "WPS UPnP: No matching STA found based "
"on NewWLANEventMAC; try wildcard match");
for (sta = hapd->sta_list; sta; sta = sta->next) {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/brcm_vendor.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/brcm_vendor.h
index 63a7566..a7cde17 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/brcm_vendor.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/brcm_vendor.h
@@ -50,7 +50,6 @@
BRCM_VENDOR_EVENT_OVERTEMP = 43
};
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
enum wifi_sae_key_attr {
BRCM_SAE_KEY_ATTR_PEER_MAC,
@@ -58,7 +57,6 @@
BRCM_SAE_KEY_ATTR_PMKID
};
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
enum brcm_nl80211_vendor_bcnrecv_attr_type {
BRCM_BCNRECV_ATTR_STATUS = 1,
@@ -67,4 +65,3 @@
BRCM_BCNRECV_ATTR_MAX
};
#endif /* BRCM_VENDOR_H */
-
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/defs.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/defs.h
index 351f599..bbe3120 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/defs.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/defs.h
@@ -161,17 +161,10 @@
return wpa_key_mgmt_wpa(akm) || (akm & WPA_KEY_MGMT_WPA_NONE);
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_CCX)
-static inline int wpa_key_mgmt_cckm(int akm)
-{
- return !!(akm & (WPA_KEY_MGMT_CCKM));
-}
-#else
static inline int wpa_key_mgmt_cckm(int akm)
{
return akm == WPA_KEY_MGMT_CCKM;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX && BRCM_CCX */
#define WPA_PROTO_WPA BIT(0)
@@ -206,11 +199,6 @@
WPA_ALG_BIP_GMAC_128,
WPA_ALG_BIP_GMAC_256,
WPA_ALG_BIP_CMAC_256
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- , WAPI_ALG_SMS4
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
static inline int wpa_alg_bip(enum wpa_alg alg)
@@ -336,11 +324,6 @@
* fully configured.
*/
WPA_COMPLETED
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI /* to be detailed out */
- , WAPI_SPECIFIC
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
#define MLME_SETPROTECTION_PROTECT_TYPE_NONE 0
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp.c
index 0683072..130e62f 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp.c
@@ -38,9 +38,8 @@
enum dpp_test_behavior dpp_test = DPP_TEST_DISABLED;
#endif /* CONFIG_TESTING_OPTIONS */
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
/* Compatibility wrappers for older versions. */
#ifdef CONFIG_DPP2
@@ -1042,7 +1041,6 @@
pos += 6;
end = os_strchr(pos, ' ');
conf->ssid_len = end ? (size_t) (end - pos) : os_strlen(pos);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_DPP_FIX
/* Remove check for ssid in hex as we are supplying
* string format in dpp_auth_init */
@@ -1053,18 +1051,11 @@
hexstr2bin(pos, conf->ssid, conf->ssid_len) < 0)
#endif /* CONFIG_DPP_FIX */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- conf->ssid_len /= 2;
- if (conf->ssid_len > sizeof(conf->ssid) ||
- hexstr2bin(pos, conf->ssid, conf->ssid_len) < 0)
-#endif /* CONFIG_DRIVER_NL80211_IFX */
goto fail;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_DPP_FIX
}
os_memcpy(conf->ssid, pos, conf->ssid_len);
#endif /* CONFIG_DPP_FIX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
} else {
#ifdef CONFIG_TESTING_OPTIONS
/* use a default SSID for legacy testing reasons */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_backup.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_backup.c
index 3b81f09..c964811 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_backup.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_backup.c
@@ -19,9 +19,8 @@
#ifdef CONFIG_DPP2
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
/* Compatibility wrappers for older versions. */
static EC_KEY * EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_crypto.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_crypto.c
index 2d0fb39..f3434a9 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_crypto.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_crypto.c
@@ -26,9 +26,8 @@
#include "dpp_i.h"
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
/* Compatibility wrappers for older versions. */
static int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s)
@@ -49,7 +48,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef ABOVE_8_1
static EC_KEY * EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
{
@@ -58,14 +56,6 @@
return pkey->pkey.ec;
}
#endif /* ABOVE_8_1 */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-static EC_KEY * EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
-{
- if (pkey->type != EVP_PKEY_EC)
- return NULL;
- return pkey->pkey.ec;
-}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif
@@ -932,14 +922,6 @@
u8 buf[200];
int level = *secret_len > 200 ? MSG_ERROR : MSG_DEBUG;
- /* It looks like OpenSSL can return unexpectedly large buffer
- * need for shared secret from EVP_PKEY_derive(NULL) in some
- * cases. For example, group 19 has shown cases where secret_len
- * is set to 72 even though the actual length ends up being
- * updated to 32 when EVP_PKEY_derive() is called with a buffer
- * for the value. Work around this by trying to fetch the value
- * and continue if it is within supported range even when the
- * initial buffer need is claimed to be larger. */
wpa_printf(level,
"DPP: Unexpected secret_len=%d from EVP_PKEY_derive()",
(int) *secret_len);
@@ -1015,9 +997,8 @@
const unsigned char *pk;
int ppklen;
X509_ALGOR *pa;
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20800000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20800000L)
ASN1_OBJECT *pa_oid;
#else
const ASN1_OBJECT *pa_oid;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_pkex.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_pkex.c
index 135ae65..e42f7fb 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_pkex.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dpp_pkex.c
@@ -27,12 +27,10 @@
size_t dpp_pkex_ephemeral_key_override_len = 0;
#endif /* CONFIG_TESTING_OPTIONS */
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
/* Compatibility wrappers for older versions. */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef ABOVE_8_1
static EC_KEY * EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
{
@@ -41,14 +39,6 @@
return pkey->pkey.ec;
}
#endif /* ABOVE_8_1 */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-static EC_KEY * EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
-{
- if (pkey->type != EVP_PKEY_EC)
- return NULL;
- return pkey->pkey.ec;
-}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.c
index 547be66..1e84271 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.c
@@ -213,3 +213,37 @@
"dragonfly: Unable to get randomness for own scalar");
return -1;
}
+
+
+/* res = sqrt(val) */
+int dragonfly_sqrt(struct crypto_ec *ec, const struct crypto_bignum *val,
+ struct crypto_bignum *res)
+{
+ const struct crypto_bignum *prime;
+ struct crypto_bignum *tmp, *one;
+ int ret = 0;
+ u8 prime_bin[DRAGONFLY_MAX_ECC_PRIME_LEN];
+ size_t prime_len;
+
+ /* For prime p such that p = 3 mod 4, sqrt(w) = w^((p+1)/4) mod p */
+
+ prime = crypto_ec_get_prime(ec);
+ prime_len = crypto_ec_prime_len(ec);
+ tmp = crypto_bignum_init();
+ one = crypto_bignum_init_uint(1);
+
+ if (crypto_bignum_to_bin(prime, prime_bin, sizeof(prime_bin),
+ prime_len) < 0 ||
+ (prime_bin[prime_len - 1] & 0x03) != 3 ||
+ !tmp || !one ||
+ /* tmp = (p+1)/4 */
+ crypto_bignum_add(prime, one, tmp) < 0 ||
+ crypto_bignum_rshift(tmp, 2, tmp) < 0 ||
+ /* res = sqrt(val) */
+ crypto_bignum_exptmod(val, tmp, prime, res) < 0)
+ ret = -1;
+
+ crypto_bignum_deinit(tmp, 0);
+ crypto_bignum_deinit(one, 0);
+ return ret;
+}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.h
index ec3dd59..84d67f5 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/dragonfly.h
@@ -27,5 +27,7 @@
struct crypto_bignum *_rand,
struct crypto_bignum *_mask,
struct crypto_bignum *scalar);
+int dragonfly_sqrt(struct crypto_ec *ec, const struct crypto_bignum *val,
+ struct crypto_bignum *res);
#endif /* DRAGONFLY_H */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.c
index 44e83f1..f76994d 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.c
@@ -574,14 +574,6 @@
show_errors))
unknown++;
break;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- case WLAN_EID_WAPI:
- elems->wapiap_ie = pos;
- elems->wapiap_ie_len = elen;
- break;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
default:
unknown++;
if (!show_errors)
@@ -696,12 +688,10 @@
return NULL;
return hdr->addr1;
case WLAN_FC_TYPE_MGMT:
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
if (len < 24)
return NULL;
#endif /* ABOVE_10 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return hdr->addr3;
default:
return NULL;
@@ -1539,11 +1529,9 @@
static int is_11b(u8 rate)
{
return rate == 0x02 || rate == 0x04 || rate == 0x0b || rate == 0x16
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
|| rate == 0x82 || rate == 0x84 || rate == 0x8b || rate == 0x96
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
;
}
@@ -1922,10 +1910,6 @@
{ HOSTAPD_MODE_IEEE80211AD, 182, 17, 20, 1, BW6480, P2P_SUPP },
{ HOSTAPD_MODE_IEEE80211AD, 183, 25, 27, 1, BW8640, P2P_SUPP },
- /* Keep the operating class 130 as the last entry as a workaround for
- * the OneHundredAndThirty Delimiter value used in the Supported
- * Operating Classes element to indicate the end of the Operating
- * Classes field. */
{ HOSTAPD_MODE_IEEE80211A, 130, 36, 161, 4, BW80P80, P2P_SUPP },
{ -1, 0, 0, 0, 0, BW20, NO_P2P_SUPP }
};
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.h
index 7283b87..0ae0fa4 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_common.h
@@ -171,16 +171,6 @@
struct mb_ies_info mb_ies;
struct frag_ies_info frag_ies;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- const u8 *wapi_ie;
- u8 wapi_ie_len;
-#endif /* WAPI */
-#ifdef WAPI_AP
- const u8 *wapiap_ie;
- u8 wapiap_ie_len;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
typedef enum { ParseOK = 0, ParseUnknown = 1, ParseFailed = -1 } ParseRes;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_defs.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_defs.h
index 6cde9ef..f3ae1b1 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_defs.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/ieee802_11_defs.h
@@ -123,21 +123,17 @@
#define WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA 17
#define WLAN_STATUS_ASSOC_DENIED_RATES 18
#define WLAN_STATUS_ASSOC_DENIED_NOSHORT 19
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
#define WLAN_STATUS_ASSOC_DENIED_NOPBCC 20
#define WLAN_STATUS_ASSOC_DENIED_NOAGILITY 21
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define WLAN_STATUS_SPEC_MGMT_REQUIRED 22
#define WLAN_STATUS_PWR_CAPABILITY_NOT_VALID 23
#define WLAN_STATUS_SUPPORTED_CHANNEL_NOT_VALID 24
#define WLAN_STATUS_ASSOC_DENIED_NO_SHORT_SLOT_TIME 25
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
#define WLAN_STATUS_ASSOC_DENIED_NO_DSSS_OFDM 26
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define WLAN_STATUS_ASSOC_DENIED_NO_HT 27
#define WLAN_STATUS_R0KH_UNREACHABLE 28
#define WLAN_STATUS_ASSOC_DENIED_NO_PCO 29
@@ -286,11 +282,9 @@
/* Information Element IDs (IEEE Std 802.11-2016, 9.4.2.1, Table 9-77) */
#define WLAN_EID_SSID 0
#define WLAN_EID_SUPP_RATES 1
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
#define WLAN_EID_FH_PARAMS 2
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define WLAN_EID_DS_PARAMS 3
#define WLAN_EID_CF_PARAMS 4
#define WLAN_EID_TIM 5
@@ -337,14 +331,10 @@
#define WLAN_EID_RSNI 65
#define WLAN_EID_MEASUREMENT_PILOT_TRANSMISSION 66
#define WLAN_EID_BSS_AVAILABLE_ADM_CAPA 67
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
//#define WLAN_EID_BSS_AC_ACCESS_DELAY 68 /* note: also used by WAPI */
#define WLAN_EID_WAPI 68
#endif /* CONFIG_BRCM_MERGES */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#define WLAN_EID_BSS_AC_ACCESS_DELAY 68 /* note: also used by WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define WLAN_EID_TIME_ADVERTISEMENT 69
#define WLAN_EID_RRM_ENABLED_CAPABILITIES 70
#define WLAN_EID_MULTIPLE_BSSID 71
@@ -1344,11 +1334,9 @@
#define OSEN_IE_VENDOR_TYPE 0x506f9a12
#define MBO_IE_VENDOR_TYPE 0x506f9a16
#define MBO_OUI_TYPE 22
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_AFBT
#define AFBT_IE_VENDOR_TYPE 0x0040960b
#endif /* BRCM_AFBT */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define OWE_IE_VENDOR_TYPE 0x506f9a1c
#define OWE_OUI_TYPE 28
#define MULTI_AP_OUI_TYPE 0x1B
@@ -1744,7 +1732,6 @@
P2P_SD_BAD_REQUEST = 3
};
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
/* cipher suite selectors */
#define WLAN_CIPHER_SUITE_USE_GROUP 0x000FAC00
@@ -1762,11 +1749,7 @@
#define WLAN_CIPHER_SUITE_BIP_GMAC_256 0x000FAC0C
#define WLAN_CIPHER_SUITE_BIP_CMAC_256 0x000FAC0D
-#if defined(WAPI) && !defined(USE_STANDARD_SUITE_SMS4_VAL)
-#define WLAN_CIPHER_SUITE_SMS4 0x000FAC07
-#else
#define WLAN_CIPHER_SUITE_SMS4 0x00147201
-#endif /* WAPI && !USE_STANDARD_SUITE_SMS4_VAL */
#define WLAN_CIPHER_SUITE_CKIP 0x00409600
#define WLAN_CIPHER_SUITE_CKIP_CMIC 0x00409601
#define WLAN_CIPHER_SUITE_CMIC 0x00409602
@@ -1783,16 +1766,11 @@
#define WLAN_AKM_SUITE_FT_PSK 0x000FAC04
#define WLAN_AKM_SUITE_8021X_SHA256 0x000FAC05
#define WLAN_AKM_SUITE_PSK_SHA256 0x000FAC06
-#ifdef WAPI
-#define WLAN_AKM_SUITE_WAPI_PSK 0x000FAC04
-#define WLAN_AKM_SUITE_WAPI_CERT 0x000FAC12
-#endif /* WAPI */
#define WLAN_AKM_SUITE_8021X_SUITE_B 0x000FAC11
#define WLAN_AKM_SUITE_8021X_SUITE_B_192 0x000FAC12
#define WLAN_AKM_SUITE_CCKM 0x00409600
#define WLAN_AKM_SUITE_OSEN 0x506f9a01
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
enum wifi_display_subelem {
WFD_SUBELEM_DEVICE_INFO = 0,
@@ -1838,7 +1816,6 @@
#define VENDOR_HT_CAPAB_OUI_TYPE 0x33 /* 00-90-4c:0x33 */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
/* cipher suite selectors */
#define WLAN_CIPHER_SUITE_USE_GROUP 0x000FAC00
@@ -1856,11 +1833,7 @@
#define WLAN_CIPHER_SUITE_BIP_GMAC_256 0x000FAC0C
#define WLAN_CIPHER_SUITE_BIP_CMAC_256 0x000FAC0D
-#if defined(WAPI) && !defined(USE_STANDARD_SUITE_SMS4_VAL)
-#define WLAN_CIPHER_SUITE_SMS4 0x000FAC07
-#else
#define WLAN_CIPHER_SUITE_SMS4 0x00147201
-#endif /* WAPI && !USE_STANDARD_SUITE_SMS4_VAL */
#define WLAN_CIPHER_SUITE_CKIP 0x00409600
#define WLAN_CIPHER_SUITE_CKIP_CMIC 0x00409601
#define WLAN_CIPHER_SUITE_CMIC 0x00409602
@@ -1877,16 +1850,11 @@
#define WLAN_AKM_SUITE_FT_PSK 0x000FAC04
#define WLAN_AKM_SUITE_8021X_SHA256 0x000FAC05
#define WLAN_AKM_SUITE_PSK_SHA256 0x000FAC06
-#ifdef WAPI
-#define WLAN_AKM_SUITE_WAPI_PSK 0x000FAC04
-#define WLAN_AKM_SUITE_WAPI_CERT 0x000FAC12
-#endif /* WAPI */
#define WLAN_AKM_SUITE_8021X_SUITE_B 0x000FAC11
#define WLAN_AKM_SUITE_8021X_SUITE_B_192 0x000FAC12
#define WLAN_AKM_SUITE_CCKM 0x00409600
#define WLAN_AKM_SUITE_OSEN 0x506f9a01
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* IEEE 802.11v - WNM Action field values */
enum wnm_action {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/sae.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/sae.c
index 372905d..88cbe53 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/sae.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/sae.c
@@ -291,14 +291,16 @@
int pwd_seed_odd = 0;
u8 prime[SAE_MAX_ECC_PRIME_LEN];
size_t prime_len;
- struct crypto_bignum *x = NULL, *qr = NULL, *qnr = NULL;
+ struct crypto_bignum *x = NULL, *y = NULL, *qr = NULL, *qnr = NULL;
u8 x_bin[SAE_MAX_ECC_PRIME_LEN];
u8 x_cand_bin[SAE_MAX_ECC_PRIME_LEN];
u8 qr_bin[SAE_MAX_ECC_PRIME_LEN];
u8 qnr_bin[SAE_MAX_ECC_PRIME_LEN];
+ u8 x_y[2 * SAE_MAX_ECC_PRIME_LEN];
int res = -1;
u8 found = 0; /* 0 (false) or 0xff (true) to be used as const_time_*
* mask */
+ unsigned int is_eq;
os_memset(x_bin, 0, sizeof(x_bin));
@@ -407,25 +409,42 @@
goto fail;
}
- if (!sae->tmp->pwe_ecc)
- sae->tmp->pwe_ecc = crypto_ec_point_init(sae->tmp->ec);
- if (!sae->tmp->pwe_ecc)
- res = -1;
- else
- res = crypto_ec_point_solve_y_coord(sae->tmp->ec,
- sae->tmp->pwe_ecc, x,
- pwd_seed_odd);
- if (res < 0) {
- /*
- * This should not happen since we already checked that there
- * is a result.
- */
+ /* y = sqrt(x^3 + ax + b) mod p
+ * if LSB(save) == LSB(y): PWE = (x, y)
+ * else: PWE = (x, p - y)
+ *
+ * Calculate y and the two possible values for PWE and after that,
+ * use constant time selection to copy the correct alternative.
+ */
+ y = crypto_ec_point_compute_y_sqr(sae->tmp->ec, x);
+ if (!y ||
+ dragonfly_sqrt(sae->tmp->ec, y, y) < 0 ||
+ crypto_bignum_to_bin(y, x_y, SAE_MAX_ECC_PRIME_LEN,
+ prime_len) < 0 ||
+ crypto_bignum_sub(sae->tmp->prime, y, y) < 0 ||
+ crypto_bignum_to_bin(y, x_y + SAE_MAX_ECC_PRIME_LEN,
+ SAE_MAX_ECC_PRIME_LEN, prime_len) < 0) {
wpa_printf(MSG_DEBUG, "SAE: Could not solve y");
+ goto fail;
+ }
+
+ is_eq = const_time_eq(pwd_seed_odd, x_y[prime_len - 1] & 0x01);
+ const_time_select_bin(is_eq, x_y, x_y + SAE_MAX_ECC_PRIME_LEN,
+ prime_len, x_y + prime_len);
+ os_memcpy(x_y, x_bin, prime_len);
+ wpa_hexdump_key(MSG_DEBUG, "SAE: PWE", x_y, 2 * prime_len);
+ crypto_ec_point_deinit(sae->tmp->pwe_ecc, 1);
+ sae->tmp->pwe_ecc = crypto_ec_point_from_bin(sae->tmp->ec, x_y);
+ if (!sae->tmp->pwe_ecc) {
+ wpa_printf(MSG_DEBUG, "SAE: Could not generate PWE");
+ res = -1;
}
fail:
+ forced_memzero(x_y, sizeof(x_y));
crypto_bignum_deinit(qr, 0);
crypto_bignum_deinit(qnr, 0);
+ crypto_bignum_deinit(y, 1);
os_free(dummy_password);
bin_clear_free(tmp_password, password_len);
crypto_bignum_deinit(x, 1);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/version.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/version.h
index 7bdc96c..665dd23 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/version.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/version.h
@@ -9,27 +9,16 @@
#define GIT_VERSION_STR_POSTFIX ""
#endif /* GIT_VERSION_STR_POSTFIX */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#define BRCM_MAJOR_VER "201"
-#define BRCM_MINOR_VER "10"
+#define BRCM_MINOR_VER "19"
#define BRCM_VER_INFO " BRCM_VER:" BRCM_MAJOR_VER "." BRCM_MINOR_VER
-#ifdef BRCM_DEBUG
-#define OPENSRC_GIT_HASH "1759a8e3f36a40b20e7c7df06c6d1afc5d1c30c7"
-#define OPENSRC_SYNC_DATE "(11/23/2020)"
-#define BRCM_STR_POSTFIX BRCM_VER_INFO" GITHASH:"OPENSRC_GIT_HASH " "OPENSRC_SYNC_DATE" \nCompiled in" \
- SUP_SRC_BASE " on " __DATE__ " at " __TIME__ "\n"
-#else
#define BRCM_STR_POSTFIX BRCM_VER_INFO
-#endif
-#if defined (ANDROID_P2P) || defined (BRCM_DEBUG)
+#if defined(ANDROID_P2P)
#define VERSION_STR "2.10-devel" VERSION_STR_POSTFIX BRCM_STR_POSTFIX
#else
#define VERSION_STR "2.10-devel" VERSION_STR_POSTFIX GIT_VERSION_STR_POSTFIX
#endif
-#else
-#define VERSION_STR "2.10-devel" VERSION_STR_POSTFIX GIT_VERSION_STR_POSTFIX
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* VERSION_H */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.c
index e9e1221..b5143d1 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.c
@@ -21,11 +21,7 @@
#include "wpa_common.h"
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_CCX)
-unsigned int wpa_kck_len(int akmp, size_t pmk_len)
-#else
static unsigned int wpa_kck_len(int akmp, size_t pmk_len)
-#endif /* CONFIG_DRIVER_NL80211_IFX && BRCM_CCX */
{
switch (akmp) {
case WPA_KEY_MGMT_IEEE8021X_SUITE_B_192:
@@ -61,11 +57,7 @@
#endif /* CONFIG_IEEE80211R */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_CCX)
-unsigned int wpa_kek_len(int akmp, size_t pmk_len)
-#else
static unsigned int wpa_kek_len(int akmp, size_t pmk_len)
-#endif /* CONFIG_DRIVER_NL80211_IFX && BRCM_CCX */
{
switch (akmp) {
case WPA_KEY_MGMT_FILS_SHA384:
@@ -1189,12 +1181,6 @@
if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_FT_SAE)
return WPA_KEY_MGMT_FT_SAE;
#endif /* CONFIG_SAE */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_CCKM)
- return WPA_KEY_MGMT_CCKM;
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_802_1X_SUITE_B)
return WPA_KEY_MGMT_IEEE8021X_SUITE_B;
if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_802_1X_SUITE_B_192)
@@ -1236,7 +1222,6 @@
cipher == WPA_CIPHER_BIP_CMAC_256;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if BRCM_AFBT
int wpa_adaptive_fbt_update(u8 *rsn_ie, int rsn_ie_len)
{
@@ -1327,7 +1312,6 @@
return 0;
}
#endif /* BRCM_AFBT */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* wpa_parse_wpa_ie_rsn - Parse RSN IE
@@ -1525,12 +1509,6 @@
return WPA_KEY_MGMT_PSK;
if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_NONE)
return WPA_KEY_MGMT_WPA_NONE;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_CCKM)
- return WPA_KEY_MGMT_CCKM;
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return 0;
}
@@ -2159,13 +2137,6 @@
return "WPA2-EAP-SHA256";
case WPA_KEY_MGMT_PSK_SHA256:
return "WPA2-PSK-SHA256";
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- case WPA_KEY_MGMT_CCKM:
- return proto == WPA_PROTO_RSN ?
- "WPA2/CCKM/EAP" : "WPA/CCKM/EAP";
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case WPA_KEY_MGMT_WPS:
return "WPS";
case WPA_KEY_MGMT_SAE:
@@ -2618,12 +2589,6 @@
val |= WPA_CIPHER_NONE;
else if (os_strcmp(start, "GTK_NOT_USED") == 0)
val |= WPA_CIPHER_GTK_NOT_USED;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else if (os_strcmp(start, "SMS4") == 0)
- val |= WPA_CIPHER_SMS4;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
else if (os_strcmp(start, "AES-128-CMAC") == 0)
val |= WPA_CIPHER_AES_128_CMAC;
else if (os_strcmp(start, "BIP-GMAC-128") == 0)
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.h
index 3f3d1bd..07f8d67 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_common.h
@@ -85,9 +85,6 @@
#define RSN_CIPHER_SUITE_NONE RSN_SELECTOR(0x00, 0x0f, 0xac, 0)
#define RSN_CIPHER_SUITE_WEP40 RSN_SELECTOR(0x00, 0x0f, 0xac, 1)
#define RSN_CIPHER_SUITE_TKIP RSN_SELECTOR(0x00, 0x0f, 0xac, 2)
-#if 0
-#define RSN_CIPHER_SUITE_WRAP RSN_SELECTOR(0x00, 0x0f, 0xac, 3)
-#endif
#define RSN_CIPHER_SUITE_CCMP RSN_SELECTOR(0x00, 0x0f, 0xac, 4)
#define RSN_CIPHER_SUITE_WEP104 RSN_SELECTOR(0x00, 0x0f, 0xac, 5)
#define RSN_CIPHER_SUITE_AES_128_CMAC RSN_SELECTOR(0x00, 0x0f, 0xac, 6)
@@ -109,19 +106,14 @@
* GroupKey and PeerKey require encryption, otherwise, encryption is optional.
*/
#define RSN_KEY_DATA_GROUPKEY RSN_SELECTOR(0x00, 0x0f, 0xac, 1)
-#if 0
-#define RSN_KEY_DATA_STAKEY RSN_SELECTOR(0x00, 0x0f, 0xac, 2)
-#endif
#define RSN_KEY_DATA_MAC_ADDR RSN_SELECTOR(0x00, 0x0f, 0xac, 3)
#define RSN_KEY_DATA_PMKID RSN_SELECTOR(0x00, 0x0f, 0xac, 4)
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_PEERKEY
#define RSN_KEY_DATA_SMK RSN_SELECTOR(0x00, 0x0f, 0xac, 5)
#define RSN_KEY_DATA_NONCE RSN_SELECTOR(0x00, 0x0f, 0xac, 6)
#define RSN_KEY_DATA_LIFETIME RSN_SELECTOR(0x00, 0x0f, 0xac, 7)
#define RSN_KEY_DATA_ERROR RSN_SELECTOR(0x00, 0x0f, 0xac, 8)
#endif /* CONFIG_PEERKEY */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define RSN_KEY_DATA_IGTK RSN_SELECTOR(0x00, 0x0f, 0xac, 9)
#define RSN_KEY_DATA_KEYID RSN_SELECTOR(0x00, 0x0f, 0xac, 10)
#define RSN_KEY_DATA_MULTIBAND_GTK RSN_SELECTOR(0x00, 0x0f, 0xac, 11)
@@ -177,13 +169,6 @@
#define FT_R0KH_ID_MAX_LEN 48
#define FT_R1KH_ID_LEN 6
#define WPA_PMK_NAME_LEN 16
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
-/* CCX CCKM */
-#define CCKM_KRK_LEN 16 /* CCKM KRK length */
-#define CCKM_BTK_LEN 32 /* CCKM BTK length */
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* IEEE 802.11, 8.5.2 EAPOL-Key frames */
@@ -221,7 +206,6 @@
/* big endian 2-octet Key Data Length field */
/* followed by Key Data Length bytes of Key Data */
} STRUCT_PACKED;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
struct wpa_eapol_key_192 {
u8 type;
@@ -238,7 +222,6 @@
/* followed by key_data_length bytes of key_data */
} STRUCT_PACKED;
#endif /* CONFIG_BRCM_MERGES */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define WPA_EAPOL_KEY_MIC_MAX_LEN 32
#define WPA_KCK_MAX_LEN 32
@@ -333,7 +316,6 @@
} STRUCT_PACKED;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_PEERKEY
enum {
STK_MUI_4WAY_STA_AP = 1,
@@ -349,7 +331,6 @@
STK_ERR_NO_STSL = 4
};
#endif /* CONFIG_PEERKEY */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct rsn_error_kde {
be16 mui;
be16 error_type;
@@ -636,15 +617,9 @@
int wpa_write_ciphers(char *start, char *end, int ciphers, const char *delim);
int wpa_select_ap_group_cipher(int wpa, int wpa_pairwise, int rsn_pairwise);
unsigned int wpa_mic_len(int akmp, size_t pmk_len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
-unsigned int wpa_kck_len(int akmp, size_t pmk_len);
-unsigned int wpa_kek_len(int akmp, size_t pmk_len);
-#endif /* BRCM_CCX */
#ifdef BRCM_AFBT
int wpa_adaptive_fbt_update(u8 *rsn_ie, int rsn_ie_len);
#endif /* BRCM_AFBT */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int wpa_use_akm_defined(int akmp);
int wpa_use_cmac(int akmp);
int wpa_use_aes_key_wrap(int akmp);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.c b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.c
index b56b87a..7b7052c 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.c
@@ -25,14 +25,10 @@
#include <dirent.h>
#include <sys/stat.h>
#include <cutils/sockets.h>
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Generic android code available in all versions */
#include <grp.h>
#include <pwd.h>
#include <sys/types.h>
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#include "private/android_filesystem_config.h"
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* ANDROID */
#ifdef CONFIG_CTRL_IFACE_UDP_IPV6
@@ -107,14 +103,12 @@
size_t res;
int tries = 0;
int flags;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID
struct group *grp_wifi;
gid_t gid_wifi;
struct passwd *pwd_system;
uid_t uid_system;
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ctrl_path == NULL)
return NULL;
@@ -182,7 +176,6 @@
#ifdef ANDROID
/* Set group even if we do not have privileges to change owner */
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Generic android code available in all versions */
chmod(ctrl->local.sun_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
grp_wifi = getgrnam("wifi");
@@ -197,10 +190,6 @@
}
chown(ctrl->local.sun_path, -1, gid_wifi);
chown(ctrl->local.sun_path, uid_system, gid_wifi);
-#else /* CONFIG_DRIVER_NL80211_IFX */
- lchown(ctrl->local.sun_path, -1, AID_WIFI);
- lchown(ctrl->local.sun_path, AID_SYSTEM, AID_WIFI);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (os_strncmp(ctrl_path, "@android:", 9) == 0) {
if (socket_local_client_connect(
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.h b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.h
index e56c508..acc2d6c 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/common/wpa_ctrl.h
@@ -356,13 +356,6 @@
/* BSS Transition Management Response frame received */
#define BSS_TM_RESP "BSS-TM-RESP "
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
-#define TDLS_EVENT_PEER_FOUND "TDLS-PEER-FOUND "
-#define TDLS_PEER_CONNECTED "TDLS-PEER-CONNECTED "
-#define TDLS_PEER_DISCONNECTED "TDLS-PEER-DISCONNECTED "
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* Collocated Interference Request frame received;
* parameters: <dialog token> <automatic report enabled> <report timeout> */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_module_tests.c b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_module_tests.c
index fafb688..1aa0e22 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_module_tests.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_module_tests.c
@@ -1304,19 +1304,6 @@
},
20
},
-#if 0 /* This takes quite long to derive.. */
- {
- "password",
- "salt",
- 16777216,
- {
- 0xee, 0xfe, 0x3d, 0x61, 0xcd, 0x4d, 0xa4, 0xe4,
- 0xe9, 0x94, 0x5b, 0x3d, 0x6b, 0xa2, 0x15, 0x8c,
- 0x26, 0x34, 0xe9, 0x84
- },
- 20
- },
-#endif
{
"passwordPASSWORDpassword",
"saltSALTsaltSALTsaltSALTsaltSALTsalt",
@@ -1329,18 +1316,6 @@
},
25
},
-#if 0 /* \0 not currently supported in passphrase parameters.. */
- {
- "pass\0word",
- "sa\0lt",
- 4096,
- {
- 0x56, 0xfa, 0x6a, 0xa7, 0x55, 0x48, 0x09, 0x9d,
- 0xcc, 0x37, 0xd7, 0xf0, 0x34, 0x25, 0xe0, 0xc3
- },
- 16
- },
-#endif
};
#define NUM_RFC6070_TESTS ARRAY_SIZE(rfc6070_tests)
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_openssl.c b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_openssl.c
index eb3c4ca..ce75002 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_openssl.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_openssl.c
@@ -36,9 +36,8 @@
#include "aes_wrap.h"
#include "crypto.h"
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
/* Compatibility wrappers for older versions. */
static HMAC_CTX * HMAC_CTX_new(void)
@@ -81,7 +80,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef ABOVE_8_1
static EC_KEY * EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
{
@@ -90,22 +88,13 @@
return pkey->pkey.ec;
}
#endif /* ABOVE_8_1 */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-static EC_KEY * EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey)
-{
- if (pkey->type != EVP_PKEY_EC)
- return NULL;
- return pkey->pkey.ec;
-}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* OpenSSL version < 1.1.0 */
static BIGNUM * get_group5_prime(void)
{
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
- !(defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !(defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
return BN_get_rfc3526_prime_1536(NULL);
#elif !defined(OPENSSL_IS_BORINGSSL)
return get_rfc3526_prime_1536(NULL);
@@ -766,9 +755,8 @@
void * dh5_init(struct wpabuf **priv, struct wpabuf **publ)
{
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
DH *dh;
struct wpabuf *pubkey = NULL, *privkey = NULL;
size_t publen, privlen;
@@ -876,9 +864,8 @@
void * dh5_init_fixed(const struct wpabuf *priv, const struct wpabuf *publ)
{
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
DH *dh;
dh = DH_new();
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_wolfssl.c b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_wolfssl.c
index 2e4bf89..8ddea57 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_wolfssl.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/crypto_wolfssl.c
@@ -465,8 +465,7 @@
#endif /* CONFIG_NO_RC4 */
-#if defined(EAP_IKEV2) || defined(EAP_IKEV2_DYNAMIC) \
- || defined(EAP_SERVER_IKEV2)
+#if defined(EAP_IKEV2) || defined(EAP_IKEV2_DYNAMIC) || defined(EAP_SERVER_IKEV2)
union wolfssl_cipher {
Aes aes;
Des3 des3;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/random.c b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/random.c
index 165234e..0b15432 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/random.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/random.c
@@ -165,7 +165,7 @@
wpa_printf(MSG_MSGDUMP, "Get randomness: len=%u entropy=%u",
(unsigned int) len, entropy);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_USE_OPENSSL_RNG)
+#if defined(CONFIG_USE_OPENSSL_RNG)
/* Start with assumed strong randomness from OpenSSL */
ret = crypto_get_random(buf, len);
wpa_hexdump_key(MSG_EXCESSIVE, "random from crypto_get_random",
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls.h b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls.h
index 09fb73b..5c490a8 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls.h
@@ -561,15 +561,6 @@
int __must_check tls_get_cipher(void *tls_ctx, struct tls_connection *conn,
char *buf, size_t buflen);
-/**
- * tls_connection_enable_workaround - Enable TLS workaround options
- * @tls_ctx: TLS context data from tls_init()
- * @conn: Connection context data from tls_connection_init()
- * Returns: 0 on success, -1 on failure
- *
- * This function is used to enable connection-specific workaround options for
- * buffer SSL/TLS implementations.
- */
int __must_check tls_connection_enable_workaround(void *tls_ctx,
struct tls_connection *conn);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_openssl.c b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_openssl.c
index 90f5819..e74f38e 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_openssl.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_openssl.c
@@ -38,15 +38,13 @@
#include "tls.h"
#include "tls_openssl.h"
-#if !defined(CONFIG_FIPS) && \
- (defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || \
- defined(EAP_SERVER_FAST))
+#if !defined(CONFIG_FIPS) && (defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || \
+ defined(EAP_SERVER_FAST))
#define OPENSSL_NEED_EAP_FAST_PRF
#endif
-#if defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || \
- defined(EAP_SERVER_FAST) || defined(EAP_TEAP) || \
- defined(EAP_SERVER_TEAP)
+#if defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || defined(EAP_SERVER_FAST) || \
+ defined(EAP_TEAP) || defined(EAP_SERVER_TEAP)
#define EAP_FAST_OR_TEAP
#endif
@@ -65,10 +63,8 @@
#endif /* OPENSSL_NO_TLSEXT */
#endif /* SSL_set_tlsext_status_type */
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)) && \
- !defined(BORINGSSL_API_VERSION)
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)) && !defined(BORINGSSL_API_VERSION)
/*
* SSL_get_client_random() and SSL_get_server_random() were added in OpenSSL
* 1.1.0 and newer BoringSSL revisions. Provide compatibility wrappers for
@@ -111,9 +107,8 @@
#endif
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
#ifdef CONFIG_SUITEB
static int RSA_bits(const RSA *r)
{
@@ -988,9 +983,8 @@
}
#endif /* OPENSSL_FIPS */
#endif /* CONFIG_FIPS */
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
SSL_load_error_strings();
SSL_library_init();
#ifndef OPENSSL_NO_SHA256
@@ -1124,9 +1118,8 @@
tls_openssl_ref_count--;
if (tls_openssl_ref_count == 0) {
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
#ifndef OPENSSL_NO_ENGINE
ENGINE_cleanup();
#endif /* OPENSSL_NO_ENGINE */
@@ -3014,8 +3007,7 @@
}
}
#endif /* >= 1.1.0 */
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
- !defined(LIBRESSL_VERSION_NUMBER) && \
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER) && \
!defined(OPENSSL_IS_BORINGSSL)
if ((flags & (TLS_CONN_ENABLE_TLSv1_0 | TLS_CONN_ENABLE_TLSv1_1)) &&
SSL_get_security_level(ssl) >= 2) {
@@ -3161,8 +3153,7 @@
#endif
static const char *cs = TEAP_DH_ANON_CS;
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
- !defined(LIBRESSL_VERSION_NUMBER) && \
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER) && \
!defined(OPENSSL_IS_BORINGSSL)
/*
* Need to drop to security level 0 to allow anonymous
@@ -3280,7 +3271,6 @@
return -1;
}
X509_free(x509);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(OPENSSL_IS_BORINGSSL)
wpa_printf(MSG_DEBUG,
"OpenSSL: Found PEM encoded certificate from blob");
@@ -3290,19 +3280,6 @@
SSL_add0_chain_cert(conn->ssl, x509);
}
#endif /* OPENSSL_IS_BORINGSSL */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#if 0
- /* To fix compilation issue, disable below part of code
- * when CONFIG_DRIVER_NL80211_IFX disabled */
- wpa_printf(MSG_DEBUG,
- "OpenSSL: Found PEM encoded certificate from blob");
- while ((x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL))) {
- wpa_printf(MSG_DEBUG,
- "OpenSSL: Added an additional certificate into the chain");
- SSL_add0_chain_cert(conn->ssl, x509);
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
BIO_free(bio);
return 0;
#endif
@@ -3325,7 +3302,6 @@
X509_free(x509);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(OPENSSL_IS_BORINGSSL)
/* Read additional certificates into the chain. */
while (bio) {
@@ -3339,23 +3315,6 @@
}
}
#endif
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#if 0
- /* To fix compilation issue, disable below part of code
- * when CONFIG_DRIVER_NL80211_IFX disabled */
- /* Read additional certificates into the chain. */
- while (bio) {
- x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
- if (x509) {
- /* Takes ownership of x509 */
- SSL_add0_chain_cert(conn->ssl, x509);
- } else {
- BIO_free(bio);
- bio = NULL;
- }
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return ret;
}
#endif /* ANDROID */
@@ -3368,8 +3327,8 @@
return 0;
}
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
- !defined(LIBRESSL_VERSION_NUMBER) && !defined(OPENSSL_IS_BORINGSSL)
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER) && \
+ !defined(OPENSSL_IS_BORINGSSL)
if (SSL_use_certificate_chain_file(conn->ssl, client_cert) == 1) {
ERR_clear_error();
wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_certificate_chain_file"
@@ -4111,9 +4070,8 @@
#ifdef OPENSSL_NEED_EAP_FAST_PRF
static int openssl_get_keyblock_size(SSL *ssl)
{
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
const EVP_CIPHER *c;
const EVP_MD *h;
int md_size;
@@ -5240,8 +5198,7 @@
if (!params->openssl_ecdh_curves) {
#ifndef OPENSSL_IS_BORINGSSL
#ifndef OPENSSL_NO_EC
-#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && \
- (OPENSSL_VERSION_NUMBER < 0x10100000L)
+#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && (OPENSSL_VERSION_NUMBER < 0x10100000L)
if (SSL_set_ecdh_auto(conn->ssl, 1) != 1) {
wpa_printf(MSG_INFO,
"OpenSSL: Failed to set ECDH curves to auto");
@@ -5464,8 +5421,7 @@
if (!params->openssl_ecdh_curves) {
#ifndef OPENSSL_IS_BORINGSSL
#ifndef OPENSSL_NO_EC
-#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && \
- (OPENSSL_VERSION_NUMBER < 0x10100000L)
+#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) && (OPENSSL_VERSION_NUMBER < 0x10100000L)
if (SSL_CTX_set_ecdh_auto(ssl_ctx, 1) != 1) {
wpa_printf(MSG_INFO,
"OpenSSL: Failed to set ECDH curves to auto");
@@ -5528,7 +5484,8 @@
* commented out unless explicitly needed for EAP-FAST in order to be able to
* build this file with unmodified openssl. */
-#if (defined(OPENSSL_IS_BORINGSSL) || OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
+#if (defined(OPENSSL_IS_BORINGSSL) || OPENSSL_VERSION_NUMBER >= 0x10100000L) && \
+ !defined(LIBRESSL_VERSION_NUMBER)
static int tls_sess_sec_cb(SSL *s, void *secret, int *secret_len,
STACK_OF(SSL_CIPHER) *peer_ciphers,
const SSL_CIPHER **cipher, void *arg)
@@ -5541,9 +5498,8 @@
struct tls_connection *conn = arg;
int ret;
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
- (defined(LIBRESSL_VERSION_NUMBER) && \
- LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || (defined(LIBRESSL_VERSION_NUMBER) && \
+ LIBRESSL_VERSION_NUMBER < 0x20700000L)
if (conn == NULL || conn->session_ticket_cb == NULL)
return 0;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_wolfssl.c b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_wolfssl.c
index b8a7665..8090957 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_wolfssl.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/crypto/tls_wolfssl.c
@@ -26,9 +26,8 @@
#include <wolfssl/wolfcrypt/aes.h>
#endif
-#if !defined(CONFIG_FIPS) && \
- (defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || \
- defined(EAP_SERVER_FAST))
+#if !defined(CONFIG_FIPS) && (defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || \
+ defined(EAP_SERVER_FAST))
#define WOLFSSL_NEED_EAP_FAST_PRF
#endif
@@ -277,16 +276,6 @@
int tls_get_errors(void *tls_ctx)
{
#ifdef DEBUG_WOLFSSL
-#if 0
- unsigned long err;
-
- err = wolfSSL_ERR_peek_last_error_line(NULL, NULL);
- if (err != 0) {
- wpa_printf(MSG_INFO, "TLS - SSL error: %s",
- wolfSSL_ERR_error_string(err, NULL));
- return 1;
- }
-#endif
#endif /* DEBUG_WOLFSSL */
return 0;
}
@@ -1238,10 +1227,6 @@
static void tls_set_conn_flags(WOLFSSL *ssl, unsigned int flags)
{
#ifdef HAVE_SESSION_TICKET
-#if 0
- if (!(flags & TLS_CONN_DISABLE_SESSION_TICKET))
- wolfSSL_UseSessionTicket(ssl);
-#endif
#endif /* HAVE_SESSION_TICKET */
if (flags & TLS_CONN_DISABLE_TLSv1_0)
@@ -1324,7 +1309,7 @@
}
#endif /* HAVE_CERTIFICATE_STATUS_REQUEST_V2 */
#if !defined(HAVE_CERTIFICATE_STATUS_REQUEST) && \
- !defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
+ !defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
#ifdef HAVE_OCSP
if (params->flags & TLS_CONN_REQUEST_OCSP)
wolfSSL_CTX_EnableOCSP(ctx, 0);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver.h b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver.h
index 6759b5e..727c836 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver.h
@@ -79,11 +79,9 @@
#define HOSTAPD_DFS_REGION_ETSI 2
#define HOSTAPD_DFS_REGION_JP 3
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
#define MAX_PASSPHRASE_LEN 63
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* enum reg_change_initiator - Regulatory change initiator
*/
@@ -318,11 +316,6 @@
#define IEEE80211_CAP_DMG_PBSS 0x0002 /* Tx by: PCP */
#define IEEE80211_CAP_DMG_AP 0x0003 /* Tx by: AP */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#define SSID_MAX_WAPI_IE_LEN 100
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define WPA_SCAN_QUAL_INVALID BIT(0)
#define WPA_SCAN_NOISE_INVALID BIT(1)
#define WPA_SCAN_LEVEL_INVALID BIT(2)
@@ -381,12 +374,6 @@
u64 parent_tsf;
u8 tsf_bssid[ETH_ALEN];
size_t ie_len;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- u8 wapi_ie[SSID_MAX_WAPI_IE_LEN];
- size_t wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
size_t beacon_ie_len;
/* Followed by ie_len + beacon_ie_len octets of IE data */
};
@@ -1070,12 +1057,6 @@
* STA mode: bits 0..3 UAPSD enabled for VO,VI,BK,BE
*/
int uapsd;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- const u8 *ap_wapi_ie;
- size_t ap_wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* fixed_bssid - Whether to force this BSSID in IBSS mode
@@ -1554,13 +1535,14 @@
* 2 = both hunting-and-pecking loop and hash-to-element enabled
*/
int sae_pwe;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
u8 sae_passphrase[MAX_PASSPHRASE_LEN];
u8 sae_passphrase_len;
#endif /* CONFIG_BRCM_SAE */
-#else /* CONFIG_DRIVER_NL80211_IFX */
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
/**
* passphrase - RSN passphrase for PSK
*
@@ -1589,7 +1571,6 @@
* for drivers that set WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP.
*/
const char *sae_password;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
struct wpa_driver_mesh_bss_params {
@@ -1821,12 +1802,6 @@
#define WPA_DRIVER_CAPA_KEY_MGMT_FT 0x00000020
#define WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK 0x00000040
#define WPA_DRIVER_CAPA_KEY_MGMT_WAPI_PSK 0x00000080
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
-#define WPA_DRIVER_CAPA_KEY_MGMT_WPA_CCKM 0x00000080
-#define WPA_DRIVER_CAPA_KEY_MGMT_WPA2_CCKM 0x00000100
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B 0x00000100
#define WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B_192 0x00000200
#define WPA_DRIVER_CAPA_KEY_MGMT_OWE 0x00000400
@@ -2024,12 +1999,13 @@
#define WPA_DRIVER_FLAGS2_CONTROL_PORT_TX_STATUS 0x0000000000000002ULL
/** Driver supports SAE authentication offload in station mode */
#define WPA_DRIVER_FLAGS2_SAE_OFFLOAD 0x0000000000000004ULL
-#ifndef CONFIG_DRIVER_NL80211_IFX
+/* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
/** Driver supports 4-way handshake offload for WPA-Personal in AP mode */
#define WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK 0x0000000000000008ULL
/** Driver supports SAE authentication offload in AP mode */
#define WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP 0x0000000000000010ULL
-#endif /* CONFIG_DRIVER_NL80211_IFX */
u64 flags2;
#define FULL_AP_CLIENT_STATE_SUPP(drv_flags) \
@@ -2578,12 +2554,6 @@
* string.
*/
int (*get_ssid)(void *priv, u8 *ssid);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- int (*set_wpa_ie)(void *priv, const u8 *wpa_ie, size_t wpa_ie_len);
- int (*set_wapi)(void *priv, int enabled);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* set_key - Configure encryption key
@@ -3123,29 +3093,6 @@
int (*read_sta_data)(void *priv, struct hostap_sta_driver_data *data,
const u8 *addr);
- /**
- * tx_control_port - Send a frame over the 802.1X controlled port
- * @priv: Private driver interface data
- * @dest: Destination MAC address
- * @proto: Ethertype in host byte order
- * @buf: Frame payload starting from IEEE 802.1X header
- * @len: Frame payload length
- * @no_encrypt: Do not encrypt frame
- *
- * Returns 0 on success, else an error
- *
- * This is like a normal Ethernet send except that the driver is aware
- * (by other means than the Ethertype) that this frame is special,
- * and more importantly it gains an ordering between the transmission of
- * the frame and other driver management operations such as key
- * installations. This can be used to work around known limitations in
- * IEEE 802.11 protocols such as race conditions between rekeying 4-way
- * handshake message 4/4 and a PTK being overwritten.
- *
- * This function is only used for a given interface if the driver
- * instance reports WPA_DRIVER_FLAGS_CONTROL_PORT capability. Otherwise,
- * API users will fall back to sending the frame via a normal socket.
- */
int (*tx_control_port)(void *priv, const u8 *dest,
u16 proto, const u8 *buf, size_t len,
int no_encrypt);
@@ -3810,7 +3757,6 @@
*/
int (*set_authmode)(void *priv, int authmode);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
/**
* driver_cmd - Execute driver-specific command
@@ -3822,19 +3768,6 @@
*/
int (*driver_cmd)(void *priv, char *cmd, char *buf, size_t buf_len);
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
- /**
- * driver_cmd - Execute driver-specific command
- * @priv: Private driver interface data
- * @cmd: Command to execute
- * @buf: Return buffer
- * @buf_len: Buffer length
- * Returns: 0 on success, -1 on failure
- */
- int (*driver_cmd)(void *priv, char *cmd, char *buf, size_t buf_len);
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* vendor_cmd - Execute vendor specific command
@@ -5044,11 +4977,6 @@
*/
EVENT_AVOID_FREQUENCIES,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- EVENT_AUTH_WAPI_ENABLE,
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* EVENT_NEW_PEER_CANDIDATE - new (unknown) mesh peer notification
*/
@@ -5148,7 +5076,6 @@
* is required to provide more details of the frame.
*/
EVENT_UNPROT_BEACON,
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
/**
* EVENT_SAE_KEY - carries the pmk data after SAE auth is done
@@ -5156,7 +5083,6 @@
*/
EVENT_SAE_KEY,
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
@@ -5226,7 +5152,6 @@
* union wpa_event_data - Additional data for wpa_supplicant_event() calls
*/
union wpa_event_data {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
/* struct for sae key info for in-driver sae auth */
struct sae_key {
@@ -5236,7 +5161,6 @@
u8 pmkid[PMKID_LEN];
} sae_key_info;
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* struct assoc_info - Data for EVENT_ASSOC and EVENT_ASSOCINFO events
*
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_atheros.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_atheros.c
index 9b4166d..ebaca44 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_atheros.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_atheros.c
@@ -391,7 +391,6 @@
wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, params->enabled);
if (!params->enabled) {
- /* XXX restore state */
if (set80211param(priv, IEEE80211_PARAM_AUTHMODE,
IEEE80211_AUTH_AUTO) < 0)
return -1;
@@ -1527,7 +1526,7 @@
return;
buf = os_malloc(iwe->u.data.length + 1);
if (buf == NULL)
- return; /* XXX */
+ return;
os_memcpy(buf, custom, iwe->u.data.length);
buf[iwe->u.data.length] = '\0';
@@ -1939,7 +1938,8 @@
wpa_hexdump_buf(MSG_DEBUG, "atheros: assocresp_ies",
params->assocresp_ies);
-#if defined(CONFIG_HS20) && (defined(IEEE80211_PARAM_OSEN) || defined(CONFIG_ATHEROS_OSEN))
+#if defined(CONFIG_HS20) && (defined(IEEE80211_PARAM_OSEN) || \
+ defined(CONFIG_ATHEROS_OSEN))
if (params->osen) {
struct wpa_bss_params bss_params;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_bsd.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_bsd.c
index a29d2c8..4123941 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_bsd.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_bsd.c
@@ -272,7 +272,7 @@
wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__,
MAC2STR(addr));
os_memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN);
- wk.idk_keyix = (u_int8_t) IEEE80211_KEYIX_NONE; /* XXX */
+ wk.idk_keyix = (u_int8_t) IEEE80211_KEYIX_NONE;
}
return set80211var(priv, IEEE80211_IOC_DELKEY, &wk, sizeof(wk));
@@ -503,7 +503,6 @@
wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, params->enabled);
if (!params->enabled) {
- /* XXX restore state */
return set80211param(priv, IEEE80211_IOC_AUTHMODE,
IEEE80211_AUTH_AUTO);
}
@@ -856,7 +855,6 @@
memcpy(stats.is_u.macaddr, addr, IEEE80211_ADDR_LEN);
if (get80211var(priv, IEEE80211_IOC_STA_STATS, &stats, sizeof(stats))
> 0) {
- /* XXX? do packets counts include non-data frames? */
data->rx_packets = stats.is_stats.ns_rx_data;
data->rx_bytes = stats.is_stats.ns_rx_bytes;
data->tx_packets = stats.is_stats.ns_tx_data;
@@ -1141,7 +1139,6 @@
ret = -1;
if (wpa_driver_bsd_set_auth_alg(drv, params->auth_alg) < 0)
ret = -1;
- /* XXX error handling is wrong but unclear what to do... */
if (wpa_driver_bsd_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len) < 0)
return -1;
@@ -1214,11 +1211,6 @@
sr.sr_duration = IEEE80211_IOC_SCAN_FOREVER;
if (params->num_ssids > 0) {
sr.sr_nssid = params->num_ssids;
-#if 0
- /* Boundary check is done by upper layer */
- if (sr.sr_nssid > IEEE80211_IOC_SCAN_MAX_SSID)
- sr.sr_nssid = IEEE80211_IOC_SCAN_MAX_SSID;
-#endif
/* NB: check scan cache first */
sr.sr_flags |= IEEE80211_IOC_SCAN_CHECK;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_common.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_common.c
index df537c7..e761f83 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_common.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_common.c
@@ -70,11 +70,9 @@
E2S(CH_SWITCH_STARTED);
E2S(WNM);
E2S(CONNECT_FAILED_REASON);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
E2S(SAE_KEY);
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
E2S(DFS_RADAR_DETECTED);
E2S(DFS_CAC_FINISHED);
E2S(DFS_CAC_ABORTED);
@@ -82,11 +80,6 @@
E2S(SURVEY);
E2S(SCAN_STARTED);
E2S(AVOID_FREQUENCIES);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- E2S(AUTH_WAPI_ENABLE);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
E2S(NEW_PEER_CANDIDATE);
E2S(ACS_CHANNEL_SELECTED);
E2S(DFS_CAC_STARTED);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_ndis.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_ndis.c
index b5fff48..082ad05 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_ndis.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_ndis.c
@@ -946,10 +946,6 @@
wep->KeyIndex = key_idx;
if (set_tx)
wep->KeyIndex |= 1 << 31;
-#if 0 /* Setting bit30 does not seem to work with some NDIS drivers */
- if (pairwise)
- wep->KeyIndex |= 1 << 30;
-#endif
wep->KeyLength = key_len;
os_memcpy(wep->KeyMaterial, key, key_len);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.c
index 5b787d6..ed11723 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.c
@@ -9,11 +9,6 @@
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_FEATURES_COPYRIGHT
-/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "includes.h"
#include <sys/types.h>
@@ -32,11 +27,9 @@
#include "eloop.h"
#include "common/qca-vendor.h"
#include "common/qca-vendor-attr.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID_P2P
#include "common/brcm_vendor.h"
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "common/ieee802_11_defs.h"
#include "common/ieee802_11_common.h"
#include "common/wpa_common.h"
@@ -48,23 +41,9 @@
#include "rfkill.h"
#include "driver_nl80211.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "../../wpa_supplicant/wpa_supplicant_i.h"
-#endif /* WAPI */
-#ifdef WAPI_AP
-#include "ap/hostapd.h"
-#endif
-#ifdef WAPI
-#include "wapi_asue.h"
-#include "wapi.h"
-#define IW_ENCODE_ALG_SM4 0x20
-#define IW_ENCODE_SEQ_MAX_SIZE 8
-#endif /* WAPI */
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
#include "android_drv.h"
#endif /* ANDROID || BCM_LINUX_BUILD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifndef NETLINK_CAP_ACK
#define NETLINK_CAP_ACK 10
@@ -98,11 +77,9 @@
#undef nl_socket_set_nonblocking
#define nl_socket_set_nonblocking(h) android_nl_socket_set_nonblocking(h)
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef ANDROID_P2P
#define genl_ctrl_resolve android_genl_ctrl_resolve
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* ANDROID */
@@ -143,7 +120,6 @@
#define ELOOP_SOCKET_INVALID (intptr_t) 0x88888889ULL
#endif
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID_P2P
#ifdef ANDROID_P2P_STUB
int wpa_driver_priv_lib_init(struct nl80211_global *global) {
@@ -157,7 +133,6 @@
int wpa_driver_priv_lib_deinit(struct nl80211_global *global);
#endif /* ANDROID_P2P_STUB */
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void nl80211_register_eloop_read(struct nl_sock **handle,
eloop_sock_handler handler,
void *eloop_data, int persist)
@@ -624,13 +599,9 @@
}
-#if defined(CONFIG_DRIVER_NL80211_IFX)
/* TODO: Need to guard this under BCM_GENL and
* fix libbcmdhd android compilations issues */
int nl_get_multicast_id(struct nl80211_global *global,
-#else
-static int nl_get_multicast_id(struct nl80211_global *global,
-#endif /* CONFIG_DRIVER_NL80211_IFX */
const char *family, const char *group)
{
struct nl_msg *msg;
@@ -2187,11 +2158,6 @@
struct wpa_driver_nl80211_data *drv;
struct i802_bss *bss;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)ctx;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (global_priv == NULL)
return NULL;
drv = os_zalloc(sizeof(*drv));
@@ -2222,19 +2188,9 @@
bss->ctx = ctx;
os_strlcpy(bss->ifname, ifname, sizeof(bss->ifname));
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- os_strlcpy(drv->ifname, ifname, sizeof(bss->ifname));
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
drv->monitor_ifidx = -1;
drv->monitor_sock = -1;
drv->eapol_tx_sock = -1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- drv->wapi_tx_sock = -1;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
if (nl80211_init_bss(bss))
@@ -2252,23 +2208,6 @@
if (drv->eapol_tx_sock < 0)
goto failed;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- wpa_printf(MSG_INFO, "%s: Creating wapi_tx_sock\n", __FUNCTION__);
- drv->wapi_tx_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
- if (drv->wapi_tx_sock < 0){
- wpa_printf(MSG_ERROR, "%s: Creating wapi_tx_sock failed\n", __FUNCTION__);
- goto failed;
- }
- if (hostapd) {
- brcm_wapiap_initialize(ctx, drv->wapi_tx_sock, bss);
- }
- else {
- wpa_s->wapi_tx_sock = drv->wapi_tx_sock;
- wpa_s->wapi_bss = bss;
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (drv->data_tx_status) {
int enabled = 1;
@@ -2290,23 +2229,6 @@
}
skip_wifi_status:
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- drv->wapi_sock = socket(PF_PACKET, SOCK_DGRAM, htons(ETHER_TYPE_WAI));
- if (drv->wapi_sock < 0) {
- wpa_printf(MSG_ERROR, "%s nl80211: socket(PF_PACKET,"
- "SOCK_DGRAM, ) failed: %s", __FUNCTION__,
- strerror(errno));
- goto failed;
- }
- if (eloop_register_read_sock(drv->wapi_sock, handle_wapi, drv, NULL))
- {
- wpa_printf(MSG_ERROR, "%s nl80211: Could not register "
- "read socket for wapi", __FUNCTION__);
- goto failed;
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (drv->global) {
nl80211_check_global(drv->global);
dl_list_add(&drv->global->interfaces, &drv->list);
@@ -2726,7 +2648,6 @@
false) < 0)
wpa_printf(MSG_DEBUG,
"nl80211: Failed to subscribe to handle Authentication frames - SAE offload may not work");
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CY_AP_RX_MGMT_DISCONNECT
type = (WLAN_FC_TYPE_MGMT << 2) | (WLAN_FC_STYPE_DISASSOC << 4);
if (nl80211_register_frame(bss, bss->nl_mgmt, type, NULL, 0)
@@ -2734,7 +2655,6 @@
wpa_printf(MSG_DEBUG,
"nl80211: Failed to subscribe to handle Disassociation frames");
#endif /* CONFIG_CY_AP_RX_MGMT_DISCONNECT */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
nl80211_mgmt_handle_register_eloop(bss);
@@ -3007,17 +2927,6 @@
if (drv->eapol_tx_sock >= 0)
close(drv->eapol_tx_sock);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (drv->wapi_tx_sock >= 0)
- close(drv->wapi_tx_sock);
-
- if (drv->wapi_sock >= 0) {
- eloop_unregister_read_sock(drv->wapi_sock);
- close(drv->wapi_sock);
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (bss->nl_preq)
wpa_driver_nl80211_probe_req_report(bss, 0);
if (bss->added_if_into_bridge) {
@@ -3139,23 +3048,14 @@
return RSN_CIPHER_SUITE_BIP_CMAC_256;
case WPA_ALG_SMS4:
return RSN_CIPHER_SUITE_SMS4;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- case WAPI_ALG_SMS4:
- wpa_printf(MSG_DEBUG, "%s: WAPI_ALG_SMS4\n", __func__);
- return RSN_CIPHER_SUITE_SMS4;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case WPA_ALG_KRK:
return RSN_CIPHER_SUITE_KRK;
case WPA_ALG_NONE:
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(IEEE8021X_EAPOL) && defined(BRCM_VE)
wpa_printf(MSG_DEBUG, "nl80211: Selected encryption algorithm "
"WPA_ALG_PMK");
return WLAN_CIPHER_SUITE_PMK;
#endif /* IEEE8021X_EAPOL && BRCM_VE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_printf(MSG_ERROR, "nl80211: Unexpected encryption algorithm %d",
alg);
return 0;
@@ -3186,12 +3086,6 @@
return RSN_CIPHER_SUITE_WEP40;
case WPA_CIPHER_GTK_NOT_USED:
return RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- case WPA_CIPHER_SMS4:
- return RSN_CIPHER_SUITE_SMS4;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
return 0;
@@ -3218,12 +3112,6 @@
if (num_suites < max_suites && ciphers & WPA_CIPHER_WEP40)
suites[num_suites++] = RSN_CIPHER_SUITE_WEP40;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (num_suites < max_suites && ciphers & WPA_CIPHER_SMS4)
- suites[num_suites++] = RSN_CIPHER_SUITE_SMS4;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return num_suites;
}
@@ -3239,15 +3127,10 @@
suites[num_suites++] = (RSN_AUTH_KEY_MGMT_ ## b)
__AKM(IEEE8021X, UNSPEC_802_1X);
__AKM(PSK, PSK_OVER_802_1X);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_VE
__AKM(FT_IEEE8021X, FT_802_1X);
__AKM(FT_PSK, FT_PSK);
#endif /* BRCM_VE */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- __AKM(FT_IEEE8021X, FT_802_1X);
- __AKM(FT_PSK, FT_PSK);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
__AKM(IEEE8021X_SHA256, 802_1X_SHA256);
__AKM(PSK_SHA256, PSK_SHA256);
__AKM(SAE, SAE);
@@ -3264,12 +3147,6 @@
__AKM(DPP, DPP);
__AKM(FT_IEEE8021X_SHA384, FT_802_1X_SHA384);
#undef __AKM
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (num_suites < max_suites && (key_mgmt_suites & WPA_KEY_MGMT_WAPI_PSK))
- suites[num_suites++] = WLAN_AKM_SUITE_WAPI_PSK;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return num_suites;
}
@@ -3305,7 +3182,6 @@
}
#endif /* CONFIG_DRIVER_NL80211_QCA */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_DRIVER_NL80211_BRCM
static int key_mgmt_set_key(struct wpa_driver_nl80211_data *drv,
const u8 *key, size_t key_len)
@@ -3390,7 +3266,6 @@
return ret;
}
#endif /* BRCM_VE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int nl80211_set_pmk(struct wpa_driver_nl80211_data *drv,
const u8 *key, size_t key_len,
@@ -3466,18 +3341,6 @@
return -EINVAL;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if ( (alg == WAPI_ALG_SMS4) && (seq_len > IW_ENCODE_SEQ_MAX_SIZE * 2) ) {
- wpa_printf(MSG_ERROR, "%s: Invalid seq_len for WAPI_ALG_SMS4 %lu",
- __FUNCTION__, (unsigned long) seq_len);
- return -1;
- } else if ( (alg != WAPI_ALG_SMS4) && (seq_len > IW_ENCODE_SEQ_MAX_SIZE) ) {
- wpa_printf(MSG_ERROR, "%s: Invalid seq_len %lu",
- __FUNCTION__, (unsigned long) seq_len);
- return -1;
- }
-#endif /* WAPI */
#ifdef CONFIG_DRIVER_NL80211_BRCM
if (key_flag == KEY_FLAG_PMK &&
@@ -3500,7 +3363,6 @@
}
}
#endif /* BRCM_VE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DRIVER_NL80211_QCA
if ((key_flag & KEY_FLAG_PMK) &&
(drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD)) {
@@ -3558,11 +3420,7 @@
goto fail;
wpa_hexdump_key(MSG_DEBUG, "nl80211: KEY_DATA", key, key_len);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if ((seq && seq_len) && (alg != WAPI_ALG_SMS4)) {
-#else
if (seq && seq_len) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
if (nla_put(key_msg, NL80211_KEY_SEQ, seq_len, seq))
goto fail;
wpa_hexdump(MSG_DEBUG, "nl80211: KEY_SEQ",
@@ -3575,14 +3433,10 @@
if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
goto fail;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (alg != WPA_ALG_WEP && key_idx && !set_tx && alg != WAPI_ALG_SMS4) {
-#else
if ((key_flag & KEY_FLAG_PAIRWISE_MASK) ==
KEY_FLAG_PAIRWISE_RX ||
(key_flag & KEY_FLAG_PAIRWISE_MASK) ==
KEY_FLAG_PAIRWISE_RX_TX_MODIFY) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
if (nla_put_u8(key_msg, NL80211_KEY_MODE,
key_flag == KEY_FLAG_PAIRWISE_RX ?
NL80211_KEY_NO_TX : NL80211_KEY_SET_TX))
@@ -4076,11 +3930,6 @@
count++;
if ((ret == -EALREADY || ret == -EEXIST) && count == 1 &&
params->bssid && !params->local_state_change) {
- /*
- * mac80211 does not currently accept new
- * authentication if we are already authenticated. As a
- * workaround, force deauthentication and try again.
- */
wpa_printf(MSG_DEBUG, "nl80211: Retry authentication "
"after forced deauthentication");
drv->ignore_deauth_event = 1;
@@ -4594,7 +4443,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
static int nl80211_set_conn_sae_keys(struct wpa_driver_nl80211_data *drv,
const char *key, size_t key_len)
@@ -4640,7 +4488,6 @@
return ret;
}
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_SAE
static int nl80211_put_sae_pwe(struct nl_msg *msg, int pwe)
@@ -4692,7 +4539,6 @@
!nl80211_get_wiphy_data_ap(bss))
return -ENOBUFS;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
if (params->key_mgmt_suites & WPA_KEY_MGMT_SAE) {
wpa_hexdump_key(MSG_DEBUG, "Set passpharse :",
@@ -4700,7 +4546,6 @@
nl80211_set_conn_sae_ap_keys(drv, params);
}
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_hexdump(MSG_DEBUG, "nl80211: Beacon head",
params->head, params->head_len);
wpa_hexdump(MSG_DEBUG, "nl80211: Beacon tail",
@@ -4771,18 +4616,8 @@
ver = 0;
if (params->wpa_version & WPA_PROTO_WPA)
ver |= NL80211_WPA_VERSION_1;
-#ifndef CONFIG_DRIVER_NL80211_IFX
- if (params->wpa_version & WPA_PROTO_RSN) {
- ver |= NL80211_WPA_VERSION_2;
-#ifdef CONFIG_SAE
- if (params->key_mgmt_suites & WPA_KEY_MGMT_SAE)
- ver |= NL80211_WPA_VERSION_3;
-#endif /* CONFIG_SAE */
- }
-#else /* CONFIG_DRIVER_NL80211_IFX */
if (params->wpa_version & WPA_PROTO_RSN)
ver |= NL80211_WPA_VERSION_2;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ver &&
nla_put_u32(msg, NL80211_ATTR_WPA_VERSIONS, ver))
goto fail;
@@ -4800,11 +4635,6 @@
suites))
goto fail;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (!(params->key_mgmt_suites & WPA_KEY_MGMT_WAPI_PSK)) {
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (params->key_mgmt_suites & WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
(!params->pairwise_ciphers ||
params->pairwise_ciphers & (WPA_CIPHER_WEP104 | WPA_CIPHER_WEP40)) &&
@@ -4832,21 +4662,10 @@
if (suite &&
nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP, suite))
goto fail;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- }
- else {
- suites[0] = RSN_CIPHER_SUITE_SMS4;
- num_suites = 1;
- nla_put(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE,
- num_suites * sizeof(u32), suites);
- nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP, RSN_CIPHER_SUITE_SMS4);
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
-#ifndef CONFIG_DRIVER_NL80211_IFX
- /* Add PSK in case of 4-way handshake offload */
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK. Add PSK in case of 4-way handshake offload
+ */
if (params->psk &&
(drv->capa.flags2 & WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK)) {
wpa_hexdump_key(MSG_DEBUG, "nl80211: PSK", params->psk, 32);
@@ -4874,7 +4693,6 @@
goto fail;
}
#endif /* CONFIG_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (params->beacon_ies) {
wpa_hexdump_buf(MSG_DEBUG, "nl80211: beacon_ies",
@@ -5150,7 +4968,6 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
/*
* TODO: Remove this after resolution of kernel cfg set channel width
* prohibited flags issue
@@ -5203,7 +5020,6 @@
return 0;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int nl80211_set_channel(struct i802_bss *bss,
struct hostapd_freq_params *freq, int set_chan)
@@ -6302,23 +6118,6 @@
{
if (nla_put_flag(msg, NL80211_ATTR_IFACE_SOCKET_OWNER))
return -1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- struct wpa_supplicant *wpa_s = drv->ctx;
- int wapi_ie_present = 0;
- if(drv->ap_wapi_ie_len && drv->ap_wapi_ie) {
- wpa_printf(MSG_ERROR, "%s : Set wpa_s->ap_wapi_ie and "
- "wpa_s->ap_wapi_ie_len\n",__func__);
- memcpy(wpa_s->ap_wapi_ie, drv->ap_wapi_ie, drv->ap_wapi_ie_len);
- wpa_s->ap_wapi_ie_len = drv->ap_wapi_ie_len;
- }
-
- if (params->wpa_ie_len && params->wpa_ie && (params->wpa_ie[0] == WLAN_EID_WAPI)) {
- wapi_ie_present = 1;
- wpa_printf(MSG_ERROR, " * ## WAPI element ID present in IE\n");
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (params->bssid) {
wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
@@ -6384,18 +6183,6 @@
}
wpa_hexdump(MSG_DEBUG, " * IEs", params->wpa_ie, params->wpa_ie_len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- wpa_printf(MSG_DEBUG, "%s: params->wpa_ie_len=%d\n", __FUNCTION__, (int)params->wpa_ie_len);
- if (wapi_ie_present) {
- wpa_printf(MSG_DEBUG, "%s: params->wpa_ie: [%02x][%02x][%02x][%02x]\n",
- __FUNCTION__, params->wpa_ie[0], params->wpa_ie[1], params->wpa_ie[2], params->wpa_ie[3]);
- wpa_printf(MSG_DEBUG, "params->wpa_ie[0] == WLAN_EID_WAPI\n");
- drv->ap_wapi_ie = params->ap_wapi_ie ;
- drv->ap_wapi_ie_len = params->ap_wapi_ie_len ;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (params->wpa_ie &&
nla_put(msg, NL80211_ATTR_IE, params->wpa_ie_len, params->wpa_ie))
return -1;
@@ -6417,55 +6204,15 @@
if (nla_put_u32(msg, NL80211_ATTR_WPA_VERSIONS, ver))
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else if (params->wpa_ie && params->wpa_ie[0] == WLAN_EID_WAPI) {
- wpa_printf(MSG_ERROR, "## its EID_WAPI\n");
- wpa_printf(MSG_DEBUG, " * NO params->wpa_ie && params->wpa_ie_len");
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (params->pairwise_suite != WPA_CIPHER_NONE) {
u32 cipher = wpa_cipher_to_cipher_suite(params->pairwise_suite);
wpa_printf(MSG_DEBUG, " * pairwise=0x%x", cipher);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (wapi_ie_present) { /* wapi */
- wpa_printf(MSG_DEBUG, " * Set SUITES_PAIRWISE to RSN_CIPHER_SUITE_SMS4");
- cipher = RSN_CIPHER_SUITE_SMS4;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE,
cipher))
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else {
-
- if (params->wpa_ie && params->wpa_ie[0] == WLAN_EID_WAPI) { /* wapi */
- int cipher;
- wpa_printf(MSG_DEBUG, " * Set SUITES_PAIRWISE to RSN_CIPHER_SUITE_SMS4");
- cipher = RSN_CIPHER_SUITE_SMS4;
-
- params->pairwise_suite = RSN_CIPHER_SUITE_SMS4;
-
- nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE, cipher);
-
- }
- wpa_printf(MSG_DEBUG, " * Set 22222222222222222\n");
- }
-#else /* WAPI */
-#ifdef BRCM_DEBUG
- else {
- wpa_printf(MSG_DEBUG, " * ## WPA_CIPHER_NONE");
- }
-#endif /* BRCM_DEBUG */
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (params->group_suite == WPA_CIPHER_GTK_NOT_USED &&
!(drv->capa.enc & WPA_DRIVER_CAPA_ENC_GTK_NOT_USED)) {
/*
@@ -6476,30 +6223,13 @@
} else if (params->group_suite != WPA_CIPHER_NONE) {
u32 cipher = wpa_cipher_to_cipher_suite(params->group_suite);
wpa_printf(MSG_DEBUG, " * group=0x%x", cipher);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (wapi_ie_present) { /* wapi */
- wpa_printf(MSG_DEBUG, " * Set SUITE_GROUP to RSN_CIPHER_SUITE_SMS4");
- cipher = RSN_CIPHER_SUITE_SMS4;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP, cipher))
return -1;
}
if (params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
params->key_mgmt_suite == WPA_KEY_MGMT_PSK ||
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- params->key_mgmt_suite == WPA_KEY_MGMT_WAPI_PSK ||
- params->key_mgmt_suite == WPA_KEY_MGMT_WAPI_CERT ||
-#endif /* WAPI */
-#ifdef BRCM_CCX
- params->key_mgmt_suite == WPA_KEY_MGMT_CCKM ||
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
params->key_mgmt_suite == WPA_KEY_MGMT_FT_IEEE8021X ||
params->key_mgmt_suite == WPA_KEY_MGMT_FT_PSK ||
params->key_mgmt_suite == WPA_KEY_MGMT_CCKM ||
@@ -6526,16 +6256,6 @@
case WPA_KEY_MGMT_IEEE8021X:
mgmt = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
break;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- case WPA_KEY_MGMT_WAPI_PSK:
- mgmt = WLAN_AKM_SUITE_WAPI_PSK;
- break;
- case WPA_KEY_MGMT_WAPI_CERT:
- mgmt = WLAN_AKM_SUITE_WAPI_CERT;
- break;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case WPA_KEY_MGMT_FT_IEEE8021X:
mgmt = RSN_AUTH_KEY_MGMT_FT_802_1X;
break;
@@ -6681,7 +6401,6 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
static int nl80211_set_conn_sae_sta_keys(struct wpa_driver_nl80211_data *drv,
struct wpa_driver_associate_params *params)
@@ -6702,7 +6421,6 @@
return ret;
}
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_driver_nl80211_try_connect(
struct wpa_driver_nl80211_data *drv,
@@ -6714,7 +6432,6 @@
int ret;
int algs;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_DRIVER_NL80211_BRCM
if (params->psk && (params->key_mgmt_suite == WPA_KEY_MGMT_PSK ||
params->key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
@@ -6727,7 +6444,6 @@
}
}
#endif /* CONFIG_DRIVER_NL80211_BRCM */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DRIVER_NL80211_QCA
if (params->req_key_mgmt_offload && params->psk &&
(params->key_mgmt_suite == WPA_KEY_MGMT_PSK ||
@@ -6785,14 +6501,6 @@
}
type = get_nl_auth_type(params->auth_alg);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (params->wpa_ie && params->wpa_ie[0] == WLAN_EID_WAPI) {
- wpa_printf(MSG_DEBUG, "params->wpa_ie[0] == WLAN_EID_WAPI, Set type = NL80211_AUTHTYPE_OPEN_SYSTEM\n");
- type = NL80211_AUTHTYPE_OPEN_SYSTEM;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_printf(MSG_DEBUG, " * Auth Type %d", type);
if (type == NL80211_AUTHTYPE_MAX ||
nla_put_u32(msg, NL80211_ATTR_AUTH_TYPE, type))
@@ -6803,7 +6511,6 @@
if (ret)
goto fail;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
if (params->auth_alg & WPA_AUTH_ALG_SAE) {
ret = nl80211_set_conn_sae_sta_keys(drv, params);
@@ -6813,7 +6520,6 @@
}
}
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
ret = send_and_recv_msgs_owner(drv, msg, nl_connect, 1, NULL,
(void *) -1, NULL, NULL);
msg = NULL;
@@ -6848,11 +6554,6 @@
ret = wpa_driver_nl80211_try_connect(drv, params, nl_connect);
if (ret == -EALREADY) {
- /*
- * cfg80211 does not currently accept new connections if
- * we are already connected. As a workaround, force
- * disconnection and try again.
- */
wpa_printf(MSG_DEBUG, "nl80211: Explicitly "
"disconnecting before reassociation "
"attempt");
@@ -7236,14 +6937,12 @@
static int i802_set_freq(void *priv, struct hostapd_freq_params *freq)
{
struct i802_bss *bss = priv;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_CY_AUTO_SET_BW) && defined(CONFIG_BRCM_AUTOMOTIVE)
#ifdef HOSTAPD
bss->bandwidth = freq->bandwidth;
#endif /* HOSTAPD */
nl80211_driver_set_channel_width(bss);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return nl80211_set_channel(bss, freq, 0);
}
@@ -7365,9 +7064,6 @@
wpa_printf(MSG_DEBUG, "nl80211: flush -> DEL_STATION %s (all)",
bss->ifname);
- /*
- * XXX: FIX! this needs to flush all VLANs too
- */
msg = nl80211_bss_msg(bss, 0, NL80211_CMD_DEL_STATION);
res = send_and_recv_msgs(bss->drv, msg, NULL, NULL, NULL, NULL);
if (res) {
@@ -7698,9 +7394,6 @@
static int i802_sta_clear_stats(void *priv, const u8 *addr)
{
-#if 0
- /* TODO */
-#endif
return 0;
}
@@ -7942,29 +7635,6 @@
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
-void handle_wapi(int sock, void *eloop_ctx, void *sock_ctx)
-{
- wpa_printf(MSG_ERROR, "%s: received a wapi_pkt\n", __FUNCTION__);
-
- struct wpa_driver_nl80211_data *drv = eloop_ctx;
- struct sockaddr_ll lladdr;
- unsigned char buf[3000];
- int len;
- socklen_t fromlen = sizeof(lladdr);
-
- len = recvfrom(sock, buf, sizeof(buf), 0,
- (struct sockaddr *)&lladdr, &fromlen);
- if (len < 0) {
- wpa_printf(MSG_ERROR, "nl80211: WAPI recv failed: %s",
- strerror(errno));
- return;
- }
- brcm_wapiap_handshakepkt_from_sta(lladdr.sll_addr, buf, len, drv->ifname);
-}
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void handle_eapol(int sock, void *eloop_ctx, void *sock_ctx)
{
@@ -8156,22 +7826,6 @@
}
skip_eapol_sock:
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- drv->wapi_sock = socket(PF_PACKET, SOCK_DGRAM, htons(ETHER_TYPE_WAI));
- if (drv->wapi_sock < 0) {
- wpa_printf(MSG_ERROR, "%s nl80211: socket(PF_PACKET, SOCK_DGRAM"
- ", ) failed: %s", __FUNCTION__, strerror(errno));
- goto failed;
- }
-
- if (eloop_register_read_sock(drv->wapi_sock, handle_wapi, drv, NULL)) {
- wpa_printf(MSG_ERROR, "%s nl80211: Could not register read "
- "socket for wapi", __FUNCTION__);
- goto failed;
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
params->own_addr))
goto failed;
@@ -9113,7 +8767,6 @@
goto err;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID_P2P)
if (wpa_driver_priv_lib_init(global) < 0) {
wpa_printf(MSG_ERROR,
@@ -9121,7 +8774,6 @@
goto err;
}
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return global;
err:
@@ -9153,14 +8805,12 @@
if (global->ioctl_sock >= 0)
close(global->ioctl_sock);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID_P2P)
if (wpa_driver_priv_lib_deinit(global) < 0) {
wpa_printf(MSG_ERROR,
"nl80211: private lib de-initilization failed\n");
}
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_free(global);
}
@@ -9554,15 +9204,6 @@
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-static int wpa_driver_nl80211_set_wapi(void *priv, int enabled)
-{
- wpa_printf(MSG_DEBUG, "CFG80211: wpa_driver_nl80211_set_wapi");
- return 1;
-}
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int nl80211_set_power_save(struct i802_bss *bss, int enabled)
{
@@ -12094,7 +11735,6 @@
#endif /* CONFIG_DRIVER_NL80211_QCA */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_DEBUG
static int nl80211_vendor_reply_brcm(struct nl80211_vendor_data *vendor,
void *data, int len)
@@ -12196,7 +11836,6 @@
return ret;
}
#endif /* CONFIG_BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int nl80211_write_to_file(const char *name, unsigned int val)
{
@@ -12394,7 +12033,6 @@
return ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef WL_SAE
static int nl80211_send_vendor_external_auth_status(
void *priv, struct external_auth *params)
@@ -12436,7 +12074,6 @@
return ret;
}
#endif /* WL_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int nl80211_send_external_auth_status(void *priv,
struct external_auth *params)
@@ -12451,11 +12088,9 @@
* SAE) to hostapd/wpa_supplicant. Do not send the status to drivers
* which do not support AP SME or use wpa_supplicant/hostapd SME.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef WL_SAE
return nl80211_send_vendor_external_auth_status(priv, params);
#endif /* WL_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if ((is_ap_interface(drv->nlmode) && !bss->drv->device_ap_sme) ||
(drv->capa.flags & WPA_DRIVER_FLAGS_SME))
return -1;
@@ -12641,29 +12276,16 @@
.get_noa = wpa_driver_get_p2p_noa,
.set_ap_wps_ie = wpa_driver_set_ap_wps_p2p_ie,
#endif /* ANDROID_P2P */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
#ifndef ANDROID_LIB_STUB
.driver_cmd = wpa_driver_nl80211_driver_cmd,
#endif /* !ANDROID_LIB_STUB */
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
-#ifndef ANDROID_LIB_STUB
- .driver_cmd = wpa_driver_nl80211_driver_cmd,
-#endif /* !ANDROID_LIB_STUB */
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
.vendor_cmd = nl80211_vendor_cmd,
.set_qos_map = nl80211_set_qos_map,
.get_wowlan = nl80211_get_wowlan,
.set_wowlan = nl80211_set_wowlan,
.set_mac_addr = nl80211_set_mac_addr,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- .set_wapi = wpa_driver_nl80211_set_wapi,
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_MESH
.init_mesh = wpa_driver_nl80211_init_mesh,
.join_mesh = wpa_driver_nl80211_join_mesh,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.h b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.h
index 8a126cd..70d8f68 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211.h
@@ -33,12 +33,6 @@
struct nl_sock *nl;
int nl80211_id;
int ioctl_sock; /* socket for ioctl() use */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BCM_GENL
- struct nl_sock *event_sock;
- int event_family;
-#endif /* BCM_GENL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct nl_sock *nl_event;
};
@@ -143,12 +137,6 @@
int monitor_ifidx;
int monitor_refcount;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BCM_GENL
- struct nl_sock *event_sock;
- int event_family;
-#endif /* BCM_GENL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
unsigned int disabled_11b_rates:1;
unsigned int pending_remain_on_chan:1;
unsigned int in_interface_list:1;
@@ -203,23 +191,10 @@
struct i802_bss *first_bss;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- char ifname[IFNAMSIZ + 1];
- size_t ap_wapi_ie_len;
- const u8 *ap_wapi_ie;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int eapol_tx_sock;
int eapol_sock; /* socket for EAPOL frames */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- int wapi_tx_sock;
- int wapi_sock;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct nl_sock *rtnl_sk; /* nl_sock for NETLINK_ROUTE */
struct drv_nl80211_if_info default_if_indices[16];
@@ -248,7 +223,6 @@
int last_scan_cmd;
};
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_DEBUG
struct nl80211_vendor_data {
struct wpa_driver_nl80211_data *nl80211_data;
@@ -278,7 +252,6 @@
WL_BCNRECV_MAX
} wl_bcnrecv_status_t;
#endif /* ANDROID_P2P*/
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct nl_msg;
void * nl80211_cmd(struct wpa_driver_nl80211_data *drv,
@@ -338,7 +311,6 @@
void nl80211_restore_ap_mode(struct i802_bss *bss);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
int android_nl_socket_set_nonblocking(struct nl_sock *handle);
int android_pno_start(struct i802_bss *bss,
@@ -356,30 +328,10 @@
const struct wpabuf *assocresp);
#endif /* ANDROID_P2P */
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
-int android_nl_socket_set_nonblocking(struct nl_sock *handle);
-int android_pno_start(struct i802_bss *bss,
- struct wpa_driver_scan_params *params);
-int android_pno_stop(struct i802_bss *bss);
-extern int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
- size_t buf_len);
-
-#ifdef ANDROID_P2P
-int wpa_driver_set_p2p_noa(void *priv, u8 count, int start, int duration);
-int wpa_driver_get_p2p_noa(void *priv, u8 *buf, size_t len);
-int wpa_driver_set_p2p_ps(void *priv, int legacy_ps, int opp_ps, int ctwindow);
-int wpa_driver_set_ap_wps_p2p_ie(void *priv, const struct wpabuf *beacon,
- const struct wpabuf *proberesp,
- const struct wpabuf *assocresp);
-#endif /* ANDROID_P2P */
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* driver_nl80211_scan.c */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID_P2P) && !defined(nla_put_string)
/* This is a custom change to compile newer wpa_supplicant
* in Android-KK and below versions
@@ -389,7 +341,6 @@
#define nla_put_flag(msg, attrtype) \
nla_put(msg, attrtype, 0, NULL)
#endif /* ANDROID_P2P && !nla_put_string */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void wpa_driver_nl80211_scan_timeout(void *eloop_ctx, void *timeout_ctx);
int wpa_driver_nl80211_scan(struct i802_bss *bss,
struct wpa_driver_scan_params *params);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_capa.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_capa.c
index b5cbb54..7f03b62 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_capa.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_capa.c
@@ -589,7 +589,9 @@
NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
capa->flags |= WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X;
-#ifndef CONFIG_DRIVER_NL80211_IFX
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
if (ext_feature_isset(ext_features, len,
NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK))
capa->flags2 |= WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK;
@@ -601,11 +603,6 @@
if (ext_feature_isset(ext_features, len,
NL80211_EXT_FEATURE_SAE_OFFLOAD_AP))
capa->flags2 |= WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP;
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (ext_feature_isset(ext_features, len,
- NL80211_EXT_FEATURE_SAE_OFFLOAD))
- capa->flags2 |= WPA_DRIVER_FLAGS2_SAE_OFFLOAD;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ext_feature_isset(ext_features, len,
NL80211_EXT_FEATURE_MFP_OPTIONAL))
@@ -1373,18 +1370,12 @@
WPA_DRIVER_AUTH_SHARED |
WPA_DRIVER_AUTH_LEAP;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_IEEE80211R) && defined(BRCM_VE)
/* Also assume that FT-PSK & FT-EAP are supported */
drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT |
WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK;
#endif /* CONFIG_IEEE80211R && BRCM_VE */
-#ifdef BRCM_CCX
- drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA_CCKM |
- WPA_DRIVER_CAPA_KEY_MGMT_WPA2_CCKM;
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
drv->capa.flags |= WPA_DRIVER_FLAGS_SANE_ERROR_CODES;
drv->capa.flags |= WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE;
drv->capa.flags |= WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_event.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_event.c
index 60c4a63..2edab84 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_event.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_event.c
@@ -18,20 +18,13 @@
#include "common/ieee802_11_defs.h"
#include "common/ieee802_11_common.h"
#include "driver_nl80211.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID_P2P
#include "common/brcm_vendor.h"
#endif /* ANDROID_P2P */
-#ifdef WAPI
-#include "../../wpa_supplicant/wpa_supplicant_i.h"
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef WL_SAE
static void nl80211_external_auth(struct wpa_driver_nl80211_data *drv,
struct nlattr **tb);
#endif /* WL_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void
@@ -415,17 +408,6 @@
{
union wpa_event_data event;
const u8 *ssid = NULL;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- struct wpa_supplicant *wpa_s = drv->ctx;
- if(drv->ap_wapi_ie_len && drv->ap_wapi_ie) {
- wpa_printf(MSG_ERROR, "%s : Set wpa_s->ap_wapi_ie and "
- "wpa_s->ap_wapi_ie_len\n",__func__);
- memcpy(wpa_s->ap_wapi_ie, drv->ap_wapi_ie, drv->ap_wapi_ie_len);
- wpa_s->ap_wapi_ie_len = drv->ap_wapi_ie_len;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
u16 status_code;
int ssid_len;
@@ -555,11 +537,7 @@
wpa_ssid_txt(drv->ssid, drv->ssid_len));
}
-#ifndef CONFIG_DRIVER_NL80211_IFX
- if (authorized && nla_get_flag(authorized)) {
-#else /* CONFIG_DRIVER_NL80211_IFX */
if (authorized && nla_get_u8(authorized)) {
-#endif /* CONFIG_DRIVER_NL80211_IFX */
event.assoc_info.authorized = 1;
wpa_printf(MSG_DEBUG, "nl80211: connection authorized");
}
@@ -665,7 +643,6 @@
case CHAN_WIDTH_4320:
case CHAN_WIDTH_6480:
case CHAN_WIDTH_8640:
- /* FIXME: implement this */
return 0;
}
@@ -1851,7 +1828,6 @@
wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID_P2P
char bcn_recv_status[][10] = {"STARTED", "STOPPED", "ABORTED", "SUSPENDED"};
static void nl80211_beacon_info_fakeap(struct wpa_driver_nl80211_data *drv,
@@ -1991,7 +1967,6 @@
}
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DRIVER_NL80211_QCA
@@ -2554,13 +2529,11 @@
case OUI_QCA:
nl80211_vendor_event_qca(drv, subcmd, data, len);
break;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID_P2P
case OUI_BRCM:
nl80211_vendor_event_brcm(drv, subcmd, data, len);
break;
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
default:
wpa_printf(MSG_DEBUG, "nl80211: Ignore unsupported vendor event");
break;
@@ -2988,12 +2961,7 @@
tb[NL80211_ATTR_RESP_IE],
tb[NL80211_ATTR_TIMED_OUT],
tb[NL80211_ATTR_TIMEOUT_REASON],
-#ifndef CONFIG_DRIVER_NL80211_IFX
- tb[NL80211_ATTR_PORT_AUTHORIZED],
- NULL, NULL,
-#else /* CONFIG_DRIVER_NL80211_IFX */
NULL, NULL, NULL,
-#endif /* CONFIG_DRIVER_NL80211_IFX */
tb[NL80211_ATTR_FILS_KEK],
NULL,
tb[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM],
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_monitor.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_monitor.c
index 7ff55f1..e9fe776 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_monitor.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_nl80211_monitor.c
@@ -219,17 +219,6 @@
*/
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0801, PASS, 0),
-#if 0
- /*
- * drop non-data frames
- */
- /* load the lower byte of the frame control field */
- BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
- /* mask off QoS bit */
- BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0x0c),
- /* drop non-data frames */
- BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 8, 0, FAIL),
-#endif
/* load the upper byte of the frame control field */
BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
/* mask off toDS/fromDS */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.c b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.c
index 74aa1b5..691097c 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.c
@@ -11,11 +11,6 @@
* can be used by other driver interface implementations that use generic WE
* ioctls, but require private ioctls for some of the functionality.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_FEATURES_COPYRIGHT
-/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "includes.h"
#include <sys/ioctl.h>
@@ -36,12 +31,6 @@
#include "rfkill.h"
#include "driver.h"
#include "driver_wext.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "wapi_asue.h"
-#include "wapi.h"
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_driver_wext_flush_pmkid(void *priv);
static int wpa_driver_wext_get_range(void *priv);
@@ -301,7 +290,6 @@
done:
os_free(resp_ies);
os_free(req_ies);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_PEERKEY
} else if (os_strncmp(custom, "STKSTART.request=", 17) == 0) {
if (hwaddr_aton(custom + 17, data.stkstart.peer)) {
@@ -311,7 +299,6 @@
}
wpa_supplicant_event(ctx, EVENT_STKSTART, &data);
#endif /* CONFIG_PEERKEY */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
}
@@ -1221,11 +1208,6 @@
u8 ssid[SSID_MAX_LEN];
size_t ssid_len;
int maxrate;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- size_t wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
@@ -1443,35 +1425,6 @@
}
res->res.tsf += WPA_GET_BE64(bin);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else if (clen > 8 && os_strncmp(custom, "wapi_ie=", 8) == 0) {
- char *spos;
- int bytes;
- spos = custom + 8;
- bytes = custom + clen - spos;
- wpa_printf(MSG_DEBUG, "Got WAPI IE (%d)\n", bytes);
- if (bytes & 1) {
- wpa_printf(MSG_ERROR, "%s: === ALARM: bytes & 1 ===\n", __FUNCTION__);
- return;
- }
- bytes /= 2;
- if (bytes > SSID_MAX_WAPI_IE_LEN) {
- wpa_printf(MSG_ERROR, "Too long WAPI IE (%d)", bytes);
- return;
- }
- tmp = os_realloc(res->ie, res->ie_len + bytes);
- if (tmp == NULL)
- return;
- hexstr2bin(spos, tmp + res->ie_len, bytes);
- res->ie = tmp;
- res->ie_len += bytes;
- res->wapi_ie_len = bytes;
- wpa_printf(MSG_DEBUG, "wapi ie, len=%d\n", res->wapi_ie_len);
- wpa_hexdump_ascii(MSG_DEBUG, "wapi ie", (u8 *)res->ie, res->wapi_ie_len);
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -1517,12 +1470,6 @@
return;
os_memcpy(r, &data->res, sizeof(*r));
r->ie_len = extra_len + data->ie_len;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- r->wapi_ie_len = data->wapi_ie_len;
- wpa_printf(MSG_DEBUG, "%s: wapi_ie_len=%d\n", __FUNCTION__, r->wapi_ie_len);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
pos = (u8 *) (r + 1);
if (ssid_ie == NULL) {
/*
@@ -1700,20 +1647,10 @@
drv->we_version_compiled = range->we_version_compiled;
if (range->enc_capa & IW_ENC_CAPA_WPA) {
drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA |
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- WPA_DRIVER_CAPA_KEY_MGMT_WPA_CCKM |
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK;
}
if (range->enc_capa & IW_ENC_CAPA_WPA2) {
drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- WPA_DRIVER_CAPA_KEY_MGMT_WPA2_CCKM |
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
}
drv->capa.enc |= WPA_DRIVER_CAPA_ENC_WEP40 |
@@ -1746,17 +1683,6 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-static int wpa_driver_wext_set_wapi(void *priv, int enabled)
-{
- struct wpa_driver_wext_data *drv = priv;
- wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
- return wpa_driver_wext_set_auth_param(drv, IW_AUTH_WAPI_ENABLED, enabled);
-}
-#define IW_ENCODE_ALG_SM4 0x20
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_driver_wext_set_psk(struct wpa_driver_wext_data *drv,
const u8 *psk)
@@ -1808,24 +1734,11 @@
int ret = 0;
struct iw_encode_ext *ext;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if ( (alg == WAPI_ALG_SMS4) && (seq_len > IW_ENCODE_SEQ_MAX_SIZE * 2) ) {
- wpa_printf(MSG_DEBUG, "%s: Invalid seq_len for WAPI_ALG_SMS4 %lu",
- __FUNCTION__, (unsigned long) seq_len);
- return -1;
- }
- else if ( (alg != WAPI_ALG_SMS4) && (seq_len > IW_ENCODE_SEQ_MAX_SIZE) ) {
- wpa_printf(MSG_DEBUG, "%s: Invalid seq_len %lu",
- __FUNCTION__, (unsigned long) seq_len);
- return -1;
- }
-#else
if (seq_len > IW_ENCODE_SEQ_MAX_SIZE) {
wpa_printf(MSG_DEBUG, "%s: Invalid seq_len %lu",
__FUNCTION__, (unsigned long) seq_len);
return -1;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
ext = os_zalloc(sizeof(*ext) + key_len);
if (ext == NULL)
@@ -1869,13 +1782,6 @@
case WPA_ALG_CCMP:
ext->alg = IW_ENCODE_ALG_CCMP;
break;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- case WAPI_ALG_SMS4:
- ext->alg = IW_ENCODE_ALG_SM4;
- break;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case WPA_ALG_BIP_CMAC_128:
ext->alg = IW_ENCODE_ALG_AES_CMAC;
break;
@@ -1888,21 +1794,8 @@
}
if (seq && seq_len) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (alg == WAPI_ALG_SMS4) {
- os_memcpy(ext->tx_seq, seq, seq_len);
- wpa_hexdump(MSG_DEBUG, "seq", seq, seq_len);
- } else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
ext->ext_flags |= IW_ENCODE_EXT_RX_SEQ_VALID;
os_memcpy(ext->rx_seq, seq, seq_len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
if (ioctl(drv->ioctl_sock, SIOCSIWENCODEEXT, &iwr) < 0) {
@@ -2169,18 +2062,12 @@
return IW_AUTH_KEY_MGMT_802_1X;
case WPA_KEY_MGMT_PSK:
return IW_AUTH_KEY_MGMT_PSK;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_IEEE80211R) && defined(BRCM_VE)
case WPA_KEY_MGMT_FT_PSK:
return IW_AUTH_KEY_MGMT_FT_PSK;
case WPA_KEY_MGMT_FT_IEEE8021X:
return IW_AUTH_KEY_MGMT_FT_8021X;
#endif /* CONFIG_IEEE80211R && BRCM_VE */
-#ifdef BRCM_CCX
- case KEY_MGMT_CCKM:
- return IW_AUTH_KEY_MGMT_CCKM;
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
default:
return 0;
}
@@ -2282,12 +2169,6 @@
ret = -1;
if (params->wpa_proto & WPA_PROTO_RSN)
value = IW_AUTH_WPA_VERSION_WPA2;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else if (params->wpa_ie[0] == WLAN_EID_WAPI) /* wapi */
- value = IW_AUTH_WAPI_VERSION_1;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
else if (params->wpa_proto & WPA_PROTO_WPA)
value = IW_AUTH_WPA_VERSION_WPA;
else
@@ -2296,38 +2177,14 @@
IW_AUTH_WPA_VERSION, value) < 0)
ret = -1;
value = wpa_driver_wext_cipher2wext(params->pairwise_suite);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (params->wpa_ie[0] == WLAN_EID_WAPI) /* wapi */
- value |= IW_AUTH_CIPHER_SMS4;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_CIPHER_PAIRWISE, value) < 0)
ret = -1;
value = wpa_driver_wext_cipher2wext(params->group_suite);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (params->wpa_ie[0] == WLAN_EID_WAPI) /* wapi */
- value |= IW_AUTH_CIPHER_SMS4;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_CIPHER_GROUP, value) < 0)
ret = -1;
value = wpa_driver_wext_keymgmt2wext(params->key_mgmt_suite);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (params->wpa_ie[0] == WLAN_EID_WAPI) { /* wapi */
- if (params->wpa_ie[9] == 2) /* wapi psk */
- value = IW_AUTH_KEY_MGMT_WAPI_PSK;
- else if (params->wpa_ie[9] == 1) /* wapi cert */
- value = IW_AUTH_KEY_MGMT_WAPI_CERT;
- else
- wpa_printf(MSG_DEBUG, "Unknown WAPI key management value 0x%x\n", params->wpa_ie[9]);
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_KEY_MGMT, value) < 0)
ret = -1;
@@ -2638,11 +2495,6 @@
.desc = "Linux wireless extensions (generic)",
.get_bssid = wpa_driver_wext_get_bssid,
.get_ssid = wpa_driver_wext_get_ssid,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- .set_wapi = wpa_driver_wext_set_wapi,
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
.set_key = wpa_driver_wext_set_key,
.set_countermeasures = wpa_driver_wext_set_countermeasures,
.scan2 = wpa_driver_wext_scan,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.h b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.h
index 8c11b4f..381530b 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/driver_wext.h
@@ -9,13 +9,9 @@
#ifndef DRIVER_WEXT_H
#define DRIVER_WEXT_H
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef BCM_LINUX_BUILD
#include <net/if.h>
#endif /* BCM_LINUX_BUILD */
-#else
-#include <net/if.h>
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wpa_driver_wext_data {
void *ctx;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/nl80211_copy.h b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/nl80211_copy.h
index 2569acc..5ac681b 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/nl80211_copy.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/nl80211_copy.h
@@ -40,11 +40,6 @@
* Nonetheless, semantics should also be documented carefully in this file.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_FEATURES_COPYRIGHT
-/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include <linux/types.h>
#define NL80211_GENL_NAME "nl80211"
@@ -1369,11 +1364,6 @@
NL80211_CMD_WIPHY_REG_CHANGE,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- NL80211_CMD_AUTH_WAPI_ENABLE,
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
NL80211_CMD_ABORT_SCAN,
NL80211_CMD_START_NAN,
@@ -2913,13 +2903,6 @@
NL80211_ATTR_REG_INDOOR,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- NL80211_ATTR_WAPI,
- NL80211_ATTR_WAPI_PSK,
- NL80211_ATTR_WAPI_CERT,
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
@@ -4648,11 +4631,6 @@
NL80211_BSS_CHAN_WIDTH,
NL80211_BSS_BEACON_TSF,
NL80211_BSS_PRESP_DATA,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- NL80211_BSS_WAPI_IES,
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
NL80211_BSS_LAST_SEEN_BOOTTIME,
NL80211_BSS_PAD,
NL80211_BSS_PARENT_TSF,
@@ -4706,11 +4684,6 @@
NL80211_AUTHTYPE_FT,
NL80211_AUTHTYPE_NETWORK_EAP,
NL80211_AUTHTYPE_SAE,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- NL80211_AUTHTYPE_WAPI,
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
NL80211_AUTHTYPE_FILS_SK,
NL80211_AUTHTYPE_FILS_SK_PFS,
NL80211_AUTHTYPE_FILS_PK,
@@ -4752,11 +4725,6 @@
NL80211_WPA_VERSION_1 = 1 << 0,
NL80211_WPA_VERSION_2 = 1 << 1,
NL80211_WPA_VERSION_3 = 1 << 2,
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- NL80211_WAPI_VERSION_1 = 1 << 3,
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
/**
@@ -5777,7 +5745,7 @@
NL80211_FEATURE_TDLS_CHANNEL_SWITCH = 1 << 28,
NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR = 1 << 29,
NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR = 1 << 30,
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_VE)
+#if defined(BRCM_VE)
/*
* BRCM local.
* Use a high number that's unlikely to clash with linux upstream for a while until we can
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/wireless_copy.h b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/wireless_copy.h
index 604df9f..3f99a63 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/wireless_copy.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/drivers/wireless_copy.h
@@ -77,11 +77,6 @@
/***************************** INCLUDES *****************************/
/* jkm - replaced linux headers with C library headers, added typedefs */
-#if 0
-#include <linux/types.h> /* for __u* and __s* typedefs */
-#include <linux/socket.h> /* for "struct sockaddr" et al */
-#include <linux/if.h> /* for IFNAMSIZ and co... */
-#else
#include <sys/types.h>
#include <net/if.h>
#ifndef ANDROID
@@ -94,7 +89,6 @@
#ifndef __user
#define __user
#endif /* __user */
-#endif
/***************************** VERSION *****************************/
/*
@@ -604,20 +598,10 @@
#define IW_AUTH_PRIVACY_INVOKED 10
#define IW_AUTH_CIPHER_GROUP_MGMT 11
#define IW_AUTH_MFP 12
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#define IW_AUTH_WAPI_ENABLED 0x20
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* IW_AUTH_WPA_VERSION values (bit field) */
#define IW_AUTH_WPA_VERSION_DISABLED 0x00000001
#define IW_AUTH_WPA_VERSION_WPA 0x00000002
#define IW_AUTH_WPA_VERSION_WPA2 0x00000004
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#define IW_AUTH_WAPI_VERSION_1 0x00000008
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* IW_AUTH_PAIRWISE_CIPHER, IW_AUTH_GROUP_CIPHER, and IW_AUTH_CIPHER_GROUP_MGMT
* values (bit field) */
@@ -626,26 +610,15 @@
#define IW_AUTH_CIPHER_TKIP 0x00000004
#define IW_AUTH_CIPHER_CCMP 0x00000008
#define IW_AUTH_CIPHER_WEP104 0x00000010
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#define IW_AUTH_CIPHER_SMS4 0x00000020
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define IW_AUTH_CIPHER_AES_CMAC 0x00000020
/* IW_AUTH_KEY_MGMT values (bit field) */
#define IW_AUTH_KEY_MGMT_802_1X 1
#define IW_AUTH_KEY_MGMT_PSK 2
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#define IW_AUTH_KEY_MGMT_WAPI_PSK 4
-#define IW_AUTH_KEY_MGMT_WAPI_CERT 8
-#endif /* WAPI */
#ifdef BRCM_VE
#define IW_AUTH_KEY_MGMT_FT_8021X 4
#define IW_AUTH_KEY_MGMT_FT_PSK 8
#endif /* BRCM_VE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* IW_AUTH_80211_AUTH_ALG values (bit field) */
#define IW_AUTH_ALG_OPEN_SYSTEM 0x00000001
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_common/eap_pwd_common.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_common/eap_pwd_common.c
index 2b2b8ef..ff22b29 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_common/eap_pwd_common.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_common/eap_pwd_common.c
@@ -127,7 +127,8 @@
u8 qr_or_qnr_bin[MAX_ECC_PRIME_LEN];
u8 x_bin[MAX_ECC_PRIME_LEN];
u8 prime_bin[MAX_ECC_PRIME_LEN];
- struct crypto_bignum *tmp2 = NULL;
+ u8 x_y[2 * MAX_ECC_PRIME_LEN];
+ struct crypto_bignum *tmp2 = NULL, *y = NULL;
struct crypto_hash *hash;
unsigned char pwe_digest[SHA256_MAC_LEN], *prfbuf = NULL, ctr;
int ret = 0, res;
@@ -139,6 +140,7 @@
u8 found_ctr = 0, is_odd = 0;
int cmp_prime;
unsigned int in_range;
+ unsigned int is_eq;
if (grp->pwe)
return -1;
@@ -151,11 +153,6 @@
if (crypto_bignum_to_bin(prime, prime_bin, sizeof(prime_bin),
primebytelen) < 0)
return -1;
- grp->pwe = crypto_ec_point_init(grp->group);
- if (!grp->pwe) {
- wpa_printf(MSG_INFO, "EAP-pwd: unable to create bignums");
- goto fail;
- }
if ((prfbuf = os_malloc(primebytelen)) == NULL) {
wpa_printf(MSG_INFO, "EAP-pwd: unable to malloc space for prf "
@@ -261,10 +258,37 @@
*/
crypto_bignum_deinit(x_candidate, 1);
x_candidate = crypto_bignum_init_set(x_bin, primebytelen);
- if (!x_candidate ||
- crypto_ec_point_solve_y_coord(grp->group, grp->pwe, x_candidate,
- is_odd) != 0) {
- wpa_printf(MSG_INFO, "EAP-pwd: Could not solve for y");
+ if (!x_candidate)
+ goto fail;
+
+ /* y = sqrt(x^3 + ax + b) mod p
+ * if LSB(y) == LSB(pwd-seed): PWE = (x, y)
+ * else: PWE = (x, p - y)
+ *
+ * Calculate y and the two possible values for PWE and after that,
+ * use constant time selection to copy the correct alternative.
+ */
+ y = crypto_ec_point_compute_y_sqr(grp->group, x_candidate);
+ if (!y ||
+ dragonfly_sqrt(grp->group, y, y) < 0 ||
+ crypto_bignum_to_bin(y, x_y, MAX_ECC_PRIME_LEN, primebytelen) < 0 ||
+ crypto_bignum_sub(prime, y, y) < 0 ||
+ crypto_bignum_to_bin(y, x_y + MAX_ECC_PRIME_LEN,
+ MAX_ECC_PRIME_LEN, primebytelen) < 0) {
+ wpa_printf(MSG_DEBUG, "SAE: Could not solve y");
+ goto fail;
+ }
+
+ /* Constant time selection of the y coordinate from the two
+ * options */
+ is_eq = const_time_eq(is_odd, x_y[primebytelen - 1] & 0x01);
+ const_time_select_bin(is_eq, x_y, x_y + MAX_ECC_PRIME_LEN,
+ primebytelen, x_y + primebytelen);
+ os_memcpy(x_y, x_bin, primebytelen);
+ wpa_hexdump_key(MSG_DEBUG, "EAP-pwd: PWE", x_y, 2 * primebytelen);
+ grp->pwe = crypto_ec_point_from_bin(grp->group, x_y);
+ if (!grp->pwe) {
+ wpa_printf(MSG_DEBUG, "EAP-pwd: Could not generate PWE");
goto fail;
}
@@ -289,6 +313,7 @@
/* cleanliness and order.... */
crypto_bignum_deinit(x_candidate, 1);
crypto_bignum_deinit(tmp2, 1);
+ crypto_bignum_deinit(y, 1);
crypto_bignum_deinit(qr, 1);
crypto_bignum_deinit(qnr, 1);
bin_clear_free(prfbuf, primebytelen);
@@ -296,6 +321,7 @@
os_memset(qnr_bin, 0, sizeof(qnr_bin));
os_memset(qr_or_qnr_bin, 0, sizeof(qr_or_qnr_bin));
os_memset(pwe_digest, 0, sizeof(pwe_digest));
+ forced_memzero(x_y, sizeof(x_y));
return ret;
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_aka.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_aka.c
index e57461a..730aa68 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_aka.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_aka.c
@@ -325,16 +325,6 @@
return -1;
}
}
-#if 0
- {
- static int test_resync = 1;
- if (test_resync) {
- /* Test Resynchronization */
- test_resync = 0;
- return -2;
- }
- }
-#endif
return 0;
#else /* CONFIG_USIM_HARDCODED */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_fast.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_fast.c
index b12cfee..6ee8a87 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_fast.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_fast.c
@@ -185,11 +185,6 @@
return NULL;
}
- /*
- * The local RADIUS server in a Cisco AP does not seem to like empty
- * fragments before data, so disable that workaround for CBC.
- * TODO: consider making this configurable
- */
if (tls_connection_enable_workaround(sm->ssl_ctx, data->ssl.conn)) {
wpa_printf(MSG_DEBUG, "EAP-FAST: Failed to enable TLS "
"workarounds");
@@ -1687,52 +1682,6 @@
}
-#if 0 /* FIX */
-static bool eap_fast_has_reauth_data(struct eap_sm *sm, void *priv)
-{
- struct eap_fast_data *data = priv;
- return tls_connection_established(sm->ssl_ctx, data->ssl.conn);
-}
-
-
-static void eap_fast_deinit_for_reauth(struct eap_sm *sm, void *priv)
-{
- struct eap_fast_data *data = priv;
-
- if (data->phase2_priv && data->phase2_method &&
- data->phase2_method->deinit_for_reauth)
- data->phase2_method->deinit_for_reauth(sm, data->phase2_priv);
- os_free(data->key_block_p);
- data->key_block_p = NULL;
- wpabuf_clear_free(data->pending_phase2_req);
- data->pending_phase2_req = NULL;
- wpabuf_clear_free(data->pending_resp);
- data->pending_resp = NULL;
-}
-
-
-static void * eap_fast_init_for_reauth(struct eap_sm *sm, void *priv)
-{
- struct eap_fast_data *data = priv;
- if (eap_peer_tls_reauth_init(sm, &data->ssl)) {
- os_free(data);
- return NULL;
- }
- os_memset(data->key_data, 0, EAP_FAST_KEY_LEN);
- os_memset(data->emsk, 0, EAP_EMSK_LEN);
- os_free(data->session_id);
- data->session_id = NULL;
- if (data->phase2_priv && data->phase2_method &&
- data->phase2_method->init_for_reauth)
- data->phase2_method->init_for_reauth(sm, data->phase2_priv);
- data->phase2_success = 0;
- data->resuming = 1;
- data->provisioning = 0;
- data->anon_provisioning = 0;
- data->simck_idx = 0;
- return priv;
-}
-#endif
static int eap_fast_get_status(struct eap_sm *sm, void *priv, char *buf,
@@ -1831,11 +1780,6 @@
eap->getKey = eap_fast_getKey;
eap->getSessionId = eap_fast_get_session_id;
eap->get_status = eap_fast_get_status;
-#if 0
- eap->has_reauth_data = eap_fast_has_reauth_data;
- eap->deinit_for_reauth = eap_fast_deinit_for_reauth;
- eap->init_for_reauth = eap_fast_init_for_reauth;
-#endif
eap->get_emsk = eap_fast_get_emsk;
return eap_peer_method_register(eap);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_teap.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_teap.c
index e8cc784..e1570a9 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_teap.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_teap.c
@@ -1993,49 +1993,6 @@
}
-#if 0 /* TODO */
-static bool eap_teap_has_reauth_data(struct eap_sm *sm, void *priv)
-{
- struct eap_teap_data *data = priv;
-
- return tls_connection_established(sm->ssl_ctx, data->ssl.conn);
-}
-
-
-static void eap_teap_deinit_for_reauth(struct eap_sm *sm, void *priv)
-{
- struct eap_teap_data *data = priv;
-
- if (data->phase2_priv && data->phase2_method &&
- data->phase2_method->deinit_for_reauth)
- data->phase2_method->deinit_for_reauth(sm, data->phase2_priv);
- eap_teap_clear(data);
-}
-
-
-static void * eap_teap_init_for_reauth(struct eap_sm *sm, void *priv)
-{
- struct eap_teap_data *data = priv;
-
- if (eap_peer_tls_reauth_init(sm, &data->ssl)) {
- eap_teap_deinit(sm, data);
- return NULL;
- }
- if (data->phase2_priv && data->phase2_method &&
- data->phase2_method->init_for_reauth)
- data->phase2_method->init_for_reauth(sm, data->phase2_priv);
- data->phase2_success = 0;
- data->inner_method_done = 0;
- data->result_success_done = 0;
- data->iresult_verified = 0;
- data->done_on_tx_completion = 0;
- data->resuming = 1;
- data->provisioning = 0;
- data->anon_provisioning = 0;
- data->simck_idx = 0;
- return priv;
-}
-#endif
static int eap_teap_get_status(struct eap_sm *sm, void *priv, char *buf,
@@ -2135,11 +2092,6 @@
eap->getKey = eap_teap_getKey;
eap->getSessionId = eap_teap_get_session_id;
eap->get_status = eap_teap_get_status;
-#if 0 /* TODO */
- eap->has_reauth_data = eap_teap_has_reauth_data;
- eap->deinit_for_reauth = eap_teap_deinit_for_reauth;
- eap->init_for_reauth = eap_teap_init_for_reauth;
-#endif
eap->get_emsk = eap_teap_get_emsk;
return eap_peer_method_register(eap);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_tls_common.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_tls_common.c
index 14ed2a3..298f374 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_tls_common.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_tls_common.c
@@ -166,15 +166,6 @@
os_memset(params, 0, sizeof(*params));
if (sm->workaround && data->eap_type != EAP_TYPE_FAST &&
data->eap_type != EAP_TYPE_TEAP) {
- /*
- * Some deployed authentication servers seem to be unable to
- * handle the TLS Session Ticket extension (they are supposed
- * to ignore unrecognized TLS extensions, but end up rejecting
- * the ClientHello instead). As a workaround, disable use of
- * TLS Sesson Ticket extension for EAP-TLS, EAP-PEAP, and
- * EAP-TTLS (EAP-FAST uses session ticket, so any server that
- * supports EAP-FAST does not need this workaround).
- */
params->flags |= TLS_CONN_DISABLE_SESSION_TICKET;
}
if (data->eap_type == EAP_TYPE_TEAP) {
@@ -1133,14 +1124,6 @@
if (vendor == EAP_VENDOR_IETF && method == EAP_TYPE_NONE) {
wpa_printf(MSG_ERROR, "TLS: Unsupported Phase2 EAP "
"method '%s'", start);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef CONFIG_BRCM_TBD
- /* Using this portion of code only in non BRCM case
- * as this part of code would result in failure to set
- * phase2 type of MSCHAPV2
- */
-#endif /* CONFIG_BRCM_TBD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_free(methods);
os_free(buf);
return -1;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_wsc.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_wsc.c
index fe00046..a1e7bff 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_wsc.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_peer/eap_wsc.c
@@ -277,28 +277,9 @@
cfg.pin, cfg.pin_len, 0);
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_DEBUG)
-/*
-* SWWLAN-33032: In case of WPS_INTEROP_10.7 test case, pin is entered on AP after
-* 90 seconds from activating the wps_pin on DUT, this leaves only 30 seconds for DUT to enroll.
-* But WPS is timing out due to weird behavior of AP(Linksys WRT120N), i.e. even after entering
-* the pin on AP, it is sending M2D instead of M2, in response to this, DUT sends WSC_ACK, after
-* this DUT expects either M2 or EAP_FAIL to proceed WPS further, but AP is not sending anything,
-* DUT waits for 30 seconds and then times out. This test case fails because DUT runs out of time for
-* second attempt and due to AP's weird EAP state machine, so to interop with Linksys WRT120N AP in
-* this test case, DUT needs a second chance and AP's EAP state machine needs to be in proper state,
-* by reducing the eap_wsc_timeout to 15 seconds, DUT gets chance for second attempt as well as it is
-* resetting the AP's EAP state machine by disassociation occurred due to early timeout.
-*/
-#define EAP_WSC_CLIENT_TIMEOUT 15
- /* Use reduced client timeout for WPS to avoid long wait */
- if (sm->ClientTimeout > EAP_WSC_CLIENT_TIMEOUT)
- sm->ClientTimeout = EAP_WSC_CLIENT_TIMEOUT;
-#else
/* Use reduced client timeout for WPS to avoid long wait */
if (sm->ClientTimeout > 30)
sm->ClientTimeout = 30;
-#endif /* CONFIG_DRIVER_NL80211_IFX && BRCM_DEBUG */
return data;
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_aka.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_aka.c
index e9bf030..3ba5115 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_aka.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_aka.c
@@ -936,28 +936,6 @@
wpa_printf(MSG_DEBUG, "EAP-AKA: Processing Challenge");
#ifdef EAP_SERVER_AKA_PRIME
-#if 0
- /* KDF negotiation; to be enabled only after more than one KDF is
- * supported */
- if (data->eap_method == EAP_TYPE_AKA_PRIME &&
- attr->kdf_count == 1 && attr->mac == NULL) {
- if (attr->kdf[0] != EAP_AKA_PRIME_KDF) {
- wpa_printf(MSG_WARNING, "EAP-AKA': Peer selected "
- "unknown KDF");
- data->notification =
- EAP_SIM_GENERAL_FAILURE_BEFORE_AUTH;
- eap_aka_state(data, NOTIFICATION);
- return;
- }
-
- data->kdf = attr->kdf[0];
-
- /* Allow negotiation to continue with the selected KDF by
- * sending another Challenge message */
- wpa_printf(MSG_DEBUG, "EAP-AKA': KDF %d selected", data->kdf);
- return;
- }
-#endif
#endif /* EAP_SERVER_AKA_PRIME */
if (attr->checkcode &&
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_tls.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_tls.c
index 769fd1f..1dd208e 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_tls.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eap_server/eap_server_tls.c
@@ -273,13 +273,6 @@
wpa_printf(MSG_DEBUG,
"EAP-TLS: Send empty application data to indicate end of exchange");
- /* FIX: This should be an empty application data based on
- * draft-ietf-emu-eap-tls13-05, but OpenSSL does not allow zero
- * length payload (SSL_write() documentation explicitly
- * describes this as not allowed), so work around that for now
- * by sending out a payload of one octet. Hopefully the draft
- * specification will change to allow this so that no crypto
- * library changes are needed. */
plain = wpabuf_alloc(1);
if (!plain)
return;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/eapol_supp/eapol_supp_sm.c b/src/lynq/packages/thirdpart/lynq-wg870/src/eapol_supp/eapol_supp_sm.c
index 861eea2..63d9ad3 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/eapol_supp/eapol_supp_sm.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/eapol_supp/eapol_supp_sm.c
@@ -1322,13 +1322,6 @@
elen = be_to_host16(ehdr->length);
if (elen > plen && elen <= len - sizeof(*hdr)) {
- /*
- * Buffalo WHR-G125 Ver.1.47 seems to send EAP-WPS
- * packets with too short EAPOL header length field
- * (14 octets). This is fixed in firmware Ver.1.49.
- * As a workaround, fix the EAPOL header based on the
- * correct length in the EAP packet.
- */
wpa_printf(MSG_DEBUG, "EAPOL: Workaround - fix EAPOL "
"payload length based on EAP header: "
"%d -> %d", (int) plen, elen);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet.h b/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet.h
index 2fb4207..1ffb744 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet.h
@@ -15,16 +15,6 @@
#ifndef L2_PACKET_H
#define L2_PACKET_H
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#ifndef ETH_P_WAI
-#define ETH_P_WAI 0x88b4
-#endif /* ETH_P_WAI */
-#ifndef ETH_P_WAI_PREAUTH
-#define ETH_P_WAI_PREAUTH 0x88b5
-#endif /* ETH_P_WAI_PREAUTH */
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* struct l2_packet_data - Internal l2_packet data structure
*
@@ -82,12 +72,6 @@
const u8 *buf, size_t len),
void *rx_callback_ctx, int l2_hdr);
-/**
- * l2_packet_init_bridge - Like l2_packet_init() but with bridge workaround
- *
- * This version of l2_packet_init() can be used to enable a workaround for Linux
- * packet socket in case of a station interface in a bridge.
- */
struct l2_packet_data * l2_packet_init_bridge(
const char *br_ifname, const char *ifname, const u8 *own_addr,
unsigned short protocol,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_freebsd.c b/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_freebsd.c
index 60de9fe..ec80792 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_freebsd.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_freebsd.c
@@ -149,7 +149,6 @@
fprintf(stderr, "%s: cannot enable immediate mode on "
"interface %s: %s\n",
__func__, l2->ifname, strerror(errno));
- /* XXX should we fail? */
}
}
#endif /* __sun__ */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_linux.c b/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_linux.c
index f1554c7..9c01b3a 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_linux.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/l2_packet/l2_packet_linux.c
@@ -17,11 +17,6 @@
#include "crypto/sha1.h"
#include "crypto/crypto.h"
#include "l2_packet.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "wpa_supplicant_i.h"
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct l2_packet_data {
@@ -120,12 +115,6 @@
int l2_packet_send(struct l2_packet_data *l2, const u8 *dst_addr, u16 proto,
const u8 *buf, size_t len)
{
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- u8 txbuf[2312] = { 0, };
- u8 *pos = txbuf;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int ret;
if (TEST_FAIL())
@@ -144,28 +133,9 @@
ll.sll_ifindex = l2->ifindex;
ll.sll_protocol = htons(proto);
ll.sll_halen = ETH_ALEN;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (proto == ETH_P_WAI) {
- os_memcpy(pos, dst_addr, ETH_ALEN); pos += ETH_ALEN;
- os_memcpy(pos, l2->own_addr, ETH_ALEN); pos += ETH_ALEN;
- os_memcpy(pos, &ll.sll_protocol, 2); pos += 2;
- os_memcpy(pos, buf, len);
- wpa_hexdump(MSG_MSGDUMP, "txbuf", txbuf, len + ETH_HLEN);
- ret = sendto(l2->fd, txbuf, len + ETH_HLEN, 0, (struct sockaddr *) &ll,
- sizeof(ll));
- wpa_printf(MSG_DEBUG, "%s: ret = '%d'", __FUNCTION__, ret);
- } else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_memcpy(ll.sll_addr, dst_addr, ETH_ALEN);
ret = sendto(l2->fd, buf, len, 0, (struct sockaddr *) &ll,
sizeof(ll));
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ret < 0) {
wpa_printf(MSG_ERROR, "l2_packet_send - sendto: %s",
strerror(errno));
@@ -180,56 +150,18 @@
struct l2_packet_data *l2 = eloop_ctx;
u8 buf[2300];
int res;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- struct l2_ethhdr l2_hdr;
- struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)l2->rx_callback_ctx;
- struct l2_packet_data *l2_wapi = wpa_s->l2_wapi;
- int is_wapi = 0;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct sockaddr_ll ll;
socklen_t fromlen;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- wpa_printf(MSG_DEBUG, "%s: l2=%p, wpa_s->l2_wapi=%p\n",
- __FUNCTION__, l2, l2_wapi);
- if (l2 == l2_wapi) {
- is_wapi = 1;
- os_memset(&l2_hdr, 0, sizeof(l2_hdr));
- res = recvfrom(sock, buf, sizeof(buf), 0, NULL, NULL);
- } else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_memset(&ll, 0, sizeof(ll));
fromlen = sizeof(ll);
res = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &ll,
&fromlen);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (res < 0) {
wpa_printf(MSG_DEBUG, "l2_packet_receive - recvfrom: %s",
strerror(errno));
return;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (is_wapi) {
- os_memcpy(&l2_hdr, buf, ETH_HLEN);
- l2_hdr.h_proto = ntohs (l2_hdr.h_proto);
- res -= ETH_HLEN;
- if (res > 0)
- os_memmove(buf, (char *)buf + ETH_HLEN, res);
- else
- res = 0;
- l2->rx_callback(l2->rx_callback_ctx, l2_hdr.h_source, buf, res);
- } else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_printf(MSG_DEBUG, "%s: src=" MACSTR " len=%d",
__func__, MAC2STR(ll.sll_addr), (int) res);
@@ -280,11 +212,6 @@
l2->last_from_br = 0;
#endif /* CONFIG_NO_LINUX_PACKET_SOCKET_WAR */
l2->rx_callback(l2->rx_callback_ctx, ll.sll_addr, buf, res);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -362,13 +289,6 @@
l2->fd_br_rx = -1;
#endif /* CONFIG_NO_LINUX_PACKET_SOCKET_WAR */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (protocol == ETH_P_WAI)
- l2->fd = socket(PF_PACKET, SOCK_RAW, htons(protocol));
- else
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
l2->fd = socket(PF_PACKET, l2_hdr ? SOCK_RAW : SOCK_DGRAM,
htons(protocol));
if (l2->fd < 0) {
@@ -449,25 +369,12 @@
return NULL;
#ifndef CONFIG_NO_LINUX_PACKET_SOCKET_WAR
- /*
- * The Linux packet socket behavior has changed over the years and there
- * is an inconvenient regression in it that breaks RX for a specific
- * protocol from interfaces in a bridge when that interface is not in
- * fully operation state (i.e., when in station mode and not completed
- * authorization). To work around this, register ETH_P_ALL version of
- * the packet socket bound to the real netdev and use socket filter to
- * match the ethertype value. This version is less efficient, but
- * required for functionality with many kernel version. If the main
- * packet socket is found to be working, this less efficient version
- * gets closed automatically.
- */
l2->fd_br_rx = socket(PF_PACKET, l2_hdr ? SOCK_RAW : SOCK_DGRAM,
htons(ETH_P_ALL));
if (l2->fd_br_rx < 0) {
wpa_printf(MSG_DEBUG, "%s: socket(PF_PACKET-fd_br_rx): %s",
__func__, strerror(errno));
- /* try to continue without the workaround RX socket */
return l2;
}
@@ -478,7 +385,6 @@
if (bind(l2->fd_br_rx, (struct sockaddr *) &ll, sizeof(ll)) < 0) {
wpa_printf(MSG_DEBUG, "%s: bind[PF_PACKET-fd_br_rx]: %s",
__func__, strerror(errno));
- /* try to continue without the workaround RX socket */
close(l2->fd_br_rx);
l2->fd_br_rx = -1;
return l2;
@@ -489,7 +395,6 @@
wpa_printf(MSG_DEBUG,
"l2_packet_linux: setsockopt(SO_ATTACH_FILTER) failed: %s",
strerror(errno));
- /* try to continue without the workaround RX socket */
close(l2->fd_br_rx);
l2->fd_br_rx = -1;
return l2;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.c b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.c
index af4edd7..c32884e 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.c
@@ -826,7 +826,6 @@
dev_name_changed = os_strncmp(dev->info.device_name, msg.device_name,
WPS_DEV_NAME_MAX_LEN) != 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_NAN
if (!freq && !scan_res && msg.listen_channel) {
@@ -836,7 +835,6 @@
dev->listen_freq = freq;
}
#endif /* CONFIG_BRCM_NAN */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
p2p_copy_wps_info(p2p, dev, 0, &msg);
@@ -968,12 +966,10 @@
c = &p2p->cfg->channels;
for (cl = 0; cl < c->reg_classes; cl++) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
if (p2p->find_type == P2P_FIND_FAST_PROGRESSIVE && cl > 0)
break;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
cla = &c->reg_class[cl];
if (cla->reg_class != p2p->last_prog_scan_class)
continue;
@@ -999,12 +995,10 @@
if (cl == c->reg_classes)
cl = 0;
ch = 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
if (p2p->find_type == P2P_FIND_FAST_PROGRESSIVE && cl > 0)
cl = 0;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
reg_class = c->reg_class[cl].reg_class;
channel = c->reg_class[cl].channel[ch];
@@ -1021,7 +1015,6 @@
return freq;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
static int p2p_get_next_prog_freq_5g(struct p2p_data *p2p)
{
@@ -1075,11 +1068,10 @@
return freq;
}
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void p2p_search(struct p2p_data *p2p)
{
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
int freq[MAX_FREQ_5G], i = 0, j;
#else
int freq = 0;
@@ -1100,7 +1092,7 @@
type = P2P_SCAN_FULL;
p2p_dbg(p2p, "Starting search (pending full scan)");
p2p->find_pending_full = 0;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
}
if (p2p->find_type == P2P_FIND_PROGRESSIVE &&
(freq[i] = p2p_get_next_prog_freq(p2p)) > 0) {
@@ -1356,7 +1348,7 @@
* scans for social channels and this specific channel.
*/
res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx,
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
P2P_SCAN_SPECIFIC, &freq,
#else
P2P_SCAN_SPECIFIC, freq,
@@ -1373,7 +1365,6 @@
p2p->req_dev_types, dev_id,
DEV_PW_DEFAULT);
break;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
case P2P_FIND_FAST_PROGRESSIVE:
res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,
@@ -1382,7 +1373,6 @@
DEV_PW_DEFAULT);
break;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case P2P_FIND_ONLY_SOCIAL:
res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,
p2p->num_req_dev_types,
@@ -1882,7 +1872,7 @@
void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len)
{
os_memcpy(ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_AUTOMOTIVE)
+#if defined(CONFIG_BRCM_AUTOMOTIVE)
if(p2p->ignore_random) {
os_memcpy(&ssid[P2P_WILDCARD_SSID_LEN],
p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);
@@ -1912,7 +1902,7 @@
p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len);
}
p2p->ssid_set = 0;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(ABOVE_10)
+#if defined(ABOVE_10)
if (p2p->passphrase_set) {
os_memcpy(params->passphrase, p2p->passphrase, os_strlen(p2p->passphrase));
} else {
@@ -3106,15 +3096,8 @@
if (os_get_random(&p2p->next_tie_breaker, 1) < 0)
p2p->next_tie_breaker = 0;
p2p->next_tie_breaker &= 0x01;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifndef CONFIG_BRCM_SD_DYNAMIC_CAPA
if (cfg->sd_request)
p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
-#endif /* CONFIG_BRCM_SD_DYNAMIC_CAPA */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (cfg->sd_request)
- p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;
if (cfg->concurrent_operations)
p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;
@@ -3716,11 +3699,9 @@
p2p_buf_add_service_hash(ies, p2p);
/* TODO: p2p_buf_add_operating_channel() if GO */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_NAN
p2p_buf_add_device_info(ies, p2p, NULL);
#endif/* CONFIG_BRCM_NAN */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
p2p_buf_update_ie_hdr(ies, len);
}
@@ -4761,12 +4742,6 @@
}
if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {
- /*
- * This should not really happen, but it looks like the Listen
- * command may fail is something else (e.g., a scan) was
- * running at an inconvenient time. As a workaround, allow new
- * Extended Listen operation to be started.
- */
p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again");
p2p->ext_listen_only = 0;
p2p_set_state(p2p, P2P_IDLE);
@@ -4929,7 +4904,7 @@
return p2p->cfg->channel;
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_AUTOMOTIVE)
+#if defined(CONFIG_BRCM_AUTOMOTIVE)
void p2p_set_ignore_random_ssid(struct p2p_data *p2p, int value)
{
p2p->ignore_random = value;
@@ -4966,8 +4941,7 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
int p2p_set_pref_freq_2g_5g(struct p2p_data *p2p, int pref_2g, int pref_5g)
{
p2p_dbg(p2p, "Set p2p pref 5G %u 2G %u channels",
@@ -4977,7 +4951,6 @@
return 0;
}
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan,
const struct p2p_channel *pref_chan)
@@ -5220,7 +5193,6 @@
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int p2p_set_interworking_ie(struct p2p_group *group)
{
@@ -5228,7 +5200,6 @@
return 0;
}
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie)
{
@@ -5354,15 +5325,13 @@
#endif /* CONFIG_WIFI_DISPLAY */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_AUTOMOTIVE) && defined (CONFIG_BRCM_BANDSTEER)
+#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_BRCM_BANDSTEER)
int p2p_set_device_id(struct p2p_group *group)
{
p2p_group_force_beacon_update_ies(group);
return 0;
}
#endif /* CONFIG_BRCM_AUTOMOTIVE && CONFIG_BRCM_BANDSTEER */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int,
int max_disc_tu)
@@ -5440,27 +5409,6 @@
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BCM_GENL
-int p2p_remove_peer(struct p2p_data *p2p, u8 *addr)
-{
- struct p2p_device *dev = NULL;
-
- if (!addr || !p2p)
- return -EINVAL;
-
- dev = p2p_get_device(p2p, addr);
-
- /* Free up the device from the dev list */
- if (dev) {
- dl_list_del(&dev->list);
- p2p_device_free(p2p, dev);
- }
-
- return 0;
-}
-#endif /* BCM_GENL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WPS_NFC
@@ -5772,7 +5720,6 @@
return buf;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
struct p2p_channels * p2p_get_channels(struct p2p_data *p2p)
{
@@ -5791,4 +5738,3 @@
return &p2p->op_channel;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.h b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.h
index 7ef71fb..f059404 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p.h
@@ -38,11 +38,9 @@
*/
#define P2P_MAX_REG_CLASS_CHANNELS 60
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
#define MAX_FREQ_5G 4
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* struct p2p_channels - List of supported channels
*/
@@ -319,11 +317,9 @@
P2P_SCAN_FULL,
P2P_SCAN_SPECIFIC,
P2P_SCAN_SOCIAL_PLUS_ONE
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
, P2P_SCAN_SOCIAL_PLUS_5G
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
#define P2P_MAX_WPS_VENDOR_EXT 10
@@ -553,12 +549,10 @@
u8 uuid[16];
u16 config_methods;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
int pref_freq_5g;
int pref_freq_2g;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* concurrent_operations - Whether concurrent operations are supported
*/
@@ -649,7 +643,7 @@
* then calling p2p_scan_res_handled() to indicate that all scan
* results have been indicated.
*/
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
int (*p2p_scan)(void *ctx, enum p2p_scan_type type, int freq[],
unsigned int num_req_dev_types,
const u8 *req_dev_types, const u8 *dev_id, u16 pw_id);
@@ -1246,7 +1240,6 @@
P2P_FIND_START_WITH_FULL,
P2P_FIND_ONLY_SOCIAL,
P2P_FIND_PROGRESSIVE
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
, P2P_FIND_FAST_PROGRESSIVE
#endif /* CONFIG_BRCM_RSDB */
@@ -1254,7 +1247,6 @@
, P2P_SEARCH_ONLY,
P2P_SEARCH_SINGLE_CHANNEL
#endif /* CONFIG_BRCM_NAN */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
/**
@@ -1324,27 +1316,6 @@
*/
void p2p_stop_listen(struct p2p_data *p2p);
-/**
- * p2p_connect - Start P2P group formation (GO negotiation)
- * @p2p: P2P module context from p2p_init()
- * @peer_addr: MAC address of the peer P2P client
- * @wps_method: WPS method to be used in provisioning
- * @go_intent: Local GO intent value (1..15)
- * @own_interface_addr: Intended interface address to use with the group
- * @force_freq: The only allowed channel frequency in MHz or 0
- * @persistent_group: Whether to create a persistent group (0 = no, 1 =
- * persistent group without persistent reconnect, 2 = persistent group with
- * persistent reconnect)
- * @force_ssid: Forced SSID for the group if we become GO or %NULL to generate
- * a new SSID
- * @force_ssid_len: Length of $force_ssid buffer
- * @pd_before_go_neg: Whether to send Provision Discovery prior to GO
- * Negotiation as an interoperability workaround when initiating group
- * formation
- * @pref_freq: Preferred operating frequency in MHz or 0 (this is only used if
- * force_freq == 0)
- * Returns: 0 on success, -1 on failure
- */
int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,
enum p2p_wps_method wps_method,
int go_intent, const u8 *own_interface_addr,
@@ -2279,8 +2250,7 @@
*/
int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan,
const struct p2p_channel *pref_chan);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
/**
* * p2p_set_pref_freq_2g_5g - set preferred channel for p2p interface
* * @p2p: P2P module context from p2p_init()
@@ -2291,7 +2261,6 @@
int p2p_set_pref_freq_2g_5g(struct p2p_data *p2p, int p2p_pref_freq_5g,
int p2p_pref_freq_2g);
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* p2p_set_no_go_freq - Set no GO channel ranges
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_build.c b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_build.c
index 63eb2e8..dc1e8d0 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_build.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_build.c
@@ -714,11 +714,6 @@
wpabuf_put_be16(buf, attr);
#ifndef CONFIG_WPS_STRICT
if (len == 0) {
- /*
- * Some deployed WPS implementations fail to parse zeor-length
- * attributes. As a workaround, send a space character if the
- * device attribute string is empty.
- */
if (wpabuf_tailroom(buf) < 3)
return -1;
wpabuf_put_be16(buf, 1);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_group.c b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_group.c
index a709fd6..2992183 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_group.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_group.c
@@ -236,8 +236,7 @@
len = p2p_buf_add_ie_hdr(ie);
p2p_group_add_common_ies(group, ie);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_AUTOMOTIVE) && defined (CONFIG_BRCM_BANDSTEER)
+#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_BRCM_BANDSTEER)
if ((p2p_group_get_freq(group) & 0x900) && !group->p2p->dev_id)
wpa_printf(MSG_ERROR,"%s Bandsteer is enabled removing p2p_device_id\n", __FUNCTION__);
else
@@ -245,9 +244,6 @@
#else
p2p_buf_add_device_id(ie, group->p2p->cfg->dev_addr);
#endif/* CONFIG_BRCM_AUTOMOTIVE && CONFIG_BRCM_BANDDSTEER */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- p2p_buf_add_device_id(ie, group->p2p->cfg->dev_addr);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
p2p_group_add_noa(ie, group->noa);
p2p_buf_update_ie_hdr(ie, len);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_i.h b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_i.h
index 95c8124..628f3a5 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_i.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_i.h
@@ -11,11 +11,9 @@
#include "utils/list.h"
#include "p2p.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
#include "ap/ap_config.h"
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define P2P_GO_NEG_CNF_MAX_RETRY_COUNT 1
@@ -351,7 +349,6 @@
* ssid_set - Whether SSID is already set for GO Negotiation
*/
int ssid_set;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
/**
* passphrase - WPA2-Personal passphrase for GO Negotiation (if local end will be GO)
@@ -363,7 +360,6 @@
*/
int passphrase_set;
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* Regulatory class for own operational channel
@@ -420,14 +416,6 @@
* srv_update_indic - Service Update Indicator for local services
*/
u16 srv_update_indic;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef CONFIG_BRCM_SD_DYNAMIC_CAPA
- /**
- * srv_count - Registered services count
- */
- u16 srv_count;
-#endif /* CONFIG_BRCM_SD_DYNAMIC_CAPA */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wpabuf *sd_resp; /* Fragmented SD response */
u8 sd_resp_addr[ETH_ALEN];
@@ -458,12 +446,10 @@
u8 last_prog_scan_class;
u8 last_prog_scan_chan;
unsigned int find_pending_full:1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
u8 last_prog_scan_class_5g;
u8 last_prog_scan_chan_5g;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int p2p_scan_running;
enum p2p_after_scan {
P2P_AFTER_SCAN_NOTHING,
@@ -580,7 +566,6 @@
/* Override option for preferred operating channel in GO Negotiation */
u8 override_pref_op_class;
u8 override_pref_channel;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int interworking;
int access_network_type;
@@ -597,7 +582,6 @@
int dev_id;
#endif
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
/**
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_pd.c b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_pd.c
index 604a918..cc4021b 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_pd.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_pd.c
@@ -14,11 +14,9 @@
#include "wps/wps_defs.h"
#include "p2p_i.h"
#include "p2p.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
#include "wpa_supplicant_i.h"
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
@@ -579,12 +577,10 @@
struct p2ps_feature_capab *req_fcap = NULL;
u8 remote_conncap;
u16 method;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
struct wpa_supplicant *wpa_s = p2p->cfg->cb_ctx;
wpa_s->rx_freq = rx_freq;
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (p2p_parse(data, len, &msg))
return;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_sd.c b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_sd.c
index 2e1183d..b0b52d3 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_sd.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/p2p/p2p_sd.c
@@ -873,7 +873,6 @@
const struct wpabuf *tlvs)
{
struct p2p_sd_query *q;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID_P2P
/* Currently, supplicant doesn't support more than one pending broadcast SD request.
* So reject if application is registering another one before cancelling the existing one.
@@ -887,7 +886,6 @@
}
}
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
q = os_zalloc(sizeof(*q));
if (q == NULL)
@@ -904,15 +902,6 @@
return NULL;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef CONFIG_BRCM_SD_DYNAMIC_CAPA
- /* When first service discovery query is registered,
- * enable the SD capability
- */
- if(p2p->cfg->sd_request && !p2p->sd_queries)
- p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
-#endif /* CONFIG_BRCM_SD_DYNAMIC_CAPA */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
q->next = p2p->sd_queries;
p2p->sd_queries = q;
p2p_dbg(p2p, "Added SD Query %p", q);
@@ -948,35 +937,9 @@
#endif /* CONFIG_WIFI_DISPLAY */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_SD_DYNAMIC_CAPA)
-void p2p_sd_service_update(struct p2p_data *p2p, int action)
-#else
void p2p_sd_service_update(struct p2p_data *p2p)
-#endif /* CONFIG_DRIVER_NL80211_IFX && CONFIG_BRCM_SD_DYNAMIC_CAPA */
{
p2p->srv_update_indic++;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef CONFIG_BRCM_SD_DYNAMIC_CAPA
- if(action == SRV_FLUSH)
- p2p->srv_count = 0;
- else if (action == SRV_DEL)
- p2p->srv_count--;
- else if (action == SRV_ADD)
- p2p->srv_count++;
-
- if(p2p->cfg->sd_request) {
- if (p2p->srv_count == 1) {
- /* First Service Registered. Enable SD capability */
- p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
- } else if (p2p->srv_count == 0 && !p2p->sd_queries) {
- /* No services remaining + No queries registered .
- * Remove the SD Capability
- */
- p2p->dev_capab &= ~P2P_DEV_CAPAB_SERVICE_DISCOVERY;
- }
- }
-#endif /* CONFIG_BRCM_SD_DYNAMIC_CAPA */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -985,16 +948,6 @@
if (p2p_unlink_sd_query(p2p, req)) {
p2p_dbg(p2p, "Cancel pending SD query %p", req);
p2p_free_sd_query(req);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef CONFIG_BRCM_SD_DYNAMIC_CAPA
- if(!p2p->sd_queries && p2p->cfg->sd_request && !p2p->srv_count) {
- /* If there are no SD queries or responses registered,
- * then disable the SD capability
- */
- p2p->dev_capab &= ~P2P_DEV_CAPAB_SERVICE_DISCOVERY;
- }
-#endif /* CONFIG_BRCM_SD_DYNAMIC_CAPA */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return 0;
}
return -1;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/pae/ieee802_1x_kay.c b/src/lynq/packages/thirdpart/lynq-wg870/src/pae/ieee802_1x_kay.c
index 2fe88ac..a638b8a 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/pae/ieee802_1x_kay.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/pae/ieee802_1x_kay.c
@@ -2134,14 +2134,6 @@
return -1;
}
- /* FIXME: A fresh SAK not generated until
- * the live peer list contains at least one peer and
- * MKA life time has elapsed since the prior SAK was first distributed,
- * or the Key server's potential peer is empty
- * but I can't understand the second item, so
- * here only check first item and ingore
- * && (!dl_list_empty(&participant->potential_peers))) {
- */
if ((time(NULL) - kay->dist_time) < MKA_LIFE_TIME / 1000) {
wpa_printf(MSG_ERROR,
"KaY: Life time has not elapsed since prior SAK distributed");
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/pmksa_cache.c b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/pmksa_cache.c
index bbbedf6..a3ed538 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/pmksa_cache.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/pmksa_cache.c
@@ -14,13 +14,11 @@
#include "wpa.h"
#include "wpa_i.h"
#include "pmksa_cache.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID11
/* android commit:126b1702 wifi: implement PMK cache interface and callback */
#include "wpa_supplicant_i.h"
#include "notify.h"
#endif /* CONFIG_ANDROID11 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#if defined(IEEE8021X_EAPOL) && !defined(CONFIG_NO_WPA)
@@ -272,12 +270,10 @@
wpa_printf(MSG_DEBUG, "RSN: Added PMKSA cache entry for " MACSTR
" network_ctx=%p akmp=0x%x", MAC2STR(entry->aa),
entry->network_ctx, entry->akmp);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID11
/* android commit:126b1702 wifi: implement PMK cache interface and callback */
wpas_notify_pmk_cache_added((struct wpa_supplicant *)pmksa->sm->ctx->ctx, entry);
#endif /* CONFIG_ANDROID11 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_sm_add_pmkid(pmksa->sm, entry->network_ctx, entry->aa, entry->pmkid,
entry->fils_cache_id_set ? entry->fils_cache_id : NULL,
entry->pmk, entry->pmk_len,
@@ -425,20 +421,18 @@
const u8 *aa, int akmp)
{
struct rsn_pmksa_cache_entry *entry = pmksa->pmksa;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
u8 pmkid_str[PMKID_LEN*2 + 1];
u8 *pmkid_strp = pmkid_str;
s32 i = 0;
os_memset(pmkid_strp, 0, PMKID_LEN*2 + 1);
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_printf(MSG_DEBUG, "RSN: Consider " MACSTR " for OKC", MAC2STR(aa));
if (network_ctx == NULL)
return NULL;
while (entry) {
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_OKC)
+#if defined(BRCM_OKC)
if((entry->network_ctx == network_ctx) &&
(!akmp || entry->akmp == akmp) &&
(os_memcmp(pmksa->sm->pmk, entry->pmk, PMK_LEN) == 0)) {
@@ -462,7 +456,7 @@
entry = pmksa_cache_clone_entry(pmksa, entry, aa);
if (entry) {
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_OKC)
+#if defined(BRCM_OKC)
for (i = 0; i < PMKID_LEN; i++)
pmkid_strp += os_snprintf((char *)pmkid_strp,
PMKID_LEN * 2 + 1, "%02x", entry->pmkid[i]);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/tdls.c b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/tdls.c
index 7c4ef19..5bdeae6 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/tdls.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/tdls.c
@@ -1795,12 +1795,6 @@
struct wpa_tdls_timeoutie *timeoutie;
struct wpa_tdls_lnkid *lnkid;
u32 lifetime = 0;
-#if 0
- struct rsn_ie_hdr *hdr;
- u8 *pos;
- u16 rsn_capab;
- u16 rsn_ver;
-#endif
u8 dtoken;
u16 ielen;
u16 status = WLAN_STATUS_UNSPECIFIED_FAILURE;
@@ -2059,43 +2053,6 @@
peer->tk_set = 0; /* A new nonce results in a new TK */
}
-#if 0
- /* get version info from RSNIE received from Peer */
- hdr = (struct rsn_ie_hdr *) kde.rsn_ie;
- rsn_ver = WPA_GET_LE16(hdr->version);
-
- /* use min(peer's version, out version) */
- if (rsn_ver > RSN_VERSION)
- rsn_ver = RSN_VERSION;
-
- hdr = (struct rsn_ie_hdr *) peer->rsnie_p;
-
- hdr->elem_id = WLAN_EID_RSN;
- WPA_PUT_LE16(hdr->version, rsn_ver);
- pos = (u8 *) (hdr + 1);
-
- RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED);
- pos += RSN_SELECTOR_LEN;
- /* Include only the selected cipher in pairwise cipher suite */
- WPA_PUT_LE16(pos, 1);
- pos += 2;
- if (cipher == WPA_CIPHER_CCMP)
- RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_CCMP);
- pos += RSN_SELECTOR_LEN;
-
- WPA_PUT_LE16(pos, 1);
- pos += 2;
- RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_TPK_HANDSHAKE);
- pos += RSN_SELECTOR_LEN;
-
- rsn_capab = WPA_CAPABILITY_PEERKEY_ENABLED;
- rsn_capab |= RSN_NUM_REPLAY_COUNTERS_16 << 2;
- WPA_PUT_LE16(pos, rsn_capab);
- pos += 2;
-
- hdr->len = (pos - peer->rsnie_p) - 2;
- peer->rsnie_p_len = pos - peer->rsnie_p;
-#endif
/* temp fix: validation of RSNIE later */
os_memcpy(peer->rsnie_p, peer->rsnie_i, peer->rsnie_i_len);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.c b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.c
index 9617286..db0d680 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.c
@@ -32,7 +32,6 @@
#include "pmksa_cache.h"
#include "wpa_i.h"
#include "wpa_ie.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_DHCP_HLP
#include <net/route.h>
#include <net/if.h>
@@ -43,14 +42,10 @@
#include "common/dhcp.h"
#include <sys/ioctl.h>
#endif /* BRCM_DHCP_HLP */
-#ifdef BRCM_CCX
-#include "wpa_cckm.h"
-#endif /* BRCM_CCX */
#if defined(BRCM_OKC) || defined(BRCM_VE) || defined(BRCM_ROAM_OFFLOAD)
#include "wpa_supplicant_i.h"
#include "driver_i.h"
#endif /* BRCM_OKC || BRCM_VE || BRCM_ROAM_OFFLOAD*/
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static const u8 null_rsc[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
@@ -310,7 +305,6 @@
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
#ifdef WL_SAE
else if(pmkid && sm->cur_pmksa &&
@@ -334,7 +328,6 @@
}
}
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (pmkid && sm->cur_pmksa &&
os_memcmp_const(pmkid, sm->cur_pmksa->pmkid, PMKID_LEN) == 0) {
wpa_hexdump(MSG_DEBUG, "RSN: matched PMKID", pmkid, PMKID_LEN);
@@ -614,15 +607,6 @@
os_memcpy(reply->key_nonce, nonce, WPA_NONCE_LEN);
wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG, "WPA: Sending EAPOL-Key 2/4");
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (wpa_key_mgmt_cckm(sm->key_mgmt))
- /* compute MIC with KRK instead of KCK only for M2 */
- return wpa_eapol_key_send(sm, &sm->ptk, ver, dst, ETH_P_EAPOL,
- rbuf, rlen, key_mic);
- else
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return wpa_eapol_key_send(sm, ptk, ver, dst, ETH_P_EAPOL, rbuf, rlen,
key_mic);
}
@@ -656,15 +640,6 @@
akmp |= WPA_KEY_MGMT_PSK_SHA256;
}
#endif /* CONFIG_OWE */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (wpa_key_mgmt_cckm(sm->key_mgmt)) {
- wpa_generate_krk_btk_cckm(sm, key->key_nonce);
- wpa_derive_ptk_cckm(sm, sm->bssid, ptk);
- return 0;
- }
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return wpa_pmk_to_ptk(sm->pmk, sm->pmk_len, "Pairwise key expansion",
sm->own_addr, sm->bssid, sm->snonce,
key->key_nonce, ptk, akmp,
@@ -1148,11 +1123,6 @@
int tx)
{
if (tx && sm->pairwise_cipher != WPA_CIPHER_NONE) {
- /* Ignore Tx bit for GTK if a pairwise key is used. One AP
- * seemed to set this bit (incorrectly, since Tx is only when
- * doing Group Key only APs) and without this workaround, the
- * data connection does not work because wpa_supplicant
- * configured non-zero keyidx to be used for unicast. */
wpa_msg(sm->ctx->msg_ctx, MSG_INFO,
"WPA: Tx bit set for GTK, but pairwise "
"keys are used - ignore Tx bit");
@@ -1277,19 +1247,6 @@
keyidx, 0, igtk->pn, sizeof(igtk->pn),
igtk->igtk, len, KEY_FLAG_GROUP_RX) < 0) {
if (keyidx == 0x0400 || keyidx == 0x0500) {
- /* Assume the AP has broken PMF implementation since it
- * seems to have swapped the KeyID bytes. The AP cannot
- * be trusted to implement BIP correctly or provide a
- * valid IGTK, so do not try to configure this key with
- * swapped KeyID bytes. Instead, continue without
- * configuring the IGTK so that the driver can drop any
- * received group-addressed robust management frames due
- * to missing keys.
- *
- * Normally, this error behavior would result in us
- * disconnecting, but there are number of deployed APs
- * with this broken behavior, so as an interoperability
- * workaround, allow the connection to proceed. */
wpa_msg(sm->ctx->msg_ctx, MSG_INFO,
"WPA: Ignore IGTK configuration error due to invalid IGTK KeyID byte order");
} else {
@@ -2680,7 +2637,6 @@
goto out;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
if (sm->rx_replay_counter_set &&
os_memcmp(key->replay_counter, sm->rx_replay_counter,
@@ -2706,7 +2662,6 @@
goto out;
}
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (sm->rx_replay_counter_set &&
os_memcmp(key->replay_counter, sm->rx_replay_counter,
WPA_REPLAY_COUNTER_LEN) <= 0) {
@@ -2964,13 +2919,12 @@
if (deauth) {
sm->pmk_len = 0;
os_memset(sm->pmk, 0, sizeof(sm->pmk));
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef BRCM_OKC
- wpa_sm_deauthenticate(sm, WLAN_REASON_UNSPECIFIED);
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ if (!sm->suppress_deauth_no_pmksa) {
+ wpa_sm_deauthenticate(sm, WLAN_REASON_UNSPECIFIED);
+ }
#endif /* BRCM_OKC */
-#else
- wpa_sm_deauthenticate(sm, WLAN_REASON_UNSPECIFIED);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
}
@@ -3293,6 +3247,8 @@
}
#endif /* CONFIG_FILS */
sm->beacon_prot = config->beacon_prot;
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ sm->suppress_deauth_no_pmksa = config->suppress_deauth_no_pmksa;
} else {
sm->network_ctx = NULL;
sm->allowed_pairwise_cipher = 0;
@@ -3752,29 +3708,6 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-int wpa_sm_set_ap_wapi_ie(struct wpa_sm *sm, const u8 *ie, size_t len)
-{
- if (sm == NULL)
- return -1;
- os_free(sm->ap_wapi_ie);
- if (ie == NULL || len == 0) {
- wpa_printf(MSG_DEBUG, " * WPA: clearing AP WAPI IE");
- sm->ap_wapi_ie = NULL;
- sm->ap_wapi_ie_len = 0;
- } else {
- wpa_hexdump(MSG_DEBUG, " * WPA: set AP WAPI IE", ie, len);
- sm->ap_wapi_ie = os_malloc(len);
- if (sm->ap_wapi_ie == NULL)
- return -1;
- os_memcpy(sm->ap_wapi_ie, ie, len);
- sm->ap_wapi_ie_len = len;
- }
- return 0;
-}
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* wpa_sm_set_ap_rsn_ie - Set AP RSN IE from Beacon/ProbeResp
@@ -3956,7 +3889,6 @@
pmksa_cache_flush(sm->pmksa, network_ctx, NULL, 0);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_VE
void wpa_sm_install_pmk(struct wpa_sm *sm)
{
@@ -3994,7 +3926,6 @@
}
}
#endif /* BRCM_VE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WNM
int wpa_wnmsleep_install_key(struct wpa_sm *sm, u8 subelem_id, u8 *buf)
@@ -4917,11 +4848,6 @@
if (!elems.rsn_ie) {
wpa_printf(MSG_DEBUG,
"FILS: No RSNE in (Re)Association Response");
- /* As an interop workaround, allow this for now since IEEE Std
- * 802.11ai-2016 did not include all the needed changes to make
- * a FILS AP include RSNE in the frame. This workaround might
- * eventually be removed and replaced with rejection (goto fail)
- * to follow a strict interpretation of the standard. */
} else if (wpa_compare_rsn_ie(wpa_key_mgmt_ft(sm->key_mgmt),
sm->ap_rsn_ie, sm->ap_rsn_ie_len,
elems.rsn_ie - 2, elems.rsn_ie_len + 2)) {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.h b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.h
index e7f1f6f..a2f02a4 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa.h
@@ -79,13 +79,6 @@
const struct hostapd_freq_params *params);
int (*tdls_disable_channel_switch)(void *ctx, const u8 *addr);
#endif /* CONFIG_TDLS */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- int (*get_rekey_request_number)(void *ctx, u32 *rn);
- int (*get_assoc_res_ies)(void *ctx, u8 *info, int len);
- int (*set_key_refresh_key)(void *ctx, const u8 *key);
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void (*set_rekey_offload)(void *ctx, const u8 *kek, size_t kek_len,
const u8 *kck, size_t kck_len,
const u8 *replay_ctr);
@@ -137,6 +130,8 @@
int owe_ptk_workaround;
const u8 *fils_cache_id;
int beacon_prot;
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ int suppress_deauth_no_pmksa;
};
#ifndef CONFIG_NO_WPA
@@ -164,11 +159,6 @@
int wpa_sm_set_ap_wpa_ie(struct wpa_sm *sm, const u8 *ie, size_t len);
int wpa_sm_set_ap_rsn_ie(struct wpa_sm *sm, const u8 *ie, size_t len);
int wpa_sm_set_ap_rsnxe(struct wpa_sm *sm, const u8 *ie, size_t len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-int wpa_sm_set_ap_wapi_ie(struct wpa_sm *sm, const u8 *ie, size_t len);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int wpa_sm_get_mib(struct wpa_sm *sm, char *buf, size_t buflen);
int wpa_sm_set_param(struct wpa_sm *sm, enum wpa_sm_conf_params param,
@@ -210,22 +200,18 @@
int wpa_sm_get_p2p_ip_addr(struct wpa_sm *sm, u8 *buf);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(BRCM_VE) || defined(BRCM_ROAM_OFFLOAD)
void wpa_sm_install_pmk(struct wpa_sm *sm);
void wpa_sm_notify_brcm_ft_reassoc(struct wpa_sm *sm, const u8 *bssid);
#endif /* BRCM_VE || BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void wpa_sm_set_rx_replay_ctr(struct wpa_sm *sm, const u8 *rx_replay_counter);
void wpa_sm_set_ptk_kck_kek(struct wpa_sm *sm,
const u8 *ptk_kck, size_t ptk_kck_len,
const u8 *ptk_kek, size_t ptk_kek_len);
int wpa_fils_is_completed(struct wpa_sm *sm);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_DHCP_HLP
void fils_process_hlp_container(struct wpa_sm *sm, const u8 *pos, size_t len);
#endif /* BRCM_DHCP_HLP */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#else /* CONFIG_NO_WPA */
@@ -403,13 +389,11 @@
{
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(BRCM_VE) || defined(BRCM_ROAM_OFFLOAD)
static inline void wpa_sm_install_pmk(struct wpa_sm *sm)
{
}
#endif /* BRCM_VE || BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static inline void wpa_sm_set_rx_replay_ctr(struct wpa_sm *sm,
const u8 *rx_replay_counter)
{
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_ft.c b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_ft.c
index bf73376..7058dfc 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_ft.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_ft.c
@@ -674,12 +674,6 @@
wpa_sm_mark_authenticated(sm, bssid);
ret = wpa_ft_install_ptk(sm, bssid);
if (ret) {
- /*
- * Some drivers do not support key configuration when we are
- * not associated with the target AP. Work around this by
- * trying again after the following reassociation gets
- * completed.
- */
wpa_printf(MSG_DEBUG, "FT: Failed to set PTK prior to "
"association - try again after reassociation");
sm->set_ptk_after_assoc = 1;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_i.h b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_i.h
index 365f85b..c029626 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_i.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/rsn_supp/wpa_i.h
@@ -103,12 +103,6 @@
size_t assoc_rsnxe_len;
u8 *ap_wpa_ie, *ap_rsn_ie, *ap_rsnxe;
size_t ap_wpa_ie_len, ap_rsn_ie_len, ap_rsnxe_len;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- u8 *ap_wapi_ie;
- size_t ap_wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_TDLS
struct wpa_tdls_peer *tdls;
@@ -153,15 +147,6 @@
u8 *assoc_resp_ies; /* MDIE and FTIE from (Re)Association Response */
size_t assoc_resp_ies_len;
#endif /* CONFIG_IEEE80211R */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- int cckm_reassoc_completed;
- u32 rn; /* reassociation request number (refreshed per session key) */
- /* fields of CCKM key hierarchy */
- u8 key_refresh_key[CCKM_KRK_LEN];
- u8 base_transient_key[CCKM_BTK_LEN];
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_P2P
u8 p2p_ip_addr[3 * 4];
@@ -205,6 +190,8 @@
struct wpabuf *dpp_z;
int dpp_pfs;
#endif /* CONFIG_DPP2 */
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ int suppress_deauth_no_pmksa;
};
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/tls/libtommath.c b/src/lynq/packages/thirdpart/lynq-wg870/src/tls/libtommath.c
index 7156744..c2f7a61 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/tls/libtommath.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/tls/libtommath.c
@@ -638,7 +638,8 @@
}
/* modified diminished radix reduction */
-#if defined(BN_MP_REDUCE_IS_2K_L_C) && defined(BN_MP_REDUCE_2K_L_C) && defined(BN_S_MP_EXPTMOD_C)
+#if defined(BN_MP_REDUCE_IS_2K_L_C) && defined(BN_MP_REDUCE_2K_L_C) && \
+ defined(BN_S_MP_EXPTMOD_C)
if (mp_reduce_is_2k_l(P) == MP_YES) {
return s_mp_exptmod(G, X, P, Y, 1);
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/common.h b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/common.h
index 610e619..8fc3c9e 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/common.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/common.h
@@ -17,7 +17,7 @@
#endif /* __linux__ */
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \
- defined(__OpenBSD__)
+ defined(__OpenBSD__)
#include <sys/types.h>
#include <sys/endian.h>
#define __BYTE_ORDER _BYTE_ORDER
@@ -341,13 +341,6 @@
#ifndef ETH_P_RRB
#define ETH_P_RRB 0x890D
#endif /* ETH_P_RRB */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#ifndef ETH_HLEN
-#define ETH_HLEN 14
-#endif /* ETH_HLEN */
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifndef ETH_P_OUI
#define ETH_P_OUI 0x88B7
#endif /* ETH_P_OUI */
@@ -355,11 +348,6 @@
#define ETH_P_8021Q 0x8100
#endif /* ETH_P_8021Q */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
-#define ETHER_TYPE_WAI 0x88b4
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef __GNUC__
#define PRINTF_FORMAT(a,b) __attribute__ ((format (printf, (a), (b))))
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.c b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.c
index a6cf1dc..c05c418 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.c
@@ -23,7 +23,7 @@
#endif
#if !defined(CONFIG_ELOOP_POLL) && !defined(CONFIG_ELOOP_EPOLL) && \
- !defined(CONFIG_ELOOP_KQUEUE)
+ !defined(CONFIG_ELOOP_KQUEUE)
#define CONFIG_ELOOP_SELECT
#endif
@@ -75,11 +75,6 @@
};
struct eloop_data {
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- void *user_data;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int max_sock;
size_t count; /* sum of all table counts */
@@ -165,18 +160,9 @@
#endif /* WPA_TRACE */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
-int eloop_init(void *user_data)
-#else
int eloop_init(void)
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
{
os_memset(&eloop, 0, sizeof(eloop));
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- eloop.user_data = user_data;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
dl_list_init(&eloop.timeout);
#ifdef CONFIG_ELOOP_EPOLL
eloop.epollfd = epoll_create1(0);
@@ -973,11 +959,7 @@
#ifndef CONFIG_NATIVE_WINDOWS
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
-void eloop_handle_alarm(int sig)
-#else
static void eloop_handle_alarm(int sig)
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
{
wpa_printf(MSG_ERROR, "eloop: could not process SIGINT or SIGTERM in "
"two seconds. Looks like there\n"
@@ -1366,14 +1348,6 @@
close(kfd);
#endif /* CONFIG_ELOOP_KQUEUE */
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-void * eloop_get_user_data(void)
-{
- return eloop.user_data;
-}
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_ELOOP_SELECT
#undef CONFIG_ELOOP_SELECT
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.h b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.h
index 77a9c1b..04ee6d1 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop.h
@@ -17,11 +17,6 @@
#ifndef ELOOP_H
#define ELOOP_H
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "wapi_config.h"
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* ELOOP_ALL_CTX - eloop_cancel_timeout() magic number to match all timeouts
*/
@@ -76,11 +71,7 @@
*
* This function must be called before any other eloop_* function.
*/
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
-int eloop_init(void *user_data);
-#else
int eloop_init(void);
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
/**
* eloop_register_read_sock - Register handler for read events
@@ -372,14 +363,5 @@
* Do a blocking wait for a single read socket.
*/
void eloop_wait_for_read_sock(int sock);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-/**
- * * eloop_get_user_data - Get global user data
- * * Returns: user_data pointer that was registered with eloop_init()
- * */
-void * eloop_get_user_data(void);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* ELOOP_H */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop_win.c b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop_win.c
index 74eaa33..764df5e 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop_win.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/eloop_win.c
@@ -419,20 +419,6 @@
/* TODO: replace with suitable signal handler */
-#if 0
-static void eloop_handle_signal(int sig)
-{
- size_t i;
-
- eloop.signaled++;
- for (i = 0; i < eloop.signal_count; i++) {
- if (eloop.signals[i].sig == sig) {
- eloop.signals[i].signaled++;
- break;
- }
- }
-}
-#endif
static void eloop_process_pending_signals(void)
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/os_unix.c b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/os_unix.c
index 591ce0f..0705a1b 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/utils/os_unix.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/utils/os_unix.c
@@ -12,20 +12,16 @@
#include <sys/wait.h>
#ifdef ANDROID
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(JB)
+#if defined(JB)
#include <linux/capability.h>
#else
#include <sys/capability.h>
#endif /* CONFIG_DRIVER_NL80211_IFX && JB */
#include <sys/prctl.h>
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android_commit:e0317907a: Use getpwnam() instead of AID_* macros */
#include <grp.h>
#include <pwd.h>
#include <sys/types.h>
-#else
-#include <private/android_filesystem_config.h>
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* ANDROID */
#ifdef __MACH__
@@ -351,7 +347,6 @@
unsigned int seed;
#ifdef ANDROID
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android_commit:e0317907a: Use getpwnam() instead of AID_* macros */
struct __user_cap_header_struct header;
struct __user_cap_data_struct cap;
@@ -359,21 +354,17 @@
gid_t gid_wifi = grp ? grp->gr_gid : 0;
struct passwd *pwd = getpwnam("wifi");
uid_t uid_wifi = pwd ? pwd->pw_uid : 0;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* We ignore errors here since errors are normal if we
* are already running as non-root.
*/
#ifdef ANDROID_SETGROUPS_OVERRIDE
gid_t groups[] = { ANDROID_SETGROUPS_OVERRIDE };
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android_commit:e0317907a: Use getpwnam() instead of AID_* macros */
if (!gid_wifi || !uid_wifi)
return -1;
setgroups(ARRAY_SIZE(groups), groups);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#else /* ANDROID_SETGROUPS_OVERRIDE */
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android_commit:e0317907a: Use getpwnam() instead of AID_* macros */
gid_t groups[4];
int group_idx = 0;
@@ -394,29 +385,14 @@
if (!groups[group_idx]) group_idx--;
setgroups(group_idx + 1, groups);
-#else
- gid_t groups[] = { AID_INET, AID_WIFI, AID_KEYSTORE };
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* ANDROID_SETGROUPS_OVERRIDE */
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android_commit:e0317907a: Use getpwnam() instead of AID_* macros */
-#else
- struct __user_cap_header_struct header;
- struct __user_cap_data_struct cap;
-
- setgroups(ARRAY_SIZE(groups), groups);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android_commit:e0317907a: Use getpwnam() instead of AID_* macros */
setgid(gid_wifi);
setuid(uid_wifi);
-#else
- setgid(AID_WIFI);
- setuid(AID_WIFI);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
header.version = _LINUX_CAPABILITY_VERSION;
header.pid = 0;
@@ -467,7 +443,7 @@
int os_unsetenv(const char *name)
{
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || \
- defined(__OpenBSD__)
+ defined(__OpenBSD__)
unsetenv(name);
return 0;
#else
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_enrollee.c b/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_enrollee.c
index 819cd43..738c512 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_enrollee.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_enrollee.c
@@ -121,15 +121,6 @@
if (wps->wps->ap && !wps->pbc_in_m1 &&
(wps->dev_password_len != 0 ||
(config_methods & WPS_CONFIG_DISPLAY))) {
- /*
- * These are the methods that the AP supports as an Enrollee
- * for adding external Registrars, so remove PushButton.
- *
- * As a workaround for Windows 7 mechanism for probing WPS
- * capabilities from M1, leave PushButton option if no PIN
- * method is available or if WPS configuration enables PBC
- * workaround.
- */
config_methods &= ~WPS_CONFIG_PUSHBUTTON;
config_methods &= ~(WPS_CONFIG_VIRT_PUSHBUTTON |
WPS_CONFIG_PHY_PUSHBUTTON);
@@ -254,11 +245,6 @@
{
u16 auth_type = wps->wps->ap_auth_type;
- /*
- * Work around issues with Windows 7 WPS implementation not liking
- * multiple Authentication Type bits in M7 AP Settings attribute by
- * showing only the most secure option from current configuration.
- */
if (auth_type & WPS_AUTH_WPA2PSK)
auth_type = WPS_AUTH_WPA2PSK;
else if (auth_type & WPS_AUTH_WPAPSK)
@@ -278,11 +264,6 @@
{
u16 encr_type = wps->wps->ap_encr_type;
- /*
- * Work around issues with Windows 7 WPS implementation not liking
- * multiple Encryption Type bits in M7 AP Settings attribute by
- * showing only the most secure option from current configuration.
- */
if (wps->wps->ap_auth_type & (WPS_AUTH_WPA2PSK | WPS_AUTH_WPAPSK)) {
if (encr_type & WPS_ENCR_AES)
encr_type = WPS_ENCR_AES;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_ssdp.c b/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_ssdp.c
index a685ce4..61a32c8 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_ssdp.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_ssdp.c
@@ -536,22 +536,6 @@
* Note that Microsoft sometimes does funny
* stuff with the HOST: line.
*/
-#if 0 /* could be */
- data += token_length(data);
- data += word_separation_length(data);
- if (*data != ':')
- goto bad;
- data++;
- data += word_separation_length(data);
- /* UPNP_MULTICAST_ADDRESS */
- if (!str_starts(data, "239.255.255.250"))
- goto bad;
- data += os_strlen("239.255.255.250");
- if (*data == ':') {
- if (!str_starts(data, ":1900"))
- goto bad;
- }
-#endif /* could be */
got_host = 1;
continue;
} else if (token_eq(data, "st")) {
@@ -589,14 +573,6 @@
st_match = 1;
continue;
}
-#if 0
- /* FIX: should we really reply to IGD string? */
- if (str_starts(data, "urn:schemas-upnp-org:device:"
- "InternetGatewayDevice:1")) {
- st_match = 1;
- continue;
- }
-#endif
if (str_starts(data, "urn:schemas-wifialliance-org:"
"service:WFAWLANConfig:1")) {
st_match = 1;
@@ -876,12 +852,6 @@
#endif /* __linux__ */
}
-#if 0 /* maybe ok if we sometimes block on writes */
- if (fcntl(sd, F_SETFL, O_NONBLOCK) != 0) {
- close(sd);
- return -1;
- }
-#endif
if (setsockopt(sd, IPPROTO_IP, IP_MULTICAST_IF,
&ip_addr, sizeof(ip_addr))) {
@@ -898,26 +868,6 @@
return -1;
}
-#if 0 /* not needed, because we don't receive using multicast_sd */
- {
- struct ip_mreq mreq;
- mreq.imr_multiaddr.s_addr = inet_addr(UPNP_MULTICAST_ADDRESS);
- mreq.imr_interface.s_addr = ip_addr;
- wpa_printf(MSG_DEBUG, "WPS UPnP: Multicast addr 0x%x if addr "
- "0x%x",
- mreq.imr_multiaddr.s_addr,
- mreq.imr_interface.s_addr);
- if (setsockopt(sd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq,
- sizeof(mreq))) {
- wpa_printf(MSG_ERROR,
- "WPS UPnP: setsockopt "
- "IP_ADD_MEMBERSHIP errno %d (%s)",
- errno, strerror(errno));
- close(sd);
- return -1;
- }
- }
-#endif /* not needed */
/*
* TODO: What about IP_MULTICAST_LOOP? It seems to be on by default?
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_web.c b/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_web.c
index 3c5a97c..2f336ea 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_web.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/src/wps/wps_upnp_web.c
@@ -1046,16 +1046,6 @@
continue;
}
/* HOST should refer to us */
-#if 0
- match = "HOST:";
- match_len = os_strlen(match);
- if (os_strncasecmp(h, match, match_len) == 0) {
- h += match_len;
- while (*h == ' ' || *h == '\t')
- h++;
- .....
- }
-#endif
/* CALLBACK gives one or more URLs for NOTIFYs
* to be sent as a result of the subscription.
* Each URL is enclosed in angle brackets.
@@ -1237,16 +1227,6 @@
break; /* no unterminated lines allowed */
/* HOST should refer to us */
-#if 0
- match = "HOST:";
- match_len = os_strlen(match);
- if (os_strncasecmp(h, match, match_len) == 0) {
- h += match_len;
- while (*h == ' ' || *h == '\t')
- h++;
- .....
- }
-#endif
match = "SID:";
match_len = os_strlen(match);
if (os_strncasecmp(h, match, match_len) == 0) {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.c
index 6d1be11..21f7531 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.c
@@ -38,11 +38,6 @@
#include "ap/sta_info.h"
#include "notify.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
-void brcm_wapiap_initialize(void *ctx, int wapiap_tx_sock, struct i802_bss *bss, struct wpa_ssid *ssid);
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WPS
static void wpas_wps_ap_pin_timeout(void *eloop_data, void *user_ctx);
@@ -90,15 +85,11 @@
if (hostapd_get_oper_chwidth(conf) == CHANWIDTH_80P80MHZ) {
ieee80211_freq_to_chan(ssid->vht_center_freq2,
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_AP_VHT
&conf->vht_oper_centr_freq_seg1_idx);
#else /* CONFIG_AP_VHT */
&freq_seg_idx);
#endif /* CONFIG_AP_VHT */
-#else
- &freq_seg_idx);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
hostapd_set_oper_centr_freq_seg1_idx(conf, freq_seg_idx);
}
@@ -116,7 +107,6 @@
return;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_BRCM_RSDB)
if (wpa_s->conf->p2p_pref_freq_2g && wpa_s->conf->p2p_pref_freq_5g) {
int freq, num;
@@ -137,7 +127,6 @@
}
}
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_P2P
switch (hostapd_get_oper_chwidth(conf)) {
case CHANWIDTH_80MHZ:
@@ -211,7 +200,6 @@
return mode;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_SAE
static int wpas_conf_ap_sae_password(struct hostapd_bss_config *bss, const char *sae_pwd)
{
@@ -236,7 +224,6 @@
return -1;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int wpa_supplicant_conf_ap_ht(struct wpa_supplicant *wpa_s,
struct wpa_ssid *ssid,
@@ -250,7 +237,6 @@
ssid->frequency);
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_BRCM_RSDB)
if (wpa_s->conf->p2p_pref_freq_2g && wpa_s->conf->p2p_pref_freq_5g) {
int freq, num;
@@ -271,7 +257,6 @@
}
}
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* Enable HT20 if the driver supports it, by setting conf->ieee80211n
@@ -352,7 +337,6 @@
if (!ssid->p2p_group &&
(mode->ht_capab &
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CY_AUTO_SET_BW
/* Fix to resolve softap creation failure on 5G/80 */
HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET) &&
@@ -363,10 +347,6 @@
HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) {
conf->secondary_channel = ssid->ht40;
#endif /* CONFIG_CY_AUTO_SET_BW */
-#else
- HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) {
- conf->secondary_channel = ssid->ht40;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_printf(MSG_DEBUG,
"HT secondary channel offset %d for AP",
conf->secondary_channel);
@@ -707,15 +687,6 @@
* require user interaction to actually use it. Only the internal
* Registrar is supported.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- /* Disable WPS feature if WAPI-AP is enabled */
- if (bss->wpa_key_mgmt == WPA_KEY_MGMT_WAPI_PSK) {
- wpa_printf(MSG_DEBUG, "%s: Disabling WPS feature\n", __FUNCTION__);
- goto no_wps;
- }
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (bss->ssid.security_policy != SECURITY_WPA_PSK &&
bss->ssid.security_policy != SECURITY_PLAINTEXT)
goto no_wps;
@@ -923,7 +894,10 @@
struct hostapd_iface *hapd_iface;
struct hostapd_config *conf;
size_t i;
-#ifdef CONFIG_DRIVER_NL80211_IFX
+#if !defined(HOSTAPD)
+ struct wpa_global *global;
+ struct wpa_supplicant *wpa_last;
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_CY_AUTO_SET_BW
/* Fix to create supplicant based softap on best channel
instead of random channel when specifying freq=2 or freq=5 */
@@ -931,32 +905,23 @@
int chan,freq;
u8 opclass;
#endif /* CONFIG_CY_AUTO_SET_BW */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ssid->ssid == NULL || ssid->ssid_len == 0) {
wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
if (ssid->vht == -1 && ssid->ht40 == -1) {
wpa_printf(MSG_ERROR, "No Channel width configured for AP mode");
return -1;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_supplicant_ap_deinit(wpa_s);
wpa_printf(MSG_DEBUG, "Setting up AP (SSID='%s')",
wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_PSK)
- brcm_wapiap_initialize(wpa_s, wpa_s->wapi_tx_sock, wpa_s->wapi_bss, ssid);
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_memset(¶ms, 0, sizeof(params));
params.ssid = ssid->ssid;
params.ssid_len = ssid->ssid_len;
@@ -969,7 +934,6 @@
default:
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CY_AUTO_SET_BW
/* Fix to create supplicant based softap on best channel
instead of random channel when specifying freq=2 or freq=5 */
@@ -978,6 +942,10 @@
return -1;
hapd_iface->owner = wpa_s;
hapd_iface->drv_flags = wpa_s->drv_flags;
+ /* Support for 4-way handshake offload to internal supplicant
+ * for WPA/WPA2-PSK
+ */
+ hapd_iface->drv_flags2 = wpa_s->drv_flags2;
hapd_iface->probe_resp_offloads = wpa_s->probe_resp_offloads;
hapd_iface->extended_capa = wpa_s->extended_capa;
hapd_iface->extended_capa_mask = wpa_s->extended_capa_mask;
@@ -1008,10 +976,6 @@
if (ssid->frequency == 0)
ssid->frequency = 2462; /* default channel 11 */
#endif /* CONFIG_CY_AUTO_SET_BW */
-#else
- if (ssid->frequency == 0)
- ssid->frequency = 2462; /* default channel 11 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
params.freq.freq = ssid->frequency;
if ((ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO) &&
@@ -1032,12 +996,6 @@
params.wpa_proto = ssid->proto;
if (ssid->key_mgmt & WPA_KEY_MGMT_PSK)
wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- else if (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_PSK)
- wpa_s->key_mgmt = WPA_KEY_MGMT_WAPI_PSK;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
else
wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
params.key_mgmt_suite = wpa_s->key_mgmt;
@@ -1079,23 +1037,6 @@
return -1;
}
-#ifndef CONFIG_DRIVER_NL80211_IFX
- wpa_s->ap_iface = hapd_iface = hostapd_alloc_iface();
- if (hapd_iface == NULL)
- return -1;
- hapd_iface->owner = wpa_s;
- hapd_iface->drv_flags = wpa_s->drv_flags;
- hapd_iface->probe_resp_offloads = wpa_s->probe_resp_offloads;
- hapd_iface->extended_capa = wpa_s->extended_capa;
- hapd_iface->extended_capa_mask = wpa_s->extended_capa_mask;
- hapd_iface->extended_capa_len = wpa_s->extended_capa_len;
-
- wpa_s->ap_iface->conf = conf = hostapd_config_defaults();
- if (conf == NULL) {
- wpa_supplicant_ap_deinit(wpa_s);
- return -1;
- }
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_memcpy(wpa_s->ap_iface->conf->wmm_ac_params,
wpa_s->conf->wmm_ac_params,
@@ -1109,13 +1050,11 @@
conf->bss[0]->wmm_uapsd = 1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
if (wpa_s->conf->replay_cntrs) {
conf->bss[0]->replay_cntrs = wpa_s->conf->replay_cntrs;
}
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_supplicant_conf_ap(wpa_s, ssid, conf)) {
wpa_printf(MSG_ERROR, "Failed to create AP configuration");
wpa_supplicant_ap_deinit(wpa_s);
@@ -1174,12 +1113,10 @@
hapd_iface->bss[i]->ext_eapol_frame_io =
wpa_s->ext_eapol_frame_io;
#endif /* CONFIG_TESTING_OPTIONS */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
if (wpa_s->conf)
hapd_iface->bss[i]->conf->ignore_broadcast_ssid = wpa_s->conf->ignore_broadcast_ssid;
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
os_memcpy(hapd_iface->bss[0]->own_addr, wpa_s->own_addr, ETH_ALEN);
@@ -1201,6 +1138,27 @@
}
#endif /* CONFIG_P2P && CONFIG_ACS */
+#if !defined(HOSTAPD)
+ if (!wpa_s->global->rsdb_flag) {
+ global = wpa_s->global;
+ for (wpa_last = global->ifaces; wpa_last; wpa_last = wpa_last->next)
+ if (os_strcmp(wpa_s->ifname, wpa_last->ifname) == 0 ||
+ os_strcmp(wpa_last->ifname, "wlan0") == 0 ||
+ os_strcmp(wpa_last->ifname, "p2p-dev-wlan0") == 0)
+ continue;
+ else if (wpa_last->ap_iface->bss != NULL &&
+ wpa_last->ap_iface->bss[0]->num_sta > 0) {
+ ssid = wpa_config_get_network(wpa_s->conf, 0);
+ if (ssid == NULL)
+ return;
+ if (ssid->disabled == 2)
+ return;
+ wpa_supplicant_disable_network(wpa_s, ssid);
+ return -1;
+ }
+ }
+#endif /* !HOSTAPD && CONFIG_DRIVER_NL80211_IFX */
+
if (hostapd_setup_interface(wpa_s->ap_iface)) {
wpa_printf(MSG_ERROR, "Failed to initialize AP interface");
wpa_supplicant_ap_deinit(wpa_s);
@@ -1715,7 +1673,7 @@
if (!iface)
return;
wpa_s->assoc_freq = freq;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_GO_CH_SWITCH_NOTIFY)
+#if defined(CONFIG_BRCM_GO_CH_SWITCH_NOTIFY)
wpa_s->current_ssid->frequency = freq;
#else
if (wpa_s->current_ssid)
@@ -2004,7 +1962,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
void wpas_ap_set_interworking_ie(struct wpa_supplicant *wpa_s)
{
@@ -2013,4 +1970,3 @@
wpa_printf(MSG_DEBUG, "%s: ret:%d\n", __FUNCTION__, ret);
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.h
index ad5fe4a..caff3a2 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ap.h
@@ -102,9 +102,7 @@
void ap_periodic(struct wpa_supplicant *wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
void wpas_ap_set_interworking_ie(struct wpa_supplicant *wpa_s);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* AP_H */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.c
index 48ebfcd..e9c2f82 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.c
@@ -463,11 +463,6 @@
os_memcpy(bss->ssid, ssid, ssid_len);
bss->ssid_len = ssid_len;
bss->ie_len = res->ie_len;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- bss->wapi_ie_len = res->wapi_ie_len;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
bss->beacon_ie_len = res->beacon_ie_len;
os_memcpy(bss->ies, res + 1, res->ie_len + res->beacon_ie_len);
wpa_bss_set_hessid(bss);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.h
index 2002140..af82ca3 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/bss.h
@@ -110,11 +110,6 @@
size_t ie_len;
/** Length of the following Beacon IE field in octets */
size_t beacon_ie_len;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- size_t wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* followed by ie_len octets of IEs */
/* followed by beacon_ie_len octets of IEs */
u8 ies[];
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.c
index ef070ec..53f941e 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.c
@@ -5,11 +5,6 @@
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_FEATURES_COPYRIGHT
-/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "includes.h"
@@ -202,14 +197,12 @@
#endif /* NO_CONFIG_WRITE */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
void wpa_config_set_frequency(struct wpa_ssid *ssid, int val)
{
ssid->frequency = val;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_config_parse_int(const struct parse_data *data,
struct wpa_ssid *ssid,
int line, const char *value)
@@ -220,19 +213,15 @@
dst = (int *) (((u8 *) ssid) + (long) data->param1);
val = strtol(value, &end, 0);
if (*end) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
if (os_strcmp(data->name, "frequency") != 0) {
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_printf(MSG_ERROR, "Line %d: invalid number \"%s\"",
line, value);
return -1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
if (*dst == val)
@@ -650,14 +639,6 @@
val |= WPA_PROTO_RSN;
else if (os_strcmp(start, "OSEN") == 0)
val |= WPA_PROTO_OSEN;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else if (os_strcmp(start, "WAPI") == 0) {
- val |= WPA_PROTO_WAPI;
- wpa_printf(MSG_DEBUG, "WAPI network\n");
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
else {
wpa_printf(MSG_ERROR, "Line %d: invalid proto '%s'",
line, start);
@@ -720,16 +701,6 @@
pos += ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (ssid->proto & WPA_PROTO_WAPI) {
- ret = os_snprintf(pos, end - pos, "%sWAPI", pos == buf ? "" : " ");
- if (ret < 0 || ret >= end - pos)
- return buf;
- pos += ret;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (pos == buf) {
os_free(buf);
buf = NULL;
@@ -772,15 +743,6 @@
val |= WPA_KEY_MGMT_NONE;
else if (os_strcmp(start, "WPA-NONE") == 0)
val |= WPA_KEY_MGMT_WPA_NONE;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else if (os_strcmp(start, "WAPI-PSK") == 0)
- val |= WPA_KEY_MGMT_WAPI_PSK;
- else if (os_strcmp(start, "WAPI-CERT") == 0) {
- val |= WPA_KEY_MGMT_WAPI_CERT;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_IEEE80211R
else if (os_strcmp(start, "FT-PSK") == 0)
val |= WPA_KEY_MGMT_FT_PSK;
@@ -795,12 +757,6 @@
val |= WPA_KEY_MGMT_PSK_SHA256;
else if (os_strcmp(start, "WPA-EAP-SHA256") == 0)
val |= WPA_KEY_MGMT_IEEE8021X_SHA256;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- else if (os_strcmp(start, "CCKM") == 0)
- val |= WPA_KEY_MGMT_CCKM;
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WPS
else if (os_strcmp(start, "WPS") == 0)
val |= WPA_KEY_MGMT_WPS;
@@ -865,18 +821,6 @@
return 1;
wpa_printf(MSG_MSGDUMP, "key_mgmt: 0x%x", val);
ssid->key_mgmt = val;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if ( (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_PSK) && (ssid->wapi != 7) ) {
- ssid->wapi = 7;
- wpa_printf(MSG_DEBUG, "WPA_KEY_MGMT_WAPI_PSK");
- }
- if ( (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_CERT) && (ssid->wapi != 11) ) {
- ssid->wapi = 11;
- wpa_printf(MSG_DEBUG, "WPA_KEY_MGMT_WAPI_CERT");
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return errors ? -1 : 0;
}
@@ -942,28 +886,6 @@
}
pos += ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_PSK) {
- ret = os_snprintf(pos, end - pos, "%sWAPI-PSK",
- pos == buf ? "" : " ");
- if (ret < 0 || ret >= end - pos) {
- end[-1] = '\0';
- return buf;
- }
- pos += ret;
- }
- if (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_CERT) {
- ret = os_snprintf(pos, end - pos, "%sWAPI-CERT",
- pos == buf ? "" : " ");
- if (ret < 0 || ret >= end - pos) {
- end[-1] = '\0';
- return buf;
- }
- pos += ret;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_IEEE80211R
if (ssid->key_mgmt & WPA_KEY_MGMT_FT_PSK) {
@@ -1031,13 +953,6 @@
}
#endif /* CONFIG_WPS */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (ssid->key_mgmt & WPA_KEY_MGMT_CCKM)
- pos += os_snprintf(pos, end - pos, "%sCCKM",
- pos == buf ? "" : " ");
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_SAE
if (ssid->key_mgmt & WPA_KEY_MGMT_SAE) {
ret = os_snprintf(pos, end - pos, "%sSAE",
@@ -1221,12 +1136,7 @@
val = wpa_config_parse_cipher(line, value);
if (val == -1)
return -1;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (val & ~(WPA_CIPHER_CCMP | WPA_CIPHER_GCMP | WPA_CIPHER_TKIP |
- WPA_CIPHER_NONE | WPA_CIPHER_SMS4)) {
-#else
if (val & ~WPA_ALLOWED_PAIRWISE_CIPHERS) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
wpa_printf(MSG_ERROR, "Line %d: not allowed pairwise cipher "
"(0x%x).", line, val);
return -1;
@@ -1257,10 +1167,6 @@
val = wpa_config_parse_cipher(line, value);
if (val == -1)
return -1;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (val & ~(WPA_CIPHER_CCMP | WPA_CIPHER_GCMP | WPA_CIPHER_TKIP |
- WPA_CIPHER_WEP104 | WPA_CIPHER_WEP40 | WPA_CIPHER_SMS4)) {
-#else
/*
* Backwards compatibility - filter out WEP ciphers that were previously
@@ -1269,7 +1175,6 @@
val &= ~(WPA_CIPHER_WEP104 | WPA_CIPHER_WEP40);
if (val & ~WPA_ALLOWED_GROUP_CIPHERS) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
wpa_printf(MSG_ERROR, "Line %d: not allowed group cipher "
"(0x%x).", line, val);
return -1;
@@ -2484,16 +2389,6 @@
{ FUNC(auth_alg) },
{ FUNC(scan_freq) },
{ FUNC(freq_list) },
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- { INT(wapi) },
- { INT(psk_key_type) },
- { INT(cert_index) },
- { STR(wapi_user_cert) },
- { STR(wapi_as_cert) },
- { STR(cert_name) },
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
{ INT_RANGE(ht, 0, 1) },
{ INT_RANGE(vht, 0, 1) },
{ INT_RANGE(ht40, -1, 1) },
@@ -2701,6 +2596,8 @@
{ INT_RANGE(beacon_prot, 0, 1) },
{ INT_RANGE(transition_disable, 0, 255) },
{ INT_RANGE(sae_pk, 0, 2) },
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ { INT_RANGE(suppress_deauth_no_pmksa, 0, 1) },
};
#undef OFFSET
@@ -2879,13 +2776,6 @@
os_free(ssid->scan_freq);
os_free(ssid->freq_list);
os_free(ssid->bgscan);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- os_free(ssid->cert_name);
- os_free(ssid->wapi_user_cert);
- os_free(ssid->wapi_as_cert);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_free(ssid->p2p_client_list);
os_free(ssid->bssid_blacklist);
os_free(ssid->bssid_whitelist);
@@ -3028,14 +2918,9 @@
#ifdef CONFIG_MBO
os_free(config->non_pref_chan);
#endif /* CONFIG_MBO */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AGO_PASSPHRASE
os_free(config->ago_passphrase);
#endif /* CONFIG_BRCM_AGO_PASSPHRASE */
-#else
- os_free(config->dpp_name);
- os_free(config->dpp_mud_url);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_free(config);
}
@@ -3176,11 +3061,6 @@
ssid->eap.fragment_size = DEFAULT_FRAGMENT_SIZE;
ssid->eap.sim_num = DEFAULT_USER_SELECTED_SIM;
#endif /* IEEE8021X_EAPOL */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- ssid->wapi = 0;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_MESH
ssid->dot11MeshMaxRetries = DEFAULT_MESH_MAX_RETRIES;
ssid->dot11MeshRetryTimeout = DEFAULT_MESH_RETRY_TIMEOUT;
@@ -3263,25 +3143,6 @@
}
ret = -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- else {
- wpa_printf(MSG_DEBUG, "parse(%s, %s) succeeded\n", var, value);
- if (os_strcmp(var, "wapi_as_cert") == 0) {
- wpa_printf(MSG_DEBUG, "%s: ssid->wapi_as_cert=%s\n",
- __FUNCTION__, ssid->wapi_as_cert);
- }
- if (os_strcmp(var, "wapi_user_cert") == 0) {
- wpa_printf(MSG_DEBUG, "%s: ssid->wapi_user_cert=%s\n",
- __FUNCTION__, ssid->wapi_user_cert);
- }
- if (os_strcmp(var, "cert_name") == 0) {
- wpa_printf(MSG_DEBUG, "%s: ssid->cert_name=%s\n",
- __FUNCTION__, ssid->cert_name);
- }
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_SAE
if (os_strcmp(var, "ssid") == 0 ||
os_strcmp(var, "psk") == 0 ||
@@ -4483,11 +4344,9 @@
DEFAULT_DISASSOC_IMMINENT_RSSI_THRESHOLD;
config->oce = DEFAULT_OCE_SUPPORT;
#endif /* CONFIG_MBO */
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* TODO: Need to revisit if this change added accidentally */
os_free(config->dpp_name);
os_free(config->dpp_mud_url);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ctrl_interface)
config->ctrl_interface = os_strdup(ctrl_interface);
@@ -5191,12 +5050,10 @@
{ INT_RANGE(p2p_go_ctwindow, 0, 127), 0 },
{ INT(p2p_no_group_iface), 0 },
{ INT_RANGE(p2p_ignore_shared_freq, 0, 1), 0 },
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined CONFIG_BRCM_RSDB
{ INT(p2p_pref_freq_5g), CFG_CHANGED_P2P_FREQ_2G_5G},
{ INT(p2p_pref_freq_2g), CFG_CHANGED_P2P_FREQ_2G_5G},
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
{ IPV4(ip_addr_go), 0 },
{ IPV4(ip_addr_mask), 0 },
{ IPV4(ip_addr_start), 0 },
@@ -5257,23 +5114,19 @@
{ INT(mac_addr), 0 },
{ INT(rand_addr_lifetime), 0 },
{ INT(preassoc_mac_addr), 0 },
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AGO_PASSPHRASE
{ STR_RANGE(ago_passphrase, 8, 63), CFG_CHANGED_AGO_PASSPHRASE },
#endif /* CONFIG_BRCM_AGO_PASSPHRASE */
#ifdef BRCM_ROAM_OFFLOAD
{INT(roam_offload), 0},
#endif /* BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
{ INT(key_mgmt_offload), 0},
{ INT(passive_scan), 0 },
{ INT(reassoc_same_bss_optim), 0 },
{ INT(wps_priority), 0},
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
{ INT_RANGE(replay_cntrs, 0, 3), 0},
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_FST
{ STR_RANGE(fst_group_id, 1, FST_MAX_GROUP_ID_LEN), 0 },
{ INT_RANGE(fst_priority, 1, FST_MAX_PRIO_VALUE), 0 },
@@ -5300,20 +5153,16 @@
{ STR(dpp_mud_url), 0 },
#endif /* CONFIG_DPP */
{ INT_RANGE(coloc_intf_reporting, 0, 1), 0 },
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
{ INT_RANGE(bss_no_flush_when_down, 0, 1), 0 },
#endif /* ABOVE_10 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WNM
{ INT_RANGE(disable_btm, 0, 1), CFG_CHANGED_DISABLE_BTM },
{ INT_RANGE(extended_key_id, 0, 1), 0 },
#endif /* CONFIG_WNM */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_DRIVER_NL80211_BRCM
{INT(offload_4way_handshake), CFG_CHANGED_4WAY_HS},
#endif /* CONFIG_DRIVER_NL80211_BRCM */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
#undef FUNC
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.h
index be8266a..66eee98 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config.h
@@ -46,11 +46,9 @@
#define DEFAULT_OCE_SUPPORT OCE_STA
#define DEFAULT_EXTENDED_KEY_ID 0
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
#define IS_5GHZ(n) (n > 4000)
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "config_ssid.h"
#include "wps/wps.h"
#include "common/ieee802_11_defs.h"
@@ -382,8 +380,7 @@
#define CFG_CHANGED_WOWLAN_TRIGGERS BIT(18)
#define CFG_CHANGED_DISABLE_BTM BIT(19)
#define CFG_CHANGED_BGSCAN BIT(20)
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
#define CFG_CHANGED_P2P_FREQ_2G_5G BIT(25)
#endif /* CONFIG_BRCM_RSDB */
#ifdef CONFIG_BRCM_AGO_PASSPHRASE
@@ -392,7 +389,6 @@
#ifdef CONFIG_DRIVER_NL80211_BRCM
#define CFG_CHANGED_4WAY_HS BIT(28)
#endif /* CONFIG_DRIVER_NL80211_BRCM */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* struct wpa_config - wpa_supplicant configuration data
@@ -798,7 +794,6 @@
int p2p_6ghz_disable;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined CONFIG_BRCM_RSDB
int p2p_pref_freq_5g;
int p2p_pref_freq_2g;
@@ -806,7 +801,6 @@
#ifdef BRCM_ROAM_OFFLOAD
int roam_offload;
#endif /* BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wpabuf *wps_vendor_ext_m1;
#define MAX_WPS_VENDOR_EXT 10
@@ -1015,20 +1009,6 @@
*/
int hs20;
- /**
- * pbc_in_m1 - AP mode WPS probing workaround for PBC with Windows 7
- *
- * Windows 7 uses incorrect way of figuring out AP's WPS capabilities
- * by acting as a Registrar and using M1 from the AP. The config
- * methods attribute in that message is supposed to indicate only the
- * configuration method supported by the AP in Enrollee role, i.e., to
- * add an external Registrar. For that case, PBC shall not be used and
- * as such, the PushButton config method is removed from M1 by default.
- * If pbc_in_m1=1 is included in the configuration file, the PushButton
- * config method is left in M1 (if included in config_methods
- * parameter) to allow Windows 7 to use PBC instead of PIN (e.g., from
- * a label in the AP).
- */
int pbc_in_m1;
/**
@@ -1334,11 +1314,9 @@
* 2 = like 1, but maintain OUI (with local admin bit set)
*/
int preassoc_mac_addr;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AGO_PASSPHRASE
char *ago_passphrase;
#endif /* CONFIG_BRCM_AGO_PASSPHRASE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* key_mgmt_offload - Use key management offload
@@ -1383,11 +1361,9 @@
* By default: 300 seconds.
*/
int mesh_max_inactivity;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
int replay_cntrs;
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* dot11RSNASAERetransPeriod - Timeout to retransmit SAE Auth frame
@@ -1524,14 +1500,12 @@
*/
int ftm_initiator;
-#ifdef CONFIG_DRIVER_NL80211_IFX
/**
* Offload the 4-Way handshake to the firmware
*/
#ifdef CONFIG_DRIVER_NL80211_BRCM
int offload_4way_handshake;
#endif /* CONFIG_DRIVER_NL80211_BRCM */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* gas_rand_addr_lifetime - Lifetime of random MAC address for ANQP in
* seconds
@@ -1610,7 +1584,6 @@
*/
int p2p_interface_random_mac_addr;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
/**
* bss_no_flush_when_down - Whether to flush BSS entries when the interface is disabled
@@ -1620,7 +1593,6 @@
*/
int bss_no_flush_when_down;
#endif /* ABOVE_10 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* disable_btm - Disable BSS transition management in STA
* - Set to 0 to enable BSS transition management
@@ -1640,11 +1612,9 @@
* 1 = use Extended Key ID when possible
*/
int extended_key_id;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int ignore_broadcast_ssid;
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_file.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_file.c
index 02f39e7..47770da 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_file.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_file.c
@@ -9,11 +9,6 @@
* configuration information is stored in a text file that uses a format
* described in the sample configuration file, wpa_supplicant.conf.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_FEATURES_COPYRIGHT
-/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "includes.h"
#ifdef ANDROID
@@ -132,45 +127,6 @@
static int wpa_config_validate_network(struct wpa_ssid *ssid, int line)
{
int errors = 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if ( ((ssid->proto & WPA_PROTO_WAPI) || (ssid->wapi != 0)) &&
- (ssid->key_mgmt != WPA_KEY_MGMT_WAPI_PSK) && (ssid->key_mgmt != WPA_KEY_MGMT_WAPI_CERT) ) {
- /* map original IWNCOMM .conf structure to WPA Supplicant style */
- if (ssid->wapi & 0x08) {
- ssid->key_mgmt = WPA_KEY_MGMT_WAPI_CERT;
- } else if (ssid->wapi & 0x04) {
- ssid->key_mgmt = WPA_KEY_MGMT_WAPI_PSK;
- } else {
- wpa_printf(MSG_ERROR, "Line %d: unknown wapi policy %d\n", line, ssid->wapi);
- errors++;
- }
- if (ssid->pairwise_cipher != WPA_CIPHER_SMS4) {
- ssid->pairwise_cipher = WPA_CIPHER_SMS4;
- }
- if (ssid->group_cipher != WPA_CIPHER_SMS4) {
- ssid->group_cipher = WPA_CIPHER_SMS4;
- }
- } else if ( ((ssid->key_mgmt == WPA_KEY_MGMT_WAPI_PSK) || (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_CERT)) &&
- (((ssid->proto & WPA_PROTO_WAPI) == 0) || (ssid->wapi==0)) ) {
- /* map WPA supplicant style to IWNCOMM .conf structure */
- if (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_PSK) {
- ssid->proto = WPA_PROTO_WAPI;
- ssid->wapi = 7;
- }
- if (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_CERT) {
- ssid->proto = WPA_PROTO_WAPI;
- ssid->wapi = 11;
- }
- if (ssid->pairwise_cipher != WPA_CIPHER_SMS4) {
- ssid->pairwise_cipher = WPA_CIPHER_SMS4;
- }
- if (ssid->group_cipher != WPA_CIPHER_SMS4) {
- ssid->group_cipher = WPA_CIPHER_SMS4;
- }
- } else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ssid->passphrase) {
if (ssid->psk_set) {
@@ -195,11 +151,6 @@
ssid->group_cipher &= ~WPA_CIPHER_CCMP;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ssid->mode == WPAS_MODE_MESH &&
(ssid->key_mgmt != WPA_KEY_MGMT_NONE &&
ssid->key_mgmt != WPA_KEY_MGMT_SAE)) {
@@ -825,22 +776,6 @@
write_proto(f, ssid);
write_key_mgmt(f, ssid);
INT_DEF(bg_scan_period, DEFAULT_BG_SCAN_PERIOD);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- INT(wapi);
- if ( (ssid->wapi == 7) || (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_PSK) ) {
- /* WAPI PSK network */
- INT(psk_key_type);
- }
- if ( (ssid->wapi == 11) || (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_CERT) ) {
- /* WAPI CERT network */
- INT(cert_index);
- STR(wapi_as_cert);
- STR(wapi_user_cert);
- STR(cert_name);
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
write_pairwise(f, ssid);
write_group(f, ssid);
write_group_mgmt(f, ssid);
@@ -1005,6 +940,8 @@
INT(beacon_prot);
INT(transition_disable);
INT(sae_pk);
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ INT(suppress_deauth_no_pmksa);
#ifdef CONFIG_HT_OVERRIDES
INT_DEF(disable_ht, DEFAULT_DISABLE_HT);
INT_DEF(disable_ht40, DEFAULT_DISABLE_HT40);
@@ -1420,21 +1357,17 @@
fprintf(f, "ip_addr_end=%u.%u.%u.%u\n",
config->ip_addr_end[0], config->ip_addr_end[1],
config->ip_addr_end[2], config->ip_addr_end[3]);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
if (config->p2p_pref_freq_5g)
fprintf(f, "p2p_pref_freq_5g=%d\n", config->p2p_pref_freq_5g);
if (config->p2p_pref_freq_2g)
fprintf(f, "p2p_pref_freq_2g=%d\n", config->p2p_pref_freq_2g);
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_P2P */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (BRCM_ROAM_OFFLOAD)
+#if defined(BRCM_ROAM_OFFLOAD)
if (config->roam_offload)
fprintf(f, "roam_offload=%d\n", config->roam_offload);
#endif /* BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (config->country[0] && config->country[1]) {
fprintf(f, "country=%c%c\n",
config->country[0], config->country[1]);
@@ -1627,13 +1560,11 @@
if (config->wps_priority)
fprintf(f, "wps_priority=%d\n", config->wps_priority);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
if (config->replay_cntrs)
fprintf(f, "replay_cntrs=%d\n",
config->replay_cntrs);
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (config->wpa_rsc_relaxation != DEFAULT_WPA_RSC_RELAXATION)
fprintf(f, "wpa_rsc_relaxation=%d\n",
config->wpa_rsc_relaxation);
@@ -1662,13 +1593,11 @@
if (config->ftm_initiator)
fprintf(f, "ftm_initiator=%d\n", config->ftm_initiator);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_DRIVER_NL80211_BRCM
if (config->offload_4way_handshake)
fprintf(f, "offload_4way_handshake=%d\n",
config->offload_4way_handshake);
#endif /* CONFIG_DRIVER_NL80211_BRCM */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (config->osu_dir)
fprintf(f, "osu_dir=%s\n", config->osu_dir);
@@ -1704,13 +1633,11 @@
if (config->extended_key_id != DEFAULT_EXTENDED_KEY_ID)
fprintf(f, "extended_key_id=%d\n",
config->extended_key_id);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
if (config->bss_no_flush_when_down)
fprintf(f, "bss_no_flush_when_down=%d\n",
config->bss_no_flush_when_down);
#endif /* ABOVE_10 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
#endif /* CONFIG_NO_CONFIG_WRITE */
@@ -1770,7 +1697,6 @@
if (wpa_key_mgmt_sae(ssid->key_mgmt) &&
!ssid->passphrase && !ssid->sae_password)
continue; /* do not save invalid network */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
#ifdef WL_SAE
if (ssid->key_mgmt == (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_IEEE8021X_NO_WPA |
@@ -1781,7 +1707,6 @@
ssid->proactive_key_caching = 1;
}
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
fprintf(f, "\nnetwork={\n");
wpa_config_write_network(f, ssid);
fprintf(f, "}\n");
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_ssid.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_ssid.h
index 06a15a2..d7b13f7 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_ssid.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/config_ssid.h
@@ -9,11 +9,6 @@
#ifndef CONFIG_SSID_H
#define CONFIG_SSID_H
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "utils/includes.h"
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "common/defs.h"
#include "utils/list.h"
#include "eap_peer/eap_config.h"
@@ -23,11 +18,7 @@
#define DEFAULT_EAPOL_FLAGS (EAPOL_FLAG_REQUIRE_KEY_UNICAST | \
EAPOL_FLAG_REQUIRE_KEY_BROADCAST)
#define DEFAULT_PROTO (WPA_PROTO_WPA | WPA_PROTO_RSN)
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_CCX)
-#define DEFAULT_KEY_MGMT (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_CCKM)
-#else
#define DEFAULT_KEY_MGMT (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X)
-#endif /* CONFIG_DRIVER_NL80211_IFX && BRCM_CCX */
#ifdef CONFIG_NO_TKIP
#define DEFAULT_PAIRWISE (WPA_CIPHER_CCMP)
#define DEFAULT_GROUP (WPA_CIPHER_CCMP)
@@ -388,17 +379,6 @@
*/
int non_leap;
- /**
- * eap_workaround - EAP workarounds enabled
- *
- * wpa_supplicant supports number of "EAP workarounds" to work around
- * interoperability issues with incorrectly behaving authentication
- * servers. This is recommended to be enabled by default because some
- * of the issues are present in large number of authentication servers.
- *
- * Strict EAP conformance mode can be configured by disabling
- * workarounds with eap_workaround = 0.
- */
unsigned int eap_workaround;
#endif /* IEEE8021X_EAPOL */
@@ -561,17 +541,6 @@
int vht;
int he;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- int wapi;
- int psk_key_type;
- int wapi_ie_len;
- int cert_index;
- char *wapi_user_cert;
- char *wapi_as_cert;
- char *cert_name;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int max_oper_chwidth;
@@ -1090,17 +1059,6 @@
*/
int owe_only;
- /**
- * owe_ptk_workaround - OWE PTK derivation workaround
- *
- * Initial OWE implementation used SHA256 when deriving the PTK for all
- * OWE groups. This was supposed to change to SHA384 for group 20 and
- * SHA512 for group 21. This parameter can be used to enable older
- * behavior mainly for testing purposes. There is no impact to group 19
- * behavior, but if enabled, this will make group 20 and 21 cases use
- * SHA256-based PTK derivation which will not work with the updated
- * OWE implementation on the AP side.
- */
int owe_ptk_workaround;
/**
@@ -1176,6 +1134,14 @@
* configuration.
*/
bool was_recently_reconfigured;
+
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ /**
+ * suppress_deauth_no_pmksa - Whether deauth when PMKSA is empty
+ * 0 = To deauthenticate if there is no PMKSA entry (default)
+ * 1 = To suppress deauthenticate if there is no PMKSA entry
+ */
+ int suppress_deauth_no_pmksa;
};
#endif /* CONFIG_SSID_H */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.c
index 609c624..ab58c79 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.c
@@ -5,11 +5,6 @@
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_FEATURES_COPYRIGHT
-/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "utils/includes.h"
#ifdef CONFIG_TESTING_OPTIONS
@@ -38,14 +33,6 @@
#include "wps/wps.h"
#include "fst/fst.h"
#include "fst/fst_ctrl_iface.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "wapi/wapi_interface.h"
-#include "wapi_asue_i.h"
-#include "wapi_config.h"
-extern int wapi_state_to_wpa_state(int wapi_state);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "config.h"
#include "wpa_supplicant_i.h"
#include "driver_i.h"
@@ -54,11 +41,9 @@
#include "ap.h"
#include "p2p_supplicant.h"
#include "p2p/p2p.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
#include "p2p/p2p_i.h"
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "hs20_supplicant.h"
#include "wifi_display.h"
#include "notify.h"
@@ -72,7 +57,9 @@
#include "offchannel.h"
#include "drivers/driver.h"
#include "mesh.h"
+#ifdef CONFIG_DPP
#include "dpp_supplicant.h"
+#endif /* CONFIG_DPP */
#include "sme.h"
#ifdef __NetBSD__
@@ -89,13 +76,11 @@
static int * freq_range_to_channel_list(struct wpa_supplicant *wpa_s,
char *val);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int wifi_interworking_ie_set(struct wpa_supplicant *wpa_s, char *cmd);
int wpas_p2p_iface_reset(struct wpa_global *global, char *cmd);
int p2p_parse_channel_width(char *cmd, int freq, int *ht40, int *vht);
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int set_bssid_filter(struct wpa_supplicant *wpa_s, char *val)
{
@@ -868,13 +853,11 @@
#endif /* CONFIG_NO_CONFIG_BLOBS */
} else if (os_strcasecmp(cmd, "setband") == 0) {
ret = wpas_ctrl_set_band(wpa_s, value);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
} else if (os_strcasecmp(cmd, "HIDE_SSID") == 0) {
int enabled = !!atoi(value);
wpa_s->conf->ignore_broadcast_ssid = enabled;
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_MBO
} else if (os_strcasecmp(cmd, "non_pref_chan") == 0) {
ret = wpas_mbo_update_non_pref_chan(wpa_s, value);
@@ -974,12 +957,10 @@
#endif /* CONFIG_TESTING_GET_GTK */
} else if (os_strcmp(cmd, "tls_library") == 0) {
res = tls_get_library_version(buf, buflen);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
} else if (os_strcasecmp(cmd, "HIDE_SSID") == 0) {
res = os_snprintf(buf, buflen, "%d", wpa_s->conf->ignore_broadcast_ssid);
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_TESTING_OPTIONS
} else if (os_strcmp(cmd, "anonce") == 0) {
return wpa_snprintf_hex(buf, buflen,
@@ -1022,69 +1003,6 @@
#ifdef CONFIG_TDLS
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined(CONFIG_WIFI_DISPLAY) && defined(BRCM_DEBUG)
-int wifi_display_update_tdls_wfd_ie(struct wpa_supplicant *wpa_s, char *cmd)
-{
- struct wpabuf *e, *buf, *wfd_ie;
- size_t len = 0;
- int ret, action_code;
-
- action_code = atoi(cmd);
- if (wpa_s->global->wfd_subelem[WFD_SUBELEM_DEVICE_INFO]) {
- e = wpa_s->global->wfd_subelem[WFD_SUBELEM_DEVICE_INFO];
- } else {
- return -1;
- }
- if (e->buf[0] == WFD_SUBELEM_DEVICE_INFO) {
- wpa_printf(MSG_DEBUG, "Device Info = 0x%04x", WPA_GET_BE16(&e->buf[3]));
-
- if (0x80 != (WPA_GET_BE16(&e->buf[3]) & 0x80)) {
- wpa_printf(MSG_DEBUG, "Can not set WFD info as TDLS "
- " preferred connectivity BIT not set");
- return -1;
- } else {
- if (wpa_s->global->wfd_subelem[WFD_SUBELEM_DEVICE_INFO])
- len += wpabuf_len(wpa_s->global->wfd_subelem[
- WFD_SUBELEM_DEVICE_INFO]);
- if (wpa_s->global->wfd_subelem[WFD_SUBELEM_ASSOCIATED_BSSID])
- len += wpabuf_len(wpa_s->global->wfd_subelem[
- WFD_SUBELEM_ASSOCIATED_BSSID]);
- if (wpa_s->global->wfd_subelem[WFD_SUBELEM_LOCAL_IP_ADDRESS])
- len += wpabuf_len(wpa_s->global->wfd_subelem[
- WFD_SUBELEM_LOCAL_IP_ADDRESS]);
-
- /*TDLS WFD IE data*/
- buf = wpabuf_alloc(len);
- if (buf == NULL)
- return -1;
-
- if (wpa_s->global->wfd_subelem[WFD_SUBELEM_DEVICE_INFO])
- wpabuf_put_buf(buf,
- wpa_s->global->wfd_subelem[WFD_SUBELEM_DEVICE_INFO]);
- if (wpa_s->global->wfd_subelem[WFD_SUBELEM_ASSOCIATED_BSSID])
- wpabuf_put_buf(buf,
- wpa_s->global->wfd_subelem[WFD_SUBELEM_ASSOCIATED_BSSID]);
- if (wpa_s->global->wfd_subelem[WFD_SUBELEM_LOCAL_IP_ADDRESS])
- wpabuf_put_buf(buf,
- wpa_s->global->wfd_subelem[WFD_SUBELEM_LOCAL_IP_ADDRESS]);
-
- /* Add wfd ie header */
- wfd_ie = wifi_display_encaps(buf);
- /* added arg for initiator. kept 0 for now. Need to check */
- ret = wpa_drv_send_tdls_mgmt(wpa_s, broadcast_ether_addr, action_code,
- 1, 0, 0, 0, wpabuf_head(wfd_ie), wpabuf_len(wfd_ie));
- if (ret)
- wpa_printf(MSG_ERROR, "Failed to set TDLS Wfd IE");
-
- wpabuf_free(buf);
- wpabuf_free(wfd_ie);
- }
- }
- return 0;
-}
-#endif /* CONFIG_WIFI_DISPLAY && BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_supplicant_ctrl_iface_tdls_discover(
struct wpa_supplicant *wpa_s, char *addr)
@@ -2267,37 +2185,6 @@
#endif /* IEEE8021X_EAPOL */
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-static const char * wapi_key_mgmt_txt(int key_mgmt)
-{
- switch (key_mgmt) {
- case WPA_KEY_MGMT_WAPI_PSK:
- return "WAPI-PSK";
- case WPA_KEY_MGMT_WAPI_CERT:
- return "WAPI-CERT";
- default:
- return "UNKNOWN";
- }
-}
-
-static int wapi_get_cipher_key_mgmt(unsigned int key_mgmt, char *buf, size_t buflen, int verbose)
-{
- char *pos = buf, *end = buf + buflen;
- int ret;
-
- ret = os_snprintf(pos, end - pos,
- "pairwise_cipher=SMS4\n"
- "group_cipher=SMS4\n"
- "key_mgmt=%s\n",
- wapi_key_mgmt_txt(key_mgmt));
- if (ret < 0 || ret >= end - pos)
- return pos - buf;
- pos += ret;
- return pos - buf;
-}
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_supplicant_ctrl_iface_status(struct wpa_supplicant *wpa_s,
const char *params,
@@ -2414,14 +2301,6 @@
return pos - buf;
pos += ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (ssid && ssid->wapi) {
- wpa_printf(MSG_DEBUG, "%s , wapi_get_cipher_key_mgmt", __FUNCTION__);
- pos += wapi_get_cipher_key_mgmt(ssid->key_mgmt, pos, end - pos, verbose);
- } else
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_AP
if (wpa_s->ap_iface) {
@@ -2611,12 +2490,21 @@
}
#endif /* CONFIG_WPS */
+#ifdef CONFIG_IEEE80211AX
+ if (wpa_s->ieee80211ax) {
+ ret = os_snprintf(pos, end - pos, "ieee80211ax=1\n");
+ if (os_snprintf_error(end - pos, ret))
+ return pos - buf;
+ pos += ret;
+ }
+#else
if (wpa_s->ieee80211ac) {
ret = os_snprintf(pos, end - pos, "ieee80211ac=1\n");
if (os_snprintf_error(end - pos, ret))
return pos - buf;
pos += ret;
}
+#endif /*CONFIG_IEEE80211AX*/
#ifdef ANDROID
/*
@@ -2735,7 +2623,6 @@
return 3;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
int wpa_supplicant_ho_connect(
struct wpa_supplicant *wpa_s, int chan,
@@ -2831,7 +2718,6 @@
return wpa_supplicant_ho_connect(wpa_s, chan, ssid_len, ssid, pph_len, pph);
}
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_supplicant_ctrl_iface_log_level(struct wpa_supplicant *wpa_s,
char *cmd, char *buf,
@@ -3048,17 +2934,6 @@
return pos;
pos += ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (data.key_mgmt & WPA_KEY_MGMT_CCKM) {
- ret = os_snprintf(pos, end - pos, "%sCCKM",
- pos == start ? "" : "+");
- if (os_snprintf_error(end - pos, ret))
- return pos;
- pos += ret;
- }
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_SUITEB
if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
@@ -3209,11 +3084,6 @@
char *pos, *end;
int ret;
const u8 *ie, *ie2, *osen_ie, *p2p, *mesh, *owe, *rsnxe;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- const u8 *ie3;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
mesh = wpa_bss_get_ie(bss, WLAN_EID_MESH_ID);
p2p = wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE);
@@ -3267,36 +3137,8 @@
return -1;
pos += ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- ie3 = wpa_bss_get_ie(bss, WLAN_EID_WAPI);
- if (ie3)
- {
- wpa_printf(MSG_DEBUG, "wapi_ie: [%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x]\n",
- ie3[0], ie3[1], ie3[2], ie3[3], ie3[4],
- ie3[5], ie3[6], ie3[7], ie3[8], ie3[9] );
- if (ie3[9] == 2) {
- wpa_printf(MSG_DEBUG, "This is a WAPI PSK network");
- ret = os_snprintf(pos, end - pos, "[WAPI-PSK]");
- } else if (ie3[9] == 1) {
- wpa_printf(MSG_DEBUG, "This is a WAPI CERT network");
- ret = os_snprintf(pos, end - pos, "[WAPI-CERT]");
- } else {
- wpa_printf(MSG_ERROR, "Unknown WAPI network type");
- ret = os_snprintf(pos, end - pos, "[WAPI-Unknown]");
- }
- if (ret < 0 || ret >= end - pos)
- return -1;
- pos += ret;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (!ie && !ie2 && !ie3 && !osen_ie && bss->caps & IEEE80211_CAP_PRIVACY) {
-#else
if (!ie && !ie2 && !osen_ie && (bss->caps & IEEE80211_CAP_PRIVACY)) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
ret = os_snprintf(pos, end - pos, "[WEP]");
if (os_snprintf_error(end - pos, ret))
return -1;
@@ -3360,16 +3202,6 @@
return -1;
pos += ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (!ie && !ie2 && !ie3) {
- ret = os_snprintf(pos, end - pos, "\t");
- if (ret < 0 || ret >= end - pos)
- return pos - buf;
- pos += ret;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_HS20
if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE) && ie2) {
ret = os_snprintf(pos, end - pos, "[HS20]");
@@ -3746,7 +3578,6 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
int p2p_gc_connect(struct wpa_supplicant *wpa_s, int chan,
int ssid_len, char *ssid, int pph_len, char *pph, u8 *bssid)
@@ -3845,7 +3676,6 @@
return p2p_gc_connect(wpa_s, chan, ssid_len, ssid, pph_len, pph, bssid);
}
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_supplicant_ctrl_iface_add_network(
struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
@@ -3875,16 +3705,6 @@
/* cmd: "<network id>" or "all" */
if (os_strcmp(cmd, "all") == 0) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK all");
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (wpa_s->key_mgmt == WPA_KEY_MGMT_WAPI_PSK) {
- wpa_s->key_mgmt = 0;
- wapiap_lib_deinitialize(wpa_s->ifname);
- } else
- wpa_printf(MSG_ERROR, "CTRL_IFACE: wapi key_mgmt mismatch %s %d\n",
- wpa_s->ifname, wpa_s->key_mgmt);
-#endif /* WAPI_AP */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return wpa_supplicant_remove_all_networks(wpa_s);
}
@@ -3904,7 +3724,6 @@
}
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_P2P)
static int wpa_supplicant_random_channel_selection(struct wpa_supplicant *wpa_s, int *val)
{
@@ -3961,7 +3780,6 @@
return 0;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_supplicant_ctrl_iface_update_network(
@@ -3969,13 +3787,11 @@
char *name, char *value)
{
int ret;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int val;
char *end;
u8 cw;
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
ret = wpa_config_set(ssid, name, value, 0);
if (ret < 0) {
@@ -3983,7 +3799,6 @@
"variable '%s'", name);
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_BRCM_AUTOMOTIVE)
if (os_strcmp(name, "frequency") == 0) {
val = strtol(value, &end, 0);
@@ -3991,16 +3806,6 @@
/* Comment out the Random channel selection code to do
* Acs with those values
*/
-#if 0
-#if defined(CONFIG_P2P)
- if (wpa_supplicant_random_channel_selection(wpa_s, &val) == -1) {
- wpa_printf(MSG_ERROR,
- "Function %s: random channel selection failure\n",
- __FUNCTION__);
- return -1;
- }
-#endif /* CONFIG_P2P */
-#endif
cw = atoi(end + 1);
if (cw == 40 && val == 5) {
ssid->ht40 = 1;
@@ -4049,10 +3854,6 @@
wpa_config_set_frequency(ssid, val);
}
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (ret == 1)
- return 0; /* No change to the previously configured value */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_BGSCAN
if (os_strcmp(name, "bgscan") == 0) {
@@ -4579,23 +4380,6 @@
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_CCKM) {
- ret = os_snprintf(pos, end - pos, " WPA-CCKM");
- if (os_snprintf_error(end - pos, ret))
- return pos - buf;
- pos += ret;
- }
-
- if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA2_CCKM) {
- ret = os_snprintf(pos, end - pos, " WPA2-CCKM");
- if (ret < 0 || ret >= end - pos)
- return pos - buf;
- pos += ret;
- }
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return pos - buf;
}
@@ -4943,11 +4727,6 @@
}
if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- WPA_DRIVER_CAPA_KEY_MGMT_WPA2_CCKM |
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
ret = os_snprintf(pos, end - pos, "%sRSN",
pos == buf ? "" : " ");
@@ -4957,11 +4736,6 @@
}
if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- WPA_DRIVER_CAPA_KEY_MGMT_WPA_CCKM |
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
ret = os_snprintf(pos, end - pos, "%sWPA",
pos == buf ? "" : " ");
@@ -5048,23 +4822,6 @@
}
#endif /* CONFIG_FILS_SK_PFS */
#endif /* CONFIG_FILS */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_CCKM) {
- ret = os_snprintf(pos, end - pos, " WPA-CCKM");
- if (os_snprintf_error(end - pos, ret))
- return pos - buf;
- pos += ret;
- }
-
- if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA2_CCKM) {
- ret = os_snprintf(pos, end - pos, " WPA2-CCKM");
- if (os_snprintf_error(end - pos, ret))
- return pos - buf;
- pos += ret;
- }
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return pos - buf;
}
@@ -5512,11 +5269,6 @@
int ret;
char *pos, *end;
const u8 *ie, *ie2, *osen_ie, *mesh, *owe, *rsnxe;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- const u8 *ie3;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
pos = buf;
end = buf + buflen;
@@ -5665,32 +5417,7 @@
pos += ret;
}
pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- ie3 = wpa_bss_get_ie(bss, WLAN_EID_WAPI);
- if (ie3)
- {
- wpa_printf(MSG_DEBUG, "wapi_ie: [%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x]\n",
- ie3[0], ie3[1], ie3[2], ie3[3], ie3[4],
- ie3[5], ie3[6], ie3[7], ie3[8], ie3[9] );
- if (ie3[9] == 2) {
- wpa_printf(MSG_DEBUG, "This is a WAPI PSK network");
- ret = os_snprintf(pos, end - pos, "[WAPI-PSK]");
- } else if (ie3[9] == 1) {
- wpa_printf(MSG_DEBUG, "This is a WAPI CERT network");
- ret = os_snprintf(pos, end - pos, "[WAPI-CERT]");
- } else {
- wpa_printf(MSG_ERROR, "Unknown WAPI network type");
- ret = os_snprintf(pos, end - pos, "[WAPI-Unknown]");
- }
-
- if (os_snprintf_error(end - pos, ret))
- return 0;
- pos += ret;
- }
- if (!ie && !ie2 && !ie3 && !osen_ie &&
-#else
if (!ie && !ie2 && !osen_ie &&
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
(bss->caps & IEEE80211_CAP_PRIVACY)) {
ret = os_snprintf(pos, end - pos, "[WEP]");
if (os_snprintf_error(end - pos, ret))
@@ -6253,7 +5980,6 @@
#endif /* CONFIG_NO_SCAN_PROCESSING */
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_NAN
int nan_ctrl_create_p2p_ie(struct wpa_supplicant *wpa_s, char *cmd, int len)
{
@@ -6283,7 +6009,6 @@
return 0;
}
#endif /* CONFIG_BRCM_NAN */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_P2P
static int p2p_ctrl_find(struct wpa_supplicant *wpa_s, char *cmd)
@@ -6673,13 +6398,11 @@
if (pos2) {
pos2 += 6;
freq = atoi(pos2);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int res = p2p_parse_channel_width(pos, freq, &ht40, &vht);
if (res)
return -1;
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (freq <= 0)
return -1;
}
@@ -6772,7 +6495,6 @@
return wpas_p2p_listen(wpa_s, timeout);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
static int p2p_ctrl_group_add_ho(struct wpa_supplicant *wpa_s, char *cmd)
{
@@ -6823,7 +6545,6 @@
return wpas_p2p_group_add_ho(wpa_s, chan, ssid_len, ssid, passphrase_len, passphrase, macaddr);
}
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int p2p_ctrl_prov_disc(struct wpa_supplicant *wpa_s, char *cmd)
{
@@ -7380,7 +7101,6 @@
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
/* Fix for persistent GC connection to GO */
vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht ||
@@ -7392,11 +7112,6 @@
ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
vht;
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#else
- vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht;
- ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
- vht;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
he = (os_strstr(cmd, " he") != NULL) || wpa_s->conf->p2p_go_he;
edmg = (os_strstr(cmd, " edmg") != NULL) || wpa_s->conf->p2p_go_edmg;
@@ -7495,7 +7210,6 @@
#endif /* CONFIG_ACS */
while ((token = str_token(cmd, " ", &context))) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CY_AUTO_SET_BW
/*Adding support for channel width configuration while creating AGO or AP */
if ((sscanf(token, "freq=%d", &freq) == 1) ||
@@ -7505,12 +7219,7 @@
if (sscanf(token, "freq2=%d", &freq2) == 1 ||
sscanf(token, "persistent=%d", &group_id) == 1 ||
#endif /* CONFIG_CY_AUTO_SET_BW */
-#else
- if (sscanf(token, "freq2=%d", &freq2) == 1 ||
- sscanf(token, "persistent=%d", &group_id) == 1 ||
-#endif /* CONFIG_DRIVER_NL80211_IFX */
sscanf(token, "max_oper_chwidth=%d", &chwidth) == 1) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
if (freq) {
int res = p2p_parse_channel_width(token, freq, &ht40, &vht);
@@ -7518,7 +7227,6 @@
return -1;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
continue;
#ifdef CONFIG_ACS
} else if (os_strcmp(token, "freq=acs") == 0) {
@@ -7794,7 +7502,6 @@
}
if (os_strcmp(cmd, "ssid_postfix") == 0) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
char *string = NULL;
@@ -7812,7 +7519,6 @@
else
p2p_set_ignore_random_ssid(wpa_s->global->p2p, 0);
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return p2p_set_ssid_postfix(wpa_s->global->p2p, (u8 *) param,
os_strlen(param));
}
@@ -7822,24 +7528,6 @@
int count, start, duration;
/* GO NoA parameters: count,start_offset(ms),duration(ms) */
count = atoi(param);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
- if (os_strcmp(param, "clear") == 0) {
- /*
- * XXX: Set 'clear' as zero to avoid NoA setting and 'start'
- * and 'duration' as non zero value to avoid bad argument error
- * in firmware.
- */
- count = 0;
- start = 1;
- duration = 1;
- wpa_printf(MSG_DEBUG, "CTRL_IFACE: P2P_SET GO NoA CLEAR: "
- "count=%d start=%d duration=%d", count, start, duration);
- return wpas_p2p_set_noa(wpa_s, count, start, duration);
- }
- else {
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
pos = os_strchr(param, ',');
if (pos == NULL)
return -1;
@@ -7850,11 +7538,6 @@
return -1;
pos++;
duration = atoi(pos);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
- }
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (count < 0 || count > 255 || start < 0 || duration < 0)
return -1;
if (count == 0 && duration > 0)
@@ -8988,7 +8671,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
static int wpa_supplicant_driver_cmd(struct wpa_supplicant *wpa_s, char *cmd,
char *buf, size_t buflen)
@@ -9022,7 +8704,7 @@
p2p_set_country(p2p, country);
}
}
-#if defined (CONFIG_BRCM_AUTOMOTIVE) && defined (CONFIG_BRCM_BANDSTEER)
+#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_BRCM_BANDSTEER)
else if (os_strncasecmp(cmd, "BANDSTEER", 9) == 0) {
char buf[30];
char *token, *context = NULL;
@@ -9081,33 +8763,6 @@
}
#endif
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
-static int wpa_supplicant_driver_cmd(struct wpa_supplicant *wpa_s, char *cmd,
- char *buf, size_t buflen)
-{
- int ret;
-
- ret = wpa_drv_driver_cmd(wpa_s, cmd, buf, buflen);
- if (ret == 0) {
- if (os_strncasecmp(cmd, "COUNTRY", 7) == 0) {
- struct p2p_data *p2p = wpa_s->global->p2p;
- if (p2p) {
- char country[3];
- country[0] = cmd[8];
- country[1] = cmd[9];
- country[2] = 0x04;
- p2p_set_country(p2p, country);
- }
- }
- ret = os_snprintf(buf, buflen, "%s\n", "OK");
- if (os_snprintf_error(buflen, ret))
- ret = -1;
- }
- return ret;
-}
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_supplicant_vendor_cmd(struct wpa_supplicant *wpa_s, char *cmd,
@@ -9177,7 +8832,6 @@
return ret;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_P2P)
int wifi_interworking_ie_set(struct wpa_supplicant *wpa_s, char *cmd)
{
@@ -9393,8 +9047,6 @@
return 0;
}
#endif /* CONFIG_BRCM_AUTOMOTIVE && CONFIG_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int wpas_get_ssid(struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
{
@@ -9454,7 +9106,6 @@
return buflen;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void wpa_supplicant_ctrl_iface_flush(struct wpa_supplicant *wpa_s)
{
@@ -9841,7 +9492,6 @@
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VIF
static int wpa_supplicant_iface_create(struct wpa_supplicant *wpa_s, char *cmd)
{
@@ -9871,7 +9521,6 @@
return wpa_drv_if_remove(wpa_s->parent ? wpa_s->parent : wpa_s, WPA_IF_STATION, ifname);
}
#endif /* CONFIG_BRCM_VIF */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void wpas_ctrl_radio_work_flush(struct wpa_supplicant *wpa_s)
{
@@ -11895,7 +11544,6 @@
} else if (os_strncmp(buf, "P2P_GROUP_ADD ", 14) == 0) {
if (p2p_ctrl_group_add(wpa_s, buf + 14))
reply_len = -1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
} else if (os_strncmp(buf, "P2P_GROUP_ADDHO ", 16) == 0) {
if (p2p_ctrl_group_add_ho(wpa_s, buf + 16))
@@ -11907,7 +11555,6 @@
if (wpa_supplicant_ctrl_iface_connect(wpa_s, buf + 8))
reply_len = -1;
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
} else if (os_strncmp(buf, "P2P_GROUP_MEMBER ", 17) == 0) {
reply_len = p2p_ctrl_group_member(wpa_s, buf + 17, reply,
reply_size);
@@ -11926,11 +11573,7 @@
if (p2p_ctrl_serv_disc_resp(wpa_s, buf + 19) < 0)
reply_len = -1;
} else if (os_strcmp(buf, "P2P_SERVICE_UPDATE") == 0) {
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_SD_DYNAMIC_CAPA)
- wpas_p2p_sd_service_update(wpa_s, SRV_UPDATE);
-#else
wpas_p2p_sd_service_update(wpa_s);
-#endif /* CONFIG_DRIVER_NL80211_IFX && CONFIG_BRCM_SD_DYNAMIC_CAPA */
} else if (os_strncmp(buf, "P2P_SERV_DISC_EXTERNAL ", 23) == 0) {
if (p2p_ctrl_serv_disc_external(wpa_s, buf + 23) < 0)
reply_len = -1;
@@ -11986,14 +11629,12 @@
} else if (os_strcmp(buf, "P2P_LO_STOP") == 0) {
if (wpas_p2p_lo_stop(wpa_s))
reply_len = -1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
} else if (os_strncmp(buf, "P2P_IFACE_RESET", 15) == 0) {
if (wpas_p2p_iface_reset(wpa_s->global, buf + 15) < 0) {
reply_len = -1;
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_P2P */
#ifdef CONFIG_WIFI_DISPLAY
} else if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0) {
@@ -12002,15 +11643,7 @@
} else if (os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0) {
reply_len = wifi_display_subelem_get(wpa_s->global, buf + 16,
reply, reply_size);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined(CONFIG_TDLS) && defined(BRCM_DEBUG)
- } else if (os_strncmp(buf, "WFD_SET_TDLS_IE ", 16) == 0) {
- if (wifi_display_update_tdls_wfd_ie(wpa_s, buf + 16) < 0)
- reply_len = -1;
-#endif /* CONFIG_TDLS && BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_WIFI_DISPLAY */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
} else if (os_strncmp(buf, "GET_PSK", 7) == 0) {
if ((reply_len = wpas_get_psk(wpa_s, reply, reply_size)) < 0) {
@@ -12025,7 +11658,6 @@
reply_len = -1;
}
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_INTERWORKING
} else if (os_strcmp(buf, "FETCH_ANQP") == 0) {
if (interworking_fetch_anqp(wpa_s) < 0)
@@ -12292,19 +11924,11 @@
} else if (os_strcmp(buf, "DRIVER_FLAGS2") == 0) {
reply_len = wpas_ctrl_iface_driver_flags2(wpa_s, reply,
reply_size);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
} else if (os_strncmp(buf, "DRIVER ", 7) == 0) {
reply_len = wpa_supplicant_driver_cmd(wpa_s, buf + 7, reply,
reply_size);
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
- } else if (os_strncmp(buf, "DRIVER ", 7) == 0) {
- reply_len = wpa_supplicant_driver_cmd(wpa_s, buf + 7, reply,
- reply_size);
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
} else if (os_strncmp(buf, "VENDOR ", 7) == 0) {
reply_len = wpa_supplicant_vendor_cmd(wpa_s, buf + 7, reply,
reply_size);
@@ -12408,7 +12032,6 @@
} else if (os_strcmp(buf, "FILS_HLP_REQ_FLUSH") == 0) {
wpas_flush_fils_hlp_req(wpa_s);
#endif /* CONFIG_FILS */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_VIF
} else if (os_strncmp(buf, "INTERFACE_CREATE ", 17) == 0) {
if (wpa_supplicant_iface_create(wpa_s, buf + 17) < 0)
@@ -12417,7 +12040,6 @@
if (wpa_supplicant_iface_del(wpa_s, buf + 14) < 0)
reply_len = -1;
#endif /* CONFIG_BRCM_VIF */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DPP
} else if (os_strncmp(buf, "DPP_QR_CODE ", 12) == 0) {
int res;
@@ -12866,13 +12488,11 @@
"P2P_STOP_FIND",
"P2P_LISTEN",
"P2P_GROUP_ADD",
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
"P2P_GROUP_ADDHO",
"P2P_GROUP_ADDHO ",
"P2P_GC_CONNECT ",
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
"P2P_GET_PASSPHRASE",
"P2P_SERVICE_UPDATE",
"P2P_SERVICE_FLUSH",
@@ -12880,11 +12500,9 @@
"P2P_CANCEL",
"P2P_PRESENCE_REQ",
"P2P_EXT_LISTEN",
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
"P2P_IFACE_RESET",
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_AP
"STA-FIRST",
#endif /* CONFIG_AP */
@@ -12962,7 +12580,6 @@
#ifdef CONFIG_WIFI_DISPLAY
if (global->p2p_init_wpa_s == NULL)
return NULL;
-#ifdef CONFIG_DRIVER_NL80211_IFX
if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0 ||
os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0
#ifdef CONFIG_BRCM_AUTOMOTIVE
@@ -12972,10 +12589,6 @@
|| os_strncmp(buf, "GET_PSK", 7) == 0
|| os_strncmp(buf, "GET_SSID", 8) == 0)
#endif
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0 ||
- os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0)
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return wpa_supplicant_ctrl_iface_process(global->p2p_init_wpa_s,
buf, resp_len);
#endif /* CONFIG_WIFI_DISPLAY */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.h
index 86b918d..510668d 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface.h
@@ -11,12 +11,6 @@
#ifdef CONFIG_CTRL_IFACE
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-void wapiap_lib_deinitialize(char *ifname);
-void brcm_wapiap_initialize(void *ctx, int wapiap_tx_sock, struct i802_bss *bss);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifndef CTRL_IFACE_MAX_LEN
#define CTRL_IFACE_MAX_LEN 8192
#endif /* CTRL_IFACE_MAX_LEN */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface_unix.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface_unix.c
index 0406c7b..953fd2c 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface_unix.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/ctrl_iface_unix.c
@@ -178,32 +178,6 @@
else
reply_len = 2;
} else {
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
- char *ifname, *ifend;
-
- ifname = os_strstr(buf, "interface=");
- if (ifname != NULL) {
- ifend = os_strchr(ifname + 10, ' ');
- if (ifend != NULL)
- *ifend++ = '\0';
- else
- *(ifname - 1) = '\0';
- wpa_printf(MSG_DEBUG, "Found %s", ifname);
- for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
- if (os_strcmp(wpa_s->ifname, ifname + 10) == 0)
- break;
- }
- if (wpa_s == NULL) {
- wpa_printf(MSG_ERROR, "P2P: %s does not exist", ifname);
- wpa_s = eloop_ctx;
- }
- if (ifend != NULL)
- os_memmove(ifname, ifend, strlen(ifend) + 1);
- wpa_printf(MSG_INFO, "wpa_s->ifname %s cmd %s", wpa_s ? wpa_s->ifname : "NULL", buf);
- }
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
reply_buf = wpa_supplicant_ctrl_iface_process(wpa_s, buf,
&reply_len);
reply = reply_buf;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/defconfig_auto b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/defconfig_auto
index cd47a7a..a119600 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/defconfig_auto
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/defconfig_auto
@@ -485,6 +485,12 @@
# (depends on CONFIG_IEEE80211N)
CONFIG_IEEE80211AC=y
+# IEEE 802.11ax HE support (mainly for AP mode)
+# Note: This is experimental and work in progress. The definitions are still
+# subject to change and this should not be expected to interoperate with the
+# final IEEE 802.11ax version.
+CONFIG_IEEE80211AX=y
+
# Wireless Network Management (IEEE Std 802.11v-2011)
# Note: This is experimental and not complete implementation.
#CONFIG_WNM=y
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/dpp_supplicant.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/dpp_supplicant.c
index 3e1c009..148cb65 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/dpp_supplicant.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/dpp_supplicant.c
@@ -27,11 +27,9 @@
#include "scan.h"
#include "notify.h"
#include "dpp_supplicant.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
#include "hidl.h"
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpas_dpp_listen_start(struct wpa_supplicant *wpa_s,
@@ -558,11 +556,9 @@
wpa_printf(MSG_INFO,
"DPP: No response received from responder - stopping initiation attempt");
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_timeout(wpa_s);
#endif /* !(OREO || PIE) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
offchannel_send_action_done(wpa_s);
wpas_dpp_listen_stop(wpa_s);
dpp_auth_deinit(auth);
@@ -657,11 +653,9 @@
wpa_printf(MSG_INFO,
"DPP: No response received from responder - stopping initiation attempt");
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_timeout(wpa_s);
#endif /* !(OREO || PIE) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
eloop_cancel_timeout(wpas_dpp_reply_wait_timeout,
wpa_s, NULL);
offchannel_send_action_done(wpa_s);
@@ -1372,11 +1366,9 @@
return -1;
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_NETWORK_ID "%d", ssid->id);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_config_received(wpa_s, ssid);
#endif /* !(OREO || PIE) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_s->conf->dpp_config_processing == 2)
ssid->disabled = 0;
@@ -1654,16 +1646,12 @@
#endif /* CONFIG_TESTING_OPTIONS */
fail:
if (status != DPP_STATUS_OK)
-#ifdef CONFIG_DRIVER_NL80211_IFX
{
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_configuration_failure(wpa_s);
#endif /* !(OREO || PIE) */
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DPP2
if (auth->peer_version >= 2 &&
auth->conf_resp_status == DPP_STATUS_OK) {
@@ -1741,11 +1729,9 @@
{
wpa_printf(MSG_DEBUG, "DPP: Authentication succeeded");
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_SUCCESS "init=%d", initiator);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_auth_success(wpa_s);
#endif /* !(OREO || PIE) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_TESTING_OPTIONS
if (dpp_test == DPP_TEST_STOP_AT_AUTH_CONF) {
wpa_printf(MSG_INFO,
@@ -1802,11 +1788,9 @@
if (auth->auth_resp_status == DPP_STATUS_RESPONSE_PENDING) {
wpa_printf(MSG_DEBUG,
"DPP: Start wait for full response");
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_resp_pending(wpa_s);
#endif /* !(OREO || PIE) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
offchannel_send_action_done(wpa_s);
wpas_dpp_listen_start(wpa_s, auth->curr_freq);
return;
@@ -1849,11 +1833,9 @@
if (dpp_auth_conf_rx(auth, hdr, buf, len) < 0) {
wpa_printf(MSG_DEBUG, "DPP: Authentication failed");
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_auth_failure(wpa_s);
#endif /* !(OREO || PIE) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return;
}
@@ -2956,16 +2938,12 @@
#endif /* CONFIG_DPP2 */
if (!resp)
-#ifdef CONFIG_DRIVER_NL80211_IFX
{
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
wpas_notify_dpp_configuration_failure(wpa_s);
#endif /* !(OREO || PIE) */
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
auth->conf_resp = resp;
return resp;
}
@@ -3018,7 +2996,6 @@
#endif /* CONFIG_DPP2 */
offchannel_send_action_done(wpa_s);
wpas_dpp_listen_stop(wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
if (ok) {
wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT);
#if !(defined(OREO) || defined(PIE))
@@ -3030,12 +3007,6 @@
wpas_notify_dpp_configuration_failure(wpa_s);
#endif /* !(OREO || PIE) */
}
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (ok)
- wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT);
- else
- wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
dpp_auth_deinit(wpa_s->dpp_auth);
wpa_s->dpp_auth = NULL;
wpabuf_free(resp);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/driver_i.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/driver_i.h
index c7a2752..e60bada 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/driver_i.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/driver_i.h
@@ -599,7 +599,6 @@
return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(ANDROID) || defined(BCM_LINUX_BUILD)
static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
char *cmd, char *buf, size_t buf_len)
@@ -612,17 +611,6 @@
return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
}
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
-static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
- char *cmd, char *buf, size_t buf_len)
-{
- if (!wpa_s->driver->driver_cmd)
- return -1;
- return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
-}
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
const u8 *kek, size_t kek_len,
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/eapol_test.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/eapol_test.c
index f01407e..9f69736 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/eapol_test.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/eapol_test.c
@@ -1449,11 +1449,7 @@
return -1;
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (eloop_init(&wpa_s)) {
-#else
if (eloop_init()) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/events.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/events.c
index 77a44c7..0738fd9 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/events.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/events.c
@@ -5,11 +5,7 @@
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CONTRIBUTE_COPYRIGHT
/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "includes.h"
@@ -49,28 +45,18 @@
#include "bss.h"
#include "scan.h"
#include "offchannel.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "wapi/wapi_interface.h"
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "interworking.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
-#include "wpa_cckm.h"
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "mesh.h"
#include "mesh_mpm.h"
#include "wmm_ac.h"
+#ifdef CONFIG_DPP
#include "dpp_supplicant.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
+#endif /* CONFIG_DPP */
#ifdef BRCM_DHCP_HLP
#include <net/if.h>
#include <sys/ioctl.h>
#include "rsn_supp/wpa_i.h"
#endif /* BRCM_DHCP_HLP */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#define MAX_OWE_TRANSITION_BSS_SELECT_COUNT 5
@@ -354,12 +340,7 @@
wpa_s->ap_ies_from_associnfo = 0;
wpa_s->current_ssid = NULL;
eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI_AP)
- if (wpa_s->key_mgmt != WPA_KEY_MGMT_WAPI_PSK)
- wpa_s->key_mgmt = 0;
-#else
wpa_s->key_mgmt = 0;
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI_AP */
wpas_rrm_reset(wpa_s);
wpa_s->wnmsleep_used = 0;
@@ -391,7 +372,6 @@
return;
for (i = 0; i < ie.num_pmkid; i++) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
if (wpa_s->current_ssid &&
wpa_s->current_ssid->proactive_key_caching == 1) {
@@ -405,7 +385,6 @@
}
else
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
pmksa_set = pmksa_cache_set_current(wpa_s->wpa,
ie.pmkid + i * PMKID_LEN,
NULL, NULL, 0, NULL, 0);
@@ -598,12 +577,6 @@
struct wpa_ie_data ie;
int proto_match = 0;
const u8 *rsn_ie, *wpa_ie;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- const u8 *wapi_ie;
- u8 wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int ret;
#ifdef CONFIG_WEP
int wep_ok;
@@ -612,43 +585,6 @@
ret = wpas_wps_ssid_bss_match(wpa_s, ssid, bss);
if (ret >= 0)
return ret;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- wapi_ie = wpa_bss_get_ie(bss, WLAN_EID_WAPI);
- if(wapi_ie)
- wpa_printf(MSG_DEBUG, "%s : get wapi_ie\n",__func__);
- else
- wpa_printf(MSG_DEBUG, "%s : wapi is null\n",__func__);
- while ((ssid->proto & WPA_PROTO_WAPI) && wapi_ie)
- {
- proto_match++;
-
- wapi_ie_len = wapi_ie ? wapi_ie[1] + 2: 0;
- bss->wapi_ie_len = wapi_ie_len;
- ssid->wapi_ie_len = wapi_ie_len;
-
- wpa_printf(MSG_DEBUG, "ssid->wapi=%x, ssid->key_mgmt=%x "
- "bss->wapi_ie_len=%d \n"
- ,ssid->wapi, ssid->key_mgmt, (int)bss->wapi_ie_len);
- wpa_printf(MSG_DEBUG, "wapi_ie:[%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x]\n",
- wapi_ie[0], wapi_ie[1], wapi_ie[2], wapi_ie[3], wapi_ie[4],
- wapi_ie[5], wapi_ie[6], wapi_ie[7], wapi_ie[8], wapi_ie[9] );
-
- if ( ((ssid->wapi & 0x04) || (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_PSK)) && (wapi_ie[9] == 2) ) {
- /* 0x400 ---- 10000000000 */
- wpa_printf(MSG_DEBUG, "WAPI PSK network is selected based on WAPI IE");
- return 1;
- }
- /* 0x800 ---- 100000000000*/
- if ( ((ssid->wapi & 0x08) || (ssid->key_mgmt & WPA_KEY_MGMT_WAPI_CERT)) && (wapi_ie[9] == 1) ) {
- wpa_printf(MSG_DEBUG, "WAPI CERT network is selected based on WAPI IE");
- return 1;
- }
-
- break;
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WEP
/* Allow TSN if local configuration accepts WEP use without WPA/WPA2 */
@@ -839,13 +775,8 @@
}
#endif /* CONFIG_OWE */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if ((ssid->proto & (WPA_PROTO_WPA | WPA_PROTO_RSN | WPA_PROTO_WAPI)) &&
- wpa_key_mgmt_wpa(ssid->key_mgmt) && proto_match == 0) {
-#else
if ((ssid->proto & (WPA_PROTO_WPA | WPA_PROTO_RSN)) &&
wpa_key_mgmt_wpa(ssid->key_mgmt) && proto_match == 0) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
if (debug_print)
wpa_dbg(wpa_s, MSG_DEBUG,
" skip - no WPA/RSN proto match");
@@ -1150,7 +1081,7 @@
#endif /* CONFIG_OWE */
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_ANDROID12)
+#if defined(CONFIG_ANDROID12)
int disabled_freq(struct wpa_supplicant *wpa_s, int freq)
#else
static int disabled_freq(struct wpa_supplicant *wpa_s, int freq)
@@ -1693,124 +1624,6 @@
wpa_dbg(wpa_s, MSG_DEBUG, "Selecting BSS from priority group %d",
group->priority);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- struct wpa_scan_res *selected = NULL;
- wpa_printf(MSG_DEBUG, " * %s",__func__);
- struct wpa_ssid *ssid;
- const u8 *ssid_, *ie;
- u8 ssid_len, wapi_ie_len;
- struct wpa_blacklist *e;
- struct wpa_bss wpa_bss;
- /* check scan_res */
-
- if(wpa_s->wapi_scan_res) {
- /* First, try to find WAPI-enabled AP */
- wpa_printf(MSG_DEBUG, " * Try to find WAPI-enabled AP");
- for (i = 0; i < wpa_s->wapi_scan_res->num && !selected; i++) {
- struct wpa_scan_res *bss = wpa_s->wapi_scan_res->res[i];
-
- /*
- wpa_scan_res *bss -> use wpa_scan_get_ie func.
- */
- ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
- ssid_ = ie ? ie + 2 : (u8 *) "";
- ssid_len = ie ? ie[1] : 0;
-
- const u8 *wapi_ie = wpa_scan_get_ie(bss, WLAN_EID_WAPI);
- wapi_ie_len = wapi_ie ? wapi_ie[1] + 2: 0;
- wpa_printf(MSG_DEBUG, "%d: " MACSTR " ssid='%s' wapi_ie_len=%lu caps=0x%x",
- i, MAC2STR(bss->bssid),
- wpa_ssid_txt(ssid_, ssid_len),
- (unsigned long) bss->wapi_ie_len, bss->caps);
-
- e = wpa_blacklist_get(wpa_s, bss->bssid);
- if (e && e->count > 1) {
- wpa_printf(MSG_DEBUG, " skip - blacklisted");
- continue;
- }
-
-
- if (wapi_ie_len == 0) {
- wpa_printf(MSG_DEBUG, " * skip - no WAPI IE");
- continue;
- }
- else {
- wpa_printf(MSG_DEBUG, " * get Wapi via WAPI_IE, wapi_ie_len = %d wapi_ie_len = %d\n",(int)bss->wapi_ie_len, wapi_ie_len);
- }
-
- for (ssid = group; ssid; ssid = ssid->pnext) {
- wpa_printf(MSG_DEBUG, " * Enter for loop\n");
- if (ssid->disabled) {
- wpa_printf(MSG_DEBUG, " skip - disabled");
- continue;
- }
-
-#ifdef CONFIG_BRCM_AUTOMOTIVE
- if (ssid->bssid_set && ssid->ssid_len == 0 &&
- os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0) {
- wpa_printf(MSG_DEBUG, " skip - "
- "BSSID mismatch");
- continue;
- }
-
- if ((ssid_len != ssid->ssid_len ||
- os_memcmp(ssid_, ssid->ssid, ssid_len) != 0)) {
- wpa_printf(MSG_DEBUG, " skip - "
- "SSID mismatch");
- continue;
- }
-#else
- if (ssid_len != ssid->ssid_len ||
- os_memcmp(ssid_, ssid->ssid, ssid_len) != 0) {
- wpa_printf(MSG_DEBUG, " skip - "
- "SSID mismatch");
- continue;
- }
-#endif /* CONFIG_BRCM_AUTOMOTIVE */
- if (ssid->bssid_set &&
- os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0) {
- wpa_printf(MSG_DEBUG, " skip - "
- "BSSID mismatch");
- continue;
- }
- /* transfer to wpa_bss */
- os_memset(&wpa_bss,0,sizeof(wpa_bss));
- wpa_bss.flags = bss->flags;
- wpa_bss.freq = bss->freq;
- wpa_bss.beacon_int = bss->beacon_int;
- wpa_bss.caps = bss->caps;
- wpa_bss.qual = bss->qual;
- wpa_bss.noise = bss->noise;
- wpa_bss.level = bss->level;
- wpa_bss.tsf = bss->tsf;
- wpa_bss.ie_len = bss->ie_len;
- wpa_bss.beacon_ie_len = bss->beacon_ie_len;
- wpa_bss.wapi_ie_len = bss->wapi_ie_len;
- os_memcpy(&wpa_bss.bssid,bss->bssid,ETH_ALEN);
- int debug_print = 0;
- if (wpa_supplicant_ssid_bss_match(wpa_s, ssid, &wpa_bss, debug_print)) {
- selected = bss;
- *selected_ssid = ssid;
- wpa_printf(MSG_DEBUG, " selected WAPI AP "
- MACSTR " ssid='%s'", MAC2STR(bss->bssid), wpa_ssid_txt(ssid_, ssid_len));
- break;
- }
- }
- }
- if (selected) {
- struct wpa_scan_res *bss = selected;
- const u8 *ie, *ssid;
- u8 ssid_len;
- ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
- ssid = ie ? ie + 2 : (u8 *) "";
- ssid_len = ie ? ie[1] : 0;
- wpa_printf(MSG_DEBUG, " selected BSS " MACSTR " ssid='%s'", MAC2STR(bss->bssid), wpa_ssid_txt(ssid, ssid_len));
- return wpa_bss_get(wpa_s, bss->bssid, ssid, ssid_len);
- }
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
for (i = 0; i < wpa_s->last_scan_res_used; i++) {
struct wpa_bss *bss = wpa_s->last_scan_res[i];
@@ -2308,38 +2121,19 @@
ret = -1;
goto scan_work_done;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (wpa_s->wapi_scan_res) {
- wpa_scan_results_free(wpa_s->wapi_scan_res);
- }
- wpa_s->wapi_scan_res = wpa_supplicant_get_scan_results(wpa_s,
- data ? &data->scan_info :
- NULL, 1);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifndef CONFIG_NO_RANDOM_POOL
num = scan_res->num;
if (num > 10)
num = 10;
for (i = 0; i < num; i++) {
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- u8 buf[6];
-#else
u8 buf[5];
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
struct wpa_scan_res *res = scan_res->res[i];
buf[0] = res->bssid[5];
buf[1] = res->qual & 0xff;
buf[2] = res->noise & 0xff;
buf[3] = res->level & 0xff;
buf[4] = res->tsf & 0xff;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- buf[5] = res->wapi_ie_len & 0xff;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
random_add_randomness(buf, sizeof(buf));
}
#endif /* CONFIG_NO_RANDOM_POOL */
@@ -2910,11 +2704,6 @@
const u8 *p;
u8 bssid[ETH_ALEN];
bool bssid_known;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DRV_ROAM
- struct wpa_ie_data ie;
-#endif /* BRCM_DRV_ROAM */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_dbg(wpa_s, MSG_DEBUG, "Association info event");
bssid_known = wpa_drv_get_bssid(wpa_s, bssid) == 0;
@@ -2963,12 +2752,10 @@
data->assoc_info.resp_ies_len,
&resp_elems, 0) != ParseFailed) {
wpa_s->connection_set = 1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
wpa_s->connection_11b_only = supp_rates_11b_only(&req_elems) ||
supp_rates_11b_only(&resp_elems);
#endif /*CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_s->connection_ht = req_elems.ht_capabilities &&
resp_elems.ht_capabilities;
/* Do not include subset of VHT on 2.4 GHz vendor
@@ -2981,6 +2768,12 @@
BAND_2_4_GHZ);
wpa_s->connection_he = req_elems.he_capabilities &&
resp_elems.he_capabilities;
+ #ifdef CONFIG_IEEE80211AX
+ if(wpa_s->connection_he) {
+ wpa_s->ieee80211ax = 1;
+ wpa_printf(MSG_DEBUG, "HE connection");
+ }
+ #endif /*CONFIG_IEEE80211AX*/
}
}
@@ -3003,7 +2796,6 @@
(p[0] == WLAN_EID_RSN && p[1] >= 2))) {
if (wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, p, len))
break;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef WL_SAE
if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) {
@@ -3066,7 +2858,6 @@
}
}
#endif /* WL_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
found = 1;
wpa_find_assoc_pmkid(wpa_s);
}
@@ -3083,72 +2874,6 @@
if (!found_x && data->assoc_info.req_ies)
wpa_sm_set_assoc_rsnxe(wpa_s->wpa, NULL, 0);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DRV_ROAM
- /* The WPA/RSN IE has been updated at this point. Since the Firmware could have roamed
- * to a different security type, update the current supplicant configuration to use the AKM
- * and pairwise suites from the assoc IE passed by the driver.
- */
- if (wpas_driver_bss_selection(wpa_s)) {
- if (!(wpa_sm_parse_own_wpa_ie(wpa_s->wpa, &ie) < 0)) {
- struct wpa_ft_ies parse;
-
- /* Check for FT reassociation is done by the driver */
-#ifdef CONFIG_IEEE80211R
- if (wpa_key_mgmt_ft(wpa_s->key_mgmt) && (wpa_s->key_mgmt == ie.key_mgmt)) {
- if (wpa_ft_parse_ies(data->assoc_info.resp_ies,
- data->assoc_info.resp_ies_len, &parse) < 0) {
- wpa_printf(MSG_DEBUG, "Failed to parse FT IEs");
- return -1;
- }
- if (parse.rsn_pmkid != NULL) {
- wpa_drv_get_bssid(wpa_s, bssid);
- os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
- wpa_s->assoc_freq = data->assoc_info.freq;
- wpa_dbg(wpa_s, MSG_DEBUG, "Assume FT reassoc completed by the driver");
- return -1;
- }
- }
-#endif /* CONFIG_IEEE80211R */
- /* Check if firmware has roamed to a different security network */
- if(wpa_s->key_mgmt != ie.key_mgmt) {
- wpa_dbg(wpa_s, MSG_DEBUG, "Update to AKM suite 0x%x from Assoc IE",
- ie.key_mgmt);
- wpa_s->key_mgmt = ie.key_mgmt;
- wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
-
- if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
- /* Restore PMK as it can get overwritten if the previous
- * association was to 802.1X.
- */
- if ((!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE)) &&
- (wpa_s->current_ssid) &&
- (wpa_s->current_ssid->psk_set)) {
- wpa_sm_set_pmk(wpa_s->wpa, wpa_s->current_ssid->psk, PMK_LEN, NULL,wpa_s->bssid);
- }
-#ifdef BRCM_VE
- /* In case the driver wants to handle re-assocs, pass it down the PMK. */
- wpa_dbg(wpa_s, MSG_DEBUG, "Pass the PMK to the driver");
- wpa_sm_install_pmk(wpa_s->wpa);
-#endif /* BRCM_VE */
- }
- /* Reconfigure EAPOL state machine if firmware has roamed to 802.1X and supplicant
- * is configured for non-802.1X authentication mode.
- */
- if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
- wpa_dbg(wpa_s, MSG_DEBUG, "Reset EAPOL state machine");
- wpa_supplicant_initiate_eapol(wpa_s);
- }
- }
- if(wpa_s->pairwise_cipher != ie.pairwise_cipher) {
- wpa_dbg(wpa_s, MSG_DEBUG, "Update to pairwise cipher suite 0x%x from Assoc IE",
- ie.pairwise_cipher);
- wpa_s->pairwise_cipher = ie.pairwise_cipher;
- wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE, wpa_s->pairwise_cipher);
- }
- }
- }
-#endif /* BRCM_DRV_ROAM */
#ifdef CONFIG_OWE
if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE &&
(!bssid_known ||
@@ -3159,15 +2884,12 @@
return -1;
}
#endif /* CONFIG_OWE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_FILS
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_DHCP_HLP
wpa_dbg(wpa_s, MSG_DEBUG, "FILS: process HLP container. resp_frame %p", data->assoc_info.resp_frame);
/* FILS HLP Container */
fils_process_hlp_container(wpa_s->wpa, data->assoc_info.resp_ies, data->assoc_info.resp_ies_len);
#endif /* BRCM_DHCP_HLP */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_SME
if ((wpa_s->sme.auth_alg == WPA_AUTH_ALG_FILS ||
wpa_s->sme.auth_alg == WPA_AUTH_ALG_FILS_SK_PFS) &&
@@ -3186,18 +2908,6 @@
wpa_sm_set_reset_fils_completed(wpa_s->wpa, 1);
#endif /* CONFIG_FILS */
-#ifndef CONFIG_DRIVER_NL80211_IFX
-#ifdef CONFIG_OWE
- if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE &&
- (!bssid_known ||
- owe_process_assoc_resp(wpa_s->wpa, bssid,
- data->assoc_info.resp_ies,
- data->assoc_info.resp_ies_len) < 0)) {
- wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_UNSPECIFIED);
- return -1;
- }
-#endif /* CONFIG_OWE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_DPP2
wpa_sm_set_dpp_z(wpa_s->wpa, NULL);
@@ -3391,14 +3101,12 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_ROAM_OFFLOAD
#define IS_OKC_ROAM_OFFLOAD() (try_okc && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) && \
wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt))
#else
#define IS_OKC_ROAM_OFFLOAD() 0
#endif /* BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void wpas_fst_update_mb_assoc(struct wpa_supplicant *wpa_s,
union wpa_event_data *data)
@@ -3448,7 +3156,6 @@
#if defined(CONFIG_FILS) || defined(CONFIG_MBO)
struct wpa_bss *bss;
#endif /* CONFIG_FILS || CONFIG_MBO */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_ROAM_OFFLOAD
int try_okc = 0;
@@ -3460,17 +3167,11 @@
wpa_s->drv_flags&WPA_DRIVER_FLAGS_4WAY_HANDSHAKE? 1:0);
}
#endif /* BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_AP
if (wpa_s->ap_iface) {
if (!data)
return;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- os_memcpy(wpa_s->ap_iface->bss[0]->ifname, wpa_s->ifname, os_strlen(wpa_s->ifname));
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
hostapd_notif_assoc(wpa_s->ap_iface->bss[0],
data->assoc_info.addr,
data->assoc_info.req_ies,
@@ -3483,53 +3184,7 @@
eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
wpa_s->own_reconnect_req = 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- MAC_ADDRESS bssid_s;
- MAC_ADDRESS own_s;
-
- ft_completed = 0;
-
- if ( (wpa_s->current_ssid) && (wpa_s->current_ssid->wapi) ) {
- wpa_printf(MSG_DEBUG,"[WAPI] %s: associated to a wapi network.\n", __FUNCTION__);
- if (wpa_drv_get_bssid(wpa_s, bssid) >= 0 &&
- os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0) {
- wpa_msg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
- MACSTR, MAC2STR(bssid));
- os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
- os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
- }
-
- os_memset(&bssid_s, 0, sizeof(bssid_s));
- os_memset(&own_s, 0, sizeof(own_s));
-
- os_memcpy(bssid_s.v, bssid, sizeof(bssid_s.v));
- os_memcpy(own_s.v, wpa_s->wapi_own_addr, sizeof(own_s.v));
- wpa_hexdump(MSG_DEBUG,"bssid",bssid, sizeof(bssid));
- wpa_hexdump(MSG_DEBUG,"own mac",wpa_s->wapi_own_addr, 6);
-
- if(wpa_s->ap_wapi_ie_len) {
- wpa_printf(MSG_DEBUG,"%s: ap_wapi_ie_len is Not Zero, wpa_s->ap_wapi_ie_len=%d\n", __FUNCTION__, wpa_s->ap_wapi_ie_len);
- WAI_Msg_Input(CONN_ASSOC, &bssid_s, &own_s, wpa_s->ap_wapi_ie,
- wpa_s->ap_wapi_ie_len);
- }
- else {
- wpa_printf(MSG_DEBUG,"%s: ap_wapi_ie_len is Zero \n", __FUNCTION__);
- WAI_Msg_Input(CONN_ASSOC, &bssid_s, &own_s, NULL, 0);
- }
-
- wpa_supplicant_cancel_auth_timeout(wpa_s);
- wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
-#ifdef BRCM_SUPP
- /* Update assoc frequency in case of wapi */
- wpa_s->assoc_freq = data->assoc_info.freq;
-#endif /* BRCM_SUPP */
- wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid));
- } else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
ft_completed = wpa_ft_is_completed(wpa_s->wpa);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
/* BRCM OKC..
* Commenting this as SSID and BSSID is not yet initialized
@@ -3547,29 +3202,6 @@
if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0)
return;
#endif /* BRCM_OKC */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0)
- return;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_CCX
- if (wpa_key_mgmt_cckm(wpa_s->key_mgmt)) {
- if (wpa_drv_get_bssid(wpa_s, bssid) >= 0 &&
- os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) == 0) {
- /* redundant assoc event triggered by same roaming */
- wpa_msg(wpa_s, MSG_INFO, "drop redundant assoc event");
- return;
- }
-
- /* borrow ft_completed variable for CCKM reassoc */
- if (!ft_completed)
- ft_completed = wpa_cckm_reassoc_process(wpa_s->wpa,
- wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE);
-
- wpa_msg(wpa_s, MSG_INFO, "ft_completed = %d", ft_completed);
- }
-#endif /* BRCM_CCX */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* FILS authentication can share the same mechanism to mark the
* connection fully authenticated, so set ft_completed also based on
@@ -3585,13 +3217,9 @@
return;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(BRCM_VE) || defined(BRCM_ROAM_OFFLOAD)
/* If the old bss is non-NULL & connection is FT then assume driver did the 4-way handshake */
if (
-#ifdef BRCM_DRV_ROAM
- !wpas_driver_bss_selection(wpa_s) &&
-#endif /* BRCM_DRV_ROAM */
(wpa_s->wpa_state == WPA_COMPLETED &&
(wpa_key_mgmt_ft(wpa_s->key_mgmt) || IS_OKC_ROAM_OFFLOAD())))
{
@@ -3606,16 +3234,12 @@
}
/* For driver based roaming, insert PSK during the initial association */
if (
-#ifdef BRCM_DRV_ROAM
- is_zero_ether_addr(wpa_s->bssid) &&
-#endif /* BRCM_DRV_ROAM */
wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
/* In case the driver wants to handle re-assocs, pass it down the PMK. */
wpa_dbg(wpa_s, MSG_DEBUG, "Pass the PMK to the driver");
wpa_sm_install_pmk(wpa_s->wpa);
}
#endif /* BRCM_VE || BRCM_ROAM_OFFLOAD */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
if (os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0) {
if (os_reltime_initialized(&wpa_s->session_start)) {
@@ -3639,7 +3263,6 @@
if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) {
wpa_clear_keys(wpa_s, bssid);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ANDROID_P2P
if (wpa_s->current_ssid) {
struct wpa_bss *bss = NULL;
@@ -3656,7 +3279,6 @@
wpa_s->current_bss = bss;
}
#endif /* ANDROID_P2P */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_supplicant_select_config(wpa_s) < 0) {
wpa_supplicant_deauthenticate(
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
@@ -3672,7 +3294,6 @@
wpa_msg(wpa_s, MSG_WARNING,
"WPA/RSN IEs not updated");
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
/* BRCM OKC Moved this calling after supplicant gets the SSID and BSSID */
if (wpa_s->current_ssid &&
@@ -3681,11 +3302,9 @@
return;
}
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpas_fst_update_mb_assoc(wpa_s, data);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
/* BRCM OKC Moved this calling after supplicant gets the SSID and BSSID */
if (wpa_s->current_ssid &&
@@ -3694,7 +3313,6 @@
return;
}
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_SME
os_memcpy(wpa_s->sme.prev_bssid, bssid, ETH_ALEN);
wpa_s->sme.prev_bssid_set = 1;
@@ -3756,11 +3374,6 @@
/* Timeout for receiving the first EAPOL packet */
wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_supplicant_cancel_scan(wpa_s);
if (ft_completed) {
@@ -3815,7 +3428,7 @@
struct os_reltime now, age;
os_get_reltime(&now);
os_reltime_sub(&now, &wpa_s->pending_eapol_rx_time, &age);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_OKC)
+#if defined(BRCM_OKC)
if (age.sec == 0 && age.usec < 900000 &&
#else
if (age.sec == 0 && age.usec < 200000 &&
@@ -3970,50 +3583,6 @@
authenticating = wpa_s->wpa_state == WPA_AUTHENTICATING;
os_memcpy(prev_pending_bssid, wpa_s->pending_bssid, ETH_ALEN);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- MAC_ADDRESS bssid_s;
- MAC_ADDRESS own_s;
-
- wpa_printf(MSG_DEBUG, "%s: wpa_s->ap_wapi_ie_len=%d\twpa_s->assoc_wapi_ie_len =%d\n",
- __FUNCTION__, wpa_s->ap_wapi_ie_len, wpa_s->assoc_wapi_ie_len);
- if ( (wpa_s->ap_wapi_ie_len > 0) && (wpa_s->assoc_wapi_ie_len > 0) ) { /* this is a WAPI network */
- os_memset(&bssid_s, 0, sizeof(bssid_s));
- os_memset(&own_s, 0, sizeof(own_s));
-
- os_memcpy(bssid_s.v, wpa_s->bssid, sizeof(bssid_s.v));
- os_memcpy(own_s.v, wpa_s->wapi_own_addr, sizeof(own_s.v));
-
- WAI_Msg_Input(CONN_DISASSOC, &bssid_s, &own_s, NULL, 0);
-
- if (wpa_s->wpa_state >= WPA_ASSOCIATED)
- wpa_supplicant_req_scan(wpa_s, 0, 100000);
-
- if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
- wpas_connect_work_done(wpa_s);
- }
-
- bssid = wpa_s->bssid;
- if (os_memcmp(bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) == 0)
- bssid = wpa_s->pending_bssid;
- wpa_blacklist_add(wpa_s, bssid);
- wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_DISCONNECTED "- Disconnect event - "
- "remove keys");
-
- wpa_supplicant_mark_disassoc(wpa_s);
-
- wpa_s->ap_wapi_ie_len = 0;
- wpa_s->assoc_wapi_ie_len = 0;
- os_memset(wpa_s->ap_wapi_ie, 0, sizeof(wpa_s->ap_wapi_ie));
- os_memset(wpa_s->assoc_wapi_ie, 0, sizeof(wpa_s->assoc_wapi_ie));
-
- if (wpa_s->wapi_conf != NULL) {
- wapi_config_free(wpa_s->wapi_conf);
- wpa_s->wapi_conf = NULL;
- }
- } else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
/*
@@ -4140,11 +3709,6 @@
*/
wpa_supplicant_req_scan(wpa_s, 0, 100000);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -4171,11 +3735,6 @@
struct os_reltime t;
wpa_msg(wpa_s, MSG_WARNING, "Michael MIC failure detected");
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if (!wpa_s->current_ssid->wapi) {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
pairwise = (data && data->michael_mic_failure.unicast);
os_get_reltime(&t);
if ((wpa_s->last_michael_mic_error.sec &&
@@ -4258,11 +3817,6 @@
#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
}
wpa_s->last_michael_mic_error = t;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_s->mic_errors_seen++;
}
@@ -4341,12 +3895,6 @@
break;
}
#endif /* CONFIG_MATCH_IFACE */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- l2_packet_deinit(wpa_s->l2_wapi);
- wpa_s->l2_wapi = NULL;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_TERMINATE_ONLASTIF
/* check if last interface */
@@ -4386,32 +3934,6 @@
break;
}
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
-static void wpa_s_tdls_rx_action(struct wpa_supplicant *wpa_s,
- u8 category, const u8 *data, size_t len, const u8 *sa)
-{
- char *wfd_ie = NULL;
- u8 ie_len = 0;
-
- if(category == WLAN_ACTION_VENDOR_SPECIFIC) {
- if(len <= 0)
- return;
- ie_len = len * 2;
- wfd_ie = os_zalloc(ie_len + 1);
- if (!wfd_ie)
- return;
-
- wpa_snprintf_hex(wfd_ie, ie_len + 1,
- (u8 *)(data), ie_len);
-
- wpa_msg_global(wpa_s, MSG_INFO, TDLS_EVENT_PEER_FOUND MACSTR
- " tdls_wfd_ie=%s", MAC2STR(sa), wfd_ie);
-
- }
-}
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_TDLS */
@@ -4608,7 +4130,6 @@
}
#endif /* CONFIG_P2P */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(WL_SAE) || defined(CONFIG_SAE)
if (reason_code == WLAN_REASON_PREV_AUTH_NOT_VALID) {
const u8 *bssid = wpa_s->bssid;
@@ -4628,7 +4149,6 @@
}
}
#endif /* WL_SAE || CONFIG_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_supplicant_event_disassoc_finish(wpa_s, reason_code,
locally_generated);
}
@@ -4882,44 +4402,6 @@
MAC2STR(mgmt->sa));
return;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
- if(category == WLAN_ACTION_TDLS && plen >=4 &&
- payload[0] == WLAN_TDLS_SETUP_RESPONSE) {
- wpa_dbg(wpa_s, MSG_DEBUG,
- "TDLS: Setup Response Frame from " MACSTR,
- MAC2STR(mgmt->sa));
- wpa_msg_global(wpa_s, MSG_INFO, TDLS_PEER_CONNECTED MACSTR,
- MAC2STR(mgmt->sa));
- return;
- }
- if(category == WLAN_ACTION_TDLS && plen >=4 &&
- payload[0] == WLAN_TDLS_SETUP_CONFIRM) {
- wpa_dbg(wpa_s, MSG_DEBUG,
- "TDLS: Setup Confirmation frame Frame from " MACSTR,
- MAC2STR(mgmt->sa));
- wpa_msg_global(wpa_s, MSG_INFO, TDLS_PEER_CONNECTED MACSTR,
- MAC2STR(mgmt->sa));
- return;
- }
- if(category == WLAN_ACTION_TDLS && plen >=4 &&
- payload[0] == WLAN_TDLS_TEARDOWN) {
- wpa_dbg(wpa_s, MSG_DEBUG,
- "TDLS: Teardown frame Frame from " MACSTR,
- MAC2STR(mgmt->sa));
- wpa_msg_global(wpa_s, MSG_INFO, TDLS_PEER_DISCONNECTED MACSTR,
- MAC2STR(mgmt->sa));
- return;
- }
- if(category == WLAN_ACTION_VENDOR_SPECIFIC && plen >=4) {
- const u8 *pos = payload + 4;
- wpa_dbg(wpa_s, MSG_DEBUG,
- "TDLS: Vendor specific probe Response Frame from " MACSTR,
- MAC2STR(mgmt->sa));
- wpa_s_tdls_rx_action(wpa_s, category, pos, (plen - 4), mgmt->sa);
- }
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_TDLS */
#ifdef CONFIG_INTERWORKING
@@ -5222,11 +4704,9 @@
" qca_driver_reason=" : "",
connect_fail_reason(data->assoc_reject.reason_code));
wpa_s->assoc_status_code = data->assoc_reject.status_code;
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:807bc58f wpa_supplicant(hidl): Add timedOut param in assoc reject */
wpa_s->assoc_timed_out = data->assoc_reject.timed_out;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_ANDROID12)
+#if defined(CONFIG_ANDROID12)
wpas_notify_assoc_status_code(wpa_s, bssid, data->assoc_reject.timed_out,
data->assoc_reject.resp_ies, data->assoc_reject.resp_ies_len);
#else
@@ -5259,10 +4739,6 @@
#endif /* CONFIG_OWE */
#ifdef CONFIG_DPP2
- /* Try to follow AP's PFS policy. WLAN_STATUS_ASSOC_DENIED_UNSPEC is
- * the status code defined in the DPP R2 tech spec.
- * WLAN_STATUS_AKMP_NOT_VALID is addressed in the same manner as an
- * interoperability workaround with older hostapd implementation. */
if (DPP_VERSION > 1 && wpa_s->current_ssid &&
(wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_DPP ||
((wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_DPP) &&
@@ -5354,7 +4830,6 @@
}
#endif /* CONFIG_FILS */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
if(wpa_s->current_ssid &&
wpa_key_mgmt_sae(wpa_s->current_ssid->key_mgmt))
@@ -5365,7 +4840,6 @@
wpa_sm_pmksa_cache_flush(wpa_s->wpa, wpa_s->current_ssid);
}
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpas_connection_failed(wpa_s, bssid);
wpa_supplicant_mark_disassoc(wpa_s);
}
@@ -5440,7 +4914,6 @@
#endif /* CONFIG_NO_STDOUT_DEBUG */
switch (event) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_SAE
case EVENT_SAE_KEY:
memcpy(wpa_s->bssid, data->sae_key_info.peer_mac, ETH_ALEN);
@@ -5448,7 +4921,6 @@
data->sae_key_info.pmkid, wpa_s->bssid);
break;
#endif /* CONFIG_BRCM_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case EVENT_AUTH:
#ifdef CONFIG_FST
if (!wpas_fst_update_mbie(wpa_s, data->auth.ies,
@@ -5555,18 +5027,6 @@
wpa_s->scan_start_time.usec = 0;
wpa_dbg(wpa_s, MSG_DEBUG, "Scan completed in %ld.%06ld seconds",
diff.sec, diff.usec);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_DEBUG
- if(strncmp(wpa_s->ifname, "p2p", 3) != 0) {
- /* Avoid for p2p. Otherwise during p2p_find, it will
- * clutter the cli with too many event prints
- */
- wpa_msg_global(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS
- "Scan completed in %ld.%06ld seconds",
- diff.sec, diff.usec);
- }
-#endif /* BRCM_DEBUG */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
if (wpa_supplicant_event_scan_results(wpa_s, data))
break; /* interface may have been removed */
@@ -6045,12 +5505,10 @@
wpa_s, WLAN_REASON_DEAUTH_LEAVING, 1);
}
wpa_supplicant_mark_disassoc(wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
if (!wpa_s->conf->bss_no_flush_when_down)
wpa_bss_flush(wpa_s);
#endif /* ABOVE_10 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
os_reltime_age(&wpa_s->last_scan, &age);
if (age.sec >= SCAN_RES_VALID_FOR_CONNECT) {
clear_at.sec = SCAN_RES_VALID_FOR_CONNECT;
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/hs20_supplicant.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/hs20_supplicant.c
index 0fbbd8b..aa0ce7d 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/hs20_supplicant.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/hs20_supplicant.c
@@ -20,22 +20,18 @@
#include "driver_i.h"
#include "config.h"
#include "scan.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 Add notifications for ANQP/HS20 events */
#include "notify.h"
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "bss.h"
#include "blacklist.h"
#include "gas_query.h"
#include "interworking.h"
#include "hs20_supplicant.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_HS20
#include <dirent.h>
#endif /* CONFIG_BRCM_HS20 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "base64.h"
@@ -490,7 +486,6 @@
RX_HS20_ICON MACSTR " %s %u",
MAC2STR(sa), icon->file_name,
(unsigned int) icon->image_len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 wpa_supplicant:
* Add notifications for ANQP/HS20 events */
@@ -499,7 +494,6 @@
icon->image,
icon->image_len);
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return 0;
}
}
@@ -1224,13 +1218,11 @@
int hs20_fetch_osu(struct wpa_supplicant *wpa_s, int skip_scan)
{
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_HS20
char fname[256];
DIR *osu_dir;
struct dirent *file;
#endif /* CONFIG_BRCM_HS20 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
wpa_printf(MSG_DEBUG, "HS 2.0: Cannot start fetch_osu - "
"interface disabled");
@@ -1256,7 +1248,6 @@
wpa_s->network_select);
return -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_HS20
/*
* By default supplicant will save the retrieved icons with an
@@ -1281,7 +1272,6 @@
}
closedir(osu_dir);
#endif /* CONFIG_BRCM_HS20 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_msg(wpa_s, MSG_INFO, "Starting OSU provisioning information fetch");
wpa_s->num_osu_scans = 0;
@@ -1338,12 +1328,10 @@
osu_method, url);
else
wpa_msg(wpa_s, MSG_INFO, HS20_SUBSCRIPTION_REMEDIATION);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 Add notifications for ANQP/HS20 events */
wpas_notify_hs20_rx_subscription_remediation(wpa_s, url, osu_method);
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -1358,12 +1346,10 @@
wpa_msg(wpa_s, MSG_INFO, HS20_DEAUTH_IMMINENT_NOTICE "%u %u %s",
code, reauth_delay, url);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 Add notifications for ANQP/HS20 events */
wpas_notify_hs20_rx_deauth_imminent_notice(wpa_s, code, reauth_delay, url);
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (code == HS20_DEAUTH_REASON_CODE_BSS) {
wpa_printf(MSG_DEBUG, "HS 2.0: Add BSS to blacklist");
wpa_blacklist_add(wpa_s, wpa_s->bssid);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/interworking.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/interworking.c
index e2136dd..f68af5f 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/interworking.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/interworking.c
@@ -3151,12 +3151,10 @@
out:
wpa_msg(wpa_s, MSG_INFO, ANQP_QUERY_DONE "addr=" MACSTR " result=%s",
MAC2STR(dst), anqp_result);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 Add notifications for ANQP/HS20 events */
wpas_notify_anqp_query_done(wpa_s, dst, anqp_result, bss ? bss->anqp : NULL);
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/main.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/main.c
index c169b40..3bd07a3 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/main.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/main.c
@@ -190,13 +190,9 @@
return -1;
os_memset(¶ms, 0, sizeof(params));
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_MERGES
params.wpa_debug_level = MSG_DEBUG;
#endif /* CONFIG_BRCM_MERGES */
-#else
- params.wpa_debug_level = MSG_INFO;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
iface = ifaces = os_zalloc(sizeof(struct wpa_interface));
if (ifaces == NULL)
@@ -387,7 +383,6 @@
exitcode = -1;
break;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Support STA+GC on DBDC, SBSC and not on SBDC. */
else {
char buf[50];
@@ -399,7 +394,6 @@
else
global->rsdb_flag = 0;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
#ifdef CONFIG_MATCH_IFACE
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.c
index 4d8c85f..bfd8ce2 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.c
@@ -24,14 +24,13 @@
#include "p2p_supplicant.h"
#include "sme.h"
#include "notify.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_HIDL) && defined (CONFIG_ANDROIDQ)
+#if defined(CONFIG_HIDL) && defined(CONFIG_ANDROIDQ)
#include "hidl/1.2/hidl.h"
-#elif defined (ABOVE_8_1) && defined (PIE)
+#elif defined(ABOVE_8_1) && defined(PIE)
#include "hidl/1.1/hidl.h"
#elif defined(CONFIG_ANDROID11)
#include "hidl/1.3/hidl.h"
-#elif defined (CONFIG_ANDROID12)
+#elif defined(CONFIG_ANDROID12)
#include "hidl/1.4/hidl.h"
#else
#ifdef CONFIG_CTRL_IFACE_HIDL
@@ -99,7 +98,6 @@
struct wpa_supplicant *wpa_s, const u8 *sta, const u8 *p2p_dev_addr);
#endif /* CONFIG_HIDL */
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int wpas_notify_supplicant_initialized(struct wpa_global *global)
{
@@ -111,19 +109,11 @@
}
#endif /* CONFIG_CTRL_IFACE_DBUS_NEW */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
global->hidl = wpas_hidl_init(global);
if (!global->hidl)
return -1;
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef CONFIG_BINDER
- global->binder = wpas_binder_init(global);
- if (!global->binder)
- return -1;
-#endif /* CONFIG_BINDER */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return 0;
}
@@ -136,23 +126,16 @@
wpas_dbus_deinit(global->dbus);
#endif /* CONFIG_CTRL_IFACE_DBUS_NEW */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
if (global->hidl)
wpas_hidl_deinit(global->hidl);
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#else
-#ifdef CONFIG_BINDER
- if (global->binder)
- wpas_binder_deinit(global->binder);
-#endif /* CONFIG_BINDER */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
int wpas_notify_iface_added(struct wpa_supplicant *wpa_s)
{
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(ABOVE_8_1)
+#if defined(ABOVE_8_1)
if (!wpa_s->p2p_mgmt) {
/* linux commit:6a8dee76d: wpa_supplicant: Drop the old D-Bus interface support */
if (wpas_dbus_register_interface(wpa_s))
@@ -167,13 +150,11 @@
return -1;
#endif /*CONFIG_DRIVER_NL80211_IFX && ABOVE_8_1 */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* HIDL interface wants to keep track of the P2P mgmt iface. */
if (wpas_hidl_register_interface(wpa_s))
return -1;
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
return 0;
}
@@ -181,7 +162,7 @@
void wpas_notify_iface_removed(struct wpa_supplicant *wpa_s)
{
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(ABOVE_8_1)
+#if defined(ABOVE_8_1)
if (!wpa_s->p2p_mgmt) {
/* unregister interface in new DBus ctrl iface */
wpas_dbus_unregister_interface(wpa_s);
@@ -194,12 +175,10 @@
wpas_dbus_unregister_interface(wpa_s);
#endif /*CONFIG_DRIVER_NL80211_IFX && ABOVE_8_1 */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* HIDL interface wants to keep track of the P2P mgmt iface. */
wpas_hidl_unregister_interface(wpa_s);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -240,11 +219,9 @@
wpa_ssid_txt(wpa_s->current_ssid->ssid,
wpa_s->current_ssid->ssid_len) : "");
#endif /* ANDROID */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_state_changed(wpa_s);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -254,11 +231,9 @@
return;
wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_DISCONNECT_REASON);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_disconnect_reason(wpa_s);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -270,7 +245,7 @@
wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_AUTH_STATUS_CODE);
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_ANDROID12)
+#if defined(CONFIG_ANDROID12)
void wpas_notify_assoc_status_code(struct wpa_supplicant *wpa_s, const u8 *bssid,
u8 timed_out, const u8 *assoc_resp_ie,
size_t assoc_resp_ie_len)
@@ -282,7 +257,6 @@
return;
wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_ASSOC_STATUS_CODE);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_assoc_reject(wpa_s
#ifdef CONFIG_ANDROID12
@@ -290,9 +264,7 @@
#endif /* CONFIG_ANDROID12 */
);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:38e96765 wpa_supplicant(hidl):
* Implement auth timeout callback */
@@ -306,7 +278,6 @@
#endif /* CONFIG_CTRL_IFACE_HIDL */
}
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void wpas_notify_roam_time(struct wpa_supplicant *wpa_s)
@@ -369,11 +340,9 @@
return;
wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_CURRENT_BSS);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_bssid_changed(wpa_s);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -415,11 +384,9 @@
return;
wpas_dbus_signal_network_request(wpa_s, ssid, rtype, default_txt);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_network_request(wpa_s, ssid, rtype, default_txt);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -484,13 +451,11 @@
#ifdef CONFIG_WPS
wpas_dbus_signal_wps_event_fail(wpa_s, fail);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_wps_event_fail(wpa_s, fail->peer_macaddr,
fail->config_error,
fail->error_indication);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_WPS */
}
@@ -502,11 +467,9 @@
#ifdef CONFIG_WPS
wpas_dbus_signal_wps_event_success(wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_wps_event_success(wpa_s);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_WPS */
}
@@ -517,11 +480,9 @@
#ifdef CONFIG_WPS
wpas_dbus_signal_wps_event_pbc_overlap(wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_notify_wps_event_pbc_overlap(wpa_s);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_WPS */
}
@@ -539,18 +500,14 @@
* regular ones.
*/
if (!ssid->p2p_group && wpa_s->global->p2p_group_formation != wpa_s)
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:57ffbcfc wpa_supplicant: HIDL implementation (1/2) */
{
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpas_dbus_register_network(wpa_s, ssid);
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:57ffbcfc wpa_supplicant: HIDL implementation (1/2) */
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_register_network(wpa_s, ssid);
#endif /* CONFIG_CTRL_IFACE_HIDL */
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -559,11 +516,9 @@
{
#ifdef CONFIG_P2P
wpas_dbus_register_persistent_group(wpa_s, ssid);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_register_network(wpa_s, ssid);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_P2P */
}
@@ -573,11 +528,9 @@
{
#ifdef CONFIG_P2P
wpas_dbus_unregister_persistent_group(wpa_s, ssid->id);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_unregister_network(wpa_s, ssid);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_P2P */
}
@@ -591,18 +544,14 @@
wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
if (!ssid->p2p_group && wpa_s->global->p2p_group_formation != wpa_s &&
!wpa_s->p2p_mgmt)
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:57ffbcfc wpa_supplicant: HIDL implementation (1/2) */
{
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpas_dbus_unregister_network(wpa_s, ssid->id);
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:57ffbcfc wpa_supplicant: HIDL implementation (1/2) */
#ifdef CONFIG_CTRL_IFACE_HIDL
wpas_hidl_unregister_network(wpa_s, ssid);
#endif /* CONFIG_CTRL_IFACE_HIDL */
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (network_is_persistent_group(ssid))
wpas_notify_persistent_group_removed(wpa_s, ssid);
@@ -813,18 +762,15 @@
{
/* Notify P2P find has stopped */
wpas_dbus_signal_p2p_find_stopped(wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_find_stopped(wpa_s);
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
void wpas_notify_p2p_device_found(struct wpa_supplicant *wpa_s,
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
const u8 *addr, const struct p2p_peer_info *info,
@@ -834,23 +780,15 @@
u8 peer_wfd_r2_device_info_len,
#endif /* CONFIG_ANDROID12 */
int new_device)
-#else /* CONFIG_DRIVER_NL80211_IFX */
- const u8 *dev_addr, int new_device)
-#endif /* CONFIG_DRIVER_NL80211_IFX */
{
if (new_device) {
/* Create the new peer object */
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_dbus_register_peer(wpa_s, info->p2p_device_addr);
-#else /* CONFIG_DRIVER_NL80211_IFX */
- wpas_dbus_register_peer(wpa_s, dev_addr);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
/* Notify a new peer has been detected*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_dbus_signal_peer_device_found(wpa_s, info->p2p_device_addr);
@@ -864,9 +802,6 @@
#endif /* CONFIG_ANDROID12 */
);
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#else /* CONFIG_DRIVER_NL80211_IFX */
- wpas_dbus_signal_peer_device_found(wpa_s, dev_addr);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -877,13 +812,11 @@
/* Create signal on interface object*/
wpas_dbus_signal_peer_device_lost(wpa_s, dev_addr);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_device_lost(wpa_s, dev_addr);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -894,13 +827,11 @@
wpas_dbus_signal_p2p_group_removed(wpa_s, role);
wpas_dbus_unregister_p2p_group(wpa_s, ssid);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_group_removed(wpa_s, ssid, role);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -908,13 +839,11 @@
const u8 *src, u16 dev_passwd_id, u8 go_intent)
{
wpas_dbus_signal_p2p_go_neg_req(wpa_s, src, dev_passwd_id, go_intent);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_go_neg_req(wpa_s, src, dev_passwd_id, go_intent);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -922,13 +851,11 @@
struct p2p_go_neg_results *res)
{
wpas_dbus_signal_p2p_go_neg_resp(wpa_s, res);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_go_neg_completed(wpa_s, res);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -936,13 +863,11 @@
int status, const u8 *bssid)
{
wpas_dbus_signal_p2p_invitation_result(wpa_s, status, bssid);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_invitation_result(wpa_s, status, bssid);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -962,14 +887,12 @@
{
wpas_dbus_signal_p2p_sd_response(wpa_s, sa, update_indic,
tlvs, tlvs_len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_sd_response(wpa_s, sa, update_indic,
tlvs, tlvs_len);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -995,7 +918,6 @@
wpas_dbus_signal_p2p_provision_discovery(wpa_s, dev_addr, request,
status, config_methods,
generated_pin);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
@@ -1003,7 +925,6 @@
status, config_methods,
generated_pin);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -1015,13 +936,11 @@
wpas_dbus_register_p2p_group(wpa_s, ssid);
wpas_dbus_signal_p2p_group_started(wpa_s, client, persistent, ip);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_group_started(wpa_s, ssid, persistent, client);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -1030,13 +949,11 @@
{
/* Notify a group formation failed */
wpas_dbus_signal_p2p_group_formation_failure(wpa_s, reason);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_group_formation_failure(wpa_s, reason);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -1054,14 +971,12 @@
/* Notify a P2P Invitation Request */
wpas_dbus_signal_p2p_invitation_received(wpa_s, sa, go_dev_addr, bssid,
id, op_freq);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_p2p_invitation_received(wpa_s, sa, go_dev_addr, bssid,
id, op_freq);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
#endif /* CONFIG_P2P */
@@ -1087,13 +1002,11 @@
/* Notify listeners a new station has been authorized */
wpas_dbus_signal_sta_authorized(wpa_s, sta);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_ap_sta_authorized(wpa_s, sta, p2p_dev_addr);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -1113,13 +1026,11 @@
/* Notify listeners a station has been deauthorized */
wpas_dbus_signal_sta_deauthorized(wpa_s, sta);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_hidl_notify_ap_sta_deauthorized(wpa_s, sta, p2p_dev_addr);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* Unregister the station */
wpas_dbus_unregister_sta(wpa_s, sta);
}
@@ -1198,11 +1109,9 @@
void wpas_notify_eap_error(struct wpa_supplicant *wpa_s, int error_code)
{
wpa_msg(wpa_s, MSG_ERROR, WPA_EVENT_EAP_ERROR_CODE "%d", error_code);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef VTS_1_0
wpas_hidl_notify_eap_error(wpa_s, error_code);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -1242,7 +1151,6 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 Add notifications for ANQP/HS20 events */
void wpas_notify_anqp_query_done(struct wpa_supplicant *wpa_s, const u8* bssid,
@@ -1303,7 +1211,6 @@
#endif /* CONFIG_HS20 */
}
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_MESH
void wpas_notify_mesh_group_started(struct wpa_supplicant *wpa_s,
@@ -1348,7 +1255,6 @@
}
#endif /* CONFIG_MESH */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !(defined(OREO) || defined(PIE))
/* android commit:59532857 [DPP] Added support for DPP in hidl */
/*
@@ -1507,4 +1413,3 @@
#endif /* CONFIG_CTRL_IFACE_HIDL */
}
#endif /* CONFIG_ANDROID11 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.h
index e23315a..386f643 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/notify.h
@@ -10,7 +10,6 @@
#define NOTIFY_H
#include "p2p/p2p.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 Add notifications for ANQP/HS20 events */
#include "bss.h"
@@ -22,7 +21,6 @@
/* android commit:126b1702 wifi: implement PMK cache interface and callback */
#include "rsn_supp/pmksa_cache.h"
#endif /* CONFIG_ANDROID11 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wps_credential;
struct wps_event_m2d;
@@ -39,20 +37,16 @@
void wpas_notify_disconnect_reason(struct wpa_supplicant *wpa_s);
void wpas_notify_auth_status_code(struct wpa_supplicant *wpa_s);
void wpas_notify_assoc_status_code(struct wpa_supplicant *wpa_s
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
, const u8 *bssid, u8 timed_out
, const u8 *assoc_resp_ie, size_t assoc_resp_ie_len
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:38e96765 wpa_supplicant(hidl):
* Implement auth timeout callback */
void wpas_notify_auth_timeout(struct wpa_supplicant *wpa_s);
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void wpas_notify_roam_time(struct wpa_supplicant *wpa_s);
void wpas_notify_roam_complete(struct wpa_supplicant *wpa_s);
void wpas_notify_session_length(struct wpa_supplicant *wpa_s);
@@ -121,7 +115,6 @@
const u8 *p2p_dev_addr);
void wpas_notify_p2p_find_stopped(struct wpa_supplicant *wpa_s);
void wpas_notify_p2p_device_found(struct wpa_supplicant *wpa_s,
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
const u8 *addr, const struct p2p_peer_info *info,
@@ -131,9 +124,6 @@
u8 peer_wfd_r2_device_info_len,
#endif /* CONFIG_ANDROID12 */
int new_device);
-#else /* CONFIG_DRIVER_NL80211_IFX */
- const u8 *dev_addr, int new_device);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void wpas_notify_p2p_device_lost(struct wpa_supplicant *wpa_s,
const u8 *dev_addr);
void wpas_notify_p2p_group_removed(struct wpa_supplicant *wpa_s,
@@ -195,7 +185,6 @@
const u8 *peer_addr);
void wpas_notify_mesh_peer_disconnected(struct wpa_supplicant *wpa_s,
const u8 *peer_addr, u16 reason_code);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:04a9d747 Add notifications for ANQP/HS20 events */
void wpas_notify_anqp_query_done(struct wpa_supplicant *wpa_s, const u8* bssid,
@@ -230,6 +219,5 @@
struct rsn_pmksa_cache_entry *entry);
#endif /* CONFIG_ANDROID11 */
#endif /* !(OREO || PIE) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* NOTIFY_H */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.c
index eb2588f..b28308b 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.c
@@ -163,7 +163,6 @@
enum wpas_p2p_channel_update_trig trig);
static void wpas_p2p_reconsider_moving_go(void *eloop_ctx, void *timeout_ctx);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
static int wpas_p2p_select_go_freq(struct wpa_supplicant *wpa_s, int freq);
static int wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s,
@@ -172,7 +171,6 @@
int vht, int max_oper_chwidth, int he,
const struct p2p_channels *channels);
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* Get the number of concurrent channels that the HW can operate, but that are
@@ -402,7 +400,7 @@
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
static int wpas_p2p_scan(void *ctx, enum p2p_scan_type type, int *freq,
unsigned int num_req_dev_types,
const u8 *req_dev_types, const u8 *dev_id, u16 pw_id)
@@ -469,14 +467,13 @@
params->freqs = os_calloc(2, sizeof(int));
if (params->freqs == NULL)
goto fail;
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
params->freqs[0] = freq[0];
#else
params->freqs[0] = freq;
#endif /* CONFIG_DRIVER_NL80211_IFX && CONFIG_BRCM_RSDB */
params->freqs[1] = 0;
break;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
case P2P_SCAN_SOCIAL_PLUS_5G:
params->freqs = os_malloc(8 * sizeof(int));
@@ -491,7 +488,6 @@
params->freqs[i+3] = 0;
break;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
case P2P_SCAN_SOCIAL_PLUS_ONE:
params->freqs = os_calloc(ARRAY_SIZE(social_channels_freq) + 2,
sizeof(int));
@@ -503,7 +499,7 @@
params->freqs[num_channels++] =
social_channels_freq[i];
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
if (p2p_supported_freq(wpa_s->global->p2p, freq[0]))
params->freqs[num_channels++] = freq[0];
#else
@@ -1232,13 +1228,11 @@
s->pbss = ssid->pbss;
s->pairwise_cipher = ssid->pbss ? WPA_CIPHER_GCMP : WPA_CIPHER_CCMP;
s->export_keys = 1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
/* Fix for persistent GC connection to GO */
s->vht = ssid->vht;
s->ht40 = ssid->ht40;
#endif /* CONFIG_BRCM_AUTOMOTIVE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (ssid->passphrase) {
os_free(s->passphrase);
s->passphrase = os_strdup(ssid->passphrase);
@@ -2195,11 +2189,9 @@
d->disassoc_low_ack = s->disassoc_low_ack;
d->disable_scan_offload = s->disable_scan_offload;
d->passive_scan = s->passive_scan;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSN_CNTRS
d->replay_cntrs = s->replay_cntrs;
#endif /* CONFIG_BRCM_RSN_CNTRS */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (s->wps_nfc_dh_privkey && s->wps_nfc_dh_pubkey &&
!d->wps_nfc_pw_from_config) {
@@ -2295,7 +2287,6 @@
return 0;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
int wpas_p2p_group_remove_ho(struct wpa_supplicant *wpa_s)
{
@@ -2454,7 +2445,6 @@
return 0;
}
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void wpas_p2p_remove_pending_group_interface(
struct wpa_supplicant *wpa_s)
@@ -2706,7 +2696,6 @@
const struct p2p_peer_info *info,
int new_device)
{
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
u8 *wfd_dev_info = NULL;
@@ -2715,20 +2704,16 @@
u8 *wfd_r2_dev_info = NULL;
u8 wfd_r2_dev_info_len = 0;
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifndef CONFIG_NO_STDOUT_DEBUG
struct wpa_supplicant *wpa_s = ctx;
char devtype[WPS_DEV_TYPE_BUFSIZE];
char *wfd_dev_info_hex = NULL;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
char *wfd_r2_dev_info_hex = NULL;
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WIFI_DISPLAY
wfd_dev_info_hex = wifi_display_subelem_hex(info->wfd_subelems,
WFD_SUBELEM_DEVICE_INFO);
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
if (wfd_dev_info_hex) {
@@ -2748,7 +2733,6 @@
hexstr2bin(wfd_r2_dev_info_hex, wfd_r2_dev_info, wfd_r2_dev_info_len);
}
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_WIFI_DISPLAY */
if (info->p2ps_instance) {
@@ -2800,7 +2784,7 @@
wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
" p2p_dev_addr=" MACSTR
" pri_dev_type=%s name='%s' config_methods=0x%x "
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_ANDROID12)
+#if defined(CONFIG_ANDROID12)
"dev_capab=0x%x group_capab=0x%x%s%s%s%s%s new=%d",
#else
"dev_capab=0x%x group_capab=0x%x%s%s%s new=%d",
@@ -2812,7 +2796,7 @@
info->dev_capab, info->group_capab,
wfd_dev_info_hex ? " wfd_dev_info=0x" : "",
wfd_dev_info_hex ? wfd_dev_info_hex : "",
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_ANDROID12)
+#if defined(CONFIG_ANDROID12)
wfd_r2_dev_info_hex ? " wfd_r2_dev_info=0x" : "",
wfd_r2_dev_info_hex ? wfd_r2_dev_info_hex : "",
#endif /* CONFIG_DRIVER_NL80211_IFX && CONFIG_ANDROID12 */
@@ -2821,14 +2805,11 @@
done:
os_free(wfd_dev_info_hex);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
os_free(wfd_r2_dev_info_hex);
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_NO_STDOUT_DEBUG */
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:fd2fd660 wpa_supplicant(hidl):
* Implementation of P2p callbacks */
wpas_notify_p2p_device_found(ctx, addr, info, wfd_dev_info,
@@ -2838,9 +2819,6 @@
#endif /* CONFIG_ANDROID12 */
new_device);
os_free(wfd_dev_info);
-#else
- wpas_notify_p2p_device_found(ctx, info->p2p_device_addr, new_device);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -3061,7 +3039,7 @@
os_memset(empty_dev_type, 0, sizeof(empty_dev_type));
pri_dev_type = empty_dev_type;
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_AUTOMOTIVE)
+#if defined(CONFIG_BRCM_AUTOMOTIVE)
res = os_snprintf(params, sizeof(params), " rx_freq=%d p2p_dev_addr=" MACSTR
" pri_dev_type=%s name='%s' config_methods=0x%x "
"dev_capab=0x%x group_capab=0x%x%s%s",
@@ -4853,15 +4831,11 @@
if (wpa_s->conf->p2p_device_random_mac_addr == 0)
return 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
if (wpa_s->conf->ssid == NULL) {
#else /* ABOVE_10 */
if (!wpa_s->conf->ssid) {
#endif /* ABOVE_10 */
-#else
- if (!wpa_s->conf->ssid) {
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (random_mac_addr(addr) < 0) {
wpa_msg(wpa_s, MSG_INFO,
"Failed to generate random MAC address");
@@ -5958,34 +5932,6 @@
}
-/**
- * wpas_p2p_connect - Request P2P Group Formation to be started
- * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
- * @peer_addr: Address of the peer P2P Device
- * @pin: PIN to use during provisioning or %NULL to indicate PBC mode
- * @persistent_group: Whether to create a persistent group
- * @auto_join: Whether to select join vs. GO Negotiation automatically
- * @join: Whether to join an existing group (as a client) instead of starting
- * Group Owner negotiation; @peer_addr is BSSID in that case
- * @auth: Whether to only authorize the connection instead of doing that and
- * initiating Group Owner negotiation
- * @go_intent: GO Intent or -1 to use default
- * @freq: Frequency for the group or 0 for auto-selection
- * @freq2: Center frequency of segment 1 for the GO operating in VHT 80P80 mode
- * @persistent_id: Persistent group credentials to use for forcing GO
- * parameters or -1 to generate new values (SSID/passphrase)
- * @pd: Whether to send Provision Discovery prior to GO Negotiation as an
- * interoperability workaround when initiating group formation
- * @ht40: Start GO with 40 MHz channel width
- * @vht: Start GO with VHT support
- * @vht_chwidth: Channel width supported by GO operating with VHT support
- * (CHANWIDTH_*).
- * @group_ssid: Specific Group SSID for join or %NULL if not set
- * @group_ssid_len: Length of @group_ssid in octets
- * Returns: 0 or new PIN (if pin was %NULL) on success, -1 on unspecified
- * failure, -2 on failure due to channel not currently available,
- * -3 if forced channel is not supported
- */
int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
const char *pin, enum p2p_wps_method wps_method,
int persistent_group, int auto_join, int join, int auth,
@@ -6889,13 +6835,11 @@
p2p_go_params(wpa_s->global->p2p, ¶ms);
params.persistent_group = persistent_group;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AGO_PASSPHRASE
if (wpa_s->conf->ago_passphrase)
os_memcpy((char *)¶ms.passphrase, wpa_s->conf->ago_passphrase,
strlen(wpa_s->conf->ago_passphrase));
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1);
if (wpa_s == NULL)
return -1;
@@ -8112,8 +8056,7 @@
wpa_printf(MSG_ERROR, "P2P: Own oper channel update "
"failed: %d", ret);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined (CONFIG_BRCM_RSDB)
+#if defined(CONFIG_BRCM_RSDB)
if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_FREQ_2G_5G) {
wpa_s->global->p2p_pref_freq_5g = wpa_s->conf->p2p_pref_freq_5g;
wpa_s->global->p2p_pref_freq_2g = wpa_s->conf->p2p_pref_freq_2g;
@@ -8124,7 +8067,6 @@
}
}
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) {
if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan,
@@ -8141,13 +8083,11 @@
if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PASSPHRASE_LEN)
p2p_set_passphrase_len(p2p, wpa_s->conf->p2p_passphrase_len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AGO_PASSPHRASE
if (wpa_s->conf->changed_parameters & CFG_CHANGED_AGO_PASSPHRASE) {
wpa_printf(MSG_ERROR, "P2P: AGO passphrase has been changed");
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.h
index f98c619..be878ef 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/p2p_supplicant.h
@@ -41,7 +41,6 @@
const u8 *group_ssid, size_t group_ssid_len);
int wpas_p2p_handle_frequency_conflicts(struct wpa_supplicant *wpa_s,
int freq, struct wpa_ssid *ssid);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_BT_WIFI_HO
#define MAX_SSID_LEN 32
#define MAX_PASSPHRASE_LEN 63
@@ -68,7 +67,6 @@
int freq, int ht40,
const struct p2p_channels *channels);
#endif /* CONFIG_BRCM_BT_WIFI_HO */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group,
int freq, int vht_center_freq2, int ht40, int vht,
int max_oper_chwidth, int he, int edmg);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/preauth_test.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/preauth_test.c
index 998657c..de49948 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/preauth_test.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/preauth_test.c
@@ -313,11 +313,7 @@
return -1;
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (eloop_init(&wpa_s)) {
-#else
if (eloop_init()) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/rrm.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/rrm.c
index 31e0848..8ba3dd2 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/rrm.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/rrm.c
@@ -52,73 +52,6 @@
wpas_clear_beacon_rep_data(wpa_s);
}
-#ifndef CONFIG_DRIVER_NL80211_IFX
-/*
- * wpas_rrm_notify_neighbor_rep - Notify received neighbor report
- * @wpa_s: Pointer to wpa_supplicant
- * @neighbor_rep: Pointer to neighbor report elements
- */
-void wpas_rrm_notify_neighbor_rep(struct wpa_supplicant *wpa_s,
- struct wpabuf *neighbor_rep)
-{
- size_t len;
- const u8 *data;
-
- /*
- * Neighbor Report element (IEEE Std 802.11-2016: 9.4.2.37)
- * Element ID[1]
- * Length[1]
- * BSSID[6]
- * BSSID Information[4]
- * Operating Class[1]
- * Channel Number[1]
- * PHY Type[1]
- * Optional Subelements[variable]
- */
-#define NR_IE_MIN_LEN (ETH_ALEN + 4 + 1 + 1 + 1)
-
- if (wpabuf_len(neighbor_rep) == 0) {
- wpa_msg(wpa_s, MSG_INFO, RRM_EVENT_NEIGHBOR_REP_RXED
- "No neighbors of the associated AP");
- goto out;
- }
-
- data = wpabuf_head_u8(neighbor_rep);
- len = wpabuf_len(neighbor_rep);
-
- while (len >= 2 + NR_IE_MIN_LEN) {
- const u8 *nr;
- u8 nr_len = data[1];
- const u8 *pos = data, *end;
-
- if ((pos[0] != WLAN_EID_NEIGHBOR_REPORT) ||
- (nr_len < NR_IE_MIN_LEN) ||
- (2U + nr_len > len)) {
- wpa_dbg(wpa_s, MSG_DEBUG,
- "RRM: Invalid Neighbor Report element: "
- "id=%u len=%zu nr_len=%u",
- data[0], len, nr_len);
- goto out;
- }
-
- pos += 2;
- end = pos + nr_len;
- nr = pos;
-
- wpa_msg(wpa_s, MSG_INFO, RRM_EVENT_NEIGHBOR_REP_RXED
- "bssid=" MACSTR
- " info=0x%x op_class=%u chan=%u phy_type=%u",
- MAC2STR(nr), WPA_GET_LE32(nr + ETH_ALEN),
- nr[ETH_ALEN + 4], nr[ETH_ALEN + 5], nr[ETH_ALEN + 6]);
-
- data = end;
- len -= 2 + nr_len;
- }
-
-out:
- wpabuf_free(neighbor_rep);
-}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* wpas_rrm_process_neighbor_rep - Handle incoming neighbor report
@@ -135,19 +68,6 @@
if (report_len < 1)
return;
-#ifndef CONFIG_DRIVER_NL80211_IFX
- if (wpa_s->rrm.notify_neighbor_rep) {
- if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) {
- wpa_printf(MSG_DEBUG,
- "RRM: Discarding neighbor report with token "
- "%d (expected %d)", report[0],
- wpa_s->rrm.next_neighbor_rep_token - 1);
- return;
- }
-
- eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler,
- &wpa_s->rrm, NULL);
-#else /* CONFIG_DRIVER_NL80211_IFX */
if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) {
wpa_printf(MSG_DEBUG,
"RRM: Discarding neighbor report with token %d (expected %d)",
@@ -161,7 +81,6 @@
if (!wpa_s->rrm.notify_neighbor_rep) {
wpa_msg(wpa_s, MSG_INFO, "RRM: Unexpected neighbor report");
return;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
/* skipping the first byte, which is only an id (dialog token) */
@@ -174,24 +93,13 @@
wpa_dbg(wpa_s, MSG_DEBUG, "RRM: Notifying neighbor report (token = %d)",
report[0]);
-#ifndef CONFIG_DRIVER_NL80211_IFX
- if (wpa_s->rrm.notify_neighbor_rep) {
- wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx,
- neighbor_rep);
- wpa_s->rrm.notify_neighbor_rep = NULL;
- wpa_s->rrm.neighbor_rep_cb_ctx = NULL;
- } else
- wpas_rrm_notify_neighbor_rep(wpa_s, neighbor_rep);
-#else /* CONFIG_DRIVER_NL80211_IFX */
wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx,
neighbor_rep);
wpa_s->rrm.notify_neighbor_rep = NULL;
wpa_s->rrm.neighbor_rep_cb_ctx = NULL;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
#if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS)
-/* Workaround different, undefined for Windows, error codes used here */
#ifndef ENOTCONN
#define ENOTCONN -1
#endif
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/scan.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/scan.c
index 1e35519..a551ebb 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/scan.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/scan.c
@@ -987,7 +987,6 @@
}
#ifdef CONFIG_P2P
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
if (wpa_s->global->p2p_go_found_external_scan &&
(wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT) &&
@@ -1000,7 +999,6 @@
}
}
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if ((wpa_s->p2p_in_provisioning || wpa_s->show_group_started) &&
wpa_s->go_params && !wpa_s->conf->passive_scan) {
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/sme.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/sme.c
index f3cf6c3..d926b77 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/sme.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/sme.c
@@ -1170,14 +1170,12 @@
wpa_s->sme.sae.state = SAE_NOTHING;
wpa_s->sme.sae.send_confirm = 0;
wpa_s->sme.sae_group_index = 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef WL_SAE
if ((is_zero_ether_addr(wpa_s->pending_bssid) &&
wpa_s->wpa_state == WPA_COMPLETED)) {
os_memcpy(&wpa_s->pending_bssid, data->external_auth.bssid, ETH_ALEN);
}
#endif /* WL_SAE */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (sme_handle_external_auth_start(wpa_s, data) < 0)
sme_send_external_auth_status(wpa_s,
WLAN_STATUS_UNSPECIFIED_FAILURE);
@@ -2279,11 +2277,6 @@
void sme_disassoc_while_authenticating(struct wpa_supplicant *wpa_s,
const u8 *prev_pending_bssid)
{
- /*
- * mac80211-workaround to force deauth on failed auth cmd,
- * requires us to remain in authenticating state to allow the
- * second authentication attempt to be continued properly.
- */
wpa_dbg(wpa_s, MSG_DEBUG, "SME: Allow pending authentication "
"to proceed after disconnection event");
wpa_supplicant_set_state(wpa_s, WPA_AUTHENTICATING);
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_cli.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_cli.c
index c5252a6..8f89c78 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_cli.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_cli.c
@@ -78,14 +78,12 @@
static void update_stations(struct wpa_ctrl *ctrl);
static void update_ifnames(struct wpa_ctrl *ctrl);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_BRCM_AUTOMOTIVE) && defined(CONFIG_P2P)
static int wpa_cli_cmd_set_interworking_ie(struct wpa_ctrl *ctrl, int argc,
char *argv[]);
static int wpa_cli_cmd_p2p_iface_reset(struct wpa_ctrl *ctrl, int argc,
char *argv[]);
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void usage(void)
{
@@ -229,12 +227,8 @@
static void wpa_cli_msg_cb(char *msg, size_t len)
{
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* For Debugging purpose */
printf("%s %zu\n", msg, len);
-#else
- printf("%s\n", msg);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
@@ -608,11 +602,9 @@
"p2p_search_delay", "mac_addr", "rand_addr_lifetime",
"preassoc_mac_addr", "key_mgmt_offload", "passive_scan",
"reassoc_same_bss_optim", "extended_key_id"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_RSDB
"p2p_pref_freq_5g","p2p_pref_freq_2g",
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
int i, num_fields = ARRAY_SIZE(fields);
@@ -2711,7 +2703,6 @@
}
#endif /* CONFIG_INTERWORKING */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
static int wpa_cli_cmd_set_interworking_ie(struct wpa_ctrl *ctrl, int argc,
char *argv[])
@@ -2787,7 +2778,6 @@
return wpa_ctrl_command(ctrl, cmd);
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_HS20
@@ -2985,21 +2975,12 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined ANDROID || defined(BCM_LINUX_BUILD)
static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
{
return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
}
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
-static int wpa_cli_cmd_driver(struct wpa_ctrl *ctrl, int argc, char *argv[])
-{
- return wpa_cli_cmd(ctrl, "DRIVER", 1, argc, argv);
-}
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpa_cli_cmd_vendor(struct wpa_ctrl *ctrl, int argc, char *argv[])
@@ -3726,13 +3707,11 @@
{ "p2p_remove_client", wpa_cli_cmd_p2p_remove_client,
wpa_cli_complete_p2p_peer, cli_cmd_flag_none,
"<address|iface=address> = remove a peer from all groups" },
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
{ "p2p_iface_reset", wpa_cli_cmd_p2p_iface_reset, NULL,
cli_cmd_flag_none,
"reset p2p group index" },
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_P2P */
{ "vendor_elem_add", wpa_cli_cmd_vendor_elem_add, NULL,
cli_cmd_flag_none,
@@ -3746,7 +3725,6 @@
cli_cmd_flag_none,
"<frame id> <hexdump of elem(s)> = remove vendor specific IE(s) in frame(s)\n"
VENDOR_ELEM_FRAME_ID },
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
{ "get_psk", wpa_cli_cmd_get_psk,
NULL, cli_cmd_flag_none,
@@ -3755,7 +3733,6 @@
NULL, cli_cmd_flag_none,
"get ssid of currently active p2p group/softAP" },
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifdef CONFIG_WIFI_DISPLAY
{ "wfd_subelem_set", wpa_cli_cmd_wfd_subelem_set, NULL,
cli_cmd_flag_none,
@@ -3846,13 +3823,11 @@
{ "signal_monitor", wpa_cli_cmd_signal_monitor, NULL,
cli_cmd_flag_none,
"= set signal monitor parameters" },
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
{ "interworking_ie", wpa_cli_cmd_set_interworking_ie, NULL,
cli_cmd_flag_none,
"<interworking_ie><add/del> <elements>" },
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
{ "pktcnt_poll", wpa_cli_cmd_pktcnt_poll, NULL,
cli_cmd_flag_none,
"= get TX/RX packet counters" },
@@ -3875,17 +3850,10 @@
"<params..> = Sent unprocessed command" },
{ "flush", wpa_cli_cmd_flush, NULL, cli_cmd_flag_none,
"= flush wpa_supplicant state" },
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined ANDROID || defined(BCM_LINUX_BUILD)
{ "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
"<command> = driver private commands" },
#endif /* ANDROID || BCM_LINUX_BUILD */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#ifdef ANDROID
- { "driver", wpa_cli_cmd_driver, NULL, cli_cmd_flag_none,
- "<command> = driver private commands" },
-#endif /* ANDROID */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
{ "radio_work", wpa_cli_cmd_radio_work, NULL, cli_cmd_flag_none,
"= radio_work <show/add/done>" },
{ "vendor", wpa_cli_cmd_vendor, NULL, cli_cmd_flag_none,
@@ -5000,11 +4968,7 @@
if (interactive)
printf("%s\n\n%s\n\n", wpa_cli_version, cli_license);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (eloop_init(NULL))
-#else
if (eloop_init())
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
return -1;
if (global && wpa_cli_open_global_ctrl() < 0)
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_priv.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_priv.c
index c7249cc..c5d7168 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_priv.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_priv.c
@@ -1250,11 +1250,7 @@
wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (eloop_init(NULL)) {
-#else
if (eloop_init()) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
goto out2;
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant.c
index ea82294..97b27ba 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant.c
@@ -57,43 +57,26 @@
#include "autoscan.h"
#include "bss.h"
#include "scan.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "wapi/wapi_asue_i.h"
-#include "wapi/wapi_interface.h"
-#include "wapi/wapi_config.h"
-#ifdef ANDROID
-#include "keystore_get.h"
-#endif /* ANDROID */
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "offchannel.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
#include "rsn_supp/wpa_i.h"
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "hs20_supplicant.h"
#include "wnm_sta.h"
#include "wpas_kay.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#define KEYSTORE_MESSAGE_SIZE 65535
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "mesh.h"
+#ifdef CONFIG_DPP
#include "dpp_supplicant.h"
+#endif /* CONFIG_DPP */
#ifdef CONFIG_MESH
#include "ap/ap_config.h"
#include "ap/hostapd.h"
#endif /* CONFIG_MESH */
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Support STA+GC on DBDC, SBSC and not on SBDC. */
#define P2P 1
#define NON_P2P 0
#define TIE_BREAKER P2P
-#endif /* CONFIG_DRIVER_NL80211_IFX */
const char *const wpa_supplicant_version =
"wpa_supplicant v" VERSION_STR "\n"
"Copyright (c) 2003-2019, Jouni Malinen <j@w1.fi> and contributors";
@@ -253,13 +236,11 @@
wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
wpa_s->reassociate = 1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_8_1
/* android commit:38e96765 wpa_supplicant(hidl):
* Implement auth timeout callback */
wpas_notify_auth_timeout(wpa_s);
#endif /* ABOVE_8_1 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* If we timed out, the AP or the local radio may be busy.
* So, wait a second until scanning again.
@@ -556,14 +537,6 @@
eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
l2_packet_deinit(wpa_s->l2);
wpa_s->l2 = NULL;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- l2_packet_deinit(wpa_s->l2_wapi);
- wpa_s->l2_wapi = NULL;
- os_free(wpa_s->wapi_scan_res);
- wpa_s->wapi_scan_res = NULL;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_s->l2_br) {
l2_packet_deinit(wpa_s->l2_br);
wpa_s->l2_br = NULL;
@@ -807,73 +780,6 @@
wpa_s->keys_cleared = (u32) -1;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-int wpa_state_to_wapi_state(enum wpa_states wpa_state)
-{
- wpa_printf(MSG_DEBUG, "%s wpa_state : %d change to wapi_state",__FUNCTION__ ,wpa_state);
- switch (wpa_state)
- {
- case WPA_DISCONNECTED:
- return WAPI_DISCONNECTED;
- case WPA_INACTIVE:
- return WAPI_INACTIVE;
- case WPA_SCANNING:
- return WAPI_SCANNING;
- case WPA_ASSOCIATING:
- return WAPI_ASSOCIATING;
- case WPA_ASSOCIATED:
- return WAPI_ASSOCIATED;
- case WPA_COMPLETED:
- return WAPI_COMPLETED;
- case WPA_INTERFACE_DISABLED:
- return WAPI_UNDEFINED_1;
- case WPA_AUTHENTICATING:
- return WAPI_UNDEFINED_2;
- default:
- return -1;
- }
- return -1;
-}
-
-int wapi_state_to_wpa_state(int wapi_state)
-{
- switch (wapi_state) {
- case WAPI_DISCONNECTED:
- return WPA_DISCONNECTED;
- case WAPI_INACTIVE:
- return WPA_INACTIVE;
- case WAPI_SCANNING:
- return WPA_SCANNING;
- case WAPI_ASSOCIATING:
- return WPA_ASSOCIATING;
- case WAPI_ASSOCIATED:
- return WPA_ASSOCIATED;
- case WAPI_AUTHENICATING:
- return WAPI_SPECIFIC;
- case WAPI_CERT_HANDSHAKE:
- return WAPI_SPECIFIC;
- case WAPI_3WAY_HANDSHAKE:
- return WPA_4WAY_HANDSHAKE;
- case WAPI_3WAYING:
- return WAPI_SPECIFIC;
- case WAPI_GROUP_HANDSHAKE:
- return WPA_GROUP_HANDSHAKE;
- case WAPI_GROUPING:
- return WAPI_SPECIFIC;
- case WAPI_COMPLETED:
- return WPA_COMPLETED;
- case WAPI_UNDEFINED_1:
- return WPA_INTERFACE_DISABLED;
- case WAPI_UNDEFINED_2:
- return WPA_AUTHENTICATING;
- default:
- return -1;
- }
- return -1;
-}
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/**
* wpa_supplicant_state_txt - Get the connection state name as a text string
@@ -1095,7 +1001,6 @@
wpa_s->consecutive_conn_failures = 0;
wpa_s->new_connection = 0;
wpa_drv_set_operstate(wpa_s, 1);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef BRCM_OKC
if (wpa_s->current_ssid &&
wpa_s->current_ssid->proactive_key_caching == 1) {
@@ -1125,7 +1030,6 @@
}
}
#endif /* BRCM_OKC */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifndef IEEE8021X_EAPOL
wpa_drv_set_supp_port(wpa_s, 1);
#endif /* IEEE8021X_EAPOL */
@@ -1167,12 +1071,6 @@
if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
wpa_supplicant_start_autoscan(wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- wpa_s->wapi_state = wpa_state_to_wapi_state(wpa_s->wpa_state);
- wpa_printf(MSG_DEBUG, "%s wapi_state : %d\n",__FUNCTION__ ,wpa_s->wapi_state);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
wmm_ac_notify_disassoc(wpa_s);
@@ -1621,17 +1519,11 @@
sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE);
#endif /* CONFIG_SAE */
#ifdef CONFIG_IEEE80211R
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifndef BRCM_VE
if (!(wpa_s->drv_flags & (WPA_DRIVER_FLAGS_SME |
WPA_DRIVER_FLAGS_UPDATE_FT_IES)))
sel &= ~WPA_KEY_MGMT_FT;
#endif /* BRCM_VE */
-#else
- if (!(wpa_s->drv_flags & (WPA_DRIVER_FLAGS_SME |
- WPA_DRIVER_FLAGS_UPDATE_FT_IES)))
- sel &= ~WPA_KEY_MGMT_FT;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_IEEE80211R */
wpa_dbg(wpa_s, MSG_DEBUG,
"WPA: AP key_mgmt 0x%x network profile key_mgmt 0x%x; available key_mgmt 0x%x",
@@ -2100,366 +1992,6 @@
return 2 + len;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-int wapi_merge_cert_files(char *wapi_as_cert, char *wapi_user_cert, char *cert_name)
-{
- char strBeginCert[] = "-----BEGIN CERTIFICATE-----";
- char strEndCert[] = "-----END CERTIFICATE-----";
- char strBeginASCert[] = "-----BEGIN ASU CERTIFICATE-----";
- char strEndASCert[] = "-----END ASU CERTIFICATE-----";
- char strBeginUserCert[] = "-----BEGIN USER CERTIFICATE-----";
- char strEndUserCert[] = "-----END USER CERTIFICATE-----";
- FILE *fpSrc;
- FILE *fpDesc;
- char line[512];
- int iSearchBegin = 1;
-#ifdef ANDROID
- int keystore = 0, length;
- char *pCert, *pBegin, *pEnd;
-#if defined(JB_MR2) || defined(KK)
- uint8_t *value = NULL;
-
- if (wapi_as_cert && strncmp("keystore://", wapi_as_cert, 11) == 0) {
- value = NULL;
- if ((length = keystore_get(&wapi_as_cert[11], strlen(wapi_as_cert)-11, &value)) == -1) {
- wpa_printf(MSG_ERROR, "%s: Could not open %s\n", __FUNCTION__, wapi_as_cert);
- goto err;
- }
- keystore = 1;
- } else
-#else
- char value[KEYSTORE_MESSAGE_SIZE];
-
- if (wapi_as_cert && strncmp("keystore://", wapi_as_cert, 11) == 0) {
- memset(value, 0, KEYSTORE_MESSAGE_SIZE);
- if ((length = keystore_get(&wapi_as_cert[11], strlen(wapi_as_cert)-11, (uint8_t**)&value)) == -1) {
- wpa_printf(MSG_ERROR, "%s: Could not open %s\n", __FUNCTION__, wapi_as_cert);
- goto err;
- }
- keystore = 1;
- } else
-#endif /* JB_MR2 || KK */
-#endif /* ANDROID */
- if ((fpSrc = fopen(wapi_as_cert, "r")) == NULL) {
- wpa_printf(MSG_ERROR, "%s: Could not open %s\n", __FUNCTION__, wapi_as_cert);
- goto err;
- }
-
- if ((fpDesc = fopen(cert_name, "w")) == NULL) {
- wpa_printf(MSG_ERROR, "%s: Could not open %s\n", __FUNCTION__, cert_name);
-#ifdef ANDROID
- if (!keystore)
-#endif /* ANDROID */
- fclose(fpSrc);
- goto err;
- }
-
-#ifdef ANDROID
- if (keystore) {
- pCert = (char *)value;
- pBegin = strstr(pCert, strBeginCert);
- if (pBegin) {
- if (pBegin > pCert) {
- fwrite(pCert, 1, pBegin - pCert, fpDesc);
- pCert = pBegin;
- length -= (pBegin - pCert);
- }
- fwrite(strBeginASCert, 1, strlen(strBeginASCert), fpDesc);
- pCert += strlen(strBeginCert);
- length -= strlen(strBeginCert);
- } else {
- wpa_printf(MSG_ERROR, "%s: Could not find begin in %s\n", __FUNCTION__, wapi_as_cert);
- }
- pEnd = strstr(pCert, strEndCert);
- if (pEnd) {
- if (pEnd > pCert) {
- fwrite(pCert, 1, pEnd - pCert, fpDesc);
- pCert = pEnd;
- length -= (pEnd - pCert);
- }
- fwrite(strEndASCert, 1, strlen(strEndASCert), fpDesc);
- pCert += strlen(strEndCert);
- length -= strlen(strEndCert);
- } else {
- wpa_printf(MSG_ERROR, "%s: Could not find end in %s\n", __FUNCTION__, wapi_as_cert);
- }
- if (length > 0) {
- fwrite(pCert, 1, length, fpDesc);
- }
- } else
-#endif /* ANDROID */
- /* copy the AS file */
- while ((fgets(line, sizeof(line), fpSrc)) != NULL) {
- if (iSearchBegin == 1) {
- if (strstr(line, strBeginCert) != 0){
- fputs(strBeginASCert, fpDesc);
- iSearchBegin = 0;
- }
- } else {
- if (strstr(line, strEndCert) != 0) {
- fputs(strEndASCert, fpDesc);
- } else {
- fputs(line, fpDesc);
- }
- }
- }
-
-#ifdef ANDROID
-#if defined(JB_MR2) || defined(KK)
- if (NULL != value)
- free(value);
-#endif /* JB_MR2 || KK */
- if (!keystore)
-#endif /* ANDROID */
- fclose(fpSrc);
-
- /* open the user file */
- iSearchBegin = 1;
-
-#ifdef ANDROID
- keystore = 0;
-
- if (wapi_user_cert && strncmp("keystore://", wapi_user_cert, 11) == 0) {
-#if defined(JB_MR2) || defined(KK)
- value = NULL;
- if ((length = keystore_get(&wapi_user_cert[11], strlen(wapi_user_cert)-11, &value)) == -1) {
-#else
- memset(value, 0, KEYSTORE_MESSAGE_SIZE);
- if ((length = keystore_get(&wapi_user_cert[11], strlen(wapi_user_cert)-11, (uint8_t**)&value)) == -1) {
-#endif /* JB_MR2 || KK */
- wpa_printf(MSG_ERROR, "%s: Could not open %s\n", __FUNCTION__, wapi_user_cert);
- fclose(fpDesc);
- goto err;
- }
- keystore = 1;
- } else
-#endif /* ANDROID */
- if ((fpSrc = fopen(wapi_user_cert, "r")) == NULL) {
- wpa_printf(MSG_ERROR, "%s: Could not open %s\n", __FUNCTION__, wapi_user_cert);
- fclose(fpDesc);
- goto err;
- }
-
-#ifdef ANDROID
- if (keystore) {
- pCert = (char *)value;
- pBegin = strstr(pCert, strBeginCert);
- if (pBegin) {
- if (pBegin > pCert) {
- fwrite(pCert, 1, pBegin - pCert, fpDesc);
- pCert = pBegin;
- length -= (pBegin - pCert);
- }
- fwrite(strBeginUserCert, 1, strlen(strBeginUserCert), fpDesc);
- pCert += strlen(strBeginCert);
- length -= strlen(strBeginCert);
- } else {
- wpa_printf(MSG_ERROR, "%s: Could not find begin in %s\n", __FUNCTION__, wapi_user_cert);
- }
- pEnd = strstr(pCert, strEndCert);
- if (pEnd) {
- if (pEnd > pCert) {
- fwrite(pCert, 1, pEnd - pCert, fpDesc);
- pCert = pEnd;
- length -= (pEnd - pCert);
- }
- fwrite(strEndUserCert, 1, strlen(strEndUserCert), fpDesc);
- pCert += strlen(strEndCert);
- length -= strlen(strEndCert);
- } else {
- wpa_printf(MSG_ERROR, "%s: Could not find end in %s\n", __FUNCTION__, wapi_user_cert);
- }
- if (length > 0) {
- fwrite(pCert, 1, length, fpDesc);
- }
- } else
-#endif /* ANDROID */
- /* copy the user file */
- while ((fgets(line, sizeof(line), fpSrc)) != NULL) {
- if (iSearchBegin == 1) {
- if (strstr(line, strBeginCert) != 0){
- fputs(strBeginUserCert, fpDesc);
- iSearchBegin = 0;
- }
- } else {
- if (strstr(line, strEndCert) != 0){
- fputs(strEndUserCert, fpDesc);
- } else {
- fputs(line, fpDesc);
- }
- }
- }
-
- fflush(fpDesc);
-
-#ifdef ANDROID
- if (!keystore)
-#endif /* ANDROID */
- fclose(fpSrc);
- fclose(fpDesc);
- return 0;
-
-err:
-#ifdef ANDROID
-#if defined(JB_MR2) || defined(KK)
- if (NULL != value)
- free(value);
-#endif /* JB_MR2 || KK */
-#endif /* ANDROID */
- return -1;
-}
-
-/* initialize the wapi_config structure from a wpa_ssid structure */
-struct wapi_config * wapi_config_init(struct wpa_ssid *ssid, struct wpa_supplicant *wpa_s)
-{
- struct wapi_config *config = NULL;
- CNTAP_PARA lib_param;
- u8 psk_type = 0;
- struct wpa_global *eloop = (struct wpa_global *)eloop_get_user_data();
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef CONFIG_BRCM_AUTOMOTIVE
- int check_ssid;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
-
- wpa_printf(MSG_DEBUG, "wapi_config_init: Enter\n");
- if(eloop->ifaces != NULL)
- wpa_printf(MSG_DEBUG, "eloop->iface: %p\n",eloop->ifaces);
- //if(eloop->ifaces->next != NULL) {
- // eloop->ifaces = eloop->ifaces->next;
- // wpa_printf(MSG_DEBUG, "eloop->iface->next: %p\n",eloop->ifaces);
- // }
- wpa_printf(MSG_DEBUG, "Entering %s...", __FUNCTION__);
-
- config = os_malloc(sizeof(*config));
- if (config == NULL)
- return NULL;
-
- os_memset(config, 0, sizeof(*config));
-
- /* Get Authentication and Key Management Suites */
- config->wapi_policy = ssid->wapi;
-
- wpa_printf(MSG_DEBUG, "wapi_policy '%d'", config->wapi_policy);
-
- if (config->wapi_policy & 0x08)
- {
- wpa_printf(MSG_DEBUG, " AUTH_TYPE_WAPI");
- lib_param.authType = AUTH_TYPE_WAPI;
- } else if (config->wapi_policy & 0x04)
- {
- wpa_printf(MSG_DEBUG, " AUTH_TYPE_WAPI_PSK");
- lib_param.authType = AUTH_TYPE_WAPI_PSK;
- } else {
- wpa_printf(MSG_DEBUG, " AUTH_TYPE_NONE_WAPI");
- lib_param.authType = AUTH_TYPE_NONE_WAPI;
- }
-
- if (config->wapi_policy != 0)
- {
- config->group_cipher = WAPI_CIPHER_SMS4;
- config->pairwise_cipher = WAPI_CIPHER_SMS4;
- }
-
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_BRCM_AUTOMOTIVE)
- if (ssid->bssid_set && ssid->ssid_len == 0)
- check_ssid = 0;
- else
- check_ssid = 1;
-
- if (check_ssid) {
- config->ssid_len = ssid->ssid_len;
- config->ssid = (u8 *)os_strdup((const char *)ssid->ssid);
- }
-#else
- config->ssid_len = ssid->ssid_len;
- config->ssid = (u8 *)os_strdup((const char *)ssid->ssid);
-#endif /* CONFIG_DRIVER_NL80211_IFX && CONFIG_BRCM_AUTOMOTIVE */
-
- wpa_hexdump_ascii(MSG_DEBUG, " SSID:", config->ssid, config->ssid_len);
- wpa_printf(MSG_DEBUG, "SSID '%s'", config->ssid);
-
- eloop->cert_info.config.used_cert = ssid->cert_index; /* 1:x509 2:GBW */
- wpa_printf(MSG_DEBUG, "cert_index %d", eloop->cert_info.config.used_cert);
- wpa_printf(MSG_DEBUG, "ssid->cert_index=%d", ssid->cert_index);
- wpa_printf(MSG_DEBUG, "ssid->wapi_as_cert=%s", ssid->wapi_as_cert);
- wpa_printf(MSG_DEBUG, "ssid->wapi_user_cert=%s", ssid->wapi_user_cert);
-
- if (config->wapi_policy & 0x08) {
- if ((ssid->wapi_as_cert) && (ssid->wapi_user_cert))
- {
- wpa_printf(MSG_DEBUG, "ssid->wapi_as_cert=%s", ssid->wapi_as_cert);
- wpa_printf(MSG_DEBUG, "ssid->wapi_user_cert=%s", ssid->wapi_user_cert);
-
- wpa_printf(MSG_DEBUG, "%s: the final mixed cert filename = %s\n",
- __FUNCTION__, ssid->cert_name);
- if (wapi_merge_cert_files(ssid->wapi_as_cert, ssid->wapi_user_cert, ssid->cert_name)) {
- wpa_printf(MSG_ERROR, "%s: wapi_merge_cert_files() failed, exit...\n", __FUNCTION__);
- wapi_config_free(config);
- return NULL;
- }
-
- /* merge the as.cer with user.cer to make a mixed.cer */
- strcpy(eloop->cert_info.config.cert_name, ssid->cert_name);
- wpa_printf(MSG_DEBUG, "CERT_NAME '%s'", eloop->cert_info.config.cert_name);
- change_cert_format(eloop->cert_info.config.cert_name,
- lib_param.para.user, 2048,
- lib_param.para.as, 2048);
- }
- else {
- wpa_printf(MSG_ERROR, "wapi cert files not present");
- wapi_config_free(config);
- return NULL;
- }
- }
-
- if (config->wapi_policy & WAPI_KEY_MGMT_PSK)
- { /* bit 2:PSK */
- psk_type = ssid->psk_key_type;
- wpa_printf(MSG_DEBUG, "%s: PSK_KEY_TYPE '%d'", __FUNCTION__, psk_type);
- wpa_printf(MSG_DEBUG, "%s: psk (%d)", __FUNCTION__, ssid->psk_set);
- wpa_printf(MSG_DEBUG, "%s: PSK'%s'", __FUNCTION__, ssid->psk);
- wpa_printf(MSG_DEBUG, "%s: passphrase'%s'", __FUNCTION__, ssid->passphrase);
-
- lib_param.para.kt = psk_type;
- if (ssid->passphrase != NULL) {
- wpa_printf(MSG_DEBUG, "%s: ssid->passphrase != NULL, use ssid->passphrase:%s\n",
- __FUNCTION__, ssid->passphrase);
- lib_param.para.kl = strlen(ssid->passphrase);
- memcpy(lib_param.para.kv, ssid->passphrase, lib_param.para.kl);
- }
- else if (ssid->psk_set) {
- wpa_printf(MSG_DEBUG, "%s: ssid->passphrase == NULL, use ssid->psk: %s\n",
- __FUNCTION__, ssid->psk);
- lib_param.para.kl = os_strlen((const char *)ssid->psk);
-
- memcpy(lib_param.para.kv, ssid->psk, lib_param.para.kl);
- } else {
- wpa_printf(MSG_ERROR, "%s: passphrase and psk both NULL. Skip assoc.\n",
- __FUNCTION__);
- wapi_config_free(config);
- return NULL;
- }
- }
-
- /* do it after the wpa_s has been attached to global */
- if (WAI_CNTAPPARA_SET(&lib_param, wpa_s->ifname) != 0) {
- wpa_printf(MSG_DEBUG, "%s: WAI_CNTAPPARA_SET error\n", __FUNCTION__);
- wapi_config_free(config);
- if ((config->wapi_policy & 0x08) &&
- (ssid->wapi_as_cert) &&
- (ssid->wapi_user_cert)) {
- wpa_msg(eloop->ifaces, MSG_INFO, "WAPI: certificate initialization failed");
- }
- return NULL;
- }
-
- wpa_printf(MSG_DEBUG, "%s: leave\n", __FUNCTION__);
- return config;
-}
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
struct wpa_bss *test_bss)
@@ -2584,7 +2116,6 @@
return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Support STA+GC on DBDC, SBSC and not on SBDC. */
int sta_p2p_check(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,struct wpa_ssid *ssid)
{
@@ -2697,7 +2228,6 @@
}
return 1;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
static void wpa_s_setup_sae_pt(struct wpa_config *conf, struct wpa_ssid *ssid)
{
@@ -2773,13 +2303,11 @@
wpa_s->own_disconnect_req = 0;
wpa_s->own_reconnect_req = 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Support STA+GC on DBDC, SBSC and not on SBDC. */
if(wpa_s->global->rsdb_flag == 1) {
if(sta_p2p_check(wpa_s,bss,ssid) == -1)
return;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* If we are starting a new connection, any previously pending EAPOL
* RX cannot be valid anymore.
@@ -4077,13 +3605,6 @@
static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
{
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- static u8 ssid_buf[SSID_MAX_LEN+1];
- u8 *wapi_ie;
- u8 wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wpa_connect_work *cwork = work->ctx;
struct wpa_bss *bss = cwork->bss;
struct wpa_ssid *ssid = cwork->ssid;
@@ -4180,133 +3701,6 @@
wpa_supplicant_cancel_sched_scan(wpa_s);
wpa_supplicant_cancel_scan(wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- if ( (ssid->wapi) || (ssid->proto & WPA_PROTO_WAPI) || (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_PSK ) ||
- (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_CERT)) {
- /* associating to a WAPI network */
- wpa_printf(MSG_DEBUG, "[WAPI] ssid->wapi %d "
- "ssid->proto %d ssid->key_mgmt %d \n",
- ssid->wapi, ssid->proto, ssid->key_mgmt);
-
- if (ssid->wapi == 0) {
- if (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_PSK) {
- ssid->wapi = 7;
- }
- else if (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_CERT) {
- ssid->wapi = 11;
- }
- else {
- wpa_printf(MSG_ERROR, "[WAPI] Unknown key mgmt type. Abort assoc.");
- wpas_connect_work_done(wpa_s);
- return;
- }
- }
- if (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_PSK) {
- params.key_mgmt_suite = WPA_KEY_MGMT_WAPI_PSK;
- } else if (ssid->key_mgmt == WPA_KEY_MGMT_WAPI_CERT) {
- params.key_mgmt_suite = WPA_KEY_MGMT_WAPI_CERT;
- } else {
- params.key_mgmt_suite = WPA_KEY_MGMT_NONE;
- }
-
- wpa_s->wapi_conf = wapi_config_init(ssid, wpa_s);
- if (wpa_s->wapi_conf == NULL) {
- wpa_printf(MSG_ERROR, "[WAPI] Initialize wapi_conf failed. Abort assoc.\n");
- wpas_connect_work_done(wpa_s);
- return;
- }
- if (bss) {
- u8 *ie = (u8 *)wpa_bss_get_ie(bss, WLAN_EID_SSID);
- if(ie) {
- wpa_printf(MSG_DEBUG, "[WAPI] WLAN_EID_SSID Get ie: "
- "[%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x]\n",
- ie[0], ie[1], ie[2], ie[3], ie[4],
- ie[5], ie[6], ie[7], ie[8], ie[9] );
-
- wpa_printf(MSG_DEBUG, "[WAPI] bss ie[1]=%d\n", ie[1]);
- params.bssid = bss->bssid;
- params.ssid = ssid_buf;
-
- if ( ie[1] > SSID_MAX_LEN ) {
- wpa_printf(MSG_ERROR, "[WAPI] ssid length is over %d, strip it!", SSID_MAX_LEN);
- }
-
- snprintf((char *) params.ssid,
- ((ie[1]>SSID_MAX_LEN)? SSID_MAX_LEN:ie[1])+1, "%s",
- ie ? wpa_ssid_txt(ie + 2, ie[1]) : "");
-
-
- params.ssid_len = os_strlen((const char *)params.ssid);
-
- params.freq.freq= bss->freq;
- wpa_printf(MSG_DEBUG, "[WAPI] params.ssid=%s\n", params.ssid);
- wpa_printf(MSG_DEBUG, "[WAPI] params.bssid=%s\n", params.bssid);
- wpa_printf(MSG_DEBUG, "[WAPI] params.key_mgmt=0x%x\n", params.key_mgmt_suite);
- wpa_printf(MSG_DEBUG, "[WAPI] bss done\n");
- wpa_sm_set_ap_wapi_ie(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
- }
- }
- else {
- params.ssid = ssid->ssid;
- params.ssid_len = ssid->ssid_len;
- }
-
- if (ssid->mode == 1 && ssid->frequency > 0 && params.freq.freq == 0) {
- params.freq.freq = ssid->frequency; /* Initial channel for IBSS */
- }
- wpa_printf(MSG_DEBUG, "%s: params.freq=%d.\n", __FUNCTION__, params.freq.freq);
- params.mode = ssid->mode;
- wpa_printf(MSG_DEBUG, "%s: params.mode=%d...\n", __FUNCTION__, params.mode);
-
- if (bss) {
- wpa_s->ap_wapi_ie_len =bss->wapi_ie_len;
- if (bss->wapi_ie_len) {
- wpa_printf(MSG_DEBUG, "%s: bss->wapi_ie_len..\n", __FUNCTION__);
- memcpy(wpa_s->ap_wapi_ie, wpa_bss_get_ie(bss, WLAN_EID_WAPI), bss->wapi_ie_len);
- wpa_hexdump(MSG_DEBUG, "wpa_s->ap_wapi_ie", wpa_s->ap_wapi_ie, wpa_s->ap_wapi_ie_len);
- }
- }
-
- /* set wpa_s->assoc_wapi_ie and wpa_s->assoc_wapi_ie */
- params.wpa_ie_len = wpa_s->assoc_wapi_ie_len;
- wpa_printf(MSG_DEBUG, "%s: params.wpa_ie_len=%d\n",
- __FUNCTION__, (int)params.wpa_ie_len);
- /* to do: do I have to manually copy the contents into params.wpa_ie? */
- params.wpa_ie = wpa_s->assoc_wapi_ie;
-
- wpa_printf(MSG_DEBUG, "wapi_ie: [%02x][%02x][%02x][%02x]\n",
- params.wpa_ie[0], params.wpa_ie[1], params.wpa_ie[2], params.wpa_ie[3]);
-
- if(bss) {
- u8 *ap_wapi_ie = (u8 *)wpa_bss_get_ie(bss, WLAN_EID_WAPI);
- if(ap_wapi_ie) {
- params.ap_wapi_ie = ap_wapi_ie;
- params.ap_wapi_ie_len = ap_wapi_ie ? ap_wapi_ie[1] + 2: 0;
- wpa_printf(MSG_DEBUG, "%s: params.ap_wapi_ie_len = %zu\n", __FUNCTION__,
- params.ap_wapi_ie_len);
- wpa_printf(MSG_DEBUG, "%s: params.ap_wapi_ie_len: [%02x][%02x][%02x][%02x]\n",
- __FUNCTION__, params.ap_wapi_ie[0], params.ap_wapi_ie[1],
- params.ap_wapi_ie[2], params.ap_wapi_ie[3]);
- }
- }
- if (!memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN)) {
-
- /* Timeout for IEEE 802.11 authentication and association */
- wpa_supplicant_req_auth_timeout(wpa_s, 20, 0);
-
- wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
- if (wpa_drv_associate(wpa_s, ¶ms)) {
- wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
- wpa_printf(MSG_ERROR, "[WAPI] wpa_drv_associate() failed\n");
- }
- } else {
- wpa_printf(MSG_ERROR, "[WAPI] Skipping drv_associate call for wapi");
- }
- }
- else {
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* Starting new association, so clear the possibly used WPA IE from the
* previous association. */
@@ -4505,12 +3899,7 @@
(params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
-#ifndef CONFIG_DRIVER_NL80211_IFX
- params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192 ||
- params.key_mgmt_suite == WPA_KEY_MGMT_FT_IEEE8021X))
-#else /* CONFIG_DRIVER_NL80211_IFX */
params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192))
-#endif /* CONFIG_DRIVER_NL80211_IFX */
params.req_handshake_offload = 1;
if (wpa_s->conf->key_mgmt_offload) {
@@ -4668,7 +4057,7 @@
timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
} else if (wpa_s->conf->ap_scan == 1) {
/* give IBSS a bit more time */
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(CONFIG_SAE)
+#if defined(CONFIG_SAE)
timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 25;
#else
timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
@@ -4692,11 +4081,6 @@
*/
eapol_sm_invalidate_cached_session(wpa_s->eapol);
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
old_ssid = wpa_s->current_ssid;
wpa_s->current_ssid = ssid;
@@ -5667,12 +5051,7 @@
eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
return;
wpa_drv_poll(wpa_s);
-#ifndef CONFIG_DRIVER_NL80211_IFX
- if (!(wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
- (wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK)))
-#else /* CONFIG_DRIVER_NL80211_IFX */
if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK))
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
/*
@@ -5698,18 +5077,6 @@
if ((!wpa_s->p2p_mgmt ||
!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- wpa_printf(MSG_DEBUG, "%s : wpa_s->driver->send_eapol ",__FUNCTION__);
-
- l2_packet_deinit(wpa_s->l2_wapi);
- wpa_s->l2_wapi = l2_packet_init(wpa_s->ifname,
- wpa_drv_get_mac_addr(wpa_s),
- ETH_P_WAI,
- wapi_asue_rx_wai, wpa_s, 0);
- wpa_printf(MSG_DEBUG, "wpa_s->l2_wapi = %p ", wpa_s->l2_wapi);
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
l2_packet_deinit(wpa_s->l2);
wpa_s->l2 = l2_packet_init(wpa_s->ifname,
wpa_drv_get_mac_addr(wpa_s),
@@ -5717,11 +5084,7 @@
wpas_eapol_needs_l2_packet(wpa_s) ?
wpa_supplicant_rx_eapol : NULL,
wpa_s, 0);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (!(wpa_s->l2 && wpa_s->l2_wapi))
-#else
if (wpa_s->l2 == NULL)
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
return -1;
if (l2_packet_set_packet_filter(wpa_s->l2,
@@ -5734,42 +5097,11 @@
"Failed to get own L2 address");
return -1;
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- } else {
- const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
- if (addr)
- os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
- wpa_printf(MSG_DEBUG, "%s : wpa_s->driver->send_eapol ", __FUNCTION__);
-
- if (!wpa_s->p2p_mgmt) {
- l2_packet_deinit(wpa_s->l2_wapi);
- wpa_s->l2_wapi = l2_packet_init(wpa_s->ifname,
- wpa_drv_get_mac_addr(wpa_s),
- ETH_P_WAI,
- wapi_asue_rx_wai, wpa_s, 0);
- wpa_printf(MSG_DEBUG, "wpa_s->l2_wapi = %p ", wpa_s->l2_wapi);
-
- wpa_s->l2 = l2_packet_init(wpa_s->ifname,
- wpa_drv_get_mac_addr(wpa_s),
- ETH_P_EAPOL,
- wpa_supplicant_rx_eapol, wpa_s, 0);
- if ( !(wpa_s->l2 && wpa_s->l2_wapi) )
- return -1;
- }
- }
- if (wpa_s->l2_wapi && l2_packet_get_own_addr(wpa_s->l2_wapi, wpa_s->wapi_own_addr)) {
- wpa_printf(MSG_ERROR, "Failed to get own WAPI L2 address");
- return -1;
- }
- wpa_printf(MSG_ERROR, "Own WAPI MAC address: " MACSTR,
- MAC2STR(wpa_s->wapi_own_addr));
-#else
} else {
const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
if (addr)
os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
}
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
wpas_wps_update_mac_addr(wpa_s);
@@ -5963,12 +5295,6 @@
wpa_s->p2pdev = wpa_s->parent;
wpa_s->sched_scanning = 0;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- wpa_s->ap_wapi_ie_len = 0;
- wpa_s->assoc_wapi_ie_len = 0;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
dl_list_init(&wpa_s->bss_tmp_disallowed);
dl_list_init(&wpa_s->fils_hlp_req);
#ifdef CONFIG_TESTING_OPTIONS
@@ -7162,20 +6488,6 @@
wpa_s->confname = os_strdup(iface->confname);
#endif /* CONFIG_BACKEND_FILE */
wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- wpa_printf(MSG_ERROR, "interface %s\n",iface->ifname);
- if ((!strncmp(iface->ifname,"eth",3) || !strncmp(iface->ifname,"wlan",4))
- && !wpa_s->global->wapi_initialized) {
- wpa_s->global->wapi_initialized = 1;
- wpa_printf(MSG_ERROR, " WIFI_lib_init WIFI_lib_init WIFI_lib_init WIFI_lib_init \n");
- if (WIFI_lib_init()) {
- wpa_printf(MSG_ERROR, "##### Failed to initialize WAPI lib, exit #####\n");
- return -1;
- }
- }
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_s->conf == NULL) {
wpa_printf(MSG_ERROR, "Failed to read or parse "
"configuration '%s'.", wpa_s->confname);
@@ -7723,7 +7035,6 @@
return NULL;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Notify the control interfaces about new iface */
if (wpas_notify_iface_added(wpa_s)) {
wpa_supplicant_deinit_iface(wpa_s, 1, 0);
@@ -7736,28 +7047,14 @@
for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
wpas_notify_network_added(wpa_s, ssid);
}
-#else /* CONFIG_DRIVER_NL80211_IFX */
- if (iface->p2p_mgmt == 0) {
- /* Notify the control interfaces about new iface */
- if (wpas_notify_iface_added(wpa_s)) {
- wpa_supplicant_deinit_iface(wpa_s, 1, 0);
- return NULL;
- }
-
- for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
- wpas_notify_network_added(wpa_s, ssid);
- }
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_s->next = global->ifaces;
global->ifaces = wpa_s;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined CONFIG_BRCM_RSDB
wpa_s->conf->p2p_pref_freq_5g = global->p2p_pref_freq_5g;
wpa_s->conf->p2p_pref_freq_2g = global->p2p_pref_freq_2g;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
@@ -7799,12 +7096,6 @@
struct wpa_supplicant *parent = wpa_s->parent;
#endif /* CONFIG_MESH */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- if (wpa_s->key_mgmt == WPA_KEY_MGMT_WAPI_PSK)
- wapiap_lib_deinitialize(wpa_s->ifname);
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/* Remove interface from the global list of interfaces */
prev = global->ifaces;
if (prev == wpa_s) {
@@ -8026,11 +7317,7 @@
wpa_printf(MSG_DEBUG, "wpa_supplicant v%s", VERSION_STR);
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(WAPI)
- if (eloop_init(global)) {
-#else
if (eloop_init()) {
-#endif /* CONFIG_DRIVER_NL80211_IFX && WAPI */
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
wpa_supplicant_deinit(global);
return NULL;
@@ -8135,11 +7422,6 @@
#ifdef CONFIG_WIFI_DISPLAY
wifi_display_deinit(global);
#endif /* CONFIG_WIFI_DISPLAY */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- WIFI_lib_exit();
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
while (global->ifaces)
wpa_supplicant_remove_iface(global, global->ifaces, 1);
@@ -8322,7 +7604,6 @@
return;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef ABOVE_10
if (wpa_s->auto_reconnect_disabled) {
wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
@@ -8330,7 +7611,6 @@
return;
}
#endif /* ABOVE_10 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
/*
* Add the failed BSSID into the blacklist and speed up next scan
* attempt if there could be other APs that could accept association.
@@ -8440,8 +7720,8 @@
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW) || defined (CONFIG_CTRL_IFACE_HIDL)
+#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW) || \
+ defined(CONFIG_CTRL_IFACE_HIDL)
int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
struct wpa_ssid *ssid,
const char *field,
@@ -8572,104 +7852,6 @@
#endif /* IEEE8021X_EAPOL */
}
#endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW || CONFIG_CTRL_IFACE_HIDL */
-#else /* CONFIG_DRIVER_NL80211_IFX */
-#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
-int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
- struct wpa_ssid *ssid,
- const char *field,
- const char *value)
-{
-#ifdef IEEE8021X_EAPOL
- struct eap_peer_config *eap = &ssid->eap;
-
- wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
- wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
- (const u8 *) value, os_strlen(value));
-
- switch (wpa_supplicant_ctrl_req_from_string(field)) {
- case WPA_CTRL_REQ_EAP_IDENTITY:
- os_free(eap->identity);
- eap->identity = (u8 *) os_strdup(value);
- eap->identity_len = os_strlen(value);
- eap->pending_req_identity = 0;
- if (ssid == wpa_s->current_ssid)
- wpa_s->reassociate = 1;
- break;
- case WPA_CTRL_REQ_EAP_PASSWORD:
- bin_clear_free(eap->password, eap->password_len);
- eap->password = (u8 *) os_strdup(value);
- eap->password_len = os_strlen(value);
- eap->pending_req_password = 0;
- if (ssid == wpa_s->current_ssid)
- wpa_s->reassociate = 1;
- break;
- case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
- bin_clear_free(eap->new_password, eap->new_password_len);
- eap->new_password = (u8 *) os_strdup(value);
- eap->new_password_len = os_strlen(value);
- eap->pending_req_new_password = 0;
- if (ssid == wpa_s->current_ssid)
- wpa_s->reassociate = 1;
- break;
- case WPA_CTRL_REQ_EAP_PIN:
- str_clear_free(eap->cert.pin);
- eap->cert.pin = os_strdup(value);
- eap->pending_req_pin = 0;
- if (ssid == wpa_s->current_ssid)
- wpa_s->reassociate = 1;
- break;
- case WPA_CTRL_REQ_EAP_OTP:
- bin_clear_free(eap->otp, eap->otp_len);
- eap->otp = (u8 *) os_strdup(value);
- eap->otp_len = os_strlen(value);
- os_free(eap->pending_req_otp);
- eap->pending_req_otp = NULL;
- eap->pending_req_otp_len = 0;
- break;
- case WPA_CTRL_REQ_EAP_PASSPHRASE:
- str_clear_free(eap->cert.private_key_passwd);
- eap->cert.private_key_passwd = os_strdup(value);
- eap->pending_req_passphrase = 0;
- if (ssid == wpa_s->current_ssid)
- wpa_s->reassociate = 1;
- break;
- case WPA_CTRL_REQ_SIM:
- str_clear_free(eap->external_sim_resp);
- eap->external_sim_resp = os_strdup(value);
- eap->pending_req_sim = 0;
- break;
- case WPA_CTRL_REQ_PSK_PASSPHRASE:
- if (wpa_config_set(ssid, "psk", value, 0) < 0)
- return -1;
- ssid->mem_only_psk = 1;
- if (ssid->passphrase)
- wpa_config_update_psk(ssid);
- if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
- wpa_supplicant_req_scan(wpa_s, 0, 0);
- break;
- case WPA_CTRL_REQ_EXT_CERT_CHECK:
- if (eap->pending_ext_cert_check != PENDING_CHECK)
- return -1;
- if (os_strcmp(value, "good") == 0)
- eap->pending_ext_cert_check = EXT_CERT_CHECK_GOOD;
- else if (os_strcmp(value, "bad") == 0)
- eap->pending_ext_cert_check = EXT_CERT_CHECK_BAD;
- else
- return -1;
- break;
- default:
- wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
- return -1;
- }
-
- return 0;
-#else /* IEEE8021X_EAPOL */
- wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
- return -1;
-#endif /* IEEE8021X_EAPOL */
-}
-#endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
@@ -8986,7 +8168,6 @@
WPA_FREQ_USED_BY_P2P_CLIENT :
WPA_FREQ_USED_BY_INFRA_STATION;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Support STA+GC on DBDC and SBDC */
else if (ifs->current_ssid->mode == WPAS_MODE_AP) {
freqs_data[i].flags |= WPA_FREQ_USED_BY_SOFTAP;
@@ -8994,7 +8175,6 @@
else if (ifs->current_ssid->mode == WPAS_MODE_P2P_GO) {
freqs_data[i].flags |= WPA_FREQ_USED_BY_P2P_GO;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
}
dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
@@ -9384,7 +8564,6 @@
return scan_res;
}
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
void wpas_get_chwidth_params(struct wpa_supplicant *wpa_s, int *ht40, int *vht)
{
@@ -9407,4 +8586,3 @@
}
}
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_conf.mk b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_conf.mk
index 4d4aafc..4293976 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_conf.mk
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_conf.mk
@@ -18,7 +18,6 @@
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR)/etc/wifi
-
include $(BUILD_SYSTEM)/base_rules.mk
WPA_SUPPLICANT_CONF_TEMPLATE := $(LOCAL_PATH)/wpa_supplicant_template.conf
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_i.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_i.h
index 4c4f02f..4728c12 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_i.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpa_supplicant_i.h
@@ -5,11 +5,6 @@
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef BRCM_FEATURES_COPYRIGHT
-/* Copyright (c) 2012-2013, Broadcom Corporation */
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#ifndef WPA_SUPPLICANT_I_H
#define WPA_SUPPLICANT_I_H
@@ -20,12 +15,6 @@
#include "common/sae.h"
#include "common/wpa_ctrl.h"
#include "wps/wps_defs.h"
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
-#include "wapi_asue.h"
-#include "wapi_config.h"
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "config_ssid.h"
#include "wmm_ac.h"
@@ -39,13 +28,8 @@
extern const char *const wpa_supplicant_full_license5;
#endif /* CONFIG_NO_STDOUT_DEBUG */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if !defined(OREO) && !defined(PIE) && !defined(ABOVE_10)
-#ifdef WAPI
-struct wapi_asue_st *wpa_s;
#endif
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wpa_sm;
struct wpa_supplicant;
struct ibss_rsn;
@@ -299,20 +283,11 @@
struct wpa_params params;
struct ctrl_iface_global_priv *ctrl_iface;
struct wpas_dbus_priv *dbus;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_HIDL
struct wpas_hidl_priv *hidl;
#endif
-#else
- struct wpas_binder_priv *binder;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void **drv_priv;
size_t drv_count;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- struct _asue_cert_info cert_info;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct os_time suspend_time;
struct p2p_data *p2p;
struct wpa_supplicant *p2p_init_wpa_s;
@@ -323,11 +298,9 @@
struct dl_list p2p_srv_bonjour; /* struct p2p_srv_bonjour */
struct dl_list p2p_srv_upnp; /* struct p2p_srv_upnp */
int p2p_disabled;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined CONFIG_BRCM_RSDB
int p2p_pref_freq_5g, p2p_pref_freq_2g;
#endif /* CONFIG_BRCM_RSDB */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int cross_connection;
int p2p_long_listen; /* remaining time in long Listen state in ms */
struct wpa_freq_range_list p2p_disallow_freq;
@@ -342,11 +315,9 @@
unsigned int p2p_24ghz_social_channels:1;
unsigned int pending_p2ps_group:1;
unsigned int pending_group_iface_for_p2ps:1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
unsigned int p2p_go_found_external_scan:1;
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
unsigned int pending_p2ps_group_freq;
#ifdef CONFIG_WIFI_DISPLAY
@@ -356,13 +327,8 @@
#endif /* CONFIG_WIFI_DISPLAY */
struct psk_list_entry *add_psk; /* From group formation */
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- unsigned int wapi_initialized;
-#endif /* WAPI */
/* Support STA+GC on DBDC, SBSC and not on SBDC. */
int rsdb_flag;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
@@ -459,11 +425,9 @@
#define WPA_FREQ_USED_BY_INFRA_STATION BIT(0)
#define WPA_FREQ_USED_BY_P2P_CLIENT BIT(1)
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* Support STA+GC on DBDC, SBSC and not on SBDC. */
#define WPA_FREQ_USED_BY_P2P_GO BIT(2)
#define WPA_FREQ_USED_BY_SOFTAP BIT(3)
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wpa_used_freq_data {
int freq;
@@ -581,23 +545,12 @@
struct wpa_supplicant *p2pdev;
struct wpa_supplicant *next;
struct l2_packet_data *l2;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- struct l2_packet_data *l2_wapi;
- struct wpa_scan_results *wapi_scan_res;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct l2_packet_data *l2_br;
struct os_reltime roam_start;
struct os_reltime roam_time;
struct os_reltime session_start;
struct os_reltime session_length;
unsigned char own_addr[ETH_ALEN];
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- unsigned char wapi_own_addr[ETH_ALEN];
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
unsigned char perm_addr[ETH_ALEN];
char ifname[100];
#ifdef CONFIG_MATCH_IFACE
@@ -613,11 +566,9 @@
#ifdef CONFIG_CTRL_IFACE_BINDER
const void *binder_object_key;
#endif /* CONFIG_CTRL_IFACE_BINDER */
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_CTRL_IFACE_HIDL
const void *hidl_object_key;
#endif /* CONFIG_CTRL_IFACE_HIDL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
char bridge_ifname[16];
char *confname;
@@ -625,11 +576,9 @@
struct wpa_config *conf;
int countermeasures;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_BRCM_AUTOMOTIVE
int rx_freq;
#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct os_reltime last_michael_mic_error;
u8 bssid[ETH_ALEN];
u8 pending_bssid[ETH_ALEN]; /* If wpa_state == WPA_ASSOCIATING, this
@@ -810,32 +759,6 @@
unsigned int suitable_network;
unsigned int no_suitable_network;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI
- struct wapi_config *wapi_conf;
- int wai_received;
- struct wapi_state_machine *wapi_sm;
- int ctrl_sock; /* UNIX domain socket for control interface or -1 if
- * not used */
- int cgi_sock; /* UNIX domain socket for control interface or -1 if
- * not used */
- int rxfragstamp;
- struct wapi_rxfrag *rxfrag;
- u16 rxseq;
- u16 txseq;
-
-
- int wapi_state;
- unsigned char last_wai_src[ETH_ALEN];
- u8 pad;
- u8 flag;
- struct _resendbuf_st *buf;
- u8 assoc_wapi_ie[256]; /* Own WAPI/RSN IE from (Re)AssocReq */
- u8 ap_wapi_ie[256];
- u8 ap_wapi_ie_len;
- u8 assoc_wapi_ie_len;
-#endif /* WAPI */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
u64 drv_flags;
u64 drv_flags2;
unsigned int drv_enc;
@@ -887,19 +810,15 @@
unsigned int connection_ht:1;
unsigned int connection_vht:1;
unsigned int connection_he:1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_ANDROID11) || defined(CONFIG_ANDROID12)
unsigned int connection_max_nss_rx:4;
unsigned int connection_max_nss_tx:4;
unsigned int connection_channel_bandwidth:5;
#endif /* defined(CONFIG_ANDROID11) || defined(CONFIG_ANDROID12) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
unsigned int disable_mbo_oce:1;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
unsigned int connection_11b_only:1;
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct os_reltime last_mac_addr_change;
int last_mac_addr_style;
@@ -1185,11 +1104,9 @@
/* WLAN_STATUS_* status codes from (Re)Association Response frame. */
u16 assoc_status_code;
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:807bc58f wpa_supplicant(hidl): Add timedOut param in assoc reject */
/* Indicates if the previous association request timed out. */
u8 assoc_timed_out;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct ext_password_data *ext_pw;
@@ -1236,20 +1153,16 @@
u8 coloc_intf_auto_report;
u8 coloc_intf_timeout;
#ifdef CONFIG_MBO
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_ANDROID11) || defined(CONFIG_ANDROID12)
unsigned int wnm_mbo_cell_pref_present:1;
unsigned int wnm_mbo_assoc_retry_delay_present:1;
#endif /* defined(CONFIG_ANDROID11) || defined(CONFIG_ANDROID12) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
unsigned int wnm_mbo_trans_reason_present:1;
u8 wnm_mbo_transition_reason;
-#ifdef CONFIG_DRIVER_NL80211_IFX
#if defined(CONFIG_ANDROID11) || defined(CONFIG_ANDROID12)
u8 wnm_mbo_cell_preference;
u16 wnm_mbo_assoc_retry_delay_sec;
#endif /* defined(CONFIG_ANDROID11) || defined(CONFIG_ANDROID12) */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* CONFIG_MBO */
#endif /* CONFIG_WNM */
@@ -1449,6 +1362,9 @@
#ifdef CONFIG_FILS
unsigned int disable_fils:1;
#endif /* CONFIG_FILS */
+#ifdef CONFIG_IEEE80211AX
+ unsigned int ieee80211ax:1;
+#endif
unsigned int ieee80211ac:1;
unsigned int enabled_4addr_mode:1;
unsigned int multi_bss_support:1;
@@ -1458,13 +1374,6 @@
unsigned int multi_ap_fronthaul:1;
struct robust_av_data robust_av;
bool mscs_setup_done;
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#ifdef WAPI_AP
- int wapi_tx_sock;
- int wapi_sock;
- struct i802_bss *wapi_bss;
-#endif
-#endif /* CONFIG_DRIVER_NL80211_IFX */
};
@@ -1663,8 +1572,8 @@
struct wpa_ssid *ssid,
const char *field,
const char *value);
-#ifdef CONFIG_DRIVER_NL80211_IFX
-#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW) || defined (CONFIG_CTRL_IFACE_HIDL)
+#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW) || \
+ defined(CONFIG_CTRL_IFACE_HIDL)
/**
* wpa_supplicant_ctrl_rsp_handle - Handle a control response
* @wpa_s: Pointer to wpa_supplicant data
@@ -1680,7 +1589,6 @@
enum wpa_ctrl_req_type rtype,
const char *value, int len);
#endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW || CONFIG_CTRL_IFACE_HIDL */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
const struct wpa_ssid *ssid,
@@ -1803,9 +1711,7 @@
size_t len);
void wpas_handle_assoc_resp_mscs(struct wpa_supplicant *wpa_s, const u8 *bssid,
const u8 *ies, size_t ies_len);
-#ifdef CONFIG_DRIVER_NL80211_IFX
#ifdef CONFIG_ANDROID12
int disabled_freq(struct wpa_supplicant *wpa_s, int freq);
#endif /* CONFIG_ANDROID12 */
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#endif /* WPA_SUPPLICANT_I_H */
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpas_glue.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpas_glue.c
index ddfac9a..d309b8b 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpas_glue.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wpas_glue.c
@@ -12,9 +12,6 @@
#include "eapol_supp/eapol_supp_sm.h"
#include "eap_peer/eap.h"
#include "rsn_supp/wpa.h"
-#ifndef CONFIG_DRIVER_NL80211_IFX
-#include "rsn_supp/wpa_i.h"
-#endif /* CONFIG_DRIVER_NL80211_IFX */
#include "eloop.h"
#include "config.h"
#include "l2_packet/l2_packet.h"
@@ -287,9 +284,6 @@
void *ctx)
{
struct wpa_supplicant *wpa_s = ctx;
-#ifndef CONFIG_DRIVER_NL80211_IFX
- struct wpa_sm *sm = wpa_s->wpa;
-#endif /* CONFIG_DRIVER_NL80211_IFX */
int res, pmk_len;
u8 pmk[PMK_LEN];
@@ -313,7 +307,7 @@
ieee802_1x_notify_create_actor(wpa_s, wpa_s->last_eapol_src);
}
-#if defined(CONFIG_DRIVER_NL80211_IFX) && defined(BRCM_VE)
+#if defined(BRCM_VE)
/* Always try and pass down the PMK/XXKey to the driver. */
if (result != EAPOL_SUPP_RESULT_SUCCESS)
#else
@@ -329,49 +323,6 @@
"handshake");
pmk_len = PMK_LEN;
-#ifndef CONFIG_DRIVER_NL80211_IFX
- if (sm->cur_pmksa) {
- pmk_len = sm->pmk_len;
- os_memcpy(pmk, sm->pmk, pmk_len);
- } else {
- if (wpa_key_mgmt_ft(wpa_s->key_mgmt)) {
-#ifdef CONFIG_IEEE80211R
- u8 buf[2 * PMK_LEN];
- wpa_printf(MSG_DEBUG, "RSN: Use FT XXKey as PMK for "
- "driver-based 4-way hs and FT");
- res = eapol_sm_get_key(eapol, buf, 2 * PMK_LEN);
- if (res == 0) {
- os_memcpy(pmk, buf + PMK_LEN, PMK_LEN);
- os_memset(buf, 0, sizeof(buf));
- }
-#else /* CONFIG_IEEE80211R */
- res = -1;
-#endif /* CONFIG_IEEE80211R */
- } else {
- res = eapol_sm_get_key(eapol, pmk, PMK_LEN);
- if (res) {
- /*
- * EAP-LEAP is an exception from other EAP
- * methods: it uses only 16-byte PMK.
- */
- res = eapol_sm_get_key(eapol, pmk, 16);
- pmk_len = 16;
- }
- }
-
- if (res) {
- wpa_printf(MSG_DEBUG, "Failed to get PMK from EAPOL "
- "state machines");
- return;
- }
-
- sm->pmk_len = pmk_len;
- os_memcpy(sm->pmk, pmk, pmk_len);
- pmksa_cache_add(sm->pmksa, pmk, pmk_len, NULL, NULL, 0,
- sm->bssid, sm->own_addr,
- sm->network_ctx, sm->key_mgmt, NULL);
- }
-#else /* CONFIG_DRIVER_NL80211_IFX */
if (wpa_key_mgmt_ft(wpa_s->key_mgmt)) {
#ifdef CONFIG_IEEE80211R
u8 buf[2 * PMK_LEN];
@@ -402,7 +353,6 @@
"machines");
return;
}
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpa_hexdump_key(MSG_DEBUG, "RSN: Configure PMK for driver-based 4-way "
"handshake", pmk, pmk_len);
@@ -1520,6 +1470,8 @@
wpa_bss_get_fils_cache_id(wpa_s->current_bss);
#endif /* CONFIG_FILS */
conf.beacon_prot = ssid->beacon_prot;
+ /* Refer commit ed56a660: Suppress deauth for PMKSA caching disabled */
+ conf.suppress_deauth_no_pmksa = ssid->suppress_deauth_no_pmksa;
}
wpa_sm_set_config(wpa_s->wpa, ssid ? &conf : NULL);
}
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.c b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.c
index cdaaf38..c6205c6 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.c
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.c
@@ -2283,13 +2283,9 @@
#ifdef CONFIG_WPS_NFC
#ifdef CONFIG_WPS_ER
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:8894db2d wpa_supplicant(hidl):
* New EAP phase 2 params and NFC methods */
struct wpabuf *
-#else
-static struct wpabuf *
-#endif /* CONFIG_DRIVER_NL80211_IFX */
wpas_wps_network_config_token(struct wpa_supplicant *wpa_s, int ndef,
struct wpa_ssid *ssid)
{
diff --git a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.h b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.h
index 82a6c9f..b9c4c77 100755
--- a/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.h
+++ b/src/lynq/packages/thirdpart/lynq-wg870/wpa_supplicant/wps_supplicant.h
@@ -63,12 +63,10 @@
int wpas_wps_terminate_pending(struct wpa_supplicant *wpa_s);
void wpas_wps_update_config(struct wpa_supplicant *wpa_s);
void wpas_wps_update_mac_addr(struct wpa_supplicant *wpa_s);
-#ifdef CONFIG_DRIVER_NL80211_IFX
/* android commit:8894db2d wpa_supplicant(hidl):
* New EAP phase 2 params and NFC methods */
struct wpabuf * wpas_wps_network_config_token(struct wpa_supplicant *wpa_s,
int ndef, struct wpa_ssid * ssid);
-#endif /* CONFIG_DRIVER_NL80211_IFX */
struct wpabuf * wpas_wps_nfc_config_token(struct wpa_supplicant *wpa_s,
int ndef, const char *id_str);
struct wpabuf * wpas_wps_nfc_token(struct wpa_supplicant *wpa_s, int ndef);
diff --git a/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/parcel_to_data_mtk_unsol_commands.h b/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/parcel_to_data_mtk_unsol_commands.h
old mode 100644
new mode 100755
index a8523b2..295121d
--- a/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/parcel_to_data_mtk_unsol_commands.h
+++ b/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/parcel_to_data_mtk_unsol_commands.h
@@ -56,7 +56,7 @@
{RIL_UNSOL_VIRTUAL_SIM_ON,parcelToInts, COMMAND_SUPPORETD(0)},
{RIL_UNSOL_VIRTUAL_SIM_OFF,parcelToInts, COMMAND_SUPPORETD(0)},
{RIL_UNSOL_INVALID_SIM, parcelToStrings, COMMAND_SUPPORETD(0)},
-{RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED, parcelToInts, COMMAND_SUPPORETD(0)},
+{RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED, parcelToInts, COMMAND_SUPPORETD(1)},
{RIL_UNSOL_RESPONSE_ACMT, parcelToInts, COMMAND_SUPPORETD(0)},
{RIL_UNSOL_EF_CSP_PLMN_MODE_BIT, parcelToInts, COMMAND_SUPPORETD(0)},
{RIL_UNSOL_IMEI_LOCK, parcelToVoid, COMMAND_SUPPORETD(0)},
diff --git a/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/socket_channel.cpp b/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/socket_channel.cpp
old mode 100644
new mode 100755
index d7558a9..15a17ab
--- a/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/socket_channel.cpp
+++ b/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/socket_channel.cpp
@@ -105,11 +105,59 @@
RLOGD("[unlockMutex]name=%s", semName[socket_id]);\
sem_close(sem);\
} while(0)
+/*warren modfiy for fix bug API-614 on 2022/10/11 start*/
+int lynq_sem_timedwait(int mtime,sem_t * sem);
+
+#define lynq_sp_lockMutex(socket_id) {\
+ RLOGD("[lockMutex] name=%s", semName[socket_id]);\
+ int sem_v = -1;\
+ sem = sem_open(semName[socket_id], O_CREAT, 0644, 1);\
+ if(SEM_FAILED == sem){\
+ RLOGD("[ lockMutex]sem_open failed, errno = %d (%s)", errno, strerror(errno));\
+ exit(1);\
+ }\
+ sem_getvalue(sem,&sem_v);\
+ if(sem_v == 0)\
+ {\
+ RLOGD("lynq_sp_lockMutex sem_v == 0");\
+ lynq_sem_timedwait(2000,sem);\
+ /*if sem value == 0,wait 2s, then return*/\
+ }\
+ else\
+ {\
+ RLOGD("lynq_sp_lockMutex sem_v == %d",sem_v);\
+ sem_wait(sem);\
+ }\
+ }while(0)
+
+int lynq_sem_timedwait(int mtime,sem_t * sem)
+{
+ RLOGD("[%s]line %d",__FUNCTION__,__LINE__);
+ int sec = 0;
+ int usec = 0;
+ int s = 0;
+ struct timeval now;
+ struct timespec timeout;
+ gettimeofday(&now,NULL);
+ sec = mtime/1000;
+ usec = mtime%1000;
+ timeout.tv_sec = now.tv_sec+sec;
+ timeout.tv_nsec = now.tv_usec*1000+usec*1000000;
+ RLOGD("lynq_sem_timedwait about to call sem_timedwait()");
+ while ((s = sem_timedwait(sem, &timeout)) == -1 && errno == EINTR)
+ {
+ continue; /* Restart if interrupted by handler */
+ }
+ return 0;
+}
+
+/*warren modfiy for fix bug API-614 on 2022/10/11 end*/
#endif
+
extern "C"
void setRadioState(RIL_RadioState newState, RIL_SOCKET_ID rid);
@@ -555,7 +603,16 @@
#else //DSDS and MT2635
for(i=0; i<RIL_SOCKET_NUM; i++) {
#if defined(TELEPHONYWARE)
- lockMutex(i);
+ /*warren modfiy for fix bug API-614 on 2022/10/11 start*/
+ /*
+ **The cause of this problem is the global semaphore deadlock.
+ **When ril_socket_init is initialized to lock in a very coincidental situation,
+ **the process hangs and is not unlocked, so a deadlock scene occurs.
+ **Only restart can restore.
+ */
+ lynq_sp_lockMutex(i);
+ //lockMutex(i);
+ /*warren modfiy for fix bug API-614 on 2022/10/11 end*/
#endif
socketName = RilpSocketUtil::getSocketName(RADIO_TECH_GROUP_GSM, RIL_SOCKET_ID(i));
#if defined(TELEPHONYWARE)