Hi John, This is the final version of wcn36xx driver with sparce/smatch warnings fixed. Please let me know if there are any problems. On Tue, Oct 8, 2013 at 10:25 PM, Eugene Krasnikov <k.eugene.e@xxxxxxxxx> wrote: > This is a mac80211 driver for Qualcomm WCN3660/WCN3680 devices. So > far WCN3660/WCN3680 is available only on MSM platform. > > Firmware can be found here: > https://www.codeaurora.org/cgit/external/hisense/platform/vendor/qcom-opensource/wlan/prima/tree/firmware_bin?h=8130_CS > > Wiki page is available here: > http://wireless.kernel.org/en/users/Drivers/wcn36xx > > A lot people made a contribution to this driver. Here is the list in > alphabetical order: > > Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > Kalle Valo <kvalo@xxxxxxxxxxxxxxxx> > Olof Johansson <dev@xxxxxxxxxxxxx> > Pontus Fuchs <pontus.fuchs@xxxxxxxxx> > Yanbo Li <yanbol@xxxxxxxxxxxxxxxx> > > Signed-off-by: Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > --- > MAINTAINERS | 8 + > drivers/net/wireless/ath/Kconfig | 1 + > drivers/net/wireless/ath/Makefile | 1 + > drivers/net/wireless/ath/wcn36xx/Kconfig | 16 + > drivers/net/wireless/ath/wcn36xx/Makefile | 7 + > drivers/net/wireless/ath/wcn36xx/debug.c | 188 ++ > drivers/net/wireless/ath/wcn36xx/debug.h | 49 + > drivers/net/wireless/ath/wcn36xx/dxe.c | 805 +++++ > drivers/net/wireless/ath/wcn36xx/dxe.h | 284 ++ > drivers/net/wireless/ath/wcn36xx/hal.h | 4657 ++++++++++++++++++++++++++++ > drivers/net/wireless/ath/wcn36xx/main.c | 1036 +++++++ > drivers/net/wireless/ath/wcn36xx/pmc.c | 62 + > drivers/net/wireless/ath/wcn36xx/pmc.h | 33 + > drivers/net/wireless/ath/wcn36xx/smd.c | 2126 +++++++++++++ > drivers/net/wireless/ath/wcn36xx/smd.h | 127 + > drivers/net/wireless/ath/wcn36xx/txrx.c | 284 ++ > drivers/net/wireless/ath/wcn36xx/txrx.h | 160 + > drivers/net/wireless/ath/wcn36xx/wcn36xx.h | 238 ++ > 18 files changed, 10082 insertions(+) > create mode 100644 drivers/net/wireless/ath/wcn36xx/Kconfig > create mode 100644 drivers/net/wireless/ath/wcn36xx/Makefile > create mode 100644 drivers/net/wireless/ath/wcn36xx/debug.c > create mode 100644 drivers/net/wireless/ath/wcn36xx/debug.h > create mode 100644 drivers/net/wireless/ath/wcn36xx/dxe.c > create mode 100644 drivers/net/wireless/ath/wcn36xx/dxe.h > create mode 100644 drivers/net/wireless/ath/wcn36xx/hal.h > create mode 100644 drivers/net/wireless/ath/wcn36xx/main.c > create mode 100644 drivers/net/wireless/ath/wcn36xx/pmc.c > create mode 100644 drivers/net/wireless/ath/wcn36xx/pmc.h > create mode 100644 drivers/net/wireless/ath/wcn36xx/smd.c > create mode 100644 drivers/net/wireless/ath/wcn36xx/smd.h > create mode 100644 drivers/net/wireless/ath/wcn36xx/txrx.c > create mode 100644 drivers/net/wireless/ath/wcn36xx/txrx.h > create mode 100644 drivers/net/wireless/ath/wcn36xx/wcn36xx.h > > diff --git a/MAINTAINERS b/MAINTAINERS > index 705bb96..5cf566d 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -6745,6 +6745,14 @@ L: linux-hexagon@xxxxxxxxxxxxxxx > S: Supported > F: arch/hexagon/ > > +QUALCOMM WCN36XX WIRELESS DRIVER > +M: Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > +L: wcn36xx@xxxxxxxxxxxxxxxxxxx > +W: http://wireless.kernel.org/en/users/Drivers/wcn36xx > +T: git git://github.com/KrasnikovEugene/wcn36xx.git > +S: Supported > +F: drivers/net/wireless/ath/wcn36xx/ > + > QUICKCAM PARALLEL PORT WEBCAMS > M: Hans Verkuil <hverkuil@xxxxxxxxx> > L: linux-media@xxxxxxxxxxxxxxx > diff --git a/drivers/net/wireless/ath/Kconfig b/drivers/net/wireless/ath/Kconfig > index 1abf1d4..ba81d62 100644 > --- a/drivers/net/wireless/ath/Kconfig > +++ b/drivers/net/wireless/ath/Kconfig > @@ -32,5 +32,6 @@ source "drivers/net/wireless/ath/ath6kl/Kconfig" > source "drivers/net/wireless/ath/ar5523/Kconfig" > source "drivers/net/wireless/ath/wil6210/Kconfig" > source "drivers/net/wireless/ath/ath10k/Kconfig" > +source "drivers/net/wireless/ath/wcn36xx/Kconfig" > > endif > diff --git a/drivers/net/wireless/ath/Makefile b/drivers/net/wireless/ath/Makefile > index fb05cfd..363b056 100644 > --- a/drivers/net/wireless/ath/Makefile > +++ b/drivers/net/wireless/ath/Makefile > @@ -5,6 +5,7 @@ obj-$(CONFIG_ATH6KL) += ath6kl/ > obj-$(CONFIG_AR5523) += ar5523/ > obj-$(CONFIG_WIL6210) += wil6210/ > obj-$(CONFIG_ATH10K) += ath10k/ > +obj-$(CONFIG_WCN36XX) += wcn36xx/ > > obj-$(CONFIG_ATH_COMMON) += ath.o > > diff --git a/drivers/net/wireless/ath/wcn36xx/Kconfig b/drivers/net/wireless/ath/wcn36xx/Kconfig > new file mode 100644 > index 0000000..591ebae > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/Kconfig > @@ -0,0 +1,16 @@ > +config WCN36XX > + tristate "Qualcomm Atheros WCN3660/3680 support" > + depends on MAC80211 && HAS_DMA > + ---help--- > + This module adds support for wireless adapters based on > + Qualcomm Atheros WCN3660 and WCN3680 mobile chipsets. > + > + If you choose to build a module, it'll be called wcn36xx. > + > +config WCN36XX_DEBUGFS > + bool "WCN36XX debugfs support" > + depends on WCN36XX > + ---help--- > + Enabled debugfs support > + > + If unsure, say Y to make it easier to debug problems. > diff --git a/drivers/net/wireless/ath/wcn36xx/Makefile b/drivers/net/wireless/ath/wcn36xx/Makefile > new file mode 100644 > index 0000000..50c43b4 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/Makefile > @@ -0,0 +1,7 @@ > +obj-$(CONFIG_WCN36XX) := wcn36xx.o > +wcn36xx-y += main.o \ > + dxe.o \ > + txrx.o \ > + smd.o \ > + pmc.o \ > + debug.o > diff --git a/drivers/net/wireless/ath/wcn36xx/debug.c b/drivers/net/wireless/ath/wcn36xx/debug.c > new file mode 100644 > index 0000000..682bcd6 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/debug.c > @@ -0,0 +1,188 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/debugfs.h> > +#include <linux/uaccess.h> > +#include "wcn36xx.h" > +#include "debug.h" > +#include "pmc.h" > + > +#ifdef CONFIG_WCN36XX_DEBUGFS > + > +static int wcn36xx_debugfs_open(struct inode *inode, struct file *file) > +{ > + file->private_data = inode->i_private; > + > + return 0; > +} > + > +static ssize_t read_file_bool_bmps(struct file *file, char __user *user_buf, > + size_t count, loff_t *ppos) > +{ > + struct wcn36xx *wcn = file->private_data; > + struct wcn36xx_vif *vif_priv = NULL; > + struct ieee80211_vif *vif = NULL; > + char buf[3]; > + > + list_for_each_entry(vif_priv, &wcn->vif_list, list) { > + vif = container_of((void *)vif_priv, > + struct ieee80211_vif, > + drv_priv); > + if (NL80211_IFTYPE_STATION == vif->type) { > + if (vif_priv->pw_state == WCN36XX_BMPS) > + buf[0] = '1'; > + else > + buf[0] = '0'; > + break; > + } > + } > + buf[1] = '\n'; > + buf[2] = 0x00; > + > + return simple_read_from_buffer(user_buf, count, ppos, buf, 2); > +} > + > +static ssize_t write_file_bool_bmps(struct file *file, > + const char __user *user_buf, > + size_t count, loff_t *ppos) > +{ > + struct wcn36xx *wcn = file->private_data; > + struct wcn36xx_vif *vif_priv = NULL; > + struct ieee80211_vif *vif = NULL; > + > + char buf[32]; > + int buf_size; > + > + buf_size = min(count, (sizeof(buf)-1)); > + if (copy_from_user(buf, user_buf, buf_size)) > + return -EFAULT; > + > + switch (buf[0]) { > + case 'y': > + case 'Y': > + case '1': > + list_for_each_entry(vif_priv, &wcn->vif_list, list) { > + vif = container_of((void *)vif_priv, > + struct ieee80211_vif, > + drv_priv); > + if (NL80211_IFTYPE_STATION == vif->type) { > + wcn36xx_enable_keep_alive_null_packet(wcn, vif); > + wcn36xx_pmc_enter_bmps_state(wcn, vif); > + } > + } > + break; > + case 'n': > + case 'N': > + case '0': > + list_for_each_entry(vif_priv, &wcn->vif_list, list) { > + vif = container_of((void *)vif_priv, > + struct ieee80211_vif, > + drv_priv); > + if (NL80211_IFTYPE_STATION == vif->type) > + wcn36xx_pmc_exit_bmps_state(wcn, vif); > + } > + break; > + } > + > + return count; > +} > + > +static const struct file_operations fops_wcn36xx_bmps = { > + .open = wcn36xx_debugfs_open, > + .read = read_file_bool_bmps, > + .write = write_file_bool_bmps, > +}; > + > +static ssize_t write_file_dump(struct file *file, > + const char __user *user_buf, > + size_t count, loff_t *ppos) > +{ > + struct wcn36xx *wcn = file->private_data; > + char buf[255], *tmp; > + int buf_size; > + u32 arg[WCN36xx_MAX_DUMP_ARGS]; > + int i; > + > + memset(buf, 0, sizeof(buf)); > + memset(arg, 0, sizeof(arg)); > + > + buf_size = min(count, (sizeof(buf) - 1)); > + if (copy_from_user(buf, user_buf, buf_size)) > + return -EFAULT; > + > + tmp = buf; > + > + for (i = 0; i < WCN36xx_MAX_DUMP_ARGS; i++) { > + char *begin; > + begin = strsep(&tmp, " "); > + if (begin == NULL) > + break; > + > + if (kstrtoul(begin, 0, (unsigned long *)(arg + i)) != 0) > + break; > + } > + > + wcn36xx_info("DUMP args is %d %d %d %d %d\n", arg[0], arg[1], arg[2], > + arg[3], arg[4]); > + wcn36xx_smd_dump_cmd_req(wcn, arg[0], arg[1], arg[2], arg[3], arg[4]); > + > + return count; > +} > + > +static const struct file_operations fops_wcn36xx_dump = { > + .open = wcn36xx_debugfs_open, > + .write = write_file_dump, > +}; > + > +#define ADD_FILE(name, mode, fop, priv_data) \ > + do { \ > + struct dentry *d; \ > + d = debugfs_create_file(__stringify(name), \ > + mode, dfs->rootdir, \ > + priv_data, fop); \ > + dfs->file_##name.dentry = d; \ > + if (IS_ERR(d)) { \ > + wcn36xx_warn("Create the debugfs entry failed");\ > + dfs->file_##name.dentry = NULL; \ > + } \ > + } while (0) > + > + > +void wcn36xx_debugfs_init(struct wcn36xx *wcn) > +{ > + struct wcn36xx_dfs_entry *dfs = &wcn->dfs; > + > + dfs->rootdir = debugfs_create_dir(KBUILD_MODNAME, > + wcn->hw->wiphy->debugfsdir); > + if (IS_ERR(dfs->rootdir)) { > + wcn36xx_warn("Create the debugfs failed\n"); > + dfs->rootdir = NULL; > + } > + > + ADD_FILE(bmps_switcher, S_IRUSR | S_IWUSR, > + &fops_wcn36xx_bmps, wcn); > + ADD_FILE(dump, S_IWUSR, &fops_wcn36xx_dump, wcn); > +} > + > +void wcn36xx_debugfs_exit(struct wcn36xx *wcn) > +{ > + struct wcn36xx_dfs_entry *dfs = &wcn->dfs; > + debugfs_remove_recursive(dfs->rootdir); > +} > + > +#endif /* CONFIG_WCN36XX_DEBUGFS */ > diff --git a/drivers/net/wireless/ath/wcn36xx/debug.h b/drivers/net/wireless/ath/wcn36xx/debug.h > new file mode 100644 > index 0000000..46307aa > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/debug.h > @@ -0,0 +1,49 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#ifndef _WCN36XX_DEBUG_H_ > +#define _WCN36XX_DEBUG_H_ > + > +#include <linux/kernel.h> > + > +#define WCN36xx_MAX_DUMP_ARGS 5 > + > +#ifdef CONFIG_WCN36XX_DEBUGFS > +struct wcn36xx_dfs_file { > + struct dentry *dentry; > + u32 value; > +}; > + > +struct wcn36xx_dfs_entry { > + struct dentry *rootdir; > + struct wcn36xx_dfs_file file_bmps_switcher; > + struct wcn36xx_dfs_file file_dump; > +}; > + > +void wcn36xx_debugfs_init(struct wcn36xx *wcn); > +void wcn36xx_debugfs_exit(struct wcn36xx *wcn); > + > +#else > +static inline void wcn36xx_debugfs_init(struct wcn36xx *wcn) > +{ > +} > +static inline void wcn36xx_debugfs_exit(struct wcn36xx *wcn) > +{ > +} > + > +#endif /* CONFIG_WCN36XX_DEBUGFS */ > + > +#endif /* _WCN36XX_DEBUG_H_ */ > diff --git a/drivers/net/wireless/ath/wcn36xx/dxe.c b/drivers/net/wireless/ath/wcn36xx/dxe.c > new file mode 100644 > index 0000000..ee25786 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/dxe.c > @@ -0,0 +1,805 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +/* DXE - DMA transfer engine > + * we have 2 channels(High prio and Low prio) for TX and 2 channels for RX. > + * through low channels data packets are transfered > + * through high channels managment packets are transfered > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/interrupt.h> > +#include "wcn36xx.h" > +#include "txrx.h" > + > +void *wcn36xx_dxe_get_next_bd(struct wcn36xx *wcn, bool is_low) > +{ > + struct wcn36xx_dxe_ch *ch = is_low ? > + &wcn->dxe_tx_l_ch : > + &wcn->dxe_tx_h_ch; > + > + return ch->head_blk_ctl->bd_cpu_addr; > +} > + > +static void wcn36xx_dxe_write_register(struct wcn36xx *wcn, int addr, int data) > +{ > + wcn36xx_dbg(WCN36XX_DBG_DXE, > + "wcn36xx_dxe_write_register: addr=%x, data=%x\n", > + addr, data); > + > + writel(data, wcn->mmio + addr); > +} > + > +static void wcn36xx_dxe_read_register(struct wcn36xx *wcn, int addr, int *data) > +{ > + *data = readl(wcn->mmio + addr); > + > + wcn36xx_dbg(WCN36XX_DBG_DXE, > + "wcn36xx_dxe_read_register: addr=%x, data=%x\n", > + addr, *data); > +} > + > +static void wcn36xx_dxe_free_ctl_block(struct wcn36xx_dxe_ch *ch) > +{ > + struct wcn36xx_dxe_ctl *ctl = ch->head_blk_ctl, *next; > + int i; > + > + for (i = 0; i < ch->desc_num && ctl; i++) { > + next = ctl->next; > + kfree(ctl); > + ctl = next; > + } > +} > + > +static int wcn36xx_dxe_allocate_ctl_block(struct wcn36xx_dxe_ch *ch) > +{ > + struct wcn36xx_dxe_ctl *prev_ctl = NULL; > + struct wcn36xx_dxe_ctl *cur_ctl = NULL; > + int i; > + > + for (i = 0; i < ch->desc_num; i++) { > + cur_ctl = kzalloc(sizeof(*cur_ctl), GFP_KERNEL); > + if (!cur_ctl) > + goto out_fail; > + > + cur_ctl->ctl_blk_order = i; > + if (i == 0) { > + ch->head_blk_ctl = cur_ctl; > + ch->tail_blk_ctl = cur_ctl; > + } else if (ch->desc_num - 1 == i) { > + prev_ctl->next = cur_ctl; > + cur_ctl->next = ch->head_blk_ctl; > + } else { > + prev_ctl->next = cur_ctl; > + } > + prev_ctl = cur_ctl; > + } > + > + return 0; > + > +out_fail: > + wcn36xx_dxe_free_ctl_block(ch); > + return -ENOMEM; > +} > + > +int wcn36xx_dxe_alloc_ctl_blks(struct wcn36xx *wcn) > +{ > + int ret; > + > + wcn->dxe_tx_l_ch.ch_type = WCN36XX_DXE_CH_TX_L; > + wcn->dxe_tx_h_ch.ch_type = WCN36XX_DXE_CH_TX_H; > + wcn->dxe_rx_l_ch.ch_type = WCN36XX_DXE_CH_RX_L; > + wcn->dxe_rx_h_ch.ch_type = WCN36XX_DXE_CH_RX_H; > + > + wcn->dxe_tx_l_ch.desc_num = WCN36XX_DXE_CH_DESC_NUMB_TX_L; > + wcn->dxe_tx_h_ch.desc_num = WCN36XX_DXE_CH_DESC_NUMB_TX_H; > + wcn->dxe_rx_l_ch.desc_num = WCN36XX_DXE_CH_DESC_NUMB_RX_L; > + wcn->dxe_rx_h_ch.desc_num = WCN36XX_DXE_CH_DESC_NUMB_RX_H; > + > + wcn->dxe_tx_l_ch.dxe_wq = WCN36XX_DXE_WQ_TX_L; > + wcn->dxe_tx_h_ch.dxe_wq = WCN36XX_DXE_WQ_TX_H; > + > + wcn->dxe_tx_l_ch.ctrl_bd = WCN36XX_DXE_CTRL_TX_L_BD; > + wcn->dxe_tx_h_ch.ctrl_bd = WCN36XX_DXE_CTRL_TX_H_BD; > + > + wcn->dxe_tx_l_ch.ctrl_skb = WCN36XX_DXE_CTRL_TX_L_SKB; > + wcn->dxe_tx_h_ch.ctrl_skb = WCN36XX_DXE_CTRL_TX_H_SKB; > + > + wcn->dxe_tx_l_ch.reg_ctrl = WCN36XX_DXE_REG_CTL_TX_L; > + wcn->dxe_tx_h_ch.reg_ctrl = WCN36XX_DXE_REG_CTL_TX_H; > + > + wcn->dxe_tx_l_ch.def_ctrl = WCN36XX_DXE_CH_DEFAULT_CTL_TX_L; > + wcn->dxe_tx_h_ch.def_ctrl = WCN36XX_DXE_CH_DEFAULT_CTL_TX_H; > + > + /* DXE control block allocation */ > + ret = wcn36xx_dxe_allocate_ctl_block(&wcn->dxe_tx_l_ch); > + if (ret) > + goto out_err; > + ret = wcn36xx_dxe_allocate_ctl_block(&wcn->dxe_tx_h_ch); > + if (ret) > + goto out_err; > + ret = wcn36xx_dxe_allocate_ctl_block(&wcn->dxe_rx_l_ch); > + if (ret) > + goto out_err; > + ret = wcn36xx_dxe_allocate_ctl_block(&wcn->dxe_rx_h_ch); > + if (ret) > + goto out_err; > + > + /* Initialize SMSM state Clear TX Enable RING EMPTY STATE */ > + ret = wcn->ctrl_ops->smsm_change_state( > + WCN36XX_SMSM_WLAN_TX_ENABLE, > + WCN36XX_SMSM_WLAN_TX_RINGS_EMPTY); > + > + return 0; > + > +out_err: > + wcn36xx_err("Failed to allocate DXE control blocks\n"); > + wcn36xx_dxe_free_ctl_blks(wcn); > + return -ENOMEM; > +} > + > +void wcn36xx_dxe_free_ctl_blks(struct wcn36xx *wcn) > +{ > + wcn36xx_dxe_free_ctl_block(&wcn->dxe_tx_l_ch); > + wcn36xx_dxe_free_ctl_block(&wcn->dxe_tx_h_ch); > + wcn36xx_dxe_free_ctl_block(&wcn->dxe_rx_l_ch); > + wcn36xx_dxe_free_ctl_block(&wcn->dxe_rx_h_ch); > +} > + > +static int wcn36xx_dxe_init_descs(struct wcn36xx_dxe_ch *wcn_ch) > +{ > + struct wcn36xx_dxe_desc *cur_dxe = NULL; > + struct wcn36xx_dxe_desc *prev_dxe = NULL; > + struct wcn36xx_dxe_ctl *cur_ctl = NULL; > + size_t size; > + int i; > + > + size = wcn_ch->desc_num * sizeof(struct wcn36xx_dxe_desc); > + wcn_ch->cpu_addr = dma_alloc_coherent(NULL, size, &wcn_ch->dma_addr, > + GFP_KERNEL); > + if (!wcn_ch->cpu_addr) > + return -ENOMEM; > + > + memset(wcn_ch->cpu_addr, 0, size); > + > + cur_dxe = (struct wcn36xx_dxe_desc *)wcn_ch->cpu_addr; > + cur_ctl = wcn_ch->head_blk_ctl; > + > + for (i = 0; i < wcn_ch->desc_num; i++) { > + cur_ctl->desc = cur_dxe; > + cur_ctl->desc_phy_addr = wcn_ch->dma_addr + > + i * sizeof(struct wcn36xx_dxe_desc); > + > + switch (wcn_ch->ch_type) { > + case WCN36XX_DXE_CH_TX_L: > + cur_dxe->ctrl = WCN36XX_DXE_CTRL_TX_L; > + cur_dxe->dst_addr_l = WCN36XX_DXE_WQ_TX_L; > + break; > + case WCN36XX_DXE_CH_TX_H: > + cur_dxe->ctrl = WCN36XX_DXE_CTRL_TX_H; > + cur_dxe->dst_addr_l = WCN36XX_DXE_WQ_TX_H; > + break; > + case WCN36XX_DXE_CH_RX_L: > + cur_dxe->ctrl = WCN36XX_DXE_CTRL_RX_L; > + cur_dxe->src_addr_l = WCN36XX_DXE_WQ_RX_L; > + break; > + case WCN36XX_DXE_CH_RX_H: > + cur_dxe->ctrl = WCN36XX_DXE_CTRL_RX_H; > + cur_dxe->src_addr_l = WCN36XX_DXE_WQ_RX_H; > + break; > + } > + if (0 == i) { > + cur_dxe->phy_next_l = 0; > + } else if ((0 < i) && (i < wcn_ch->desc_num - 1)) { > + prev_dxe->phy_next_l = > + cur_ctl->desc_phy_addr; > + } else if (i == (wcn_ch->desc_num - 1)) { > + prev_dxe->phy_next_l = > + cur_ctl->desc_phy_addr; > + cur_dxe->phy_next_l = > + wcn_ch->head_blk_ctl->desc_phy_addr; > + } > + cur_ctl = cur_ctl->next; > + prev_dxe = cur_dxe; > + cur_dxe++; > + } > + > + return 0; > +} > + > +static void wcn36xx_dxe_init_tx_bd(struct wcn36xx_dxe_ch *ch, > + struct wcn36xx_dxe_mem_pool *pool) > +{ > + int i, chunk_size = pool->chunk_size; > + dma_addr_t bd_phy_addr = pool->phy_addr; > + void *bd_cpu_addr = pool->virt_addr; > + struct wcn36xx_dxe_ctl *cur = ch->head_blk_ctl; > + > + for (i = 0; i < ch->desc_num; i++) { > + /* Only every second dxe needs a bd pointer, > + the other will point to the skb data */ > + if (!(i & 1)) { > + cur->bd_phy_addr = bd_phy_addr; > + cur->bd_cpu_addr = bd_cpu_addr; > + bd_phy_addr += chunk_size; > + bd_cpu_addr += chunk_size; > + } else { > + cur->bd_phy_addr = 0; > + cur->bd_cpu_addr = NULL; > + } > + cur = cur->next; > + } > +} > + > +static int wcn36xx_dxe_enable_ch_int(struct wcn36xx *wcn, u16 wcn_ch) > +{ > + int reg_data = 0; > + > + wcn36xx_dxe_read_register(wcn, > + WCN36XX_DXE_INT_MASK_REG, > + ®_data); > + > + reg_data |= wcn_ch; > + > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_INT_MASK_REG, > + (int)reg_data); > + return 0; > +} > + > +static int wcn36xx_dxe_fill_skb(struct wcn36xx_dxe_ctl *ctl) > +{ > + struct wcn36xx_dxe_desc *dxe = ctl->desc; > + struct sk_buff *skb; > + > + skb = alloc_skb(WCN36XX_PKT_SIZE, GFP_ATOMIC); > + if (skb == NULL) > + return -ENOMEM; > + > + dxe->dst_addr_l = dma_map_single(NULL, > + skb_tail_pointer(skb), > + WCN36XX_PKT_SIZE, > + DMA_FROM_DEVICE); > + ctl->skb = skb; > + > + return 0; > +} > + > +static int wcn36xx_dxe_ch_alloc_skb(struct wcn36xx *wcn, > + struct wcn36xx_dxe_ch *wcn_ch) > +{ > + int i; > + struct wcn36xx_dxe_ctl *cur_ctl = NULL; > + > + cur_ctl = wcn_ch->head_blk_ctl; > + > + for (i = 0; i < wcn_ch->desc_num; i++) { > + wcn36xx_dxe_fill_skb(cur_ctl); > + cur_ctl = cur_ctl->next; > + } > + > + return 0; > +} > + > +static void wcn36xx_dxe_ch_free_skbs(struct wcn36xx *wcn, > + struct wcn36xx_dxe_ch *wcn_ch) > +{ > + struct wcn36xx_dxe_ctl *cur = wcn_ch->head_blk_ctl; > + int i; > + > + for (i = 0; i < wcn_ch->desc_num; i++) { > + kfree_skb(cur->skb); > + cur = cur->next; > + } > +} > + > +void wcn36xx_dxe_tx_ack_ind(struct wcn36xx *wcn, u32 status) > +{ > + struct ieee80211_tx_info *info; > + struct sk_buff *skb; > + unsigned long flags; > + > + spin_lock_irqsave(&wcn->dxe_lock, flags); > + skb = wcn->tx_ack_skb; > + wcn->tx_ack_skb = NULL; > + spin_unlock_irqrestore(&wcn->dxe_lock, flags); > + > + if (!skb) { > + wcn36xx_warn("Spurious TX complete indication\n"); > + return; > + } > + > + info = IEEE80211_SKB_CB(skb); > + > + if (status == 1) > + info->flags |= IEEE80211_TX_STAT_ACK; > + > + wcn36xx_dbg(WCN36XX_DBG_DXE, "dxe tx ack status: %d\n", status); > + > + ieee80211_tx_status_irqsafe(wcn->hw, skb); > + ieee80211_wake_queues(wcn->hw); > +} > + > +static void reap_tx_dxes(struct wcn36xx *wcn, struct wcn36xx_dxe_ch *ch) > +{ > + struct wcn36xx_dxe_ctl *ctl = ch->tail_blk_ctl; > + struct ieee80211_tx_info *info; > + unsigned long flags; > + > + /* > + * Make at least one loop of do-while because in case ring is > + * completely full head and tail are pointing to the same element > + * and while-do will not make any cycles. > + */ > + do { > + if (ctl->skb) { > + dma_unmap_single(NULL, ctl->desc->src_addr_l, > + ctl->skb->len, DMA_TO_DEVICE); > + info = IEEE80211_SKB_CB(ctl->skb); > + if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)) { > + /* Keep frame until TX status comes */ > + ieee80211_free_txskb(wcn->hw, ctl->skb); > + } > + spin_lock_irqsave(&ctl->skb_lock, flags); > + if (wcn->queues_stopped) { > + wcn->queues_stopped = false; > + ieee80211_wake_queues(wcn->hw); > + } > + spin_unlock_irqrestore(&ctl->skb_lock, flags); > + > + ctl->skb = NULL; > + } > + ctl = ctl->next; > + } while (ctl != ch->head_blk_ctl && > + !(ctl->desc->ctrl & WCN36XX_DXE_CTRL_VALID_MASK)); > + > + ch->tail_blk_ctl = ctl; > +} > + > +static irqreturn_t wcn36xx_irq_tx_complete(int irq, void *dev) > +{ > + struct wcn36xx *wcn = (struct wcn36xx *)dev; > + int int_src, int_reason; > + > + wcn36xx_dxe_read_register(wcn, WCN36XX_DXE_INT_SRC_RAW_REG, &int_src); > + > + if (int_src & WCN36XX_INT_MASK_CHAN_TX_H) { > + wcn36xx_dxe_read_register(wcn, > + WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_H, > + &int_reason); > + > + /* TODO: Check int_reason */ > + > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_0_INT_CLR, > + WCN36XX_INT_MASK_CHAN_TX_H); > + > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_0_INT_ED_CLR, > + WCN36XX_INT_MASK_CHAN_TX_H); > + wcn36xx_dbg(WCN36XX_DBG_DXE, "dxe tx ready high\n"); > + reap_tx_dxes(wcn, &wcn->dxe_tx_h_ch); > + } > + > + if (int_src & WCN36XX_INT_MASK_CHAN_TX_L) { > + wcn36xx_dxe_read_register(wcn, > + WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_L, > + &int_reason); > + /* TODO: Check int_reason */ > + > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_0_INT_CLR, > + WCN36XX_INT_MASK_CHAN_TX_L); > + > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_0_INT_ED_CLR, > + WCN36XX_INT_MASK_CHAN_TX_L); > + wcn36xx_dbg(WCN36XX_DBG_DXE, "dxe tx ready low\n"); > + reap_tx_dxes(wcn, &wcn->dxe_tx_l_ch); > + } > + > + return IRQ_HANDLED; > +} > + > +static irqreturn_t wcn36xx_irq_rx_ready(int irq, void *dev) > +{ > + struct wcn36xx *wcn = (struct wcn36xx *)dev; > + > + disable_irq_nosync(wcn->rx_irq); > + wcn36xx_dxe_rx_frame(wcn); > + enable_irq(wcn->rx_irq); > + return IRQ_HANDLED; > +} > + > +static int wcn36xx_dxe_request_irqs(struct wcn36xx *wcn) > +{ > + int ret; > + > + ret = request_irq(wcn->tx_irq, wcn36xx_irq_tx_complete, > + IRQF_TRIGGER_HIGH, "wcn36xx_tx", wcn); > + if (ret) { > + wcn36xx_err("failed to alloc tx irq\n"); > + goto out_err; > + } > + > + ret = request_irq(wcn->rx_irq, wcn36xx_irq_rx_ready, IRQF_TRIGGER_HIGH, > + "wcn36xx_rx", wcn); > + if (ret) { > + wcn36xx_err("failed to alloc rx irq\n"); > + goto out_txirq; > + } > + > + enable_irq_wake(wcn->rx_irq); > + > + return 0; > + > +out_txirq: > + free_irq(wcn->tx_irq, wcn); > +out_err: > + return ret; > + > +} > + > +static int wcn36xx_rx_handle_packets(struct wcn36xx *wcn, > + struct wcn36xx_dxe_ch *ch) > +{ > + struct wcn36xx_dxe_ctl *ctl = ch->head_blk_ctl; > + struct wcn36xx_dxe_desc *dxe = ctl->desc; > + dma_addr_t dma_addr; > + struct sk_buff *skb; > + > + while (!(dxe->ctrl & WCN36XX_DXE_CTRL_VALID_MASK)) { > + skb = ctl->skb; > + dma_addr = dxe->dst_addr_l; > + wcn36xx_dxe_fill_skb(ctl); > + > + switch (ch->ch_type) { > + case WCN36XX_DXE_CH_RX_L: > + dxe->ctrl = WCN36XX_DXE_CTRL_RX_L; > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_ENCH_ADDR, > + WCN36XX_DXE_INT_CH1_MASK); > + break; > + case WCN36XX_DXE_CH_RX_H: > + dxe->ctrl = WCN36XX_DXE_CTRL_RX_H; > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_ENCH_ADDR, > + WCN36XX_DXE_INT_CH3_MASK); > + break; > + default: > + wcn36xx_warn("Unknown channel\n"); > + } > + > + dma_unmap_single(NULL, dma_addr, WCN36XX_PKT_SIZE, > + DMA_FROM_DEVICE); > + wcn36xx_rx_skb(wcn, skb); > + ctl = ctl->next; > + dxe = ctl->desc; > + } > + > + ch->head_blk_ctl = ctl; > + > + return 0; > +} > + > +void wcn36xx_dxe_rx_frame(struct wcn36xx *wcn) > +{ > + int int_src; > + > + wcn36xx_dxe_read_register(wcn, WCN36XX_DXE_INT_SRC_RAW_REG, &int_src); > + > + /* RX_LOW_PRI */ > + if (int_src & WCN36XX_DXE_INT_CH1_MASK) { > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_0_INT_CLR, > + WCN36XX_DXE_INT_CH1_MASK); > + wcn36xx_rx_handle_packets(wcn, &(wcn->dxe_rx_l_ch)); > + } > + > + /* RX_HIGH_PRI */ > + if (int_src & WCN36XX_DXE_INT_CH3_MASK) { > + /* Clean up all the INT within this channel */ > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_0_INT_CLR, > + WCN36XX_DXE_INT_CH3_MASK); > + wcn36xx_rx_handle_packets(wcn, &(wcn->dxe_rx_h_ch)); > + } > + > + if (!int_src) > + wcn36xx_warn("No DXE interrupt pending\n"); > +} > + > +int wcn36xx_dxe_allocate_mem_pools(struct wcn36xx *wcn) > +{ > + size_t s; > + void *cpu_addr; > + > + /* Allocate BD headers for MGMT frames */ > + > + /* Where this come from ask QC */ > + wcn->mgmt_mem_pool.chunk_size = WCN36XX_BD_CHUNK_SIZE + > + 16 - (WCN36XX_BD_CHUNK_SIZE % 8); > + > + s = wcn->mgmt_mem_pool.chunk_size * WCN36XX_DXE_CH_DESC_NUMB_TX_H; > + cpu_addr = dma_alloc_coherent(NULL, s, &wcn->mgmt_mem_pool.phy_addr, > + GFP_KERNEL); > + if (!cpu_addr) > + goto out_err; > + > + wcn->mgmt_mem_pool.virt_addr = cpu_addr; > + memset(cpu_addr, 0, s); > + > + /* Allocate BD headers for DATA frames */ > + > + /* Where this come from ask QC */ > + wcn->data_mem_pool.chunk_size = WCN36XX_BD_CHUNK_SIZE + > + 16 - (WCN36XX_BD_CHUNK_SIZE % 8); > + > + s = wcn->data_mem_pool.chunk_size * WCN36XX_DXE_CH_DESC_NUMB_TX_L; > + cpu_addr = dma_alloc_coherent(NULL, s, &wcn->data_mem_pool.phy_addr, > + GFP_KERNEL); > + if (!cpu_addr) > + goto out_err; > + > + wcn->data_mem_pool.virt_addr = cpu_addr; > + memset(cpu_addr, 0, s); > + > + return 0; > + > +out_err: > + wcn36xx_dxe_free_mem_pools(wcn); > + wcn36xx_err("Failed to allocate BD mempool\n"); > + return -ENOMEM; > +} > + > +void wcn36xx_dxe_free_mem_pools(struct wcn36xx *wcn) > +{ > + if (wcn->mgmt_mem_pool.virt_addr) > + dma_free_coherent(NULL, wcn->mgmt_mem_pool.chunk_size * > + WCN36XX_DXE_CH_DESC_NUMB_TX_H, > + wcn->mgmt_mem_pool.virt_addr, > + wcn->mgmt_mem_pool.phy_addr); > + > + if (wcn->data_mem_pool.virt_addr) { > + dma_free_coherent(NULL, wcn->data_mem_pool.chunk_size * > + WCN36XX_DXE_CH_DESC_NUMB_TX_L, > + wcn->data_mem_pool.virt_addr, > + wcn->data_mem_pool.phy_addr); > + } > +} > + > +int wcn36xx_dxe_tx_frame(struct wcn36xx *wcn, > + struct wcn36xx_vif *vif_priv, > + struct sk_buff *skb, > + bool is_low) > +{ > + struct wcn36xx_dxe_ctl *ctl = NULL; > + struct wcn36xx_dxe_desc *desc = NULL; > + struct wcn36xx_dxe_ch *ch = NULL; > + unsigned long flags; > + > + ch = is_low ? &wcn->dxe_tx_l_ch : &wcn->dxe_tx_h_ch; > + > + ctl = ch->head_blk_ctl; > + > + spin_lock_irqsave(&ctl->next->skb_lock, flags); > + > + /* > + * If skb is not null that means that we reached the tail of the ring > + * hence ring is full. Stop queues to let mac80211 back off until ring > + * has an empty slot again. > + */ > + if (NULL != ctl->next->skb) { > + ieee80211_stop_queues(wcn->hw); > + wcn->queues_stopped = true; > + spin_unlock_irqrestore(&ctl->next->skb_lock, flags); > + return -EBUSY; > + } > + spin_unlock_irqrestore(&ctl->next->skb_lock, flags); > + > + ctl->skb = NULL; > + desc = ctl->desc; > + > + /* Set source address of the BD we send */ > + desc->src_addr_l = ctl->bd_phy_addr; > + > + desc->dst_addr_l = ch->dxe_wq; > + desc->fr_len = sizeof(struct wcn36xx_tx_bd); > + desc->ctrl = ch->ctrl_bd; > + > + wcn36xx_dbg(WCN36XX_DBG_DXE, "DXE TX\n"); > + > + wcn36xx_dbg_dump(WCN36XX_DBG_DXE_DUMP, "DESC1 >>> ", > + (char *)desc, sizeof(*desc)); > + wcn36xx_dbg_dump(WCN36XX_DBG_DXE_DUMP, > + "BD >>> ", (char *)ctl->bd_cpu_addr, > + sizeof(struct wcn36xx_tx_bd)); > + > + /* Set source address of the SKB we send */ > + ctl = ctl->next; > + ctl->skb = skb; > + desc = ctl->desc; > + if (ctl->bd_cpu_addr) { > + wcn36xx_err("bd_cpu_addr cannot be NULL for skb DXE\n"); > + return -EINVAL; > + } > + > + desc->src_addr_l = dma_map_single(NULL, > + ctl->skb->data, > + ctl->skb->len, > + DMA_TO_DEVICE); > + > + desc->dst_addr_l = ch->dxe_wq; > + desc->fr_len = ctl->skb->len; > + > + /* set dxe descriptor to VALID */ > + desc->ctrl = ch->ctrl_skb; > + > + wcn36xx_dbg_dump(WCN36XX_DBG_DXE_DUMP, "DESC2 >>> ", > + (char *)desc, sizeof(*desc)); > + wcn36xx_dbg_dump(WCN36XX_DBG_DXE_DUMP, "SKB >>> ", > + (char *)ctl->skb->data, ctl->skb->len); > + > + /* Move the head of the ring to the next empty descriptor */ > + ch->head_blk_ctl = ctl->next; > + > + /* > + * When connected and trying to send data frame chip can be in sleep > + * mode and writing to the register will not wake up the chip. Instead > + * notify chip about new frame through SMSM bus. > + */ > + if (is_low && vif_priv->pw_state == WCN36XX_BMPS) { > + wcn->ctrl_ops->smsm_change_state( > + 0, > + WCN36XX_SMSM_WLAN_TX_ENABLE); > + } else { > + /* indicate End Of Packet and generate interrupt on descriptor > + * done. > + */ > + wcn36xx_dxe_write_register(wcn, > + ch->reg_ctrl, ch->def_ctrl); > + } > + > + return 0; > +} > + > +int wcn36xx_dxe_init(struct wcn36xx *wcn) > +{ > + int reg_data = 0, ret; > + > + reg_data = WCN36XX_DXE_REG_RESET; > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_REG_CSR_RESET, reg_data); > + > + /* Setting interrupt path */ > + reg_data = WCN36XX_DXE_CCU_INT; > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_REG_CCU_INT, reg_data); > + > + /***************************************/ > + /* Init descriptors for TX LOW channel */ > + /***************************************/ > + wcn36xx_dxe_init_descs(&wcn->dxe_tx_l_ch); > + wcn36xx_dxe_init_tx_bd(&wcn->dxe_tx_l_ch, &wcn->data_mem_pool); > + > + /* Write channel head to a NEXT register */ > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_L, > + wcn->dxe_tx_l_ch.head_blk_ctl->desc_phy_addr); > + > + /* Program DMA destination addr for TX LOW */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_CH_DEST_ADDR_TX_L, > + WCN36XX_DXE_WQ_TX_L); > + > + wcn36xx_dxe_read_register(wcn, WCN36XX_DXE_REG_CH_EN, ®_data); > + wcn36xx_dxe_enable_ch_int(wcn, WCN36XX_INT_MASK_CHAN_TX_L); > + > + /***************************************/ > + /* Init descriptors for TX HIGH channel */ > + /***************************************/ > + wcn36xx_dxe_init_descs(&wcn->dxe_tx_h_ch); > + wcn36xx_dxe_init_tx_bd(&wcn->dxe_tx_h_ch, &wcn->mgmt_mem_pool); > + > + /* Write channel head to a NEXT register */ > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_H, > + wcn->dxe_tx_h_ch.head_blk_ctl->desc_phy_addr); > + > + /* Program DMA destination addr for TX HIGH */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_CH_DEST_ADDR_TX_H, > + WCN36XX_DXE_WQ_TX_H); > + > + wcn36xx_dxe_read_register(wcn, WCN36XX_DXE_REG_CH_EN, ®_data); > + > + /* Enable channel interrupts */ > + wcn36xx_dxe_enable_ch_int(wcn, WCN36XX_INT_MASK_CHAN_TX_H); > + > + /***************************************/ > + /* Init descriptors for RX LOW channel */ > + /***************************************/ > + wcn36xx_dxe_init_descs(&wcn->dxe_rx_l_ch); > + > + /* For RX we need to preallocated buffers */ > + wcn36xx_dxe_ch_alloc_skb(wcn, &wcn->dxe_rx_l_ch); > + > + /* Write channel head to a NEXT register */ > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_L, > + wcn->dxe_rx_l_ch.head_blk_ctl->desc_phy_addr); > + > + /* Write DMA source address */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_CH_SRC_ADDR_RX_L, > + WCN36XX_DXE_WQ_RX_L); > + > + /* Program preallocated destination address */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_CH_DEST_ADDR_RX_L, > + wcn->dxe_rx_l_ch.head_blk_ctl->desc->phy_next_l); > + > + /* Enable default control registers */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_REG_CTL_RX_L, > + WCN36XX_DXE_CH_DEFAULT_CTL_RX_L); > + > + /* Enable channel interrupts */ > + wcn36xx_dxe_enable_ch_int(wcn, WCN36XX_INT_MASK_CHAN_RX_L); > + > + /***************************************/ > + /* Init descriptors for RX HIGH channel */ > + /***************************************/ > + wcn36xx_dxe_init_descs(&wcn->dxe_rx_h_ch); > + > + /* For RX we need to prealocat buffers */ > + wcn36xx_dxe_ch_alloc_skb(wcn, &wcn->dxe_rx_h_ch); > + > + /* Write chanel head to a NEXT register */ > + wcn36xx_dxe_write_register(wcn, WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_H, > + wcn->dxe_rx_h_ch.head_blk_ctl->desc_phy_addr); > + > + /* Write DMA source address */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_CH_SRC_ADDR_RX_H, > + WCN36XX_DXE_WQ_RX_H); > + > + /* Program preallocated destination address */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_CH_DEST_ADDR_RX_H, > + wcn->dxe_rx_h_ch.head_blk_ctl->desc->phy_next_l); > + > + /* Enable default control registers */ > + wcn36xx_dxe_write_register(wcn, > + WCN36XX_DXE_REG_CTL_RX_H, > + WCN36XX_DXE_CH_DEFAULT_CTL_RX_H); > + > + /* Enable channel interrupts */ > + wcn36xx_dxe_enable_ch_int(wcn, WCN36XX_INT_MASK_CHAN_RX_H); > + > + ret = wcn36xx_dxe_request_irqs(wcn); > + if (ret < 0) > + goto out_err; > + > + return 0; > + > +out_err: > + return ret; > +} > + > +void wcn36xx_dxe_deinit(struct wcn36xx *wcn) > +{ > + free_irq(wcn->tx_irq, wcn); > + free_irq(wcn->rx_irq, wcn); > + > + if (wcn->tx_ack_skb) { > + ieee80211_tx_status_irqsafe(wcn->hw, wcn->tx_ack_skb); > + wcn->tx_ack_skb = NULL; > + } > + > + wcn36xx_dxe_ch_free_skbs(wcn, &wcn->dxe_rx_l_ch); > + wcn36xx_dxe_ch_free_skbs(wcn, &wcn->dxe_rx_h_ch); > +} > diff --git a/drivers/net/wireless/ath/wcn36xx/dxe.h b/drivers/net/wireless/ath/wcn36xx/dxe.h > new file mode 100644 > index 0000000..c88562f > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/dxe.h > @@ -0,0 +1,284 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#ifndef _DXE_H_ > +#define _DXE_H_ > + > +#include "wcn36xx.h" > + > +/* > +TX_LOW = DMA0 > +TX_HIGH = DMA4 > +RX_LOW = DMA1 > +RX_HIGH = DMA3 > +H2H_TEST_RX_TX = DMA2 > +*/ > + > +/* DXE registers */ > +#define WCN36XX_DXE_MEM_BASE 0x03000000 > +#define WCN36XX_DXE_MEM_REG 0x202000 > + > +#define WCN36XX_DXE_CCU_INT 0xA0011 > +#define WCN36XX_DXE_REG_CCU_INT 0x200b10 > + > +/* TODO This must calculated properly but not hardcoded */ > +#define WCN36XX_DXE_CTRL_TX_L 0x328a44 > +#define WCN36XX_DXE_CTRL_TX_H 0x32ce44 > +#define WCN36XX_DXE_CTRL_RX_L 0x12ad2f > +#define WCN36XX_DXE_CTRL_RX_H 0x12d12f > +#define WCN36XX_DXE_CTRL_TX_H_BD 0x30ce45 > +#define WCN36XX_DXE_CTRL_TX_H_SKB 0x32ce4d > +#define WCN36XX_DXE_CTRL_TX_L_BD 0x308a45 > +#define WCN36XX_DXE_CTRL_TX_L_SKB 0x328a4d > + > +/* TODO This must calculated properly but not hardcoded */ > +#define WCN36XX_DXE_WQ_TX_L 0x17 > +#define WCN36XX_DXE_WQ_TX_H 0x17 > +#define WCN36XX_DXE_WQ_RX_L 0xB > +#define WCN36XX_DXE_WQ_RX_H 0x4 > + > +/* DXE descriptor control filed */ > +#define WCN36XX_DXE_CTRL_VALID_MASK (0x00000001) > + > +/* TODO This must calculated properly but not hardcoded */ > +/* DXE default control register values */ > +#define WCN36XX_DXE_CH_DEFAULT_CTL_RX_L 0x847EAD2F > +#define WCN36XX_DXE_CH_DEFAULT_CTL_RX_H 0x84FED12F > +#define WCN36XX_DXE_CH_DEFAULT_CTL_TX_H 0x853ECF4D > +#define WCN36XX_DXE_CH_DEFAULT_CTL_TX_L 0x843e8b4d > + > +/* Common DXE registers */ > +#define WCN36XX_DXE_MEM_CSR (WCN36XX_DXE_MEM_REG + 0x00) > +#define WCN36XX_DXE_REG_CSR_RESET (WCN36XX_DXE_MEM_REG + 0x00) > +#define WCN36XX_DXE_ENCH_ADDR (WCN36XX_DXE_MEM_REG + 0x04) > +#define WCN36XX_DXE_REG_CH_EN (WCN36XX_DXE_MEM_REG + 0x08) > +#define WCN36XX_DXE_REG_CH_DONE (WCN36XX_DXE_MEM_REG + 0x0C) > +#define WCN36XX_DXE_REG_CH_ERR (WCN36XX_DXE_MEM_REG + 0x10) > +#define WCN36XX_DXE_INT_MASK_REG (WCN36XX_DXE_MEM_REG + 0x18) > +#define WCN36XX_DXE_INT_SRC_RAW_REG (WCN36XX_DXE_MEM_REG + 0x20) > + /* #define WCN36XX_DXE_INT_CH6_MASK 0x00000040 */ > + /* #define WCN36XX_DXE_INT_CH5_MASK 0x00000020 */ > + #define WCN36XX_DXE_INT_CH4_MASK 0x00000010 > + #define WCN36XX_DXE_INT_CH3_MASK 0x00000008 > + /* #define WCN36XX_DXE_INT_CH2_MASK 0x00000004 */ > + #define WCN36XX_DXE_INT_CH1_MASK 0x00000002 > + #define WCN36XX_DXE_INT_CH0_MASK 0x00000001 > +#define WCN36XX_DXE_0_INT_CLR (WCN36XX_DXE_MEM_REG + 0x30) > +#define WCN36XX_DXE_0_INT_ED_CLR (WCN36XX_DXE_MEM_REG + 0x34) > +#define WCN36XX_DXE_0_INT_DONE_CLR (WCN36XX_DXE_MEM_REG + 0x38) > +#define WCN36XX_DXE_0_INT_ERR_CLR (WCN36XX_DXE_MEM_REG + 0x3C) > + > +#define WCN36XX_DXE_0_CH0_STATUS (WCN36XX_DXE_MEM_REG + 0x404) > +#define WCN36XX_DXE_0_CH1_STATUS (WCN36XX_DXE_MEM_REG + 0x444) > +#define WCN36XX_DXE_0_CH2_STATUS (WCN36XX_DXE_MEM_REG + 0x484) > +#define WCN36XX_DXE_0_CH3_STATUS (WCN36XX_DXE_MEM_REG + 0x4C4) > +#define WCN36XX_DXE_0_CH4_STATUS (WCN36XX_DXE_MEM_REG + 0x504) > + > +#define WCN36XX_DXE_REG_RESET 0x5c89 > + > +/* Temporary BMU Workqueue 4 */ > +#define WCN36XX_DXE_BMU_WQ_RX_LOW 0xB > +#define WCN36XX_DXE_BMU_WQ_RX_HIGH 0x4 > +/* DMA channel offset */ > +#define WCN36XX_DXE_TX_LOW_OFFSET 0x400 > +#define WCN36XX_DXE_TX_HIGH_OFFSET 0x500 > +#define WCN36XX_DXE_RX_LOW_OFFSET 0x440 > +#define WCN36XX_DXE_RX_HIGH_OFFSET 0x4C0 > + > +/* Address of the next DXE descriptor */ > +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR 0x001C > +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_LOW_OFFSET + \ > + WCN36XX_DXE_CH_NEXT_DESC_ADDR) > +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_HIGH_OFFSET + \ > + WCN36XX_DXE_CH_NEXT_DESC_ADDR) > +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_LOW_OFFSET + \ > + WCN36XX_DXE_CH_NEXT_DESC_ADDR) > +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_HIGH_OFFSET + \ > + WCN36XX_DXE_CH_NEXT_DESC_ADDR) > + > +/* DXE Descriptor source address */ > +#define WCN36XX_DXE_CH_SRC_ADDR 0x000C > +#define WCN36XX_DXE_CH_SRC_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_LOW_OFFSET + \ > + WCN36XX_DXE_CH_SRC_ADDR) > +#define WCN36XX_DXE_CH_SRC_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_HIGH_OFFSET + \ > + WCN36XX_DXE_CH_SRC_ADDR) > + > +/* DXE Descriptor address destination address */ > +#define WCN36XX_DXE_CH_DEST_ADDR 0x0014 > +#define WCN36XX_DXE_CH_DEST_ADDR_TX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_LOW_OFFSET + \ > + WCN36XX_DXE_CH_DEST_ADDR) > +#define WCN36XX_DXE_CH_DEST_ADDR_TX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_HIGH_OFFSET + \ > + WCN36XX_DXE_CH_DEST_ADDR) > +#define WCN36XX_DXE_CH_DEST_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_LOW_OFFSET + \ > + WCN36XX_DXE_CH_DEST_ADDR) > +#define WCN36XX_DXE_CH_DEST_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_HIGH_OFFSET + \ > + WCN36XX_DXE_CH_DEST_ADDR) > + > +/* Interrupt status */ > +#define WCN36XX_DXE_CH_STATUS_REG_ADDR 0x0004 > +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_LOW_OFFSET + \ > + WCN36XX_DXE_CH_STATUS_REG_ADDR) > +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_HIGH_OFFSET + \ > + WCN36XX_DXE_CH_STATUS_REG_ADDR) > +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_LOW_OFFSET + \ > + WCN36XX_DXE_CH_STATUS_REG_ADDR) > +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_HIGH_OFFSET + \ > + WCN36XX_DXE_CH_STATUS_REG_ADDR) > + > + > +/* DXE default control register */ > +#define WCN36XX_DXE_REG_CTL_RX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_LOW_OFFSET) > +#define WCN36XX_DXE_REG_CTL_RX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_RX_HIGH_OFFSET) > +#define WCN36XX_DXE_REG_CTL_TX_H (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_HIGH_OFFSET) > +#define WCN36XX_DXE_REG_CTL_TX_L (WCN36XX_DXE_MEM_REG + \ > + WCN36XX_DXE_TX_LOW_OFFSET) > + > +#define WCN36XX_SMSM_WLAN_TX_ENABLE 0x00000400 > +#define WCN36XX_SMSM_WLAN_TX_RINGS_EMPTY 0x00000200 > + > + > +/* Interrupt control channel mask */ > +#define WCN36XX_INT_MASK_CHAN_TX_L 0x00000001 > +#define WCN36XX_INT_MASK_CHAN_RX_L 0x00000002 > +#define WCN36XX_INT_MASK_CHAN_RX_H 0x00000008 > +#define WCN36XX_INT_MASK_CHAN_TX_H 0x00000010 > + > +#define WCN36XX_BD_CHUNK_SIZE 128 > + > +#define WCN36XX_PKT_SIZE 0xF20 > +enum wcn36xx_dxe_ch_type { > + WCN36XX_DXE_CH_TX_L, > + WCN36XX_DXE_CH_TX_H, > + WCN36XX_DXE_CH_RX_L, > + WCN36XX_DXE_CH_RX_H > +}; > + > +/* amount of descriptors per channel */ > +enum wcn36xx_dxe_ch_desc_num { > + WCN36XX_DXE_CH_DESC_NUMB_TX_L = 128, > + WCN36XX_DXE_CH_DESC_NUMB_TX_H = 10, > + WCN36XX_DXE_CH_DESC_NUMB_RX_L = 512, > + WCN36XX_DXE_CH_DESC_NUMB_RX_H = 40 > +}; > + > +/** > + * struct wcn36xx_dxe_desc - describes descriptor of one DXE buffer > + * > + * @ctrl: is a union that consists of following bits: > + * union { > + * u32 valid :1; //0 = DMA stop, 1 = DMA continue with this > + * //descriptor > + * u32 transfer_type :2; //0 = Host to Host space > + * u32 eop :1; //End of Packet > + * u32 bd_handling :1; //if transferType = Host to BMU, then 0 > + * // means first 128 bytes contain BD, and 1 > + * // means create new empty BD > + * u32 siq :1; // SIQ > + * u32 diq :1; // DIQ > + * u32 pdu_rel :1; //0 = don't release BD and PDUs when done, > + * // 1 = release them > + * u32 bthld_sel :4; //BMU Threshold Select > + * u32 prio :3; //Specifies the priority level to use for > + * // the transfer > + * u32 stop_channel :1; //1 = DMA stops processing further, channel > + * //requires re-enabling after this > + * u32 intr :1; //Interrupt on Descriptor Done > + * u32 rsvd :1; //reserved > + * u32 size :14;//14 bits used - ignored for BMU transfers, > + * //only used for host to host transfers? > + * } ctrl; > + */ > +struct wcn36xx_dxe_desc { > + u32 ctrl; > + u32 fr_len; > + > + u32 src_addr_l; > + u32 dst_addr_l; > + u32 phy_next_l; > + u32 src_addr_h; > + u32 dst_addr_h; > + u32 phy_next_h; > +} __packed; > + > +/* DXE Control block */ > +struct wcn36xx_dxe_ctl { > + struct wcn36xx_dxe_ctl *next; > + struct wcn36xx_dxe_desc *desc; > + unsigned int desc_phy_addr; > + int ctl_blk_order; > + struct sk_buff *skb; > + spinlock_t skb_lock; > + void *bd_cpu_addr; > + dma_addr_t bd_phy_addr; > +}; > + > +struct wcn36xx_dxe_ch { > + enum wcn36xx_dxe_ch_type ch_type; > + void *cpu_addr; > + dma_addr_t dma_addr; > + enum wcn36xx_dxe_ch_desc_num desc_num; > + /* DXE control block ring */ > + struct wcn36xx_dxe_ctl *head_blk_ctl; > + struct wcn36xx_dxe_ctl *tail_blk_ctl; > + > + /* DXE channel specific configs */ > + u32 dxe_wq; > + u32 ctrl_bd; > + u32 ctrl_skb; > + u32 reg_ctrl; > + u32 def_ctrl; > +}; > + > +/* Memory Pool for BD headers */ > +struct wcn36xx_dxe_mem_pool { > + int chunk_size; > + void *virt_addr; > + dma_addr_t phy_addr; > +}; > + > +struct wcn36xx_vif; > +int wcn36xx_dxe_allocate_mem_pools(struct wcn36xx *wcn); > +void wcn36xx_dxe_free_mem_pools(struct wcn36xx *wcn); > +void wcn36xx_dxe_rx_frame(struct wcn36xx *wcn); > +int wcn36xx_dxe_alloc_ctl_blks(struct wcn36xx *wcn); > +void wcn36xx_dxe_free_ctl_blks(struct wcn36xx *wcn); > +int wcn36xx_dxe_init(struct wcn36xx *wcn); > +void wcn36xx_dxe_deinit(struct wcn36xx *wcn); > +int wcn36xx_dxe_init_channels(struct wcn36xx *wcn); > +int wcn36xx_dxe_tx_frame(struct wcn36xx *wcn, > + struct wcn36xx_vif *vif_priv, > + struct sk_buff *skb, > + bool is_low); > +void wcn36xx_dxe_tx_ack_ind(struct wcn36xx *wcn, u32 status); > +void *wcn36xx_dxe_get_next_bd(struct wcn36xx *wcn, bool is_low); > +#endif /* _DXE_H_ */ > diff --git a/drivers/net/wireless/ath/wcn36xx/hal.h b/drivers/net/wireless/ath/wcn36xx/hal.h > new file mode 100644 > index 0000000..c02dbc6 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/hal.h > @@ -0,0 +1,4657 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#ifndef _HAL_H_ > +#define _HAL_H_ > + > +/*--------------------------------------------------------------------------- > + API VERSIONING INFORMATION > + > + The RIVA API is versioned as MAJOR.MINOR.VERSION.REVISION > + The MAJOR is incremented for major product/architecture changes > + (and then MINOR/VERSION/REVISION are zeroed) > + The MINOR is incremented for minor product/architecture changes > + (and then VERSION/REVISION are zeroed) > + The VERSION is incremented if a significant API change occurs > + (and then REVISION is zeroed) > + The REVISION is incremented if an insignificant API change occurs > + or if a new API is added > + All values are in the range 0..255 (ie they are 8-bit values) > + ---------------------------------------------------------------------------*/ > +#define WCN36XX_HAL_VER_MAJOR 1 > +#define WCN36XX_HAL_VER_MINOR 4 > +#define WCN36XX_HAL_VER_VERSION 1 > +#define WCN36XX_HAL_VER_REVISION 2 > + > +/* This is to force compiler to use the maximum of an int ( 4 bytes ) */ > +#define WCN36XX_HAL_MAX_ENUM_SIZE 0x7FFFFFFF > +#define WCN36XX_HAL_MSG_TYPE_MAX_ENUM_SIZE 0x7FFF > + > +/* Max no. of transmit categories */ > +#define STACFG_MAX_TC 8 > + > +/* The maximum value of access category */ > +#define WCN36XX_HAL_MAX_AC 4 > + > +#define WCN36XX_HAL_IPV4_ADDR_LEN 4 > + > +#define WALN_HAL_STA_INVALID_IDX 0xFF > +#define WCN36XX_HAL_BSS_INVALID_IDX 0xFF > + > +/* Default Beacon template size */ > +#define BEACON_TEMPLATE_SIZE 0x180 > + > +/* Param Change Bitmap sent to HAL */ > +#define PARAM_BCN_INTERVAL_CHANGED (1 << 0) > +#define PARAM_SHORT_PREAMBLE_CHANGED (1 << 1) > +#define PARAM_SHORT_SLOT_TIME_CHANGED (1 << 2) > +#define PARAM_llACOEXIST_CHANGED (1 << 3) > +#define PARAM_llBCOEXIST_CHANGED (1 << 4) > +#define PARAM_llGCOEXIST_CHANGED (1 << 5) > +#define PARAM_HT20MHZCOEXIST_CHANGED (1<<6) > +#define PARAM_NON_GF_DEVICES_PRESENT_CHANGED (1<<7) > +#define PARAM_RIFS_MODE_CHANGED (1<<8) > +#define PARAM_LSIG_TXOP_FULL_SUPPORT_CHANGED (1<<9) > +#define PARAM_OBSS_MODE_CHANGED (1<<10) > +#define PARAM_BEACON_UPDATE_MASK \ > + (PARAM_BCN_INTERVAL_CHANGED | \ > + PARAM_SHORT_PREAMBLE_CHANGED | \ > + PARAM_SHORT_SLOT_TIME_CHANGED | \ > + PARAM_llACOEXIST_CHANGED | \ > + PARAM_llBCOEXIST_CHANGED | \ > + PARAM_llGCOEXIST_CHANGED | \ > + PARAM_HT20MHZCOEXIST_CHANGED | \ > + PARAM_NON_GF_DEVICES_PRESENT_CHANGED | \ > + PARAM_RIFS_MODE_CHANGED | \ > + PARAM_LSIG_TXOP_FULL_SUPPORT_CHANGED | \ > + PARAM_OBSS_MODE_CHANGED) > + > +/* dump command response Buffer size */ > +#define DUMPCMD_RSP_BUFFER 100 > + > +/* version string max length (including NULL) */ > +#define WCN36XX_HAL_VERSION_LENGTH 64 > + > +/* message types for messages exchanged between WDI and HAL */ > +enum wcn36xx_hal_host_msg_type { > + /* Init/De-Init */ > + WCN36XX_HAL_START_REQ = 0, > + WCN36XX_HAL_START_RSP = 1, > + WCN36XX_HAL_STOP_REQ = 2, > + WCN36XX_HAL_STOP_RSP = 3, > + > + /* Scan */ > + WCN36XX_HAL_INIT_SCAN_REQ = 4, > + WCN36XX_HAL_INIT_SCAN_RSP = 5, > + WCN36XX_HAL_START_SCAN_REQ = 6, > + WCN36XX_HAL_START_SCAN_RSP = 7, > + WCN36XX_HAL_END_SCAN_REQ = 8, > + WCN36XX_HAL_END_SCAN_RSP = 9, > + WCN36XX_HAL_FINISH_SCAN_REQ = 10, > + WCN36XX_HAL_FINISH_SCAN_RSP = 11, > + > + /* HW STA configuration/deconfiguration */ > + WCN36XX_HAL_CONFIG_STA_REQ = 12, > + WCN36XX_HAL_CONFIG_STA_RSP = 13, > + WCN36XX_HAL_DELETE_STA_REQ = 14, > + WCN36XX_HAL_DELETE_STA_RSP = 15, > + WCN36XX_HAL_CONFIG_BSS_REQ = 16, > + WCN36XX_HAL_CONFIG_BSS_RSP = 17, > + WCN36XX_HAL_DELETE_BSS_REQ = 18, > + WCN36XX_HAL_DELETE_BSS_RSP = 19, > + > + /* Infra STA asscoiation */ > + WCN36XX_HAL_JOIN_REQ = 20, > + WCN36XX_HAL_JOIN_RSP = 21, > + WCN36XX_HAL_POST_ASSOC_REQ = 22, > + WCN36XX_HAL_POST_ASSOC_RSP = 23, > + > + /* Security */ > + WCN36XX_HAL_SET_BSSKEY_REQ = 24, > + WCN36XX_HAL_SET_BSSKEY_RSP = 25, > + WCN36XX_HAL_SET_STAKEY_REQ = 26, > + WCN36XX_HAL_SET_STAKEY_RSP = 27, > + WCN36XX_HAL_RMV_BSSKEY_REQ = 28, > + WCN36XX_HAL_RMV_BSSKEY_RSP = 29, > + WCN36XX_HAL_RMV_STAKEY_REQ = 30, > + WCN36XX_HAL_RMV_STAKEY_RSP = 31, > + > + /* Qos Related */ > + WCN36XX_HAL_ADD_TS_REQ = 32, > + WCN36XX_HAL_ADD_TS_RSP = 33, > + WCN36XX_HAL_DEL_TS_REQ = 34, > + WCN36XX_HAL_DEL_TS_RSP = 35, > + WCN36XX_HAL_UPD_EDCA_PARAMS_REQ = 36, > + WCN36XX_HAL_UPD_EDCA_PARAMS_RSP = 37, > + WCN36XX_HAL_ADD_BA_REQ = 38, > + WCN36XX_HAL_ADD_BA_RSP = 39, > + WCN36XX_HAL_DEL_BA_REQ = 40, > + WCN36XX_HAL_DEL_BA_RSP = 41, > + > + WCN36XX_HAL_CH_SWITCH_REQ = 42, > + WCN36XX_HAL_CH_SWITCH_RSP = 43, > + WCN36XX_HAL_SET_LINK_ST_REQ = 44, > + WCN36XX_HAL_SET_LINK_ST_RSP = 45, > + WCN36XX_HAL_GET_STATS_REQ = 46, > + WCN36XX_HAL_GET_STATS_RSP = 47, > + WCN36XX_HAL_UPDATE_CFG_REQ = 48, > + WCN36XX_HAL_UPDATE_CFG_RSP = 49, > + > + WCN36XX_HAL_MISSED_BEACON_IND = 50, > + WCN36XX_HAL_UNKNOWN_ADDR2_FRAME_RX_IND = 51, > + WCN36XX_HAL_MIC_FAILURE_IND = 52, > + WCN36XX_HAL_FATAL_ERROR_IND = 53, > + WCN36XX_HAL_SET_KEYDONE_MSG = 54, > + > + /* NV Interface */ > + WCN36XX_HAL_DOWNLOAD_NV_REQ = 55, > + WCN36XX_HAL_DOWNLOAD_NV_RSP = 56, > + > + WCN36XX_HAL_ADD_BA_SESSION_REQ = 57, > + WCN36XX_HAL_ADD_BA_SESSION_RSP = 58, > + WCN36XX_HAL_TRIGGER_BA_REQ = 59, > + WCN36XX_HAL_TRIGGER_BA_RSP = 60, > + WCN36XX_HAL_UPDATE_BEACON_REQ = 61, > + WCN36XX_HAL_UPDATE_BEACON_RSP = 62, > + WCN36XX_HAL_SEND_BEACON_REQ = 63, > + WCN36XX_HAL_SEND_BEACON_RSP = 64, > + > + WCN36XX_HAL_SET_BCASTKEY_REQ = 65, > + WCN36XX_HAL_SET_BCASTKEY_RSP = 66, > + WCN36XX_HAL_DELETE_STA_CONTEXT_IND = 67, > + WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ = 68, > + WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP = 69, > + > + /* PTT interface support */ > + WCN36XX_HAL_PROCESS_PTT_REQ = 70, > + WCN36XX_HAL_PROCESS_PTT_RSP = 71, > + > + /* BTAMP related events */ > + WCN36XX_HAL_SIGNAL_BTAMP_EVENT_REQ = 72, > + WCN36XX_HAL_SIGNAL_BTAMP_EVENT_RSP = 73, > + WCN36XX_HAL_TL_HAL_FLUSH_AC_REQ = 74, > + WCN36XX_HAL_TL_HAL_FLUSH_AC_RSP = 75, > + > + WCN36XX_HAL_ENTER_IMPS_REQ = 76, > + WCN36XX_HAL_EXIT_IMPS_REQ = 77, > + WCN36XX_HAL_ENTER_BMPS_REQ = 78, > + WCN36XX_HAL_EXIT_BMPS_REQ = 79, > + WCN36XX_HAL_ENTER_UAPSD_REQ = 80, > + WCN36XX_HAL_EXIT_UAPSD_REQ = 81, > + WCN36XX_HAL_UPDATE_UAPSD_PARAM_REQ = 82, > + WCN36XX_HAL_CONFIGURE_RXP_FILTER_REQ = 83, > + WCN36XX_HAL_ADD_BCN_FILTER_REQ = 84, > + WCN36XX_HAL_REM_BCN_FILTER_REQ = 85, > + WCN36XX_HAL_ADD_WOWL_BCAST_PTRN = 86, > + WCN36XX_HAL_DEL_WOWL_BCAST_PTRN = 87, > + WCN36XX_HAL_ENTER_WOWL_REQ = 88, > + WCN36XX_HAL_EXIT_WOWL_REQ = 89, > + WCN36XX_HAL_HOST_OFFLOAD_REQ = 90, > + WCN36XX_HAL_SET_RSSI_THRESH_REQ = 91, > + WCN36XX_HAL_GET_RSSI_REQ = 92, > + WCN36XX_HAL_SET_UAPSD_AC_PARAMS_REQ = 93, > + WCN36XX_HAL_CONFIGURE_APPS_CPU_WAKEUP_STATE_REQ = 94, > + > + WCN36XX_HAL_ENTER_IMPS_RSP = 95, > + WCN36XX_HAL_EXIT_IMPS_RSP = 96, > + WCN36XX_HAL_ENTER_BMPS_RSP = 97, > + WCN36XX_HAL_EXIT_BMPS_RSP = 98, > + WCN36XX_HAL_ENTER_UAPSD_RSP = 99, > + WCN36XX_HAL_EXIT_UAPSD_RSP = 100, > + WCN36XX_HAL_SET_UAPSD_AC_PARAMS_RSP = 101, > + WCN36XX_HAL_UPDATE_UAPSD_PARAM_RSP = 102, > + WCN36XX_HAL_CONFIGURE_RXP_FILTER_RSP = 103, > + WCN36XX_HAL_ADD_BCN_FILTER_RSP = 104, > + WCN36XX_HAL_REM_BCN_FILTER_RSP = 105, > + WCN36XX_HAL_SET_RSSI_THRESH_RSP = 106, > + WCN36XX_HAL_HOST_OFFLOAD_RSP = 107, > + WCN36XX_HAL_ADD_WOWL_BCAST_PTRN_RSP = 108, > + WCN36XX_HAL_DEL_WOWL_BCAST_PTRN_RSP = 109, > + WCN36XX_HAL_ENTER_WOWL_RSP = 110, > + WCN36XX_HAL_EXIT_WOWL_RSP = 111, > + WCN36XX_HAL_RSSI_NOTIFICATION_IND = 112, > + WCN36XX_HAL_GET_RSSI_RSP = 113, > + WCN36XX_HAL_CONFIGURE_APPS_CPU_WAKEUP_STATE_RSP = 114, > + > + /* 11k related events */ > + WCN36XX_HAL_SET_MAX_TX_POWER_REQ = 115, > + WCN36XX_HAL_SET_MAX_TX_POWER_RSP = 116, > + > + /* 11R related msgs */ > + WCN36XX_HAL_AGGR_ADD_TS_REQ = 117, > + WCN36XX_HAL_AGGR_ADD_TS_RSP = 118, > + > + /* P2P WLAN_FEATURE_P2P */ > + WCN36XX_HAL_SET_P2P_GONOA_REQ = 119, > + WCN36XX_HAL_SET_P2P_GONOA_RSP = 120, > + > + /* WLAN Dump commands */ > + WCN36XX_HAL_DUMP_COMMAND_REQ = 121, > + WCN36XX_HAL_DUMP_COMMAND_RSP = 122, > + > + /* OEM_DATA FEATURE SUPPORT */ > + WCN36XX_HAL_START_OEM_DATA_REQ = 123, > + WCN36XX_HAL_START_OEM_DATA_RSP = 124, > + > + /* ADD SELF STA REQ and RSP */ > + WCN36XX_HAL_ADD_STA_SELF_REQ = 125, > + WCN36XX_HAL_ADD_STA_SELF_RSP = 126, > + > + /* DEL SELF STA SUPPORT */ > + WCN36XX_HAL_DEL_STA_SELF_REQ = 127, > + WCN36XX_HAL_DEL_STA_SELF_RSP = 128, > + > + /* Coex Indication */ > + WCN36XX_HAL_COEX_IND = 129, > + > + /* Tx Complete Indication */ > + WCN36XX_HAL_OTA_TX_COMPL_IND = 130, > + > + /* Host Suspend/resume messages */ > + WCN36XX_HAL_HOST_SUSPEND_IND = 131, > + WCN36XX_HAL_HOST_RESUME_REQ = 132, > + WCN36XX_HAL_HOST_RESUME_RSP = 133, > + > + WCN36XX_HAL_SET_TX_POWER_REQ = 134, > + WCN36XX_HAL_SET_TX_POWER_RSP = 135, > + WCN36XX_HAL_GET_TX_POWER_REQ = 136, > + WCN36XX_HAL_GET_TX_POWER_RSP = 137, > + > + WCN36XX_HAL_P2P_NOA_ATTR_IND = 138, > + > + WCN36XX_HAL_ENABLE_RADAR_DETECT_REQ = 139, > + WCN36XX_HAL_ENABLE_RADAR_DETECT_RSP = 140, > + WCN36XX_HAL_GET_TPC_REPORT_REQ = 141, > + WCN36XX_HAL_GET_TPC_REPORT_RSP = 142, > + WCN36XX_HAL_RADAR_DETECT_IND = 143, > + WCN36XX_HAL_RADAR_DETECT_INTR_IND = 144, > + WCN36XX_HAL_KEEP_ALIVE_REQ = 145, > + WCN36XX_HAL_KEEP_ALIVE_RSP = 146, > + > + /* PNO messages */ > + WCN36XX_HAL_SET_PREF_NETWORK_REQ = 147, > + WCN36XX_HAL_SET_PREF_NETWORK_RSP = 148, > + WCN36XX_HAL_SET_RSSI_FILTER_REQ = 149, > + WCN36XX_HAL_SET_RSSI_FILTER_RSP = 150, > + WCN36XX_HAL_UPDATE_SCAN_PARAM_REQ = 151, > + WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP = 152, > + WCN36XX_HAL_PREF_NETW_FOUND_IND = 153, > + > + WCN36XX_HAL_SET_TX_PER_TRACKING_REQ = 154, > + WCN36XX_HAL_SET_TX_PER_TRACKING_RSP = 155, > + WCN36XX_HAL_TX_PER_HIT_IND = 156, > + > + WCN36XX_HAL_8023_MULTICAST_LIST_REQ = 157, > + WCN36XX_HAL_8023_MULTICAST_LIST_RSP = 158, > + > + WCN36XX_HAL_SET_PACKET_FILTER_REQ = 159, > + WCN36XX_HAL_SET_PACKET_FILTER_RSP = 160, > + WCN36XX_HAL_PACKET_FILTER_MATCH_COUNT_REQ = 161, > + WCN36XX_HAL_PACKET_FILTER_MATCH_COUNT_RSP = 162, > + WCN36XX_HAL_CLEAR_PACKET_FILTER_REQ = 163, > + WCN36XX_HAL_CLEAR_PACKET_FILTER_RSP = 164, > + > + /* > + * This is temp fix. Should be removed once Host and Riva code is > + * in sync. > + */ > + WCN36XX_HAL_INIT_SCAN_CON_REQ = 165, > + > + WCN36XX_HAL_SET_POWER_PARAMS_REQ = 166, > + WCN36XX_HAL_SET_POWER_PARAMS_RSP = 167, > + > + WCN36XX_HAL_TSM_STATS_REQ = 168, > + WCN36XX_HAL_TSM_STATS_RSP = 169, > + > + /* wake reason indication (WOW) */ > + WCN36XX_HAL_WAKE_REASON_IND = 170, > + > + /* GTK offload support */ > + WCN36XX_HAL_GTK_OFFLOAD_REQ = 171, > + WCN36XX_HAL_GTK_OFFLOAD_RSP = 172, > + WCN36XX_HAL_GTK_OFFLOAD_GETINFO_REQ = 173, > + WCN36XX_HAL_GTK_OFFLOAD_GETINFO_RSP = 174, > + > + WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ = 175, > + WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP = 176, > + WCN36XX_HAL_EXCLUDE_UNENCRYPTED_IND = 177, > + > + WCN36XX_HAL_SET_THERMAL_MITIGATION_REQ = 178, > + WCN36XX_HAL_SET_THERMAL_MITIGATION_RSP = 179, > + > + WCN36XX_HAL_UPDATE_VHT_OP_MODE_REQ = 182, > + WCN36XX_HAL_UPDATE_VHT_OP_MODE_RSP = 183, > + > + WCN36XX_HAL_P2P_NOA_START_IND = 184, > + > + WCN36XX_HAL_GET_ROAM_RSSI_REQ = 185, > + WCN36XX_HAL_GET_ROAM_RSSI_RSP = 186, > + > + WCN36XX_HAL_CLASS_B_STATS_IND = 187, > + WCN36XX_HAL_DEL_BA_IND = 188, > + WCN36XX_HAL_DHCP_START_IND = 189, > + WCN36XX_HAL_DHCP_STOP_IND = 190, > + > + WCN36XX_HAL_MSG_MAX = WCN36XX_HAL_MSG_TYPE_MAX_ENUM_SIZE > +}; > + > +/* Enumeration for Version */ > +enum wcn36xx_hal_host_msg_version { > + WCN36XX_HAL_MSG_VERSION0 = 0, > + WCN36XX_HAL_MSG_VERSION1 = 1, > + /* define as 2 bytes data */ > + WCN36XX_HAL_MSG_WCNSS_CTRL_VERSION = 0x7FFF, > + WCN36XX_HAL_MSG_VERSION_MAX_FIELD = WCN36XX_HAL_MSG_WCNSS_CTRL_VERSION > +}; > + > +enum driver_type { > + DRIVER_TYPE_PRODUCTION = 0, > + DRIVER_TYPE_MFG = 1, > + DRIVER_TYPE_DVT = 2, > + DRIVER_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +enum wcn36xx_hal_stop_type { > + HAL_STOP_TYPE_SYS_RESET, > + HAL_STOP_TYPE_SYS_DEEP_SLEEP, > + HAL_STOP_TYPE_RF_KILL, > + HAL_STOP_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +enum wcn36xx_hal_sys_mode { > + HAL_SYS_MODE_NORMAL, > + HAL_SYS_MODE_LEARN, > + HAL_SYS_MODE_SCAN, > + HAL_SYS_MODE_PROMISC, > + HAL_SYS_MODE_SUSPEND_LINK, > + HAL_SYS_MODE_ROAM_SCAN, > + HAL_SYS_MODE_ROAM_SUSPEND_LINK, > + HAL_SYS_MODE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +enum phy_chan_bond_state { > + /* 20MHz IF bandwidth centered on IF carrier */ > + PHY_SINGLE_CHANNEL_CENTERED = 0, > + > + /* 40MHz IF bandwidth with lower 20MHz supporting the primary channel */ > + PHY_DOUBLE_CHANNEL_LOW_PRIMARY = 1, > + > + /* 40MHz IF bandwidth centered on IF carrier */ > + PHY_DOUBLE_CHANNEL_CENTERED = 2, > + > + /* 40MHz IF bandwidth with higher 20MHz supporting the primary ch */ > + PHY_DOUBLE_CHANNEL_HIGH_PRIMARY = 3, > + > + /* 20/40MHZ offset LOW 40/80MHZ offset CENTERED */ > + PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_CENTERED = 4, > + > + /* 20/40MHZ offset CENTERED 40/80MHZ offset CENTERED */ > + PHY_QUADRUPLE_CHANNEL_20MHZ_CENTERED_40MHZ_CENTERED = 5, > + > + /* 20/40MHZ offset HIGH 40/80MHZ offset CENTERED */ > + PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_CENTERED = 6, > + > + /* 20/40MHZ offset LOW 40/80MHZ offset LOW */ > + PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW = 7, > + > + /* 20/40MHZ offset HIGH 40/80MHZ offset LOW */ > + PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW = 8, > + > + /* 20/40MHZ offset LOW 40/80MHZ offset HIGH */ > + PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH = 9, > + > + /* 20/40MHZ offset-HIGH 40/80MHZ offset HIGH */ > + PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH = 10, > + > + PHY_CHANNEL_BONDING_STATE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* Spatial Multiplexing(SM) Power Save mode */ > +enum wcn36xx_hal_ht_mimo_state { > + /* Static SM Power Save mode */ > + WCN36XX_HAL_HT_MIMO_PS_STATIC = 0, > + > + /* Dynamic SM Power Save mode */ > + WCN36XX_HAL_HT_MIMO_PS_DYNAMIC = 1, > + > + /* reserved */ > + WCN36XX_HAL_HT_MIMO_PS_NA = 2, > + > + /* SM Power Save disabled */ > + WCN36XX_HAL_HT_MIMO_PS_NO_LIMIT = 3, > + > + WCN36XX_HAL_HT_MIMO_PS_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* each station added has a rate mode which specifies the sta attributes */ > +enum sta_rate_mode { > + STA_TAURUS = 0, > + STA_TITAN, > + STA_POLARIS, > + STA_11b, > + STA_11bg, > + STA_11a, > + STA_11n, > + STA_11ac, > + STA_INVALID_RATE_MODE = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* 1,2,5.5,11 */ > +#define WCN36XX_HAL_NUM_DSSS_RATES 4 > + > +/* 6,9,12,18,24,36,48,54 */ > +#define WCN36XX_HAL_NUM_OFDM_RATES 8 > + > +/* 72,96,108 */ > +#define WCN36XX_HAL_NUM_POLARIS_RATES 3 > + > +#define WCN36XX_HAL_MAC_MAX_SUPPORTED_MCS_SET 16 > + > +enum wcn36xx_hal_bss_type { > + WCN36XX_HAL_INFRASTRUCTURE_MODE, > + > + /* Added for softAP support */ > + WCN36XX_HAL_INFRA_AP_MODE, > + > + WCN36XX_HAL_IBSS_MODE, > + > + /* Added for BT-AMP support */ > + WCN36XX_HAL_BTAMP_STA_MODE, > + > + /* Added for BT-AMP support */ > + WCN36XX_HAL_BTAMP_AP_MODE, > + > + WCN36XX_HAL_AUTO_MODE, > + > + WCN36XX_HAL_DONOT_USE_BSS_TYPE = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +enum wcn36xx_hal_nw_type { > + WCN36XX_HAL_11A_NW_TYPE, > + WCN36XX_HAL_11B_NW_TYPE, > + WCN36XX_HAL_11G_NW_TYPE, > + WCN36XX_HAL_11N_NW_TYPE, > + WCN36XX_HAL_DONOT_USE_NW_TYPE = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +#define WCN36XX_HAL_MAC_RATESET_EID_MAX 12 > + > +enum wcn36xx_hal_ht_operating_mode { > + /* No Protection */ > + WCN36XX_HAL_HT_OP_MODE_PURE, > + > + /* Overlap Legacy device present, protection is optional */ > + WCN36XX_HAL_HT_OP_MODE_OVERLAP_LEGACY, > + > + /* No legacy device, but 20 MHz HT present */ > + WCN36XX_HAL_HT_OP_MODE_NO_LEGACY_20MHZ_HT, > + > + /* Protection is required */ > + WCN36XX_HAL_HT_OP_MODE_MIXED, > + > + WCN36XX_HAL_HT_OP_MODE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* Encryption type enum used with peer */ > +enum ani_ed_type { > + WCN36XX_HAL_ED_NONE, > + WCN36XX_HAL_ED_WEP40, > + WCN36XX_HAL_ED_WEP104, > + WCN36XX_HAL_ED_TKIP, > + WCN36XX_HAL_ED_CCMP, > + WCN36XX_HAL_ED_WPI, > + WCN36XX_HAL_ED_AES_128_CMAC, > + WCN36XX_HAL_ED_NOT_IMPLEMENTED = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +#define WLAN_MAX_KEY_RSC_LEN 16 > +#define WLAN_WAPI_KEY_RSC_LEN 16 > + > +/* MAX key length when ULA is used */ > +#define WCN36XX_HAL_MAC_MAX_KEY_LENGTH 32 > +#define WCN36XX_HAL_MAC_MAX_NUM_OF_DEFAULT_KEYS 4 > + > +/* > + * Enum to specify whether key is used for TX only, RX only or both. > + */ > +enum ani_key_direction { > + WCN36XX_HAL_TX_ONLY, > + WCN36XX_HAL_RX_ONLY, > + WCN36XX_HAL_TX_RX, > + WCN36XX_HAL_TX_DEFAULT, > + WCN36XX_HAL_DONOT_USE_KEY_DIRECTION = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +enum ani_wep_type { > + WCN36XX_HAL_WEP_STATIC, > + WCN36XX_HAL_WEP_DYNAMIC, > + WCN36XX_HAL_WEP_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +enum wcn36xx_hal_link_state { > + > + WCN36XX_HAL_LINK_IDLE_STATE = 0, > + WCN36XX_HAL_LINK_PREASSOC_STATE = 1, > + WCN36XX_HAL_LINK_POSTASSOC_STATE = 2, > + WCN36XX_HAL_LINK_AP_STATE = 3, > + WCN36XX_HAL_LINK_IBSS_STATE = 4, > + > + /* BT-AMP Case */ > + WCN36XX_HAL_LINK_BTAMP_PREASSOC_STATE = 5, > + WCN36XX_HAL_LINK_BTAMP_POSTASSOC_STATE = 6, > + WCN36XX_HAL_LINK_BTAMP_AP_STATE = 7, > + WCN36XX_HAL_LINK_BTAMP_STA_STATE = 8, > + > + /* Reserved for HAL Internal Use */ > + WCN36XX_HAL_LINK_LEARN_STATE = 9, > + WCN36XX_HAL_LINK_SCAN_STATE = 10, > + WCN36XX_HAL_LINK_FINISH_SCAN_STATE = 11, > + WCN36XX_HAL_LINK_INIT_CAL_STATE = 12, > + WCN36XX_HAL_LINK_FINISH_CAL_STATE = 13, > + WCN36XX_HAL_LINK_LISTEN_STATE = 14, > + > + WCN36XX_HAL_LINK_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +enum wcn36xx_hal_stats_mask { > + HAL_SUMMARY_STATS_INFO = 0x00000001, > + HAL_GLOBAL_CLASS_A_STATS_INFO = 0x00000002, > + HAL_GLOBAL_CLASS_B_STATS_INFO = 0x00000004, > + HAL_GLOBAL_CLASS_C_STATS_INFO = 0x00000008, > + HAL_GLOBAL_CLASS_D_STATS_INFO = 0x00000010, > + HAL_PER_STA_STATS_INFO = 0x00000020 > +}; > + > +/* BT-AMP events type */ > +enum bt_amp_event_type { > + BTAMP_EVENT_CONNECTION_START, > + BTAMP_EVENT_CONNECTION_STOP, > + BTAMP_EVENT_CONNECTION_TERMINATED, > + > + /* This and beyond are invalid values */ > + BTAMP_EVENT_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE, > +}; > + > +/* PE Statistics */ > +enum pe_stats_mask { > + PE_SUMMARY_STATS_INFO = 0x00000001, > + PE_GLOBAL_CLASS_A_STATS_INFO = 0x00000002, > + PE_GLOBAL_CLASS_B_STATS_INFO = 0x00000004, > + PE_GLOBAL_CLASS_C_STATS_INFO = 0x00000008, > + PE_GLOBAL_CLASS_D_STATS_INFO = 0x00000010, > + PE_PER_STA_STATS_INFO = 0x00000020, > + > + /* This and beyond are invalid values */ > + PE_STATS_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* > + * Configuration Parameter IDs > + */ > +#define WCN36XX_HAL_CFG_STA_ID 0 > +#define WCN36XX_HAL_CFG_CURRENT_TX_ANTENNA 1 > +#define WCN36XX_HAL_CFG_CURRENT_RX_ANTENNA 2 > +#define WCN36XX_HAL_CFG_LOW_GAIN_OVERRIDE 3 > +#define WCN36XX_HAL_CFG_POWER_STATE_PER_CHAIN 4 > +#define WCN36XX_HAL_CFG_CAL_PERIOD 5 > +#define WCN36XX_HAL_CFG_CAL_CONTROL 6 > +#define WCN36XX_HAL_CFG_PROXIMITY 7 > +#define WCN36XX_HAL_CFG_NETWORK_DENSITY 8 > +#define WCN36XX_HAL_CFG_MAX_MEDIUM_TIME 9 > +#define WCN36XX_HAL_CFG_MAX_MPDUS_IN_AMPDU 10 > +#define WCN36XX_HAL_CFG_RTS_THRESHOLD 11 > +#define WCN36XX_HAL_CFG_SHORT_RETRY_LIMIT 12 > +#define WCN36XX_HAL_CFG_LONG_RETRY_LIMIT 13 > +#define WCN36XX_HAL_CFG_FRAGMENTATION_THRESHOLD 14 > +#define WCN36XX_HAL_CFG_DYNAMIC_THRESHOLD_ZERO 15 > +#define WCN36XX_HAL_CFG_DYNAMIC_THRESHOLD_ONE 16 > +#define WCN36XX_HAL_CFG_DYNAMIC_THRESHOLD_TWO 17 > +#define WCN36XX_HAL_CFG_FIXED_RATE 18 > +#define WCN36XX_HAL_CFG_RETRYRATE_POLICY 19 > +#define WCN36XX_HAL_CFG_RETRYRATE_SECONDARY 20 > +#define WCN36XX_HAL_CFG_RETRYRATE_TERTIARY 21 > +#define WCN36XX_HAL_CFG_FORCE_POLICY_PROTECTION 22 > +#define WCN36XX_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ 23 > +#define WCN36XX_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ 24 > +#define WCN36XX_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ 25 > +#define WCN36XX_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ 26 > +#define WCN36XX_HAL_CFG_MAX_BA_SESSIONS 27 > +#define WCN36XX_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT 28 > +#define WCN36XX_HAL_CFG_PS_ENABLE_BCN_FILTER 29 > +#define WCN36XX_HAL_CFG_PS_ENABLE_RSSI_MONITOR 30 > +#define WCN36XX_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE 31 > +#define WCN36XX_HAL_CFG_STATS_PERIOD 32 > +#define WCN36XX_HAL_CFG_CFP_MAX_DURATION 33 > +#define WCN36XX_HAL_CFG_FRAME_TRANS_ENABLED 34 > +#define WCN36XX_HAL_CFG_DTIM_PERIOD 35 > +#define WCN36XX_HAL_CFG_EDCA_WMM_ACBK 36 > +#define WCN36XX_HAL_CFG_EDCA_WMM_ACBE 37 > +#define WCN36XX_HAL_CFG_EDCA_WMM_ACVO 38 > +#define WCN36XX_HAL_CFG_EDCA_WMM_ACVI 39 > +#define WCN36XX_HAL_CFG_BA_THRESHOLD_HIGH 40 > +#define WCN36XX_HAL_CFG_MAX_BA_BUFFERS 41 > +#define WCN36XX_HAL_CFG_RPE_POLLING_THRESHOLD 42 > +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC0_REG 43 > +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC1_REG 44 > +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC2_REG 45 > +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC3_REG 46 > +#define WCN36XX_HAL_CFG_NO_OF_ONCHIP_REORDER_SESSIONS 47 > +#define WCN36XX_HAL_CFG_PS_LISTEN_INTERVAL 48 > +#define WCN36XX_HAL_CFG_PS_HEART_BEAT_THRESHOLD 49 > +#define WCN36XX_HAL_CFG_PS_NTH_BEACON_FILTER 50 > +#define WCN36XX_HAL_CFG_PS_MAX_PS_POLL 51 > +#define WCN36XX_HAL_CFG_PS_MIN_RSSI_THRESHOLD 52 > +#define WCN36XX_HAL_CFG_PS_RSSI_FILTER_PERIOD 53 > +#define WCN36XX_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE 54 > +#define WCN36XX_HAL_CFG_PS_IGNORE_DTIM 55 > +#define WCN36XX_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM 56 > +#define WCN36XX_HAL_CFG_DYNAMIC_PS_POLL_VALUE 57 > +#define WCN36XX_HAL_CFG_PS_NULLDATA_AP_RESP_TIMEOUT 58 > +#define WCN36XX_HAL_CFG_TELE_BCN_WAKEUP_EN 59 > +#define WCN36XX_HAL_CFG_TELE_BCN_TRANS_LI 60 > +#define WCN36XX_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS 61 > +#define WCN36XX_HAL_CFG_TELE_BCN_MAX_LI 62 > +#define WCN36XX_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS 63 > +#define WCN36XX_HAL_CFG_TX_PWR_CTRL_ENABLE 64 > +#define WCN36XX_HAL_CFG_VALID_RADAR_CHANNEL_LIST 65 > +#define WCN36XX_HAL_CFG_TX_POWER_24_20 66 > +#define WCN36XX_HAL_CFG_TX_POWER_24_40 67 > +#define WCN36XX_HAL_CFG_TX_POWER_50_20 68 > +#define WCN36XX_HAL_CFG_TX_POWER_50_40 69 > +#define WCN36XX_HAL_CFG_MCAST_BCAST_FILTER_SETTING 70 > +#define WCN36XX_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL 71 > +#define WCN36XX_HAL_CFG_MAX_TX_POWER_2_4 72 > +#define WCN36XX_HAL_CFG_MAX_TX_POWER_5 73 > +#define WCN36XX_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD 74 > +#define WCN36XX_HAL_CFG_ENABLE_CLOSE_LOOP 75 > +#define WCN36XX_HAL_CFG_BTC_EXECUTION_MODE 76 > +#define WCN36XX_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK 77 > +#define WCN36XX_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS 78 > +#define WCN36XX_HAL_CFG_PS_TX_INACTIVITY_TIMEOUT 79 > +#define WCN36XX_HAL_CFG_WCNSS_API_VERSION 80 > +#define WCN36XX_HAL_CFG_AP_KEEPALIVE_TIMEOUT 81 > +#define WCN36XX_HAL_CFG_GO_KEEPALIVE_TIMEOUT 82 > +#define WCN36XX_HAL_CFG_ENABLE_MC_ADDR_LIST 83 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_INQ_BT 84 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_PAGE_BT 85 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_CONN_BT 86 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_LE_BT 87 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN 88 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN 89 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN 90 > +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_LE_WLAN 91 > +#define WCN36XX_HAL_CFG_BTC_DYN_MAX_LEN_BT 92 > +#define WCN36XX_HAL_CFG_BTC_DYN_MAX_LEN_WLAN 93 > +#define WCN36XX_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC 94 > +#define WCN36XX_HAL_CFG_BTC_DHCP_PROT_ON_A2DP 95 > +#define WCN36XX_HAL_CFG_BTC_DHCP_PROT_ON_SCO 96 > +#define WCN36XX_HAL_CFG_ENABLE_UNICAST_FILTER 97 > +#define WCN36XX_HAL_CFG_MAX_ASSOC_LIMIT 98 > +#define WCN36XX_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION 99 > +#define WCN36XX_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER 100 > +#define WCN36XX_HAL_CFG_ENABLE_DETECT_PS_SUPPORT 101 > +#define WCN36XX_HAL_CFG_AP_LINK_MONITOR_TIMEOUT 102 > +#define WCN36XX_HAL_CFG_BTC_DWELL_TIME_MULTIPLIER 103 > +#define WCN36XX_HAL_CFG_ENABLE_TDLS_OXYGEN_MODE 104 > +#define WCN36XX_HAL_CFG_MAX_PARAMS 105 > + > +/* Message definitons - All the messages below need to be packed */ > + > +/* Definition for HAL API Version. */ > +struct wcnss_wlan_version { > + u8 revision; > + u8 version; > + u8 minor; > + u8 major; > +} __packed; > + > +/* Definition for Encryption Keys */ > +struct wcn36xx_hal_keys { > + u8 id; > + > + /* 0 for multicast */ > + u8 unicast; > + > + enum ani_key_direction direction; > + > + /* Usage is unknown */ > + u8 rsc[WLAN_MAX_KEY_RSC_LEN]; > + > + /* =1 for authenticator,=0 for supplicant */ > + u8 pae_role; > + > + u16 length; > + u8 key[WCN36XX_HAL_MAC_MAX_KEY_LENGTH]; > +} __packed; > + > +/* > + * set_sta_key_params Moving here since it is shared by > + * configbss/setstakey msgs > + */ > +struct wcn36xx_hal_set_sta_key_params { > + /* STA Index */ > + u16 sta_index; > + > + /* Encryption Type used with peer */ > + enum ani_ed_type enc_type; > + > + /* STATIC/DYNAMIC - valid only for WEP */ > + enum ani_wep_type wep_type; > + > + /* Default WEP key, valid only for static WEP, must between 0 and 3. */ > + u8 def_wep_idx; > + > + /* valid only for non-static WEP encyrptions */ > + struct wcn36xx_hal_keys key[WCN36XX_HAL_MAC_MAX_NUM_OF_DEFAULT_KEYS]; > + > + /* > + * Control for Replay Count, 1= Single TID based replay count on Tx > + * 0 = Per TID based replay count on TX > + */ > + u8 single_tid_rc; > + > +} __packed; > + > +/* 4-byte control message header used by HAL*/ > +struct wcn36xx_hal_msg_header { > + enum wcn36xx_hal_host_msg_type msg_type:16; > + enum wcn36xx_hal_host_msg_version msg_version:16; > + u32 len; > +} __packed; > + > +/* Config format required by HAL for each CFG item*/ > +struct wcn36xx_hal_cfg { > + /* Cfg Id. The Id required by HAL is exported by HAL > + * in shared header file between UMAC and HAL.*/ > + u16 id; > + > + /* Length of the Cfg. This parameter is used to go to next cfg > + * in the TLV format.*/ > + u16 len; > + > + /* Padding bytes for unaligned address's */ > + u16 pad_bytes; > + > + /* Reserve bytes for making cfgVal to align address */ > + u16 reserve; > + > + /* Following the uCfgLen field there should be a 'uCfgLen' bytes > + * containing the uCfgValue ; u8 uCfgValue[uCfgLen] */ > +} __packed; > + > +struct wcn36xx_hal_mac_start_parameters { > + /* Drive Type - Production or FTM etc */ > + enum driver_type type; > + > + /* Length of the config buffer */ > + u32 len; > + > + /* Following this there is a TLV formatted buffer of length > + * "len" bytes containing all config values. > + * The TLV is expected to be formatted like this: > + * 0 15 31 31+CFG_LEN-1 length-1 > + * | CFG_ID | CFG_LEN | CFG_BODY | CFG_ID |......| > + */ > +} __packed; > + > +struct wcn36xx_hal_mac_start_req_msg { > + /* config buffer must start in TLV format just here */ > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_mac_start_parameters params; > +} __packed; > + > +struct wcn36xx_hal_mac_start_rsp_params { > + /* success or failure */ > + u16 status; > + > + /* Max number of STA supported by the device */ > + u8 stations; > + > + /* Max number of BSS supported by the device */ > + u8 bssids; > + > + /* API Version */ > + struct wcnss_wlan_version version; > + > + /* CRM build information */ > + u8 crm_version[WCN36XX_HAL_VERSION_LENGTH]; > + > + /* hardware/chipset/misc version information */ > + u8 wlan_version[WCN36XX_HAL_VERSION_LENGTH]; > + > +} __packed; > + > +struct wcn36xx_hal_mac_start_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_mac_start_rsp_params start_rsp_params; > +} __packed; > + > +struct wcn36xx_hal_mac_stop_req_params { > + /* The reason for which the device is being stopped */ > + enum wcn36xx_hal_stop_type reason; > + > +} __packed; > + > +struct wcn36xx_hal_mac_stop_req_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_mac_stop_req_params stop_req_params; > +} __packed; > + > +struct wcn36xx_hal_mac_stop_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +} __packed; > + > +struct wcn36xx_hal_update_cfg_req_msg { > + /* > + * Note: The length specified in tHalUpdateCfgReqMsg messages should be > + * header.msgLen = sizeof(tHalUpdateCfgReqMsg) + uConfigBufferLen > + */ > + struct wcn36xx_hal_msg_header header; > + > + /* Length of the config buffer. Allows UMAC to update multiple CFGs */ > + u32 len; > + > + /* > + * Following this there is a TLV formatted buffer of length > + * "uConfigBufferLen" bytes containing all config values. > + * The TLV is expected to be formatted like this: > + * 0 15 31 31+CFG_LEN-1 length-1 > + * | CFG_ID | CFG_LEN | CFG_BODY | CFG_ID |......| > + */ > + > +} __packed; > + > +struct wcn36xx_hal_update_cfg_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > +} __packed; > + > +/* Frame control field format (2 bytes) */ > +struct wcn36xx_hal_mac_frame_ctl { > + > +#ifndef ANI_LITTLE_BIT_ENDIAN > + > + u8 subType:4; > + u8 type:2; > + u8 protVer:2; > + > + u8 order:1; > + u8 wep:1; > + u8 moreData:1; > + u8 powerMgmt:1; > + u8 retry:1; > + u8 moreFrag:1; > + u8 fromDS:1; > + u8 toDS:1; > + > +#else > + > + u8 protVer:2; > + u8 type:2; > + u8 subType:4; > + > + u8 toDS:1; > + u8 fromDS:1; > + u8 moreFrag:1; > + u8 retry:1; > + u8 powerMgmt:1; > + u8 moreData:1; > + u8 wep:1; > + u8 order:1; > + > +#endif > + > +}; > + > +/* Sequence control field */ > +struct wcn36xx_hal_mac_seq_ctl { > + u8 fragNum:4; > + u8 seqNumLo:4; > + u8 seqNumHi:8; > +}; > + > +/* Management header format */ > +struct wcn36xx_hal_mac_mgmt_hdr { > + struct wcn36xx_hal_mac_frame_ctl fc; > + u8 durationLo; > + u8 durationHi; > + u8 da[6]; > + u8 sa[6]; > + u8 bssId[6]; > + struct wcn36xx_hal_mac_seq_ctl seqControl; > +}; > + > +/* FIXME: pronto v1 apparently has 4 */ > +#define WCN36XX_HAL_NUM_BSSID 2 > + > +/* Scan Entry to hold active BSS idx's */ > +struct wcn36xx_hal_scan_entry { > + u8 bss_index[WCN36XX_HAL_NUM_BSSID]; > + u8 active_bss_count; > +}; > + > +struct wcn36xx_hal_init_scan_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* LEARN - AP Role > + SCAN - STA Role */ > + enum wcn36xx_hal_sys_mode mode; > + > + /* BSSID of the BSS */ > + u8 bssid[ETH_ALEN]; > + > + /* Whether BSS needs to be notified */ > + u8 notify; > + > + /* Kind of frame to be used for notifying the BSS (Data Null, QoS > + * Null, or CTS to Self). Must always be a valid frame type. */ > + u8 frame_type; > + > + /* UMAC has the option of passing the MAC frame to be used for > + * notifying the BSS. If non-zero, HAL will use the MAC frame > + * buffer pointed to by macMgmtHdr. If zero, HAL will generate the > + * appropriate MAC frame based on frameType. */ > + u8 frame_len; > + > + /* Following the framelength there is a MAC frame buffer if > + * frameLength is non-zero. */ > + struct wcn36xx_hal_mac_mgmt_hdr mac_mgmt_hdr; > + > + /* Entry to hold number of active BSS idx's */ > + struct wcn36xx_hal_scan_entry scan_entry; > +}; > + > +struct wcn36xx_hal_init_scan_con_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* LEARN - AP Role > + SCAN - STA Role */ > + enum wcn36xx_hal_sys_mode mode; > + > + /* BSSID of the BSS */ > + u8 bssid[ETH_ALEN]; > + > + /* Whether BSS needs to be notified */ > + u8 notify; > + > + /* Kind of frame to be used for notifying the BSS (Data Null, QoS > + * Null, or CTS to Self). Must always be a valid frame type. */ > + u8 frame_type; > + > + /* UMAC has the option of passing the MAC frame to be used for > + * notifying the BSS. If non-zero, HAL will use the MAC frame > + * buffer pointed to by macMgmtHdr. If zero, HAL will generate the > + * appropriate MAC frame based on frameType. */ > + u8 frame_length; > + > + /* Following the framelength there is a MAC frame buffer if > + * frameLength is non-zero. */ > + struct wcn36xx_hal_mac_mgmt_hdr mac_mgmt_hdr; > + > + /* Entry to hold number of active BSS idx's */ > + struct wcn36xx_hal_scan_entry scan_entry; > + > + /* Single NoA usage in Scanning */ > + u8 use_noa; > + > + /* Indicates the scan duration (in ms) */ > + u16 scan_duration; > + > +}; > + > +struct wcn36xx_hal_init_scan_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > +} __packed; > + > +struct wcn36xx_hal_start_scan_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Indicates the channel to scan */ > + u8 scan_channel; > +} __packed; > + > +struct wcn36xx_hal_start_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u32 start_tsf[2]; > + u8 tx_mgmt_power; > + > +} __packed; > + > +struct wcn36xx_hal_end_scan_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Indicates the channel to stop scanning. Not used really. But > + * retained for symmetry with "start Scan" message. It can also > + * help in error check if needed. */ > + u8 scan_channel; > +} __packed; > + > +struct wcn36xx_hal_end_scan_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +} __packed; > + > +struct wcn36xx_hal_finish_scan_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Identifies the operational state of the AP/STA > + * LEARN - AP Role SCAN - STA Role */ > + enum wcn36xx_hal_sys_mode mode; > + > + /* Operating channel to tune to. */ > + u8 oper_channel; > + > + /* Channel Bonding state If 20/40 MHz is operational, this will > + * indicate the 40 MHz extension channel in combination with the > + * control channel */ > + enum phy_chan_bond_state cb_state; > + > + /* BSSID of the BSS */ > + u8 bssid[ETH_ALEN]; > + > + /* Whether BSS needs to be notified */ > + u8 notify; > + > + /* Kind of frame to be used for notifying the BSS (Data Null, QoS > + * Null, or CTS to Self). Must always be a valid frame type. */ > + u8 frame_type; > + > + /* UMAC has the option of passing the MAC frame to be used for > + * notifying the BSS. If non-zero, HAL will use the MAC frame > + * buffer pointed to by macMgmtHdr. If zero, HAL will generate the > + * appropriate MAC frame based on frameType. */ > + u8 frame_length; > + > + /* Following the framelength there is a MAC frame buffer if > + * frameLength is non-zero. */ > + struct wcn36xx_hal_mac_mgmt_hdr mac_mgmt_hdr; > + > + /* Entry to hold number of active BSS idx's */ > + struct wcn36xx_hal_scan_entry scan_entry; > + > +} __packed; > + > +struct wcn36xx_hal_finish_scan_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > +} __packed; > + > +enum wcn36xx_hal_rate_index { > + HW_RATE_INDEX_1MBPS = 0x82, > + HW_RATE_INDEX_2MBPS = 0x84, > + HW_RATE_INDEX_5_5MBPS = 0x8B, > + HW_RATE_INDEX_6MBPS = 0x0C, > + HW_RATE_INDEX_9MBPS = 0x12, > + HW_RATE_INDEX_11MBPS = 0x96, > + HW_RATE_INDEX_12MBPS = 0x18, > + HW_RATE_INDEX_18MBPS = 0x24, > + HW_RATE_INDEX_24MBPS = 0x30, > + HW_RATE_INDEX_36MBPS = 0x48, > + HW_RATE_INDEX_48MBPS = 0x60, > + HW_RATE_INDEX_54MBPS = 0x6C > +}; > + > +struct wcn36xx_hal_supported_rates { > + /* > + * For Self STA Entry: this represents Self Mode. > + * For Peer Stations, this represents the mode of the peer. > + * On Station: > + * > + * --this mode is updated when PE adds the Self Entry. > + * > + * -- OR when PE sends 'ADD_BSS' message and station context in BSS > + * is used to indicate the mode of the AP. > + * > + * ON AP: > + * > + * -- this mode is updated when PE sends 'ADD_BSS' and Sta entry > + * for that BSS is used to indicate the self mode of the AP. > + * > + * -- OR when a station is associated, PE sends 'ADD_STA' message > + * with this mode updated. > + */ > + > + enum sta_rate_mode op_rate_mode; > + > + /* 11b, 11a and aniLegacyRates are IE rates which gives rate in > + * unit of 500Kbps */ > + u16 dsss_rates[WCN36XX_HAL_NUM_DSSS_RATES]; > + u16 ofdm_rates[WCN36XX_HAL_NUM_OFDM_RATES]; > + u16 legacy_rates[WCN36XX_HAL_NUM_POLARIS_RATES]; > + u16 reserved; > + > + /* Taurus only supports 26 Titan Rates(no ESF/concat Rates will be > + * supported) First 26 bits are reserved for those Titan rates and > + * the last 4 bits(bit28-31) for Taurus, 2(bit26-27) bits are > + * reserved. */ > + /* Titan and Taurus Rates */ > + u32 enhanced_rate_bitmap; > + > + /* > + * 0-76 bits used, remaining reserved > + * bits 0-15 and 32 should be set. > + */ > + u8 supported_mcs_set[WCN36XX_HAL_MAC_MAX_SUPPORTED_MCS_SET]; > + > + /* > + * RX Highest Supported Data Rate defines the highest data > + * rate that the STA is able to receive, in unites of 1Mbps. > + * This value is derived from "Supported MCS Set field" inside > + * the HT capability element. > + */ > + u16 rx_highest_data_rate; > + > +} __packed; > + > +struct wcn36xx_hal_config_sta_params { > + /* BSSID of STA */ > + u8 bssid[ETH_ALEN]; > + > + /* ASSOC ID, as assigned by UMAC */ > + u16 aid; > + > + /* STA entry Type: 0 - Self, 1 - Other/Peer, 2 - BSSID, 3 - BCAST */ > + u8 type; > + > + /* Short Preamble Supported. */ > + u8 short_preamble_supported; > + > + /* MAC Address of STA */ > + u8 mac[ETH_ALEN]; > + > + /* Listen interval of the STA */ > + u16 listen_interval; > + > + /* Support for 11e/WMM */ > + u8 wmm_enabled; > + > + /* 11n HT capable STA */ > + u8 ht_capable; > + > + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ > + u8 tx_channel_width_set; > + > + /* RIFS mode 0 - NA, 1 - Allowed */ > + u8 rifs_mode; > + > + /* L-SIG TXOP Protection mechanism > + 0 - No Support, 1 - Supported > + SG - there is global field */ > + u8 lsig_txop_protection; > + > + /* Max Ampdu Size supported by STA. TPE programming. > + 0 : 8k , 1 : 16k, 2 : 32k, 3 : 64k */ > + u8 max_ampdu_size; > + > + /* Max Ampdu density. Used by RA. 3 : 0~7 : 2^(11nAMPDUdensity -4) */ > + u8 max_ampdu_density; > + > + /* Max AMSDU size 1 : 3839 bytes, 0 : 7935 bytes */ > + u8 max_amsdu_size; > + > + /* Short GI support for 40Mhz packets */ > + u8 sgi_40mhz; > + > + /* Short GI support for 20Mhz packets */ > + u8 sgi_20Mhz; > + > + /* TODO move this parameter to the end for 3680 */ > + /* These rates are the intersection of peer and self capabilities. */ > + struct wcn36xx_hal_supported_rates supported_rates; > + > + /* Robust Management Frame (RMF) enabled/disabled */ > + u8 rmf; > + > + /* The unicast encryption type in the association */ > + u32 encrypt_type; > + > + /* HAL should update the existing STA entry, if this flag is set. UMAC > + will set this flag in case of RE-ASSOC, where we want to reuse the > + old STA ID. 0 = Add, 1 = Update */ > + u8 action; > + > + /* U-APSD Flags: 1b per AC. Encoded as follows: > + b7 b6 b5 b4 b3 b2 b1 b0 = > + X X X X BE BK VI VO */ > + u8 uapsd; > + > + /* Max SP Length */ > + u8 max_sp_len; > + > + /* 11n Green Field preamble support > + 0 - Not supported, 1 - Supported */ > + u8 green_field_capable; > + > + /* MIMO Power Save mode */ > + enum wcn36xx_hal_ht_mimo_state mimo_ps; > + > + /* Delayed BA Support */ > + u8 delayed_ba_support; > + > + /* Max AMPDU duration in 32us */ > + u8 max_ampdu_duration; > + > + /* HT STA should set it to 1 if it is enabled in BSS. HT STA should > + * set it to 0 if AP does not support it. This indication is sent > + * to HAL and HAL uses this flag to pickup up appropriate 40Mhz > + * rates. */ > + u8 dsss_cck_mode_40mhz; > + > + /* Valid STA Idx when action=Update. Set to 0xFF when invalid! > + * Retained for backward compalibity with existing HAL code */ > + u8 sta_index; > + > + /* BSSID of BSS to which station is associated. Set to 0xFF when > + * invalid. Retained for backward compalibity with existing HAL > + * code */ > + u8 bssid_index; > + > + u8 p2p; > + > + /* TODO add this parameter for 3680. */ > + /* Reserved to align next field on a dword boundary */ > + /* u8 reserved; */ > +} __packed; > + > +struct wcn36xx_hal_config_sta_req_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_config_sta_params sta_params; > +} __packed; > + > +struct wcn36xx_hal_config_sta_params_v1 { > + /* BSSID of STA */ > + u8 bssid[ETH_ALEN]; > + > + /* ASSOC ID, as assigned by UMAC */ > + u16 aid; > + > + /* STA entry Type: 0 - Self, 1 - Other/Peer, 2 - BSSID, 3 - BCAST */ > + u8 type; > + > + /* Short Preamble Supported. */ > + u8 short_preamble_supported; > + > + /* MAC Address of STA */ > + u8 mac[ETH_ALEN]; > + > + /* Listen interval of the STA */ > + u16 listen_interval; > + > + /* Support for 11e/WMM */ > + u8 wmm_enabled; > + > + /* 11n HT capable STA */ > + u8 ht_capable; > + > + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ > + u8 tx_channel_width_set; > + > + /* RIFS mode 0 - NA, 1 - Allowed */ > + u8 rifs_mode; > + > + /* L-SIG TXOP Protection mechanism > + 0 - No Support, 1 - Supported > + SG - there is global field */ > + u8 lsig_txop_protection; > + > + /* Max Ampdu Size supported by STA. TPE programming. > + 0 : 8k , 1 : 16k, 2 : 32k, 3 : 64k */ > + u8 max_ampdu_size; > + > + /* Max Ampdu density. Used by RA. 3 : 0~7 : 2^(11nAMPDUdensity -4) */ > + u8 max_ampdu_density; > + > + /* Max AMSDU size 1 : 3839 bytes, 0 : 7935 bytes */ > + u8 max_amsdu_size; > + > + /* Short GI support for 40Mhz packets */ > + u8 sgi_40mhz; > + > + /* Short GI support for 20Mhz packets */ > + u8 sgi_20Mhz; > + > + /* Robust Management Frame (RMF) enabled/disabled */ > + u8 rmf; > + > + /* The unicast encryption type in the association */ > + u32 encrypt_type; > + > + /* HAL should update the existing STA entry, if this flag is set. UMAC > + will set this flag in case of RE-ASSOC, where we want to reuse the > + old STA ID. 0 = Add, 1 = Update */ > + u8 action; > + > + /* U-APSD Flags: 1b per AC. Encoded as follows: > + b7 b6 b5 b4 b3 b2 b1 b0 = > + X X X X BE BK VI VO */ > + u8 uapsd; > + > + /* Max SP Length */ > + u8 max_sp_len; > + > + /* 11n Green Field preamble support > + 0 - Not supported, 1 - Supported */ > + u8 green_field_capable; > + > + /* MIMO Power Save mode */ > + enum wcn36xx_hal_ht_mimo_state mimo_ps; > + > + /* Delayed BA Support */ > + u8 delayed_ba_support; > + > + /* Max AMPDU duration in 32us */ > + u8 max_ampdu_duration; > + > + /* HT STA should set it to 1 if it is enabled in BSS. HT STA should > + * set it to 0 if AP does not support it. This indication is sent > + * to HAL and HAL uses this flag to pickup up appropriate 40Mhz > + * rates. */ > + u8 dsss_cck_mode_40mhz; > + > + /* Valid STA Idx when action=Update. Set to 0xFF when invalid! > + * Retained for backward compalibity with existing HAL code */ > + u8 sta_index; > + > + /* BSSID of BSS to which station is associated. Set to 0xFF when > + * invalid. Retained for backward compalibity with existing HAL > + * code */ > + u8 bssid_index; > + > + u8 p2p; > + > + /* Reserved to align next field on a dword boundary */ > + u8 reserved; > + > + /* These rates are the intersection of peer and self capabilities. */ > + struct wcn36xx_hal_supported_rates supported_rates; > +} __packed; > + > +struct wcn36xx_hal_config_sta_req_msg_v1 { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_config_sta_params_v1 sta_params; > +} __packed; > + > +struct config_sta_rsp_params { > + /* success or failure */ > + u32 status; > + > + /* Station index; valid only when 'status' field value SUCCESS */ > + u8 sta_index; > + > + /* BSSID Index of BSS to which the station is associated */ > + u8 bssid_index; > + > + /* DPU Index for PTK */ > + u8 dpu_index; > + > + /* DPU Index for GTK */ > + u8 bcast_dpu_index; > + > + /* DPU Index for IGTK */ > + u8 bcast_mgmt_dpu_idx; > + > + /* PTK DPU signature */ > + u8 uc_ucast_sig; > + > + /* GTK DPU isignature */ > + u8 uc_bcast_sig; > + > + /* IGTK DPU signature */ > + u8 uc_mgmt_sig; > + > + u8 p2p; > + > +} __packed; > + > +struct wcn36xx_hal_config_sta_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + struct config_sta_rsp_params params; > +} __packed; > + > +/* Delete STA Request message */ > +struct wcn36xx_hal_delete_sta_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Index of STA to delete */ > + u8 sta_index; > + > +} __packed; > + > +/* Delete STA Response message */ > +struct wcn36xx_hal_delete_sta_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* Index of STA deleted */ > + u8 sta_id; > +} __packed; > + > +/* 12 Bytes long because this structure can be used to represent rate and > + * extended rate set IEs. The parser assume this to be at least 12 */ > +struct wcn36xx_hal_rate_set { > + u8 num_rates; > + u8 rate[WCN36XX_HAL_MAC_RATESET_EID_MAX]; > +} __packed; > + > +/* access category record */ > +struct wcn36xx_hal_aci_aifsn { > +#ifndef ANI_LITTLE_BIT_ENDIAN > + u8 rsvd:1; > + u8 aci:2; > + u8 acm:1; > + u8 aifsn:4; > +#else > + u8 aifsn:4; > + u8 acm:1; > + u8 aci:2; > + u8 rsvd:1; > +#endif > +} __packed; > + > +/* contention window size */ > +struct wcn36xx_hal_mac_cw { > +#ifndef ANI_LITTLE_BIT_ENDIAN > + u8 max:4; > + u8 min:4; > +#else > + u8 min:4; > + u8 max:4; > +#endif > +} __packed; > + > +struct wcn36xx_hal_edca_param_record { > + struct wcn36xx_hal_aci_aifsn aci; > + struct wcn36xx_hal_mac_cw cw; > + u16 txop_limit; > +} __packed; > + > +struct wcn36xx_hal_mac_ssid { > + u8 length; > + u8 ssid[32]; > +} __packed; > + > +/* Concurrency role. These are generic IDs that identify the various roles > + * in the software system. */ > +enum wcn36xx_hal_con_mode { > + WCN36XX_HAL_STA_MODE = 0, > + > + /* to support softAp mode . This is misleading. > + It means AP MODE only. */ > + WCN36XX_HAL_STA_SAP_MODE = 1, > + > + WCN36XX_HAL_P2P_CLIENT_MODE, > + WCN36XX_HAL_P2P_GO_MODE, > + WCN36XX_HAL_MONITOR_MODE, > +}; > + > +/* This is a bit pattern to be set for each mode > + * bit 0 - sta mode > + * bit 1 - ap mode > + * bit 2 - p2p client mode > + * bit 3 - p2p go mode */ > +enum wcn36xx_hal_concurrency_mode { > + HAL_STA = 1, > + HAL_SAP = 2, > + > + /* to support sta, softAp mode . This means STA+AP mode */ > + HAL_STA_SAP = 3, > + > + HAL_P2P_CLIENT = 4, > + HAL_P2P_GO = 8, > + HAL_MAX_CONCURRENCY_PERSONA = 4 > +}; > + > +struct wcn36xx_hal_config_bss_params { > + /* BSSID */ > + u8 bssid[ETH_ALEN]; > + > + /* Self Mac Address */ > + u8 self_mac_addr[ETH_ALEN]; > + > + /* BSS type */ > + enum wcn36xx_hal_bss_type bss_type; > + > + /* Operational Mode: AP =0, STA = 1 */ > + u8 oper_mode; > + > + /* Network Type */ > + enum wcn36xx_hal_nw_type nw_type; > + > + /* Used to classify PURE_11G/11G_MIXED to program MTU */ > + u8 short_slot_time_supported; > + > + /* Co-exist with 11a STA */ > + u8 lla_coexist; > + > + /* Co-exist with 11b STA */ > + u8 llb_coexist; > + > + /* Co-exist with 11g STA */ > + u8 llg_coexist; > + > + /* Coexistence with 11n STA */ > + u8 ht20_coexist; > + > + /* Non GF coexist flag */ > + u8 lln_non_gf_coexist; > + > + /* TXOP protection support */ > + u8 lsig_tx_op_protection_full_support; > + > + /* RIFS mode */ > + u8 rifs_mode; > + > + /* Beacon Interval in TU */ > + u16 beacon_interval; > + > + /* DTIM period */ > + u8 dtim_period; > + > + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ > + u8 tx_channel_width_set; > + > + /* Operating channel */ > + u8 oper_channel; > + > + /* Extension channel for channel bonding */ > + u8 ext_channel; > + > + /* Reserved to align next field on a dword boundary */ > + u8 reserved; > + > + /* TODO move sta to the end for 3680 */ > + /* Context of the station being added in HW > + * Add a STA entry for "itself" - > + * > + * On AP - Add the AP itself in an "STA context" > + * > + * On STA - Add the AP to which this STA is joining in an > + * "STA context" > + */ > + struct wcn36xx_hal_config_sta_params sta; > + /* SSID of the BSS */ > + struct wcn36xx_hal_mac_ssid ssid; > + > + /* HAL should update the existing BSS entry, if this flag is set. > + * UMAC will set this flag in case of reassoc, where we want to > + * resue the the old BSSID and still return success 0 = Add, 1 = > + * Update */ > + u8 action; > + > + /* MAC Rate Set */ > + struct wcn36xx_hal_rate_set rateset; > + > + /* Enable/Disable HT capabilities of the BSS */ > + u8 ht; > + > + /* Enable/Disable OBSS protection */ > + u8 obss_prot_enabled; > + > + /* RMF enabled/disabled */ > + u8 rmf; > + > + /* HT Operating Mode operating mode of the 802.11n STA */ > + enum wcn36xx_hal_ht_operating_mode ht_oper_mode; > + > + /* Dual CTS Protection: 0 - Unused, 1 - Used */ > + u8 dual_cts_protection; > + > + /* Probe Response Max retries */ > + u8 max_probe_resp_retry_limit; > + > + /* To Enable Hidden ssid */ > + u8 hidden_ssid; > + > + /* To Enable Disable FW Proxy Probe Resp */ > + u8 proxy_probe_resp; > + > + /* Boolean to indicate if EDCA params are valid. UMAC might not > + * have valid EDCA params or might not desire to apply EDCA params > + * during config BSS. 0 implies Not Valid ; Non-Zero implies > + * valid */ > + u8 edca_params_valid; > + > + /* EDCA Parameters for Best Effort Access Category */ > + struct wcn36xx_hal_edca_param_record acbe; > + > + /* EDCA Parameters forBackground Access Category */ > + struct wcn36xx_hal_edca_param_record acbk; > + > + /* EDCA Parameters for Video Access Category */ > + struct wcn36xx_hal_edca_param_record acvi; > + > + /* EDCA Parameters for Voice Access Category */ > + struct wcn36xx_hal_edca_param_record acvo; > + > + /* Ext Bss Config Msg if set */ > + u8 ext_set_sta_key_param_valid; > + > + /* SetStaKeyParams for ext bss msg */ > + struct wcn36xx_hal_set_sta_key_params ext_set_sta_key_param; > + > + /* Persona for the BSS can be STA,AP,GO,CLIENT value same as enum > + * wcn36xx_hal_con_mode */ > + u8 wcn36xx_hal_persona; > + > + u8 spectrum_mgt_enable; > + > + /* HAL fills in the tx power used for mgmt frames in txMgmtPower */ > + s8 tx_mgmt_power; > + > + /* maxTxPower has max power to be used after applying the power > + * constraint if any */ > + s8 max_tx_power; > +} __packed; > + > +struct wcn36xx_hal_config_bss_req_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_config_bss_params bss_params; > +} __packed; > + > +struct wcn36xx_hal_config_bss_params_v1 { > + /* BSSID */ > + u8 bssid[ETH_ALEN]; > + > + /* Self Mac Address */ > + u8 self_mac_addr[ETH_ALEN]; > + > + /* BSS type */ > + enum wcn36xx_hal_bss_type bss_type; > + > + /* Operational Mode: AP =0, STA = 1 */ > + u8 oper_mode; > + > + /* Network Type */ > + enum wcn36xx_hal_nw_type nw_type; > + > + /* Used to classify PURE_11G/11G_MIXED to program MTU */ > + u8 short_slot_time_supported; > + > + /* Co-exist with 11a STA */ > + u8 lla_coexist; > + > + /* Co-exist with 11b STA */ > + u8 llb_coexist; > + > + /* Co-exist with 11g STA */ > + u8 llg_coexist; > + > + /* Coexistence with 11n STA */ > + u8 ht20_coexist; > + > + /* Non GF coexist flag */ > + u8 lln_non_gf_coexist; > + > + /* TXOP protection support */ > + u8 lsig_tx_op_protection_full_support; > + > + /* RIFS mode */ > + u8 rifs_mode; > + > + /* Beacon Interval in TU */ > + u16 beacon_interval; > + > + /* DTIM period */ > + u8 dtim_period; > + > + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ > + u8 tx_channel_width_set; > + > + /* Operating channel */ > + u8 oper_channel; > + > + /* Extension channel for channel bonding */ > + u8 ext_channel; > + > + /* Reserved to align next field on a dword boundary */ > + u8 reserved; > + > + /* SSID of the BSS */ > + struct wcn36xx_hal_mac_ssid ssid; > + > + /* HAL should update the existing BSS entry, if this flag is set. > + * UMAC will set this flag in case of reassoc, where we want to > + * resue the the old BSSID and still return success 0 = Add, 1 = > + * Update */ > + u8 action; > + > + /* MAC Rate Set */ > + struct wcn36xx_hal_rate_set rateset; > + > + /* Enable/Disable HT capabilities of the BSS */ > + u8 ht; > + > + /* Enable/Disable OBSS protection */ > + u8 obss_prot_enabled; > + > + /* RMF enabled/disabled */ > + u8 rmf; > + > + /* HT Operating Mode operating mode of the 802.11n STA */ > + enum wcn36xx_hal_ht_operating_mode ht_oper_mode; > + > + /* Dual CTS Protection: 0 - Unused, 1 - Used */ > + u8 dual_cts_protection; > + > + /* Probe Response Max retries */ > + u8 max_probe_resp_retry_limit; > + > + /* To Enable Hidden ssid */ > + u8 hidden_ssid; > + > + /* To Enable Disable FW Proxy Probe Resp */ > + u8 proxy_probe_resp; > + > + /* Boolean to indicate if EDCA params are valid. UMAC might not > + * have valid EDCA params or might not desire to apply EDCA params > + * during config BSS. 0 implies Not Valid ; Non-Zero implies > + * valid */ > + u8 edca_params_valid; > + > + /* EDCA Parameters for Best Effort Access Category */ > + struct wcn36xx_hal_edca_param_record acbe; > + > + /* EDCA Parameters forBackground Access Category */ > + struct wcn36xx_hal_edca_param_record acbk; > + > + /* EDCA Parameters for Video Access Category */ > + struct wcn36xx_hal_edca_param_record acvi; > + > + /* EDCA Parameters for Voice Access Category */ > + struct wcn36xx_hal_edca_param_record acvo; > + > + /* Ext Bss Config Msg if set */ > + u8 ext_set_sta_key_param_valid; > + > + /* SetStaKeyParams for ext bss msg */ > + struct wcn36xx_hal_set_sta_key_params ext_set_sta_key_param; > + > + /* Persona for the BSS can be STA,AP,GO,CLIENT value same as enum > + * wcn36xx_hal_con_mode */ > + u8 wcn36xx_hal_persona; > + > + u8 spectrum_mgt_enable; > + > + /* HAL fills in the tx power used for mgmt frames in txMgmtPower */ > + s8 tx_mgmt_power; > + > + /* maxTxPower has max power to be used after applying the power > + * constraint if any */ > + s8 max_tx_power; > + > + /* Context of the station being added in HW > + * Add a STA entry for "itself" - > + * > + * On AP - Add the AP itself in an "STA context" > + * > + * On STA - Add the AP to which this STA is joining in an > + * "STA context" > + */ > + struct wcn36xx_hal_config_sta_params_v1 sta; > +} __packed; > + > +struct wcn36xx_hal_config_bss_req_msg_v1 { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_config_bss_params_v1 bss_params; > +} __packed; > + > +struct wcn36xx_hal_config_bss_rsp_params { > + /* Success or Failure */ > + u32 status; > + > + /* BSS index allocated by HAL */ > + u8 bss_index; > + > + /* DPU descriptor index for PTK */ > + u8 dpu_desc_index; > + > + /* PTK DPU signature */ > + u8 ucast_dpu_signature; > + > + /* DPU descriptor index for GTK */ > + u8 bcast_dpu_desc_indx; > + > + /* GTK DPU signature */ > + u8 bcast_dpu_signature; > + > + /* DPU descriptor for IGTK */ > + u8 mgmt_dpu_desc_index; > + > + /* IGTK DPU signature */ > + u8 mgmt_dpu_signature; > + > + /* Station Index for BSS entry */ > + u8 bss_sta_index; > + > + /* Self station index for this BSS */ > + u8 bss_self_sta_index; > + > + /* Bcast station for buffering bcast frames in AP role */ > + u8 bss_bcast_sta_idx; > + > + /* MAC Address of STA(PEER/SELF) in staContext of configBSSReq */ > + u8 mac[ETH_ALEN]; > + > + /* HAL fills in the tx power used for mgmt frames in this field. */ > + s8 tx_mgmt_power; > + > +} __packed; > + > +struct wcn36xx_hal_config_bss_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_config_bss_rsp_params bss_rsp_params; > +} __packed; > + > +struct wcn36xx_hal_delete_bss_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* BSS index to be deleted */ > + u8 bss_index; > + > +} __packed; > + > +struct wcn36xx_hal_delete_bss_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Success or Failure */ > + u32 status; > + > + /* BSS index that has been deleted */ > + u8 bss_index; > + > +} __packed; > + > +struct wcn36xx_hal_join_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Indicates the BSSID to which STA is going to associate */ > + u8 bssid[ETH_ALEN]; > + > + /* Indicates the channel to switch to. */ > + u8 channel; > + > + /* Self STA MAC */ > + u8 self_sta_mac_addr[ETH_ALEN]; > + > + /* Local power constraint */ > + u8 local_power_constraint; > + > + /* Secondary channel offset */ > + enum phy_chan_bond_state secondary_channel_offset; > + > + /* link State */ > + enum wcn36xx_hal_link_state link_state; > + > + /* Max TX power */ > + s8 max_tx_power; > +} __packed; > + > +struct wcn36xx_hal_join_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* HAL fills in the tx power used for mgmt frames in this field */ > + u8 tx_mgmt_power; > +} __packed; > + > +struct post_assoc_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + struct wcn36xx_hal_config_sta_params sta_params; > + struct wcn36xx_hal_config_bss_params bss_params; > +}; > + > +struct post_assoc_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + struct config_sta_rsp_params sta_rsp_params; > + struct wcn36xx_hal_config_bss_rsp_params bss_rsp_params; > +}; > + > +/* This is used to create a set of WEP keys for a given BSS. */ > +struct wcn36xx_hal_set_bss_key_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* BSS Index of the BSS */ > + u8 bss_idx; > + > + /* Encryption Type used with peer */ > + enum ani_ed_type enc_type; > + > + /* Number of keys */ > + u8 num_keys; > + > + /* Array of keys. */ > + struct wcn36xx_hal_keys keys[WCN36XX_HAL_MAC_MAX_NUM_OF_DEFAULT_KEYS]; > + > + /* Control for Replay Count, 1= Single TID based replay count on Tx > + * 0 = Per TID based replay count on TX */ > + u8 single_tid_rc; > +} __packed; > + > +/* tagged version of set bss key */ > +struct wcn36xx_hal_set_bss_key_req_msg_tagged { > + struct wcn36xx_hal_set_bss_key_req_msg Msg; > + u32 tag; > +} __packed; > + > +struct wcn36xx_hal_set_bss_key_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +} __packed; > + > +/* > + * This is used configure the key information on a given station. > + * When the sec_type is WEP40 or WEP104, the def_wep_idx is used to locate > + * a preconfigured key from a BSS the station assoicated with; otherwise > + * a new key descriptor is created based on the key field. > + */ > +struct wcn36xx_hal_set_sta_key_req_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_set_sta_key_params set_sta_key_params; > +} __packed; > + > +struct wcn36xx_hal_set_sta_key_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +} __packed; > + > +struct wcn36xx_hal_remove_bss_key_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* BSS Index of the BSS */ > + u8 bss_idx; > + > + /* Encryption Type used with peer */ > + enum ani_ed_type enc_type; > + > + /* Key Id */ > + u8 key_id; > + > + /* STATIC/DYNAMIC. Used in Nullifying in Key Descriptors for > + * Static/Dynamic keys */ > + enum ani_wep_type wep_type; > +} __packed; > + > +struct wcn36xx_hal_remove_bss_key_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +} __packed; > + > +/* > + * This is used by PE to Remove the key information on a given station. > + */ > +struct wcn36xx_hal_remove_sta_key_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* STA Index */ > + u16 sta_idx; > + > + /* Encryption Type used with peer */ > + enum ani_ed_type enc_type; > + > + /* Key Id */ > + u8 key_id; > + > + /* Whether to invalidate the Broadcast key or Unicast key. In case > + * of WEP, the same key is used for both broadcast and unicast. */ > + u8 unicast; > + > +} __packed; > + > +struct wcn36xx_hal_remove_sta_key_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /*success or failure */ > + u32 status; > + > +} __packed; > + > +#ifdef FEATURE_OEM_DATA_SUPPORT > + > +#ifndef OEM_DATA_REQ_SIZE > +#define OEM_DATA_REQ_SIZE 134 > +#endif > + > +#ifndef OEM_DATA_RSP_SIZE > +#define OEM_DATA_RSP_SIZE 1968 > +#endif > + > +struct start_oem_data_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u32 status; > + tSirMacAddr self_mac_addr; > + u8 oem_data_req[OEM_DATA_REQ_SIZE]; > + > +}; > + > +struct start_oem_data_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 oem_data_rsp[OEM_DATA_RSP_SIZE]; > +}; > + > +#endif > + > +struct wcn36xx_hal_switch_channel_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Channel number */ > + u8 channel_number; > + > + /* Local power constraint */ > + u8 local_power_constraint; > + > + /* Secondary channel offset */ > + enum phy_chan_bond_state secondary_channel_offset; > + > + /* HAL fills in the tx power used for mgmt frames in this field. */ > + u8 tx_mgmt_power; > + > + /* Max TX power */ > + u8 max_tx_power; > + > + /* Self STA MAC */ > + u8 self_sta_mac_addr[ETH_ALEN]; > + > + /* VO WIFI comment: BSSID needed to identify session. As the > + * request has power constraints, this should be applied only to > + * that session Since MTU timing and EDCA are sessionized, this > + * struct needs to be sessionized and bssid needs to be out of the > + * VOWifi feature flag V IMP: Keep bssId field at the end of this > + * msg. It is used to mantain backward compatbility by way of > + * ignoring if using new host/old FW or old host/new FW since it is > + * at the end of this struct > + */ > + u8 bssid[ETH_ALEN]; > +} __packed; > + > +struct wcn36xx_hal_switch_channel_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Status */ > + u32 status; > + > + /* Channel number - same as in request */ > + u8 channel_number; > + > + /* HAL fills in the tx power used for mgmt frames in this field */ > + u8 tx_mgmt_power; > + > + /* BSSID needed to identify session - same as in request */ > + u8 bssid[ETH_ALEN]; > + > +} __packed; > + > +struct update_edca_params_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /*BSS Index */ > + u16 bss_index; > + > + /* Best Effort */ > + struct wcn36xx_hal_edca_param_record acbe; > + > + /* Background */ > + struct wcn36xx_hal_edca_param_record acbk; > + > + /* Video */ > + struct wcn36xx_hal_edca_param_record acvi; > + > + /* Voice */ > + struct wcn36xx_hal_edca_param_record acvo; > +}; > + > +struct update_edca_params_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct dpu_stats_params { > + /* Index of STA to which the statistics */ > + u16 sta_index; > + > + /* Encryption mode */ > + u8 enc_mode; > + > + /* status */ > + u32 status; > + > + /* Statistics */ > + u32 send_blocks; > + u32 recv_blocks; > + u32 replays; > + u8 mic_error_cnt; > + u32 prot_excl_cnt; > + u16 format_err_cnt; > + u16 un_decryptable_cnt; > + u32 decrypt_err_cnt; > + u32 decrypt_ok_cnt; > +}; > + > +struct wcn36xx_hal_stats_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Valid STA Idx for per STA stats request */ > + u32 sta_id; > + > + /* Categories of stats requested as specified in eHalStatsMask */ > + u32 stats_mask; > +}; > + > +struct ani_summary_stats_info { > + /* Total number of packets(per AC) that were successfully > + * transmitted with retries */ > + u32 retry_cnt[4]; > + > + /* The number of MSDU packets and MMPDU frames per AC that the > + * 802.11 station successfully transmitted after more than one > + * retransmission attempt */ > + u32 multiple_retry_cnt[4]; > + > + /* Total number of packets(per AC) that were successfully > + * transmitted (with and without retries, including multi-cast, > + * broadcast) */ > + u32 tx_frm_cnt[4]; > + > + /* Total number of packets that were successfully received (after > + * appropriate filter rules including multi-cast, broadcast) */ > + u32 rx_frm_cnt; > + > + /* Total number of duplicate frames received successfully */ > + u32 frm_dup_cnt; > + > + /* Total number packets(per AC) failed to transmit */ > + u32 fail_cnt[4]; > + > + /* Total number of RTS/CTS sequence failures for transmission of a > + * packet */ > + u32 rts_fail_cnt; > + > + /* Total number packets failed transmit because of no ACK from the > + * remote entity */ > + u32 ack_fail_cnt; > + > + /* Total number of RTS/CTS sequence success for transmission of a > + * packet */ > + u32 rts_succ_cnt; > + > + /* The sum of the receive error count and dropped-receive-buffer > + * error count. HAL will provide this as a sum of (FCS error) + > + * (Fail get BD/PDU in HW) */ > + u32 rx_discard_cnt; > + > + /* > + * The receive error count. HAL will provide the RxP FCS error > + * global counter. */ > + u32 rx_error_cnt; > + > + /* The sum of the transmit-directed byte count, transmit-multicast > + * byte count and transmit-broadcast byte count. HAL will sum TPE > + * UC/MC/BCAST global counters to provide this. */ > + u32 tx_byte_cnt; > +}; > + > +/* defines tx_rate_flags */ > +enum tx_rate_info { > + /* Legacy rates */ > + HAL_TX_RATE_LEGACY = 0x1, > + > + /* HT20 rates */ > + HAL_TX_RATE_HT20 = 0x2, > + > + /* HT40 rates */ > + HAL_TX_RATE_HT40 = 0x4, > + > + /* Rate with Short guard interval */ > + HAL_TX_RATE_SGI = 0x8, > + > + /* Rate with Long guard interval */ > + HAL_TX_RATE_LGI = 0x10 > +}; > + > +struct ani_global_class_a_stats_info { > + /* The number of MPDU frames received by the 802.11 station for > + * MSDU packets or MMPDU frames */ > + u32 rx_frag_cnt; > + > + /* The number of MPDU frames received by the 802.11 station for > + * MSDU packets or MMPDU frames when a promiscuous packet filter > + * was enabled */ > + u32 promiscuous_rx_frag_cnt; > + > + /* The receiver input sensitivity referenced to a FER of 8% at an > + * MPDU length of 1024 bytes at the antenna connector. Each element > + * of the array shall correspond to a supported rate and the order > + * shall be the same as the supporteRates parameter. */ > + u32 rx_input_sensitivity; > + > + /* The maximum transmit power in dBm upto one decimal. for eg: if > + * it is 10.5dBm, the value would be 105 */ > + u32 max_pwr; > + > + /* Number of times the receiver failed to synchronize with the > + * incoming signal after detecting the sync in the preamble of the > + * transmitted PLCP protocol data unit. */ > + u32 sync_fail_cnt; > + > + /* Legacy transmit rate, in units of 500 kbit/sec, for the most > + * recently transmitted frame */ > + u32 tx_rate; > + > + /* mcs index for HT20 and HT40 rates */ > + u32 mcs_index; > + > + /* to differentiate between HT20 and HT40 rates; short and long > + * guard interval */ > + u32 tx_rate_flags; > +}; > + > +struct ani_global_security_stats { > + /* The number of unencrypted received MPDU frames that the MAC > + * layer discarded when the IEEE 802.11 dot11ExcludeUnencrypted > + * management information base (MIB) object is enabled */ > + u32 rx_wep_unencrypted_frm_cnt; > + > + /* The number of received MSDU packets that that the 802.11 station > + * discarded because of MIC failures */ > + u32 rx_mic_fail_cnt; > + > + /* The number of encrypted MPDU frames that the 802.11 station > + * failed to decrypt because of a TKIP ICV error */ > + u32 tkip_icv_err; > + > + /* The number of received MPDU frames that the 802.11 discarded > + * because of an invalid AES-CCMP format */ > + u32 aes_ccmp_format_err; > + > + /* The number of received MPDU frames that the 802.11 station > + * discarded because of the AES-CCMP replay protection procedure */ > + u32 aes_ccmp_replay_cnt; > + > + /* The number of received MPDU frames that the 802.11 station > + * discarded because of errors detected by the AES-CCMP decryption > + * algorithm */ > + u32 aes_ccmp_decrpt_err; > + > + /* The number of encrypted MPDU frames received for which a WEP > + * decryption key was not available on the 802.11 station */ > + u32 wep_undecryptable_cnt; > + > + /* The number of encrypted MPDU frames that the 802.11 station > + * failed to decrypt because of a WEP ICV error */ > + u32 wep_icv_err; > + > + /* The number of received encrypted packets that the 802.11 station > + * successfully decrypted */ > + u32 rx_decrypt_succ_cnt; > + > + /* The number of encrypted packets that the 802.11 station failed > + * to decrypt */ > + u32 rx_decrypt_fail_cnt; > +}; > + > +struct ani_global_class_b_stats_info { > + struct ani_global_security_stats uc_stats; > + struct ani_global_security_stats mc_bc_stats; > +}; > + > +struct ani_global_class_c_stats_info { > + /* This counter shall be incremented for a received A-MSDU frame > + * with the stations MAC address in the address 1 field or an > + * A-MSDU frame with a group address in the address 1 field */ > + u32 rx_amsdu_cnt; > + > + /* This counter shall be incremented when the MAC receives an AMPDU > + * from the PHY */ > + u32 rx_ampdu_cnt; > + > + /* This counter shall be incremented when a Frame is transmitted > + * only on the primary channel */ > + u32 tx_20_frm_cnt; > + > + /* This counter shall be incremented when a Frame is received only > + * on the primary channel */ > + u32 rx_20_frm_cnt; > + > + /* This counter shall be incremented by the number of MPDUs > + * received in the A-MPDU when an A-MPDU is received */ > + u32 rx_mpdu_in_ampdu_cnt; > + > + /* This counter shall be incremented when an MPDU delimiter has a > + * CRC error when this is the first CRC error in the received AMPDU > + * or when the previous delimiter has been decoded correctly */ > + u32 ampdu_delimiter_crc_err; > +}; > + > +struct ani_per_sta_stats_info { > + /* The number of MPDU frames that the 802.11 station transmitted > + * and acknowledged through a received 802.11 ACK frame */ > + u32 tx_frag_cnt[4]; > + > + /* This counter shall be incremented when an A-MPDU is transmitted */ > + u32 tx_ampdu_cnt; > + > + /* This counter shall increment by the number of MPDUs in the AMPDU > + * when an A-MPDU is transmitted */ > + u32 tx_mpdu_in_ampdu_cnt; > +}; > + > +struct wcn36xx_hal_stats_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Success or Failure */ > + u32 status; > + > + /* STA Idx */ > + u32 sta_index; > + > + /* Categories of STATS being returned as per eHalStatsMask */ > + u32 stats_mask; > + > + /* message type is same as the request type */ > + u16 msg_type; > + > + /* length of the entire request, includes the pStatsBuf length too */ > + u16 msg_len; > +}; > + > +struct wcn36xx_hal_set_link_state_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bssid[ETH_ALEN]; > + enum wcn36xx_hal_link_state state; > + u8 self_mac_addr[ETH_ALEN]; > + > +} __packed; > + > +struct set_link_state_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +/* TSPEC Params */ > +struct wcn36xx_hal_ts_info_tfc { > +#ifndef ANI_LITTLE_BIT_ENDIAN > + u16 ackPolicy:2; > + u16 userPrio:3; > + u16 psb:1; > + u16 aggregation:1; > + u16 accessPolicy:2; > + u16 direction:2; > + u16 tsid:4; > + u16 trafficType:1; > +#else > + u16 trafficType:1; > + u16 tsid:4; > + u16 direction:2; > + u16 accessPolicy:2; > + u16 aggregation:1; > + u16 psb:1; > + u16 userPrio:3; > + u16 ackPolicy:2; > +#endif > +}; > + > +/* Flag to schedule the traffic type */ > +struct wcn36xx_hal_ts_info_sch { > +#ifndef ANI_LITTLE_BIT_ENDIAN > + u8 rsvd:7; > + u8 schedule:1; > +#else > + u8 schedule:1; > + u8 rsvd:7; > +#endif > +}; > + > +/* Traffic and scheduling info */ > +struct wcn36xx_hal_ts_info { > + struct wcn36xx_hal_ts_info_tfc traffic; > + struct wcn36xx_hal_ts_info_sch schedule; > +}; > + > +/* Information elements */ > +struct wcn36xx_hal_tspec_ie { > + u8 type; > + u8 length; > + struct wcn36xx_hal_ts_info ts_info; > + u16 nom_msdu_size; > + u16 max_msdu_size; > + u32 min_svc_interval; > + u32 max_svc_interval; > + u32 inact_interval; > + u32 suspend_interval; > + u32 svc_start_time; > + u32 min_data_rate; > + u32 mean_data_rate; > + u32 peak_data_rate; > + u32 max_burst_sz; > + u32 delay_bound; > + u32 min_phy_rate; > + u16 surplus_bw; > + u16 medium_time; > +}; > + > +struct add_ts_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Station Index */ > + u16 sta_index; > + > + /* TSPEC handler uniquely identifying a TSPEC for a STA in a BSS */ > + u16 tspec_index; > + > + /* To program TPE with required parameters */ > + struct wcn36xx_hal_tspec_ie tspec; > + > + /* U-APSD Flags: 1b per AC. Encoded as follows: > + b7 b6 b5 b4 b3 b2 b1 b0 = > + X X X X BE BK VI VO */ > + u8 uapsd; > + > + /* These parameters are for all the access categories */ > + > + /* Service Interval */ > + u32 service_interval[WCN36XX_HAL_MAX_AC]; > + > + /* Suspend Interval */ > + u32 suspend_interval[WCN36XX_HAL_MAX_AC]; > + > + /* Delay Interval */ > + u32 delay_interval[WCN36XX_HAL_MAX_AC]; > +}; > + > +struct add_rs_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct del_ts_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Station Index */ > + u16 sta_index; > + > + /* TSPEC identifier uniquely identifying a TSPEC for a STA in a BSS */ > + u16 tspec_index; > + > + /* To lookup station id using the mac address */ > + u8 bssid[ETH_ALEN]; > +}; > + > +struct del_ts_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +/* End of TSpec Parameters */ > + > +/* Start of BLOCK ACK related Parameters */ > + > +struct wcn36xx_hal_add_ba_session_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Station Index */ > + u16 sta_index; > + > + /* Peer MAC Address */ > + u8 mac_addr[ETH_ALEN]; > + > + /* ADDBA Action Frame dialog token > + HAL will not interpret this object */ > + u8 dialog_token; > + > + /* TID for which the BA is being setup > + This identifies the TC or TS of interest */ > + u8 tid; > + > + /* 0 - Delayed BA (Not supported) > + 1 - Immediate BA */ > + u8 policy; > + > + /* Indicates the number of buffers for this TID (baTID) > + NOTE - This is the requested buffer size. When this > + is processed by HAL and subsequently by HDD, it is > + possible that HDD may change this buffer size. Any > + change in the buffer size should be noted by PE and > + advertized appropriately in the ADDBA response */ > + u16 buffer_size; > + > + /* BA timeout in TU's 0 means no timeout will occur */ > + u16 timeout; > + > + /* b0..b3 - Fragment Number - Always set to 0 > + b4..b15 - Starting Sequence Number of first MSDU > + for which this BA is setup */ > + u16 ssn; > + > + /* ADDBA direction > + 1 - Originator > + 0 - Recipient */ > + u8 direction; > +} __packed; > + > +struct wcn36xx_hal_add_ba_session_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* Dialog token */ > + u8 dialog_token; > + > + /* TID for which the BA session has been setup */ > + u8 ba_tid; > + > + /* BA Buffer Size allocated for the current BA session */ > + u8 ba_buffer_size; > + > + u8 ba_session_id; > + > + /* Reordering Window buffer */ > + u8 win_size; > + > + /* Station Index to id the sta */ > + u8 sta_index; > + > + /* Starting Sequence Number */ > + u16 ssn; > +} __packed; > + > +struct wcn36xx_hal_add_ba_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Session Id */ > + u8 session_id; > + > + /* Reorder Window Size */ > + u8 win_size; > +/* Old FW 1.2.2.4 does not support this*/ > +#ifdef FEATURE_ON_CHIP_REORDERING > + u8 reordering_done_on_chip; > +#endif > +} __packed; > + > +struct wcn36xx_hal_add_ba_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* Dialog token */ > + u8 dialog_token; > +} __packed; > + > +struct add_ba_info { > + u16 ba_enable:1; > + u16 starting_seq_num:12; > + u16 reserved:3; > +}; > + > +struct wcn36xx_hal_trigger_ba_rsp_candidate { > + u8 sta_addr[ETH_ALEN]; > + struct add_ba_info ba_info[STACFG_MAX_TC]; > +} __packed; > + > +struct wcn36xx_hal_trigget_ba_req_candidate { > + u8 sta_index; > + u8 tid_bitmap; > +} __packed; > + > +struct wcn36xx_hal_trigger_ba_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Session Id */ > + u8 session_id; > + > + /* baCandidateCnt is followed by trigger BA > + * Candidate List(tTriggerBaCandidate) > + */ > + u16 candidate_cnt; > + > +} __packed; > + > +struct wcn36xx_hal_trigger_ba_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* TO SUPPORT BT-AMP */ > + u8 bssid[ETH_ALEN]; > + > + /* success or failure */ > + u32 status; > + > + /* baCandidateCnt is followed by trigger BA > + * Rsp Candidate List(tTriggerRspBaCandidate) > + */ > + u16 candidate_cnt; > +} __packed; > + > +struct wcn36xx_hal_del_ba_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Station Index */ > + u16 sta_index; > + > + /* TID for which the BA session is being deleted */ > + u8 tid; > + > + /* DELBA direction > + 1 - Originator > + 0 - Recipient */ > + u8 direction; > +} __packed; > + > +struct wcn36xx_hal_del_ba_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +} __packed; > + > +struct tsm_stats_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Traffic Id */ > + u8 tid; > + > + u8 bssid[ETH_ALEN]; > +}; > + > +struct tsm_stats_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /*success or failure */ > + u32 status; > + > + /* Uplink Packet Queue delay */ > + u16 uplink_pkt_queue_delay; > + > + /* Uplink Packet Queue delay histogram */ > + u16 uplink_pkt_queue_delay_hist[4]; > + > + /* Uplink Packet Transmit delay */ > + u32 uplink_pkt_tx_delay; > + > + /* Uplink Packet loss */ > + u16 uplink_pkt_loss; > + > + /* Uplink Packet count */ > + u16 uplink_pkt_count; > + > + /* Roaming count */ > + u8 roaming_count; > + > + /* Roaming Delay */ > + u16 roaming_delay; > +}; > + > +struct set_key_done_msg { > + struct wcn36xx_hal_msg_header header; > + > + /*bssid of the keys */ > + u8 bssidx; > + u8 enc_type; > +}; > + > +struct wcn36xx_hal_nv_img_download_req_msg { > + /* Note: The length specified in wcn36xx_hal_nv_img_download_req_msg > + * messages should be > + * header.len = sizeof(wcn36xx_hal_nv_img_download_req_msg) + > + * nv_img_buffer_size */ > + struct wcn36xx_hal_msg_header header; > + > + /* Fragment sequence number of the NV Image. Note that NV Image > + * might not fit into one message due to size limitation of the SMD > + * channel FIFO. UMAC can hence choose to chop the NV blob into > + * multiple fragments starting with seqeunce number 0, 1, 2 etc. > + * The last fragment MUST be indicated by marking the > + * isLastFragment field to 1. Note that all the NV blobs would be > + * concatenated together by HAL without any padding bytes in > + * between.*/ > + u16 frag_number; > + > + /* Is this the last fragment? When set to 1 it indicates that no > + * more fragments will be sent by UMAC and HAL can concatenate all > + * the NV blobs rcvd & proceed with the parsing. HAL would generate > + * a WCN36XX_HAL_DOWNLOAD_NV_RSP to the WCN36XX_HAL_DOWNLOAD_NV_REQ > + * after it receives each fragment */ > + u16 last_fragment; > + > + /* NV Image size (number of bytes) */ > + u32 nv_img_buffer_size; > + > + /* Following the 'nv_img_buffer_size', there should be > + * nv_img_buffer_size bytes of NV Image i.e. > + * u8[nv_img_buffer_size] */ > +} __packed; > + > +struct wcn36xx_hal_nv_img_download_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Success or Failure. HAL would generate a > + * WCN36XX_HAL_DOWNLOAD_NV_RSP after each fragment */ > + u32 status; > +} __packed; > + > +struct wcn36xx_hal_nv_store_ind { > + /* Note: The length specified in tHalNvStoreInd messages should be > + * header.msgLen = sizeof(tHalNvStoreInd) + nvBlobSize */ > + struct wcn36xx_hal_msg_header header; > + > + /* NV Item */ > + u32 table_id; > + > + /* Size of NV Blob */ > + u32 nv_blob_size; > + > + /* Following the 'nvBlobSize', there should be nvBlobSize bytes of > + * NV blob i.e. u8[nvBlobSize] */ > +}; > + > +/* End of Block Ack Related Parameters */ > + > +#define WCN36XX_HAL_CIPHER_SEQ_CTR_SIZE 6 > + > +/* Definition for MIC failure indication MAC reports this each time a MIC > + * failure occures on Rx TKIP packet > + */ > +struct mic_failure_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bssid[ETH_ALEN]; > + > + /* address used to compute MIC */ > + u8 src_addr[ETH_ALEN]; > + > + /* transmitter address */ > + u8 ta_addr[ETH_ALEN]; > + > + u8 dst_addr[ETH_ALEN]; > + > + u8 multicast; > + > + /* first byte of IV */ > + u8 iv1; > + > + /* second byte of IV */ > + u8 key_id; > + > + /* sequence number */ > + u8 tsc[WCN36XX_HAL_CIPHER_SEQ_CTR_SIZE]; > + > + /* receive address */ > + u8 rx_addr[ETH_ALEN]; > +}; > + > +struct update_vht_op_mode_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u16 op_mode; > + u16 sta_id; > +}; > + > +struct update_vht_op_mode_params_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + u32 status; > +}; > + > +struct update_beacon_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bss_index; > + > + /* shortPreamble mode. HAL should update all the STA rates when it > + * receives this message */ > + u8 short_preamble; > + > + /* short Slot time. */ > + u8 short_slot_time; > + > + /* Beacon Interval */ > + u16 beacon_interval; > + > + /* Protection related */ > + u8 lla_coexist; > + u8 llb_coexist; > + u8 llg_coexist; > + u8 ht20_coexist; > + u8 lln_non_gf_coexist; > + u8 lsig_tx_op_protection_full_support; > + u8 rifs_mode; > + > + u16 param_change_bitmap; > +}; > + > +struct update_beacon_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + u32 status; > +}; > + > +struct wcn36xx_hal_send_beacon_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* length of the template. */ > + u32 beacon_length; > + > + /* Beacon data. */ > + u8 beacon[BEACON_TEMPLATE_SIZE]; > + > + u8 bssid[ETH_ALEN]; > + > + /* TIM IE offset from the beginning of the template. */ > + u32 tim_ie_offset; > + > + /* P2P IE offset from the begining of the template */ > + u16 p2p_ie_offset; > +} __packed; > + > +struct send_beacon_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + u32 status; > +} __packed; > + > +struct enable_radar_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bssid[ETH_ALEN]; > + u8 channel; > +}; > + > +struct enable_radar_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Link Parameters */ > + u8 bssid[ETH_ALEN]; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct radar_detect_intr_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 radar_det_channel; > +}; > + > +struct radar_detect_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* channel number in which the RADAR detected */ > + u8 channel_number; > + > + /* RADAR pulse width in usecond */ > + u16 radar_pulse_width; > + > + /* Number of RADAR pulses */ > + u16 num_radar_pulse; > +}; > + > +struct wcn36xx_hal_get_tpc_report_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 sta[ETH_ALEN]; > + u8 dialog_token; > + u8 txpower; > +}; > + > +struct wcn36xx_hal_get_tpc_report_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_send_probe_resp_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 probe_resp_template[BEACON_TEMPLATE_SIZE]; > + u32 probe_resp_template_len; > + u32 proxy_probe_req_valid_ie_bmap[8]; > + u8 bssid[ETH_ALEN]; > +}; > + > +struct send_probe_resp_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct send_unknown_frame_rx_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_delete_sta_context_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u16 aid; > + u16 sta_id; > + > + /* TO SUPPORT BT-AMP */ > + u8 bssid[ETH_ALEN]; > + > + /* HAL copies bssid from the sta table. */ > + u8 addr2[ETH_ALEN]; > + > + /* To unify the keepalive / unknown A2 / tim-based disa */ > + u16 reason_code; > +} __packed; > + > +struct indicate_del_sta { > + struct wcn36xx_hal_msg_header header; > + u8 aid; > + u8 sta_index; > + u8 bss_index; > + u8 reason_code; > + u32 status; > +}; > + > +struct bt_amp_event_msg { > + struct wcn36xx_hal_msg_header header; > + > + enum bt_amp_event_type btAmpEventType; > +}; > + > +struct bt_amp_event_rsp { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct tl_hal_flush_ac_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Station Index. originates from HAL */ > + u8 sta_id; > + > + /* TID for which the transmit queue is being flushed */ > + u8 tid; > +}; > + > +struct tl_hal_flush_ac_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Station Index. originates from HAL */ > + u8 sta_id; > + > + /* TID for which the transmit queue is being flushed */ > + u8 tid; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_enter_imps_req_msg { > + struct wcn36xx_hal_msg_header header; > +}; > + > +struct wcn36xx_hal_exit_imps_req { > + struct wcn36xx_hal_msg_header header; > +}; > + > +struct wcn36xx_hal_enter_bmps_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bss_index; > + > + /* TBTT value derived from the last beacon */ > +#ifndef BUILD_QWPTTSTATIC > + u64 tbtt; > +#endif > + u8 dtim_count; > + > + /* DTIM period given to HAL during association may not be valid, if > + * association is based on ProbeRsp instead of beacon. */ > + u8 dtim_period; > + > + /* For CCX and 11R Roaming */ > + u32 rssi_filter_period; > + > + u32 num_beacon_per_rssi_average; > + u8 rssi_filter_enable; > +} __packed; > + > +struct wcn36xx_hal_exit_bmps_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 send_data_null; > + u8 bss_index; > +} __packed; > + > +struct wcn36xx_hal_missed_beacon_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bss_index; > +} __packed; > + > +/* Beacon Filtering data structures */ > + > +/* The above structure would be followed by multiple of below mentioned > + * structure > + */ > +struct beacon_filter_ie { > + u8 element_id; > + u8 check_ie_presence; > + u8 offset; > + u8 value; > + u8 bitmask; > + u8 ref; > +}; > + > +struct wcn36xx_hal_add_bcn_filter_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u16 capability_info; > + u16 capability_mask; > + u16 beacon_interval; > + u16 ie_num; > + u8 bss_index; > + u8 reserved; > +}; > + > +struct wcn36xx_hal_rem_bcn_filter_req { > + struct wcn36xx_hal_msg_header header; > + > + u8 ie_Count; > + u8 rem_ie_id[1]; > +}; > + > +#define WCN36XX_HAL_IPV4_ARP_REPLY_OFFLOAD 0 > +#define WCN36XX_HAL_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD 1 > +#define WCN36XX_HAL_IPV6_NS_OFFLOAD 2 > +#define WCN36XX_HAL_IPV6_ADDR_LEN 16 > +#define WCN36XX_HAL_OFFLOAD_DISABLE 0 > +#define WCN36XX_HAL_OFFLOAD_ENABLE 1 > +#define WCN36XX_HAL_OFFLOAD_BCAST_FILTER_ENABLE 0x2 > +#define WCN36XX_HAL_OFFLOAD_ARP_AND_BCAST_FILTER_ENABLE \ > + (HAL_OFFLOAD_ENABLE|HAL_OFFLOAD_BCAST_FILTER_ENABLE) > + > +struct wcn36xx_hal_ns_offload_params { > + u8 src_ipv6_addr[WCN36XX_HAL_IPV6_ADDR_LEN]; > + u8 self_ipv6_addr[WCN36XX_HAL_IPV6_ADDR_LEN]; > + > + /* Only support 2 possible Network Advertisement IPv6 address */ > + u8 target_ipv6_addr1[WCN36XX_HAL_IPV6_ADDR_LEN]; > + u8 target_ipv6_addr2[WCN36XX_HAL_IPV6_ADDR_LEN]; > + > + u8 self_addr[ETH_ALEN]; > + u8 src_ipv6_addr_valid:1; > + u8 target_ipv6_addr1_valid:1; > + u8 target_ipv6_addr2_valid:1; > + u8 reserved1:5; > + > + /* make it DWORD aligned */ > + u8 reserved2; > + > + /* slot index for this offload */ > + u32 slot_index; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_host_offload_req { > + u8 offload_Type; > + > + /* enable or disable */ > + u8 enable; > + > + union { > + u8 host_ipv4_addr[4]; > + u8 host_ipv6_addr[WCN36XX_HAL_IPV6_ADDR_LEN]; > + } u; > +}; > + > +struct wcn36xx_hal_host_offload_req_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_host_offload_req host_offload_params; > + struct wcn36xx_hal_ns_offload_params ns_offload_params; > +}; > + > +/* Packet Types. */ > +#define WCN36XX_HAL_KEEP_ALIVE_NULL_PKT 1 > +#define WCN36XX_HAL_KEEP_ALIVE_UNSOLICIT_ARP_RSP 2 > + > +/* Enable or disable keep alive */ > +#define WCN36XX_HAL_KEEP_ALIVE_DISABLE 0 > +#define WCN36XX_HAL_KEEP_ALIVE_ENABLE 1 > +#define WCN36XX_KEEP_ALIVE_TIME_PERIOD 30 /* unit: s */ > + > +/* Keep Alive request. */ > +struct wcn36xx_hal_keep_alive_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 packet_type; > + u32 time_period; > + u8 host_ipv4_addr[WCN36XX_HAL_IPV4_ADDR_LEN]; > + u8 dest_ipv4_addr[WCN36XX_HAL_IPV4_ADDR_LEN]; > + u8 dest_addr[ETH_ALEN]; > + u8 bss_index; > +} __packed; > + > +struct wcn36xx_hal_rssi_threshold_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + s8 threshold1:8; > + s8 threshold2:8; > + s8 threshold3:8; > + u8 thres1_pos_notify:1; > + u8 thres1_neg_notify:1; > + u8 thres2_pos_notify:1; > + u8 thres2_neg_notify:1; > + u8 thres3_pos_notify:1; > + u8 thres3_neg_notify:1; > + u8 reserved10:2; > +}; > + > +struct wcn36xx_hal_enter_uapsd_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bk_delivery:1; > + u8 be_delivery:1; > + u8 vi_delivery:1; > + u8 vo_delivery:1; > + u8 bk_trigger:1; > + u8 be_trigger:1; > + u8 vi_trigger:1; > + u8 vo_trigger:1; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_exit_uapsd_req_msg { > + struct wcn36xx_hal_msg_header header; > + u8 bss_index; > +}; > + > +#define WCN36XX_HAL_WOWL_BCAST_PATTERN_MAX_SIZE 128 > +#define WCN36XX_HAL_WOWL_BCAST_MAX_NUM_PATTERNS 16 > + > +struct wcn36xx_hal_wowl_add_bcast_ptrn_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Pattern ID */ > + u8 id; > + > + /* Pattern byte offset from beginning of the 802.11 packet to start > + * of the wake-up pattern */ > + u8 byte_Offset; > + > + /* Non-Zero Pattern size */ > + u8 size; > + > + /* Pattern */ > + u8 pattern[WCN36XX_HAL_WOWL_BCAST_PATTERN_MAX_SIZE]; > + > + /* Non-zero pattern mask size */ > + u8 mask_size; > + > + /* Pattern mask */ > + u8 mask[WCN36XX_HAL_WOWL_BCAST_PATTERN_MAX_SIZE]; > + > + /* Extra pattern */ > + u8 extra[WCN36XX_HAL_WOWL_BCAST_PATTERN_MAX_SIZE]; > + > + /* Extra pattern mask */ > + u8 mask_extra[WCN36XX_HAL_WOWL_BCAST_PATTERN_MAX_SIZE]; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_wow_del_bcast_ptrn_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Pattern ID of the wakeup pattern to be deleted */ > + u8 id; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_wowl_enter_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Enables/disables magic packet filtering */ > + u8 magic_packet_enable; > + > + /* Magic pattern */ > + u8 magic_pattern[ETH_ALEN]; > + > + /* Enables/disables packet pattern filtering in firmware. Enabling > + * this flag enables broadcast pattern matching in Firmware. If > + * unicast pattern matching is also desired, > + * ucUcastPatternFilteringEnable flag must be set tot true as well > + */ > + u8 pattern_filtering_enable; > + > + /* Enables/disables unicast packet pattern filtering. This flag > + * specifies whether we want to do pattern match on unicast packets > + * as well and not just broadcast packets. This flag has no effect > + * if the ucPatternFilteringEnable (main controlling flag) is set > + * to false > + */ > + u8 ucast_pattern_filtering_enable; > + > + /* This configuration is valid only when magicPktEnable=1. It > + * requests hardware to wake up when it receives the Channel Switch > + * Action Frame. > + */ > + u8 wow_channel_switch_receive; > + > + /* This configuration is valid only when magicPktEnable=1. It > + * requests hardware to wake up when it receives the > + * Deauthentication Frame. > + */ > + u8 wow_deauth_receive; > + > + /* This configuration is valid only when magicPktEnable=1. It > + * requests hardware to wake up when it receives the Disassociation > + * Frame. > + */ > + u8 wow_disassoc_receive; > + > + /* This configuration is valid only when magicPktEnable=1. It > + * requests hardware to wake up when it has missed consecutive > + * beacons. This is a hardware register configuration (NOT a > + * firmware configuration). > + */ > + u8 wow_max_missed_beacons; > + > + /* This configuration is valid only when magicPktEnable=1. This is > + * a timeout value in units of microsec. It requests hardware to > + * unconditionally wake up after it has stayed in WoWLAN mode for > + * some time. Set 0 to disable this feature. > + */ > + u8 wow_max_sleep; > + > + /* This configuration directs the WoW packet filtering to look for > + * EAP-ID requests embedded in EAPOL frames and use this as a wake > + * source. > + */ > + u8 wow_eap_id_request_enable; > + > + /* This configuration directs the WoW packet filtering to look for > + * EAPOL-4WAY requests and use this as a wake source. > + */ > + u8 wow_eapol_4way_enable; > + > + /* This configuration allows a host wakeup on an network scan > + * offload match. > + */ > + u8 wow_net_scan_offload_match; > + > + /* This configuration allows a host wakeup on any GTK rekeying > + * error. > + */ > + u8 wow_gtk_rekey_error; > + > + /* This configuration allows a host wakeup on BSS connection loss. > + */ > + u8 wow_bss_connection_loss; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_wowl_exit_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_get_rssi_req_msg { > + struct wcn36xx_hal_msg_header header; > +}; > + > +struct wcn36xx_hal_get_roam_rssi_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Valid STA Idx for per STA stats request */ > + u32 sta_id; > +}; > + > +struct wcn36xx_hal_set_uapsd_ac_params_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* STA index */ > + u8 sta_idx; > + > + /* Access Category */ > + u8 ac; > + > + /* User Priority */ > + u8 up; > + > + /* Service Interval */ > + u32 service_interval; > + > + /* Suspend Interval */ > + u32 suspend_interval; > + > + /* Delay Interval */ > + u32 delay_interval; > +}; > + > +struct wcn36xx_hal_configure_rxp_filter_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 set_mcst_bcst_filter_setting; > + u8 set_mcst_bcst_filter; > +}; > + > +struct wcn36xx_hal_enter_imps_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_exit_imps_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_enter_bmps_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u8 bss_index; > +} __packed; > + > +struct wcn36xx_hal_exit_bmps_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u8 bss_index; > +} __packed; > + > +struct wcn36xx_hal_enter_uapsd_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_exit_uapsd_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_rssi_notification_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u32 rssi_thres1_pos_cross:1; > + u32 rssi_thres1_neg_cross:1; > + u32 rssi_thres2_pos_cross:1; > + u32 rssi_thres2_neg_cross:1; > + u32 rssi_thres3_pos_cross:1; > + u32 rssi_thres3_neg_cross:1; > + u32 avg_rssi:8; > + u32 reserved:18; > + > +}; > + > +struct wcn36xx_hal_get_rssio_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + s8 rssi; > + > +}; > + > +struct wcn36xx_hal_get_roam_rssi_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u8 sta_id; > + s8 rssi; > +}; > + > +struct wcn36xx_hal_wowl_enter_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_wowl_exit_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_add_bcn_filter_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_rem_bcn_filter_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_add_wowl_bcast_ptrn_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_del_wowl_bcast_ptrn_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_host_offload_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_keep_alive_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_set_rssi_thresh_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_set_uapsd_ac_params_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_configure_rxp_filter_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct set_max_tx_pwr_req { > + struct wcn36xx_hal_msg_header header; > + > + /* BSSID is needed to identify which session issued this request. > + * As the request has power constraints, this should be applied > + * only to that session */ > + u8 bssid[ETH_ALEN]; > + > + u8 self_addr[ETH_ALEN]; > + > + /* In request, power == MaxTx power to be used. */ > + u8 power; > +}; > + > +struct set_max_tx_pwr_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* power == tx power used for management frames */ > + u8 power; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct set_tx_pwr_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* TX Power in milli watts */ > + u32 tx_power; > + > + u8 bss_index; > +}; > + > +struct set_tx_pwr_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct get_tx_pwr_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 sta_id; > +}; > + > +struct get_tx_pwr_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* TX Power in milli watts */ > + u32 tx_power; > +}; > + > +struct set_p2p_gonoa_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 opp_ps; > + u32 ct_window; > + u8 count; > + u32 duration; > + u32 interval; > + u32 single_noa_duration; > + u8 ps_selection; > +}; > + > +struct set_p2p_gonoa_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_add_sta_self_req { > + struct wcn36xx_hal_msg_header header; > + > + u8 self_addr[ETH_ALEN]; > + u32 status; > +} __packed; > + > +struct wcn36xx_hal_add_sta_self_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* Self STA Index */ > + u8 self_sta_index; > + > + /* DPU Index (IGTK, PTK, GTK all same) */ > + u8 dpu_index; > + > + /* DPU Signature */ > + u8 dpu_signature; > +} __packed; > + > +struct wcn36xx_hal_del_sta_self_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 self_addr[ETH_ALEN]; > +} __packed; > + > +struct wcn36xx_hal_del_sta_self_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /*success or failure */ > + u32 status; > + > + u8 self_addr[ETH_ALEN]; > +} __packed; > + > +struct aggr_add_ts_req { > + struct wcn36xx_hal_msg_header header; > + > + /* Station Index */ > + u16 sta_idx; > + > + /* TSPEC handler uniquely identifying a TSPEC for a STA in a BSS. > + * This will carry the bitmap with the bit positions representing > + * different AC.s */ > + u16 tspec_index; > + > + /* Tspec info per AC To program TPE with required parameters */ > + struct wcn36xx_hal_tspec_ie tspec[WCN36XX_HAL_MAX_AC]; > + > + /* U-APSD Flags: 1b per AC. Encoded as follows: > + b7 b6 b5 b4 b3 b2 b1 b0 = > + X X X X BE BK VI VO */ > + u8 uapsd; > + > + /* These parameters are for all the access categories */ > + > + /* Service Interval */ > + u32 service_interval[WCN36XX_HAL_MAX_AC]; > + > + /* Suspend Interval */ > + u32 suspend_interval[WCN36XX_HAL_MAX_AC]; > + > + /* Delay Interval */ > + u32 delay_interval[WCN36XX_HAL_MAX_AC]; > +}; > + > +struct aggr_add_ts_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status0; > + > + /* FIXME PRIMA for future use for 11R */ > + u32 status1; > +}; > + > +struct wcn36xx_hal_configure_apps_cpu_wakeup_state_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 is_apps_cpu_awake; > +}; > + > +struct wcn36xx_hal_configure_apps_cpu_wakeup_state_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_dump_cmd_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u32 arg1; > + u32 arg2; > + u32 arg3; > + u32 arg4; > + u32 arg5; > +} __packed; > + > +struct wcn36xx_hal_dump_cmd_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* Length of the responce message */ > + u32 rsp_length; > + > + /* FIXME: Currently considering the the responce will be less than > + * 100bytes */ > + u8 rsp_buffer[DUMPCMD_RSP_BUFFER]; > +} __packed; > + > +#define WLAN_COEX_IND_DATA_SIZE (4) > +#define WLAN_COEX_IND_TYPE_DISABLE_HB_MONITOR (0) > +#define WLAN_COEX_IND_TYPE_ENABLE_HB_MONITOR (1) > + > +struct coex_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Coex Indication Type */ > + u32 type; > + > + /* Coex Indication Data */ > + u32 data[WLAN_COEX_IND_DATA_SIZE]; > +}; > + > +struct wcn36xx_hal_tx_compl_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Tx Complete Indication Success or Failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_wlan_host_suspend_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u32 configured_mcst_bcst_filter_setting; > + u32 active_session_count; > +}; > + > +struct wcn36xx_hal_wlan_exclude_unencrpted_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 dot11_exclude_unencrypted; > + u8 bssid[ETH_ALEN]; > +}; > + > +struct noa_attr_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 index; > + u8 opp_ps_flag; > + u16 ctwin; > + > + u16 noa1_interval_count; > + u16 bss_index; > + u32 noa1_duration; > + u32 noa1_interval; > + u32 noa1_starttime; > + > + u16 noa2_interval_count; > + u16 reserved2; > + u32 noa2_duration; > + u32 noa2_interval; > + u32 noa2_start_time; > + > + u32 status; > +}; > + > +struct noa_start_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u32 status; > + u32 bss_index; > +}; > + > +struct wcn36xx_hal_wlan_host_resume_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 configured_mcst_bcst_filter_setting; > +}; > + > +struct wcn36xx_hal_host_resume_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +struct wcn36xx_hal_del_ba_ind_msg { > + struct wcn36xx_hal_msg_header header; > + > + u16 sta_idx; > + > + /* Peer MAC Address, whose BA session has timed out */ > + u8 peer_addr[ETH_ALEN]; > + > + /* TID for which a BA session timeout is being triggered */ > + u8 ba_tid; > + > + /* DELBA direction > + * 1 - Originator > + * 0 - Recipient > + */ > + u8 direction; > + > + u32 reason_code; > + > + /* TO SUPPORT BT-AMP */ > + u8 bssid[ETH_ALEN]; > +}; > + > +/* PNO Messages */ > + > +/* Max number of channels that a network can be found on */ > +#define WCN36XX_HAL_PNO_MAX_NETW_CHANNELS 26 > + > +/* Max number of channels that a network can be found on */ > +#define WCN36XX_HAL_PNO_MAX_NETW_CHANNELS_EX 60 > + > +/* Maximum numbers of networks supported by PNO */ > +#define WCN36XX_HAL_PNO_MAX_SUPP_NETWORKS 16 > + > +/* The number of scan time intervals that can be programmed into PNO */ > +#define WCN36XX_HAL_PNO_MAX_SCAN_TIMERS 10 > + > +/* Maximum size of the probe template */ > +#define WCN36XX_HAL_PNO_MAX_PROBE_SIZE 450 > + > +/* Type of PNO enabling: > + * > + * Immediate - scanning will start immediately and PNO procedure will be > + * repeated based on timer > + * > + * Suspend - scanning will start at suspend > + * > + * Resume - scanning will start on system resume > + */ > +enum pno_mode { > + PNO_MODE_IMMEDIATE, > + PNO_MODE_ON_SUSPEND, > + PNO_MODE_ON_RESUME, > + PNO_MODE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* Authentication type */ > +enum auth_type { > + AUTH_TYPE_ANY = 0, > + AUTH_TYPE_OPEN_SYSTEM = 1, > + > + /* Upper layer authentication types */ > + AUTH_TYPE_WPA = 2, > + AUTH_TYPE_WPA_PSK = 3, > + > + AUTH_TYPE_RSN = 4, > + AUTH_TYPE_RSN_PSK = 5, > + AUTH_TYPE_FT_RSN = 6, > + AUTH_TYPE_FT_RSN_PSK = 7, > + AUTH_TYPE_WAPI_WAI_CERTIFICATE = 8, > + AUTH_TYPE_WAPI_WAI_PSK = 9, > + > + AUTH_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* Encryption type */ > +enum ed_type { > + ED_ANY = 0, > + ED_NONE = 1, > + ED_WEP = 2, > + ED_TKIP = 3, > + ED_CCMP = 4, > + ED_WPI = 5, > + > + ED_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* SSID broadcast type */ > +enum ssid_bcast_type { > + BCAST_UNKNOWN = 0, > + BCAST_NORMAL = 1, > + BCAST_HIDDEN = 2, > + > + BCAST_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE > +}; > + > +/* The network description for which PNO will have to look for */ > +struct network_type { > + /* SSID of the BSS */ > + struct wcn36xx_hal_mac_ssid ssid; > + > + /* Authentication type for the network */ > + enum auth_type authentication; > + > + /* Encryption type for the network */ > + enum ed_type encryption; > + > + /* Indicate the channel on which the Network can be found 0 - if > + * all channels */ > + u8 channel_count; > + u8 channels[WCN36XX_HAL_PNO_MAX_NETW_CHANNELS]; > + > + /* Indicates the RSSI threshold for the network to be considered */ > + u8 rssi_threshold; > +}; > + > +struct scan_timer { > + /* How much it should wait */ > + u32 value; > + > + /* How many times it should repeat that wait value 0 - keep using > + * this timer until PNO is disabled */ > + u32 repeat; > + > + /* e.g: 2 3 4 0 - it will wait 2s between consecutive scans for 3 > + * times - after that it will wait 4s between consecutive scans > + * until disabled */ > +}; > + > +/* The network parameters to be sent to the PNO algorithm */ > +struct scan_timers_type { > + /* set to 0 if you wish for PNO to use its default telescopic timer */ > + u8 count; > + > + /* A set value represents the amount of time that PNO will wait > + * between two consecutive scan procedures If the desired is for a > + * uniform timer that fires always at the exact same interval - one > + * single value is to be set If there is a desire for a more > + * complex - telescopic like timer multiple values can be set - > + * once PNO reaches the end of the array it will continue scanning > + * at intervals presented by the last value */ > + struct scan_timer values[WCN36XX_HAL_PNO_MAX_SCAN_TIMERS]; > +}; > + > +/* Preferred network list request */ > +struct set_pref_netw_list_req { > + struct wcn36xx_hal_msg_header header; > + > + /* Enable PNO */ > + u32 enable; > + > + /* Immediate, On Suspend, On Resume */ > + enum pno_mode mode; > + > + /* Number of networks sent for PNO */ > + u32 networks_count; > + > + /* The networks that PNO needs to look for */ > + struct network_type networks[WCN36XX_HAL_PNO_MAX_SUPP_NETWORKS]; > + > + /* The scan timers required for PNO */ > + struct scan_timers_type scan_timers; > + > + /* Probe template for 2.4GHz band */ > + u16 band_24g_probe_size; > + u8 band_24g_probe_template[WCN36XX_HAL_PNO_MAX_PROBE_SIZE]; > + > + /* Probe template for 5GHz band */ > + u16 band_5g_probe_size; > + u8 band_5g_probe_template[WCN36XX_HAL_PNO_MAX_PROBE_SIZE]; > +}; > + > +/* The network description for which PNO will have to look for */ > +struct network_type_new { > + /* SSID of the BSS */ > + struct wcn36xx_hal_mac_ssid ssid; > + > + /* Authentication type for the network */ > + enum auth_type authentication; > + > + /* Encryption type for the network */ > + enum ed_type encryption; > + > + /* SSID broadcast type, normal, hidden or unknown */ > + enum ssid_bcast_type bcast_network_type; > + > + /* Indicate the channel on which the Network can be found 0 - if > + * all channels */ > + u8 channel_count; > + u8 channels[WCN36XX_HAL_PNO_MAX_NETW_CHANNELS]; > + > + /* Indicates the RSSI threshold for the network to be considered */ > + u8 rssi_threshold; > +}; > + > +/* Preferred network list request new */ > +struct set_pref_netw_list_req_new { > + struct wcn36xx_hal_msg_header header; > + > + /* Enable PNO */ > + u32 enable; > + > + /* Immediate, On Suspend, On Resume */ > + enum pno_mode mode; > + > + /* Number of networks sent for PNO */ > + u32 networks_count; > + > + /* The networks that PNO needs to look for */ > + struct network_type_new networks[WCN36XX_HAL_PNO_MAX_SUPP_NETWORKS]; > + > + /* The scan timers required for PNO */ > + struct scan_timers_type scan_timers; > + > + /* Probe template for 2.4GHz band */ > + u16 band_24g_probe_size; > + u8 band_24g_probe_template[WCN36XX_HAL_PNO_MAX_PROBE_SIZE]; > + > + /* Probe template for 5GHz band */ > + u16 band_5g_probe_size; > + u8 band_5g_probe_template[WCN36XX_HAL_PNO_MAX_PROBE_SIZE]; > +}; > + > +/* Preferred network list response */ > +struct set_pref_netw_list_resp { > + struct wcn36xx_hal_msg_header header; > + > + /* status of the request - just to indicate that PNO has > + * acknowledged the request and will start scanning */ > + u32 status; > +}; > + > +/* Preferred network found indication */ > +struct pref_netw_found_ind { > + > + struct wcn36xx_hal_msg_header header; > + > + /* Network that was found with the highest RSSI */ > + struct wcn36xx_hal_mac_ssid ssid; > + > + /* Indicates the RSSI */ > + u8 rssi; > +}; > + > +/* RSSI Filter request */ > +struct set_rssi_filter_req { > + struct wcn36xx_hal_msg_header header; > + > + /* RSSI Threshold */ > + u8 rssi_threshold; > +}; > + > +/* Set RSSI filter resp */ > +struct set_rssi_filter_resp { > + struct wcn36xx_hal_msg_header header; > + > + /* status of the request */ > + u32 status; > +}; > + > +/* Update scan params - sent from host to PNO to be used during PNO > + * scanningx */ > +struct wcn36xx_hal_update_scan_params_req { > + > + struct wcn36xx_hal_msg_header header; > + > + /* Host setting for 11d */ > + u8 dot11d_enabled; > + > + /* Lets PNO know that host has determined the regulatory domain */ > + u8 dot11d_resolved; > + > + /* Channels on which PNO is allowed to scan */ > + u8 channel_count; > + u8 channels[WCN36XX_HAL_PNO_MAX_NETW_CHANNELS]; > + > + /* Minimum channel time */ > + u16 active_min_ch_time; > + > + /* Maximum channel time */ > + u16 active_max_ch_time; > + > + /* Minimum channel time */ > + u16 passive_min_ch_time; > + > + /* Maximum channel time */ > + u16 passive_max_ch_time; > + > + /* Cb State */ > + enum phy_chan_bond_state state; > +} __packed; > + > +/* Update scan params - sent from host to PNO to be used during PNO > + * scanningx */ > +struct update_scan_params_req_ex { > + > + struct wcn36xx_hal_msg_header header; > + > + /* Host setting for 11d */ > + u8 dot11d_enabled; > + > + /* Lets PNO know that host has determined the regulatory domain */ > + u8 dot11d_resolved; > + > + /* Channels on which PNO is allowed to scan */ > + u8 channel_count; > + u8 channels[WCN36XX_HAL_PNO_MAX_NETW_CHANNELS_EX]; > + > + /* Minimum channel time */ > + u16 active_min_ch_time; > + > + /* Maximum channel time */ > + u16 active_max_ch_time; > + > + /* Minimum channel time */ > + u16 passive_min_ch_time; > + > + /* Maximum channel time */ > + u16 passive_max_ch_time; > + > + /* Cb State */ > + enum phy_chan_bond_state state; > +}; > + > +/* Update scan params - sent from host to PNO to be used during PNO > + * scanningx */ > +struct wcn36xx_hal_update_scan_params_resp { > + > + struct wcn36xx_hal_msg_header header; > + > + /* status of the request */ > + u32 status; > +} __packed; > + > +struct wcn36xx_hal_set_tx_per_tracking_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* 0: disable, 1:enable */ > + u8 tx_per_tracking_enable; > + > + /* Check period, unit is sec. */ > + u8 tx_per_tracking_period; > + > + /* (Fail TX packet)/(Total TX packet) ratio, the unit is 10%. */ > + u8 tx_per_tracking_ratio; > + > + /* A watermark of check number, once the tx packet exceed this > + * number, we do the check, default is 5 */ > + u32 tx_per_tracking_watermark; > +}; > + > +struct wcn36xx_hal_set_tx_per_tracking_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > +}; > + > +struct tx_per_hit_ind_msg { > + struct wcn36xx_hal_msg_header header; > +}; > + > +/* Packet Filtering Definitions Begin */ > +#define WCN36XX_HAL_PROTOCOL_DATA_LEN 8 > +#define WCN36XX_HAL_MAX_NUM_MULTICAST_ADDRESS 240 > +#define WCN36XX_HAL_MAX_NUM_FILTERS 20 > +#define WCN36XX_HAL_MAX_CMP_PER_FILTER 10 > + > +enum wcn36xx_hal_receive_packet_filter_type { > + HAL_RCV_FILTER_TYPE_INVALID, > + HAL_RCV_FILTER_TYPE_FILTER_PKT, > + HAL_RCV_FILTER_TYPE_BUFFER_PKT, > + HAL_RCV_FILTER_TYPE_MAX_ENUM_SIZE > +}; > + > +enum wcn36xx_hal_rcv_pkt_flt_protocol_type { > + HAL_FILTER_PROTO_TYPE_INVALID, > + HAL_FILTER_PROTO_TYPE_MAC, > + HAL_FILTER_PROTO_TYPE_ARP, > + HAL_FILTER_PROTO_TYPE_IPV4, > + HAL_FILTER_PROTO_TYPE_IPV6, > + HAL_FILTER_PROTO_TYPE_UDP, > + HAL_FILTER_PROTO_TYPE_MAX > +}; > + > +enum wcn36xx_hal_rcv_pkt_flt_cmp_flag_type { > + HAL_FILTER_CMP_TYPE_INVALID, > + HAL_FILTER_CMP_TYPE_EQUAL, > + HAL_FILTER_CMP_TYPE_MASK_EQUAL, > + HAL_FILTER_CMP_TYPE_NOT_EQUAL, > + HAL_FILTER_CMP_TYPE_MAX > +}; > + > +struct wcn36xx_hal_rcv_pkt_filter_params { > + u8 protocol_layer; > + u8 cmp_flag; > + > + /* Length of the data to compare */ > + u16 data_length; > + > + /* from start of the respective frame header */ > + u8 data_offset; > + > + /* Reserved field */ > + u8 reserved; > + > + /* Data to compare */ > + u8 compare_data[WCN36XX_HAL_PROTOCOL_DATA_LEN]; > + > + /* Mask to be applied on the received packet data before compare */ > + u8 data_mask[WCN36XX_HAL_PROTOCOL_DATA_LEN]; > +}; > + > +struct wcn36xx_hal_sessionized_rcv_pkt_filter_cfg_type { > + u8 id; > + u8 type; > + u8 params_count; > + u32 coleasce_time; > + u8 bss_index; > + struct wcn36xx_hal_rcv_pkt_filter_params params[1]; > +}; > + > +struct wcn36xx_hal_set_rcv_pkt_filter_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 id; > + u8 type; > + u8 params_count; > + u32 coalesce_time; > + struct wcn36xx_hal_rcv_pkt_filter_params params[1]; > +}; > + > +struct wcn36xx_hal_rcv_flt_mc_addr_list_type { > + /* from start of the respective frame header */ > + u8 data_offset; > + > + u32 mc_addr_count; > + u8 mc_addr[ETH_ALEN][WCN36XX_HAL_MAX_NUM_MULTICAST_ADDRESS]; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_set_pkt_filter_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_match_cnt_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_match_cnt { > + u8 id; > + u32 match_cnt; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_match_cnt_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Success or Failure */ > + u32 status; > + > + u32 match_count; > + struct wcn36xx_hal_rcv_flt_pkt_match_cnt > + matches[WCN36XX_HAL_MAX_NUM_FILTERS]; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_clear_param { > + /* only valid for response message */ > + u32 status; > + u8 id; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_clear_req_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_rcv_flt_pkt_clear_param param; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_clear_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_rcv_flt_pkt_clear_param param; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg { > + struct wcn36xx_hal_msg_header header; > + struct wcn36xx_hal_rcv_flt_mc_addr_list_type mc_addr_list; > +}; > + > +struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + u32 status; > + u8 bss_index; > +}; > + > +/* Packet Filtering Definitions End */ > + > +struct wcn36xx_hal_set_power_params_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Ignore DTIM */ > + u32 ignore_dtim; > + > + /* DTIM Period */ > + u32 dtim_period; > + > + /* Listen Interval */ > + u32 listen_interval; > + > + /* Broadcast Multicast Filter */ > + u32 bcast_mcast_filter; > + > + /* Beacon Early Termination */ > + u32 enable_bet; > + > + /* Beacon Early Termination Interval */ > + u32 bet_interval; > +} __packed; > + > +struct wcn36xx_hal_set_power_params_resp { > + > + struct wcn36xx_hal_msg_header header; > + > + /* status of the request */ > + u32 status; > +} __packed; > + > +/* Capability bitmap exchange definitions and macros starts */ > + > +enum place_holder_in_cap_bitmap { > + MCC = 0, > + P2P = 1, > + DOT11AC = 2, > + SLM_SESSIONIZATION = 3, > + DOT11AC_OPMODE = 4, > + SAP32STA = 5, > + TDLS = 6, > + P2P_GO_NOA_DECOUPLE_INIT_SCAN = 7, > + WLANACTIVE_OFFLOAD = 8, > + BEACON_OFFLOAD = 9, > + SCAN_OFFLOAD = 10, > + ROAM_OFFLOAD = 11, > + BCN_MISS_OFFLOAD = 12, > + STA_POWERSAVE = 13, > + STA_ADVANCED_PWRSAVE = 14, > + AP_UAPSD = 15, > + AP_DFS = 16, > + BLOCKACK = 17, > + PHY_ERR = 18, > + BCN_FILTER = 19, > + RTT = 20, > + RATECTRL = 21, > + WOW = 22, > + MAX_FEATURE_SUPPORTED = 128, > +}; > + > +struct wcn36xx_hal_feat_caps_msg { > + > + struct wcn36xx_hal_msg_header header; > + > + u32 feat_caps[4]; > +} __packed; > + > +/* status codes to help debug rekey failures */ > +enum gtk_rekey_status { > + WCN36XX_HAL_GTK_REKEY_STATUS_SUCCESS = 0, > + > + /* rekey detected, but not handled */ > + WCN36XX_HAL_GTK_REKEY_STATUS_NOT_HANDLED = 1, > + > + /* MIC check error on M1 */ > + WCN36XX_HAL_GTK_REKEY_STATUS_MIC_ERROR = 2, > + > + /* decryption error on M1 */ > + WCN36XX_HAL_GTK_REKEY_STATUS_DECRYPT_ERROR = 3, > + > + /* M1 replay detected */ > + WCN36XX_HAL_GTK_REKEY_STATUS_REPLAY_ERROR = 4, > + > + /* missing GTK key descriptor in M1 */ > + WCN36XX_HAL_GTK_REKEY_STATUS_MISSING_KDE = 5, > + > + /* missing iGTK key descriptor in M1 */ > + WCN36XX_HAL_GTK_REKEY_STATUS_MISSING_IGTK_KDE = 6, > + > + /* key installation error */ > + WCN36XX_HAL_GTK_REKEY_STATUS_INSTALL_ERROR = 7, > + > + /* iGTK key installation error */ > + WCN36XX_HAL_GTK_REKEY_STATUS_IGTK_INSTALL_ERROR = 8, > + > + /* GTK rekey M2 response TX error */ > + WCN36XX_HAL_GTK_REKEY_STATUS_RESP_TX_ERROR = 9, > + > + /* non-specific general error */ > + WCN36XX_HAL_GTK_REKEY_STATUS_GEN_ERROR = 255 > +}; > + > +/* wake reason types */ > +enum wake_reason_type { > + WCN36XX_HAL_WAKE_REASON_NONE = 0, > + > + /* magic packet match */ > + WCN36XX_HAL_WAKE_REASON_MAGIC_PACKET = 1, > + > + /* host defined pattern match */ > + WCN36XX_HAL_WAKE_REASON_PATTERN_MATCH = 2, > + > + /* EAP-ID frame detected */ > + WCN36XX_HAL_WAKE_REASON_EAPID_PACKET = 3, > + > + /* start of EAPOL 4-way handshake detected */ > + WCN36XX_HAL_WAKE_REASON_EAPOL4WAY_PACKET = 4, > + > + /* network scan offload match */ > + WCN36XX_HAL_WAKE_REASON_NETSCAN_OFFL_MATCH = 5, > + > + /* GTK rekey status wakeup (see status) */ > + WCN36XX_HAL_WAKE_REASON_GTK_REKEY_STATUS = 6, > + > + /* BSS connection lost */ > + WCN36XX_HAL_WAKE_REASON_BSS_CONN_LOST = 7, > +}; > + > +/* > + Wake Packet which is saved at tWakeReasonParams.DataStart > + This data is sent for any wake reasons that involve a packet-based wakeup : > + > + WCN36XX_HAL_WAKE_REASON_TYPE_MAGIC_PACKET > + WCN36XX_HAL_WAKE_REASON_TYPE_PATTERN_MATCH > + WCN36XX_HAL_WAKE_REASON_TYPE_EAPID_PACKET > + WCN36XX_HAL_WAKE_REASON_TYPE_EAPOL4WAY_PACKET > + WCN36XX_HAL_WAKE_REASON_TYPE_GTK_REKEY_STATUS > + > + The information is provided to the host for auditing and debug purposes > + > +*/ > + > +/* Wake reason indication */ > +struct wcn36xx_hal_wake_reason_ind { > + struct wcn36xx_hal_msg_header header; > + > + /* see tWakeReasonType */ > + u32 reason; > + > + /* argument specific to the reason type */ > + u32 reason_arg; > + > + /* length of optional data stored in this message, in case HAL > + * truncates the data (i.e. data packets) this length will be less > + * than the actual length */ > + u32 stored_data_len; > + > + /* actual length of data */ > + u32 actual_data_len; > + > + /* variable length start of data (length == storedDataLen) see > + * specific wake type */ > + u8 data_start[1]; > + > + u32 bss_index:8; > + u32 reserved:24; > +}; > + > +#define WCN36XX_HAL_GTK_KEK_BYTES 16 > +#define WCN36XX_HAL_GTK_KCK_BYTES 16 > + > +#define WCN36XX_HAL_GTK_OFFLOAD_FLAGS_DISABLE (1 << 0) > + > +#define GTK_SET_BSS_KEY_TAG 0x1234AA55 > + > +struct wcn36xx_hal_gtk_offload_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* optional flags */ > + u32 flags; > + > + /* Key confirmation key */ > + u8 kck[WCN36XX_HAL_GTK_KCK_BYTES]; > + > + /* key encryption key */ > + u8 kek[WCN36XX_HAL_GTK_KEK_BYTES]; > + > + /* replay counter */ > + u64 key_replay_counter; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_gtk_offload_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_gtk_offload_get_info_req_msg { > + struct wcn36xx_hal_msg_header header; > + u8 bss_index; > +}; > + > +struct wcn36xx_hal_gtk_offload_get_info_rsp_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > + > + /* last rekey status when the rekey was offloaded */ > + u32 last_rekey_status; > + > + /* current replay counter value */ > + u64 key_replay_counter; > + > + /* total rekey attempts */ > + u32 total_rekey_count; > + > + /* successful GTK rekeys */ > + u32 gtk_rekey_count; > + > + /* successful iGTK rekeys */ > + u32 igtk_rekey_count; > + > + u8 bss_index; > +}; > + > +struct dhcp_info { > + /* Indicates the device mode which indicates about the DHCP activity */ > + u8 device_mode; > + > + u8 addr[ETH_ALEN]; > +}; > + > +struct dhcp_ind_status { > + struct wcn36xx_hal_msg_header header; > + > + /* success or failure */ > + u32 status; > +}; > + > +/* > + * Thermal Mitigation mode of operation. > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_MODE_0 - Based on AMPDU disabling aggregation > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_MODE_1 - Based on AMPDU disabling aggregation > + * and reducing transmit power > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_MODE_2 - Not supported */ > +enum wcn36xx_hal_thermal_mitigation_mode_type { > + HAL_THERMAL_MITIGATION_MODE_INVALID = -1, > + HAL_THERMAL_MITIGATION_MODE_0, > + HAL_THERMAL_MITIGATION_MODE_1, > + HAL_THERMAL_MITIGATION_MODE_2, > + HAL_THERMAL_MITIGATION_MODE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE, > +}; > + > + > +/* > + * Thermal Mitigation level. > + * Note the levels are incremental i.e WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_2 = > + * WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_0 + > + * WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_1 > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_0 - lowest level of thermal mitigation. > + * This level indicates normal mode of operation > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_1 - 1st level of thermal mitigation > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_2 - 2nd level of thermal mitigation > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_3 - 3rd level of thermal mitigation > + * > + * WCN36XX_HAL_THERMAL_MITIGATION_LEVEL_4 - 4th level of thermal mitigation > + */ > +enum wcn36xx_hal_thermal_mitigation_level_type { > + HAL_THERMAL_MITIGATION_LEVEL_INVALID = -1, > + HAL_THERMAL_MITIGATION_LEVEL_0, > + HAL_THERMAL_MITIGATION_LEVEL_1, > + HAL_THERMAL_MITIGATION_LEVEL_2, > + HAL_THERMAL_MITIGATION_LEVEL_3, > + HAL_THERMAL_MITIGATION_LEVEL_4, > + HAL_THERMAL_MITIGATION_LEVEL_MAX = WCN36XX_HAL_MAX_ENUM_SIZE, > +}; > + > + > +/* WCN36XX_HAL_SET_THERMAL_MITIGATION_REQ */ > +struct set_thermal_mitigation_req_msg { > + struct wcn36xx_hal_msg_header header; > + > + /* Thermal Mitigation Operation Mode */ > + enum wcn36xx_hal_thermal_mitigation_mode_type mode; > + > + /* Thermal Mitigation Level */ > + enum wcn36xx_hal_thermal_mitigation_level_type level; > +}; > + > +struct set_thermal_mitigation_resp { > + > + struct wcn36xx_hal_msg_header header; > + > + /* status of the request */ > + u32 status; > +}; > + > +/* Per STA Class B Statistics. Class B statistics are STA TX/RX stats > + * provided to FW from Host via periodic messages */ > +struct stats_class_b_ind { > + struct wcn36xx_hal_msg_header header; > + > + /* Duration over which this stats was collected */ > + u32 duration; > + > + /* Per STA Stats */ > + > + /* TX stats */ > + u32 tx_bytes_pushed; > + u32 tx_packets_pushed; > + > + /* RX stats */ > + u32 rx_bytes_rcvd; > + u32 rx_packets_rcvd; > + u32 rx_time_total; > +}; > + > +#endif /* _HAL_H_ */ > diff --git a/drivers/net/wireless/ath/wcn36xx/main.c b/drivers/net/wireless/ath/wcn36xx/main.c > new file mode 100644 > index 0000000..7839b31 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/main.c > @@ -0,0 +1,1036 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/module.h> > +#include <linux/platform_device.h> > +#include "wcn36xx.h" > + > +unsigned int wcn36xx_dbg_mask; > +module_param_named(debug_mask, wcn36xx_dbg_mask, uint, 0644); > +MODULE_PARM_DESC(debug_mask, "Debugging mask"); > + > +#define CHAN2G(_freq, _idx) { \ > + .band = IEEE80211_BAND_2GHZ, \ > + .center_freq = (_freq), \ > + .hw_value = (_idx), \ > + .max_power = 25, \ > +} > + > +#define CHAN5G(_freq, _idx) { \ > + .band = IEEE80211_BAND_5GHZ, \ > + .center_freq = (_freq), \ > + .hw_value = (_idx), \ > + .max_power = 25, \ > +} > + > +/* The wcn firmware expects channel values to matching > + * their mnemonic values. So use these for .hw_value. */ > +static struct ieee80211_channel wcn_2ghz_channels[] = { > + CHAN2G(2412, 1), /* Channel 1 */ > + CHAN2G(2417, 2), /* Channel 2 */ > + CHAN2G(2422, 3), /* Channel 3 */ > + CHAN2G(2427, 4), /* Channel 4 */ > + CHAN2G(2432, 5), /* Channel 5 */ > + CHAN2G(2437, 6), /* Channel 6 */ > + CHAN2G(2442, 7), /* Channel 7 */ > + CHAN2G(2447, 8), /* Channel 8 */ > + CHAN2G(2452, 9), /* Channel 9 */ > + CHAN2G(2457, 10), /* Channel 10 */ > + CHAN2G(2462, 11), /* Channel 11 */ > + CHAN2G(2467, 12), /* Channel 12 */ > + CHAN2G(2472, 13), /* Channel 13 */ > + CHAN2G(2484, 14) /* Channel 14 */ > + > +}; > + > +static struct ieee80211_channel wcn_5ghz_channels[] = { > + CHAN5G(5180, 36), > + CHAN5G(5200, 40), > + CHAN5G(5220, 44), > + CHAN5G(5240, 48), > + CHAN5G(5260, 52), > + CHAN5G(5280, 56), > + CHAN5G(5300, 60), > + CHAN5G(5320, 64), > + CHAN5G(5500, 100), > + CHAN5G(5520, 104), > + CHAN5G(5540, 108), > + CHAN5G(5560, 112), > + CHAN5G(5580, 116), > + CHAN5G(5600, 120), > + CHAN5G(5620, 124), > + CHAN5G(5640, 128), > + CHAN5G(5660, 132), > + CHAN5G(5700, 140), > + CHAN5G(5745, 149), > + CHAN5G(5765, 153), > + CHAN5G(5785, 157), > + CHAN5G(5805, 161), > + CHAN5G(5825, 165) > +}; > + > +#define RATE(_bitrate, _hw_rate, _flags) { \ > + .bitrate = (_bitrate), \ > + .flags = (_flags), \ > + .hw_value = (_hw_rate), \ > + .hw_value_short = (_hw_rate) \ > +} > + > +static struct ieee80211_rate wcn_2ghz_rates[] = { > + RATE(10, HW_RATE_INDEX_1MBPS, 0), > + RATE(20, HW_RATE_INDEX_2MBPS, IEEE80211_RATE_SHORT_PREAMBLE), > + RATE(55, HW_RATE_INDEX_5_5MBPS, IEEE80211_RATE_SHORT_PREAMBLE), > + RATE(110, HW_RATE_INDEX_11MBPS, IEEE80211_RATE_SHORT_PREAMBLE), > + RATE(60, HW_RATE_INDEX_6MBPS, 0), > + RATE(90, HW_RATE_INDEX_9MBPS, 0), > + RATE(120, HW_RATE_INDEX_12MBPS, 0), > + RATE(180, HW_RATE_INDEX_18MBPS, 0), > + RATE(240, HW_RATE_INDEX_24MBPS, 0), > + RATE(360, HW_RATE_INDEX_36MBPS, 0), > + RATE(480, HW_RATE_INDEX_48MBPS, 0), > + RATE(540, HW_RATE_INDEX_54MBPS, 0) > +}; > + > +static struct ieee80211_rate wcn_5ghz_rates[] = { > + RATE(60, HW_RATE_INDEX_6MBPS, 0), > + RATE(90, HW_RATE_INDEX_9MBPS, 0), > + RATE(120, HW_RATE_INDEX_12MBPS, 0), > + RATE(180, HW_RATE_INDEX_18MBPS, 0), > + RATE(240, HW_RATE_INDEX_24MBPS, 0), > + RATE(360, HW_RATE_INDEX_36MBPS, 0), > + RATE(480, HW_RATE_INDEX_48MBPS, 0), > + RATE(540, HW_RATE_INDEX_54MBPS, 0) > +}; > + > +static struct ieee80211_supported_band wcn_band_2ghz = { > + .channels = wcn_2ghz_channels, > + .n_channels = ARRAY_SIZE(wcn_2ghz_channels), > + .bitrates = wcn_2ghz_rates, > + .n_bitrates = ARRAY_SIZE(wcn_2ghz_rates), > + .ht_cap = { > + .cap = IEEE80211_HT_CAP_GRN_FLD | > + IEEE80211_HT_CAP_SGI_20 | > + IEEE80211_HT_CAP_DSSSCCK40 | > + IEEE80211_HT_CAP_LSIG_TXOP_PROT, > + .ht_supported = true, > + .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, > + .ampdu_density = IEEE80211_HT_MPDU_DENSITY_16, > + .mcs = { > + .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, > + .rx_highest = cpu_to_le16(72), > + .tx_params = IEEE80211_HT_MCS_TX_DEFINED, > + } > + } > +}; > + > +static struct ieee80211_supported_band wcn_band_5ghz = { > + .channels = wcn_5ghz_channels, > + .n_channels = ARRAY_SIZE(wcn_5ghz_channels), > + .bitrates = wcn_5ghz_rates, > + .n_bitrates = ARRAY_SIZE(wcn_5ghz_rates), > + .ht_cap = { > + .cap = IEEE80211_HT_CAP_GRN_FLD | > + IEEE80211_HT_CAP_SGI_20 | > + IEEE80211_HT_CAP_DSSSCCK40 | > + IEEE80211_HT_CAP_LSIG_TXOP_PROT | > + IEEE80211_HT_CAP_SGI_40 | > + IEEE80211_HT_CAP_SUP_WIDTH_20_40, > + .ht_supported = true, > + .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, > + .ampdu_density = IEEE80211_HT_MPDU_DENSITY_16, > + .mcs = { > + .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, > + .rx_highest = cpu_to_le16(72), > + .tx_params = IEEE80211_HT_MCS_TX_DEFINED, > + } > + } > +}; > + > +#ifdef CONFIG_PM > + > +static const struct wiphy_wowlan_support wowlan_support = { > + .flags = WIPHY_WOWLAN_ANY > +}; > + > +#endif > + > +static inline u8 get_sta_index(struct ieee80211_vif *vif, > + struct wcn36xx_sta *sta_priv) > +{ > + return NL80211_IFTYPE_STATION == vif->type ? > + sta_priv->bss_sta_index : > + sta_priv->sta_index; > +} > + > +static int wcn36xx_start(struct ieee80211_hw *hw) > +{ > + struct wcn36xx *wcn = hw->priv; > + int ret; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac start\n"); > + > + /* SMD initialization */ > + ret = wcn36xx_smd_open(wcn); > + if (ret) { > + wcn36xx_err("Failed to open smd channel: %d\n", ret); > + goto out_err; > + } > + > + /* Allocate memory pools for Mgmt BD headers and Data BD headers */ > + ret = wcn36xx_dxe_allocate_mem_pools(wcn); > + if (ret) { > + wcn36xx_err("Failed to alloc DXE mempool: %d\n", ret); > + goto out_smd_close; > + } > + > + ret = wcn36xx_dxe_alloc_ctl_blks(wcn); > + if (ret) { > + wcn36xx_err("Failed to alloc DXE ctl blocks: %d\n", ret); > + goto out_free_dxe_pool; > + } > + > + wcn->hal_buf = kmalloc(WCN36XX_HAL_BUF_SIZE, GFP_KERNEL); > + if (!wcn->hal_buf) { > + wcn36xx_err("Failed to allocate smd buf\n"); > + ret = -ENOMEM; > + goto out_free_dxe_ctl; > + } > + > + ret = wcn36xx_smd_load_nv(wcn); > + if (ret) { > + wcn36xx_err("Failed to push NV to chip\n"); > + goto out_free_smd_buf; > + } > + > + ret = wcn36xx_smd_start(wcn); > + if (ret) { > + wcn36xx_err("Failed to start chip\n"); > + goto out_free_smd_buf; > + } > + > + /* DMA channel initialization */ > + ret = wcn36xx_dxe_init(wcn); > + if (ret) { > + wcn36xx_err("DXE init failed\n"); > + goto out_smd_stop; > + } > + > + wcn36xx_debugfs_init(wcn); > + > + if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) { > + ret = wcn36xx_smd_feature_caps_exchange(wcn); > + if (ret) > + wcn36xx_warn("Exchange feature caps failed\n"); > + } > + INIT_LIST_HEAD(&wcn->vif_list); > + return 0; > + > +out_smd_stop: > + wcn36xx_smd_stop(wcn); > +out_free_smd_buf: > + kfree(wcn->hal_buf); > +out_free_dxe_pool: > + wcn36xx_dxe_free_mem_pools(wcn); > +out_free_dxe_ctl: > + wcn36xx_dxe_free_ctl_blks(wcn); > +out_smd_close: > + wcn36xx_smd_close(wcn); > +out_err: > + return ret; > +} > + > +static void wcn36xx_stop(struct ieee80211_hw *hw) > +{ > + struct wcn36xx *wcn = hw->priv; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac stop\n"); > + > + wcn36xx_debugfs_exit(wcn); > + wcn36xx_smd_stop(wcn); > + wcn36xx_dxe_deinit(wcn); > + wcn36xx_smd_close(wcn); > + > + wcn36xx_dxe_free_mem_pools(wcn); > + wcn36xx_dxe_free_ctl_blks(wcn); > + > + kfree(wcn->hal_buf); > +} > + > +static int wcn36xx_config(struct ieee80211_hw *hw, u32 changed) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct ieee80211_vif *vif = NULL; > + struct wcn36xx_vif *tmp; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac config changed 0x%08x\n", changed); > + > + if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { > + int ch = WCN36XX_HW_CHANNEL(wcn); > + wcn36xx_dbg(WCN36XX_DBG_MAC, "wcn36xx_config channel switch=%d\n", > + ch); > + list_for_each_entry(tmp, &wcn->vif_list, list) { > + vif = container_of((void *)tmp, > + struct ieee80211_vif, > + drv_priv); > + wcn36xx_smd_switch_channel(wcn, vif, ch); > + } > + } > + > + return 0; > +} > + > +#define WCN36XX_SUPPORTED_FILTERS (0) > + > +static void wcn36xx_configure_filter(struct ieee80211_hw *hw, > + unsigned int changed, > + unsigned int *total, u64 multicast) > +{ > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac configure filter\n"); > + > + *total &= WCN36XX_SUPPORTED_FILTERS; > +} > + > +static void wcn36xx_tx(struct ieee80211_hw *hw, > + struct ieee80211_tx_control *control, > + struct sk_buff *skb) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct wcn36xx_sta *sta_priv = NULL; > + > + if (control->sta) > + sta_priv = (struct wcn36xx_sta *)control->sta->drv_priv; > + > + if (wcn36xx_start_tx(wcn, sta_priv, skb)) > + ieee80211_free_txskb(wcn->hw, skb); > +} > + > +static int wcn36xx_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, > + struct ieee80211_vif *vif, > + struct ieee80211_sta *sta, > + struct ieee80211_key_conf *key_conf) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + struct wcn36xx_sta *sta_priv = vif_priv->sta; > + int ret = 0; > + u8 key[WLAN_MAX_KEY_LEN]; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac80211 set key\n"); > + wcn36xx_dbg(WCN36XX_DBG_MAC, "Key: cmd=0x%x algo:0x%x, id:%d, len:%d flags 0x%x\n", > + cmd, key_conf->cipher, key_conf->keyidx, > + key_conf->keylen, key_conf->flags); > + wcn36xx_dbg_dump(WCN36XX_DBG_MAC, "KEY: ", > + key_conf->key, > + key_conf->keylen); > + > + switch (key_conf->cipher) { > + case WLAN_CIPHER_SUITE_WEP40: > + vif_priv->encrypt_type = WCN36XX_HAL_ED_WEP40; > + break; > + case WLAN_CIPHER_SUITE_WEP104: > + vif_priv->encrypt_type = WCN36XX_HAL_ED_WEP40; > + break; > + case WLAN_CIPHER_SUITE_CCMP: > + vif_priv->encrypt_type = WCN36XX_HAL_ED_CCMP; > + break; > + case WLAN_CIPHER_SUITE_TKIP: > + vif_priv->encrypt_type = WCN36XX_HAL_ED_TKIP; > + break; > + default: > + wcn36xx_err("Unsupported key type 0x%x\n", > + key_conf->cipher); > + ret = -EOPNOTSUPP; > + goto out; > + } > + > + switch (cmd) { > + case SET_KEY: > + if (WCN36XX_HAL_ED_TKIP == vif_priv->encrypt_type) { > + /* > + * Supplicant is sending key in the wrong order: > + * Temporal Key (16 b) - TX MIC (8 b) - RX MIC (8 b) > + * but HW expects it to be in the order as described in > + * IEEE 802.11 spec (see chapter 11.7) like this: > + * Temporal Key (16 b) - RX MIC (8 b) - TX MIC (8 b) > + */ > + memcpy(key, key_conf->key, 16); > + memcpy(key + 16, key_conf->key + 24, 8); > + memcpy(key + 24, key_conf->key + 16, 8); > + } else { > + memcpy(key, key_conf->key, key_conf->keylen); > + } > + > + if (IEEE80211_KEY_FLAG_PAIRWISE & key_conf->flags) { > + sta_priv->is_data_encrypted = true; > + /* Reconfigure bss with encrypt_type */ > + if (NL80211_IFTYPE_STATION == vif->type) > + wcn36xx_smd_config_bss(wcn, > + vif, > + sta, > + sta->addr, > + true); > + > + wcn36xx_smd_set_stakey(wcn, > + vif_priv->encrypt_type, > + key_conf->keyidx, > + key_conf->keylen, > + key, > + get_sta_index(vif, sta_priv)); > + } else { > + wcn36xx_smd_set_bsskey(wcn, > + vif_priv->encrypt_type, > + key_conf->keyidx, > + key_conf->keylen, > + key); > + if ((WLAN_CIPHER_SUITE_WEP40 == key_conf->cipher) || > + (WLAN_CIPHER_SUITE_WEP104 == key_conf->cipher)) { > + sta_priv->is_data_encrypted = true; > + wcn36xx_smd_set_stakey(wcn, > + vif_priv->encrypt_type, > + key_conf->keyidx, > + key_conf->keylen, > + key, > + get_sta_index(vif, sta_priv)); > + } > + } > + break; > + case DISABLE_KEY: > + if (!(IEEE80211_KEY_FLAG_PAIRWISE & key_conf->flags)) { > + wcn36xx_smd_remove_bsskey(wcn, > + vif_priv->encrypt_type, > + key_conf->keyidx); > + } else { > + sta_priv->is_data_encrypted = false; > + /* do not remove key if disassociated */ > + if (sta_priv->aid) > + wcn36xx_smd_remove_stakey(wcn, > + vif_priv->encrypt_type, > + key_conf->keyidx, > + get_sta_index(vif, sta_priv)); > + } > + break; > + default: > + wcn36xx_err("Unsupported key cmd 0x%x\n", cmd); > + ret = -EOPNOTSUPP; > + goto out; > + break; > + } > + > +out: > + return ret; > +} > + > +static void wcn36xx_sw_scan_start(struct ieee80211_hw *hw) > +{ > + struct wcn36xx *wcn = hw->priv; > + > + wcn36xx_smd_init_scan(wcn, HAL_SYS_MODE_SCAN); > + wcn36xx_smd_start_scan(wcn); > +} > + > +static void wcn36xx_sw_scan_complete(struct ieee80211_hw *hw) > +{ > + struct wcn36xx *wcn = hw->priv; > + > + wcn36xx_smd_end_scan(wcn); > + wcn36xx_smd_finish_scan(wcn, HAL_SYS_MODE_SCAN); > +} > + > +static void wcn36xx_update_allowed_rates(struct ieee80211_sta *sta, > + enum ieee80211_band band) > +{ > + int i, size; > + u16 *rates_table; > + struct wcn36xx_sta *sta_priv = (struct wcn36xx_sta *)sta->drv_priv; > + u32 rates = sta->supp_rates[band]; > + > + memset(&sta_priv->supported_rates, 0, > + sizeof(sta_priv->supported_rates)); > + sta_priv->supported_rates.op_rate_mode = STA_11n; > + > + size = ARRAY_SIZE(sta_priv->supported_rates.dsss_rates); > + rates_table = sta_priv->supported_rates.dsss_rates; > + if (band == IEEE80211_BAND_2GHZ) { > + for (i = 0; i < size; i++) { > + if (rates & 0x01) { > + rates_table[i] = wcn_2ghz_rates[i].hw_value; > + rates = rates >> 1; > + } > + } > + } > + > + size = ARRAY_SIZE(sta_priv->supported_rates.ofdm_rates); > + rates_table = sta_priv->supported_rates.ofdm_rates; > + for (i = 0; i < size; i++) { > + if (rates & 0x01) { > + rates_table[i] = wcn_5ghz_rates[i].hw_value; > + rates = rates >> 1; > + } > + } > + > + if (sta->ht_cap.ht_supported) { > + BUILD_BUG_ON(sizeof(sta->ht_cap.mcs.rx_mask) > > + sizeof(sta_priv->supported_rates.supported_mcs_set)); > + memcpy(sta_priv->supported_rates.supported_mcs_set, > + sta->ht_cap.mcs.rx_mask, > + sizeof(sta->ht_cap.mcs.rx_mask)); > + } > +} > +void wcn36xx_set_default_rates(struct wcn36xx_hal_supported_rates *rates) > +{ > + u16 ofdm_rates[WCN36XX_HAL_NUM_OFDM_RATES] = { > + HW_RATE_INDEX_6MBPS, > + HW_RATE_INDEX_9MBPS, > + HW_RATE_INDEX_12MBPS, > + HW_RATE_INDEX_18MBPS, > + HW_RATE_INDEX_24MBPS, > + HW_RATE_INDEX_36MBPS, > + HW_RATE_INDEX_48MBPS, > + HW_RATE_INDEX_54MBPS > + }; > + u16 dsss_rates[WCN36XX_HAL_NUM_DSSS_RATES] = { > + HW_RATE_INDEX_1MBPS, > + HW_RATE_INDEX_2MBPS, > + HW_RATE_INDEX_5_5MBPS, > + HW_RATE_INDEX_11MBPS > + }; > + > + rates->op_rate_mode = STA_11n; > + memcpy(rates->dsss_rates, dsss_rates, > + sizeof(*dsss_rates) * WCN36XX_HAL_NUM_DSSS_RATES); > + memcpy(rates->ofdm_rates, ofdm_rates, > + sizeof(*ofdm_rates) * WCN36XX_HAL_NUM_OFDM_RATES); > + rates->supported_mcs_set[0] = 0xFF; > +} > +static void wcn36xx_bss_info_changed(struct ieee80211_hw *hw, > + struct ieee80211_vif *vif, > + struct ieee80211_bss_conf *bss_conf, > + u32 changed) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct sk_buff *skb = NULL; > + u16 tim_off, tim_len; > + enum wcn36xx_hal_link_state link_state; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac bss info changed vif %p changed 0x%08x\n", > + vif, changed); > + > + if (changed & BSS_CHANGED_BEACON_INFO) { > + wcn36xx_dbg(WCN36XX_DBG_MAC, > + "mac bss changed dtim period %d\n", > + bss_conf->dtim_period); > + > + vif_priv->dtim_period = bss_conf->dtim_period; > + } > + > + if (changed & BSS_CHANGED_PS) { > + wcn36xx_dbg(WCN36XX_DBG_MAC, > + "mac bss PS set %d\n", > + bss_conf->ps); > + if (bss_conf->ps) { > + wcn36xx_pmc_enter_bmps_state(wcn, vif); > + } else { > + wcn36xx_pmc_exit_bmps_state(wcn, vif); > + } > + } > + > + if (changed & BSS_CHANGED_BSSID) { > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac bss changed_bssid %pM\n", > + bss_conf->bssid); > + > + if (!is_zero_ether_addr(bss_conf->bssid)) { > + vif_priv->is_joining = true; > + vif_priv->bss_index = 0xff; > + wcn36xx_smd_join(wcn, bss_conf->bssid, > + vif->addr, WCN36XX_HW_CHANNEL(wcn)); > + wcn36xx_smd_config_bss(wcn, vif, NULL, > + bss_conf->bssid, false); > + } else { > + vif_priv->is_joining = false; > + wcn36xx_smd_delete_bss(wcn, vif); > + } > + } > + > + if (changed & BSS_CHANGED_SSID) { > + wcn36xx_dbg(WCN36XX_DBG_MAC, > + "mac bss changed ssid\n"); > + wcn36xx_dbg_dump(WCN36XX_DBG_MAC, "ssid ", > + bss_conf->ssid, bss_conf->ssid_len); > + > + vif_priv->ssid.length = bss_conf->ssid_len; > + memcpy(&vif_priv->ssid.ssid, > + bss_conf->ssid, > + bss_conf->ssid_len); > + } > + > + if (changed & BSS_CHANGED_ASSOC) { > + vif_priv->is_joining = false; > + if (bss_conf->assoc) { > + struct ieee80211_sta *sta; > + struct wcn36xx_sta *sta_priv; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, > + "mac assoc bss %pM vif %pM AID=%d\n", > + bss_conf->bssid, > + vif->addr, > + bss_conf->aid); > + > + rcu_read_lock(); > + sta = ieee80211_find_sta(vif, bss_conf->bssid); > + if (!sta) { > + wcn36xx_err("sta %pM is not found\n", > + bss_conf->bssid); > + rcu_read_unlock(); > + goto out; > + } > + sta_priv = (struct wcn36xx_sta *)sta->drv_priv; > + > + wcn36xx_update_allowed_rates(sta, WCN36XX_BAND(wcn)); > + > + wcn36xx_smd_set_link_st(wcn, bss_conf->bssid, > + vif->addr, > + WCN36XX_HAL_LINK_POSTASSOC_STATE); > + wcn36xx_smd_config_bss(wcn, vif, sta, > + bss_conf->bssid, > + true); > + sta_priv->aid = bss_conf->aid; > + /* > + * config_sta must be called from because this is the > + * place where AID is available. > + */ > + wcn36xx_smd_config_sta(wcn, vif, sta); > + rcu_read_unlock(); > + } else { > + wcn36xx_dbg(WCN36XX_DBG_MAC, > + "disassociated bss %pM vif %pM AID=%d\n", > + bss_conf->bssid, > + vif->addr, > + bss_conf->aid); > + wcn36xx_smd_set_link_st(wcn, > + bss_conf->bssid, > + vif->addr, > + WCN36XX_HAL_LINK_IDLE_STATE); > + } > + } > + > + if (changed & BSS_CHANGED_AP_PROBE_RESP) { > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac bss changed ap probe resp\n"); > + skb = ieee80211_proberesp_get(hw, vif); > + if (!skb) { > + wcn36xx_err("failed to alloc probereq skb\n"); > + goto out; > + } > + > + wcn36xx_smd_update_proberesp_tmpl(wcn, vif, skb); > + dev_kfree_skb(skb); > + } > + > + if (changed & BSS_CHANGED_BEACON_ENABLED) { > + wcn36xx_dbg(WCN36XX_DBG_MAC, > + "mac bss changed beacon enabled %d\n", > + bss_conf->enable_beacon); > + > + if (bss_conf->enable_beacon) { > + vif_priv->bss_index = 0xff; > + wcn36xx_smd_config_bss(wcn, vif, NULL, > + vif->addr, false); > + skb = ieee80211_beacon_get_tim(hw, vif, &tim_off, > + &tim_len); > + if (!skb) { > + wcn36xx_err("failed to alloc beacon skb\n"); > + goto out; > + } > + wcn36xx_smd_send_beacon(wcn, vif, skb, tim_off, 0); > + dev_kfree_skb(skb); > + > + if (vif->type == NL80211_IFTYPE_ADHOC || > + vif->type == NL80211_IFTYPE_MESH_POINT) > + link_state = WCN36XX_HAL_LINK_IBSS_STATE; > + else > + link_state = WCN36XX_HAL_LINK_AP_STATE; > + > + wcn36xx_smd_set_link_st(wcn, vif->addr, vif->addr, > + link_state); > + } else { > + wcn36xx_smd_set_link_st(wcn, vif->addr, vif->addr, > + WCN36XX_HAL_LINK_IDLE_STATE); > + wcn36xx_smd_delete_bss(wcn, vif); > + } > + } > +out: > + return; > +} > + > +/* this is required when using IEEE80211_HW_HAS_RATE_CONTROL */ > +static int wcn36xx_set_rts_threshold(struct ieee80211_hw *hw, u32 value) > +{ > + struct wcn36xx *wcn = hw->priv; > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac set RTS threshold %d\n", value); > + > + wcn36xx_smd_update_cfg(wcn, WCN36XX_HAL_CFG_RTS_THRESHOLD, value); > + return 0; > +} > + > +static void wcn36xx_remove_interface(struct ieee80211_hw *hw, > + struct ieee80211_vif *vif) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac remove interface vif %p\n", vif); > + > + list_del(&vif_priv->list); > + wcn36xx_smd_delete_sta_self(wcn, vif->addr); > +} > + > +static int wcn36xx_add_interface(struct ieee80211_hw *hw, > + struct ieee80211_vif *vif) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac add interface vif %p type %d\n", > + vif, vif->type); > + > + if (!(NL80211_IFTYPE_STATION == vif->type || > + NL80211_IFTYPE_AP == vif->type || > + NL80211_IFTYPE_ADHOC == vif->type || > + NL80211_IFTYPE_MESH_POINT == vif->type)) { > + wcn36xx_warn("Unsupported interface type requested: %d\n", > + vif->type); > + return -EOPNOTSUPP; > + } > + > + list_add(&vif_priv->list, &wcn->vif_list); > + wcn36xx_smd_add_sta_self(wcn, vif); > + > + return 0; > +} > + > +static int wcn36xx_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, > + struct ieee80211_sta *sta) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + struct wcn36xx_sta *sta_priv = (struct wcn36xx_sta *)sta->drv_priv; > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac sta add vif %p sta %pM\n", > + vif, sta->addr); > + > + vif_priv->sta = sta_priv; > + sta_priv->vif = vif_priv; > + /* > + * For STA mode HW will be configured on BSS_CHANGED_ASSOC because > + * at this stage AID is not available yet. > + */ > + if (NL80211_IFTYPE_STATION != vif->type) { > + wcn36xx_update_allowed_rates(sta, WCN36XX_BAND(wcn)); > + sta_priv->aid = sta->aid; > + wcn36xx_smd_config_sta(wcn, vif, sta); > + } > + return 0; > +} > + > +static int wcn36xx_sta_remove(struct ieee80211_hw *hw, > + struct ieee80211_vif *vif, > + struct ieee80211_sta *sta) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + struct wcn36xx_sta *sta_priv = (struct wcn36xx_sta *)sta->drv_priv; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac sta remove vif %p sta %pM index %d\n", > + vif, sta->addr, sta_priv->sta_index); > + > + wcn36xx_smd_delete_sta(wcn, sta_priv->sta_index); > + vif_priv->sta = NULL; > + sta_priv->vif = NULL; > + return 0; > +} > + > +#ifdef CONFIG_PM > + > +static int wcn36xx_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wow) > +{ > + struct wcn36xx *wcn = hw->priv; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac suspend\n"); > + > + flush_workqueue(wcn->hal_ind_wq); > + wcn36xx_smd_set_power_params(wcn, true); > + return 0; > +} > + > +static int wcn36xx_resume(struct ieee80211_hw *hw) > +{ > + struct wcn36xx *wcn = hw->priv; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac resume\n"); > + > + flush_workqueue(wcn->hal_ind_wq); > + wcn36xx_smd_set_power_params(wcn, false); > + return 0; > +} > + > +#endif > + > +static int wcn36xx_ampdu_action(struct ieee80211_hw *hw, > + struct ieee80211_vif *vif, > + enum ieee80211_ampdu_mlme_action action, > + struct ieee80211_sta *sta, u16 tid, u16 *ssn, > + u8 buf_size) > +{ > + struct wcn36xx *wcn = hw->priv; > + struct wcn36xx_sta *sta_priv = NULL; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "mac ampdu action action %d tid %d\n", > + action, tid); > + > + sta_priv = (struct wcn36xx_sta *)sta->drv_priv; > + > + switch (action) { > + case IEEE80211_AMPDU_RX_START: > + sta_priv->tid = tid; > + wcn36xx_smd_add_ba_session(wcn, sta, tid, ssn, 0, > + get_sta_index(vif, sta_priv)); > + wcn36xx_smd_add_ba(wcn); > + wcn36xx_smd_trigger_ba(wcn, get_sta_index(vif, sta_priv)); > + ieee80211_start_tx_ba_session(sta, tid, 0); > + break; > + case IEEE80211_AMPDU_RX_STOP: > + wcn36xx_smd_del_ba(wcn, tid, get_sta_index(vif, sta_priv)); > + break; > + case IEEE80211_AMPDU_TX_START: > + ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); > + break; > + case IEEE80211_AMPDU_TX_OPERATIONAL: > + wcn36xx_smd_add_ba_session(wcn, sta, tid, ssn, 1, > + get_sta_index(vif, sta_priv)); > + break; > + case IEEE80211_AMPDU_TX_STOP_FLUSH: > + case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: > + case IEEE80211_AMPDU_TX_STOP_CONT: > + ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); > + break; > + default: > + wcn36xx_err("Unknown AMPDU action\n"); > + } > + > + return 0; > +} > + > +static const struct ieee80211_ops wcn36xx_ops = { > + .start = wcn36xx_start, > + .stop = wcn36xx_stop, > + .add_interface = wcn36xx_add_interface, > + .remove_interface = wcn36xx_remove_interface, > +#ifdef CONFIG_PM > + .suspend = wcn36xx_suspend, > + .resume = wcn36xx_resume, > +#endif > + .config = wcn36xx_config, > + .configure_filter = wcn36xx_configure_filter, > + .tx = wcn36xx_tx, > + .set_key = wcn36xx_set_key, > + .sw_scan_start = wcn36xx_sw_scan_start, > + .sw_scan_complete = wcn36xx_sw_scan_complete, > + .bss_info_changed = wcn36xx_bss_info_changed, > + .set_rts_threshold = wcn36xx_set_rts_threshold, > + .sta_add = wcn36xx_sta_add, > + .sta_remove = wcn36xx_sta_remove, > + .ampdu_action = wcn36xx_ampdu_action, > +}; > + > +static int wcn36xx_init_ieee80211(struct wcn36xx *wcn) > +{ > + int ret = 0; > + > + static const u32 cipher_suites[] = { > + WLAN_CIPHER_SUITE_WEP40, > + WLAN_CIPHER_SUITE_WEP104, > + WLAN_CIPHER_SUITE_TKIP, > + WLAN_CIPHER_SUITE_CCMP, > + }; > + > + wcn->hw->flags = IEEE80211_HW_SIGNAL_DBM | > + IEEE80211_HW_HAS_RATE_CONTROL | > + IEEE80211_HW_SUPPORTS_PS | > + IEEE80211_HW_CONNECTION_MONITOR | > + IEEE80211_HW_AMPDU_AGGREGATION | > + IEEE80211_HW_TIMING_BEACON_ONLY; > + > + wcn->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | > + BIT(NL80211_IFTYPE_AP) | > + BIT(NL80211_IFTYPE_ADHOC) | > + BIT(NL80211_IFTYPE_MESH_POINT); > + > + wcn->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wcn_band_2ghz; > + wcn->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wcn_band_5ghz; > + > + wcn->hw->wiphy->cipher_suites = cipher_suites; > + wcn->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); > + > + wcn->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; > + > +#ifdef CONFIG_PM > + wcn->hw->wiphy->wowlan = &wowlan_support; > +#endif > + > + wcn->hw->max_listen_interval = 200; > + > + wcn->hw->queues = 4; > + > + SET_IEEE80211_DEV(wcn->hw, wcn->dev); > + > + wcn->hw->sta_data_size = sizeof(struct wcn36xx_sta); > + wcn->hw->vif_data_size = sizeof(struct wcn36xx_vif); > + > + return ret; > +} > + > +static int wcn36xx_platform_get_resources(struct wcn36xx *wcn, > + struct platform_device *pdev) > +{ > + struct resource *res; > + /* Set TX IRQ */ > + res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, > + "wcnss_wlantx_irq"); > + if (!res) { > + wcn36xx_err("failed to get tx_irq\n"); > + return -ENOENT; > + } > + wcn->tx_irq = res->start; > + > + /* Set RX IRQ */ > + res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, > + "wcnss_wlanrx_irq"); > + if (!res) { > + wcn36xx_err("failed to get rx_irq\n"); > + return -ENOENT; > + } > + wcn->rx_irq = res->start; > + > + /* Map the memory */ > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, > + "wcnss_mmio"); > + if (!res) { > + wcn36xx_err("failed to get mmio\n"); > + return -ENOENT; > + } > + wcn->mmio = ioremap(res->start, resource_size(res)); > + if (!wcn->mmio) { > + wcn36xx_err("failed to map io memory\n"); > + return -ENOMEM; > + } > + return 0; > +} > + > +static int wcn36xx_probe(struct platform_device *pdev) > +{ > + struct ieee80211_hw *hw; > + struct wcn36xx *wcn; > + int ret; > + u8 addr[ETH_ALEN]; > + > + wcn36xx_dbg(WCN36XX_DBG_MAC, "platform probe\n"); > + > + hw = ieee80211_alloc_hw(sizeof(struct wcn36xx), &wcn36xx_ops); > + if (!hw) { > + wcn36xx_err("failed to alloc hw\n"); > + ret = -ENOMEM; > + goto out_err; > + } > + platform_set_drvdata(pdev, hw); > + wcn = hw->priv; > + wcn->hw = hw; > + wcn->dev = &pdev->dev; > + wcn->ctrl_ops = pdev->dev.platform_data; > + > + mutex_init(&wcn->hal_mutex); > + > + if (!wcn->ctrl_ops->get_hw_mac(addr)) { > + wcn36xx_info("mac address: %pM\n", addr); > + SET_IEEE80211_PERM_ADDR(wcn->hw, addr); > + } > + > + ret = wcn36xx_platform_get_resources(wcn, pdev); > + if (ret) > + goto out_wq; > + > + wcn36xx_init_ieee80211(wcn); > + ret = ieee80211_register_hw(wcn->hw); > + if (ret) > + goto out_unmap; > + > + return 0; > + > +out_unmap: > + iounmap(wcn->mmio); > +out_wq: > + ieee80211_free_hw(hw); > +out_err: > + return ret; > +} > +static int wcn36xx_remove(struct platform_device *pdev) > +{ > + struct ieee80211_hw *hw = platform_get_drvdata(pdev); > + struct wcn36xx *wcn = hw->priv; > + wcn36xx_dbg(WCN36XX_DBG_MAC, "platform remove\n"); > + > + mutex_destroy(&wcn->hal_mutex); > + > + ieee80211_unregister_hw(hw); > + iounmap(wcn->mmio); > + ieee80211_free_hw(hw); > + > + return 0; > +} > +static const struct platform_device_id wcn36xx_platform_id_table[] = { > + { > + .name = "wcn36xx", > + .driver_data = 0 > + }, > + {} > +}; > +MODULE_DEVICE_TABLE(platform, wcn36xx_platform_id_table); > + > +static struct platform_driver wcn36xx_driver = { > + .probe = wcn36xx_probe, > + .remove = wcn36xx_remove, > + .driver = { > + .name = "wcn36xx", > + .owner = THIS_MODULE, > + }, > + .id_table = wcn36xx_platform_id_table, > +}; > + > +static int __init wcn36xx_init(void) > +{ > + platform_driver_register(&wcn36xx_driver); > + return 0; > +} > +module_init(wcn36xx_init); > + > +static void __exit wcn36xx_exit(void) > +{ > + platform_driver_unregister(&wcn36xx_driver); > +} > +module_exit(wcn36xx_exit); > + > +MODULE_LICENSE("Dual BSD/GPL"); > +MODULE_AUTHOR("Eugene Krasnikov k.eugene.e@xxxxxxxxx"); > +MODULE_FIRMWARE(WLAN_NV_FILE); > diff --git a/drivers/net/wireless/ath/wcn36xx/pmc.c b/drivers/net/wireless/ath/wcn36xx/pmc.c > new file mode 100644 > index 0000000..28b515c > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/pmc.c > @@ -0,0 +1,62 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include "wcn36xx.h" > + > +int wcn36xx_pmc_enter_bmps_state(struct wcn36xx *wcn, > + struct ieee80211_vif *vif) > +{ > + int ret = 0; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + /* TODO: Make sure the TX chain clean */ > + ret = wcn36xx_smd_enter_bmps(wcn, vif); > + if (!ret) { > + wcn36xx_dbg(WCN36XX_DBG_PMC, "Entered BMPS\n"); > + vif_priv->pw_state = WCN36XX_BMPS; > + } else { > + /* > + * One of the reasons why HW will not enter BMPS is because > + * driver is trying to enter bmps before first beacon was > + * received just after auth complete > + */ > + wcn36xx_err("Can not enter BMPS!\n"); > + } > + return ret; > +} > + > +int wcn36xx_pmc_exit_bmps_state(struct wcn36xx *wcn, > + struct ieee80211_vif *vif) > +{ > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + > + if (WCN36XX_BMPS != vif_priv->pw_state) { > + wcn36xx_err("Not in BMPS mode, no need to exit from BMPS mode!\n"); > + return -EINVAL; > + } > + wcn36xx_smd_exit_bmps(wcn, vif); > + vif_priv->pw_state = WCN36XX_FULL_POWER; > + return 0; > +} > + > +int wcn36xx_enable_keep_alive_null_packet(struct wcn36xx *wcn, > + struct ieee80211_vif *vif) > +{ > + wcn36xx_dbg(WCN36XX_DBG_PMC, "%s\n", __func__); > + return wcn36xx_smd_keep_alive_req(wcn, vif, > + WCN36XX_HAL_KEEP_ALIVE_NULL_PKT); > +} > diff --git a/drivers/net/wireless/ath/wcn36xx/pmc.h b/drivers/net/wireless/ath/wcn36xx/pmc.h > new file mode 100644 > index 0000000..f72ed68 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/pmc.h > @@ -0,0 +1,33 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#ifndef _WCN36XX_PMC_H_ > +#define _WCN36XX_PMC_H_ > + > +struct wcn36xx; > + > +enum wcn36xx_power_state { > + WCN36XX_FULL_POWER, > + WCN36XX_BMPS > +}; > + > +int wcn36xx_pmc_enter_bmps_state(struct wcn36xx *wcn, > + struct ieee80211_vif *vif); > +int wcn36xx_pmc_exit_bmps_state(struct wcn36xx *wcn, > + struct ieee80211_vif *vif); > +int wcn36xx_enable_keep_alive_null_packet(struct wcn36xx *wcn, > + struct ieee80211_vif *vif); > +#endif /* _WCN36XX_PMC_H_ */ > diff --git a/drivers/net/wireless/ath/wcn36xx/smd.c b/drivers/net/wireless/ath/wcn36xx/smd.c > new file mode 100644 > index 0000000..f8c3a10 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/smd.c > @@ -0,0 +1,2126 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/etherdevice.h> > +#include <linux/firmware.h> > +#include <linux/bitops.h> > +#include "smd.h" > + > +static int put_cfg_tlv_u32(struct wcn36xx *wcn, size_t *len, u32 id, u32 value) > +{ > + struct wcn36xx_hal_cfg *entry; > + u32 *val; > + > + if (*len + sizeof(*entry) + sizeof(u32) >= WCN36XX_HAL_BUF_SIZE) { > + wcn36xx_err("Not enough room for TLV entry\n"); > + return -ENOMEM; > + } > + > + entry = (struct wcn36xx_hal_cfg *) (wcn->hal_buf + *len); > + entry->id = id; > + entry->len = sizeof(u32); > + entry->pad_bytes = 0; > + entry->reserve = 0; > + > + val = (u32 *) (entry + 1); > + *val = value; > + > + *len += sizeof(*entry) + sizeof(u32); > + > + return 0; > +} > + > +static void wcn36xx_smd_set_bss_nw_type(struct wcn36xx *wcn, > + struct ieee80211_sta *sta, > + struct wcn36xx_hal_config_bss_params *bss_params) > +{ > + if (IEEE80211_BAND_5GHZ == WCN36XX_BAND(wcn)) > + bss_params->nw_type = WCN36XX_HAL_11A_NW_TYPE; > + else if (sta && sta->ht_cap.ht_supported) > + bss_params->nw_type = WCN36XX_HAL_11N_NW_TYPE; > + else if (sta && (sta->supp_rates[IEEE80211_BAND_2GHZ] & 0x7f)) > + bss_params->nw_type = WCN36XX_HAL_11G_NW_TYPE; > + else > + bss_params->nw_type = WCN36XX_HAL_11B_NW_TYPE; > +} > + > +static inline u8 is_cap_supported(unsigned long caps, unsigned long flag) > +{ > + return caps & flag ? 1 : 0; > +} > +static void wcn36xx_smd_set_bss_ht_params(struct ieee80211_vif *vif, > + struct ieee80211_sta *sta, > + struct wcn36xx_hal_config_bss_params *bss_params) > +{ > + if (sta && sta->ht_cap.ht_supported) { > + unsigned long caps = sta->ht_cap.cap; > + bss_params->ht = sta->ht_cap.ht_supported; > + bss_params->tx_channel_width_set = is_cap_supported(caps, > + IEEE80211_HT_CAP_SUP_WIDTH_20_40); > + bss_params->lsig_tx_op_protection_full_support = > + is_cap_supported(caps, > + IEEE80211_HT_CAP_LSIG_TXOP_PROT); > + > + bss_params->ht_oper_mode = vif->bss_conf.ht_operation_mode; > + bss_params->lln_non_gf_coexist = > + !!(vif->bss_conf.ht_operation_mode & > + IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT); > + /* IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT */ > + bss_params->dual_cts_protection = 0; > + /* IEEE80211_HT_OP_MODE_PROTECTION_20MHZ */ > + bss_params->ht20_coexist = 0; > + } > +} > + > +static void wcn36xx_smd_set_sta_ht_params(struct ieee80211_sta *sta, > + struct wcn36xx_hal_config_sta_params *sta_params) > +{ > + if (sta->ht_cap.ht_supported) { > + unsigned long caps = sta->ht_cap.cap; > + sta_params->ht_capable = sta->ht_cap.ht_supported; > + sta_params->tx_channel_width_set = is_cap_supported(caps, > + IEEE80211_HT_CAP_SUP_WIDTH_20_40); > + sta_params->lsig_txop_protection = is_cap_supported(caps, > + IEEE80211_HT_CAP_LSIG_TXOP_PROT); > + > + sta_params->max_ampdu_size = sta->ht_cap.ampdu_factor; > + sta_params->max_ampdu_density = sta->ht_cap.ampdu_density; > + sta_params->max_amsdu_size = is_cap_supported(caps, > + IEEE80211_HT_CAP_MAX_AMSDU); > + sta_params->sgi_20Mhz = is_cap_supported(caps, > + IEEE80211_HT_CAP_SGI_20); > + sta_params->sgi_40mhz = is_cap_supported(caps, > + IEEE80211_HT_CAP_SGI_40); > + sta_params->green_field_capable = is_cap_supported(caps, > + IEEE80211_HT_CAP_GRN_FLD); > + sta_params->delayed_ba_support = is_cap_supported(caps, > + IEEE80211_HT_CAP_DELAY_BA); > + sta_params->dsss_cck_mode_40mhz = is_cap_supported(caps, > + IEEE80211_HT_CAP_DSSSCCK40); > + } > +} > + > +static void wcn36xx_smd_set_sta_params(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, > + struct ieee80211_sta *sta, > + struct wcn36xx_hal_config_sta_params *sta_params) > +{ > + struct wcn36xx_vif *priv_vif = (struct wcn36xx_vif *)vif->drv_priv; > + struct wcn36xx_sta *priv_sta = NULL; > + if (vif->type == NL80211_IFTYPE_ADHOC || > + vif->type == NL80211_IFTYPE_AP || > + vif->type == NL80211_IFTYPE_MESH_POINT) { > + sta_params->type = 1; > + sta_params->sta_index = 0xFF; > + } else { > + sta_params->type = 0; > + sta_params->sta_index = 1; > + } > + > + sta_params->listen_interval = WCN36XX_LISTEN_INTERVAL(wcn); > + > + /* > + * In STA mode ieee80211_sta contains bssid and ieee80211_vif > + * contains our mac address. In AP mode we are bssid so vif > + * contains bssid and ieee80211_sta contains mac. > + */ > + if (NL80211_IFTYPE_STATION == vif->type) > + memcpy(&sta_params->mac, vif->addr, ETH_ALEN); > + else > + memcpy(&sta_params->bssid, vif->addr, ETH_ALEN); > + > + sta_params->encrypt_type = priv_vif->encrypt_type; > + sta_params->short_preamble_supported = > + !(WCN36XX_FLAGS(wcn) & > + IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE); > + > + sta_params->rifs_mode = 0; > + sta_params->rmf = 0; > + sta_params->action = 0; > + sta_params->uapsd = 0; > + sta_params->mimo_ps = WCN36XX_HAL_HT_MIMO_PS_STATIC; > + sta_params->max_ampdu_duration = 0; > + sta_params->bssid_index = priv_vif->bss_index; > + sta_params->p2p = 0; > + > + if (sta) { > + priv_sta = (struct wcn36xx_sta *)sta->drv_priv; > + if (NL80211_IFTYPE_STATION == vif->type) > + memcpy(&sta_params->bssid, sta->addr, ETH_ALEN); > + else > + memcpy(&sta_params->mac, sta->addr, ETH_ALEN); > + sta_params->wmm_enabled = sta->wme; > + sta_params->max_sp_len = sta->max_sp; > + sta_params->aid = priv_sta->aid; > + wcn36xx_smd_set_sta_ht_params(sta, sta_params); > + memcpy(&sta_params->supported_rates, &priv_sta->supported_rates, > + sizeof(priv_sta->supported_rates)); > + } else { > + wcn36xx_set_default_rates(&sta_params->supported_rates); > + } > +} > + > +static int wcn36xx_smd_send_and_wait(struct wcn36xx *wcn, size_t len) > +{ > + int ret = 0; > + wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "HAL >>> ", wcn->hal_buf, len); > + > + init_completion(&wcn->hal_rsp_compl); > + ret = wcn->ctrl_ops->tx(wcn->hal_buf, len); > + if (ret) { > + wcn36xx_err("HAL TX failed\n"); > + goto out; > + } > + if (wait_for_completion_timeout(&wcn->hal_rsp_compl, > + msecs_to_jiffies(HAL_MSG_TIMEOUT)) <= 0) { > + wcn36xx_err("Timeout while waiting SMD response\n"); > + ret = -ETIME; > + goto out; > + } > +out: > + return ret; > +} > + > +#define INIT_HAL_MSG(msg_body, type) \ > + do { \ > + memset(&msg_body, 0, sizeof(msg_body)); \ > + msg_body.header.msg_type = type; \ > + msg_body.header.msg_version = WCN36XX_HAL_MSG_VERSION0; \ > + msg_body.header.len = sizeof(msg_body); \ > + } while (0) \ > + > +#define PREPARE_HAL_BUF(send_buf, msg_body) \ > + do { \ > + memset(send_buf, 0, msg_body.header.len); \ > + memcpy(send_buf, &msg_body, sizeof(msg_body)); \ > + } while (0) \ > + > +static int wcn36xx_smd_rsp_status_check(void *buf, size_t len) > +{ > + struct wcn36xx_fw_msg_status_rsp *rsp; > + > + if (len < sizeof(struct wcn36xx_hal_msg_header) + > + sizeof(struct wcn36xx_fw_msg_status_rsp)) > + return -EIO; > + > + rsp = (struct wcn36xx_fw_msg_status_rsp *) > + (buf + sizeof(struct wcn36xx_hal_msg_header)); > + > + if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status) > + return rsp->status; > + > + return 0; > +} > + > +int wcn36xx_smd_load_nv(struct wcn36xx *wcn) > +{ > + const struct firmware *nv; > + struct nv_data *nv_d; > + struct wcn36xx_hal_nv_img_download_req_msg msg_body; > + int fw_bytes_left; > + int ret; > + u16 fm_offset = 0; > + > + ret = request_firmware(&nv, WLAN_NV_FILE, wcn->dev); > + if (ret) { > + wcn36xx_err("Failed to load nv file %s: %d\n", > + WLAN_NV_FILE, ret); > + goto out_free_nv; > + } > + > + nv_d = (struct nv_data *)nv->data; > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_DOWNLOAD_NV_REQ); > + > + msg_body.header.len += WCN36XX_NV_FRAGMENT_SIZE; > + > + msg_body.frag_number = 0; > + /* hal_buf must be protected with mutex */ > + mutex_lock(&wcn->hal_mutex); > + > + do { > + fw_bytes_left = nv->size - fm_offset - 4; > + if (fw_bytes_left > WCN36XX_NV_FRAGMENT_SIZE) { > + msg_body.last_fragment = 0; > + msg_body.nv_img_buffer_size = WCN36XX_NV_FRAGMENT_SIZE; > + } else { > + msg_body.last_fragment = 1; > + msg_body.nv_img_buffer_size = fw_bytes_left; > + > + /* Do not forget update general message len */ > + msg_body.header.len = sizeof(msg_body) + fw_bytes_left; > + > + } > + > + /* Add load NV request message header */ > + memcpy(wcn->hal_buf, &msg_body, sizeof(msg_body)); > + > + /* Add NV body itself */ > + memcpy(wcn->hal_buf + sizeof(msg_body), > + &nv_d->table + fm_offset, > + msg_body.nv_img_buffer_size); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) > + goto out_unlock; > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, > + wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_load_nv response failed err=%d\n", > + ret); > + goto out_unlock; > + } > + msg_body.frag_number++; > + fm_offset += WCN36XX_NV_FRAGMENT_SIZE; > + > + } while (msg_body.last_fragment != 1); > + > +out_unlock: > + mutex_unlock(&wcn->hal_mutex); > +out_free_nv: > + release_firmware(nv); > + > + return ret; > +} > + > +static int wcn36xx_smd_start_rsp(struct wcn36xx *wcn, void *buf, size_t len) > +{ > + struct wcn36xx_hal_mac_start_rsp_msg *rsp; > + > + if (len < sizeof(*rsp)) > + return -EIO; > + > + rsp = (struct wcn36xx_hal_mac_start_rsp_msg *)buf; > + > + if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->start_rsp_params.status) > + return -EIO; > + > + memcpy(wcn->crm_version, rsp->start_rsp_params.crm_version, > + WCN36XX_HAL_VERSION_LENGTH); > + memcpy(wcn->wlan_version, rsp->start_rsp_params.wlan_version, > + WCN36XX_HAL_VERSION_LENGTH); > + > + /* null terminate the strings, just in case */ > + wcn->crm_version[WCN36XX_HAL_VERSION_LENGTH] = '\0'; > + wcn->wlan_version[WCN36XX_HAL_VERSION_LENGTH] = '\0'; > + > + wcn->fw_revision = rsp->start_rsp_params.version.revision; > + wcn->fw_version = rsp->start_rsp_params.version.version; > + wcn->fw_minor = rsp->start_rsp_params.version.minor; > + wcn->fw_major = rsp->start_rsp_params.version.major; > + > + wcn36xx_info("firmware WLAN version '%s' and CRM version '%s'\n", > + wcn->wlan_version, wcn->crm_version); > + > + wcn36xx_info("firmware API %u.%u.%u.%u, %u stations, %u bssids\n", > + wcn->fw_major, wcn->fw_minor, > + wcn->fw_version, wcn->fw_revision, > + rsp->start_rsp_params.stations, > + rsp->start_rsp_params.bssids); > + > + return 0; > +} > + > +int wcn36xx_smd_start(struct wcn36xx *wcn) > +{ > + struct wcn36xx_hal_mac_start_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_REQ); > + > + msg_body.params.type = DRIVER_TYPE_PRODUCTION; > + msg_body.params.len = 0; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start type %d\n", > + msg_body.params.type); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_start failed\n"); > + goto out; > + } > + > + ret = wcn36xx_smd_start_rsp(wcn, wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_start response failed err=%d\n", ret); > + goto out; > + } > + > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_stop(struct wcn36xx *wcn) > +{ > + struct wcn36xx_hal_mac_stop_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_STOP_REQ); > + > + msg_body.stop_req_params.reason = HAL_STOP_TYPE_RF_KILL; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_stop failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_stop response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_init_scan(struct wcn36xx *wcn, enum wcn36xx_hal_sys_mode mode) > +{ > + struct wcn36xx_hal_init_scan_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_INIT_SCAN_REQ); > + > + msg_body.mode = mode; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, "hal init scan mode %d\n", msg_body.mode); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_init_scan failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_init_scan response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_start_scan(struct wcn36xx *wcn) > +{ > + struct wcn36xx_hal_start_scan_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_SCAN_REQ); > + > + msg_body.scan_channel = WCN36XX_HW_CHANNEL(wcn); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start scan channel %d\n", > + msg_body.scan_channel); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_start_scan failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_start_scan response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_end_scan(struct wcn36xx *wcn) > +{ > + struct wcn36xx_hal_end_scan_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_END_SCAN_REQ); > + > + msg_body.scan_channel = WCN36XX_HW_CHANNEL(wcn); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, "hal end scan channel %d\n", > + msg_body.scan_channel); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_end_scan failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_end_scan response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_finish_scan(struct wcn36xx *wcn, > + enum wcn36xx_hal_sys_mode mode) > +{ > + struct wcn36xx_hal_finish_scan_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_FINISH_SCAN_REQ); > + > + msg_body.mode = mode; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, "hal finish scan mode %d\n", > + msg_body.mode); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_finish_scan failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_finish_scan response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static int wcn36xx_smd_switch_channel_rsp(void *buf, size_t len) > +{ > + struct wcn36xx_hal_switch_channel_rsp_msg *rsp; > + int ret = 0; > + > + ret = wcn36xx_smd_rsp_status_check(buf, len); > + if (ret) > + return ret; > + rsp = (struct wcn36xx_hal_switch_channel_rsp_msg *)buf; > + wcn36xx_dbg(WCN36XX_DBG_HAL, "channel switched to: %d, status: %d\n", > + rsp->channel_number, rsp->status); > + return ret; > +} > + > +int wcn36xx_smd_switch_channel(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, int ch) > +{ > + struct wcn36xx_hal_switch_channel_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_CH_SWITCH_REQ); > + > + msg_body.channel_number = (u8)ch; > + msg_body.tx_mgmt_power = 0xbf; > + msg_body.max_tx_power = 0xbf; > + memcpy(msg_body.self_sta_mac_addr, vif->addr, ETH_ALEN); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_switch_channel failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_switch_channel_rsp(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_switch_channel response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static int wcn36xx_smd_update_scan_params_rsp(void *buf, size_t len) > +{ > + struct wcn36xx_hal_update_scan_params_resp *rsp; > + > + rsp = (struct wcn36xx_hal_update_scan_params_resp *)buf; > + > + /* Remove the PNO version bit */ > + rsp->status &= (~(WCN36XX_FW_MSG_PNO_VERSION_MASK)); > + > + if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status) { > + wcn36xx_warn("error response from update scan\n"); > + return rsp->status; > + } > + > + return 0; > +} > + > +int wcn36xx_smd_update_scan_params(struct wcn36xx *wcn) > +{ > + struct wcn36xx_hal_update_scan_params_req msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_SCAN_PARAM_REQ); > + > + msg_body.dot11d_enabled = 0; > + msg_body.dot11d_resolved = 0; > + msg_body.channel_count = 26; > + msg_body.active_min_ch_time = 60; > + msg_body.active_max_ch_time = 120; > + msg_body.passive_min_ch_time = 60; > + msg_body.passive_max_ch_time = 110; > + msg_body.state = 0; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal update scan params channel_count %d\n", > + msg_body.channel_count); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_update_scan_params failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_update_scan_params_rsp(wcn->hal_buf, > + wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_update_scan_params response failed err=%d\n", > + ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static int wcn36xx_smd_add_sta_self_rsp(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, > + void *buf, > + size_t len) > +{ > + struct wcn36xx_hal_add_sta_self_rsp_msg *rsp; > + struct wcn36xx_vif *priv_vif = (struct wcn36xx_vif *)vif->drv_priv; > + > + if (len < sizeof(*rsp)) > + return -EINVAL; > + > + rsp = (struct wcn36xx_hal_add_sta_self_rsp_msg *)buf; > + > + if (rsp->status != WCN36XX_FW_MSG_RESULT_SUCCESS) { > + wcn36xx_warn("hal add sta self failure: %d\n", > + rsp->status); > + return rsp->status; > + } > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal add sta self status %d self_sta_index %d dpu_index %d\n", > + rsp->status, rsp->self_sta_index, rsp->dpu_index); > + > + priv_vif->self_sta_index = rsp->self_sta_index; > + priv_vif->self_dpu_desc_index = rsp->dpu_index; > + > + return 0; > +} > + > +int wcn36xx_smd_add_sta_self(struct wcn36xx *wcn, struct ieee80211_vif *vif) > +{ > + struct wcn36xx_hal_add_sta_self_req msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_STA_SELF_REQ); > + > + memcpy(&msg_body.self_addr, vif->addr, ETH_ALEN); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal add sta self self_addr %pM status %d\n", > + msg_body.self_addr, msg_body.status); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_add_sta_self failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_add_sta_self_rsp(wcn, > + vif, > + wcn->hal_buf, > + wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_add_sta_self response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_delete_sta_self(struct wcn36xx *wcn, u8 *addr) > +{ > + struct wcn36xx_hal_del_sta_self_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_STA_SELF_REQ); > + > + memcpy(&msg_body.self_addr, addr, ETH_ALEN); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_delete_sta_self failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_delete_sta_self response failed err=%d\n", > + ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_delete_sta(struct wcn36xx *wcn, u8 sta_index) > +{ > + struct wcn36xx_hal_delete_sta_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_STA_REQ); > + > + msg_body.sta_index = sta_index; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal delete sta sta_index %d\n", > + msg_body.sta_index); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_delete_sta failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_delete_sta response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static int wcn36xx_smd_join_rsp(void *buf, size_t len) > +{ > + struct wcn36xx_hal_join_rsp_msg *rsp; > + > + if (wcn36xx_smd_rsp_status_check(buf, len)) > + return -EIO; > + > + rsp = (struct wcn36xx_hal_join_rsp_msg *)buf; > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal rsp join status %d tx_mgmt_power %d\n", > + rsp->status, rsp->tx_mgmt_power); > + > + return 0; > +} > + > +int wcn36xx_smd_join(struct wcn36xx *wcn, const u8 *bssid, u8 *vif, u8 ch) > +{ > + struct wcn36xx_hal_join_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_JOIN_REQ); > + > + memcpy(&msg_body.bssid, bssid, ETH_ALEN); > + memcpy(&msg_body.self_sta_mac_addr, vif, ETH_ALEN); > + msg_body.channel = ch; > + > + if (conf_is_ht40_minus(&wcn->hw->conf)) > + msg_body.secondary_channel_offset = > + PHY_DOUBLE_CHANNEL_HIGH_PRIMARY; > + else if (conf_is_ht40_plus(&wcn->hw->conf)) > + msg_body.secondary_channel_offset = > + PHY_DOUBLE_CHANNEL_LOW_PRIMARY; > + else > + msg_body.secondary_channel_offset = > + PHY_SINGLE_CHANNEL_CENTERED; > + > + msg_body.link_state = WCN36XX_HAL_LINK_PREASSOC_STATE; > + > + msg_body.max_tx_power = 0xbf; > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal join req bssid %pM self_sta_mac_addr %pM channel %d link_state %d\n", > + msg_body.bssid, msg_body.self_sta_mac_addr, > + msg_body.channel, msg_body.link_state); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_join failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_join_rsp(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_join response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_set_link_st(struct wcn36xx *wcn, const u8 *bssid, > + const u8 *sta_mac, > + enum wcn36xx_hal_link_state state) > +{ > + struct wcn36xx_hal_set_link_state_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_LINK_ST_REQ); > + > + memcpy(&msg_body.bssid, bssid, ETH_ALEN); > + memcpy(&msg_body.self_mac_addr, sta_mac, ETH_ALEN); > + msg_body.state = state; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal set link state bssid %pM self_mac_addr %pM state %d\n", > + msg_body.bssid, msg_body.self_mac_addr, msg_body.state); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_set_link_st failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_set_link_st response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static void wcn36xx_smd_convert_sta_to_v1(struct wcn36xx *wcn, > + const struct wcn36xx_hal_config_sta_params *orig, > + struct wcn36xx_hal_config_sta_params_v1 *v1) > +{ > + /* convert orig to v1 format */ > + memcpy(&v1->bssid, orig->bssid, ETH_ALEN); > + memcpy(&v1->mac, orig->mac, ETH_ALEN); > + v1->aid = orig->aid; > + v1->type = orig->type; > + v1->listen_interval = orig->listen_interval; > + v1->ht_capable = orig->ht_capable; > + > + v1->max_ampdu_size = orig->max_ampdu_size; > + v1->max_ampdu_density = orig->max_ampdu_density; > + v1->sgi_40mhz = orig->sgi_40mhz; > + v1->sgi_20Mhz = orig->sgi_20Mhz; > + > + memcpy(&v1->supported_rates, &orig->supported_rates, > + sizeof(orig->supported_rates)); > + v1->sta_index = orig->sta_index; > +} > + > +static int wcn36xx_smd_config_sta_rsp(struct wcn36xx *wcn, > + struct ieee80211_sta *sta, > + void *buf, > + size_t len) > +{ > + struct wcn36xx_hal_config_sta_rsp_msg *rsp; > + struct config_sta_rsp_params *params; > + struct wcn36xx_sta *sta_priv = (struct wcn36xx_sta *)sta->drv_priv; > + > + if (len < sizeof(*rsp)) > + return -EINVAL; > + > + rsp = (struct wcn36xx_hal_config_sta_rsp_msg *)buf; > + params = &rsp->params; > + > + if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) { > + wcn36xx_warn("hal config sta response failure: %d\n", > + params->status); > + return -EIO; > + } > + > + sta_priv->sta_index = params->sta_index; > + sta_priv->dpu_desc_index = params->dpu_index; > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal config sta rsp status %d sta_index %d bssid_index %d p2p %d\n", > + params->status, params->sta_index, params->bssid_index, > + params->p2p); > + > + return 0; > +} > + > +static int wcn36xx_smd_config_sta_v1(struct wcn36xx *wcn, > + const struct wcn36xx_hal_config_sta_req_msg *orig) > +{ > + struct wcn36xx_hal_config_sta_req_msg_v1 msg_body; > + struct wcn36xx_hal_config_sta_params_v1 *sta = &msg_body.sta_params; > + > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_CONFIG_STA_REQ); > + > + wcn36xx_smd_convert_sta_to_v1(wcn, &orig->sta_params, > + &msg_body.sta_params); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal config sta v1 action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n", > + sta->action, sta->sta_index, sta->bssid_index, > + sta->bssid, sta->type, sta->mac, sta->aid); > + > + return wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > +} > + > +int wcn36xx_smd_config_sta(struct wcn36xx *wcn, struct ieee80211_vif *vif, > + struct ieee80211_sta *sta) > +{ > + struct wcn36xx_hal_config_sta_req_msg msg; > + struct wcn36xx_hal_config_sta_params *sta_params; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg, WCN36XX_HAL_CONFIG_STA_REQ); > + > + sta_params = &msg.sta_params; > + > + wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params); > + > + if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) { > + ret = wcn36xx_smd_config_sta_v1(wcn, &msg); > + } else { > + PREPARE_HAL_BUF(wcn->hal_buf, msg); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal config sta action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n", > + sta_params->action, sta_params->sta_index, > + sta_params->bssid_index, sta_params->bssid, > + sta_params->type, sta_params->mac, sta_params->aid); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len); > + } > + if (ret) { > + wcn36xx_err("Sending hal_config_sta failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_config_sta_rsp(wcn, > + sta, > + wcn->hal_buf, > + wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_config_sta response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static int wcn36xx_smd_config_bss_v1(struct wcn36xx *wcn, > + const struct wcn36xx_hal_config_bss_req_msg *orig) > +{ > + struct wcn36xx_hal_config_bss_req_msg_v1 msg_body; > + struct wcn36xx_hal_config_bss_params_v1 *bss = &msg_body.bss_params; > + struct wcn36xx_hal_config_sta_params_v1 *sta = &bss->sta; > + > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_CONFIG_BSS_REQ); > + > + /* convert orig to v1 */ > + memcpy(&msg_body.bss_params.bssid, > + &orig->bss_params.bssid, ETH_ALEN); > + memcpy(&msg_body.bss_params.self_mac_addr, > + &orig->bss_params.self_mac_addr, ETH_ALEN); > + > + msg_body.bss_params.bss_type = orig->bss_params.bss_type; > + msg_body.bss_params.oper_mode = orig->bss_params.oper_mode; > + msg_body.bss_params.nw_type = orig->bss_params.nw_type; > + > + msg_body.bss_params.short_slot_time_supported = > + orig->bss_params.short_slot_time_supported; > + msg_body.bss_params.lla_coexist = orig->bss_params.lla_coexist; > + msg_body.bss_params.llb_coexist = orig->bss_params.llb_coexist; > + msg_body.bss_params.llg_coexist = orig->bss_params.llg_coexist; > + msg_body.bss_params.ht20_coexist = orig->bss_params.ht20_coexist; > + msg_body.bss_params.lln_non_gf_coexist = > + orig->bss_params.lln_non_gf_coexist; > + > + msg_body.bss_params.lsig_tx_op_protection_full_support = > + orig->bss_params.lsig_tx_op_protection_full_support; > + msg_body.bss_params.rifs_mode = orig->bss_params.rifs_mode; > + msg_body.bss_params.beacon_interval = orig->bss_params.beacon_interval; > + msg_body.bss_params.dtim_period = orig->bss_params.dtim_period; > + msg_body.bss_params.tx_channel_width_set = > + orig->bss_params.tx_channel_width_set; > + msg_body.bss_params.oper_channel = orig->bss_params.oper_channel; > + msg_body.bss_params.ext_channel = orig->bss_params.ext_channel; > + > + msg_body.bss_params.reserved = orig->bss_params.reserved; > + > + memcpy(&msg_body.bss_params.ssid, > + &orig->bss_params.ssid, > + sizeof(orig->bss_params.ssid)); > + > + msg_body.bss_params.action = orig->bss_params.action; > + msg_body.bss_params.rateset = orig->bss_params.rateset; > + msg_body.bss_params.ht = orig->bss_params.ht; > + msg_body.bss_params.obss_prot_enabled = > + orig->bss_params.obss_prot_enabled; > + msg_body.bss_params.rmf = orig->bss_params.rmf; > + msg_body.bss_params.ht_oper_mode = orig->bss_params.ht_oper_mode; > + msg_body.bss_params.dual_cts_protection = > + orig->bss_params.dual_cts_protection; > + > + msg_body.bss_params.max_probe_resp_retry_limit = > + orig->bss_params.max_probe_resp_retry_limit; > + msg_body.bss_params.hidden_ssid = orig->bss_params.hidden_ssid; > + msg_body.bss_params.proxy_probe_resp = > + orig->bss_params.proxy_probe_resp; > + msg_body.bss_params.edca_params_valid = > + orig->bss_params.edca_params_valid; > + > + memcpy(&msg_body.bss_params.acbe, > + &orig->bss_params.acbe, > + sizeof(orig->bss_params.acbe)); > + memcpy(&msg_body.bss_params.acbk, > + &orig->bss_params.acbk, > + sizeof(orig->bss_params.acbk)); > + memcpy(&msg_body.bss_params.acvi, > + &orig->bss_params.acvi, > + sizeof(orig->bss_params.acvi)); > + memcpy(&msg_body.bss_params.acvo, > + &orig->bss_params.acvo, > + sizeof(orig->bss_params.acvo)); > + > + msg_body.bss_params.ext_set_sta_key_param_valid = > + orig->bss_params.ext_set_sta_key_param_valid; > + > + memcpy(&msg_body.bss_params.ext_set_sta_key_param, > + &orig->bss_params.ext_set_sta_key_param, > + sizeof(orig->bss_params.acvo)); > + > + msg_body.bss_params.wcn36xx_hal_persona = > + orig->bss_params.wcn36xx_hal_persona; > + msg_body.bss_params.spectrum_mgt_enable = > + orig->bss_params.spectrum_mgt_enable; > + msg_body.bss_params.tx_mgmt_power = orig->bss_params.tx_mgmt_power; > + msg_body.bss_params.max_tx_power = orig->bss_params.max_tx_power; > + > + wcn36xx_smd_convert_sta_to_v1(wcn, &orig->bss_params.sta, > + &msg_body.bss_params.sta); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal config bss v1 bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n", > + bss->bssid, bss->self_mac_addr, bss->bss_type, > + bss->oper_mode, bss->nw_type); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n", > + sta->bssid, sta->action, sta->sta_index, > + sta->bssid_index, sta->aid, sta->type, sta->mac); > + > + return wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > +} > + > + > +static int wcn36xx_smd_config_bss_rsp(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, > + void *buf, > + size_t len) > +{ > + struct wcn36xx_hal_config_bss_rsp_msg *rsp; > + struct wcn36xx_hal_config_bss_rsp_params *params; > + struct wcn36xx_vif *priv_vif = (struct wcn36xx_vif *)vif->drv_priv; > + > + if (len < sizeof(*rsp)) > + return -EINVAL; > + > + rsp = (struct wcn36xx_hal_config_bss_rsp_msg *)buf; > + params = &rsp->bss_rsp_params; > + > + if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) { > + wcn36xx_warn("hal config bss response failure: %d\n", > + params->status); > + return -EIO; > + } > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal config bss rsp status %d bss_idx %d dpu_desc_index %d" > + " sta_idx %d self_idx %d bcast_idx %d mac %pM" > + " power %d ucast_dpu_signature %d\n", > + params->status, params->bss_index, params->dpu_desc_index, > + params->bss_sta_index, params->bss_self_sta_index, > + params->bss_bcast_sta_idx, params->mac, > + params->tx_mgmt_power, params->ucast_dpu_signature); > + > + priv_vif->bss_index = params->bss_index; > + > + if (priv_vif->sta) { > + priv_vif->sta->bss_sta_index = params->bss_sta_index; > + priv_vif->sta->bss_dpu_desc_index = params->dpu_desc_index; > + } > + > + priv_vif->ucast_dpu_signature = params->ucast_dpu_signature; > + > + return 0; > +} > + > +int wcn36xx_smd_config_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif, > + struct ieee80211_sta *sta, const u8 *bssid, > + bool update) > +{ > + struct wcn36xx_hal_config_bss_req_msg msg; > + struct wcn36xx_hal_config_bss_params *bss; > + struct wcn36xx_hal_config_sta_params *sta_params; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg, WCN36XX_HAL_CONFIG_BSS_REQ); > + > + bss = &msg.bss_params; > + sta_params = &bss->sta; > + > + WARN_ON(is_zero_ether_addr(bssid)); > + > + memcpy(&bss->bssid, bssid, ETH_ALEN); > + > + memcpy(bss->self_mac_addr, vif->addr, ETH_ALEN); > + > + if (vif->type == NL80211_IFTYPE_STATION) { > + bss->bss_type = WCN36XX_HAL_INFRASTRUCTURE_MODE; > + > + /* STA */ > + bss->oper_mode = 1; > + bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_MODE; > + } else if (vif->type == NL80211_IFTYPE_AP) { > + bss->bss_type = WCN36XX_HAL_INFRA_AP_MODE; > + > + /* AP */ > + bss->oper_mode = 0; > + bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_SAP_MODE; > + } else if (vif->type == NL80211_IFTYPE_ADHOC || > + vif->type == NL80211_IFTYPE_MESH_POINT) { > + bss->bss_type = WCN36XX_HAL_IBSS_MODE; > + > + /* STA */ > + bss->oper_mode = 1; > + } else { > + wcn36xx_warn("Unknown type for bss config: %d\n", vif->type); > + } > + > + if (vif->type == NL80211_IFTYPE_STATION) > + wcn36xx_smd_set_bss_nw_type(wcn, sta, bss); > + else > + bss->nw_type = WCN36XX_HAL_11N_NW_TYPE; > + > + bss->short_slot_time_supported = vif->bss_conf.use_short_slot; > + bss->lla_coexist = 0; > + bss->llb_coexist = 0; > + bss->llg_coexist = 0; > + bss->rifs_mode = 0; > + bss->beacon_interval = vif->bss_conf.beacon_int; > + bss->dtim_period = vif_priv->dtim_period; > + > + wcn36xx_smd_set_bss_ht_params(vif, sta, bss); > + > + bss->oper_channel = WCN36XX_HW_CHANNEL(wcn); > + > + if (conf_is_ht40_minus(&wcn->hw->conf)) > + bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_BELOW; > + else if (conf_is_ht40_plus(&wcn->hw->conf)) > + bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; > + else > + bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_NONE; > + > + bss->reserved = 0; > + wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params); > + > + /* wcn->ssid is only valid in AP and IBSS mode */ > + bss->ssid.length = vif_priv->ssid.length; > + memcpy(bss->ssid.ssid, vif_priv->ssid.ssid, vif_priv->ssid.length); > + > + bss->obss_prot_enabled = 0; > + bss->rmf = 0; > + bss->max_probe_resp_retry_limit = 0; > + bss->hidden_ssid = vif->bss_conf.hidden_ssid; > + bss->proxy_probe_resp = 0; > + bss->edca_params_valid = 0; > + > + /* FIXME: set acbe, acbk, acvi and acvo */ > + > + bss->ext_set_sta_key_param_valid = 0; > + > + /* FIXME: set ext_set_sta_key_param */ > + > + bss->spectrum_mgt_enable = 0; > + bss->tx_mgmt_power = 0; > + bss->max_tx_power = WCN36XX_MAX_POWER(wcn); > + > + bss->action = update; > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal config bss bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n", > + bss->bssid, bss->self_mac_addr, bss->bss_type, > + bss->oper_mode, bss->nw_type); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n", > + sta_params->bssid, sta_params->action, > + sta_params->sta_index, sta_params->bssid_index, > + sta_params->aid, sta_params->type, > + sta_params->mac); > + > + if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) { > + ret = wcn36xx_smd_config_bss_v1(wcn, &msg); > + } else { > + PREPARE_HAL_BUF(wcn->hal_buf, msg); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len); > + } > + if (ret) { > + wcn36xx_err("Sending hal_config_bss failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_config_bss_rsp(wcn, > + vif, > + wcn->hal_buf, > + wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_config_bss response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_delete_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif) > +{ > + struct wcn36xx_hal_delete_bss_req_msg msg_body; > + struct wcn36xx_vif *priv_vif = (struct wcn36xx_vif *)vif->drv_priv; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_BSS_REQ); > + > + msg_body.bss_index = priv_vif->bss_index; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, "hal delete bss %d\n", msg_body.bss_index); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_delete_bss failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_delete_bss response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_send_beacon(struct wcn36xx *wcn, struct ieee80211_vif *vif, > + struct sk_buff *skb_beacon, u16 tim_off, > + u16 p2p_off) > +{ > + struct wcn36xx_hal_send_beacon_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_SEND_BEACON_REQ); > + > + /* TODO need to find out why this is needed? */ > + msg_body.beacon_length = skb_beacon->len + 6; > + > + if (BEACON_TEMPLATE_SIZE > msg_body.beacon_length) { > + memcpy(&msg_body.beacon, &skb_beacon->len, sizeof(u32)); > + memcpy(&(msg_body.beacon[4]), skb_beacon->data, > + skb_beacon->len); > + } else { > + wcn36xx_err("Beacon is to big: beacon size=%d\n", > + msg_body.beacon_length); > + return -ENOMEM; > + } > + memcpy(msg_body.bssid, vif->addr, ETH_ALEN); > + > + /* TODO need to find out why this is needed? */ > + msg_body.tim_ie_offset = tim_off+4; > + msg_body.p2p_ie_offset = p2p_off; > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal send beacon beacon_length %d\n", > + msg_body.beacon_length); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_send_beacon failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_send_beacon response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_update_proberesp_tmpl(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, > + struct sk_buff *skb) > +{ > + struct wcn36xx_hal_send_probe_resp_req_msg msg; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg, WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ); > + > + if (skb->len > BEACON_TEMPLATE_SIZE) { > + wcn36xx_warn("probe response template is too big: %d\n", > + skb->len); > + return -E2BIG; > + } > + > + msg.probe_resp_template_len = skb->len; > + memcpy(&msg.probe_resp_template, skb->data, skb->len); > + > + memcpy(msg.bssid, vif->addr, ETH_ALEN); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg); > + > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "hal update probe rsp len %d bssid %pM\n", > + msg.probe_resp_template_len, msg.bssid); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_update_proberesp_tmpl failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_update_proberesp_tmpl response failed err=%d\n", > + ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_set_stakey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx, > + u8 keylen, > + u8 *key, > + u8 sta_index) > +{ > + struct wcn36xx_hal_set_sta_key_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_STAKEY_REQ); > + > + msg_body.set_sta_key_params.sta_index = sta_index; > + msg_body.set_sta_key_params.enc_type = enc_type; > + > + msg_body.set_sta_key_params.key[0].id = keyidx; > + msg_body.set_sta_key_params.key[0].unicast = 1; > + msg_body.set_sta_key_params.key[0].direction = WCN36XX_HAL_TX_RX; > + msg_body.set_sta_key_params.key[0].pae_role = 0; > + msg_body.set_sta_key_params.key[0].length = keylen; > + memcpy(msg_body.set_sta_key_params.key[0].key, key, keylen); > + msg_body.set_sta_key_params.single_tid_rc = 1; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_set_stakey failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_set_stakey response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_set_bsskey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx, > + u8 keylen, > + u8 *key) > +{ > + struct wcn36xx_hal_set_bss_key_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_BSSKEY_REQ); > + msg_body.bss_idx = 0; > + msg_body.enc_type = enc_type; > + msg_body.num_keys = 1; > + msg_body.keys[0].id = keyidx; > + msg_body.keys[0].unicast = 0; > + msg_body.keys[0].direction = WCN36XX_HAL_RX_ONLY; > + msg_body.keys[0].pae_role = 0; > + msg_body.keys[0].length = keylen; > + memcpy(msg_body.keys[0].key, key, keylen); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_set_bsskey failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_set_bsskey response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_remove_stakey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx, > + u8 sta_index) > +{ > + struct wcn36xx_hal_remove_sta_key_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_STAKEY_REQ); > + > + msg_body.sta_idx = sta_index; > + msg_body.enc_type = enc_type; > + msg_body.key_id = keyidx; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_remove_stakey failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_remove_stakey response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_remove_bsskey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx) > +{ > + struct wcn36xx_hal_remove_bss_key_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_BSSKEY_REQ); > + msg_body.bss_idx = 0; > + msg_body.enc_type = enc_type; > + msg_body.key_id = keyidx; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_remove_bsskey failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_remove_bsskey response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_enter_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif) > +{ > + struct wcn36xx_hal_enter_bmps_req_msg msg_body; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_ENTER_BMPS_REQ); > + > + msg_body.bss_index = vif_priv->bss_index; > + msg_body.tbtt = vif->bss_conf.sync_tsf; > + msg_body.dtim_period = vif_priv->dtim_period; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_enter_bmps failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_enter_bmps response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_exit_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif) > +{ > + struct wcn36xx_hal_enter_bmps_req_msg msg_body; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_EXIT_BMPS_REQ); > + > + msg_body.bss_index = vif_priv->bss_index; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_exit_bmps failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_exit_bmps response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > +int wcn36xx_smd_set_power_params(struct wcn36xx *wcn, bool ignore_dtim) > +{ > + struct wcn36xx_hal_set_power_params_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_POWER_PARAMS_REQ); > + > + /* > + * When host is down ignore every second dtim > + */ > + if (ignore_dtim) { > + msg_body.ignore_dtim = 1; > + msg_body.dtim_period = 2; > + } > + msg_body.listen_interval = WCN36XX_LISTEN_INTERVAL(wcn); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_set_power_params failed\n"); > + goto out; > + } > + > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > +/* Notice: This function should be called after associated, or else it > + * will be invalid > + */ > +int wcn36xx_smd_keep_alive_req(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, > + int packet_type) > +{ > + struct wcn36xx_hal_keep_alive_req_msg msg_body; > + struct wcn36xx_vif *vif_priv = (struct wcn36xx_vif *)vif->drv_priv; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_KEEP_ALIVE_REQ); > + > + if (packet_type == WCN36XX_HAL_KEEP_ALIVE_NULL_PKT) { > + msg_body.bss_index = vif_priv->bss_index; > + msg_body.packet_type = WCN36XX_HAL_KEEP_ALIVE_NULL_PKT; > + msg_body.time_period = WCN36XX_KEEP_ALIVE_TIME_PERIOD; > + } else if (packet_type == WCN36XX_HAL_KEEP_ALIVE_UNSOLICIT_ARP_RSP) { > + /* TODO: it also support ARP response type */ > + } else { > + wcn36xx_warn("unknow keep alive packet type %d\n", packet_type); > + return -EINVAL; > + } > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_exit_bmps failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_exit_bmps response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_dump_cmd_req(struct wcn36xx *wcn, u32 arg1, u32 arg2, > + u32 arg3, u32 arg4, u32 arg5) > +{ > + struct wcn36xx_hal_dump_cmd_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_DUMP_COMMAND_REQ); > + > + msg_body.arg1 = arg1; > + msg_body.arg2 = arg2; > + msg_body.arg3 = arg3; > + msg_body.arg4 = arg4; > + msg_body.arg5 = arg5; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_dump_cmd failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_dump_cmd response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static inline void set_feat_caps(u32 *bitmap, > + enum place_holder_in_cap_bitmap cap) > +{ > + int arr_idx, bit_idx; > + > + if (cap < 0 || cap > 127) { > + wcn36xx_warn("error cap idx %d\n", cap); > + return; > + } > + > + arr_idx = cap / 32; > + bit_idx = cap % 32; > + bitmap[arr_idx] |= (1 << bit_idx); > +} > + > +static inline int get_feat_caps(u32 *bitmap, > + enum place_holder_in_cap_bitmap cap) > +{ > + int arr_idx, bit_idx; > + int ret = 0; > + > + if (cap < 0 || cap > 127) { > + wcn36xx_warn("error cap idx %d\n", cap); > + return -EINVAL; > + } > + > + arr_idx = cap / 32; > + bit_idx = cap % 32; > + ret = (bitmap[arr_idx] & (1 << bit_idx)) ? 1 : 0; > + return ret; > +} > + > +static inline void clear_feat_caps(u32 *bitmap, > + enum place_holder_in_cap_bitmap cap) > +{ > + int arr_idx, bit_idx; > + > + if (cap < 0 || cap > 127) { > + wcn36xx_warn("error cap idx %d\n", cap); > + return; > + } > + > + arr_idx = cap / 32; > + bit_idx = cap % 32; > + bitmap[arr_idx] &= ~(1 << bit_idx); > +} > + > +int wcn36xx_smd_feature_caps_exchange(struct wcn36xx *wcn) > +{ > + struct wcn36xx_hal_feat_caps_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ); > + > + set_feat_caps(msg_body.feat_caps, STA_POWERSAVE); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_feature_caps_exchange failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_feature_caps_exchange response failed err=%d\n", > + ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_add_ba_session(struct wcn36xx *wcn, > + struct ieee80211_sta *sta, > + u16 tid, > + u16 *ssn, > + u8 direction, > + u8 sta_index) > +{ > + struct wcn36xx_hal_add_ba_session_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_SESSION_REQ); > + > + msg_body.sta_index = sta_index; > + memcpy(&msg_body.mac_addr, sta->addr, ETH_ALEN); > + msg_body.dialog_token = 0x10; > + msg_body.tid = tid; > + > + /* Immediate BA because Delayed BA is not supported */ > + msg_body.policy = 1; > + msg_body.buffer_size = WCN36XX_AGGR_BUFFER_SIZE; > + msg_body.timeout = 0; > + if (ssn) > + msg_body.ssn = *ssn; > + msg_body.direction = direction; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_add_ba_session failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_add_ba_session response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_add_ba(struct wcn36xx *wcn) > +{ > + struct wcn36xx_hal_add_ba_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_REQ); > + > + msg_body.session_id = 0; > + msg_body.win_size = WCN36XX_AGGR_BUFFER_SIZE; > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_add_ba failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_add_ba response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_del_ba(struct wcn36xx *wcn, u16 tid, u8 sta_index) > +{ > + struct wcn36xx_hal_del_ba_req_msg msg_body; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_BA_REQ); > + > + msg_body.sta_index = sta_index; > + msg_body.tid = tid; > + msg_body.direction = 0; > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_del_ba failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_del_ba response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +int wcn36xx_smd_trigger_ba(struct wcn36xx *wcn, u8 sta_index) > +{ > + struct wcn36xx_hal_trigger_ba_req_msg msg_body; > + struct wcn36xx_hal_trigget_ba_req_candidate *candidate; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_TRIGGER_BA_REQ); > + > + msg_body.session_id = 0; > + msg_body.candidate_cnt = 1; > + msg_body.header.len += sizeof(*candidate); > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + candidate = (struct wcn36xx_hal_trigget_ba_req_candidate *) > + (wcn->hal_buf + sizeof(msg_body)); > + candidate->sta_index = sta_index; > + candidate->tid_bitmap = 1; > + > + ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len); > + if (ret) { > + wcn36xx_err("Sending hal_trigger_ba failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_trigger_ba response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > + > +static int wcn36xx_smd_tx_compl_ind(struct wcn36xx *wcn, void *buf, size_t len) > +{ > + struct wcn36xx_hal_tx_compl_ind_msg *rsp = buf; > + > + if (len != sizeof(*rsp)) { > + wcn36xx_warn("Bad TX complete indication\n"); > + return -EIO; > + } > + > + wcn36xx_dxe_tx_ack_ind(wcn, rsp->status); > + > + return 0; > +} > + > +static int wcn36xx_smd_missed_beacon_ind(struct wcn36xx *wcn, > + void *buf, > + size_t len) > +{ > + struct wcn36xx_hal_missed_beacon_ind_msg *rsp = buf; > + struct ieee80211_vif *vif = NULL; > + struct wcn36xx_vif *tmp; > + > + /* Old FW does not have bss index */ > + if (wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) { > + list_for_each_entry(tmp, &wcn->vif_list, list) { > + wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n", > + tmp->bss_index); > + vif = container_of((void *)tmp, > + struct ieee80211_vif, > + drv_priv); > + ieee80211_connection_loss(vif); > + } > + return 0; > + } > + > + if (len != sizeof(*rsp)) { > + wcn36xx_warn("Corrupted missed beacon indication\n"); > + return -EIO; > + } > + > + list_for_each_entry(tmp, &wcn->vif_list, list) { > + if (tmp->bss_index == rsp->bss_index) { > + wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n", > + rsp->bss_index); > + vif = container_of((void *)tmp, > + struct ieee80211_vif, > + drv_priv); > + ieee80211_connection_loss(vif); > + return 0; > + } > + } > + > + wcn36xx_warn("BSS index %d not found\n", rsp->bss_index); > + return -ENOENT; > +} > + > +static int wcn36xx_smd_delete_sta_context_ind(struct wcn36xx *wcn, > + void *buf, > + size_t len) > +{ > + struct wcn36xx_hal_delete_sta_context_ind_msg *rsp = buf; > + struct wcn36xx_vif *tmp; > + struct ieee80211_sta *sta = NULL; > + > + if (len != sizeof(*rsp)) { > + wcn36xx_warn("Corrupted delete sta indication\n"); > + return -EIO; > + } > + > + list_for_each_entry(tmp, &wcn->vif_list, list) { > + if (sta && (tmp->sta->sta_index == rsp->sta_id)) { > + sta = container_of((void *)tmp->sta, > + struct ieee80211_sta, > + drv_priv); > + wcn36xx_dbg(WCN36XX_DBG_HAL, > + "delete station indication %pM index %d\n", > + rsp->addr2, > + rsp->sta_id); > + ieee80211_report_low_ack(sta, 0); > + return 0; > + } > + } > + > + wcn36xx_warn("STA with addr %pM and index %d not found\n", > + rsp->addr2, > + rsp->sta_id); > + return -ENOENT; > +} > + > +int wcn36xx_smd_update_cfg(struct wcn36xx *wcn, u32 cfg_id, u32 value) > +{ > + struct wcn36xx_hal_update_cfg_req_msg msg_body, *body; > + size_t len; > + int ret = 0; > + > + mutex_lock(&wcn->hal_mutex); > + INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_CFG_REQ); > + > + PREPARE_HAL_BUF(wcn->hal_buf, msg_body); > + > + body = (struct wcn36xx_hal_update_cfg_req_msg *) wcn->hal_buf; > + len = msg_body.header.len; > + > + put_cfg_tlv_u32(wcn, &len, cfg_id, value); > + body->header.len = len; > + body->len = len - sizeof(*body); > + > + ret = wcn36xx_smd_send_and_wait(wcn, body->header.len); > + if (ret) { > + wcn36xx_err("Sending hal_update_cfg failed\n"); > + goto out; > + } > + ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len); > + if (ret) { > + wcn36xx_err("hal_update_cfg response failed err=%d\n", ret); > + goto out; > + } > +out: > + mutex_unlock(&wcn->hal_mutex); > + return ret; > +} > +static void wcn36xx_smd_rsp_process(struct wcn36xx *wcn, void *buf, size_t len) > +{ > + struct wcn36xx_hal_msg_header *msg_header = buf; > + struct wcn36xx_hal_ind_msg *msg_ind; > + wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "SMD <<< ", buf, len); > + > + switch (msg_header->msg_type) { > + case WCN36XX_HAL_START_RSP: > + case WCN36XX_HAL_CONFIG_STA_RSP: > + case WCN36XX_HAL_CONFIG_BSS_RSP: > + case WCN36XX_HAL_ADD_STA_SELF_RSP: > + case WCN36XX_HAL_STOP_RSP: > + case WCN36XX_HAL_DEL_STA_SELF_RSP: > + case WCN36XX_HAL_DELETE_STA_RSP: > + case WCN36XX_HAL_INIT_SCAN_RSP: > + case WCN36XX_HAL_START_SCAN_RSP: > + case WCN36XX_HAL_END_SCAN_RSP: > + case WCN36XX_HAL_FINISH_SCAN_RSP: > + case WCN36XX_HAL_DOWNLOAD_NV_RSP: > + case WCN36XX_HAL_DELETE_BSS_RSP: > + case WCN36XX_HAL_SEND_BEACON_RSP: > + case WCN36XX_HAL_SET_LINK_ST_RSP: > + case WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP: > + case WCN36XX_HAL_SET_BSSKEY_RSP: > + case WCN36XX_HAL_SET_STAKEY_RSP: > + case WCN36XX_HAL_RMV_STAKEY_RSP: > + case WCN36XX_HAL_RMV_BSSKEY_RSP: > + case WCN36XX_HAL_ENTER_BMPS_RSP: > + case WCN36XX_HAL_SET_POWER_PARAMS_RSP: > + case WCN36XX_HAL_EXIT_BMPS_RSP: > + case WCN36XX_HAL_KEEP_ALIVE_RSP: > + case WCN36XX_HAL_DUMP_COMMAND_RSP: > + case WCN36XX_HAL_ADD_BA_SESSION_RSP: > + case WCN36XX_HAL_ADD_BA_RSP: > + case WCN36XX_HAL_DEL_BA_RSP: > + case WCN36XX_HAL_TRIGGER_BA_RSP: > + case WCN36XX_HAL_UPDATE_CFG_RSP: > + case WCN36XX_HAL_JOIN_RSP: > + case WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP: > + case WCN36XX_HAL_CH_SWITCH_RSP: > + case WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP: > + memcpy(wcn->hal_buf, buf, len); > + wcn->hal_rsp_len = len; > + complete(&wcn->hal_rsp_compl); > + break; > + > + case WCN36XX_HAL_OTA_TX_COMPL_IND: > + case WCN36XX_HAL_MISSED_BEACON_IND: > + case WCN36XX_HAL_DELETE_STA_CONTEXT_IND: > + mutex_lock(&wcn->hal_ind_mutex); > + msg_ind = kmalloc(sizeof(*msg_ind), GFP_KERNEL); > + msg_ind->msg_len = len; > + msg_ind->msg = kmalloc(len, GFP_KERNEL); > + memcpy(msg_ind->msg, buf, len); > + list_add_tail(&msg_ind->list, &wcn->hal_ind_queue); > + queue_work(wcn->hal_ind_wq, &wcn->hal_ind_work); > + wcn36xx_dbg(WCN36XX_DBG_HAL, "indication arrived\n"); > + mutex_unlock(&wcn->hal_ind_mutex); > + break; > + default: > + wcn36xx_err("SMD_EVENT (%d) not supported\n", > + msg_header->msg_type); > + } > +} > +static void wcn36xx_ind_smd_work(struct work_struct *work) > +{ > + struct wcn36xx *wcn = > + container_of(work, struct wcn36xx, hal_ind_work); > + struct wcn36xx_hal_msg_header *msg_header; > + struct wcn36xx_hal_ind_msg *hal_ind_msg; > + > + mutex_lock(&wcn->hal_ind_mutex); > + > + hal_ind_msg = list_first_entry(&wcn->hal_ind_queue, > + struct wcn36xx_hal_ind_msg, > + list); > + > + msg_header = (struct wcn36xx_hal_msg_header *)hal_ind_msg->msg; > + > + switch (msg_header->msg_type) { > + case WCN36XX_HAL_OTA_TX_COMPL_IND: > + wcn36xx_smd_tx_compl_ind(wcn, > + hal_ind_msg->msg, > + hal_ind_msg->msg_len); > + break; > + case WCN36XX_HAL_MISSED_BEACON_IND: > + wcn36xx_smd_missed_beacon_ind(wcn, > + hal_ind_msg->msg, > + hal_ind_msg->msg_len); > + break; > + case WCN36XX_HAL_DELETE_STA_CONTEXT_IND: > + wcn36xx_smd_delete_sta_context_ind(wcn, > + hal_ind_msg->msg, > + hal_ind_msg->msg_len); > + break; > + default: > + wcn36xx_err("SMD_EVENT (%d) not supported\n", > + msg_header->msg_type); > + } > + list_del(wcn->hal_ind_queue.next); > + kfree(hal_ind_msg->msg); > + kfree(hal_ind_msg); > + mutex_unlock(&wcn->hal_ind_mutex); > +} > +int wcn36xx_smd_open(struct wcn36xx *wcn) > +{ > + int ret = 0; > + wcn->hal_ind_wq = create_freezable_workqueue("wcn36xx_smd_ind"); > + if (!wcn->hal_ind_wq) { > + wcn36xx_err("failed to allocate wq\n"); > + ret = -ENOMEM; > + goto out; > + } > + INIT_WORK(&wcn->hal_ind_work, wcn36xx_ind_smd_work); > + INIT_LIST_HEAD(&wcn->hal_ind_queue); > + mutex_init(&wcn->hal_ind_mutex); > + > + ret = wcn->ctrl_ops->open(wcn, wcn36xx_smd_rsp_process); > + if (ret) { > + wcn36xx_err("failed to open control channel\n"); > + goto free_wq; > + } > + > + return ret; > + > +free_wq: > + destroy_workqueue(wcn->hal_ind_wq); > +out: > + return ret; > +} > + > +void wcn36xx_smd_close(struct wcn36xx *wcn) > +{ > + wcn->ctrl_ops->close(); > + destroy_workqueue(wcn->hal_ind_wq); > + mutex_destroy(&wcn->hal_ind_mutex); > +} > diff --git a/drivers/net/wireless/ath/wcn36xx/smd.h b/drivers/net/wireless/ath/wcn36xx/smd.h > new file mode 100644 > index 0000000..e7c3901 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/smd.h > @@ -0,0 +1,127 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#ifndef _SMD_H_ > +#define _SMD_H_ > + > +#include "wcn36xx.h" > + > +/* Max shared size is 4k but we take less.*/ > +#define WCN36XX_NV_FRAGMENT_SIZE 3072 > + > +#define WCN36XX_HAL_BUF_SIZE 4096 > + > +#define HAL_MSG_TIMEOUT 200 > +#define WCN36XX_SMSM_WLAN_TX_ENABLE 0x00000400 > +#define WCN36XX_SMSM_WLAN_TX_RINGS_EMPTY 0x00000200 > +/* The PNO version info be contained in the rsp msg */ > +#define WCN36XX_FW_MSG_PNO_VERSION_MASK 0x8000 > + > +enum wcn36xx_fw_msg_result { > + WCN36XX_FW_MSG_RESULT_SUCCESS = 0, > + WCN36XX_FW_MSG_RESULT_SUCCESS_SYNC = 1, > + > + WCN36XX_FW_MSG_RESULT_MEM_FAIL = 5, > +}; > + > +/******************************/ > +/* SMD requests and responses */ > +/******************************/ > +struct wcn36xx_fw_msg_status_rsp { > + u32 status; > +} __packed; > + > +struct wcn36xx_hal_ind_msg { > + struct list_head list; > + u8 *msg; > + size_t msg_len; > +}; > + > +struct wcn36xx; > + > +int wcn36xx_smd_open(struct wcn36xx *wcn); > +void wcn36xx_smd_close(struct wcn36xx *wcn); > + > +int wcn36xx_smd_load_nv(struct wcn36xx *wcn); > +int wcn36xx_smd_start(struct wcn36xx *wcn); > +int wcn36xx_smd_stop(struct wcn36xx *wcn); > +int wcn36xx_smd_init_scan(struct wcn36xx *wcn, enum wcn36xx_hal_sys_mode mode); > +int wcn36xx_smd_start_scan(struct wcn36xx *wcn); > +int wcn36xx_smd_end_scan(struct wcn36xx *wcn); > +int wcn36xx_smd_finish_scan(struct wcn36xx *wcn, > + enum wcn36xx_hal_sys_mode mode); > +int wcn36xx_smd_update_scan_params(struct wcn36xx *wcn); > +int wcn36xx_smd_add_sta_self(struct wcn36xx *wcn, struct ieee80211_vif *vif); > +int wcn36xx_smd_delete_sta_self(struct wcn36xx *wcn, u8 *addr); > +int wcn36xx_smd_delete_sta(struct wcn36xx *wcn, u8 sta_index); > +int wcn36xx_smd_join(struct wcn36xx *wcn, const u8 *bssid, u8 *vif, u8 ch); > +int wcn36xx_smd_set_link_st(struct wcn36xx *wcn, const u8 *bssid, > + const u8 *sta_mac, > + enum wcn36xx_hal_link_state state); > +int wcn36xx_smd_config_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif, > + struct ieee80211_sta *sta, const u8 *bssid, > + bool update); > +int wcn36xx_smd_delete_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif); > +int wcn36xx_smd_config_sta(struct wcn36xx *wcn, struct ieee80211_vif *vif, > + struct ieee80211_sta *sta); > +int wcn36xx_smd_send_beacon(struct wcn36xx *wcn, struct ieee80211_vif *vif, > + struct sk_buff *skb_beacon, u16 tim_off, > + u16 p2p_off); > +int wcn36xx_smd_switch_channel(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, int ch); > +int wcn36xx_smd_update_proberesp_tmpl(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, > + struct sk_buff *skb); > +int wcn36xx_smd_set_stakey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx, > + u8 keylen, > + u8 *key, > + u8 sta_index); > +int wcn36xx_smd_set_bsskey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx, > + u8 keylen, > + u8 *key); > +int wcn36xx_smd_remove_stakey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx, > + u8 sta_index); > +int wcn36xx_smd_remove_bsskey(struct wcn36xx *wcn, > + enum ani_ed_type enc_type, > + u8 keyidx); > +int wcn36xx_smd_enter_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif); > +int wcn36xx_smd_exit_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif); > +int wcn36xx_smd_set_power_params(struct wcn36xx *wcn, bool ignore_dtim); > +int wcn36xx_smd_keep_alive_req(struct wcn36xx *wcn, > + struct ieee80211_vif *vif, > + int packet_type); > +int wcn36xx_smd_dump_cmd_req(struct wcn36xx *wcn, u32 arg1, u32 arg2, > + u32 arg3, u32 arg4, u32 arg5); > +int wcn36xx_smd_feature_caps_exchange(struct wcn36xx *wcn); > + > +int wcn36xx_smd_add_ba_session(struct wcn36xx *wcn, > + struct ieee80211_sta *sta, > + u16 tid, > + u16 *ssn, > + u8 direction, > + u8 sta_index); > +int wcn36xx_smd_add_ba(struct wcn36xx *wcn); > +int wcn36xx_smd_del_ba(struct wcn36xx *wcn, u16 tid, u8 sta_index); > +int wcn36xx_smd_trigger_ba(struct wcn36xx *wcn, u8 sta_index); > + > +int wcn36xx_smd_update_cfg(struct wcn36xx *wcn, u32 cfg_id, u32 value); > +#endif /* _SMD_H_ */ > diff --git a/drivers/net/wireless/ath/wcn36xx/txrx.c b/drivers/net/wireless/ath/wcn36xx/txrx.c > new file mode 100644 > index 0000000..b2b60e3 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/txrx.c > @@ -0,0 +1,284 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include "txrx.h" > + > +static inline int get_rssi0(struct wcn36xx_rx_bd *bd) > +{ > + return 100 - ((bd->phy_stat0 >> 24) & 0xff); > +} > + > +int wcn36xx_rx_skb(struct wcn36xx *wcn, struct sk_buff *skb) > +{ > + struct ieee80211_rx_status status; > + struct ieee80211_hdr *hdr; > + struct wcn36xx_rx_bd *bd; > + u16 fc, sn; > + > + /* > + * All fields must be 0, otherwise it can lead to > + * unexpected consequences. > + */ > + memset(&status, 0, sizeof(status)); > + > + bd = (struct wcn36xx_rx_bd *)skb->data; > + buff_to_be((u32 *)bd, sizeof(*bd)/sizeof(u32)); > + wcn36xx_dbg_dump(WCN36XX_DBG_RX_DUMP, > + "BD <<< ", (char *)bd, > + sizeof(struct wcn36xx_rx_bd)); > + > + skb_put(skb, bd->pdu.mpdu_header_off + bd->pdu.mpdu_len); > + skb_pull(skb, bd->pdu.mpdu_header_off); > + > + status.mactime = 10; > + status.freq = WCN36XX_CENTER_FREQ(wcn); > + status.band = WCN36XX_BAND(wcn); > + status.signal = -get_rssi0(bd); > + status.antenna = 1; > + status.rate_idx = 1; > + status.flag = 0; > + status.rx_flags = 0; > + status.flag |= RX_FLAG_IV_STRIPPED | > + RX_FLAG_MMIC_STRIPPED | > + RX_FLAG_DECRYPTED; > + > + wcn36xx_dbg(WCN36XX_DBG_RX, "status.flags=%x status->vendor_radiotap_len=%x\n", > + status.flag, status.vendor_radiotap_len); > + > + memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status)); > + > + hdr = (struct ieee80211_hdr *) skb->data; > + fc = __le16_to_cpu(hdr->frame_control); > + sn = IEEE80211_SEQ_TO_SN(__le16_to_cpu(hdr->seq_ctrl)); > + > + if (ieee80211_is_beacon(hdr->frame_control)) { > + wcn36xx_dbg(WCN36XX_DBG_BEACON, "beacon skb %p len %d fc %04x sn %d\n", > + skb, skb->len, fc, sn); > + wcn36xx_dbg_dump(WCN36XX_DBG_BEACON_DUMP, "SKB <<< ", > + (char *)skb->data, skb->len); > + } else { > + wcn36xx_dbg(WCN36XX_DBG_RX, "rx skb %p len %d fc %04x sn %d\n", > + skb, skb->len, fc, sn); > + wcn36xx_dbg_dump(WCN36XX_DBG_RX_DUMP, "SKB <<< ", > + (char *)skb->data, skb->len); > + } > + > + ieee80211_rx_irqsafe(wcn->hw, skb); > + > + return 0; > +} > + > +static void wcn36xx_set_tx_pdu(struct wcn36xx_tx_bd *bd, > + u32 mpdu_header_len, > + u32 len, > + u16 tid) > +{ > + bd->pdu.mpdu_header_len = mpdu_header_len; > + bd->pdu.mpdu_header_off = sizeof(*bd); > + bd->pdu.mpdu_data_off = bd->pdu.mpdu_header_len + > + bd->pdu.mpdu_header_off; > + bd->pdu.mpdu_len = len; > + bd->pdu.tid = tid; > +} > + > +static inline struct wcn36xx_vif *get_vif_by_addr(struct wcn36xx *wcn, > + u8 *addr) > +{ > + struct wcn36xx_vif *vif_priv = NULL; > + struct ieee80211_vif *vif = NULL; > + list_for_each_entry(vif_priv, &wcn->vif_list, list) { > + vif = container_of((void *)vif_priv, > + struct ieee80211_vif, > + drv_priv); > + if (memcmp(vif->addr, addr, ETH_ALEN) == 0) > + return vif_priv; > + } > + wcn36xx_warn("vif %pM not found\n", addr); > + return NULL; > +} > +static void wcn36xx_set_tx_data(struct wcn36xx_tx_bd *bd, > + struct wcn36xx *wcn, > + struct wcn36xx_vif **vif_priv, > + struct wcn36xx_sta *sta_priv, > + struct ieee80211_hdr *hdr, > + bool bcast) > +{ > + struct ieee80211_vif *vif = NULL; > + struct wcn36xx_vif *__vif_priv = NULL; > + bd->bd_rate = WCN36XX_BD_RATE_DATA; > + > + /* > + * For not unicast frames mac80211 will not set sta pointer so use > + * self_sta_index instead. > + */ > + if (sta_priv) { > + __vif_priv = sta_priv->vif; > + vif = container_of((void *)__vif_priv, > + struct ieee80211_vif, > + drv_priv); > + > + if (vif->type == NL80211_IFTYPE_STATION) { > + bd->sta_index = sta_priv->bss_sta_index; > + bd->dpu_desc_idx = sta_priv->bss_dpu_desc_index; > + } else if (vif->type == NL80211_IFTYPE_AP || > + vif->type == NL80211_IFTYPE_ADHOC || > + vif->type == NL80211_IFTYPE_MESH_POINT) { > + bd->sta_index = sta_priv->sta_index; > + bd->dpu_desc_idx = sta_priv->dpu_desc_index; > + } > + } else { > + __vif_priv = get_vif_by_addr(wcn, hdr->addr2); > + bd->sta_index = __vif_priv->self_sta_index; > + bd->dpu_desc_idx = __vif_priv->self_dpu_desc_index; > + } > + > + bd->dpu_sign = __vif_priv->ucast_dpu_signature; > + > + if (ieee80211_is_nullfunc(hdr->frame_control) || > + (sta_priv && !sta_priv->is_data_encrypted)) > + bd->dpu_ne = 1; > + > + if (bcast) { > + bd->ub = 1; > + bd->ack_policy = 1; > + } > + *vif_priv = __vif_priv; > +} > + > +static void wcn36xx_set_tx_mgmt(struct wcn36xx_tx_bd *bd, > + struct wcn36xx *wcn, > + struct wcn36xx_vif **vif_priv, > + struct ieee80211_hdr *hdr, > + bool bcast) > +{ > + struct wcn36xx_vif *__vif_priv = > + get_vif_by_addr(wcn, hdr->addr2); > + bd->sta_index = __vif_priv->self_sta_index; > + bd->dpu_desc_idx = __vif_priv->self_dpu_desc_index; > + bd->dpu_ne = 1; > + > + /* default rate for unicast */ > + if (ieee80211_is_mgmt(hdr->frame_control)) > + bd->bd_rate = (WCN36XX_BAND(wcn) == IEEE80211_BAND_5GHZ) ? > + WCN36XX_BD_RATE_CTRL : > + WCN36XX_BD_RATE_MGMT; > + else if (ieee80211_is_ctl(hdr->frame_control)) > + bd->bd_rate = WCN36XX_BD_RATE_CTRL; > + else > + wcn36xx_warn("frame control type unknown\n"); > + > + /* > + * In joining state trick hardware that probe is sent as > + * unicast even if address is broadcast. > + */ > + if (__vif_priv->is_joining && > + ieee80211_is_probe_req(hdr->frame_control)) > + bcast = false; > + > + if (bcast) { > + /* broadcast */ > + bd->ub = 1; > + /* No ack needed not unicast */ > + bd->ack_policy = 1; > + bd->queue_id = WCN36XX_TX_B_WQ_ID; > + } else > + bd->queue_id = WCN36XX_TX_U_WQ_ID; > + *vif_priv = __vif_priv; > +} > + > +int wcn36xx_start_tx(struct wcn36xx *wcn, > + struct wcn36xx_sta *sta_priv, > + struct sk_buff *skb) > +{ > + struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; > + struct wcn36xx_vif *vif_priv = NULL; > + struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); > + unsigned long flags; > + bool is_low = ieee80211_is_data(hdr->frame_control); > + bool bcast = is_broadcast_ether_addr(hdr->addr1) || > + is_multicast_ether_addr(hdr->addr1); > + struct wcn36xx_tx_bd *bd = wcn36xx_dxe_get_next_bd(wcn, is_low); > + > + if (!bd) { > + /* > + * TX DXE are used in pairs. One for the BD and one for the > + * actual frame. The BD DXE's has a preallocated buffer while > + * the skb ones does not. If this isn't true something is really > + * wierd. TODO: Recover from this situation > + */ > + > + wcn36xx_err("bd address may not be NULL for BD DXE\n"); > + return -EINVAL; > + } > + > + memset(bd, 0, sizeof(*bd)); > + > + wcn36xx_dbg(WCN36XX_DBG_TX, > + "tx skb %p len %d fc %04x sn %d %s %s\n", > + skb, skb->len, __le16_to_cpu(hdr->frame_control), > + IEEE80211_SEQ_TO_SN(__le16_to_cpu(hdr->seq_ctrl)), > + is_low ? "low" : "high", bcast ? "bcast" : "ucast"); > + > + wcn36xx_dbg_dump(WCN36XX_DBG_TX_DUMP, "", skb->data, skb->len); > + > + bd->dpu_rf = WCN36XX_BMU_WQ_TX; > + > + bd->tx_comp = info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS; > + if (bd->tx_comp) { > + wcn36xx_dbg(WCN36XX_DBG_DXE, "TX_ACK status requested\n"); > + spin_lock_irqsave(&wcn->dxe_lock, flags); > + if (wcn->tx_ack_skb) { > + spin_unlock_irqrestore(&wcn->dxe_lock, flags); > + wcn36xx_warn("tx_ack_skb already set\n"); > + return -EINVAL; > + } > + > + wcn->tx_ack_skb = skb; > + spin_unlock_irqrestore(&wcn->dxe_lock, flags); > + > + /* Only one at a time is supported by fw. Stop the TX queues > + * until the ack status gets back. > + * > + * TODO: Add watchdog in case FW does not answer > + */ > + ieee80211_stop_queues(wcn->hw); > + } > + > + /* Data frames served first*/ > + if (is_low) { > + wcn36xx_set_tx_data(bd, wcn, &vif_priv, sta_priv, hdr, bcast); > + wcn36xx_set_tx_pdu(bd, > + ieee80211_is_data_qos(hdr->frame_control) ? > + sizeof(struct ieee80211_qos_hdr) : > + sizeof(struct ieee80211_hdr_3addr), > + skb->len, sta_priv ? sta_priv->tid : 0); > + } else { > + /* MGMT and CTRL frames are handeld here*/ > + wcn36xx_set_tx_mgmt(bd, wcn, &vif_priv, hdr, bcast); > + wcn36xx_set_tx_pdu(bd, > + ieee80211_is_data_qos(hdr->frame_control) ? > + sizeof(struct ieee80211_qos_hdr) : > + sizeof(struct ieee80211_hdr_3addr), > + skb->len, WCN36XX_TID); > + } > + > + buff_to_be((u32 *)bd, sizeof(*bd)/sizeof(u32)); > + bd->tx_bd_sign = 0xbdbdbdbd; > + > + return wcn36xx_dxe_tx_frame(wcn, vif_priv, skb, is_low); > +} > diff --git a/drivers/net/wireless/ath/wcn36xx/txrx.h b/drivers/net/wireless/ath/wcn36xx/txrx.h > new file mode 100644 > index 0000000..bbfbcf8 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/txrx.h > @@ -0,0 +1,160 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#ifndef _TXRX_H_ > +#define _TXRX_H_ > + > +#include <linux/etherdevice.h> > +#include "wcn36xx.h" > + > +/* TODO describe all properties */ > +#define WCN36XX_802_11_HEADER_LEN 24 > +#define WCN36XX_BMU_WQ_TX 25 > +#define WCN36XX_TID 7 > +/* broadcast wq ID */ > +#define WCN36XX_TX_B_WQ_ID 0xA > +#define WCN36XX_TX_U_WQ_ID 0x9 > +/* bd_rate */ > +#define WCN36XX_BD_RATE_DATA 0 > +#define WCN36XX_BD_RATE_MGMT 2 > +#define WCN36XX_BD_RATE_CTRL 3 > + > +struct wcn36xx_pdu { > + u32 dpu_fb:8; > + u32 adu_fb:8; > + u32 pdu_id:16; > + > + /* 0x04*/ > + u32 tail_pdu_idx:16; > + u32 head_pdu_idx:16; > + > + /* 0x08*/ > + u32 pdu_count:7; > + u32 mpdu_data_off:9; > + u32 mpdu_header_off:8; > + u32 mpdu_header_len:8; > + > + /* 0x0c*/ > + u32 reserved4:8; > + u32 tid:4; > + u32 reserved3:4; > + u32 mpdu_len:16; > +}; > + > +struct wcn36xx_rx_bd { > + u32 bdt:2; > + u32 ft:1; > + u32 dpu_ne:1; > + u32 rx_key_id:3; > + u32 ub:1; > + u32 rmf:1; > + u32 uma_bypass:1; > + u32 csr11:1; > + u32 reserved0:1; > + u32 scan_learn:1; > + u32 rx_ch:4; > + u32 rtsf:1; > + u32 bsf:1; > + u32 a2hf:1; > + u32 st_auf:1; > + u32 dpu_sign:3; > + u32 dpu_rf:8; > + > + struct wcn36xx_pdu pdu; > + > + /* 0x14*/ > + u32 addr3:8; > + u32 addr2:8; > + u32 addr1:8; > + u32 dpu_desc_idx:8; > + > + /* 0x18*/ > + u32 rxp_flags:23; > + u32 rate_id:9; > + > + u32 phy_stat0; > + u32 phy_stat1; > + > + /* 0x24 */ > + u32 rx_times; > + > + u32 pmi_cmd[6]; > + > + /* 0x40 */ > + u32 reserved7:4; > + u32 reorder_slot_id:6; > + u32 reorder_fwd_id:6; > + u32 reserved6:12; > + u32 reorder_code:4; > + > + /* 0x44 */ > + u32 exp_seq_num:12; > + u32 cur_seq_num:12; > + u32 fr_type_subtype:8; > + > + /* 0x48 */ > + u32 msdu_size:16; > + u32 sub_fr_id:4; > + u32 proc_order:4; > + u32 reserved9:4; > + u32 aef:1; > + u32 lsf:1; > + u32 esf:1; > + u32 asf:1; > +}; > + > +struct wcn36xx_tx_bd { > + u32 bdt:2; > + u32 ft:1; > + u32 dpu_ne:1; > + u32 fw_tx_comp:1; > + u32 tx_comp:1; > + u32 reserved1:1; > + u32 ub:1; > + u32 rmf:1; > + u32 reserved0:12; > + u32 dpu_sign:3; > + u32 dpu_rf:8; > + > + struct wcn36xx_pdu pdu; > + > + /* 0x14*/ > + u32 reserved5:7; > + u32 queue_id:5; > + u32 bd_rate:2; > + u32 ack_policy:2; > + u32 sta_index:8; > + u32 dpu_desc_idx:8; > + > + u32 tx_bd_sign; > + u32 reserved6; > + u32 dxe_start_time; > + u32 dxe_end_time; > + > + /*u32 tcp_udp_start_off:10; > + u32 header_cks:16; > + u32 reserved7:6;*/ > +}; > + > +struct wcn36xx_sta; > +struct wcn36xx; > + > +int wcn36xx_rx_skb(struct wcn36xx *wcn, struct sk_buff *skb); > +int wcn36xx_start_tx(struct wcn36xx *wcn, > + struct wcn36xx_sta *sta_priv, > + struct sk_buff *skb); > + > +#endif /* _TXRX_H_ */ > diff --git a/drivers/net/wireless/ath/wcn36xx/wcn36xx.h b/drivers/net/wireless/ath/wcn36xx/wcn36xx.h > new file mode 100644 > index 0000000..58b6383 > --- /dev/null > +++ b/drivers/net/wireless/ath/wcn36xx/wcn36xx.h > @@ -0,0 +1,238 @@ > +/* > + * Copyright (c) 2013 Eugene Krasnikov <k.eugene.e@xxxxxxxxx> > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY > + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION > + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN > + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + */ > + > +#ifndef _WCN36XX_H_ > +#define _WCN36XX_H_ > + > +#include <linux/completion.h> > +#include <linux/printk.h> > +#include <linux/spinlock.h> > +#include <net/mac80211.h> > + > +#include "hal.h" > +#include "smd.h" > +#include "txrx.h" > +#include "dxe.h" > +#include "pmc.h" > +#include "debug.h" > + > +#define WLAN_NV_FILE "wlan/prima/WCNSS_qcom_wlan_nv.bin" > +#define WCN36XX_AGGR_BUFFER_SIZE 64 > + > +extern unsigned int wcn36xx_dbg_mask; > + > +enum wcn36xx_debug_mask { > + WCN36XX_DBG_DXE = 0x00000001, > + WCN36XX_DBG_DXE_DUMP = 0x00000002, > + WCN36XX_DBG_SMD = 0x00000004, > + WCN36XX_DBG_SMD_DUMP = 0x00000008, > + WCN36XX_DBG_RX = 0x00000010, > + WCN36XX_DBG_RX_DUMP = 0x00000020, > + WCN36XX_DBG_TX = 0x00000040, > + WCN36XX_DBG_TX_DUMP = 0x00000080, > + WCN36XX_DBG_HAL = 0x00000100, > + WCN36XX_DBG_HAL_DUMP = 0x00000200, > + WCN36XX_DBG_MAC = 0x00000400, > + WCN36XX_DBG_BEACON = 0x00000800, > + WCN36XX_DBG_BEACON_DUMP = 0x00001000, > + WCN36XX_DBG_PMC = 0x00002000, > + WCN36XX_DBG_PMC_DUMP = 0x00004000, > + WCN36XX_DBG_ANY = 0xffffffff, > +}; > + > +#define wcn36xx_err(fmt, arg...) \ > + printk(KERN_ERR pr_fmt("ERROR " fmt), ##arg); > + > +#define wcn36xx_warn(fmt, arg...) \ > + printk(KERN_WARNING pr_fmt("WARNING " fmt), ##arg) > + > +#define wcn36xx_info(fmt, arg...) \ > + printk(KERN_INFO pr_fmt(fmt), ##arg) > + > +#define wcn36xx_dbg(mask, fmt, arg...) do { \ > + if (wcn36xx_dbg_mask & mask) \ > + printk(KERN_DEBUG pr_fmt(fmt), ##arg); \ > +} while (0) > + > +#define wcn36xx_dbg_dump(mask, prefix_str, buf, len) do { \ > + if (wcn36xx_dbg_mask & mask) \ > + print_hex_dump(KERN_DEBUG, pr_fmt(prefix_str), \ > + DUMP_PREFIX_OFFSET, 32, 1, \ > + buf, len, false); \ > +} while (0) > + > +#define WCN36XX_HW_CHANNEL(__wcn) (__wcn->hw->conf.chandef.chan->hw_value) > +#define WCN36XX_BAND(__wcn) (__wcn->hw->conf.chandef.chan->band) > +#define WCN36XX_CENTER_FREQ(__wcn) (__wcn->hw->conf.chandef.chan->center_freq) > +#define WCN36XX_LISTEN_INTERVAL(__wcn) (__wcn->hw->conf.listen_interval) > +#define WCN36XX_FLAGS(__wcn) (__wcn->hw->flags) > +#define WCN36XX_MAX_POWER(__wcn) (__wcn->hw->conf.chandef.chan->max_power) > + > +static inline void buff_to_be(u32 *buf, size_t len) > +{ > + int i; > + for (i = 0; i < len; i++) > + buf[i] = cpu_to_be32(buf[i]); > +} > + > +struct nv_data { > + int is_valid; > + u8 table; > +}; > + > +/* Interface for platform control path > + * > + * @open: hook must be called when wcn36xx wants to open control channel. > + * @tx: sends a buffer. > + */ > +struct wcn36xx_platform_ctrl_ops { > + int (*open)(void *drv_priv, void *rsp_cb); > + void (*close)(void); > + int (*tx)(char *buf, size_t len); > + int (*get_hw_mac)(u8 *addr); > + int (*smsm_change_state)(u32 clear_mask, u32 set_mask); > +}; > + > +/** > + * struct wcn36xx_vif - holds VIF related fields > + * > + * @bss_index: bss_index is initially set to 0xFF. bss_index is received from > + * HW after first config_bss call and must be used in delete_bss and > + * enter/exit_bmps. > + */ > +struct wcn36xx_vif { > + struct list_head list; > + struct wcn36xx_sta *sta; > + u8 dtim_period; > + enum ani_ed_type encrypt_type; > + bool is_joining; > + struct wcn36xx_hal_mac_ssid ssid; > + > + /* Power management */ > + enum wcn36xx_power_state pw_state; > + > + u8 bss_index; > + u8 ucast_dpu_signature; > + /* Returned from WCN36XX_HAL_ADD_STA_SELF_RSP */ > + u8 self_sta_index; > + u8 self_dpu_desc_index; > +}; > + > +/** > + * struct wcn36xx_sta - holds STA related fields > + * > + * @tid: traffic ID that is used during AMPDU and in TX BD. > + * @sta_index: STA index is returned from HW after config_sta call and is > + * used in both SMD channel and TX BD. > + * @dpu_desc_index: DPU descriptor index is returned from HW after config_sta > + * call and is used in TX BD. > + * @bss_sta_index: STA index is returned from HW after config_bss call and is > + * used in both SMD channel and TX BD. See table bellow when it is used. > + * @bss_dpu_desc_index: DPU descriptor index is returned from HW after > + * config_bss call and is used in TX BD. > + * ______________________________________________ > + * | | STA | AP | > + * |______________|_____________|_______________| > + * | TX BD |bss_sta_index| sta_index | > + * |______________|_____________|_______________| > + * |all SMD calls |bss_sta_index| sta_index | > + * |______________|_____________|_______________| > + * |smd_delete_sta| sta_index | sta_index | > + * |______________|_____________|_______________| > + */ > +struct wcn36xx_sta { > + struct wcn36xx_vif *vif; > + u16 aid; > + u16 tid; > + u8 sta_index; > + u8 dpu_desc_index; > + u8 bss_sta_index; > + u8 bss_dpu_desc_index; > + bool is_data_encrypted; > + /* Rates */ > + struct wcn36xx_hal_supported_rates supported_rates; > +}; > +struct wcn36xx_dxe_ch; > +struct wcn36xx { > + struct ieee80211_hw *hw; > + struct device *dev; > + struct list_head vif_list; > + > + u8 fw_revision; > + u8 fw_version; > + u8 fw_minor; > + u8 fw_major; > + > + /* extra byte for the NULL termination */ > + u8 crm_version[WCN36XX_HAL_VERSION_LENGTH + 1]; > + u8 wlan_version[WCN36XX_HAL_VERSION_LENGTH + 1]; > + > + /* IRQs */ > + int tx_irq; > + int rx_irq; > + void __iomem *mmio; > + > + struct wcn36xx_platform_ctrl_ops *ctrl_ops; > + /* > + * smd_buf must be protected with smd_mutex to garantee > + * that all messages are sent one after another > + */ > + u8 *hal_buf; > + size_t hal_rsp_len; > + struct mutex hal_mutex; > + struct completion hal_rsp_compl; > + struct workqueue_struct *hal_ind_wq; > + struct work_struct hal_ind_work; > + struct mutex hal_ind_mutex; > + struct list_head hal_ind_queue; > + > + /* DXE channels */ > + struct wcn36xx_dxe_ch dxe_tx_l_ch; /* TX low */ > + struct wcn36xx_dxe_ch dxe_tx_h_ch; /* TX high */ > + struct wcn36xx_dxe_ch dxe_rx_l_ch; /* RX low */ > + struct wcn36xx_dxe_ch dxe_rx_h_ch; /* RX high */ > + > + /* For synchronization of DXE resources from BH, IRQ and WQ contexts */ > + spinlock_t dxe_lock; > + bool queues_stopped; > + > + /* Memory pools */ > + struct wcn36xx_dxe_mem_pool mgmt_mem_pool; > + struct wcn36xx_dxe_mem_pool data_mem_pool; > + > + struct sk_buff *tx_ack_skb; > + > +#ifdef CONFIG_WCN36XX_DEBUGFS > + /* Debug file system entry */ > + struct wcn36xx_dfs_entry dfs; > +#endif /* CONFIG_WCN36XX_DEBUGFS */ > + > +}; > + > +static inline bool wcn36xx_is_fw_version(struct wcn36xx *wcn, > + u8 major, > + u8 minor, > + u8 version, > + u8 revision) > +{ > + return (wcn->fw_major == major && > + wcn->fw_minor == minor && > + wcn->fw_version == version && > + wcn->fw_revision == revision); > +} > +void wcn36xx_set_default_rates(struct wcn36xx_hal_supported_rates *rates); > + > +#endif /* _WCN36XX_H_ */ > -- > 1.8.1.2 > -- Best regards, Eugene -- To unsubscribe from this list: send the line "unsubscribe linux-wireless" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
