[wifi][MR3.0][bcmdhd]Featrue:update wifi6 bcmdhd
Change-Id: Ib666f8365ccf8c7d0b4eb23dc78f2c582976806b
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 b114cf1..ea49dd7 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/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/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