wifi: nxpwifi: create nxpwifi to support iw61x
PATCH 23/43 wifi: nxpwifi: add main.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/main.c | 1726 +++++++++++++++++++++++ 1 file changed, 1726 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/main.c
drivers/net/wireless/nxp/nxpwifi/main.c new file +1726 -0
@@ -0,0 +1,1726 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: major functions +* +* Copyright 2011-2024 NXP +*/ + +#include <linux/suspend.h> + +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "cfg80211.h" +#include "11n.h" + +#define VERSION "1.0" + +static unsigned int debug_mask =NXPWIFI_DEFAULT_DEBUG_MASK ; + +char driver_version[] ="nxpwifi " VERSION " (%s) " ; + +const u16 nxpwifi_1d_to_wmm_queue[8 ] = {1 ,0 ,0 ,1 ,2 ,2 ,3 ,3 }; + +/* This function registers the device and performs all the necessary +* initializations. +* +* The following initialization operations are performed - +* - Allocate adapter structure +* - Save interface specific operations table in adapter +* - Call interface specific initialization routine +* - Allocate private structures +* - Set default adapter structure parameters +* - Initialize locks +* +* In case of any errors during inittialization, this function also ensures +* proper cleanup before exiting. +*/ +static int nxpwifi_register (void *card,struct device *dev, +struct nxpwifi_if_ops *if_ops,void **padapter) +{ +struct nxpwifi_adapter *adapter; +int i; + + adapter =kzalloc (sizeof (*adapter),GFP_KERNEL ); +if (!adapter) +return -ENOMEM ; + + *padapter = adapter; + adapter->dev = dev; + adapter->card = card; + +/* Save interface specific operations in adapter */ +memmove (&adapter->if_ops, if_ops,sizeof (struct nxpwifi_if_ops )); + adapter->debug_mask = debug_mask; + +/* card specific initialization has been deferred until now .. */ +if (adapter->if_ops.init_if) +if (adapter->if_ops.init_if (adapter)) + goto error; + + adapter->priv_num =0 ; + +for (i =0 ; i <NXPWIFI_MAX_BSS_NUM ; i++) { +/* Allocate memory for private structure */ + adapter->priv[i] = +kzalloc (sizeof (struct nxpwifi_private ),GFP_KERNEL ); +if (!adapter->priv[i]) + goto error; + + adapter->priv[i]->adapter = adapter; + adapter->priv_num++; + } +nxpwifi_init_lock_list (adapter); + +timer_setup (&adapter->cmd_timer, nxpwifi_cmd_timeout_func,0 ); + +return 0 ; + +error: +nxpwifi_dbg (adapter,ERROR , +"info: leave %s with error\n" , __func__); + +for (i =0 ; i < adapter->priv_num; i++) +kfree (adapter->priv[i]); + +kfree (adapter); + +return -1 ; +} + +/* This function unregisters the device and performs all the necessary +* cleanups. +* +* The following cleanup operations are performed - +* - Free the timers +* - Free beacon buffers +* - Free private structures +* - Free adapter structure +*/ +static int nxpwifi_unregister (struct nxpwifi_adapter *adapter) +{ +s32 i; + +if (adapter->if_ops.cleanup_if) + adapter->if_ops.cleanup_if (adapter); + +del_timer_sync (&adapter->cmd_timer); + +/* Free private structures */ +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { +nxpwifi_free_curr_bcn (adapter->priv[i]); +kfree (adapter->priv[i]); + } + } + +if (adapter->nd_info) { +for (i =0 ; i < adapter->nd_info->n_matches ; i++) +kfree (adapter->nd_info->matches[i]); +kfree (adapter->nd_info); + adapter->nd_info =NULL ; + } + +kfree (adapter->regd); + +kfree (adapter); +return 0 ; +} + +void nxpwifi_queue_main_work (struct nxpwifi_adapter *adapter) +{ +unsigned long flags; + +spin_lock_irqsave (&adapter->main_proc_lock, flags); +if (adapter->nxpwifi_processing) { + adapter->more_task_flag = true; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + }else { +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); +queue_work (adapter->workqueue, &adapter->main_work); + } +} +EXPORT_SYMBOL_GPL (nxpwifi_queue_main_work); + +static void nxpwifi_queue_rx_work (struct nxpwifi_adapter *adapter) +{ +spin_lock_bh (&adapter->rx_proc_lock); +if (adapter->rx_processing) { +spin_unlock_bh (&adapter->rx_proc_lock); + }else { +spin_unlock_bh (&adapter->rx_proc_lock); +queue_work (adapter->rx_workqueue, &adapter->rx_work); + } +} + +static int nxpwifi_process_rx (struct nxpwifi_adapter *adapter) +{ +struct sk_buff *skb; +struct nxpwifi_rxinfo *rx_info; + +spin_lock_bh (&adapter->rx_proc_lock); +if (adapter->rx_processing || adapter->rx_locked) { +spin_unlock_bh (&adapter->rx_proc_lock); + goto exit_rx_proc; + }else { + adapter->rx_processing = true; +spin_unlock_bh (&adapter->rx_proc_lock); + } + +/* Check for Rx data */ +while ((skb =skb_dequeue (&adapter->rx_data_q))) { +atomic_dec (&adapter->rx_pending); +if (adapter->delay_main_work && + (atomic_read (&adapter->rx_pending) <LOW_RX_PENDING )) { + adapter->delay_main_work = false; +nxpwifi_queue_main_work (adapter); + } + rx_info =NXPWIFI_SKB_RXCB (skb); +if (rx_info->buf_type ==NXPWIFI_TYPE_AGGR_DATA ) { +if (adapter->if_ops.deaggr_pkt) + adapter->if_ops.deaggr_pkt (adapter, skb); +dev_kfree_skb_any (skb); + }else { +nxpwifi_handle_rx_packet (adapter, skb); + } + } +spin_lock_bh (&adapter->rx_proc_lock); + adapter->rx_processing = false; +spin_unlock_bh (&adapter->rx_proc_lock); + +exit_rx_proc: +return 0 ; +} + +static void maybe_quirk_fw_disable_ds (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ); +struct nxpwifi_ver_ext ver_ext; + +if (test_and_set_bit (NXPWIFI_IS_REQUESTING_FW_VEREXT , &adapter->work_flags)) +return ; + +memset (&ver_ext,0 ,sizeof (ver_ext)); + ver_ext.version_str_sel =1 ; +if (nxpwifi_send_cmd (priv,HOST_CMD_VERSION_EXT , +HOST_ACT_GEN_GET ,0 , &ver_ext, false)) { +nxpwifi_dbg (priv->adapter,MSG , +"Checking hardware revision failed.\n" ); + } +} + +/* The main process. +* +* This function is the main procedure of the driver and handles various driver +* operations. It runs in a loop and provides the core functionalities. +* +* The main responsibilities of this function are - +* - Ensure concurrency control +* - Handle pending interrupts and call interrupt handlers +* - Wake up the card if required +* - Handle command responses and call response handlers +* - Handle events and call event handlers +* - Execute pending commands +* - Transmit pending data packets +*/ +int nxpwifi_main_process (struct nxpwifi_adapter *adapter) +{ +int ret =0 ; +unsigned long flags; + +spin_lock_irqsave (&adapter->main_proc_lock, flags); + +/* Check if already processing */ +if (adapter->nxpwifi_processing || adapter->main_locked) { + adapter->more_task_flag = true; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); +return 0 ; + } + + adapter->nxpwifi_processing = true; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + +process_start: +do { +if (adapter->hw_status ==NXPWIFI_HW_STATUS_NOT_READY ) +break ; + +/* For non-USB interfaces, If we process interrupts first, it +* would increase RX pending even further. Avoid this by +* checking if rx_pending has crossed high threshold and +* schedule rx work queue and then process interrupts. +* For USB interface, there are no interrupts. We already have +* HIGH_RX_PENDING check in usb.c +*/ +if (atomic_read (&adapter->rx_pending) >=HIGH_RX_PENDING ) { + adapter->delay_main_work = true; +nxpwifi_queue_rx_work (adapter); +break ; + } + +/* Handle pending interrupt if any */ +if (adapter->int_status) { +if (adapter->hs_activated) +nxpwifi_process_hs_config (adapter); +if (adapter->if_ops.process_int_status) + adapter->if_ops.process_int_status (adapter); + } + +if (adapter->rx_work_enabled && adapter->data_received) +nxpwifi_queue_rx_work (adapter); + +/* Need to wake up the card ? */ +if (adapter->ps_state ==PS_STATE_SLEEP && + (adapter->pm_wakeup_card_req && + !adapter->pm_wakeup_fw_try) && + (is_command_pending (adapter) || + !skb_queue_empty (&adapter->tx_data_q) || + !nxpwifi_bypass_txlist_empty (adapter) || + !nxpwifi_wmm_lists_empty (adapter))) { + adapter->pm_wakeup_fw_try = true; +mod_timer (&adapter->wakeup_timer, jiffies + (HZ *3 )); + adapter->if_ops.wakeup (adapter); +continue ; + } + +if (IS_CARD_RX_RCVD (adapter)) { + adapter->data_received = false; + adapter->pm_wakeup_fw_try = false; +del_timer (&adapter->wakeup_timer); +if (adapter->ps_state ==PS_STATE_SLEEP ) + adapter->ps_state =PS_STATE_AWAKE ; + }else { +/* We have tried to wakeup the card already */ +if (adapter->pm_wakeup_fw_try) +break ; +if (adapter->ps_state ==PS_STATE_PRE_SLEEP ) +nxpwifi_check_ps_cond (adapter); + +if (adapter->ps_state !=PS_STATE_AWAKE ) +break ; +if (adapter->tx_lock_flag) +break ; + +if ((!adapter->scan_chan_gap_enabled && + adapter->scan_processing) || adapter->data_sent || + (nxpwifi_wmm_lists_empty (adapter) && +nxpwifi_bypass_txlist_empty (adapter) && +skb_queue_empty (&adapter->tx_data_q))) { +if (adapter->cmd_sent || adapter->curr_cmd || + (!is_command_pending (adapter))) +break ; + } + } + +/* Check for event */ +if (adapter->event_received) { + adapter->event_received = false; +nxpwifi_process_event (adapter); + } + +/* Check for Cmd Resp */ +if (adapter->cmd_resp_received) { + adapter->cmd_resp_received = false; +nxpwifi_process_cmdresp (adapter); + +/* call nxpwifi back when init_fw is done */ +if (adapter->hw_status ==NXPWIFI_HW_STATUS_INIT_DONE ) { + adapter->hw_status =NXPWIFI_HW_STATUS_READY ; +nxpwifi_init_fw_complete (adapter); +maybe_quirk_fw_disable_ds (adapter); + } + } + +/* Check if we need to confirm Sleep Request +* received previously +*/ +if (adapter->ps_state ==PS_STATE_PRE_SLEEP ) +nxpwifi_check_ps_cond (adapter); + +/* * The ps_state may have been changed during processing of +* Sleep Request event. +*/ +if (adapter->ps_state ==PS_STATE_SLEEP || + adapter->ps_state ==PS_STATE_PRE_SLEEP || + adapter->ps_state ==PS_STATE_SLEEP_CFM ) { +continue ; + } + +if (adapter->tx_lock_flag) +continue ; + +if (!adapter->cmd_sent && !adapter->curr_cmd) { +if (nxpwifi_exec_next_cmd (adapter) ==-1 ) { + ret =-1 ; +break ; + } + } + +if ((adapter->scan_chan_gap_enabled || + !adapter->scan_processing) && + !adapter->data_sent && + !skb_queue_empty (&adapter->tx_data_q)) { +if (adapter->hs_activated_manually) { +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ), +NXPWIFI_ASYNC_CMD ); + adapter->hs_activated_manually = false; + } + +nxpwifi_process_tx_queue (adapter); +if (adapter->hs_activated) { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags); +nxpwifi_hs_activated_event + (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), + false); + } + } + +if ((adapter->scan_chan_gap_enabled || + !adapter->scan_processing) && + !adapter->data_sent && + !nxpwifi_bypass_txlist_empty (adapter)) { +if (adapter->hs_activated_manually) { +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ), +NXPWIFI_ASYNC_CMD ); + adapter->hs_activated_manually = false; + } + +nxpwifi_process_bypass_tx (adapter); +if (adapter->hs_activated) { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags); +nxpwifi_hs_activated_event + (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), + false); + } + } + +if ((adapter->scan_chan_gap_enabled || + !adapter->scan_processing) && + !adapter->data_sent && !nxpwifi_wmm_lists_empty (adapter)) { +if (adapter->hs_activated_manually) { +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ), +NXPWIFI_ASYNC_CMD ); + adapter->hs_activated_manually = false; + } + +nxpwifi_wmm_process_tx (adapter); +if (adapter->hs_activated) { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags); +nxpwifi_hs_activated_event + (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), + false); + } + } + +if (adapter->delay_null_pkt && !adapter->cmd_sent && + !adapter->curr_cmd && !is_command_pending (adapter) && + (nxpwifi_wmm_lists_empty (adapter) && +nxpwifi_bypass_txlist_empty (adapter) && +skb_queue_empty (&adapter->tx_data_q))) { +if (!nxpwifi_send_null_packet + (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ), + NXPWIFI_TxPD_POWER_MGMT_NULL_PACKET | + NXPWIFI_TxPD_POWER_MGMT_LAST_PACKET)) { + adapter->delay_null_pkt = false; + adapter->ps_state =PS_STATE_SLEEP ; + } +break ; + } + }while (true); + +spin_lock_irqsave (&adapter->main_proc_lock, flags); +if (adapter->more_task_flag) { + adapter->more_task_flag = false; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + goto process_start; + } + adapter->nxpwifi_processing = false; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + +return ret; +} +EXPORT_SYMBOL_GPL (nxpwifi_main_process); + +/* This function frees the adapter structure. +* +* Additionally, this closes the netlink socket, frees the timers +* and private structures. +*/ +static void nxpwifi_free_adapter (struct nxpwifi_adapter *adapter) +{ +if (!adapter) { +pr_err ("%s: adapter is NULL\n" , __func__); +return ; + } + +nxpwifi_unregister (adapter); +pr_debug ("info: %s: free adapter\n" , __func__); +} + +/* This function cancels all works in the queue and destroys +* the main workqueue. +*/ +static void nxpwifi_terminate_workqueue (struct nxpwifi_adapter *adapter) +{ +if (adapter->workqueue) { +destroy_workqueue (adapter->workqueue); + adapter->workqueue =NULL ; + } + +if (adapter->rx_workqueue) { +destroy_workqueue (adapter->rx_workqueue); + adapter->rx_workqueue =NULL ; + } + +if (adapter->host_mlme_workqueue) { +destroy_workqueue (adapter->host_mlme_workqueue); + adapter->host_mlme_workqueue =NULL ; + } +} + +/* This function gets firmware and initializes it. +* +* The main initialization steps followed are - +* - Download the correct firmware to card +* - Issue the init commands to firmware +*/ +static int _nxpwifi_fw_dpc (const struct firmware *firmware,void *context) +{ +int ret; +char fmt[64 ]; +struct nxpwifi_adapter *adapter = context; +struct nxpwifi_fw_image fw; +bool init_failed = false; +struct wireless_dev *wdev; +struct completion *fw_done = adapter->fw_done; + +if (!firmware) { +nxpwifi_dbg (adapter,ERROR , +"Failed to get firmware %s\n" , adapter->fw_name); + goto err_dnld_fw; + } + +memset (&fw,0 ,sizeof (struct nxpwifi_fw_image )); + adapter->firmware = firmware; + fw.fw_buf = (u8 *)adapter->firmware->data; + fw.fw_len = adapter->firmware->size; + +if (adapter->if_ops.dnld_fw) + ret = adapter->if_ops.dnld_fw (adapter, &fw); +else + ret =nxpwifi_dnld_fw (adapter, &fw); + +if (ret ==-1 ) + goto err_dnld_fw; + +nxpwifi_dbg (adapter,MSG ,"WLAN FW is active\n" ); + +/* enable host interrupt after fw dnld is successful */ +if (adapter->if_ops.enable_int) { +if (adapter->if_ops.enable_int (adapter)) + goto err_dnld_fw; + } + + adapter->init_wait_q_woken = false; + ret =nxpwifi_init_fw (adapter); +if (ret ==-1 ) { + goto err_init_fw; + }else if (!ret) { + adapter->hw_status =NXPWIFI_HW_STATUS_READY ; + goto done; + } +/* Wait for nxpwifi_init to complete */ +wait_event_interruptible (adapter->init_wait_q, + adapter->init_wait_q_woken); +if (adapter->hw_status !=NXPWIFI_HW_STATUS_READY ) + goto err_init_fw; + +if (!adapter->wiphy) { +if (nxpwifi_register_cfg80211 (adapter)) { +nxpwifi_dbg (adapter,ERROR , +"cannot register with cfg80211\n" ); + goto err_init_fw; + } + } + +if (nxpwifi_init_channel_scan_gap (adapter)) { +nxpwifi_dbg (adapter,ERROR , +"could not init channel stats table\n" ); + goto err_init_chan_scan; + } + +rtnl_lock (); +wiphy_lock (adapter->wiphy); +/* Create station interface by default */ + wdev =nxpwifi_add_virtual_intf (adapter->wiphy,"mlan%d" ,NET_NAME_ENUM , +NL80211_IFTYPE_STATION ,NULL ); +if (IS_ERR (wdev)) { +nxpwifi_dbg (adapter,ERROR , +"cannot create default STA interface\n" ); +wiphy_unlock (adapter->wiphy); +rtnl_unlock (); + goto err_add_intf; + } + + wdev =nxpwifi_add_virtual_intf (adapter->wiphy,"uap%d" ,NET_NAME_ENUM , +NL80211_IFTYPE_AP ,NULL ); +if (IS_ERR (wdev)) { +nxpwifi_dbg (adapter,ERROR , +"cannot create AP interface\n" ); +wiphy_unlock (adapter->wiphy); +rtnl_unlock (); + goto err_add_intf; + } + +wiphy_unlock (adapter->wiphy); +rtnl_unlock (); + +nxpwifi_drv_get_driver_version (adapter, fmt,sizeof (fmt) -1 ); +nxpwifi_dbg (adapter,MSG ,"driver_version = %s\n" , fmt); + adapter->is_up = true; + goto done; + +err_add_intf: +vfree (adapter->chan_stats); +err_init_chan_scan: +wiphy_unregister (adapter->wiphy); +wiphy_free (adapter->wiphy); +err_init_fw: +if (adapter->if_ops.disable_int) + adapter->if_ops.disable_int (adapter); +err_dnld_fw: +nxpwifi_dbg (adapter,ERROR , +"info: %s: unregister device\n" , __func__); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); + +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +nxpwifi_terminate_workqueue (adapter); + +if (adapter->hw_status ==NXPWIFI_HW_STATUS_READY ) { +pr_debug ("info: %s: shutdown nxpwifi\n" , __func__); +nxpwifi_shutdown_drv (adapter); +nxpwifi_free_cmd_buffers (adapter); + } + + init_failed = true; +done: +if (adapter->cal_data) { +release_firmware (adapter->cal_data); + adapter->cal_data =NULL ; + } +if (adapter->firmware) { +release_firmware (adapter->firmware); + adapter->firmware =NULL ; + } +if (init_failed) { +if (adapter->irq_wakeup >=0 ) +device_init_wakeup (adapter->dev, false); +nxpwifi_free_adapter (adapter); + } +/* Tell all current and future waiters we're finished */ +complete_all (fw_done); + +return init_failed ? -EIO :0 ; +} + +static void nxpwifi_fw_dpc (const struct firmware *firmware,void *context) +{ +_nxpwifi_fw_dpc (firmware, context); +} + +/* This function gets the firmware and (if called asynchronously) kicks off the +* HW init when done. +*/ +static int nxpwifi_init_hw_fw (struct nxpwifi_adapter *adapter, +bool req_fw_nowait) +{ +int ret; + +if (req_fw_nowait) { + ret =request_firmware_nowait (THIS_MODULE ,1 , adapter->fw_name, + adapter->dev,GFP_KERNEL , adapter, + nxpwifi_fw_dpc); + }else { + ret =request_firmware (&adapter->firmware, + adapter->fw_name, + adapter->dev); + } + +if (ret <0 ) +nxpwifi_dbg (adapter,ERROR ,"request_firmware%s error %d\n" , + req_fw_nowait ?"_nowait" :"" , ret); +return ret; +} + +/* CFG802.11 network device handler for open. +* +* Starts the data queue. +*/ +static int +nxpwifi_open (struct net_device *dev) +{ +netif_carrier_off (dev); + +return 0 ; +} + +/* CFG802.11 network device handler for close. +*/ +static int +nxpwifi_close (struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + +if (priv->scan_request) { +struct cfg80211_scan_info info = { + .aborted = true, + }; + +nxpwifi_dbg (priv->adapter,INFO , +"aborting scan on ndo_stop\n" ); +cfg80211_scan_done (priv->scan_request, &info); + priv->scan_request =NULL ; + priv->scan_aborting = true; + } + +if (priv->sched_scanning) { +nxpwifi_dbg (priv->adapter,INFO , +"aborting bgscan on ndo_stop\n" ); +nxpwifi_stop_bg_scan (priv); +cfg80211_sched_scan_stopped (priv->wdev.wiphy,0 ); + } + +return 0 ; +} + +static bool +nxpwifi_bypass_tx_queue (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct ethhdr *eth_hdr = (struct ethhdr *)skb->data; + +if (eth_hdr->h_proto ==htons (ETH_P_PAE ) || +nxpwifi_is_skb_mgmt_frame (skb)) { +nxpwifi_dbg (priv->adapter,DATA , +"bypass txqueue; eth type %#x, mgmt %d\n" , +ntohs (eth_hdr->h_proto), +nxpwifi_is_skb_mgmt_frame (skb)); +if (eth_hdr->h_proto ==htons (ETH_P_PAE )) +nxpwifi_dbg (priv->adapter,MSG , +"key: send EAPOL to %pM\n" , + eth_hdr->h_dest); +return true; + } + +return false; +} + +/* Add buffer into wmm tx queue and queue work to transmit it. +*/ +int nxpwifi_queue_tx_pkt (struct nxpwifi_private *priv,struct sk_buff *skb) +{ +struct netdev_queue *txq; +int index = nxpwifi_1d_to_wmm_queue[skb->priority]; + +if (atomic_inc_return (&priv->wmm_tx_pending[index]) >=MAX_TX_PENDING ) { + txq =netdev_get_tx_queue (priv->netdev, index); +if (!netif_tx_queue_stopped (txq)) { +netif_tx_stop_queue (txq); +nxpwifi_dbg (priv->adapter,DATA , +"stop queue: %d\n" , index); + } + } + +if (nxpwifi_bypass_tx_queue (priv, skb)) { +atomic_inc (&priv->adapter->tx_pending); +atomic_inc (&priv->adapter->bypass_tx_pending); +nxpwifi_wmm_add_buf_bypass_txqueue (priv, skb); + }else { +atomic_inc (&priv->adapter->tx_pending); +nxpwifi_wmm_add_buf_txqueue (priv, skb); + } + +nxpwifi_queue_main_work (priv->adapter); + +return 0 ; +} + +struct sk_buff * +nxpwifi_clone_skb_for_tx_status (struct nxpwifi_private *priv, +struct sk_buff *skb,u8 flag,u64 *cookie) +{ +struct sk_buff *orig_skb = skb; +struct nxpwifi_txinfo *tx_info, *orig_tx_info; + + skb =skb_clone (skb,GFP_ATOMIC ); +if (skb) { +int id; + +spin_lock_bh (&priv->ack_status_lock); + id =idr_alloc (&priv->ack_status_frames, orig_skb, +1 ,0x10 ,GFP_ATOMIC ); +spin_unlock_bh (&priv->ack_status_lock); + +if (id >=0 ) { + tx_info =NXPWIFI_SKB_TXCB (skb); + tx_info->ack_frame_id = id; + tx_info->flags |= flag; + orig_tx_info =NXPWIFI_SKB_TXCB (orig_skb); + orig_tx_info->ack_frame_id = id; + orig_tx_info->flags |= flag; + +if (flag ==NXPWIFI_BUF_FLAG_ACTION_TX_STATUS && cookie) + orig_tx_info->cookie = *cookie; + + }else if (skb_shared (skb)) { +kfree_skb (orig_skb); + }else { +kfree_skb (skb); + skb = orig_skb; + } + }else { +/* couldn't clone -- lose tx status ... */ + skb = orig_skb; + } + +return skb; +} + +/* CFG802.11 network device handler for data transmission. +*/ +static netdev_tx_t +nxpwifi_hard_start_xmit (struct sk_buff *skb,struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct sk_buff *new_skb; +struct nxpwifi_txinfo *tx_info; +bool multicast; + +nxpwifi_dbg (priv->adapter,DATA , +"data: %lu BSS(%d-%d): Data <= kernel\n" , + jiffies, priv->bss_type, priv->bss_num); + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &priv->adapter->work_flags)) { +kfree_skb (skb); + priv->stats.tx_dropped++; +return 0 ; + } +if (!skb->len || skb->len >ETH_FRAME_LEN ) { +nxpwifi_dbg (priv->adapter,ERROR , +"Tx: bad skb len %d\n" , skb->len); +kfree_skb (skb); + priv->stats.tx_dropped++; +return 0 ; + } +if (skb_headroom (skb) <NXPWIFI_MIN_DATA_HEADER_LEN ) { +nxpwifi_dbg (priv->adapter,DATA , +"data: Tx: insufficient skb headroom %d\n" , +skb_headroom (skb)); +/* Insufficient skb headroom - allocate a new skb */ + new_skb = +skb_realloc_headroom (skb,NXPWIFI_MIN_DATA_HEADER_LEN ); +if (unlikely (!new_skb)) { +nxpwifi_dbg (priv->adapter,ERROR , +"Tx: cannot alloca new_skb\n" ); +kfree_skb (skb); + priv->stats.tx_dropped++; +return 0 ; + } +kfree_skb (skb); + skb = new_skb; +nxpwifi_dbg (priv->adapter,INFO , +"info: new skb headroomd %d\n" , +skb_headroom (skb)); + } + + tx_info =NXPWIFI_SKB_TXCB (skb); +memset (tx_info,0 ,sizeof (*tx_info)); + tx_info->bss_num = priv->bss_num; + tx_info->bss_type = priv->bss_type; + tx_info->pkt_len = skb->len; + + multicast =is_multicast_ether_addr (skb->data); + +if (unlikely (!multicast && skb->sk && +skb_shinfo (skb)->tx_flags &SKBTX_WIFI_STATUS && + priv->adapter->fw_api_ver ==NXPWIFI_FW_V15 )) + skb =nxpwifi_clone_skb_for_tx_status (priv, + skb, +NXPWIFI_BUF_FLAG_EAPOL_TX_STATUS ,NULL ); + +/* Record the current time the packet was queued; used to +* determine the amount of time the packet was queued in +* the driver before it was sent to the firmware. +* The delay is then sent along with the packet to the +* firmware for aggregate delay calculation for stats and +* MSDU lifetime expiry. +*/ +__net_timestamp (skb); + +nxpwifi_queue_tx_pkt (priv, skb); + +return 0 ; +} + +int nxpwifi_set_mac_address (struct nxpwifi_private *priv, +struct net_device *dev,bool external, +u8 *new_mac) +{ +int ret; +u64 mac_addr, old_mac_addr; + + old_mac_addr =ether_addr_to_u64 (priv->curr_addr); + +if (external) { + mac_addr =ether_addr_to_u64 (new_mac); + }else { +/* Internal mac address change */ +if (priv->bss_type ==NXPWIFI_BSS_TYPE_ANY ) +return -EOPNOTSUPP ; + + mac_addr = old_mac_addr; + +if (priv->adapter->priv[0 ] != priv) { +/* Set mac address based on bss_type/bss_num */ + mac_addr ^=BIT_ULL (priv->bss_type +8 ); + mac_addr += priv->bss_num; + } + } + +u64_to_ether_addr (mac_addr, priv->curr_addr); + +/* Send request to firmware */ + ret =nxpwifi_send_cmd (priv,HOST_CMD_802_11_MAC_ADDRESS , +HOST_ACT_GEN_SET ,0 ,NULL , true); + +if (ret) { +u64_to_ether_addr (old_mac_addr, priv->curr_addr); +nxpwifi_dbg (priv->adapter,ERROR , +"set mac address failed: ret=%d\n" , ret); +return ret; + } + +eth_hw_addr_set (dev, priv->curr_addr); +return 0 ; +} + +/* CFG802.11 network device handler for setting MAC address. +*/ +static int +nxpwifi_ndo_set_mac_address (struct net_device *dev,void *addr) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct sockaddr *hw_addr = addr; + +return nxpwifi_set_mac_address (priv, dev, true, hw_addr->sa_data); +} + +/* CFG802.11 network device handler for setting multicast list. +*/ +static void nxpwifi_set_multicast_list (struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_multicast_list mcast_list; + +if (dev->flags &IFF_PROMISC ) { + mcast_list.mode =NXPWIFI_PROMISC_MODE ; + }else if (dev->flags &IFF_ALLMULTI || +netdev_mc_count (dev) >NXPWIFI_MAX_MULTICAST_LIST_SIZE ) { + mcast_list.mode =NXPWIFI_ALL_MULTI_MODE ; + }else { + mcast_list.mode =NXPWIFI_MULTICAST_MODE ; + mcast_list.num_multicast_addr = +nxpwifi_copy_mcast_addr (&mcast_list, dev); + } +nxpwifi_request_set_multicast_list (priv, &mcast_list); +} + +/* CFG802.11 network device handler for transmission timeout. +*/ +static void +nxpwifi_tx_timeout (struct net_device *dev,unsigned int txqueue) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + + priv->num_tx_timeout++; + priv->tx_timeout_cnt++; +nxpwifi_dbg (priv->adapter,ERROR , +"%lu : Tx timeout(#%d), bss_type-num = %d-%d\n" , + jiffies, priv->tx_timeout_cnt, priv->bss_type, + priv->bss_num); +nxpwifi_set_trans_start (dev); + +if (priv->tx_timeout_cnt >TX_TIMEOUT_THRESHOLD && + priv->adapter->if_ops.card_reset) { +nxpwifi_dbg (priv->adapter,ERROR , +"tx_timeout_cnt exceeds threshold.\t" +"Triggering card reset!\n" ); + priv->adapter->if_ops.card_reset (priv->adapter); + } +} + +void nxpwifi_upload_device_dump (struct nxpwifi_adapter *adapter) +{ +/* Dump all the memory data into single file, a userspace script will +* be used to split all the memory data to multiple files +*/ +nxpwifi_dbg (adapter,MSG , +"== nxpwifi dump information to /sys/class/devcoredump start\n" ); +dev_coredumpv (adapter->dev, adapter->devdump_data, adapter->devdump_len, +GFP_KERNEL ); +nxpwifi_dbg (adapter,MSG , +"== nxpwifi dump information to /sys/class/devcoredump end\n" ); + +/* Device dump data will be freed in device coredump release function +* after 5 min. Here reset adapter->devdump_data and ->devdump_len +* to avoid it been accidentally reused. +*/ + adapter->devdump_data =NULL ; + adapter->devdump_len =0 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_upload_device_dump); + +void nxpwifi_drv_info_dump (struct nxpwifi_adapter *adapter) +{ +char *p; +char drv_version[64 ]; +struct sdio_mmc_card *sdio_card; +struct nxpwifi_private *priv; +int i, idx; +struct netdev_queue *txq; +struct nxpwifi_debug_info *debug_info; + +nxpwifi_dbg (adapter,MSG ,"===nxpwifi driverinfo dump start===\n" ); + + p = adapter->devdump_data; +strscpy (p,"========Start dump driverinfo========\n" ,NXPWIFI_FW_DUMP_SIZE ); + p +=strlen ("========Start dump driverinfo========\n" ); + p +=sprintf (p,"driver_name = " ); + p +=sprintf (p,"\"nxpwifi\"\n" ); + +nxpwifi_drv_get_driver_version (adapter, drv_version, +sizeof (drv_version) -1 ); + p +=sprintf (p,"driver_version = %s\n" , drv_version); + + p +=sprintf (p,"tx_pending = %d\n" , +atomic_read (&adapter->tx_pending)); + p +=sprintf (p,"rx_pending = %d\n" , +atomic_read (&adapter->rx_pending)); + +if (adapter->iface_type ==NXPWIFI_SDIO ) { + sdio_card = (struct sdio_mmc_card *)adapter->card; + p +=sprintf (p,"\nmp_rd_bitmap=0x%x curr_rd_port=0x%x\n" , + sdio_card->mp_rd_bitmap, sdio_card->curr_rd_port); + p +=sprintf (p,"mp_wr_bitmap=0x%x curr_wr_port=0x%x\n" , + sdio_card->mp_wr_bitmap, sdio_card->curr_wr_port); + } + +for (i =0 ; i < adapter->priv_num; i++) { +if (!adapter->priv[i] || !adapter->priv[i]->netdev) +continue ; + priv = adapter->priv[i]; + p +=sprintf (p,"\n[interface : \"%s\"]\n" , + priv->netdev->name); + p +=sprintf (p,"wmm_tx_pending[0] = %d\n" , +atomic_read (&priv->wmm_tx_pending[0 ])); + p +=sprintf (p,"wmm_tx_pending[1] = %d\n" , +atomic_read (&priv->wmm_tx_pending[1 ])); + p +=sprintf (p,"wmm_tx_pending[2] = %d\n" , +atomic_read (&priv->wmm_tx_pending[2 ])); + p +=sprintf (p,"wmm_tx_pending[3] = %d\n" , +atomic_read (&priv->wmm_tx_pending[3 ])); + p +=sprintf (p,"media_state=\"%s\"\n" , !priv->media_connected ? +"Disconnected" :"Connected" ); + p +=sprintf (p,"carrier %s\n" , (netif_carrier_ok (priv->netdev) + ?"on" :"off" )); +for (idx =0 ; idx < priv->netdev->num_tx_queues; idx++) { + txq =netdev_get_tx_queue (priv->netdev, idx); + p +=sprintf (p,"tx queue %d:%s " , idx, +netif_tx_queue_stopped (txq) ? +"stopped" :"started" ); + } + p +=sprintf (p,"\n%s: num_tx_timeout = %d\n" , + priv->netdev->name, priv->num_tx_timeout); + } + +if (adapter->iface_type ==NXPWIFI_SDIO ) { + p +=sprintf (p,"\n=== %s register dump===\n" ,"SDIO" ); +if (adapter->if_ops.reg_dump) + p += adapter->if_ops.reg_dump (adapter, p); + } + p +=sprintf (p,"\n=== more debug information\n" ); + debug_info =kzalloc (sizeof (*debug_info),GFP_KERNEL ); +if (debug_info) { +for (i =0 ; i < adapter->priv_num; i++) { +if (!adapter->priv[i] || !adapter->priv[i]->netdev) +continue ; + priv = adapter->priv[i]; +nxpwifi_get_debug_info (priv, debug_info); + p +=nxpwifi_debug_info_to_buffer (priv, p, debug_info); +break ; + } +kfree (debug_info); + } + + p +=sprintf (p,"\n========End dump========\n" ); +nxpwifi_dbg (adapter,MSG ,"===nxpwifi driverinfo dump end===\n" ); + adapter->devdump_len = p - (char *)adapter->devdump_data; +} +EXPORT_SYMBOL_GPL (nxpwifi_drv_info_dump); + +void nxpwifi_prepare_fw_dump_info (struct nxpwifi_adapter *adapter) +{ +u8 idx; +char *fw_dump_ptr; +u32 dump_len =0 ; + +for (idx =0 ; idx < adapter->num_mem_types; idx++) { +struct memory_type_mapping *entry = + &adapter->mem_type_mapping_tbl[idx]; + +if (entry->mem_ptr) { + dump_len += (strlen ("========Start dump " ) + +strlen (entry->mem_name) + +strlen ("========\n" ) + + (entry->mem_size +1 ) + +strlen ("\n========End dump========\n" )); + } + } + +if (dump_len +1 + adapter->devdump_len >NXPWIFI_FW_DUMP_SIZE ) { +/* Realloc in case buffer overflow */ + fw_dump_ptr =vzalloc (dump_len +1 + adapter->devdump_len); +nxpwifi_dbg (adapter,MSG ,"Realloc device dump data.\n" ); +if (!fw_dump_ptr) { +vfree (adapter->devdump_data); +nxpwifi_dbg (adapter,ERROR , +"vzalloc devdump data failure!\n" ); +return ; + } + +memmove (fw_dump_ptr, adapter->devdump_data, + adapter->devdump_len); +vfree (adapter->devdump_data); + adapter->devdump_data = fw_dump_ptr; + } + + fw_dump_ptr = (char *)adapter->devdump_data + adapter->devdump_len; + +for (idx =0 ; idx < adapter->num_mem_types; idx++) { +struct memory_type_mapping *entry = + &adapter->mem_type_mapping_tbl[idx]; + +if (entry->mem_ptr) { + fw_dump_ptr +=sprintf (fw_dump_ptr,"========Start dump " ); + fw_dump_ptr +=sprintf (fw_dump_ptr,"%s" , entry->mem_name); + fw_dump_ptr +=sprintf (fw_dump_ptr,"========\n" ); +memcpy (fw_dump_ptr, entry->mem_ptr, entry->mem_size); + fw_dump_ptr += entry->mem_size; + fw_dump_ptr +=sprintf (fw_dump_ptr,"\n========End dump========\n" ); + } + } + + adapter->devdump_len = fw_dump_ptr - (char *)adapter->devdump_data; + +for (idx =0 ; idx < adapter->num_mem_types; idx++) { +struct memory_type_mapping *entry = + &adapter->mem_type_mapping_tbl[idx]; + +vfree (entry->mem_ptr); + entry->mem_ptr =NULL ; + entry->mem_size =0 ; + } +} +EXPORT_SYMBOL_GPL (nxpwifi_prepare_fw_dump_info); + +/* CFG802.11 network device handler for statistics retrieval. +*/ +static struct net_device_stats *nxpwifi_get_stats (struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + +return &priv->stats; +} + +static u16 +nxpwifi_netdev_select_wmm_queue (struct net_device *dev,struct sk_buff *skb, +struct net_device *sb_dev) +{ + skb->priority =cfg80211_classify8021d (skb,NULL ); +return nxpwifi_1d_to_wmm_queue[skb->priority]; +} + +/* Network device handlers */ +static const struct net_device_ops nxpwifi_netdev_ops = { + .ndo_open = nxpwifi_open, + .ndo_stop = nxpwifi_close, + .ndo_start_xmit = nxpwifi_hard_start_xmit, + .ndo_set_mac_address = nxpwifi_ndo_set_mac_address, + .ndo_validate_addr = eth_validate_addr, + .ndo_tx_timeout = nxpwifi_tx_timeout, + .ndo_get_stats = nxpwifi_get_stats, + .ndo_set_rx_mode = nxpwifi_set_multicast_list, + .ndo_select_queue = nxpwifi_netdev_select_wmm_queue, +}; + +/* This function initializes the private structure parameters. +* +* The following wait queues are initialized - +* - IOCTL wait queue +* - Command wait queue +* - Statistics wait queue +* +* ...and the following default parameters are set - +* - Current key index : Set to 0 +* - Rate index : Set to auto +* - Media connected : Set to disconnected +* - Nick name : Set to null +* - Number of Tx timeout : Set to 0 +* - Device address : Set to current address +* - Rx histogram statistc : Set to 0 +* +* In addition, the CFG80211 work queue is also created. +*/ +void nxpwifi_init_priv_params (struct nxpwifi_private *priv, +struct net_device *dev) +{ + dev->netdev_ops = &nxpwifi_netdev_ops; + dev->needs_free_netdev = true; +/* Initialize private structure */ + priv->current_key_index =0 ; + priv->media_connected = false; +memset (priv->mgmt_ie,0 , +sizeof (struct nxpwifi_ie ) *MAX_MGMT_IE_INDEX ); + priv->beacon_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->proberesp_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->assocresp_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->gen_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->num_tx_timeout =0 ; +if (is_valid_ether_addr (dev->dev_addr)) +ether_addr_copy (priv->curr_addr, dev->dev_addr); +else +ether_addr_copy (priv->curr_addr, priv->adapter->perm_addr); + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA || +GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { + priv->hist_data =kmalloc (sizeof (*priv->hist_data),GFP_KERNEL ); +if (priv->hist_data) +nxpwifi_hist_data_reset (priv); + } +} + +/* This function check if command is pending. +*/ +int is_command_pending (struct nxpwifi_adapter *adapter) +{ +int is_cmd_pend_q_empty; + +spin_lock_bh (&adapter->cmd_pending_q_lock); + is_cmd_pend_q_empty =list_empty (&adapter->cmd_pending_q); +spin_unlock_bh (&adapter->cmd_pending_q_lock); + +return !is_cmd_pend_q_empty; +} + +/* This is the host mlme work queue function. +* It handles the host mlme operations. +*/ +static void nxpwifi_host_mlme_work_queue (struct work_struct *work) +{ +struct nxpwifi_adapter *adapter = + container_of(work, struct nxpwifi_adapter, host_mlme_work); + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return ; + +/* Check for host mlme disconnection */ +if (adapter->host_mlme_link_lost) { +if (adapter->priv_link_lost) { +nxpwifi_reset_connect_state (adapter->priv_link_lost, +WLAN_REASON_DEAUTH_LEAVING , + true); + adapter->priv_link_lost =NULL ; + } + adapter->host_mlme_link_lost = false; + } + +/* Check for host mlme Assoc Resp */ +if (adapter->assoc_resp_received) { +nxpwifi_process_assoc_resp (adapter); + adapter->assoc_resp_received = false; + } +} + +/* This is the RX work queue function. +* +* It handles the RX operations. +*/ +static void nxpwifi_rx_work_queue (struct work_struct *work) +{ +struct nxpwifi_adapter *adapter = + container_of(work, struct nxpwifi_adapter, rx_work); + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return ; +nxpwifi_process_rx (adapter); +} + +/* This is the main work queue function. +* +* It handles the main process, which in turn handles the complete +* driver operations. +*/ +static void nxpwifi_main_work_queue (struct work_struct *work) +{ +struct nxpwifi_adapter *adapter = + container_of(work, struct nxpwifi_adapter, main_work); + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return ; +nxpwifi_main_process (adapter); +} + +/* Common teardown code used for both device removal and reset */ +static void nxpwifi_uninit_sw (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +int i; + +/* We can no longer handle interrupts once we start doing the teardown +* below. +*/ +if (adapter->if_ops.disable_int) + adapter->if_ops.disable_int (adapter); + +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +nxpwifi_terminate_workqueue (adapter); + adapter->int_status =0 ; + +/* Stop data */ +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (priv && priv->netdev) { +nxpwifi_stop_net_dev_queue (priv->netdev, adapter); +if (netif_carrier_ok (priv->netdev)) +netif_carrier_off (priv->netdev); +netif_device_detach (priv->netdev); + } + } + +nxpwifi_dbg (adapter,CMD ,"cmd: calling nxpwifi_shutdown_drv...\n" ); +nxpwifi_shutdown_drv (adapter); +nxpwifi_dbg (adapter,CMD ,"cmd: nxpwifi_shutdown_drv done\n" ); + +if (atomic_read (&adapter->rx_pending) || +atomic_read (&adapter->tx_pending) || +atomic_read (&adapter->cmd_pending)) { +nxpwifi_dbg (adapter,ERROR , +"rx_pending=%d, tx_pending=%d,\t" +"cmd_pending=%d\n" , +atomic_read (&adapter->rx_pending), +atomic_read (&adapter->tx_pending), +atomic_read (&adapter->cmd_pending)); + } + +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (!priv) +continue ; +rtnl_lock (); +if (priv->netdev && + priv->wdev.iftype !=NL80211_IFTYPE_UNSPECIFIED ) { +/* Close the netdev now, because if we do it later, the +* netdev notifiers will need to acquire the wiphy lock +* again --> deadlock. +*/ +dev_close (priv->wdev.netdev); +wiphy_lock (adapter->wiphy); +nxpwifi_del_virtual_intf (adapter->wiphy, &priv->wdev); +wiphy_unlock (adapter->wiphy); + } +rtnl_unlock (); + } + +wiphy_unregister (adapter->wiphy); +wiphy_free (adapter->wiphy); + adapter->wiphy =NULL ; + +vfree (adapter->chan_stats); +nxpwifi_free_cmd_buffers (adapter); +} + +/* This function can be used for shutting down the adapter SW. +*/ +int nxpwifi_shutdown_sw (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; + +if (!adapter) +return 0 ; + +wait_for_completion (adapter->fw_done); +/* Caller should ensure we aren't suspending while this happens */ +reinit_completion (adapter->fw_done); + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +nxpwifi_deauthenticate (priv,NULL ); + +nxpwifi_init_shutdown_fw (priv,NXPWIFI_FUNC_SHUTDOWN ); + +nxpwifi_uninit_sw (adapter); + adapter->is_up = false; + +return 0 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_shutdown_sw); + +/* This function can be used for reinitting the adapter SW. Required +* code is extracted from nxpwifi_add_card() +*/ +int +nxpwifi_reinit_sw (struct nxpwifi_adapter *adapter) +{ +int ret; + +nxpwifi_init_lock_list (adapter); +if (adapter->if_ops.up_dev) + adapter->if_ops.up_dev (adapter); + + adapter->hw_status =NXPWIFI_HW_STATUS_INITIALIZING ; +clear_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +init_waitqueue_head (&adapter->init_wait_q); +clear_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags); + adapter->hs_activated = false; +clear_bit (NXPWIFI_IS_CMD_TIMEDOUT , &adapter->work_flags); +init_waitqueue_head (&adapter->hs_activate_wait_q); +init_waitqueue_head (&adapter->cmd_wait_q.wait); + adapter->cmd_wait_q.status =0 ; + adapter->scan_wait_q_woken = false; + +if (num_possible_cpus () >1 ) + adapter->rx_work_enabled = true; + + adapter->workqueue = +alloc_workqueue ("NXPWIFI_WORK_QUEUE" , +WQ_HIGHPRI |WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (!adapter->workqueue) + goto err_kmalloc; + +INIT_WORK (&adapter->main_work, nxpwifi_main_work_queue); + +if (adapter->rx_work_enabled) { + adapter->rx_workqueue =alloc_workqueue ("NXPWIFI_RX_WORK_QUEUE" , +WQ_HIGHPRI | +WQ_MEM_RECLAIM | +WQ_UNBOUND ,0 ); +if (!adapter->rx_workqueue) + goto err_kmalloc; +INIT_WORK (&adapter->rx_work, nxpwifi_rx_work_queue); + } + + adapter->host_mlme_workqueue = +alloc_workqueue ("NXPWIFI_HOST_MLME_WORK_QUEUE" , +WQ_HIGHPRI |WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (!adapter->host_mlme_workqueue) + goto err_kmalloc; + +INIT_WORK (&adapter->host_mlme_work, nxpwifi_host_mlme_work_queue); + +/* Register the device. Fill up the private data structure with +* relevant information from the card. Some code extracted from +* nxpwifi_register_dev() +*/ +nxpwifi_dbg (adapter,INFO ,"%s, nxpwifi_init_hw_fw()...\n" , __func__); + +if (nxpwifi_init_hw_fw (adapter, false)) { +nxpwifi_dbg (adapter,ERROR , +"%s: firmware init failed\n" , __func__); + goto err_init_fw; + } + +/* _nxpwifi_fw_dpc() does its own cleanup */ + ret =_nxpwifi_fw_dpc (adapter->firmware, adapter); +if (ret) { +pr_err ("Failed to bring up adapter: %d\n" , ret); +return ret; + } +nxpwifi_dbg (adapter,INFO ,"%s, successful\n" , __func__); + +return 0 ; + +err_init_fw: +nxpwifi_dbg (adapter,ERROR ,"info: %s: unregister device\n" , __func__); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); + +err_kmalloc: +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +nxpwifi_terminate_workqueue (adapter); +if (adapter->hw_status ==NXPWIFI_HW_STATUS_READY ) { +nxpwifi_dbg (adapter,ERROR , +"info: %s: shutdown nxpwifi\n" , __func__); +nxpwifi_shutdown_drv (adapter); +nxpwifi_free_cmd_buffers (adapter); + } + +complete_all (adapter->fw_done); +nxpwifi_dbg (adapter,INFO ,"%s, error\n" , __func__); + +return -1 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_reinit_sw); + +static irqreturn_t nxpwifi_irq_wakeup_handler (int irq,void *priv) +{ +struct nxpwifi_adapter *adapter = priv; + +dev_dbg (adapter->dev,"%s: wake by wifi" , __func__); + adapter->wake_by_wifi = true; +disable_irq_nosync (irq); + +/* Notify PM core we are wakeup source */ +pm_wakeup_event (adapter->dev,0 ); +pm_system_wakeup (); + +return IRQ_HANDLED ; +} + +static void nxpwifi_probe_of (struct nxpwifi_adapter *adapter) +{ +int ret; +struct device *dev = adapter->dev; + +if (!dev->of_node) + goto err_exit; + + adapter->dt_node = dev->of_node; + adapter->irq_wakeup =irq_of_parse_and_map (adapter->dt_node,0 ); +if (!adapter->irq_wakeup) { +dev_dbg (dev,"fail to parse irq_wakeup from device tree\n" ); + goto err_exit; + } + + ret =devm_request_irq (dev, adapter->irq_wakeup, + nxpwifi_irq_wakeup_handler,IRQF_TRIGGER_LOW , +"wifi_wake" , adapter); +if (ret) { +dev_err (dev,"Failed to request irq_wakeup %d (%d)\n" , + adapter->irq_wakeup, ret); + goto err_exit; + } + +disable_irq (adapter->irq_wakeup); +if (device_init_wakeup (dev, true)) { +dev_err (dev,"fail to init wakeup for nxpwifi\n" ); + goto err_exit; + } +return ; + +err_exit: + adapter->irq_wakeup =-1 ; +} + +/* This function adds the card. +* +* This function follows the following major steps to set up the device - +* - Initialize software. This includes probing the card, registering +* the interface operations table, and allocating/initializing the +* adapter structure +* - Set up the netlink socket +* - Create and start the main work queue +* - Register the device +* - Initialize firmware and hardware +* - Add logical interfaces +*/ +int +nxpwifi_add_card (void *card,struct completion *fw_done, +struct nxpwifi_if_ops *if_ops,u8 iface_type, +struct device *dev) +{ +struct nxpwifi_adapter *adapter; + +if (nxpwifi_register (card, dev, if_ops, (void **)&adapter)) { +pr_err ("%s: software init failed\n" , __func__); + goto err_init_sw; + } + +nxpwifi_probe_of (adapter); + + adapter->iface_type = iface_type; + adapter->fw_done = fw_done; + + adapter->hw_status =NXPWIFI_HW_STATUS_INITIALIZING ; +clear_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +init_waitqueue_head (&adapter->init_wait_q); +clear_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags); + adapter->hs_activated = false; +init_waitqueue_head (&adapter->hs_activate_wait_q); +init_waitqueue_head (&adapter->cmd_wait_q.wait); + adapter->cmd_wait_q.status =0 ; + adapter->scan_wait_q_woken = false; + +if (num_possible_cpus () >1 ) + adapter->rx_work_enabled = true; + + adapter->workqueue = +alloc_workqueue ("NXPWIFI_WORK_QUEUE" , +WQ_HIGHPRI |WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (!adapter->workqueue) + goto err_kmalloc; + +INIT_WORK (&adapter->main_work, nxpwifi_main_work_queue); + +if (adapter->rx_work_enabled) { + adapter->rx_workqueue =alloc_workqueue ("NXPWIFI_RX_WORK_QUEUE" , +WQ_HIGHPRI | +WQ_MEM_RECLAIM | +WQ_UNBOUND ,0 ); +if (!adapter->rx_workqueue) + goto err_kmalloc; + +INIT_WORK (&adapter->rx_work, nxpwifi_rx_work_queue); + } + + adapter->host_mlme_workqueue = +alloc_workqueue ("NXPWIFI_HOST_MLME_WORK_QUEUE" , +WQ_HIGHPRI |WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (!adapter->host_mlme_workqueue) + goto err_kmalloc; + +INIT_WORK (&adapter->host_mlme_work, nxpwifi_host_mlme_work_queue); + +/* Register the device. Fill up the private data structure with relevant +* information from the card. +*/ +if (adapter->if_ops.register_dev (adapter)) { +pr_err ("%s: failed to register nxpwifi device\n" , __func__); + goto err_registerdev; + } + +if (nxpwifi_init_hw_fw (adapter, true)) { +pr_err ("%s: firmware init failed\n" , __func__); + goto err_init_fw; + } + +return 0 ; + +err_init_fw: +pr_debug ("info: %s: unregister device\n" , __func__); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); +err_registerdev: +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +nxpwifi_terminate_workqueue (adapter); +if (adapter->hw_status ==NXPWIFI_HW_STATUS_READY ) { +pr_debug ("info: %s: shutdown nxpwifi\n" , __func__); +nxpwifi_shutdown_drv (adapter); +nxpwifi_free_cmd_buffers (adapter); + } +err_kmalloc: +if (adapter->irq_wakeup >=0 ) +device_init_wakeup (adapter->dev, false); +nxpwifi_free_adapter (adapter); + +err_init_sw: + +return -1 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_add_card); + +/* This function removes the card. +* +* This function follows the following major steps to remove the device - +* - Stop data traffic +* - Shutdown firmware +* - Remove the logical interfaces +* - Terminate the work queue +* - Unregister the device +* - Free the adapter structure +*/ +int nxpwifi_remove_card (struct nxpwifi_adapter *adapter) +{ +if (!adapter) +return 0 ; + +if (adapter->is_up) +nxpwifi_uninit_sw (adapter); + +if (adapter->irq_wakeup >=0 ) +device_init_wakeup (adapter->dev, false); + +/* Unregister device */ +nxpwifi_dbg (adapter,INFO , +"info: unregister device\n" ); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); +/* Free adapter structure */ +nxpwifi_dbg (adapter,INFO , +"info: free adapter\n" ); +nxpwifi_free_adapter (adapter); + +return 0 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_remove_card); + +void _nxpwifi_dbg (const struct nxpwifi_adapter *adapter,int mask, +const char *fmt, ...) +{ +struct va_format vaf; +va_list args; + +if (!(adapter->debug_mask & mask)) +return ; + +va_start (args, fmt); + + vaf.fmt = fmt; + vaf.va = &args; + +if (adapter->dev) +dev_info (adapter->dev,"%pV" , &vaf); +else +pr_info ("%pV" , &vaf); + +va_end (args); +} +EXPORT_SYMBOL_GPL (_nxpwifi_dbg); + +/* This function initializes the module. +* +* The debug FS is also initialized if configured. +*/ +static int +nxpwifi_init_module (void ) +{ +#ifdef CONFIG_DEBUG_FS +nxpwifi_debugfs_init (); +#endif +return 0 ; +} + +/* This function cleans up the module. +* +* The debug FS is removed if available. +*/ +static void +nxpwifi_cleanup_module (void ) +{ +#ifdef CONFIG_DEBUG_FS +nxpwifi_debugfs_remove (); +#endif +} + +module_init (nxpwifi_init_module); +module_exit (nxpwifi_cleanup_module); + +MODULE_AUTHOR ("NXP International Ltd." ); +MODULE_DESCRIPTION ("NXP WiFi Driver version " VERSION ); +MODULE_VERSION (VERSION ); +MODULE_LICENSE ("GPL" );
Signature · 1 line
2.34.1
PATCH 24/43 wifi: nxpwifi: add main.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/main.h | 1507 +++++++++++++++++++++++ 1 file changed, 1507 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/main.h
drivers/net/wireless/nxp/nxpwifi/main.h new file +1507 -0
@@ -0,0 +1,1507 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: major data structures and prototypes +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_MAIN_H_ +#define _NXPWIFI_MAIN_H_ + +#include <linux/completion.h> +#include <linux/kernel.h> +#include <linux/kstrtox.h> +#include <linux/module.h> +#include <linux/sched.h> +#include <linux/semaphore.h> +#include <linux/ip.h> +#include <linux/skbuff.h> +#include <linux/if_arp.h> +#include <linux/etherdevice.h> +#include <net/sock.h> +#include <net/lib80211.h> +#include <linux/vmalloc.h> +#include <linux/firmware.h> +#include <linux/ctype.h> +#include <linux/of.h> +#include <linux/idr.h> +#include <linux/inetdevice.h> +#include <linux/devcoredump.h> +#include <linux/err.h> +#include <linux/gfp.h> +#include <linux/interrupt.h> +#include <linux/io.h> +#include <linux/of_platform.h> +#include <linux/platform_device.h> +#include <linux/pm_runtime.h> +#include <linux/slab.h> +#include <linux/of_irq.h> +#include <linux/workqueue.h> + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "sdio.h" + +extern char driver_version[]; + +struct nxpwifi_adapter ; +struct nxpwifi_private ; + +enum { +NXPWIFI_ASYNC_CMD , +NXPWIFI_SYNC_CMD +}; + +#define NXPWIFI_MAX_AP 64 + +#define NXPWIFI_MAX_PKTS_TXQ 16 + +#define NXPWIFI_DEFAULT_WATCHDOG_TIMEOUT (5 * HZ) + +#define NXPWIFI_TIMER_10S 10000 +#define NXPWIFI_TIMER_1S 1000 + +#define MAX_TX_PENDING 400 +#define LOW_TX_PENDING 380 + +#define HIGH_RX_PENDING 50 +#define LOW_RX_PENDING 20 + +#define NXPWIFI_UPLD_SIZE (2312) + +#define MAX_EVENT_SIZE 2048 + +#define NXPWIFI_FW_DUMP_SIZE (2 * 1024 * 1024) + +#define ARP_FILTER_MAX_BUF_SIZE 68 + +#define NXPWIFI_KEY_BUFFER_SIZE 16 +#define NXPWIFI_DEFAULT_LISTEN_INTERVAL 10 +#define NXPWIFI_MAX_REGION_CODE 9 + +#define DEFAULT_BCN_AVG_FACTOR 8 +#define DEFAULT_DATA_AVG_FACTOR 8 + +#define FIRST_VALID_CHANNEL 0xff + +#define DEFAULT_BCN_MISS_TIMEOUT 5 + +#define MAX_SCAN_BEACON_BUFFER 8000 + +#define SCAN_BEACON_ENTRY_PAD 6 + +#define NXPWIFI_PASSIVE_SCAN_CHAN_TIME 110 +#define NXPWIFI_ACTIVE_SCAN_CHAN_TIME 40 +#define NXPWIFI_SPECIFIC_SCAN_CHAN_TIME 40 +#define NXPWIFI_DEF_SCAN_CHAN_GAP_TIME 50 + +#define SCAN_RSSI (RSSI ) (0x100 - ((u8)(RSSI))) + +#define NXPWIFI_MAX_TOTAL_SCAN_TIME (NXPWIFI_TIMER_10S - NXPWIFI_TIMER_1S) + +#define WPA_GTK_OUI_OFFSET 2 +#define RSN_GTK_OUI_OFFSET 2 + +#define NXPWIFI_OUI_NOT_PRESENT 0 +#define NXPWIFI_OUI_PRESENT 1 + +#define PKT_TYPE_MGMT 0xE5 + +/* Do not check for data_received for USB, as data_received +* is handled in nxpwifi_usb_recv for USB +*/ +#define IS_CARD_RX_RCVD (adapter) ({ \ + typeof(adapter) (_adapter) = adapter; \ + ((_adapter)->cmd_resp_received || \ + (_adapter)->event_received || \ + (_adapter)->data_received); \ + }) + +#define NXPWIFI_TYPE_CMD 1 +#define NXPWIFI_TYPE_DATA 0 +#define NXPWIFI_TYPE_AGGR_DATA 10 +#define NXPWIFI_TYPE_EVENT 3 + +#define MAX_BITMAP_RATES_SIZE 18 + +#define MAX_CHANNEL_BAND_BG 14 +#define MAX_CHANNEL_BAND_A 165 + +#define MAX_FREQUENCY_BAND_BG 2484 + +#define NXPWIFI_EVENT_HEADER_LEN 4 +#define NXPWIFI_UAP_EVENT_EXTRA_HEADER 2 + +#define NXPWIFI_TYPE_LEN 4 +#define NXPWIFI_USB_TYPE_CMD 0xF00DFACE +#define NXPWIFI_USB_TYPE_DATA 0xBEADC0DE +#define NXPWIFI_USB_TYPE_EVENT 0xBEEFFACE + +/* Threshold for tx_timeout_cnt before we trigger a card reset */ +#define TX_TIMEOUT_THRESHOLD 6 + +#define NXPWIFI_DRV_INFO_SIZE_MAX 0x40000 + +/* Address alignment */ +#define NXPWIFI_ALIGN_ADDR (p, a) ({ \ + typeof(a) (_a) = a; \ + (((long)(p) + (_a) - 1) & ~((_a) - 1)); \ + }) + +#define NXPWIFI_MAC_LOCAL_ADMIN_BIT 41 + +/** +*enum nxpwifi_debug_level - nxp wifi debug level +*/ +enum NXPWIFI_DEBUG_LEVEL { +NXPWIFI_DBG_MSG =0x00000001 , +NXPWIFI_DBG_FATAL =0x00000002 , +NXPWIFI_DBG_ERROR =0x00000004 , +NXPWIFI_DBG_DATA =0x00000008 , +NXPWIFI_DBG_CMD =0x00000010 , +NXPWIFI_DBG_EVENT =0x00000020 , +NXPWIFI_DBG_INTR =0x00000040 , +NXPWIFI_DBG_IOCTL =0x00000080 , + +NXPWIFI_DBG_MPA_D =0x00008000 , +NXPWIFI_DBG_DAT_D =0x00010000 , +NXPWIFI_DBG_CMD_D =0x00020000 , +NXPWIFI_DBG_EVT_D =0x00040000 , +NXPWIFI_DBG_FW_D =0x00080000 , +NXPWIFI_DBG_IF_D =0x00100000 , + +NXPWIFI_DBG_ENTRY =0x10000000 , +NXPWIFI_DBG_WARN =0x20000000 , +NXPWIFI_DBG_INFO =0x40000000 , +NXPWIFI_DBG_DUMP =0x80000000 , + +NXPWIFI_DBG_ANY =0xffffffff +}; + +#define NXPWIFI_DEFAULT_DEBUG_MASK (NXPWIFI_DBG_MSG | \ + NXPWIFI_DBG_FATAL | \ + NXPWIFI_DBG_ERROR) + +__printf(3, 4) +void _nxpwifi_dbg (const struct nxpwifi_adapter *adapter,int mask, +const char *fmt, ...); +#define nxpwifi_dbg (adapter, mask, fmt, ...) \ + _nxpwifi_dbg(adapter, NXPWIFI_DBG_##mask, fmt, ##__VA_ARGS__) + +#define DEBUG_DUMP_DATA_MAX_LEN 128 +#define nxpwifi_dbg_dump (adapter, dbg_mask, str, buf, len) \ +do { \ + if ((adapter)->debug_mask & NXPWIFI_DBG_##dbg_mask) \ + print_hex_dump(KERN_DEBUG, str, \ + DUMP_PREFIX_OFFSET, 16, 1, \ + buf, len, false); \ +} while (0) + +/** Min BGSCAN interval 15 second */ +#define NXPWIFI_BGSCAN_INTERVAL 15000 +/** default repeat count */ +#define NXPWIFI_BGSCAN_REPEAT_COUNT 6 + +struct nxpwifi_dbg { +u32 num_cmd_host_to_card_failure; +u32 num_cmd_sleep_cfm_host_to_card_failure; +u32 num_tx_host_to_card_failure; +u32 num_event_deauth; +u32 num_event_disassoc; +u32 num_event_link_lost; +u32 num_cmd_deauth; +u32 num_cmd_assoc_success; +u32 num_cmd_assoc_failure; +u32 num_tx_timeout; +u16 timeout_cmd_id; +u16 timeout_cmd_act; +u16 last_cmd_id[DBG_CMD_NUM ]; +u16 last_cmd_act[DBG_CMD_NUM ]; +u16 last_cmd_index; +u16 last_cmd_resp_id[DBG_CMD_NUM ]; +u16 last_cmd_resp_index; +u16 last_event[DBG_CMD_NUM ]; +u16 last_event_index; +u32 last_mp_wr_bitmap[NXPWIFI_DBG_SDIO_MP_NUM ]; +u32 last_mp_wr_ports[NXPWIFI_DBG_SDIO_MP_NUM ]; +u32 last_mp_wr_len[NXPWIFI_DBG_SDIO_MP_NUM ]; +u32 last_mp_curr_wr_port[NXPWIFI_DBG_SDIO_MP_NUM ]; +u8 last_sdio_mp_index; +}; + +enum NXPWIFI_HARDWARE_STATUS { +NXPWIFI_HW_STATUS_READY , +NXPWIFI_HW_STATUS_INITIALIZING , +NXPWIFI_HW_STATUS_INIT_DONE , +NXPWIFI_HW_STATUS_RESET , +NXPWIFI_HW_STATUS_NOT_READY +}; + +enum NXPWIFI_802_11_POWER_MODE { +NXPWIFI_802_11_POWER_MODE_CAM , +NXPWIFI_802_11_POWER_MODE_PSP +}; + +struct nxpwifi_tx_param { +u32 next_pkt_len; +}; + +enum NXPWIFI_PS_STATE { +PS_STATE_AWAKE , +PS_STATE_PRE_SLEEP , +PS_STATE_SLEEP_CFM , +PS_STATE_SLEEP +}; + +enum nxpwifi_iface_type { +NXPWIFI_SDIO +}; + +struct nxpwifi_add_ba_param { +u32 tx_win_size; +u32 rx_win_size; +u32 timeout; +u8 tx_amsdu; +u8 rx_amsdu; +}; + +struct nxpwifi_tx_aggr { +u8 ampdu_user; +u8 ampdu_ap; +u8 amsdu; +}; + +enum nxpwifi_ba_status { +BA_SETUP_NONE =0 , +BA_SETUP_INPROGRESS , +BA_SETUP_COMPLETE +}; + +struct nxpwifi_ra_list_tbl { +struct list_head list; +struct sk_buff_head skb_head; +u8 ra[ETH_ALEN ]; +u32 is_11n_enabled; +u16 max_amsdu; +u16 ba_pkt_count; +u8 ba_packet_thr; +enum nxpwifi_ba_status ba_status; +u8 amsdu_in_ampdu; +u16 total_pkt_count; +bool tx_paused; +}; + +struct nxpwifi_tid_tbl { +struct list_head ra_list; +}; + +#define WMM_HIGHEST_PRIORITY 7 +#define HIGH_PRIO_TID 7 +#define LOW_PRIO_TID 0 +#define NO_PKT_PRIO_TID -1 +#define NXPWIFI_WMM_DRV_DELAY_MAX 510 + +struct nxpwifi_wmm_desc { +struct nxpwifi_tid_tbl tid_tbl_ptr[MAX_NUM_TID ]; +u32 packets_out[MAX_NUM_TID ]; +u32 pkts_paused[MAX_NUM_TID ]; +/* spin lock to protect ra_list */ +spinlock_t ra_list_spinlock; +struct nxpwifi_wmm_ac_status ac_status[IEEE80211_NUM_ACS ]; +enum nxpwifi_wmm_ac_e ac_down_graded_vals[IEEE80211_NUM_ACS ]; +u32 drv_pkt_delay_max; +u8 queue_priority[IEEE80211_NUM_ACS ]; +u32 user_pri_pkt_tx_ctrl[WMM_HIGHEST_PRIORITY +1 ];/* UP: 0 to 7 */ +/* Number of transmit packets queued */ +atomic_t tx_pkts_queued; +/* Tracks highest priority with a packet queued */ +atomic_t highest_queued_prio; +}; + +struct nxpwifi_802_11_security { +u8 wpa_enabled; +u8 wpa2_enabled; +u8 wep_enabled; +u32 authentication_mode; +u8 is_authtype_auto; +u32 encryption_mode; +}; + +struct ieee_types_header { +u8 element_id; +u8 len; +} __packed; + +struct ieee_types_vendor_specific { +struct ieee_types_vendor_header vend_hdr; +u8 data[IEEE_MAX_IE_SIZE -sizeof (struct ieee_types_vendor_header )]; +} __packed; + +struct ieee_types_generic { +struct ieee_types_header ieee_hdr; +u8 data[IEEE_MAX_IE_SIZE -sizeof (struct ieee_types_header )]; +} __packed; + +struct ieee_types_bss_co_2040 { +struct ieee_types_header ieee_hdr; +u8 bss_2040co; +} __packed; + +struct ieee_types_extcap { +struct ieee_types_header ieee_hdr; +u8 ext_capab[8 ]; +} __packed; + +struct ieee_types_vht_cap { +struct ieee_types_header ieee_hdr; +struct ieee80211_vht_cap vhtcap; +} __packed; + +struct ieee_types_vht_oper { +struct ieee_types_header ieee_hdr; +struct ieee80211_vht_operation vhtoper; +} __packed; + +struct ieee_types_aid { +struct ieee_types_header ieee_hdr; +u16 aid; +} __packed; + +struct nxpwifi_bssdescriptor { +u8 mac_address[ETH_ALEN ]; +struct cfg80211_ssid ssid; +u32 privacy; +s32 rssi; +u32 channel; +u32 freq; +u16 beacon_period; +u8 erp_flags; +u32 bss_mode; +u8 supported_rates[NXPWIFI_SUPPORTED_RATES ]; +u8 data_rates[NXPWIFI_SUPPORTED_RATES ]; +/* Network band. +* BAND_B(0x01): 'b' band +* BAND_G(0x02): 'g' band +* BAND_A(0X04): 'a' band +*/ +u16 bss_band; +u64 fw_tsf; +u64 timestamp; +union ieee_types_phy_param_set phy_param_set; +union ieee_types_ss_param_set ss_param_set; +u16 cap_info_bitmap; +struct ieee_types_wmm_parameter wmm_ie; +u8 disable_11n; +struct ieee80211_ht_cap *bcn_ht_cap; +u16 ht_cap_offset; +struct ieee80211_ht_operation *bcn_ht_oper; +u16 ht_info_offset; +u8 *bcn_bss_co_2040; +u16 bss_co_2040_offset; +u8 *bcn_ext_cap; +u16 ext_cap_offset; +struct ieee80211_vht_cap *bcn_vht_cap; +u16 vht_cap_offset; +struct ieee80211_vht_operation *bcn_vht_oper; +u16 vht_info_offset; +struct ieee_types_oper_mode_ntf *oper_mode; +u16 oper_mode_offset; +u8 disable_11ac; +struct ieee_types_vendor_specific *bcn_wpa_ie; +u16 wpa_offset; +struct ieee_types_generic *bcn_rsn_ie; +u16 rsn_offset; +struct ieee_types_generic *bcn_rsnx_ie; +u16 rsnx_offset; +u8 *beacon_buf; +u32 beacon_buf_size; +u8 sensed_11h; +u8 local_constraint; +u8 chan_sw_ie_present; +}; + +struct nxpwifi_current_bss_params { +struct nxpwifi_bssdescriptor bss_descriptor; +u8 wmm_enabled; +u8 wmm_uapsd_enabled; +u8 band; +u32 num_of_rates; +u8 data_rates[NXPWIFI_SUPPORTED_RATES ]; +}; + +struct nxpwifi_sleep_period { +u16 period; +u16 reserved; +}; + +struct nxpwifi_wep_key { +u32 length; +u32 key_index; +u32 key_length; +u8 key_material[NXPWIFI_KEY_BUFFER_SIZE ]; +}; + +#define MAX_REGION_CHANNEL_NUM 2 + +struct nxpwifi_chan_freq_power { +u16 channel; +u32 freq; +u16 max_tx_power; +u8 unsupported; +}; + +enum state_11d_t { +DISABLE_11D =0 , +ENABLE_11D =1 , +}; + +#define NXPWIFI_MAX_TRIPLET_802_11D 83 + +struct nxpwifi_802_11d_domain_reg { +u8 country_code[IEEE80211_COUNTRY_STRING_LEN ]; +u8 no_of_triplet; +struct ieee80211_country_ie_triplet + triplet[NXPWIFI_MAX_TRIPLET_802_11D ]; +}; + +struct nxpwifi_vendor_spec_cfg_ie { +u16 mask; +u16 flag; +u8 ie[NXPWIFI_MAX_VSIE_LEN ]; +}; + +struct wps { +u8 session_enable; +}; + +struct nxpwifi_roc_cfg { +u64 cookie; +struct ieee80211_channel chan; +}; + +enum nxpwifi_iface_work_flags { +NXPWIFI_IFACE_WORK_DEVICE_DUMP , +NXPWIFI_IFACE_WORK_CARD_RESET , +}; + +enum nxpwifi_adapter_work_flags { +NXPWIFI_SURPRISE_REMOVED , +NXPWIFI_IS_CMD_TIMEDOUT , +NXPWIFI_IS_SUSPENDED , +NXPWIFI_IS_HS_CONFIGURED , +NXPWIFI_IS_HS_ENABLING , +NXPWIFI_IS_REQUESTING_FW_VEREXT , +}; + +struct nxpwifi_band_config { +u8 chan_band:2 ; +u8 chan_width:2 ; +u8 chan2_offset:2 ; +u8 scan_mode:2 ; +} __packed; + +struct nxpwifi_channel_band { +struct nxpwifi_band_config band_config; +u8 channel; +}; + +struct nxpwifi_private { +struct nxpwifi_adapter *adapter; +u8 bss_type; +u8 bss_role; +u8 bss_priority; +u8 bss_num; +u8 bss_started; +u8 auth_flag; +u16 auth_alg; +u8 frame_type; +u8 curr_addr[ETH_ALEN ]; +u8 media_connected; +u8 port_open; +u8 usb_port; +u32 num_tx_timeout; +/* track consecutive timeout */ +u8 tx_timeout_cnt; +struct net_device *netdev; +struct net_device_stats stats; +u32 curr_pkt_filter; +u32 bss_mode; +u32 pkt_tx_ctrl; +u16 tx_power_level; +u8 max_tx_power_level; +u8 min_tx_power_level; +u32 tx_ant; +u32 rx_ant; +u8 tx_rate; +u8 tx_htinfo; +u8 rxpd_htinfo; +u8 rxpd_rate; +u16 rate_bitmap; +u16 bitmap_rates[MAX_BITMAP_RATES_SIZE ]; +u32 data_rate; +u8 is_data_rate_auto; +u16 bcn_avg_factor; +u16 data_avg_factor; +s16 data_rssi_last; +s16 data_nf_last; +s16 data_rssi_avg; +s16 data_nf_avg; +s16 bcn_rssi_last; +s16 bcn_nf_last; +s16 bcn_rssi_avg; +s16 bcn_nf_avg; +struct nxpwifi_bssdescriptor *attempted_bss_desc; +struct cfg80211_ssid prev_ssid; +u8 prev_bssid[ETH_ALEN ]; +struct nxpwifi_current_bss_params curr_bss_params; +u16 beacon_period; +u8 dtim_period; +u16 listen_interval; +u16 atim_window; +struct nxpwifi_802_11_security sec_info; +struct nxpwifi_wep_key wep_key[NUM_WEP_KEYS ]; +u16 wep_key_curr_index; +u8 wpa_ie[256 ]; +u16 wpa_ie_len; +u8 wpa_is_gtk_set; +struct host_cmd_ds_802_11_key_material aes_key; +u8 *wps_ie; +u16 wps_ie_len; +u8 wmm_required; +u8 wmm_enabled; +u8 wmm_qosinfo; +struct nxpwifi_wmm_desc wmm; +atomic_t wmm_tx_pending[IEEE80211_NUM_ACS ]; +struct list_head sta_list; +/* spin lock for associated station list */ +spinlock_t sta_list_spinlock; +struct list_head tx_ba_stream_tbl_ptr; +/* spin lock for tx_ba_stream_tbl_ptr queue */ +spinlock_t tx_ba_stream_tbl_lock; +struct nxpwifi_tx_aggr aggr_prio_tbl[MAX_NUM_TID ]; +struct nxpwifi_add_ba_param add_ba_param; +u16 rx_seq[MAX_NUM_TID ]; +u8 tos_to_tid_inv[MAX_NUM_TID ]; +struct list_head rx_reorder_tbl_ptr; +/* spin lock for rx_reorder_tbl_ptr queue */ +spinlock_t rx_reorder_tbl_lock; +#define NXPWIFI_ASSOC_RSP_BUF_SIZE 500 +u8 assoc_rsp_buf[NXPWIFI_ASSOC_RSP_BUF_SIZE ]; +u32 assoc_rsp_size; +struct cfg80211_bss *req_bss; + +#define NXPWIFI_GENIE_BUF_SIZE 256 +u8 gen_ie_buf[NXPWIFI_GENIE_BUF_SIZE ]; +u8 gen_ie_buf_len; + +struct nxpwifi_vendor_spec_cfg_ie vs_ie[NXPWIFI_MAX_VSIE_NUM ]; + +#define NXPWIFI_ASSOC_TLV_BUF_SIZE 256 +u8 assoc_tlv_buf[NXPWIFI_ASSOC_TLV_BUF_SIZE ]; +u8 assoc_tlv_buf_len; + +u8 *curr_bcn_buf; +u32 curr_bcn_size; +/* spin lock for beacon buffer */ +spinlock_t curr_bcn_buf_lock; +struct wireless_dev wdev; +struct nxpwifi_chan_freq_power cfp; +u32 versionstrsel; +char version_str[NXPWIFI_VERSION_STR_LENGTH ]; +#ifdef CONFIG_DEBUG_FS +struct dentry *dfs_dev_dir; +#endif +u16 current_key_index; +/* mutex for scan */ +struct mutex async_mutex; +struct cfg80211_scan_request *scan_request; +u8 cfg_bssid[6 ]; +struct wps wps; +u8 scan_block; +s32 cqm_rssi_thold; +u32 cqm_rssi_hyst; +u8 subsc_evt_rssi_state; +struct nxpwifi_ds_misc_subsc_evt async_subsc_evt_storage; +struct nxpwifi_ie mgmt_ie[MAX_MGMT_IE_INDEX ]; +u16 beacon_idx; +u16 proberesp_idx; +u16 assocresp_idx; +u16 gen_idx; +u8 ap_11n_enabled; +u8 ap_11ac_enabled; +bool host_mlme_reg; +u32 mgmt_frame_mask; +struct nxpwifi_roc_cfg roc_cfg; +bool scan_aborting; +u8 sched_scanning; +u8 csa_chan; +unsigned long csa_expire_time; +u8 del_list_idx; +bool hs2_enabled; +struct nxpwifi_uap_bss_param bss_cfg; +struct cfg80211_chan_def bss_chandef; +struct station_parameters *sta_params; +struct idr ack_status_frames; +/* spin lock for ack status */ +spinlock_t ack_status_lock; +/** rx histogram data */ +struct nxpwifi_histogram_data *hist_data; +struct cfg80211_chan_def dfs_chandef; +struct workqueue_struct *dfs_cac_workqueue; +struct delayed_work dfs_cac_work; +struct workqueue_struct *dfs_chan_sw_workqueue; +struct delayed_work dfs_chan_sw_work; +bool uap_stop_tx; +struct cfg80211_beacon_data beacon_after; +struct nxpwifi_11h_intf_state state_11h; +struct nxpwifi_ds_mem_rw mem_rw; +struct sk_buff_head bypass_txq; +struct nxpwifi_user_scan_chan hidden_chan[NXPWIFI_USER_SCAN_CHAN_MAX ]; +u8 assoc_resp_ht_param; +bool ht_param_present; +}; + +struct nxpwifi_tx_ba_stream_tbl { +struct list_head list; +int tid; +u8 ra[ETH_ALEN ]; +enum nxpwifi_ba_status ba_status; +u8 amsdu; +}; + +struct nxpwifi_rx_reorder_tbl ; + +struct reorder_tmr_cnxt { +struct timer_list timer; +struct nxpwifi_rx_reorder_tbl *ptr; +struct nxpwifi_private *priv; +u8 timer_is_set; +}; + +struct nxpwifi_rx_reorder_tbl { +struct list_head list; +int tid; +u8 ta[ETH_ALEN ]; +int init_win; +int start_win; +int win_size; +void **rx_reorder_ptr; +struct reorder_tmr_cnxt timer_context; +u8 amsdu; +u8 flags; +}; + +struct nxpwifi_bss_prio_node { +struct list_head list; +struct nxpwifi_private *priv; +}; + +struct nxpwifi_bss_prio_tbl { +struct list_head bss_prio_head; +/* spin lock for bss priority */ +spinlock_t bss_prio_lock; +struct nxpwifi_bss_prio_node *bss_prio_cur; +}; + +struct cmd_ctrl_node { +struct list_head list; +struct nxpwifi_private *priv; +u32 cmd_no; +u32 cmd_flag; +struct sk_buff *cmd_skb; +struct sk_buff *resp_skb; +void *data_buf; +u32 wait_q_enabled; +struct sk_buff *skb; +u8 *condition; +u8 cmd_wait_q_woken; +int (*cmd_resp)(struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf); +}; + +struct nxpwifi_bss_priv { +u8 band; +u64 fw_tsf; +}; + +struct nxpwifi_station_stats { +u64 last_rx; +s8 rssi; +u64 rx_bytes; +u64 tx_bytes; +u32 rx_packets; +u32 tx_packets; +u32 tx_failed; +u8 last_tx_rate; +u8 last_tx_htinfo; +}; + +/* This is AP specific structure which stores information +* about associated/peer STA +*/ +struct nxpwifi_sta_node { +struct list_head list; +u8 mac_addr[ETH_ALEN ]; +u8 is_wmm_enabled; +u8 is_11n_enabled; +u8 is_11ac_enabled; +u8 ampdu_sta[MAX_NUM_TID ]; +u16 rx_seq[MAX_NUM_TID ]; +u16 max_amsdu; +struct nxpwifi_station_stats stats; +u8 tx_pause; +}; + +#define NXPWIFI_TYPE_AGGR_DATA_V2 11 +#define NXPWIFI_BUS_AGGR_MODE_LEN_V2 (2) +#define NXPWIFI_BUS_AGGR_MAX_LEN 16000 +#define NXPWIFI_BUS_AGGR_MAX_NUM 10 +struct bus_aggr_params { +u16 enable; +u16 mode; +u16 tx_aggr_max_size; +u16 tx_aggr_max_num; +u16 tx_aggr_align; +}; + +struct nxpwifi_if_ops { +int (*init_if)(struct nxpwifi_adapter *adapter); +void (*cleanup_if)(struct nxpwifi_adapter *adapter); +int (*check_fw_status)(struct nxpwifi_adapter *adapter,u32 poll_num); +int (*check_winner_status)(struct nxpwifi_adapter *adapter); +int (*prog_fw)(struct nxpwifi_adapter *adapter, +struct nxpwifi_fw_image *fw); +int (*register_dev)(struct nxpwifi_adapter *adapter); +void (*unregister_dev)(struct nxpwifi_adapter *adapter); +int (*enable_int)(struct nxpwifi_adapter *adapter); +void (*disable_int)(struct nxpwifi_adapter *adapter); +int (*process_int_status)(struct nxpwifi_adapter *adapter); +int (*host_to_card)(struct nxpwifi_adapter *adapter,u8 type, +struct sk_buff *skb, +struct nxpwifi_tx_param *tx_param); +int (*wakeup)(struct nxpwifi_adapter *adapter); +int (*wakeup_complete)(struct nxpwifi_adapter *adapter); + +/* Interface specific functions */ +void (*update_mp_end_port)(struct nxpwifi_adapter *adapter,u16 port); +void (*cleanup_mpa_buf)(struct nxpwifi_adapter *adapter); +int (*cmdrsp_complete)(struct nxpwifi_adapter *adapter, +struct sk_buff *skb); +int (*event_complete)(struct nxpwifi_adapter *adapter, +struct sk_buff *skb); +int (*dnld_fw)(struct nxpwifi_adapter *adapter, +struct nxpwifi_fw_image *fw); +void (*card_reset)(struct nxpwifi_adapter *adapter); +int (*reg_dump)(struct nxpwifi_adapter *adapter,char *drv_buf); +void (*device_dump)(struct nxpwifi_adapter *adapter); +void (*iface_work)(struct work_struct *work); +void (*deaggr_pkt)(struct nxpwifi_adapter *adapter, +struct sk_buff *skb); +bool (*is_port_ready)(struct nxpwifi_private *adapter); +void (*up_dev)(struct nxpwifi_adapter *adapter); +}; + +struct nxpwifi_adapter { +u8 iface_type; +unsigned int debug_mask; +struct nxpwifi_iface_comb iface_limit; +struct nxpwifi_iface_comb curr_iface_comb; +struct nxpwifi_private *priv[NXPWIFI_MAX_BSS_NUM ]; +u8 priv_num; +const struct firmware *firmware; +char fw_name[32 ]; +int winner; +struct device *dev; +struct wiphy *wiphy; +u8 perm_addr[ETH_ALEN ]; +unsigned long work_flags; +u32 fw_release_number; +u8 intf_hdr_len; +u16 init_wait_q_woken; +wait_queue_head_t init_wait_q; +void *card; +struct nxpwifi_if_ops if_ops; +atomic_t bypass_tx_pending; +atomic_t rx_pending; +atomic_t tx_pending; +atomic_t cmd_pending; +atomic_t tx_hw_pending; +struct workqueue_struct *workqueue; +struct work_struct main_work; +struct workqueue_struct *rx_workqueue; +struct work_struct rx_work; +struct workqueue_struct *host_mlme_workqueue; +struct work_struct host_mlme_work; +bool rx_work_enabled; +bool rx_processing; +bool delay_main_work; +bool rx_locked; +bool main_locked; +struct nxpwifi_bss_prio_tbl bss_prio_tbl[NXPWIFI_MAX_BSS_NUM ]; +/* spin lock for main process */ +spinlock_t main_proc_lock; +u32 nxpwifi_processing; +u8 more_task_flag; +u16 tx_buf_size; +u16 curr_tx_buf_size; +/* sdio single port rx aggregation capability */ +bool host_disable_sdio_rx_aggr; +bool sdio_rx_aggr_enable; +u16 sdio_rx_block_size; +u32 ioport; +enum NXPWIFI_HARDWARE_STATUS hw_status; +u16 number_of_antenna; +u32 fw_cap_info; +/* spin lock for interrupt handling */ +spinlock_t int_lock; +u8 int_status; +u32 event_cause; +struct sk_buff *event_skb; +u8 upld_buf[NXPWIFI_UPLD_SIZE ]; +u8 data_sent; +u8 cmd_sent; +u8 cmd_resp_received; +u8 event_received; +u8 data_received; +u8 assoc_resp_received; +struct nxpwifi_private *priv_link_lost; +u8 host_mlme_link_lost; +u16 seq_num; +struct cmd_ctrl_node *cmd_pool; +struct cmd_ctrl_node *curr_cmd; +/* spin lock for command */ +spinlock_t nxpwifi_cmd_lock; +u16 last_init_cmd; +struct timer_list cmd_timer; +struct list_head cmd_free_q; +/* spin lock for cmd_free_q */ +spinlock_t cmd_free_q_lock; +struct list_head cmd_pending_q; +/* spin lock for cmd_pending_q */ +spinlock_t cmd_pending_q_lock; +struct list_head scan_pending_q; +/* spin lock for scan_pending_q */ +spinlock_t scan_pending_q_lock; +/* spin lock for RX processing routine */ +spinlock_t rx_proc_lock; +struct sk_buff_head tx_data_q; +atomic_t tx_queued; +u32 scan_processing; +u16 region_code; +struct nxpwifi_802_11d_domain_reg domain_reg; +u16 scan_probes; +u32 scan_mode; +u16 specific_scan_time; +u16 active_scan_time; +u16 passive_scan_time; +u16 scan_chan_gap_time; +u8 fw_bands; +u8 config_bands; +u8 tx_lock_flag; +struct nxpwifi_sleep_period sleep_period; +u16 ps_mode; +u32 ps_state; +u8 need_to_wakeup; +u16 multiple_dtim; +u16 local_listen_interval; +u16 null_pkt_interval; +struct sk_buff *sleep_cfm; +u16 bcn_miss_time_out; +u8 is_deep_sleep; +u8 delay_null_pkt; +u16 delay_to_ps; +u16 enhanced_ps_mode; +u8 pm_wakeup_card_req; +u16 gen_null_pkt; +u16 pps_uapsd_mode; +u32 pm_wakeup_fw_try; +struct timer_list wakeup_timer; +struct nxpwifi_hs_config_param hs_cfg; +u8 hs_activated; +u8 hs_activated_manually; +u16 hs_activate_wait_q_woken; +wait_queue_head_t hs_activate_wait_q; +u8 event_body[MAX_EVENT_SIZE ]; +u32 hw_dot_11n_dev_cap; +u8 hw_dev_mcs_support; +u8 user_dev_mcs_support; +u8 sec_chan_offset; +struct nxpwifi_dbg dbg; +u8 arp_filter[ARP_FILTER_MAX_BUF_SIZE ]; +u32 arp_filter_size; +struct nxpwifi_wait_queue cmd_wait_q; +u8 scan_wait_q_woken; +spinlock_t queue_lock;/* lock for tx queues */ +u8 country_code[IEEE80211_COUNTRY_STRING_LEN ]; +u16 max_mgmt_ie_index; +const struct firmware *cal_data; +struct device_node *dt_node; + +/* 11AC */ +u32 is_hw_11ac_capable; +u32 hw_dot_11ac_dev_cap; +u32 hw_dot_11ac_mcs_support; +u32 usr_dot_11ac_dev_cap_bg; +u32 usr_dot_11ac_dev_cap_a; +u32 usr_dot_11ac_mcs_support; + +atomic_t pending_bridged_pkts; + +/* For synchronizing FW initialization with device lifecycle. */ +struct completion *fw_done; +bool is_up; + +bool ext_scan; +u8 fw_api_ver; +u8 key_api_major_ver, key_api_minor_ver; +u8 max_sta_conn; +struct memory_type_mapping *mem_type_mapping_tbl; +u8 num_mem_types; +bool scan_chan_gap_enabled; +struct sk_buff_head rx_data_q; +struct nxpwifi_chan_stats *chan_stats; +u32 num_in_chan_stats; +int survey_idx; +u8 coex_scan; +u8 coex_min_scan_time; +u8 coex_max_scan_time; +u8 coex_win_size; +u8 coex_tx_win_size; +u8 coex_rx_win_size; +u8 active_scan_triggered; +bool usb_mc_status; +bool usb_mc_setup; +struct cfg80211_wowlan_nd_info *nd_info; +struct ieee80211_regdomain *regd; + +/* Wake-on-WLAN (WoWLAN) */ +int irq_wakeup; +bool wake_by_wifi; +/* Aggregation parameters*/ +struct bus_aggr_params bus_aggr; +/* Device dump data/length */ +void *devdump_data; +int devdump_len; +struct delayed_work devdump_work; + +bool ignore_btcoex_events; +}; + +void nxpwifi_process_tx_queue (struct nxpwifi_adapter *adapter); + +int nxpwifi_init_lock_list (struct nxpwifi_adapter *adapter); + +void nxpwifi_set_trans_start (struct net_device *dev); + +void nxpwifi_stop_net_dev_queue (struct net_device *netdev, +struct nxpwifi_adapter *adapter); + +void nxpwifi_wake_up_net_dev_queue (struct net_device *netdev, +struct nxpwifi_adapter *adapter); + +int nxpwifi_init_priv (struct nxpwifi_private *priv); +void nxpwifi_free_priv (struct nxpwifi_private *priv); + +int nxpwifi_init_fw (struct nxpwifi_adapter *adapter); + +int nxpwifi_init_fw_complete (struct nxpwifi_adapter *adapter); + +void nxpwifi_shutdown_drv (struct nxpwifi_adapter *adapter); + +int nxpwifi_dnld_fw (struct nxpwifi_adapter *adapter, +struct nxpwifi_fw_image *fw); + +int nxpwifi_recv_packet (struct nxpwifi_private *priv,struct sk_buff *skb); +int nxpwifi_uap_recv_packet (struct nxpwifi_private *priv, +struct sk_buff *skb); + +void nxpwifi_host_mlme_disconnect (struct nxpwifi_private *priv, +u16 reason_code,u8 *sa); + +int nxpwifi_process_mgmt_packet (struct nxpwifi_private *priv, +struct sk_buff *skb); + +int nxpwifi_complete_cmd (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_node); + +void nxpwifi_cmd_timeout_func (struct timer_list *t); + +int nxpwifi_get_debug_info (struct nxpwifi_private *priv, +struct nxpwifi_debug_info *info); + +int nxpwifi_alloc_cmd_buffer (struct nxpwifi_adapter *adapter); +void nxpwifi_free_cmd_buffer (struct nxpwifi_adapter *adapter); +void nxpwifi_free_cmd_buffers (struct nxpwifi_adapter *adapter); +void nxpwifi_cancel_all_pending_cmd (struct nxpwifi_adapter *adapter); +void nxpwifi_cancel_pending_scan_cmd (struct nxpwifi_adapter *adapter); +void nxpwifi_cancel_scan (struct nxpwifi_adapter *adapter); + +void nxpwifi_recycle_cmd_node (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_node); + +void nxpwifi_insert_cmd_to_pending_q (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_node); + +int nxpwifi_exec_next_cmd (struct nxpwifi_adapter *adapter); +int nxpwifi_process_cmdresp (struct nxpwifi_adapter *adapter); +void nxpwifi_process_assoc_resp (struct nxpwifi_adapter *adapter); +int nxpwifi_handle_rx_packet (struct nxpwifi_adapter *adapter, +struct sk_buff *skb); +int nxpwifi_process_tx (struct nxpwifi_private *priv,struct sk_buff *skb, +struct nxpwifi_tx_param *tx_param); +int nxpwifi_send_null_packet (struct nxpwifi_private *priv,u8 flags); +int nxpwifi_write_data_complete (struct nxpwifi_adapter *adapter, +struct sk_buff *skb,int aggr,int status); +void nxpwifi_clean_txrx (struct nxpwifi_private *priv); +u8 nxpwifi_check_last_packet_indication (struct nxpwifi_private *priv); +void nxpwifi_check_ps_cond (struct nxpwifi_adapter *adapter); +void nxpwifi_process_sleep_confirm_resp (struct nxpwifi_adapter *adapter, +u8 *pbuf,u32 upld_len); +void nxpwifi_process_hs_config (struct nxpwifi_adapter *adapter); +void nxpwifi_hs_activated_event (struct nxpwifi_private *priv, +u8 activated); +int nxpwifi_set_hs_params (struct nxpwifi_private *priv,u16 action, +int cmd_type,struct nxpwifi_ds_hs_cfg *hs_cfg); +int nxpwifi_ret_802_11_hs_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp); +int nxpwifi_process_rx_packet (struct nxpwifi_private *priv, +struct sk_buff *skb); +int nxpwifi_process_sta_rx_packet (struct nxpwifi_private *priv, +struct sk_buff *skb); +int nxpwifi_process_uap_rx_packet (struct nxpwifi_private *priv, +struct sk_buff *skb); +int nxpwifi_handle_uap_rx_forward (struct nxpwifi_private *priv, +struct sk_buff *skb); +void nxpwifi_delete_all_station_list (struct nxpwifi_private *priv); +void nxpwifi_wmm_del_peer_ra_list (struct nxpwifi_private *priv, +const u8 *ra_addr); +void nxpwifi_process_sta_txpd (struct nxpwifi_private *priv, +struct sk_buff *skb); +void nxpwifi_process_uap_txpd (struct nxpwifi_private *priv, +struct sk_buff *skb); +int nxpwifi_cmd_802_11_scan (struct host_cmd_ds_command *cmd, +struct nxpwifi_scan_cmd_config *scan_cfg); +void nxpwifi_queue_scan_cmd (struct nxpwifi_private *priv, +struct cmd_ctrl_node *cmd_node); +int nxpwifi_ret_802_11_scan (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp); +int nxpwifi_associate (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc); +int nxpwifi_cmd_802_11_associate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +struct nxpwifi_bssdescriptor *bss_desc); +int nxpwifi_ret_802_11_associate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp); +u8 nxpwifi_band_to_radio_type (u8 band); +int nxpwifi_deauthenticate (struct nxpwifi_private *priv,u8 *mac); +void nxpwifi_deauthenticate_all (struct nxpwifi_adapter *adapter); +int nxpwifi_cmd_802_11_bg_scan_query (struct host_cmd_ds_command *cmd); +struct nxpwifi_chan_freq_power *nxpwifi_get_cfp (struct nxpwifi_private *priv, +u8 band,u16 channel,u32 freq); +u32 nxpwifi_index_to_data_rate (struct nxpwifi_private *priv, +u8 index,u8 ht_info); +u32 nxpwifi_index_to_acs_data_rate (struct nxpwifi_private *priv, +u8 index,u8 ht_info); +int nxpwifi_cmd_append_vsie_tlv (struct nxpwifi_private *priv,u16 vsie_mask, +u8 **buffer); +u32 nxpwifi_get_active_data_rates (struct nxpwifi_private *priv, +u8 *rates); +u32 nxpwifi_get_supported_rates (struct nxpwifi_private *priv,u8 *rates); +u32 nxpwifi_get_rates_from_cfg80211 (struct nxpwifi_private *priv, +u8 *rates,u8 radio_type); +u8 nxpwifi_is_rate_auto (struct nxpwifi_private *priv); +extern u16 region_code_index[NXPWIFI_MAX_REGION_CODE ]; +void nxpwifi_save_curr_bcn (struct nxpwifi_private *priv); +void nxpwifi_free_curr_bcn (struct nxpwifi_private *priv); +int is_command_pending (struct nxpwifi_adapter *adapter); +void nxpwifi_init_priv_params (struct nxpwifi_private *priv, +struct net_device *dev); +void nxpwifi_set_ba_params (struct nxpwifi_private *priv); +void nxpwifi_update_ampdu_txwinsize (struct nxpwifi_adapter *pmadapter); +void nxpwifi_set_11ac_ba_params (struct nxpwifi_private *priv); +int nxpwifi_cmd_802_11_scan_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +void *data_buf); +int nxpwifi_ret_802_11_scan_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp); +int nxpwifi_handle_event_ext_scan_report (struct nxpwifi_private *priv, +void *buf); +int nxpwifi_cmd_802_11_bg_scan_config (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +void *data_buf); +int nxpwifi_stop_bg_scan (struct nxpwifi_private *priv); + +/* This function checks if the queuing is RA based or not. +*/ +static inline u8 +nxpwifi_queuing_ra_based (struct nxpwifi_private *priv) +{ +/* Currently we assume if we are in Infra, then DA=RA. This might not be +* true in the future +*/ +if (priv->bss_mode ==NL80211_IFTYPE_STATION && + (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA )) +return false; + +return true; +} + +/* This function copies rates. +*/ +static inline u32 +nxpwifi_copy_rates (u8 *dest,u32 pos,u8 *src,int len) +{ +int i; + +for (i =0 ; i < len && src[i]; i++, pos++) { +if (pos >=NXPWIFI_SUPPORTED_RATES ) +break ; + dest[pos] = src[i]; + } + +return pos; +} + +/* This function returns the correct private structure pointer based +* upon the BSS type and BSS number. +*/ +static inline struct nxpwifi_private * +nxpwifi_get_priv_by_id (struct nxpwifi_adapter *adapter, +u8 bss_num,u8 bss_type) +{ +int i; + +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { +if (adapter->priv[i]->bss_num == bss_num && + adapter->priv[i]->bss_type == bss_type) +break ; + } + } +return ((i < adapter->priv_num) ? adapter->priv[i] :NULL ); +} + +/* This function returns the first available private structure pointer +* based upon the BSS role. +*/ +static inline struct nxpwifi_private * +nxpwifi_get_priv (struct nxpwifi_adapter *adapter, +enum nxpwifi_bss_role bss_role) +{ +int i; + +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { +if (bss_role ==NXPWIFI_BSS_ROLE_ANY || +GET_BSS_ROLE (adapter->priv[i]) == bss_role) +break ; + } + } + +return ((i < adapter->priv_num) ? adapter->priv[i] :NULL ); +} + +/* This function checks available bss_num when adding new interface or +* changing interface type. +*/ +static inline u8 +nxpwifi_get_unused_bss_num (struct nxpwifi_adapter *adapter,u8 bss_type) +{ +u8 i, j; +int index[NXPWIFI_MAX_BSS_NUM ]; + +memset (index,0 ,sizeof (index)); +for (i =0 ; i < adapter->priv_num; i++) +if (adapter->priv[i]) { +if (adapter->priv[i]->bss_type == bss_type && + !(adapter->priv[i]->bss_mode == +NL80211_IFTYPE_UNSPECIFIED )) { + index[adapter->priv[i]->bss_num] =1 ; + } + } +for (j =0 ; j <NXPWIFI_MAX_BSS_NUM ; j++) +if (!index[j]) +return j; +return -1 ; +} + +/* This function returns the first available unused private structure pointer. +*/ +static inline struct nxpwifi_private * +nxpwifi_get_unused_priv_by_bss_type (struct nxpwifi_adapter *adapter, +u8 bss_type) +{ +u8 i; + +for (i =0 ; i < adapter->priv_num; i++) +if (adapter->priv[i]->bss_mode == +NL80211_IFTYPE_UNSPECIFIED ) { + adapter->priv[i]->bss_num = +nxpwifi_get_unused_bss_num (adapter, bss_type); +break ; + } + +return ((i < adapter->priv_num) ? adapter->priv[i] :NULL ); +} + +/* This function returns the driver private structure of a network device. +*/ +static inline struct nxpwifi_private * +nxpwifi_netdev_get_priv (struct net_device *dev) +{ +return (struct nxpwifi_private *)(*(unsigned long *)netdev_priv (dev)); +} + +/* This function checks if a skb holds a management frame. +*/ +static inline bool nxpwifi_is_skb_mgmt_frame (struct sk_buff *skb) +{ +return (get_unaligned_le32 (skb->data) ==PKT_TYPE_MGMT ); +} + +/* This function retrieves channel closed for operation by Channel +* Switch Announcement. +*/ +static inline u8 +nxpwifi_11h_get_csa_closed_channel (struct nxpwifi_private *priv) +{ +if (!priv->csa_chan) +return 0 ; + +/* Clear csa channel, if DFS channel move time has passed */ +if (time_after (jiffies, priv->csa_expire_time)) { + priv->csa_chan =0 ; + priv->csa_expire_time =0 ; + } + +return priv->csa_chan; +} + +static inline u8 nxpwifi_is_any_intf_active (struct nxpwifi_private *priv) +{ +struct nxpwifi_private *priv_num; +int i; + +for (i =0 ; i < priv->adapter->priv_num; i++) { + priv_num = priv->adapter->priv[i]; +if (priv_num) { +if ((GET_BSS_ROLE (priv_num) ==NXPWIFI_BSS_ROLE_UAP && + priv_num->bss_started) || + (GET_BSS_ROLE (priv_num) ==NXPWIFI_BSS_ROLE_STA && + priv_num->media_connected)) +return 1 ; + } + } + +return 0 ; +} + +/* Disable platform specific wakeup interrupt */ +static inline void nxpwifi_disable_wake (struct nxpwifi_adapter *adapter) +{ +if (adapter->irq_wakeup >=0 ) { +disable_irq_wake (adapter->irq_wakeup); +disable_irq (adapter->irq_wakeup); +if (adapter->wake_by_wifi) +/* Undo our disable, since interrupt handler already +* did this. +*/ +enable_irq (adapter->irq_wakeup); + } +} + +/* Enable platform specific wakeup interrupt */ +static inline void nxpwifi_enable_wake (struct nxpwifi_adapter *adapter) +{ +/* Enable platform specific wakeup interrupt */ +if (adapter->irq_wakeup >=0 ) { + adapter->wake_by_wifi = false; +enable_irq (adapter->irq_wakeup); +enable_irq_wake (adapter->irq_wakeup); + } +} + +int nxpwifi_init_shutdown_fw (struct nxpwifi_private *priv, +u32 func_init_shutdown); + +int nxpwifi_add_card (void *card,struct completion *fw_done, +struct nxpwifi_if_ops *if_ops,u8 iface_type, +struct device *dev); +int nxpwifi_remove_card (struct nxpwifi_adapter *adapter); + +void nxpwifi_get_version (struct nxpwifi_adapter *adapter,char *version, +int maxlen); +int +nxpwifi_request_set_multicast_list (struct nxpwifi_private *priv, +struct nxpwifi_multicast_list *mcast_list); +int nxpwifi_copy_mcast_addr (struct nxpwifi_multicast_list *mlist, +struct net_device *dev); +int nxpwifi_wait_queue_complete (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_queued); +int nxpwifi_bss_start (struct nxpwifi_private *priv,struct cfg80211_bss *bss, +struct cfg80211_ssid *req_ssid); +int nxpwifi_cancel_hs (struct nxpwifi_private *priv,int cmd_type); +int nxpwifi_enable_hs (struct nxpwifi_adapter *adapter); +int nxpwifi_disable_auto_ds (struct nxpwifi_private *priv); +int nxpwifi_drv_get_data_rate (struct nxpwifi_private *priv,u32 *rate); +int nxpwifi_request_scan (struct nxpwifi_private *priv, +struct cfg80211_ssid *req_ssid); +int nxpwifi_scan_networks (struct nxpwifi_private *priv, +const struct nxpwifi_user_scan_cfg *user_scan_in); +int nxpwifi_set_radio (struct nxpwifi_private *priv,u8 option); + +int nxpwifi_set_encode (struct nxpwifi_private *priv,struct key_params *kp, +const u8 *key,int key_len,u8 key_index, +const u8 *mac_addr,int disable); + +int nxpwifi_set_gen_ie (struct nxpwifi_private *priv,const u8 *ie,int ie_len); + +int nxpwifi_get_ver_ext (struct nxpwifi_private *priv,u32 version_str_sel); + +int nxpwifi_remain_on_chan_cfg (struct nxpwifi_private *priv,u16 action, +struct ieee80211_channel *chan, +unsigned int duration); + +int nxpwifi_get_stats_info (struct nxpwifi_private *priv, +struct nxpwifi_ds_get_stats *log); + +int nxpwifi_reg_write (struct nxpwifi_private *priv,u32 reg_type, +u32 reg_offset,u32 reg_value); + +int nxpwifi_reg_read (struct nxpwifi_private *priv,u32 reg_type, +u32 reg_offset,u32 *value); + +int nxpwifi_eeprom_read (struct nxpwifi_private *priv,u16 offset,u16 bytes, +u8 *value); + +int nxpwifi_set_11n_httx_cfg (struct nxpwifi_private *priv,int data); + +int nxpwifi_get_11n_httx_cfg (struct nxpwifi_private *priv,int *data); + +int nxpwifi_set_tx_rate_cfg (struct nxpwifi_private *priv,int tx_rate_index); + +int nxpwifi_get_tx_rate_cfg (struct nxpwifi_private *priv,int *tx_rate_index); + +int nxpwifi_drv_set_power (struct nxpwifi_private *priv,u32 *ps_mode); + +int nxpwifi_drv_get_driver_version (struct nxpwifi_adapter *adapter, +char *version,int max_len); + +int nxpwifi_set_tx_power (struct nxpwifi_private *priv, +struct nxpwifi_power_cfg *power_cfg); + +int nxpwifi_main_process (struct nxpwifi_adapter *adapter); + +int nxpwifi_queue_tx_pkt (struct nxpwifi_private *priv,struct sk_buff *skb); + +int nxpwifi_get_bss_info (struct nxpwifi_private *priv, +struct nxpwifi_bss_info *info); +int nxpwifi_fill_new_bss_desc (struct nxpwifi_private *priv, +struct cfg80211_bss *bss, +struct nxpwifi_bssdescriptor *bss_desc); +int nxpwifi_update_bss_desc_with_ie (struct nxpwifi_adapter *adapter, +struct nxpwifi_bssdescriptor *bss_entry); +int nxpwifi_check_network_compatibility (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc); + +u8 nxpwifi_chan_type_to_sec_chan_offset (enum nl80211_channel_type chan_type); +u8 nxpwifi_get_chan_type (struct nxpwifi_private *priv); + +struct wireless_dev *nxpwifi_add_virtual_intf (struct wiphy *wiphy, +const char *name, +unsigned char name_assign_type, +enum nl80211_iftype type, +struct vif_params *params); +int nxpwifi_del_virtual_intf (struct wiphy *wiphy,struct wireless_dev *wdev); + +int nxpwifi_add_wowlan_magic_pkt_filter (struct nxpwifi_adapter *adapter); + +int nxpwifi_set_mgmt_ies (struct nxpwifi_private *priv, +struct cfg80211_beacon_data *data); +int nxpwifi_del_mgmt_ies (struct nxpwifi_private *priv); +u8 *nxpwifi_11d_code_2_region (u8 code); +void nxpwifi_init_11h_params (struct nxpwifi_private *priv); +int nxpwifi_is_11h_active (struct nxpwifi_private *priv); +int nxpwifi_11h_activate (struct nxpwifi_private *priv,bool flag); +void nxpwifi_11h_process_join (struct nxpwifi_private *priv,u8 **buffer, +struct nxpwifi_bssdescriptor *bss_desc); +int nxpwifi_11h_handle_event_chanswann (struct nxpwifi_private *priv); +void nxpwifi_dnld_txpwr_table (struct nxpwifi_private *priv); + +extern const struct ethtool_ops nxpwifi_ethtool_ops; + +void nxpwifi_del_all_sta_list (struct nxpwifi_private *priv); +void nxpwifi_del_sta_entry (struct nxpwifi_private *priv,const u8 *mac); +void +nxpwifi_set_sta_ht_cap (struct nxpwifi_private *priv,const u8 *ies, +int ies_len,struct nxpwifi_sta_node *node); +struct nxpwifi_sta_node * +nxpwifi_add_sta_entry (struct nxpwifi_private *priv,const u8 *mac); +struct nxpwifi_sta_node * +nxpwifi_get_sta_entry (struct nxpwifi_private *priv,const u8 *mac); +bool nxpwifi_is_bss_in_11ac_mode (struct nxpwifi_private *priv); +u8 nxpwifi_get_center_freq_index (struct nxpwifi_private *priv,u8 band, +u32 pri_chan,u8 chan_bw); +int nxpwifi_init_channel_scan_gap (struct nxpwifi_adapter *adapter); + +int nxpwifi_cmd_issue_chan_report_request (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +void *data_buf); +int nxpwifi_11h_handle_chanrpt_ready (struct nxpwifi_private *priv, +struct sk_buff *skb); + +void nxpwifi_parse_tx_status_event (struct nxpwifi_private *priv, +void *event_body); + +struct sk_buff * +nxpwifi_clone_skb_for_tx_status (struct nxpwifi_private *priv, +struct sk_buff *skb,u8 flag,u64 *cookie); +void nxpwifi_dfs_cac_work_queue (struct work_struct *work); +void nxpwifi_dfs_chan_sw_work_queue (struct work_struct *work); +void nxpwifi_abort_cac (struct nxpwifi_private *priv); +int nxpwifi_stop_radar_detection (struct nxpwifi_private *priv, +struct cfg80211_chan_def *chandef); +int nxpwifi_11h_handle_radar_detected (struct nxpwifi_private *priv, +struct sk_buff *skb); + +void nxpwifi_hist_data_set (struct nxpwifi_private *priv,u8 rx_rate,s8 snr, +s8 nflr); +void nxpwifi_hist_data_reset (struct nxpwifi_private *priv); +void nxpwifi_hist_data_add (struct nxpwifi_private *priv, +u8 rx_rate,s8 snr,s8 nflr); +u8 nxpwifi_adjust_data_rate (struct nxpwifi_private *priv, +u8 rx_rate,u8 ht_info); + +void nxpwifi_drv_info_dump (struct nxpwifi_adapter *adapter); +void nxpwifi_prepare_fw_dump_info (struct nxpwifi_adapter *adapter); +void nxpwifi_upload_device_dump (struct nxpwifi_adapter *adapter); +void *nxpwifi_alloc_dma_align_buf (int rx_len,gfp_t flags); +void nxpwifi_fw_dump_event (struct nxpwifi_private *priv); +void nxpwifi_queue_main_work (struct nxpwifi_adapter *adapter); +int nxpwifi_get_wakeup_reason (struct nxpwifi_private *priv,u16 action, +int cmd_type, +struct nxpwifi_ds_wakeup_reason *wakeup_reason); +int nxpwifi_get_chan_info (struct nxpwifi_private *priv, +struct nxpwifi_channel_band *channel_band); +void nxpwifi_coex_ampdu_rxwinsize (struct nxpwifi_adapter *adapter); +void nxpwifi_11n_delba (struct nxpwifi_private *priv,int tid); +int nxpwifi_send_domain_info_cmd_fw (struct wiphy *wiphy); +int nxpwifi_set_mac_address (struct nxpwifi_private *priv, +struct net_device *dev, +bool external,u8 *new_mac); +void nxpwifi_devdump_tmo_func (unsigned long function_context); + +#ifdef CONFIG_DEBUG_FS +void nxpwifi_debugfs_init (void ); +void nxpwifi_debugfs_remove (void ); + +void nxpwifi_dev_debugfs_init (struct nxpwifi_private *priv); +void nxpwifi_dev_debugfs_remove (struct nxpwifi_private *priv); +#endif +int nxpwifi_reinit_sw (struct nxpwifi_adapter *adapter); +int nxpwifi_shutdown_sw (struct nxpwifi_adapter *adapter); +#endif /* !_NXPWIFI_MAIN_H_ */
Signature · 1 line
2.34.1
PATCH 25/43 wifi: nxpwifi: add scan.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/scan.c | 2894 +++++++++++++++++++++++ 1 file changed, 2894 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/scan.c
drivers/net/wireless/nxp/nxpwifi/scan.c new file +2894 -0
@@ -0,0 +1,2894 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: scan ioctl and command handling +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "11n.h" +#include "cfg80211.h" + +/* The maximum number of channels the firmware can scan per command */ +#define NXPWIFI_MAX_CHANNELS_PER_SPECIFIC_SCAN 14 + +#define NXPWIFI_DEF_CHANNELS_PER_SCAN_CMD 4 + +/* Memory needed to store a max sized Channel List TLV for a firmware scan */ +#define CHAN_TLV_MAX_SIZE (sizeof(struct nxpwifi_ie_types_header) \ + + (NXPWIFI_MAX_CHANNELS_PER_SPECIFIC_SCAN \ + * sizeof(struct nxpwifi_chan_scan_param_set))) + +/* Memory needed to store supported rate */ +#define RATE_TLV_MAX_SIZE (sizeof(struct nxpwifi_ie_types_rates_param_set) \ + + HOSTCMD_SUPPORTED_RATES) + +/* Memory needed to store a max number/size WildCard SSID TLV for a firmware +* scan +*/ +#define WILDCARD_SSID_TLV_MAX_SIZE \ + (NXPWIFI_MAX_SSID_LIST_LENGTH * \ + (sizeof(struct nxpwifi_ie_types_wildcard_ssid_params) \ + + IEEE80211_MAX_SSID_LEN)) + +/* Maximum memory needed for a nxpwifi_scan_cmd_config with all TLVs at max */ +#define MAX_SCAN_CFG_ALLOC (sizeof(struct nxpwifi_scan_cmd_config) \ + + sizeof(struct nxpwifi_ie_types_num_probes) \ + + sizeof(struct nxpwifi_ie_types_htcap) \ + + CHAN_TLV_MAX_SIZE \ + + RATE_TLV_MAX_SIZE \ + + WILDCARD_SSID_TLV_MAX_SIZE) + +union nxpwifi_scan_cmd_config_tlv { +/* Scan configuration (variable length) */ +struct nxpwifi_scan_cmd_config config; +/* Max allocated block */ +u8 config_alloc_buf[MAX_SCAN_CFG_ALLOC ]; +}; + +enum cipher_suite { +CIPHER_SUITE_TKIP , +CIPHER_SUITE_CCMP , +CIPHER_SUITE_MAX +}; + +static u8 nxpwifi_wpa_oui[CIPHER_SUITE_MAX ][4 ] = { + {0x00 ,0x50 ,0xf2 ,0x02 },/* TKIP */ + {0x00 ,0x50 ,0xf2 ,0x04 },/* AES */ +}; + +static u8 nxpwifi_rsn_oui[CIPHER_SUITE_MAX ][4 ] = { + {0x00 ,0x0f ,0xac ,0x02 },/* TKIP */ + {0x00 ,0x0f ,0xac ,0x04 },/* AES */ +}; + +static void +_dbg_security_flags (int log_level,const char *func,const char *desc, +struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +_nxpwifi_dbg (priv->adapter, log_level, +"info: %s: %s:\twpa_ie=%#x wpa2_ie=%#x WEP=%s WPA=%s WPA2=%s\tEncMode=%#x privacy=%#x\n" , + func, desc, + bss_desc->bcn_wpa_ie ? + bss_desc->bcn_wpa_ie->vend_hdr.element_id :0 , + bss_desc->bcn_rsn_ie ? + bss_desc->bcn_rsn_ie->ieee_hdr.element_id :0 , + priv->sec_info.wep_enabled ?"e" :"d" , + priv->sec_info.wpa_enabled ?"e" :"d" , + priv->sec_info.wpa2_enabled ?"e" :"d" , + priv->sec_info.encryption_mode, + bss_desc->privacy); +} + +#define dbg_security_flags (mask, desc, priv, bss_desc) \ + _dbg_security_flags(NXPWIFI_DBG_##mask, desc, __func__, priv, bss_desc) + +static bool +has_ieee_hdr (struct ieee_types_generic *ie,u8 key) +{ +return (ie && ie->ieee_hdr.element_id == key); +} + +static bool +has_vendor_hdr (struct ieee_types_vendor_specific *ie,u8 key) +{ +return (ie && ie->vend_hdr.element_id == key); +} + +/* This function parses a given IE for a given OUI. +* +* This is used to parse a WPA/RSN IE to find if it has +* a given oui in PTK. +*/ +static u8 +nxpwifi_search_oui_in_ie (struct ie_body *iebody,u8 *oui) +{ +u8 count; + + count = iebody->ptk_cnt[0 ]; + +/* There could be multiple OUIs for PTK hence +* 1) Take the length. +* 2) Check all the OUIs for AES. +* 3) If one of them is AES then pass success. +*/ +while (count) { +if (!memcmp (iebody->ptk_body, oui,sizeof (iebody->ptk_body))) +return NXPWIFI_OUI_PRESENT ; + + --count; +if (count) + iebody = (struct ie_body *)((u8 *)iebody + +sizeof (iebody->ptk_body)); + } + +pr_debug ("info: %s: OUI is not found in PTK\n" , __func__); +return NXPWIFI_OUI_NOT_PRESENT ; +} + +/* This function checks if a given OUI is present in a RSN IE. +* +* The function first checks if a RSN IE is present or not in the +* BSS descriptor. It tries to locate the OUI only if such an IE is +* present. +*/ +static u8 +nxpwifi_is_rsn_oui_present (struct nxpwifi_bssdescriptor *bss_desc,u32 cipher) +{ +u8 *oui; +struct ie_body *iebody; +u8 ret =NXPWIFI_OUI_NOT_PRESENT ; + +if (has_ieee_hdr (bss_desc->bcn_rsn_ie,WLAN_EID_RSN )) { + iebody = (struct ie_body *) + (((u8 *)bss_desc->bcn_rsn_ie->data) + +RSN_GTK_OUI_OFFSET ); + oui = &nxpwifi_rsn_oui[cipher][0 ]; + ret =nxpwifi_search_oui_in_ie (iebody, oui); +if (ret) +return ret; + } +return ret; +} + +/* This function checks if a given OUI is present in a WPA IE. +* +* The function first checks if a WPA IE is present or not in the +* BSS descriptor. It tries to locate the OUI only if such an IE is +* present. +*/ +static u8 +nxpwifi_is_wpa_oui_present (struct nxpwifi_bssdescriptor *bss_desc,u32 cipher) +{ +u8 *oui; +struct ie_body *iebody; +u8 ret =NXPWIFI_OUI_NOT_PRESENT ; + +if (has_vendor_hdr (bss_desc->bcn_wpa_ie,WLAN_EID_VENDOR_SPECIFIC )) { + iebody = (struct ie_body *)((u8 *)bss_desc->bcn_wpa_ie->data + +WPA_GTK_OUI_OFFSET ); + oui = &nxpwifi_wpa_oui[cipher][0 ]; + ret =nxpwifi_search_oui_in_ie (iebody, oui); +if (ret) +return ret; + } +return ret; +} + +/* This function checks if driver is configured with no security mode and +* scanned network is compatible with it. +*/ +static bool +nxpwifi_is_bss_no_sec (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +if (!priv->sec_info.wep_enabled && !priv->sec_info.wpa_enabled && + !priv->sec_info.wpa2_enabled && + !has_vendor_hdr (bss_desc->bcn_wpa_ie,WLAN_EID_VENDOR_SPECIFIC ) && + !has_ieee_hdr (bss_desc->bcn_rsn_ie,WLAN_EID_RSN ) && + !priv->sec_info.encryption_mode && !bss_desc->privacy) { +return true; + } +return false; +} + +/* This function checks if static WEP is enabled in driver and scanned network +* is compatible with it. +*/ +static bool +nxpwifi_is_bss_static_wep (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +if (priv->sec_info.wep_enabled && !priv->sec_info.wpa_enabled && + !priv->sec_info.wpa2_enabled && bss_desc->privacy) { +return true; + } +return false; +} + +/* This function checks if wpa is enabled in driver and scanned network is +* compatible with it. +*/ +static bool +nxpwifi_is_bss_wpa (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +if (!priv->sec_info.wep_enabled && priv->sec_info.wpa_enabled && + !priv->sec_info.wpa2_enabled && +has_vendor_hdr (bss_desc->bcn_wpa_ie,WLAN_EID_VENDOR_SPECIFIC ) +/* Privacy bit may NOT be set in some APs like +* LinkSys WRT54G && bss_desc->privacy +*/ + ) { +dbg_security_flags (INFO ,"WPA" , priv, bss_desc); +return true; + } +return false; +} + +/* This function checks if wpa2 is enabled in driver and scanned network is +* compatible with it. +*/ +static bool +nxpwifi_is_bss_wpa2 (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +if (!priv->sec_info.wep_enabled && !priv->sec_info.wpa_enabled && + priv->sec_info.wpa2_enabled && +has_ieee_hdr (bss_desc->bcn_rsn_ie,WLAN_EID_RSN )) { +/* Privacy bit may NOT be set in some APs like +* LinkSys WRT54G && bss_desc->privacy +*/ +dbg_security_flags (INFO ,"WAP2" , priv, bss_desc); +return true; + } +return false; +} + +/* This function checks if dynamic WEP is enabled in driver and scanned network +* is compatible with it. +*/ +static bool +nxpwifi_is_bss_dynamic_wep (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +if (!priv->sec_info.wep_enabled && !priv->sec_info.wpa_enabled && + !priv->sec_info.wpa2_enabled && + !has_vendor_hdr (bss_desc->bcn_wpa_ie,WLAN_EID_VENDOR_SPECIFIC ) && + !has_ieee_hdr (bss_desc->bcn_rsn_ie,WLAN_EID_RSN ) && + priv->sec_info.encryption_mode && bss_desc->privacy) { +dbg_security_flags (INFO ,"dynamic" , priv, bss_desc); +return true; + } +return false; +} + +/* This function checks if a scanned network is compatible with the driver +* settings. +* +* WEP WPA WPA2 encrypt Network +* -enabled -enabled -enabled mode Privacy WPA WPA2 Compatible +* 0 0 0 NONE 0 0 0 yes No security +* 0 1 0 x 1x 1 x yes WPA (disable +* HT if no AES) +* 0 0 1 x 1x x 1 yes WPA2 (disable +* HT if no AES) +* 1 0 0 NONE 1 0 0 yes Static WEP +* (disable HT) +* 0 0 0 !=NONE 1 0 0 yes Dynamic WEP +* +* Compatibility is not matched while roaming, except for mode. +*/ +static s32 +nxpwifi_is_network_compatible (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc,u32 mode) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + + bss_desc->disable_11n = false; + +/* Don't check for compatibility if roaming */ +if (priv->media_connected && + priv->bss_mode ==NL80211_IFTYPE_STATION && + bss_desc->bss_mode ==NL80211_IFTYPE_STATION ) +return 0 ; + +if (priv->wps.session_enable) { +nxpwifi_dbg (adapter,IOCTL , +"info: return success directly in WPS period\n" ); +return 0 ; + } + +if (bss_desc->chan_sw_ie_present) { +nxpwifi_dbg (adapter,INFO , +"Don't connect to AP with WLAN_EID_CHANNEL_SWITCH\n" ); +return -1 ; + } + +if (bss_desc->bss_mode == mode) { +if (nxpwifi_is_bss_no_sec (priv, bss_desc)) { +/* No security */ +return 0 ; + }else if (nxpwifi_is_bss_static_wep (priv, bss_desc)) { +/* Static WEP enabled */ +nxpwifi_dbg (adapter,INFO , +"info: Disable 11n in WEP mode.\n" ); + bss_desc->disable_11n = true; +return 0 ; + }else if (nxpwifi_is_bss_wpa (priv, bss_desc)) { +/* WPA enabled */ +if (((priv->adapter->config_bands &BAND_GN || + priv->adapter->config_bands &BAND_AN ) && + bss_desc->bcn_ht_cap) && + !nxpwifi_is_wpa_oui_present (bss_desc, +CIPHER_SUITE_CCMP )) { +if (nxpwifi_is_wpa_oui_present + (bss_desc,CIPHER_SUITE_TKIP )) { +nxpwifi_dbg (adapter,INFO , +"info: Disable 11n if AES\t" +"is not supported by AP\n" ); + bss_desc->disable_11n = true; + }else { +return -1 ; + } + } +return 0 ; + }else if (nxpwifi_is_bss_wpa2 (priv, bss_desc)) { +/* WPA2 enabled */ +if (((priv->adapter->config_bands &BAND_GN || + priv->adapter->config_bands &BAND_AN ) && + bss_desc->bcn_ht_cap) && + !nxpwifi_is_rsn_oui_present (bss_desc, +CIPHER_SUITE_CCMP )) { +if (nxpwifi_is_rsn_oui_present + (bss_desc,CIPHER_SUITE_TKIP )) { +nxpwifi_dbg (adapter,INFO , +"info: Disable 11n if AES\t" +"is not supported by AP\n" ); + bss_desc->disable_11n = true; + }else { +return -1 ; + } + } +return 0 ; + }else if (nxpwifi_is_bss_dynamic_wep (priv, bss_desc)) { +/* Dynamic WEP enabled */ +return 0 ; + } + +/* Security doesn't match */ +dbg_security_flags (ERROR ,"failed" , priv, bss_desc); +return -1 ; + } + +/* Mode doesn't match */ +return -1 ; +} + +/* This function creates a channel list for the driver to scan, based +* on region/band information. +* +* This routine is used for any scan that is not provided with a +* specific channel list to scan. +*/ +static int +nxpwifi_scan_create_channel_list (struct nxpwifi_private *priv, +const struct nxpwifi_user_scan_cfg + *user_scan_in, +struct nxpwifi_chan_scan_param_set + *scan_chan_list, +u8 filtered_scan) +{ +enum nl80211_band band; +struct ieee80211_supported_band *sband; +struct ieee80211_channel *ch; +struct nxpwifi_adapter *adapter = priv->adapter; +int chan_idx =0 , i; +u16 scan_time =0 ; + +if (user_scan_in) + scan_time = (u16 )user_scan_in->chan_list[0 ].scan_time; + +for (band =0 ; (band <NUM_NL80211_BANDS ) ; band++) { +if (!priv->wdev.wiphy->bands[band]) +continue ; + + sband = priv->wdev.wiphy->bands[band]; + +for (i =0 ; (i < sband->n_channels) ; i++) { + ch = &sband->channels[i]; +if (ch->flags &IEEE80211_CHAN_DISABLED ) +continue ; + scan_chan_list[chan_idx].radio_type = band; + +if (scan_time) + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (scan_time); +else if ((ch->flags &IEEE80211_CHAN_NO_IR ) || + (ch->flags &IEEE80211_CHAN_RADAR )) + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (adapter->passive_scan_time); +else + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (adapter->active_scan_time); + +if (ch->flags &IEEE80211_CHAN_NO_IR ) + scan_chan_list[chan_idx].chan_scan_mode_bmap |= + (NXPWIFI_PASSIVE_SCAN |NXPWIFI_HIDDEN_SSID_REPORT ); +else + scan_chan_list[chan_idx].chan_scan_mode_bmap &= + ~NXPWIFI_PASSIVE_SCAN ; + + scan_chan_list[chan_idx].chan_number = (u32 )ch->hw_value; + scan_chan_list[chan_idx].chan_scan_mode_bmap |= +NXPWIFI_DISABLE_CHAN_FILT ; + +if (filtered_scan && + !((ch->flags &IEEE80211_CHAN_NO_IR ) || + (ch->flags &IEEE80211_CHAN_RADAR ))) + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (adapter->specific_scan_time); + + chan_idx++; + } + } +return chan_idx; +} + +/* This function creates a channel list tlv for bgscan config, based +* on region/band information. +*/ +static int +nxpwifi_bgscan_create_channel_list (struct nxpwifi_private *priv, +const struct nxpwifi_bg_scan_cfg + *bgscan_cfg_in, +struct nxpwifi_chan_scan_param_set + *scan_chan_list) +{ +enum nl80211_band band; +struct ieee80211_supported_band *sband; +struct ieee80211_channel *ch; +struct nxpwifi_adapter *adapter = priv->adapter; +int chan_idx =0 , i; +u16 scan_time =0 , specific_scan_time = adapter->specific_scan_time; + +if (bgscan_cfg_in) + scan_time = (u16 )bgscan_cfg_in->chan_list[0 ].scan_time; + +for (band =0 ; (band <NUM_NL80211_BANDS ); band++) { +if (!priv->wdev.wiphy->bands[band]) +continue ; + + sband = priv->wdev.wiphy->bands[band]; + +for (i =0 ; (i < sband->n_channels) ; i++) { + ch = &sband->channels[i]; +if (ch->flags &IEEE80211_CHAN_DISABLED ) +continue ; + scan_chan_list[chan_idx].radio_type = band; + +if (scan_time) + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (scan_time); +else if (ch->flags &IEEE80211_CHAN_NO_IR ) + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (adapter->passive_scan_time); +else + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (specific_scan_time); + +if (ch->flags &IEEE80211_CHAN_NO_IR ) + scan_chan_list[chan_idx].chan_scan_mode_bmap |= +NXPWIFI_PASSIVE_SCAN ; +else + scan_chan_list[chan_idx].chan_scan_mode_bmap &= + ~NXPWIFI_PASSIVE_SCAN ; + + scan_chan_list[chan_idx].chan_number = (u32 )ch->hw_value; + chan_idx++; + } + } +return chan_idx; +} + +/* This function appends rate TLV to scan config command. */ +static int +nxpwifi_append_rate_tlv (struct nxpwifi_private *priv, +struct nxpwifi_scan_cmd_config *scan_cfg_out, +u8 radio) +{ +struct nxpwifi_ie_types_rates_param_set *rates_tlv; +u8 rates[NXPWIFI_SUPPORTED_RATES ], *tlv_pos; +u32 rates_size; + +memset (rates,0 ,sizeof (rates)); + + tlv_pos = (u8 *)scan_cfg_out->tlv_buf + scan_cfg_out->tlv_buf_len; + +if (priv->scan_request) + rates_size =nxpwifi_get_rates_from_cfg80211 (priv, rates, + radio); +else + rates_size =nxpwifi_get_supported_rates (priv, rates); + +nxpwifi_dbg (priv->adapter,CMD , +"info: SCAN_CMD: Rates size = %d\n" , + rates_size); + rates_tlv = (struct nxpwifi_ie_types_rates_param_set *)tlv_pos; + rates_tlv->header.type =cpu_to_le16 (WLAN_EID_SUPP_RATES ); + rates_tlv->header.len =cpu_to_le16 ((u16 )rates_size); +memcpy (rates_tlv->rates, rates, rates_size); + scan_cfg_out->tlv_buf_len +=sizeof (rates_tlv->header) + rates_size; + +return rates_size; +} + +/* This function constructs and sends multiple scan config commands to +* the firmware. +* +* Previous routines in the code flow have created a scan command configuration +* with any requested TLVs. This function splits the channel TLV into maximum +* channels supported per scan lists and sends the portion of the channel TLV, +* along with the other TLVs, to the firmware. +*/ +static int +nxpwifi_scan_channel_list (struct nxpwifi_private *priv, +u32 max_chan_per_scan,u8 filtered_scan, +struct nxpwifi_scan_cmd_config *scan_cfg_out, +struct nxpwifi_ie_types_chan_list_param_set *tlv_o, +struct nxpwifi_chan_scan_param_set *scan_chan_list) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret =0 ; +struct nxpwifi_chan_scan_param_set *tmp_chan_list; +u32 tlv_idx, rates_size, cmd_no; +u32 total_scan_time; +u32 done_early; +u8 radio_type; + +if (!scan_cfg_out || !tlv_o || !scan_chan_list) { +nxpwifi_dbg (priv->adapter,ERROR , +"info: Scan: Null detect: %p, %p, %p\n" , + scan_cfg_out, tlv_o, scan_chan_list); +return -1 ; + } + +/* Check csa channel expiry before preparing scan list */ +nxpwifi_11h_get_csa_closed_channel (priv); + + tlv_o->header.type =cpu_to_le16 (TLV_TYPE_CHANLIST ); + +/* Set the temp channel struct pointer to the start of the desired +* list +*/ + tmp_chan_list = scan_chan_list; + +/* Loop through the desired channel list, sending a new firmware scan +* commands for each max_chan_per_scan channels (or for 1,6,11 +* individually if configured accordingly) +*/ +while (tmp_chan_list->chan_number) { + tlv_idx =0 ; + total_scan_time =0 ; + radio_type =0 ; + tlv_o->header.len =0 ; + done_early = false; + +/* Construct the Channel TLV for the scan command. Continue to +* insert channel TLVs until: +* - the tlv_idx hits the maximum configured per scan command +* - the next channel to insert is 0 (end of desired channel +* list) +* - done_early is set (controlling individual scanning of +* 1,6,11) +*/ +while (tlv_idx < max_chan_per_scan && + tmp_chan_list->chan_number && !done_early) { +if (tmp_chan_list->chan_number == priv->csa_chan) { + tmp_chan_list++; +continue ; + } + + radio_type = tmp_chan_list->radio_type; +nxpwifi_dbg (priv->adapter,INFO , +"info: Scan: Chan(%3d), Radio(%d),\t" +"Mode(%d, %d), Dur(%d)\n" , + tmp_chan_list->chan_number, + tmp_chan_list->radio_type, + tmp_chan_list->chan_scan_mode_bmap + &NXPWIFI_PASSIVE_SCAN , + (tmp_chan_list->chan_scan_mode_bmap + &NXPWIFI_DISABLE_CHAN_FILT ) >>1 , +le16_to_cpu (tmp_chan_list->max_scan_time)); + +/* Copy the current channel TLV to the command being +* prepared +*/ +memcpy (&tlv_o->chan_scan_param[tlv_idx], + tmp_chan_list, +sizeof (*tlv_o->chan_scan_param)); + +/* Increment the TLV header length by the size +* appended +*/ +le16_unaligned_add_cpu (&tlv_o->header.len, +sizeof (*tlv_o->chan_scan_param)); + +/* The tlv buffer length is set to the number of bytes +* of the between the channel tlv pointer and the start +* of the tlv buffer. This compensates for any TLVs +* that were appended before the channel list. +*/ + scan_cfg_out->tlv_buf_len = (u32)((u8 *)tlv_o - + scan_cfg_out->tlv_buf); + +/* Add the size of the channel tlv header and the data +* length +*/ + scan_cfg_out->tlv_buf_len += + (sizeof (tlv_o->header) + +le16_to_cpu (tlv_o->header.len)); + +/* Increment the index to the channel tlv we are +* constructing +*/ + tlv_idx++; + +/* Count the total scan time per command */ + total_scan_time += +le16_to_cpu (tmp_chan_list->max_scan_time); + + done_early = false; + +/* Stop the loop if the *current* channel is in the +* 1,6,11 set and we are not filtering on a BSSID +* or SSID. +*/ +if (!filtered_scan && + (tmp_chan_list->chan_number ==1 || + tmp_chan_list->chan_number ==6 || + tmp_chan_list->chan_number ==11 )) + done_early = true; + +/* Increment the tmp pointer to the next channel to +* be scanned +*/ + tmp_chan_list++; + +/* Stop the loop if the *next* channel is in the 1,6,11 +* set. This will cause it to be the only channel +* scanned on the next interation +*/ +if (!filtered_scan && + (tmp_chan_list->chan_number ==1 || + tmp_chan_list->chan_number ==6 || + tmp_chan_list->chan_number ==11 )) + done_early = true; + } + +/* The total scan time should be less than scan command timeout +* value +*/ +if (total_scan_time >NXPWIFI_MAX_TOTAL_SCAN_TIME ) { +nxpwifi_dbg (priv->adapter,ERROR , +"total scan time %dms\t" +"is over limit (%dms), scan skipped\n" , + total_scan_time, +NXPWIFI_MAX_TOTAL_SCAN_TIME ); + ret =-1 ; +break ; + } + + rates_size =nxpwifi_append_rate_tlv (priv, scan_cfg_out, + radio_type); + +/* Send the scan command to the firmware with the specified +* cfg +*/ +if (priv->adapter->ext_scan) + cmd_no =HOST_CMD_802_11_SCAN_EXT ; +else + cmd_no =HOST_CMD_802_11_SCAN ; + + ret =nxpwifi_send_cmd (priv, cmd_no,HOST_ACT_GEN_SET , +0 , scan_cfg_out, false); + +/* rate IE is updated per scan command but same starting +* pointer is used each time so that rate IE from earlier +* scan_cfg_out->buf is overwritten with new one. +*/ + scan_cfg_out->tlv_buf_len -= +sizeof (struct nxpwifi_ie_types_header ) + rates_size; + +if (ret) { +nxpwifi_cancel_pending_scan_cmd (adapter); +break ; + } + } + +if (ret) +return -1 ; + +return 0 ; +} + +/* This function constructs a scan command configuration structure to use +* in scan commands. +* +* Application layer or other functions can invoke network scanning +* with a scan configuration supplied in a user scan configuration structure. +* This structure is used as the basis of one or many scan command configuration +* commands that are sent to the command processing module and eventually to the +* firmware. +* +* This function creates a scan command configuration structure based on the +* following user supplied parameters (if present): +* - SSID filter +* - BSSID filter +* - Number of Probes to be sent +* - Channel list +* +* If the SSID or BSSID filter is not present, the filter is disabled/cleared. +* If the number of probes is not set, adapter default setting is used. +*/ +static void +nxpwifi_config_scan (struct nxpwifi_private *priv, +const struct nxpwifi_user_scan_cfg *user_scan_in, +struct nxpwifi_scan_cmd_config *scan_cfg_out, +struct nxpwifi_ie_types_chan_list_param_set **chan_list_out, +struct nxpwifi_chan_scan_param_set *scan_chan_list, +u8 *max_chan_per_scan,u8 *filtered_scan, +u8 *scan_current_only) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_ie_types_num_probes *num_probes_tlv; +struct nxpwifi_ie_types_scan_chan_gap *chan_gap_tlv; +struct nxpwifi_ie_types_random_mac *random_mac_tlv; +struct nxpwifi_ie_types_wildcard_ssid_params *wildcard_ssid_tlv; +struct nxpwifi_ie_types_bssid_list *bssid_tlv; +u8 *tlv_pos; +u32 num_probes; +u32 ssid_len; +u32 chan_idx; +u32 scan_time; +u32 scan_type; +u16 scan_dur; +u8 channel; +u8 radio_type; +int i; +u8 ssid_filter; +struct nxpwifi_ie_types_htcap *ht_cap; +struct nxpwifi_ie_types_bss_mode *bss_mode; + +/* The tlv_buf_len is calculated for each scan command. The TLVs added +* in this routine will be preserved since the routine that sends the +* command will append channelTLVs at *chan_list_out. The difference +* between the *chan_list_out and the tlv_buf start will be used to +* calculate the size of anything we add in this routine. +*/ + scan_cfg_out->tlv_buf_len =0 ; + +/* Running tlv pointer. Assigned to chan_list_out at end of function +* so later routines know where channels can be added to the command +* buf +*/ + tlv_pos = scan_cfg_out->tlv_buf; + +/* Initialize the scan as un-filtered; the flag is later set to TRUE +* below if a SSID or BSSID filter is sent in the command +*/ + *filtered_scan = false; + +/* Initialize the scan as not being only on the current channel. If +* the channel list is customized, only contains one channel, and is +* the active channel, this is set true and data flow is not halted. +*/ + *scan_current_only = false; + +if (user_scan_in) { +u8 tmpaddr[ETH_ALEN ]; + +/* Default the ssid_filter flag to TRUE, set false under +* certain wildcard conditions and qualified by the existence +* of an SSID list before marking the scan as filtered +*/ + ssid_filter = true; + +/* Set the BSS type scan filter, use Adapter setting if +* unset +*/ + scan_cfg_out->bss_mode = + (u8)(user_scan_in->bss_mode ?: adapter->scan_mode); + +/* Set the number of probes to send, use Adapter setting +* if unset +*/ + num_probes = user_scan_in->num_probes ?: adapter->scan_probes; + +/* Set the BSSID filter to the incoming configuration, +* if non-zero. If not set, it will remain disabled +* (all zeros). +*/ +memcpy (scan_cfg_out->specific_bssid, + user_scan_in->specific_bssid, +sizeof (scan_cfg_out->specific_bssid)); + +memcpy (tmpaddr, scan_cfg_out->specific_bssid,ETH_ALEN ); + +if (adapter->ext_scan && + !is_zero_ether_addr (tmpaddr)) { + bssid_tlv = + (struct nxpwifi_ie_types_bssid_list *)tlv_pos; + bssid_tlv->header.type =cpu_to_le16 (TLV_TYPE_BSSID ); + bssid_tlv->header.len =cpu_to_le16 (ETH_ALEN ); +memcpy (bssid_tlv->bssid, user_scan_in->specific_bssid, +ETH_ALEN ); + tlv_pos +=sizeof (struct nxpwifi_ie_types_bssid_list ); + } + +for (i =0 ; i < user_scan_in->num_ssids; i++) { + ssid_len = user_scan_in->ssid_list[i].ssid_len; + + wildcard_ssid_tlv = + (struct nxpwifi_ie_types_wildcard_ssid_params *) + tlv_pos; + wildcard_ssid_tlv->header.type = +cpu_to_le16 (TLV_TYPE_WILDCARDSSID ); + wildcard_ssid_tlv->header.len = +cpu_to_le16 ((u16)(ssid_len +sizeof (u8))); + +/* max_ssid_length = 0 tells firmware to perform +* specific scan for the SSID filled, whereas +* max_ssid_length = IEEE80211_MAX_SSID_LEN is for +* wildcard scan. +*/ +if (ssid_len) + wildcard_ssid_tlv->max_ssid_length =0 ; +else + wildcard_ssid_tlv->max_ssid_length = +IEEE80211_MAX_SSID_LEN ; + +if (!memcmp (user_scan_in->ssid_list[i].ssid, +"DIRECT-" ,7 )) + wildcard_ssid_tlv->max_ssid_length =0xfe ; + +memcpy (wildcard_ssid_tlv->ssid, + user_scan_in->ssid_list[i].ssid, ssid_len); + + tlv_pos += (sizeof (wildcard_ssid_tlv->header) + +le16_to_cpu (wildcard_ssid_tlv->header.len)); + +nxpwifi_dbg (adapter,INFO , +"info: scan: ssid[%d]: %s, %d\n" , + i, wildcard_ssid_tlv->ssid, + wildcard_ssid_tlv->max_ssid_length); + +/* Empty wildcard ssid with a maxlen will match many or +* potentially all SSIDs (maxlen == 32), therefore do +* not treat the scan as +* filtered. +*/ +if (!ssid_len && wildcard_ssid_tlv->max_ssid_length) + ssid_filter = false; + } + +/* The default number of channels sent in the command is low to +* ensure the response buffer from the firmware does not +* truncate scan results. That is not an issue with an SSID +* or BSSID filter applied to the scan results in the firmware. +*/ +memcpy (tmpaddr, scan_cfg_out->specific_bssid,ETH_ALEN ); +if ((i && ssid_filter) || + !is_zero_ether_addr (tmpaddr)) + *filtered_scan = true; + +if (user_scan_in->scan_chan_gap) { +nxpwifi_dbg (adapter,INFO , +"info: scan: channel gap = %d\n" , + user_scan_in->scan_chan_gap); + *max_chan_per_scan = +NXPWIFI_MAX_CHANNELS_PER_SPECIFIC_SCAN ; + + chan_gap_tlv = (void *)tlv_pos; + chan_gap_tlv->header.type = +cpu_to_le16 (TLV_TYPE_SCAN_CHANNEL_GAP ); + chan_gap_tlv->header.len = +cpu_to_le16 (sizeof (chan_gap_tlv->chan_gap)); + chan_gap_tlv->chan_gap = +cpu_to_le16 ((user_scan_in->scan_chan_gap)); + tlv_pos += +sizeof (struct nxpwifi_ie_types_scan_chan_gap ); + } + +if (!is_zero_ether_addr (user_scan_in->random_mac)) { + random_mac_tlv = (void *)tlv_pos; + random_mac_tlv->header.type = +cpu_to_le16 (TLV_TYPE_RANDOM_MAC ); + random_mac_tlv->header.len = +cpu_to_le16 (sizeof (random_mac_tlv->mac)); +ether_addr_copy (random_mac_tlv->mac, + user_scan_in->random_mac); + tlv_pos += +sizeof (struct nxpwifi_ie_types_random_mac ); + } + }else { + scan_cfg_out->bss_mode = (u8 )adapter->scan_mode; + num_probes = adapter->scan_probes; + } + +/* If a specific BSSID or SSID is used, the number of channels in the +* scan command will be increased to the absolute maximum. +*/ +if (*filtered_scan) { + *max_chan_per_scan =NXPWIFI_MAX_CHANNELS_PER_SPECIFIC_SCAN ; + }else { +if (!priv->media_connected) + *max_chan_per_scan =NXPWIFI_DEF_CHANNELS_PER_SCAN_CMD ; +else + *max_chan_per_scan = +NXPWIFI_DEF_CHANNELS_PER_SCAN_CMD /2 ; + } + +if (adapter->ext_scan) { + bss_mode = (struct nxpwifi_ie_types_bss_mode *)tlv_pos; + bss_mode->header.type =cpu_to_le16 (TLV_TYPE_BSS_MODE ); + bss_mode->header.len =cpu_to_le16 (sizeof (bss_mode->bss_mode)); + bss_mode->bss_mode = scan_cfg_out->bss_mode; + tlv_pos +=sizeof (bss_mode->header) + +le16_to_cpu (bss_mode->header.len); + } + +/* If the input config or adapter has the number of Probes set, +* add tlv +*/ +if (num_probes) { +nxpwifi_dbg (adapter,INFO , +"info: scan: num_probes = %d\n" , + num_probes); + + num_probes_tlv = (struct nxpwifi_ie_types_num_probes *)tlv_pos; + num_probes_tlv->header.type =cpu_to_le16 (TLV_TYPE_NUMPROBES ); + num_probes_tlv->header.len = +cpu_to_le16 (sizeof (num_probes_tlv->num_probes)); + num_probes_tlv->num_probes =cpu_to_le16 ((u16 )num_probes); + + tlv_pos +=sizeof (num_probes_tlv->header) + +le16_to_cpu (num_probes_tlv->header.len); + } + +if (ISSUPP_11NENABLED (priv->adapter->fw_cap_info) && + (priv->adapter->config_bands &BAND_GN || + priv->adapter->config_bands &BAND_AN )) { + ht_cap = (struct nxpwifi_ie_types_htcap *)tlv_pos; +memset (ht_cap,0 ,sizeof (struct nxpwifi_ie_types_htcap )); + ht_cap->header.type =cpu_to_le16 (WLAN_EID_HT_CAPABILITY ); + ht_cap->header.len = +cpu_to_le16 (sizeof (struct ieee80211_ht_cap )); + radio_type = +nxpwifi_band_to_radio_type (priv->adapter->config_bands); +nxpwifi_fill_cap_info (priv, radio_type, &ht_cap->ht_cap); + tlv_pos +=sizeof (struct nxpwifi_ie_types_htcap ); + } + +/* Append vendor specific IE TLV */ +nxpwifi_cmd_append_vsie_tlv (priv,NXPWIFI_VSIE_MASK_SCAN , &tlv_pos); + +/* Set the output for the channel TLV to the address in the tlv buffer +* past any TLVs that were added in this function (SSID, num_probes). +* Channel TLVs will be added past this for each scan command, +* preserving the TLVs that were previously added. +*/ + *chan_list_out = + (struct nxpwifi_ie_types_chan_list_param_set *)tlv_pos; + +if (user_scan_in && user_scan_in->chan_list[0 ].chan_number) { +nxpwifi_dbg (adapter,INFO , +"info: Scan: Using supplied channel list\n" ); + +for (chan_idx =0 ; + chan_idx <NXPWIFI_USER_SCAN_CHAN_MAX && + user_scan_in->chan_list[chan_idx].chan_number; + chan_idx++) { + channel = user_scan_in->chan_list[chan_idx].chan_number; + scan_chan_list[chan_idx].chan_number = channel; + + radio_type = + user_scan_in->chan_list[chan_idx].radio_type; + scan_chan_list[chan_idx].radio_type = radio_type; + + scan_type = user_scan_in->chan_list[chan_idx].scan_type; + +if (scan_type ==NXPWIFI_SCAN_TYPE_PASSIVE ) + scan_chan_list[chan_idx].chan_scan_mode_bmap |= + (NXPWIFI_PASSIVE_SCAN | +NXPWIFI_HIDDEN_SSID_REPORT ); +else + scan_chan_list[chan_idx].chan_scan_mode_bmap &= + ~NXPWIFI_PASSIVE_SCAN ; + + scan_chan_list[chan_idx].chan_scan_mode_bmap |= +NXPWIFI_DISABLE_CHAN_FILT ; + + scan_time = user_scan_in->chan_list[chan_idx].scan_time; + +if (scan_time) { + scan_dur = (u16 )scan_time; + }else { +if (scan_type ==NXPWIFI_SCAN_TYPE_PASSIVE ) + scan_dur = adapter->passive_scan_time; +else if (*filtered_scan) + scan_dur = adapter->specific_scan_time; +else + scan_dur = adapter->active_scan_time; + } + + scan_chan_list[chan_idx].min_scan_time = +cpu_to_le16 (scan_dur); + scan_chan_list[chan_idx].max_scan_time = +cpu_to_le16 (scan_dur); + } + +/* Check if we are only scanning the current channel */ +if (chan_idx ==1 && + user_scan_in->chan_list[0 ].chan_number == + priv->curr_bss_params.bss_descriptor.channel) { + *scan_current_only = true; +nxpwifi_dbg (adapter,INFO , +"info: Scan: Scanning current channel only\n" ); + } + }else { +nxpwifi_dbg (adapter,INFO , +"info: Scan: Creating full region channel list\n" ); +nxpwifi_scan_create_channel_list (priv, user_scan_in, + scan_chan_list, + *filtered_scan); + } +} + +/* This function inspects the scan response buffer for pointers to +* expected TLVs. +* +* TLVs can be included at the end of the scan response BSS information. +* +* Data in the buffer is parsed pointers to TLVs that can potentially +* be passed back in the response. +*/ +static void +nxpwifi_ret_802_11_scan_get_tlv_ptrs (struct nxpwifi_adapter *adapter, +struct nxpwifi_ie_types_data *tlv, +u32 tlv_buf_size,u32 req_tlv_type, +struct nxpwifi_ie_types_data **tlv_data) +{ +struct nxpwifi_ie_types_data *current_tlv; +u32 tlv_buf_left; +u32 tlv_type; +u32 tlv_len; + + current_tlv = tlv; + tlv_buf_left = tlv_buf_size; + *tlv_data =NULL ; + +nxpwifi_dbg (adapter,INFO , +"info: SCAN_RESP: tlv_buf_size = %d\n" , + tlv_buf_size); + +while (tlv_buf_left >=sizeof (struct nxpwifi_ie_types_header )) { + tlv_type =le16_to_cpu (current_tlv->header.type); + tlv_len =le16_to_cpu (current_tlv->header.len); + +if (sizeof (tlv->header) + tlv_len > tlv_buf_left) { +nxpwifi_dbg (adapter,ERROR , +"SCAN_RESP: TLV buffer corrupt\n" ); +break ; + } + +if (req_tlv_type == tlv_type) { +switch (tlv_type) { +case TLV_TYPE_TSFTIMESTAMP : +nxpwifi_dbg (adapter,INFO , +"info: SCAN_RESP: TSF\t" +"timestamp TLV, len = %d\n" , + tlv_len); + *tlv_data = current_tlv; +break ; +case TLV_TYPE_CHANNELBANDLIST : +nxpwifi_dbg (adapter,INFO , +"info: SCAN_RESP: channel\t" +"band list TLV, len = %d\n" , + tlv_len); + *tlv_data = current_tlv; +break ; +default : +nxpwifi_dbg (adapter,ERROR , +"SCAN_RESP: unhandled TLV = %d\n" , + tlv_type); +/* Give up, this seems corrupted */ +return ; + } + } + +if (*tlv_data) +break ; + + tlv_buf_left -= (sizeof (tlv->header) + tlv_len); + current_tlv = + (struct nxpwifi_ie_types_data *)(current_tlv->data + + tlv_len); + }/* while */ +} + +/* This function parses provided beacon buffer and updates +* respective fields in bss descriptor structure. +*/ +int nxpwifi_update_bss_desc_with_ie (struct nxpwifi_adapter *adapter, +struct nxpwifi_bssdescriptor *bss_entry) +{ +u8 element_id; +struct ieee_types_fh_param_set *fh_param_set; +struct ieee_types_ds_param_set *ds_param_set; +struct ieee_types_cf_param_set *cf_param_set; +struct ieee_types_ibss_param_set *ibss_param_set; +u8 *current_ptr; +u8 *rate; +u8 element_len; +u16 total_ie_len; +u8 bytes_to_copy; +u8 rate_size; +u8 found_data_rate_ie; +u32 bytes_left; +struct ieee_types_vendor_specific *vendor_ie; +const u8 wpa_oui[4 ] = {0x00 ,0x50 ,0xf2 ,0x01 }; +const u8 wmm_oui[4 ] = {0x00 ,0x50 ,0xf2 ,0x02 }; + + found_data_rate_ie = false; + rate_size =0 ; + current_ptr = bss_entry->beacon_buf; + bytes_left = bss_entry->beacon_buf_size; + +/* Process variable IE */ +while (bytes_left >=2 ) { + element_id = *current_ptr; + element_len = *(current_ptr +1 ); + total_ie_len = element_len +sizeof (struct ieee_types_header ); + +if (bytes_left < total_ie_len) { +nxpwifi_dbg (adapter,ERROR , +"err: InterpretIE: in processing\t" +"IE, bytes left < IE length\n" ); +return -EINVAL ; + } +switch (element_id) { +case WLAN_EID_SSID : +if (element_len >IEEE80211_MAX_SSID_LEN ) +return -EINVAL ; + bss_entry->ssid.ssid_len = element_len; +memcpy (bss_entry->ssid.ssid, (current_ptr +2 ), + element_len); +nxpwifi_dbg (adapter,INFO , +"info: InterpretIE: ssid: %-32s\n" , + bss_entry->ssid.ssid); +break ; + +case WLAN_EID_SUPP_RATES : +if (element_len >NXPWIFI_SUPPORTED_RATES ) +return -EINVAL ; +memcpy (bss_entry->data_rates, current_ptr +2 , + element_len); +memcpy (bss_entry->supported_rates, current_ptr +2 , + element_len); + rate_size = element_len; + found_data_rate_ie = true; +break ; + +case WLAN_EID_FH_PARAMS : +if (total_ie_len <sizeof (*fh_param_set)) +return -EINVAL ; + fh_param_set = + (struct ieee_types_fh_param_set *)current_ptr; +memcpy (&bss_entry->phy_param_set.fh_param_set, + fh_param_set, +sizeof (struct ieee_types_fh_param_set )); +break ; + +case WLAN_EID_DS_PARAMS : +if (total_ie_len <sizeof (*ds_param_set)) +return -EINVAL ; + ds_param_set = + (struct ieee_types_ds_param_set *)current_ptr; + + bss_entry->channel = ds_param_set->current_chan; + +memcpy (&bss_entry->phy_param_set.ds_param_set, + ds_param_set, +sizeof (struct ieee_types_ds_param_set )); +break ; + +case WLAN_EID_CF_PARAMS : +if (total_ie_len <sizeof (*cf_param_set)) +return -EINVAL ; + cf_param_set = + (struct ieee_types_cf_param_set *)current_ptr; +memcpy (&bss_entry->ss_param_set.cf_param_set, + cf_param_set, +sizeof (struct ieee_types_cf_param_set )); +break ; + +case WLAN_EID_IBSS_PARAMS : +if (total_ie_len <sizeof (*ibss_param_set)) +return -EINVAL ; + ibss_param_set = + (struct ieee_types_ibss_param_set *) + current_ptr; +memcpy (&bss_entry->ss_param_set.ibss_param_set, + ibss_param_set, +sizeof (struct ieee_types_ibss_param_set )); +break ; + +case WLAN_EID_ERP_INFO : +if (!element_len) +return -EINVAL ; + bss_entry->erp_flags = *(current_ptr +2 ); +break ; + +case WLAN_EID_PWR_CONSTRAINT : +if (!element_len) +return -EINVAL ; + bss_entry->local_constraint = *(current_ptr +2 ); + bss_entry->sensed_11h = true; +break ; + +case WLAN_EID_CHANNEL_SWITCH : + bss_entry->chan_sw_ie_present = true; + fallthrough; +case WLAN_EID_PWR_CAPABILITY : +case WLAN_EID_TPC_REPORT : +case WLAN_EID_QUIET : + bss_entry->sensed_11h = true; +break ; + +case WLAN_EID_EXT_SUPP_RATES : +/* Only process extended supported rate +* if data rate is already found. +* Data rate IE should come before +* extended supported rate IE +*/ +if (found_data_rate_ie) { +if ((element_len + rate_size) > +NXPWIFI_SUPPORTED_RATES ) + bytes_to_copy = + (NXPWIFI_SUPPORTED_RATES - + rate_size); +else + bytes_to_copy = element_len; + + rate = (u8 *)bss_entry->data_rates; + rate += rate_size; +memcpy (rate, current_ptr +2 , bytes_to_copy); + + rate = (u8 *)bss_entry->supported_rates; + rate += rate_size; +memcpy (rate, current_ptr +2 , bytes_to_copy); + } +break ; + +case WLAN_EID_VENDOR_SPECIFIC : + vendor_ie = (struct ieee_types_vendor_specific *) + current_ptr; + +/* 802.11 requires at least 3-byte OUI. */ +if (element_len <sizeof (vendor_ie->vend_hdr.oui.oui)) +return -EINVAL ; + +/* Not long enough for a match? Skip it. */ +if (element_len <sizeof (wpa_oui)) +break ; + +if (!memcmp (&vendor_ie->vend_hdr.oui, wpa_oui, +sizeof (wpa_oui))) { + bss_entry->bcn_wpa_ie = + (struct ieee_types_vendor_specific *) + current_ptr; + bss_entry->wpa_offset = (u16) + (current_ptr - bss_entry->beacon_buf); + }else if (!memcmp (&vendor_ie->vend_hdr.oui, wmm_oui, +sizeof (wmm_oui))) { +if (total_ie_len == +sizeof (struct ieee_types_wmm_parameter ) || + total_ie_len == +sizeof (struct ieee_types_wmm_info )) +/* Only accept and copy the WMM IE if +* it matches the size expected for the +* WMM Info IE or the WMM Parameter IE. +*/ +memcpy ((u8 *)&bss_entry->wmm_ie, + current_ptr, total_ie_len); + } +break ; +case WLAN_EID_RSN : + bss_entry->bcn_rsn_ie = + (struct ieee_types_generic *)current_ptr; + bss_entry->rsn_offset = (u16)(current_ptr - + bss_entry->beacon_buf); +break ; +case WLAN_EID_RSNX : + bss_entry->bcn_rsnx_ie = + (struct ieee_types_generic *)current_ptr; + bss_entry->rsnx_offset = + (u16)(current_ptr - bss_entry->beacon_buf); +break ; +case WLAN_EID_HT_CAPABILITY : + bss_entry->bcn_ht_cap = (struct ieee80211_ht_cap *) + (current_ptr + +sizeof (struct ieee_types_header )); + bss_entry->ht_cap_offset = (u16)(current_ptr + +sizeof (struct ieee_types_header ) - + bss_entry->beacon_buf); +break ; +case WLAN_EID_HT_OPERATION : + bss_entry->bcn_ht_oper = + (struct ieee80211_ht_operation *)(current_ptr + +sizeof (struct ieee_types_header )); + bss_entry->ht_info_offset = (u16)(current_ptr + +sizeof (struct ieee_types_header ) - + bss_entry->beacon_buf); +break ; +case WLAN_EID_VHT_CAPABILITY : + bss_entry->disable_11ac = false; + bss_entry->bcn_vht_cap = + (void *)(current_ptr + +sizeof (struct ieee_types_header )); + bss_entry->vht_cap_offset = + (u16)((u8 *)bss_entry->bcn_vht_cap - + bss_entry->beacon_buf); +break ; +case WLAN_EID_VHT_OPERATION : + bss_entry->bcn_vht_oper = + (void *)(current_ptr + +sizeof (struct ieee_types_header )); + bss_entry->vht_info_offset = + (u16)((u8 *)bss_entry->bcn_vht_oper - + bss_entry->beacon_buf); +break ; +case WLAN_EID_BSS_COEX_2040 : + bss_entry->bcn_bss_co_2040 = current_ptr; + bss_entry->bss_co_2040_offset = + (u16)(current_ptr - bss_entry->beacon_buf); +break ; +case WLAN_EID_EXT_CAPABILITY : + bss_entry->bcn_ext_cap = current_ptr; + bss_entry->ext_cap_offset = + (u16)(current_ptr - bss_entry->beacon_buf); +break ; +case WLAN_EID_OPMODE_NOTIF : + bss_entry->oper_mode = (void *)current_ptr; + bss_entry->oper_mode_offset = + (u16)((u8 *)bss_entry->oper_mode - + bss_entry->beacon_buf); +break ; +default : +break ; + } + + current_ptr += total_ie_len; + bytes_left -= total_ie_len; + + }/* while (bytes_left > 2) */ +return 0 ; +} + +/* This function converts radio type scan parameter to a band configuration +* to be used in join command. +*/ +static u8 +nxpwifi_radio_type_to_band (u8 radio_type) +{ +switch (radio_type) { +case HOST_SCAN_RADIO_TYPE_A : +return BAND_A ; +case HOST_SCAN_RADIO_TYPE_BG : +default : +return BAND_G ; + } +} + +/* This is an internal function used to start a scan based on an input +* configuration. +* +* This uses the input user scan configuration information when provided in +* order to send the appropriate scan commands to firmware to populate or +* update the internal driver scan table. +*/ +int nxpwifi_scan_networks (struct nxpwifi_private *priv, +const struct nxpwifi_user_scan_cfg *user_scan_in) +{ +int ret; +struct nxpwifi_adapter *adapter = priv->adapter; +struct cmd_ctrl_node *cmd_node; +union nxpwifi_scan_cmd_config_tlv *scan_cfg_out; +struct nxpwifi_ie_types_chan_list_param_set *chan_list_out; +struct nxpwifi_chan_scan_param_set *scan_chan_list; +u8 filtered_scan; +u8 scan_current_chan_only; +u8 max_chan_per_scan; + +if (adapter->scan_processing) { +nxpwifi_dbg (adapter,WARN , +"cmd: Scan already in process...\n" ); +return -EBUSY ; + } + +if (priv->scan_block) { +nxpwifi_dbg (adapter,WARN , +"cmd: Scan is blocked during association...\n" ); +return -EBUSY ; + } + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags) || +test_bit (NXPWIFI_IS_CMD_TIMEDOUT , &adapter->work_flags)) { +nxpwifi_dbg (adapter,ERROR , +"Ignore scan. Card removed or firmware in bad state\n" ); +return -EFAULT ; + } + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->scan_processing = true; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + + scan_cfg_out =kzalloc (sizeof (union nxpwifi_scan_cmd_config_tlv ), +GFP_KERNEL ); +if (!scan_cfg_out) { + ret = -ENOMEM ; + goto done; + } + + scan_chan_list =kcalloc (NXPWIFI_USER_SCAN_CHAN_MAX , +sizeof (struct nxpwifi_chan_scan_param_set ), +GFP_KERNEL ); +if (!scan_chan_list) { +kfree (scan_cfg_out); + ret = -ENOMEM ; + goto done; + } + +nxpwifi_config_scan (priv, user_scan_in, &scan_cfg_out->config, + &chan_list_out, scan_chan_list, &max_chan_per_scan, + &filtered_scan, &scan_current_chan_only); + + ret =nxpwifi_scan_channel_list (priv, max_chan_per_scan, filtered_scan, + &scan_cfg_out->config, chan_list_out, + scan_chan_list); + +/* Get scan command from scan_pending_q and put to cmd_pending_q */ +if (!ret) { +spin_lock_bh (&adapter->scan_pending_q_lock); +if (!list_empty (&adapter->scan_pending_q)) { + cmd_node =list_first_entry (&adapter->scan_pending_q, + struct cmd_ctrl_node, list); +list_del (&cmd_node->list); +spin_unlock_bh (&adapter->scan_pending_q_lock); +nxpwifi_insert_cmd_to_pending_q (adapter, cmd_node); +queue_work (adapter->workqueue, &adapter->main_work); + +/* Perform internal scan synchronously */ +if (!priv->scan_request) { +nxpwifi_dbg (adapter,INFO , +"wait internal scan\n" ); +nxpwifi_wait_queue_complete (adapter, cmd_node); + } + }else { +spin_unlock_bh (&adapter->scan_pending_q_lock); + } + } + +kfree (scan_cfg_out); +kfree (scan_chan_list); +done: +if (ret) { +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->scan_processing = false; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + } +return ret; +} + +/* This function prepares a scan command to be sent to the firmware. +* +* This uses the scan command configuration sent to the command processing +* module in command preparation stage to configure a scan command structure +* to send to firmware. +* +* The fixed fields specifying the BSS type and BSSID filters as well as a +* variable number/length of TLVs are sent in the command to firmware. +* +* Preparation also includes - +* - Setting command ID, and proper size +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_802_11_scan (struct host_cmd_ds_command *cmd, +struct nxpwifi_scan_cmd_config *scan_cfg) +{ +struct host_cmd_ds_802_11_scan *scan_cmd = &cmd->params.scan; + +/* Set fixed field variables in scan command */ + scan_cmd->bss_mode = scan_cfg->bss_mode; +memcpy (scan_cmd->bssid, scan_cfg->specific_bssid, +sizeof (scan_cmd->bssid)); +memcpy (scan_cmd->tlv_buffer, scan_cfg->tlv_buf, scan_cfg->tlv_buf_len); + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_SCAN ); + +/* Size is equal to the sizeof(fixed portions) + the TLV len + header */ + cmd->size =cpu_to_le16 ((u16)(sizeof (scan_cmd->bss_mode) + +sizeof (scan_cmd->bssid) + + scan_cfg->tlv_buf_len +S_DS_GEN )); + +return 0 ; +} + +/* This function checks compatibility of requested network with current +* driver settings. +*/ +int nxpwifi_check_network_compatibility (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +int ret =-1 ; + +if (!bss_desc) +return -1 ; + +if ((nxpwifi_get_cfp (priv, (u8 )bss_desc->bss_band, + (u16 )bss_desc->channel,0 ))) { +switch (priv->bss_mode) { +case NL80211_IFTYPE_STATION : + ret =nxpwifi_is_network_compatible (priv, bss_desc, + priv->bss_mode); +if (ret) +nxpwifi_dbg (priv->adapter,ERROR , +"Incompatible network settings\n" ); +break ; +default : + ret =0 ; + } + } + +return ret; +} + +/* This function checks if SSID string contains all zeroes or length is zero */ +static bool nxpwifi_is_hidden_ssid (struct cfg80211_ssid *ssid) +{ +int idx; + +for (idx =0 ; idx < ssid->ssid_len; idx++) { +if (ssid->ssid[idx]) +return false; + } + +return true; +} + +/* This function checks if any hidden SSID found in passive scan channels +* and save those channels for specific SSID active scan +*/ +static int nxpwifi_save_hidden_ssid_channels (struct nxpwifi_private *priv, +struct cfg80211_bss *bss) +{ +struct nxpwifi_bssdescriptor *bss_desc; +int ret; +int chid; + +/* Allocate and fill new bss descriptor */ + bss_desc =kzalloc (sizeof (*bss_desc),GFP_KERNEL ); +if (!bss_desc) +return -ENOMEM ; + + ret =nxpwifi_fill_new_bss_desc (priv, bss, bss_desc); +if (ret) + goto done; + +if (nxpwifi_is_hidden_ssid (&bss_desc->ssid)) { +nxpwifi_dbg (priv->adapter,INFO ,"found hidden SSID\n" ); +for (chid =0 ; chid <NXPWIFI_USER_SCAN_CHAN_MAX ; chid++) { +if (priv->hidden_chan[chid].chan_number == + bss->channel->hw_value) +break ; + +if (!priv->hidden_chan[chid].chan_number) { + priv->hidden_chan[chid].chan_number = + bss->channel->hw_value; + priv->hidden_chan[chid].radio_type = + bss->channel->band; + priv->hidden_chan[chid].scan_type = +NXPWIFI_SCAN_TYPE_ACTIVE ; +break ; + } + } + } + +done: +/* beacon_ie buffer was allocated in function +* nxpwifi_fill_new_bss_desc(). Free it now. +*/ +kfree (bss_desc->beacon_buf); +kfree (bss_desc); +return 0 ; +} + +static int nxpwifi_update_curr_bss_params (struct nxpwifi_private *priv, +struct cfg80211_bss *bss) +{ +struct nxpwifi_bssdescriptor *bss_desc; +int ret; + +/* Allocate and fill new bss descriptor */ + bss_desc =kzalloc (sizeof (*bss_desc),GFP_KERNEL ); +if (!bss_desc) +return -ENOMEM ; + + ret =nxpwifi_fill_new_bss_desc (priv, bss, bss_desc); +if (ret) + goto done; + + ret =nxpwifi_check_network_compatibility (priv, bss_desc); +if (ret) + goto done; + +spin_lock_bh (&priv->curr_bcn_buf_lock); +/* Make a copy of current BSSID descriptor */ +memcpy (&priv->curr_bss_params.bss_descriptor, bss_desc, +sizeof (priv->curr_bss_params.bss_descriptor)); + +/* The contents of beacon_ie will be copied to its own buffer +* in nxpwifi_save_curr_bcn() +*/ +nxpwifi_save_curr_bcn (priv); +spin_unlock_bh (&priv->curr_bcn_buf_lock); + +done: +/* beacon_ie buffer was allocated in function +* nxpwifi_fill_new_bss_desc(). Free it now. +*/ +kfree (bss_desc->beacon_buf); +kfree (bss_desc); +return 0 ; +} + +static int +nxpwifi_parse_single_response_buf (struct nxpwifi_private *priv,u8 **bss_info, +u32 *bytes_left,u64 fw_tsf,u8 *radio_type, +bool ext_scan,s32 rssi_val) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_chan_freq_power *cfp; +struct cfg80211_bss *bss; +u8 bssid[ETH_ALEN ]; +s32 rssi; +const u8 *ie_buf; +size_t ie_len; +u16 channel =0 ; +u16 beacon_size =0 ; +u32 curr_bcn_bytes; +u32 freq; +u16 beacon_period; +u16 cap_info_bitmap; +u8 *current_ptr; +u64 timestamp; +struct nxpwifi_fixed_bcn_param *bcn_param; +struct nxpwifi_bss_priv *bss_priv; + +if (*bytes_left >=sizeof (beacon_size)) { +/* Extract & convert beacon size from command buffer */ + beacon_size =get_unaligned_le16 ((*bss_info)); + *bytes_left -=sizeof (beacon_size); + *bss_info +=sizeof (beacon_size); + } + +if (!beacon_size || beacon_size > *bytes_left) { + *bss_info += *bytes_left; + *bytes_left =0 ; +return -EFAULT ; + } + +/* Initialize the current working beacon pointer for this BSS +* iteration +*/ + current_ptr = *bss_info; + +/* Advance the return beacon pointer past the current beacon */ + *bss_info += beacon_size; + *bytes_left -= beacon_size; + + curr_bcn_bytes = beacon_size; + +/* First 5 fields are bssid, RSSI(for legacy scan only), +* time stamp, beacon interval, and capability information +*/ +if (curr_bcn_bytes <ETH_ALEN +sizeof (u8) + +sizeof (struct nxpwifi_fixed_bcn_param )) { +nxpwifi_dbg (adapter,ERROR , +"InterpretIE: not enough bytes left\n" ); +return -EFAULT ; + } + +memcpy (bssid, current_ptr,ETH_ALEN ); + current_ptr +=ETH_ALEN ; + curr_bcn_bytes -=ETH_ALEN ; + +if (!ext_scan) { + rssi = (s32)*current_ptr; + rssi = (-rssi) *100 ;/* Convert dBm to mBm */ + current_ptr +=sizeof (u8); + curr_bcn_bytes -=sizeof (u8); +nxpwifi_dbg (adapter,INFO , +"info: InterpretIE: RSSI=%d\n" , rssi); + }else { + rssi = rssi_val; + } + + bcn_param = (struct nxpwifi_fixed_bcn_param *)current_ptr; + current_ptr +=sizeof (*bcn_param); + curr_bcn_bytes -=sizeof (*bcn_param); + + timestamp =le64_to_cpu (bcn_param->timestamp); + beacon_period =le16_to_cpu (bcn_param->beacon_period); + + cap_info_bitmap =le16_to_cpu (bcn_param->cap_info_bitmap); +nxpwifi_dbg (adapter,INFO , +"info: InterpretIE: capabilities=0x%X\n" , + cap_info_bitmap); + +/* Rest of the current buffer are IE's */ + ie_buf = current_ptr; + ie_len = curr_bcn_bytes; +nxpwifi_dbg (adapter,INFO , +"info: InterpretIE: IELength for this AP = %d\n" , + curr_bcn_bytes); + +while (curr_bcn_bytes >=sizeof (struct ieee_types_header )) { +u8 element_id, element_len; + + element_id = *current_ptr; + element_len = *(current_ptr +1 ); +if (curr_bcn_bytes < element_len + +sizeof (struct ieee_types_header )) { +nxpwifi_dbg (adapter,ERROR , +"%s: bytes left < IE length\n" , __func__); +return -EFAULT ; + } +if (element_id ==WLAN_EID_DS_PARAMS ) { + channel = *(current_ptr + +sizeof (struct ieee_types_header )); +break ; + } + + current_ptr += element_len +sizeof (struct ieee_types_header ); + curr_bcn_bytes -= element_len + +sizeof (struct ieee_types_header ); + } + +if (channel) { +struct ieee80211_channel *chan; +struct nxpwifi_bssdescriptor *bss_desc; +u8 band; + +/* Skip entry if on csa closed channel */ +if (channel == priv->csa_chan) { +nxpwifi_dbg (adapter,WARN , +"Dropping entry on csa closed channel\n" ); +return 0 ; + } + + band =BAND_G ; +if (radio_type) + band =nxpwifi_radio_type_to_band (*radio_type & + (BIT (0 ) |BIT (1 ))); + + cfp =nxpwifi_get_cfp (priv, band, channel,0 ); + + freq = cfp ? cfp->freq :0 ; + + chan =ieee80211_get_channel (priv->wdev.wiphy, freq); + +if (chan && !(chan->flags &IEEE80211_CHAN_DISABLED )) { + bss =cfg80211_inform_bss (priv->wdev.wiphy, chan, +CFG80211_BSS_FTYPE_UNKNOWN , + bssid, timestamp, + cap_info_bitmap, + beacon_period, + ie_buf, ie_len, rssi, +GFP_ATOMIC ); +if (bss) { + bss_priv = (struct nxpwifi_bss_priv *)bss->priv; + bss_priv->band = band; + bss_priv->fw_tsf = fw_tsf; + bss_desc = + &priv->curr_bss_params.bss_descriptor; +if (priv->media_connected && + !memcmp (bssid, bss_desc->mac_address, +ETH_ALEN )) +nxpwifi_update_curr_bss_params (priv, + bss); + +if ((chan->flags &IEEE80211_CHAN_RADAR ) || + (chan->flags &IEEE80211_CHAN_NO_IR )) { +nxpwifi_dbg (adapter,INFO , +"radar or passive channel %d\n" , + channel); +nxpwifi_save_hidden_ssid_channels (priv, + bss); + } + +cfg80211_put_bss (priv->wdev.wiphy, bss); + } + } + }else { +nxpwifi_dbg (adapter,WARN ,"missing BSS channel IE\n" ); + } + +return 0 ; +} + +static void nxpwifi_complete_scan (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + + adapter->survey_idx =0 ; +if (adapter->curr_cmd->wait_q_enabled) { + adapter->cmd_wait_q.status =0 ; +if (!priv->scan_request) { +nxpwifi_dbg (adapter,INFO , +"complete internal scan\n" ); +nxpwifi_complete_cmd (adapter, adapter->curr_cmd); + } + } +} + +/* This function checks if any hidden SSID found in passive scan channels +* and do specific SSID active scan for those channels +*/ +static int +nxpwifi_active_scan_req_for_passive_chan (struct nxpwifi_private *priv) +{ +int ret; +struct nxpwifi_adapter *adapter = priv->adapter; +u8 id =0 ; +struct nxpwifi_user_scan_cfg *user_scan_cfg; + +if (adapter->active_scan_triggered || !priv->scan_request || + priv->scan_aborting) { + adapter->active_scan_triggered = false; +return 0 ; + } + +if (!priv->hidden_chan[0 ].chan_number) { +nxpwifi_dbg (adapter,INFO ,"No BSS with hidden SSID found on DFS channels\n" ); +return 0 ; + } + user_scan_cfg =kzalloc (sizeof (*user_scan_cfg),GFP_KERNEL ); + +if (!user_scan_cfg) +return -ENOMEM ; + +for (id =0 ; id <NXPWIFI_USER_SCAN_CHAN_MAX ; id++) { +if (!priv->hidden_chan[id].chan_number) +break ; +memcpy (&user_scan_cfg->chan_list[id], + &priv->hidden_chan[id], +sizeof (struct nxpwifi_user_scan_chan )); + } + + adapter->active_scan_triggered = true; +if (priv->scan_request->flags &NL80211_SCAN_FLAG_RANDOM_ADDR ) +ether_addr_copy (user_scan_cfg->random_mac, + priv->scan_request->mac_addr); + user_scan_cfg->num_ssids = priv->scan_request->n_ssids; + user_scan_cfg->ssid_list = priv->scan_request->ssids; + + ret =nxpwifi_scan_networks (priv, user_scan_cfg); +kfree (user_scan_cfg); + +memset (&priv->hidden_chan,0 ,sizeof (priv->hidden_chan)); + +if (ret) { +dev_err (priv->adapter->dev,"scan failed: %d\n" , ret); +return ret; + } + +return 0 ; +} + +static void nxpwifi_check_next_scan_command (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct cmd_ctrl_node *cmd_node; + +spin_lock_bh (&adapter->scan_pending_q_lock); +if (list_empty (&adapter->scan_pending_q)) { +spin_unlock_bh (&adapter->scan_pending_q_lock); + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->scan_processing = false; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + +nxpwifi_active_scan_req_for_passive_chan (priv); + +if (!adapter->ext_scan) +nxpwifi_complete_scan (priv); + +if (priv->scan_request) { +struct cfg80211_scan_info info = { + .aborted = false, + }; + +nxpwifi_dbg (adapter,INFO , +"info: notifying scan done\n" ); +cfg80211_scan_done (priv->scan_request, &info); + priv->scan_request =NULL ; + priv->scan_aborting = false; + }else { + priv->scan_aborting = false; +nxpwifi_dbg (adapter,INFO , +"info: scan already aborted\n" ); + } + }else if ((priv->scan_aborting && !priv->scan_request) || + priv->scan_block) { +spin_unlock_bh (&adapter->scan_pending_q_lock); + +nxpwifi_cancel_pending_scan_cmd (adapter); + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->scan_processing = false; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + +if (!adapter->active_scan_triggered) { +if (priv->scan_request) { +struct cfg80211_scan_info info = { + .aborted = true, + }; + +nxpwifi_dbg (adapter,INFO , +"info: aborting scan\n" ); +cfg80211_scan_done (priv->scan_request, &info); + priv->scan_request =NULL ; + priv->scan_aborting = false; + }else { + priv->scan_aborting = false; +nxpwifi_dbg (adapter,INFO , +"info: scan already aborted\n" ); + } + } + }else { +/* Get scan command from scan_pending_q and put to +* cmd_pending_q +*/ + cmd_node =list_first_entry (&adapter->scan_pending_q, + struct cmd_ctrl_node, list); +list_del (&cmd_node->list); +spin_unlock_bh (&adapter->scan_pending_q_lock); +nxpwifi_insert_cmd_to_pending_q (adapter, cmd_node); + } +} + +void nxpwifi_cancel_scan (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +int i; + +nxpwifi_cancel_pending_scan_cmd (adapter); + +if (adapter->scan_processing) { +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->scan_processing = false; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (!priv) +continue ; +if (priv->scan_request) { +struct cfg80211_scan_info info = { + .aborted = true, + }; + +nxpwifi_dbg (adapter,INFO , +"info: aborting scan\n" ); +cfg80211_scan_done (priv->scan_request, &info); + priv->scan_request =NULL ; + priv->scan_aborting = false; + } + } + } +} + +/* This function handles the command response of scan. +* +* The response buffer for the scan command has the following +* memory layout: +* +* .-------------------------------------------------------------. +* | Header (4 * sizeof(t_u16)): Standard command response hdr | +* .-------------------------------------------------------------. +* | BufSize (t_u16) : sizeof the BSS Description data | +* .-------------------------------------------------------------. +* | NumOfSet (t_u8) : Number of BSS Descs returned | +* .-------------------------------------------------------------. +* | BSSDescription data (variable, size given in BufSize) | +* .-------------------------------------------------------------. +* | TLV data (variable, size calculated using Header->Size, | +* | BufSize and sizeof the fixed fields above) | +* .-------------------------------------------------------------. +*/ +int nxpwifi_ret_802_11_scan (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +int ret =0 ; +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_802_11_scan_rsp *scan_rsp; +struct nxpwifi_ie_types_data *tlv_data; +struct nxpwifi_ie_types_tsf_timestamp *tsf_tlv; +u8 *bss_info; +u32 scan_resp_size; +u32 bytes_left; +u32 idx; +u32 tlv_buf_size; +struct nxpwifi_ie_types_chan_band_list_param_set *chan_band_tlv; +struct chan_band_param_set *chan_band; +u8 is_bgscan_resp; +__le64 fw_tsf =0 ; +u8 *radio_type; +struct cfg80211_wowlan_nd_match *pmatch; +struct cfg80211_sched_scan_request *nd_config =NULL ; + + is_bgscan_resp = (le16_to_cpu (resp->command) + ==HOST_CMD_802_11_BG_SCAN_QUERY ); +if (is_bgscan_resp) + scan_rsp = &resp->params.bg_scan_query_resp.scan_resp; +else + scan_rsp = &resp->params.scan_resp; + +if (scan_rsp->number_of_sets >NXPWIFI_MAX_AP ) { +nxpwifi_dbg (adapter,ERROR , +"SCAN_RESP: too many AP returned (%d)\n" , + scan_rsp->number_of_sets); + ret =-1 ; + goto check_next_scan; + } + +/* Check csa channel expiry before parsing scan response */ +nxpwifi_11h_get_csa_closed_channel (priv); + + bytes_left =le16_to_cpu (scan_rsp->bss_descript_size); +nxpwifi_dbg (adapter,INFO , +"info: SCAN_RESP: bss_descript_size %d\n" , + bytes_left); + + scan_resp_size =le16_to_cpu (resp->size); + +nxpwifi_dbg (adapter,INFO , +"info: SCAN_RESP: returned %d APs before parsing\n" , + scan_rsp->number_of_sets); + + bss_info = scan_rsp->bss_desc_and_tlv_buffer; + +/* The size of the TLV buffer is equal to the entire command response +* size (scan_resp_size) minus the fixed fields (sizeof()'s), the +* BSS Descriptions (bss_descript_size as bytesLef) and the command +* response header (S_DS_GEN) +*/ + tlv_buf_size = scan_resp_size - (bytes_left + +sizeof (scan_rsp->bss_descript_size) + +sizeof (scan_rsp->number_of_sets) + +S_DS_GEN ); + + tlv_data = (struct nxpwifi_ie_types_data *) + (scan_rsp->bss_desc_and_tlv_buffer + bytes_left); + +/* Search the TLV buffer space in the scan response for any valid +* TLVs +*/ +nxpwifi_ret_802_11_scan_get_tlv_ptrs (adapter, tlv_data, tlv_buf_size, +TLV_TYPE_TSFTIMESTAMP , + (struct nxpwifi_ie_types_data **) + &tsf_tlv); + +/* Search the TLV buffer space in the scan response for any valid +* TLVs +*/ +nxpwifi_ret_802_11_scan_get_tlv_ptrs (adapter, tlv_data, tlv_buf_size, +TLV_TYPE_CHANNELBANDLIST , + (struct nxpwifi_ie_types_data **) + &chan_band_tlv); + +#ifdef CONFIG_PM +if (priv->wdev.wiphy->wowlan_config) + nd_config = priv->wdev.wiphy->wowlan_config->nd_config; +#endif + +if (nd_config) { + adapter->nd_info = +kzalloc (struct_size (adapter->nd_info, matches, + scan_rsp->number_of_sets), +GFP_ATOMIC ); + +if (adapter->nd_info) + adapter->nd_info->n_matches = scan_rsp->number_of_sets; + } + +for (idx =0 ; idx < scan_rsp->number_of_sets && bytes_left; idx++) { +/* If the TSF TLV was appended to the scan results, save this +* entry's TSF value in the fw_tsf field. It is the firmware's +* TSF value at the time the beacon or probe response was +* received. +*/ +if (tsf_tlv) +memcpy (&fw_tsf, &tsf_tlv->tsf_data[idx *TSF_DATA_SIZE ], +sizeof (fw_tsf)); + +if (chan_band_tlv) { + chan_band = &chan_band_tlv->chan_band_param[idx]; + radio_type = &chan_band->radio_type; + }else { + radio_type =NULL ; + } + +if (chan_band_tlv && adapter->nd_info) { + adapter->nd_info->matches[idx] = +kzalloc (sizeof (*pmatch) +sizeof (u32), +GFP_ATOMIC ); + + pmatch = adapter->nd_info->matches[idx]; + +if (pmatch) { + pmatch->n_channels =1 ; + pmatch->channels[0 ] = chan_band->chan_number; + } + } + + ret =nxpwifi_parse_single_response_buf (priv, &bss_info, + &bytes_left, +le64_to_cpu (fw_tsf), + radio_type, false,0 ); +if (ret) + goto check_next_scan; + } + +check_next_scan: +nxpwifi_check_next_scan_command (priv); +return ret; +} + +/* This function prepares an extended scan command to be sent to the firmware +* +* This uses the scan command configuration sent to the command processing +* module in command preparation stage to configure a extended scan command +* structure to send to firmware. +*/ +int nxpwifi_cmd_802_11_scan_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +void *data_buf) +{ +struct host_cmd_ds_802_11_scan_ext *ext_scan = &cmd->params.ext_scan; +struct nxpwifi_scan_cmd_config *scan_cfg = data_buf; + +memcpy (ext_scan->tlv_buffer, scan_cfg->tlv_buf, scan_cfg->tlv_buf_len); + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_SCAN_EXT ); + +/* Size is equal to the sizeof(fixed portions) + the TLV len + header */ + cmd->size =cpu_to_le16 ((u16)(sizeof (ext_scan->reserved) + + scan_cfg->tlv_buf_len +S_DS_GEN )); + +return 0 ; +} + +/* This function prepares an background scan config command to be sent +* to the firmware +*/ +int nxpwifi_cmd_802_11_bg_scan_config (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +void *data_buf) +{ +struct host_cmd_ds_802_11_bg_scan_config *bgscan_config = + &cmd->params.bg_scan_config; +struct nxpwifi_bg_scan_cfg *bgscan_cfg_in = data_buf; +u8 *tlv_pos = bgscan_config->tlv; +u8 num_probes; +u32 ssid_len, chan_idx, scan_time, scan_type, scan_dur, chan_num; +int i; +struct nxpwifi_ie_types_num_probes *num_probes_tlv; +struct nxpwifi_ie_types_repeat_count *repeat_count_tlv; +struct nxpwifi_ie_types_min_rssi_threshold *rssi_threshold_tlv; +struct nxpwifi_ie_types_bgscan_start_later *start_later_tlv; +struct nxpwifi_ie_types_wildcard_ssid_params *wildcard_ssid_tlv; +struct nxpwifi_ie_types_chan_list_param_set *tlv_l; +struct nxpwifi_chan_scan_param_set *temp_chan; + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_BG_SCAN_CONFIG ); + cmd->size =cpu_to_le16 (sizeof (*bgscan_config) +S_DS_GEN ); + + bgscan_config->action =cpu_to_le16 (bgscan_cfg_in->action); + bgscan_config->enable = bgscan_cfg_in->enable; + bgscan_config->bss_type = bgscan_cfg_in->bss_type; + bgscan_config->scan_interval = +cpu_to_le32 (bgscan_cfg_in->scan_interval); + bgscan_config->report_condition = +cpu_to_le32 (bgscan_cfg_in->report_condition); + +/* stop sched scan */ +if (!bgscan_config->enable) +return 0 ; + + bgscan_config->chan_per_scan = bgscan_cfg_in->chan_per_scan; + + num_probes = (bgscan_cfg_in->num_probes ? + bgscan_cfg_in->num_probes : priv->adapter->scan_probes); + +if (num_probes) { + num_probes_tlv = (struct nxpwifi_ie_types_num_probes *)tlv_pos; + num_probes_tlv->header.type =cpu_to_le16 (TLV_TYPE_NUMPROBES ); + num_probes_tlv->header.len = +cpu_to_le16 (sizeof (num_probes_tlv->num_probes)); + num_probes_tlv->num_probes =cpu_to_le16 ((u16 )num_probes); + + tlv_pos +=sizeof (num_probes_tlv->header) + +le16_to_cpu (num_probes_tlv->header.len); + } + +if (bgscan_cfg_in->repeat_count) { + repeat_count_tlv = + (struct nxpwifi_ie_types_repeat_count *)tlv_pos; + repeat_count_tlv->header.type = +cpu_to_le16 (TLV_TYPE_REPEAT_COUNT ); + repeat_count_tlv->header.len = +cpu_to_le16 (sizeof (repeat_count_tlv->repeat_count)); + repeat_count_tlv->repeat_count = +cpu_to_le16 (bgscan_cfg_in->repeat_count); + + tlv_pos +=sizeof (repeat_count_tlv->header) + +le16_to_cpu (repeat_count_tlv->header.len); + } + +if (bgscan_cfg_in->rssi_threshold) { + rssi_threshold_tlv = + (struct nxpwifi_ie_types_min_rssi_threshold *)tlv_pos; + rssi_threshold_tlv->header.type = +cpu_to_le16 (TLV_TYPE_RSSI_LOW ); + rssi_threshold_tlv->header.len = +cpu_to_le16 (sizeof (rssi_threshold_tlv->rssi_threshold)); + rssi_threshold_tlv->rssi_threshold = +cpu_to_le16 (bgscan_cfg_in->rssi_threshold); + + tlv_pos +=sizeof (rssi_threshold_tlv->header) + +le16_to_cpu (rssi_threshold_tlv->header.len); + } + +for (i =0 ; i < bgscan_cfg_in->num_ssids; i++) { + ssid_len = bgscan_cfg_in->ssid_list[i].ssid.ssid_len; + + wildcard_ssid_tlv = + (struct nxpwifi_ie_types_wildcard_ssid_params *)tlv_pos; + wildcard_ssid_tlv->header.type = +cpu_to_le16 (TLV_TYPE_WILDCARDSSID ); + wildcard_ssid_tlv->header.len = +cpu_to_le16 ((u16)(ssid_len +sizeof (u8))); + +/* max_ssid_length = 0 tells firmware to perform +* specific scan for the SSID filled, whereas +* max_ssid_length = IEEE80211_MAX_SSID_LEN is for +* wildcard scan. +*/ +if (ssid_len) + wildcard_ssid_tlv->max_ssid_length =0 ; +else + wildcard_ssid_tlv->max_ssid_length = +IEEE80211_MAX_SSID_LEN ; + +memcpy (wildcard_ssid_tlv->ssid, + bgscan_cfg_in->ssid_list[i].ssid.ssid, ssid_len); + + tlv_pos += (sizeof (wildcard_ssid_tlv->header) + +le16_to_cpu (wildcard_ssid_tlv->header.len)); + } + + tlv_l = (struct nxpwifi_ie_types_chan_list_param_set *)tlv_pos; + +if (bgscan_cfg_in->chan_list[0 ].chan_number) { +dev_dbg (priv->adapter->dev,"info: bgscan: Using supplied channel list\n" ); + + tlv_l->header.type =cpu_to_le16 (TLV_TYPE_CHANLIST ); + +for (chan_idx =0 ; + chan_idx <NXPWIFI_BG_SCAN_CHAN_MAX && + bgscan_cfg_in->chan_list[chan_idx].chan_number; + chan_idx++) { + temp_chan = &tlv_l->chan_scan_param[chan_idx]; + +/* Increment the TLV header length by size appended */ +le16_unaligned_add_cpu (&tlv_l->header.len, +sizeof (*tlv_l->chan_scan_param)); + + temp_chan->chan_number = + bgscan_cfg_in->chan_list[chan_idx].chan_number; + temp_chan->radio_type = + bgscan_cfg_in->chan_list[chan_idx].radio_type; + + scan_type = + bgscan_cfg_in->chan_list[chan_idx].scan_type; + +if (scan_type ==NXPWIFI_SCAN_TYPE_PASSIVE ) + temp_chan->chan_scan_mode_bmap |= +NXPWIFI_PASSIVE_SCAN ; +else + temp_chan->chan_scan_mode_bmap &= + ~NXPWIFI_PASSIVE_SCAN ; + + scan_time = bgscan_cfg_in->chan_list[chan_idx].scan_time; + +if (scan_time) { + scan_dur = (u16 )scan_time; + }else { + scan_dur = (scan_type == +NXPWIFI_SCAN_TYPE_PASSIVE ) ? + priv->adapter->passive_scan_time : + priv->adapter->specific_scan_time; + } + + temp_chan->min_scan_time =cpu_to_le16 (scan_dur); + temp_chan->max_scan_time =cpu_to_le16 (scan_dur); + } + }else { +dev_dbg (priv->adapter->dev, +"info: bgscan: Creating full region channel list\n" ); + chan_num = +nxpwifi_bgscan_create_channel_list + (priv, bgscan_cfg_in, + tlv_l->chan_scan_param); +le16_unaligned_add_cpu (&tlv_l->header.len, + chan_num * +sizeof (*tlv_l->chan_scan_param)); + } + + tlv_pos += (sizeof (tlv_l->header) + +le16_to_cpu (tlv_l->header.len)); + +if (bgscan_cfg_in->start_later) { + start_later_tlv = + (struct nxpwifi_ie_types_bgscan_start_later *)tlv_pos; + start_later_tlv->header.type = +cpu_to_le16 (TLV_TYPE_BGSCAN_START_LATER ); + start_later_tlv->header.len = +cpu_to_le16 (sizeof (start_later_tlv->start_later)); + start_later_tlv->start_later = +cpu_to_le16 (bgscan_cfg_in->start_later); + + tlv_pos +=sizeof (start_later_tlv->header) + +le16_to_cpu (start_later_tlv->header.len); + } + +/* Append vendor specific IE TLV */ +nxpwifi_cmd_append_vsie_tlv (priv,NXPWIFI_VSIE_MASK_BGSCAN , &tlv_pos); + +le16_unaligned_add_cpu (&cmd->size, tlv_pos - bgscan_config->tlv); + +return 0 ; +} + +int nxpwifi_stop_bg_scan (struct nxpwifi_private *priv) +{ +struct nxpwifi_bg_scan_cfg *bgscan_cfg; + +if (!priv->sched_scanning) { +dev_dbg (priv->adapter->dev,"bgscan already stopped!\n" ); +return 0 ; + } + + bgscan_cfg =kzalloc (sizeof (*bgscan_cfg),GFP_KERNEL ); +if (!bgscan_cfg) +return -ENOMEM ; + + bgscan_cfg->bss_type =NXPWIFI_BSS_MODE_INFRA ; + bgscan_cfg->action =NXPWIFI_BGSCAN_ACT_SET ; + bgscan_cfg->enable = false; + +if (nxpwifi_send_cmd (priv,HOST_CMD_802_11_BG_SCAN_CONFIG , +HOST_ACT_GEN_SET ,0 , bgscan_cfg, true)) { +kfree (bgscan_cfg); +return -EFAULT ; + } + +kfree (bgscan_cfg); + priv->sched_scanning = false; + +return 0 ; +} + +static void +nxpwifi_update_chan_statistics (struct nxpwifi_private *priv, +struct nxpwifi_ietypes_chanstats *tlv_stat) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u8 i, num_chan; +struct nxpwifi_fw_chan_stats *fw_chan_stats; +struct nxpwifi_chan_stats chan_stats; + + fw_chan_stats = (void *)((u8 *)tlv_stat + +sizeof (struct nxpwifi_ie_types_header )); + num_chan =le16_to_cpu (tlv_stat->header.len) / +sizeof (struct nxpwifi_chan_stats ); + +for (i =0 ; i < num_chan; i++) { +if (adapter->survey_idx >= adapter->num_in_chan_stats) { +nxpwifi_dbg (adapter,WARN , +"FW reported too many channel results (max %d)\n" , + adapter->num_in_chan_stats); +return ; + } + chan_stats.chan_num = fw_chan_stats->chan_num; + chan_stats.bandcfg = fw_chan_stats->bandcfg; + chan_stats.flags = fw_chan_stats->flags; + chan_stats.noise = fw_chan_stats->noise; + chan_stats.total_bss =le16_to_cpu (fw_chan_stats->total_bss); + chan_stats.cca_scan_dur = +le16_to_cpu (fw_chan_stats->cca_scan_dur); + chan_stats.cca_busy_dur = +le16_to_cpu (fw_chan_stats->cca_busy_dur); +nxpwifi_dbg (adapter,INFO , +"chan=%d, noise=%d, total_network=%d scan_duration=%d, busy_duration=%d\n" , + chan_stats.chan_num, + chan_stats.noise, + chan_stats.total_bss, + chan_stats.cca_scan_dur, + chan_stats.cca_busy_dur); +memcpy (&adapter->chan_stats[adapter->survey_idx++], &chan_stats, +sizeof (struct nxpwifi_chan_stats )); + fw_chan_stats++; + } +} + +/* This function handles the command response of extended scan */ +int nxpwifi_ret_802_11_scan_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_802_11_scan_ext *ext_scan_resp; +struct nxpwifi_ie_types_header *tlv; +struct nxpwifi_ietypes_chanstats *tlv_stat; +u16 buf_left, type, len; + +struct host_cmd_ds_command *cmd_ptr; +struct cmd_ctrl_node *cmd_node; +bool complete_scan = false; + +nxpwifi_dbg (adapter,INFO ,"info: EXT scan returns successfully\n" ); + + ext_scan_resp = &resp->params.ext_scan; + + tlv = (void *)ext_scan_resp->tlv_buffer; + buf_left =le16_to_cpu (resp->size) - (sizeof (*ext_scan_resp) +S_DS_GEN + -1 ); + +while (buf_left >=sizeof (struct nxpwifi_ie_types_header )) { + type =le16_to_cpu (tlv->type); + len =le16_to_cpu (tlv->len); + +if (buf_left < (sizeof (struct nxpwifi_ie_types_header ) + len)) { +nxpwifi_dbg (adapter,ERROR , +"error processing scan response TLVs" ); +break ; + } + +switch (type) { +case TLV_TYPE_CHANNEL_STATS : + tlv_stat = (void *)tlv; +nxpwifi_update_chan_statistics (priv, tlv_stat); +break ; +default : +break ; + } + + buf_left -= len +sizeof (struct nxpwifi_ie_types_header ); + tlv = (void *)((u8 *)tlv + len + +sizeof (struct nxpwifi_ie_types_header )); + } + +spin_lock_bh (&adapter->cmd_pending_q_lock); +spin_lock_bh (&adapter->scan_pending_q_lock); +if (list_empty (&adapter->scan_pending_q)) { + complete_scan = true; +list_for_each_entry (cmd_node, &adapter->cmd_pending_q, list) { + cmd_ptr = (void *)cmd_node->cmd_skb->data; +if (le16_to_cpu (cmd_ptr->command) == +HOST_CMD_802_11_SCAN_EXT ) { +nxpwifi_dbg (adapter,INFO , +"Scan pending in command pending list" ); + complete_scan = false; +break ; + } + } + } +spin_unlock_bh (&adapter->scan_pending_q_lock); +spin_unlock_bh (&adapter->cmd_pending_q_lock); + +if (complete_scan) +nxpwifi_complete_scan (priv); + +return 0 ; +} + +/* This function This function handles the event extended scan report. It +* parses extended scan results and informs to cfg80211 stack. +*/ +int nxpwifi_handle_event_ext_scan_report (struct nxpwifi_private *priv, +void *buf) +{ +int ret =0 ; +struct nxpwifi_adapter *adapter = priv->adapter; +u8 *bss_info; +u32 bytes_left, bytes_left_for_tlv, idx; +u16 type, len; +struct nxpwifi_ie_types_data *tlv; +struct nxpwifi_ie_types_bss_scan_rsp *scan_rsp_tlv; +struct nxpwifi_ie_types_bss_scan_info *scan_info_tlv; +u8 *radio_type; +u64 fw_tsf =0 ; +s32 rssi =0 ; +struct nxpwifi_event_scan_result *event_scan = buf; +u8 num_of_set = event_scan->num_of_set; +u8 *scan_resp = buf +sizeof (struct nxpwifi_event_scan_result ); +u16 scan_resp_size =le16_to_cpu (event_scan->buf_size); + +if (num_of_set >NXPWIFI_MAX_AP ) { +nxpwifi_dbg (adapter,ERROR , +"EXT_SCAN: Invalid number of AP returned (%d)!!\n" , + num_of_set); + ret =-1 ; + goto check_next_scan; + } + + bytes_left = scan_resp_size; +nxpwifi_dbg (adapter,INFO , +"EXT_SCAN: size %d, returned %d APs..." , + scan_resp_size, num_of_set); +nxpwifi_dbg_dump (adapter,CMD_D ,"EXT_SCAN buffer:" , buf, + scan_resp_size + +sizeof (struct nxpwifi_event_scan_result )); + + tlv = (struct nxpwifi_ie_types_data *)scan_resp; + +for (idx =0 ; idx < num_of_set && bytes_left; idx++) { + type =le16_to_cpu (tlv->header.type); + len =le16_to_cpu (tlv->header.len); +if (bytes_left <sizeof (struct nxpwifi_ie_types_header ) + len) { +nxpwifi_dbg (adapter,ERROR , +"EXT_SCAN: Error bytes left < TLV length\n" ); +break ; + } + scan_rsp_tlv =NULL ; + scan_info_tlv =NULL ; + bytes_left_for_tlv = bytes_left; + +/* BSS response TLV with beacon or probe response buffer +* at the initial position of each descriptor +*/ +if (type !=TLV_TYPE_BSS_SCAN_RSP ) +break ; + + bss_info = (u8 *)tlv; + scan_rsp_tlv = (struct nxpwifi_ie_types_bss_scan_rsp *)tlv; + tlv = (struct nxpwifi_ie_types_data *)(tlv->data + len); + bytes_left_for_tlv -= + (len +sizeof (struct nxpwifi_ie_types_header )); + +while (bytes_left_for_tlv >= +sizeof (struct nxpwifi_ie_types_header ) && +le16_to_cpu (tlv->header.type) !=TLV_TYPE_BSS_SCAN_RSP ) { + type =le16_to_cpu (tlv->header.type); + len =le16_to_cpu (tlv->header.len); +if (bytes_left_for_tlv < +sizeof (struct nxpwifi_ie_types_header ) + len) { +nxpwifi_dbg (adapter,ERROR , +"EXT_SCAN: Error in processing TLV,\t" +"bytes left < TLV length\n" ); + scan_rsp_tlv =NULL ; + bytes_left_for_tlv =0 ; +continue ; + } +switch (type) { +case TLV_TYPE_BSS_SCAN_INFO : + scan_info_tlv = + (struct nxpwifi_ie_types_bss_scan_info *)tlv; +if (len != +sizeof (struct nxpwifi_ie_types_bss_scan_info ) - +sizeof (struct nxpwifi_ie_types_header )) { + bytes_left_for_tlv =0 ; +continue ; + } +break ; +default : +break ; + } + tlv = (struct nxpwifi_ie_types_data *)(tlv->data + len); + bytes_left -= + (len +sizeof (struct nxpwifi_ie_types_header )); + bytes_left_for_tlv -= + (len +sizeof (struct nxpwifi_ie_types_header )); + } + +if (!scan_rsp_tlv) +break ; + +/* Advance pointer to the beacon buffer length and +* update the bytes count so that the function +* wlan_interpret_bss_desc_with_ie() can handle the +* scan buffer withut any change +*/ + bss_info +=sizeof (u16); + bytes_left -=sizeof (u16); + +if (scan_info_tlv) { + rssi = (s32)(s16)(le16_to_cpu (scan_info_tlv->rssi)); + rssi *=100 ;/* Convert dBm to mBm */ +nxpwifi_dbg (adapter,INFO , +"info: InterpretIE: RSSI=%d\n" , rssi); + fw_tsf =le64_to_cpu (scan_info_tlv->tsf); + radio_type = &scan_info_tlv->radio_type; + }else { + radio_type =NULL ; + } + ret =nxpwifi_parse_single_response_buf (priv, &bss_info, + &bytes_left, fw_tsf, + radio_type, true, rssi); +if (ret) + goto check_next_scan; + } + +check_next_scan: +if (!event_scan->more_event) +nxpwifi_check_next_scan_command (priv); + +return ret; +} + +/* This function prepares command for background scan query. +* +* Preparation includes - +* - Setting command ID and proper size +* - Setting background scan flush parameter +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_802_11_bg_scan_query (struct host_cmd_ds_command *cmd) +{ +struct host_cmd_ds_802_11_bg_scan_query *bg_query = + &cmd->params.bg_scan_query; + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_BG_SCAN_QUERY ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_802_11_bg_scan_query ) + +S_DS_GEN ); + + bg_query->flush =1 ; + +return 0 ; +} + +/* This function inserts scan command node to the scan pending queue. +*/ +void +nxpwifi_queue_scan_cmd (struct nxpwifi_private *priv, +struct cmd_ctrl_node *cmd_node) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + + cmd_node->wait_q_enabled = true; + cmd_node->condition = &adapter->scan_wait_q_woken; +spin_lock_bh (&adapter->scan_pending_q_lock); +list_add_tail (&cmd_node->list, &adapter->scan_pending_q); +spin_unlock_bh (&adapter->scan_pending_q_lock); +} + +/* This function sends a scan command for all available channels to the +* firmware, filtered on a specific SSID. +*/ +static int nxpwifi_scan_specific_ssid (struct nxpwifi_private *priv, +struct cfg80211_ssid *req_ssid) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret; +struct nxpwifi_user_scan_cfg *scan_cfg; + +if (adapter->scan_processing) { +nxpwifi_dbg (adapter,WARN , +"cmd: Scan already in process...\n" ); +return -EBUSY ; + } + +if (priv->scan_block) { +nxpwifi_dbg (adapter,WARN , +"cmd: Scan is blocked during association...\n" ); +return -EBUSY ; + } + + scan_cfg =kzalloc (sizeof (*scan_cfg),GFP_KERNEL ); +if (!scan_cfg) +return -ENOMEM ; + + scan_cfg->ssid_list = req_ssid; + scan_cfg->num_ssids =1 ; + + ret =nxpwifi_scan_networks (priv, scan_cfg); + +kfree (scan_cfg); +return ret; +} + +/* Sends IOCTL request to start a scan. +* +* This function allocates the IOCTL request buffer, fills it +* with requisite parameters and calls the IOCTL handler. +* +* Scan command can be issued for both normal scan and specific SSID +* scan, depending upon whether an SSID is provided or not. +*/ +int nxpwifi_request_scan (struct nxpwifi_private *priv, +struct cfg80211_ssid *req_ssid) +{ +int ret; + +if (mutex_lock_interruptible (&priv->async_mutex)) { +nxpwifi_dbg (priv->adapter,ERROR , +"%s: acquire semaphore fail\n" , + __func__); +return -1 ; + } + + priv->adapter->scan_wait_q_woken = false; + +if (req_ssid && req_ssid->ssid_len !=0 ) +/* Specific SSID scan */ + ret =nxpwifi_scan_specific_ssid (priv, req_ssid); +else +/* Normal scan */ + ret =nxpwifi_scan_networks (priv,NULL ); + +mutex_unlock (&priv->async_mutex); + +return ret; +} + +/* This function appends the vendor specific IE TLV to a buffer. +*/ +int +nxpwifi_cmd_append_vsie_tlv (struct nxpwifi_private *priv, +u16 vsie_mask,u8 **buffer) +{ +int id, ret_len =0 ; +struct nxpwifi_ie_types_vendor_param_set *vs_param_set; + +if (!buffer) +return 0 ; +if (!(*buffer)) +return 0 ; + +/* Traverse through the saved vendor specific IE array and append +* the selected(scan/assoc) IE as TLV to the command +*/ +for (id =0 ; id <NXPWIFI_MAX_VSIE_NUM ; id++) { +if (priv->vs_ie[id].mask & vsie_mask) { + vs_param_set = + (struct nxpwifi_ie_types_vendor_param_set *) + *buffer; + vs_param_set->header.type = +cpu_to_le16 (TLV_TYPE_PASSTHROUGH ); + vs_param_set->header.len = +cpu_to_le16 ((((u16 )priv->vs_ie[id].ie[1 ]) + &0x00FF ) +2 ); +if (le16_to_cpu (vs_param_set->header.len) > +NXPWIFI_MAX_VSIE_LEN ) { +nxpwifi_dbg (priv->adapter,ERROR , +"Invalid param length!\n" ); +break ; + } + +memcpy (vs_param_set->ie, priv->vs_ie[id].ie, +le16_to_cpu (vs_param_set->header.len)); + *buffer +=le16_to_cpu (vs_param_set->header.len) + +sizeof (struct nxpwifi_ie_types_header ); + ret_len +=le16_to_cpu (vs_param_set->header.len) + +sizeof (struct nxpwifi_ie_types_header ); + } + } +return ret_len; +} + +/* This function saves a beacon buffer of the current BSS descriptor. +* +* The current beacon buffer is saved so that it can be restored in the +* following cases that makes the beacon buffer not to contain the current +* ssid's beacon buffer. +* - The current ssid was not found somehow in the last scan. +* - The current ssid was the last entry of the scan table and overloaded. +*/ +void +nxpwifi_save_curr_bcn (struct nxpwifi_private *priv) +{ +struct nxpwifi_bssdescriptor *curr_bss = + &priv->curr_bss_params.bss_descriptor; + +if (!curr_bss->beacon_buf_size) +return ; + +/* allocate beacon buffer at 1st time; or if it's size has changed */ +if (!priv->curr_bcn_buf || + priv->curr_bcn_size != curr_bss->beacon_buf_size) { + priv->curr_bcn_size = curr_bss->beacon_buf_size; + +kfree (priv->curr_bcn_buf); + priv->curr_bcn_buf =kmalloc (curr_bss->beacon_buf_size, +GFP_ATOMIC ); +if (!priv->curr_bcn_buf) +return ; + } + +memcpy (priv->curr_bcn_buf, curr_bss->beacon_buf, + curr_bss->beacon_buf_size); +nxpwifi_dbg (priv->adapter,INFO , +"info: current beacon saved %d\n" , + priv->curr_bcn_size); + + curr_bss->beacon_buf = priv->curr_bcn_buf; + +/* adjust the pointers in the current BSS descriptor */ +if (curr_bss->bcn_wpa_ie) + curr_bss->bcn_wpa_ie = + (struct ieee_types_vendor_specific *) + (curr_bss->beacon_buf + + curr_bss->wpa_offset); + +if (curr_bss->bcn_rsn_ie) + curr_bss->bcn_rsn_ie = (struct ieee_types_generic *) + (curr_bss->beacon_buf + + curr_bss->rsn_offset); + +if (curr_bss->bcn_ht_cap) + curr_bss->bcn_ht_cap = (struct ieee80211_ht_cap *) + (curr_bss->beacon_buf + + curr_bss->ht_cap_offset); + +if (curr_bss->bcn_ht_oper) + curr_bss->bcn_ht_oper = (struct ieee80211_ht_operation *) + (curr_bss->beacon_buf + + curr_bss->ht_info_offset); + +if (curr_bss->bcn_vht_cap) + curr_bss->bcn_vht_cap = (void *)(curr_bss->beacon_buf + + curr_bss->vht_cap_offset); + +if (curr_bss->bcn_vht_oper) + curr_bss->bcn_vht_oper = (void *)(curr_bss->beacon_buf + + curr_bss->vht_info_offset); + +if (curr_bss->bcn_bss_co_2040) + curr_bss->bcn_bss_co_2040 = + (curr_bss->beacon_buf + curr_bss->bss_co_2040_offset); + +if (curr_bss->bcn_ext_cap) + curr_bss->bcn_ext_cap = curr_bss->beacon_buf + + curr_bss->ext_cap_offset; + +if (curr_bss->oper_mode) + curr_bss->oper_mode = (void *)(curr_bss->beacon_buf + + curr_bss->oper_mode_offset); +} + +/* This function frees the current BSS descriptor beacon buffer. +*/ +void +nxpwifi_free_curr_bcn (struct nxpwifi_private *priv) +{ +kfree (priv->curr_bcn_buf); + priv->curr_bcn_buf =NULL ; +}
Signature · 1 line
2.34.1
PATCH 26/43 wifi: nxpwifi: add sdio.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/sdio.c | 2646 +++++++++++++++++++++++ 1 file changed, 2646 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/sdio.c
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +2646 -0
@@ -0,0 +1,2646 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: SDIO specific handling +* +* Copyright 2011-2024 NXP +*/ + +#include <linux/firmware.h> +#include <linux/completion.h> +#include <linux/mmc/sdio.h> +#include <linux/mmc/sdio_ids.h> +#include <linux/mmc/sdio_func.h> +#include <linux/mmc/card.h> +#include <linux/mmc/host.h> + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "wmm.h" +#include "11n.h" +#include "sdio.h" + +#define SDIO_VERSION "1.0" + +static void nxpwifi_sdio_work (struct work_struct *work); + +static struct nxpwifi_if_ops sdio_ops; + +static const struct nxpwifi_sdio_card_reg nxpwifi_reg_iw61x = { + .start_rd_port =0 , + .start_wr_port =0 , + .base_0_reg =0xF8 , + .base_1_reg =0xF9 , + .poll_reg =0x5C , + .host_int_enable =UP_LD_HOST_INT_MASK |DN_LD_HOST_INT_MASK | +CMD_PORT_UPLD_INT_MASK |CMD_PORT_DNLD_INT_MASK , + .host_int_rsr_reg =0x4 , + .host_int_status_reg =0x0C , + .host_int_mask_reg =0x08 , + .host_strap_reg =0xF4 , + .host_strap_mask =0x01 , + .host_strap_value =0x00 , + .status_reg_0 =0xE8 , + .status_reg_1 =0xE9 , + .sdio_int_mask =0xff , + .data_port_mask =0xffffffff , + .io_port_0_reg =0xE4 , + .io_port_1_reg =0xE5 , + .io_port_2_reg =0xE6 , + .max_mp_regs =196 , + .rd_bitmap_l =0x10 , + .rd_bitmap_u =0x11 , + .rd_bitmap_1l =0x12 , + .rd_bitmap_1u =0x13 , + .wr_bitmap_l =0x14 , + .wr_bitmap_u =0x15 , + .wr_bitmap_1l =0x16 , + .wr_bitmap_1u =0x17 , + .rd_len_p0_l =0x18 , + .rd_len_p0_u =0x19 , + .card_misc_cfg_reg =0xd8 , + .card_cfg_2_1_reg =0xd9 , + .cmd_rd_len_0 =0xc0 , + .cmd_rd_len_1 =0xc1 , + .cmd_rd_len_2 =0xc2 , + .cmd_rd_len_3 =0xc3 , + .cmd_cfg_0 =0xc4 , + .cmd_cfg_1 =0xc5 , + .cmd_cfg_2 =0xc6 , + .cmd_cfg_3 =0xc7 , + .fw_dump_host_ready =0xcc , + .fw_dump_ctrl =0xf9 , + .fw_dump_start =0xf1 , + .fw_dump_end =0xf8 , + .func1_dump_reg_start =0x10 , + .func1_dump_reg_end =0x17 , + .func1_scratch_reg =0xE8 , + .func1_spec_reg_num =13 , + .func1_spec_reg_table = {0x08 ,0x58 ,0x5C ,0x5D ,0x60 , +0x61 ,0x62 ,0x64 ,0x65 ,0x66 , +0x68 ,0x69 ,0x6a }, +}; + +static const struct nxpwifi_sdio_device nxpwifi_sdio_iw61x = { + .firmware =IW61X_SDIO_FW_NAME , + .reg = &nxpwifi_reg_iw61x, + .max_ports =32 , + .mp_agg_pkt_limit =16 , + .tx_buf_size =NXPWIFI_TX_DATA_BUF_SIZE_4K , + .mp_tx_agg_buf_size =NXPWIFI_MP_AGGR_BSIZE_MAX , + .mp_rx_agg_buf_size =NXPWIFI_MP_AGGR_BSIZE_MAX , + .can_dump_fw = true, + .fw_dump_enh = true, + .can_ext_scan = true, +}; + +static struct memory_type_mapping generic_mem_type_map[] = { + {"DUMP" ,NULL ,0 ,0xDD }, +}; + +static struct memory_type_mapping mem_type_mapping_tbl[] = { + {"ITCM" ,NULL ,0 ,0xF0 }, + {"DTCM" ,NULL ,0 ,0xF1 }, + {"SQRAM" ,NULL ,0 ,0xF2 }, + {"APU" ,NULL ,0 ,0xF3 }, + {"CIU" ,NULL ,0 ,0xF4 }, + {"ICU" ,NULL ,0 ,0xF5 }, + {"MAC" ,NULL ,0 ,0xF6 }, + {"EXT7" ,NULL ,0 ,0xF7 }, + {"EXT8" ,NULL ,0 ,0xF8 }, + {"EXT9" ,NULL ,0 ,0xF9 }, + {"EXT10" ,NULL ,0 ,0xFA }, + {"EXT11" ,NULL ,0 ,0xFB }, + {"EXT12" ,NULL ,0 ,0xFC }, + {"EXT13" ,NULL ,0 ,0xFD }, + {"EXTLAST" ,NULL ,0 ,0xFE }, +}; + +static const struct of_device_id nxpwifi_sdio_of_match_table[]__maybe_unused = { + { } +}; + +/* This function parse device tree node using mmc subnode devicetree API. +* The device node is saved in card->plt_of_node. +* if the device tree node exist and include interrupts attributes, this +* function will also request platform specific wakeup interrupt. +*/ +static int nxpwifi_sdio_probe_of (struct device *dev) +{ +if (!of_match_node (nxpwifi_sdio_of_match_table, dev->of_node)) { +dev_err (dev,"required compatible string missing\n" ); +return -EINVAL ; + } + +return 0 ; +} + +/* SDIO probe. +* +* This function probes an nxpwifi device and registers it. It allocates +* the card structure, enables SDIO function number and initiates the +* device registration and initialization procedure by adding a logical +* interface. +*/ +static int +nxpwifi_sdio_probe (struct sdio_func *func,const struct sdio_device_id *id) +{ +int ret; +struct sdio_mmc_card *card =NULL ; + +pr_debug ("info: vendor=0x%4.04X device=0x%4.04X class=%d function=%d\n" , + func->vendor, func->device, func->class, func->num); + + card =devm_kzalloc (&func->dev,sizeof (*card),GFP_KERNEL ); +if (!card) +return -ENOMEM ; + +init_completion (&card->fw_done); + + card->func = func; + + func->card->quirks |=MMC_QUIRK_BLKSZ_FOR_BYTE_MODE ; + +if (id->driver_data) { +struct nxpwifi_sdio_device *data = (void *)id->driver_data; + + card->firmware = data->firmware; + card->firmware_sdiouart = data->firmware_sdiouart; + card->reg = data->reg; + card->max_ports = data->max_ports; + card->mp_agg_pkt_limit = data->mp_agg_pkt_limit; + card->tx_buf_size = data->tx_buf_size; + card->mp_tx_agg_buf_size = data->mp_tx_agg_buf_size; + card->mp_rx_agg_buf_size = data->mp_rx_agg_buf_size; + card->can_dump_fw = data->can_dump_fw; + card->fw_dump_enh = data->fw_dump_enh; + card->can_ext_scan = data->can_ext_scan; +INIT_WORK (&card->work, nxpwifi_sdio_work); + } + +sdio_claim_host (func); + ret =sdio_enable_func (func); +sdio_release_host (func); + +if (ret) { +dev_err (&func->dev,"failed to enable function\n" ); +return ret; + } + +/* device tree node parsing and platform specific configuration*/ +if (func->dev.of_node) { + ret =nxpwifi_sdio_probe_of (&func->dev); +if (ret) + goto err_disable; + } + + ret =nxpwifi_add_card (card, &card->fw_done, &sdio_ops, +NXPWIFI_SDIO , &func->dev); +if (ret) { +dev_err (&func->dev,"add card failed\n" ); + goto err_disable; + } + +return 0 ; + +err_disable: +sdio_claim_host (func); +sdio_disable_func (func); +sdio_release_host (func); + +return ret; +} + +/* SDIO resume. +* +* Kernel needs to suspend all functions separately. Therefore all +* registered functions must have drivers with suspend and resume +* methods. Failing that the kernel simply removes the whole card. +* +* If already not resumed, this function turns on the traffic and +* sends a host sleep cancel request to the firmware. +*/ +static int nxpwifi_sdio_resume (struct device *dev) +{ +struct sdio_func *func =dev_to_sdio_func (dev); +struct sdio_mmc_card *card; +struct nxpwifi_adapter *adapter; + + card =sdio_get_drvdata (func); +if (!card || !card->adapter) { +dev_err (dev,"resume: invalid card or adapter\n" ); +return 0 ; + } + + adapter = card->adapter; + +if (!test_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags)) { +nxpwifi_dbg (adapter,WARN , +"device already resumed\n" ); +return 0 ; + } + +clear_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags); + +/* Disable Host Sleep */ +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ), +NXPWIFI_SYNC_CMD ); + +nxpwifi_disable_wake (adapter); + +return 0 ; +} + +/* Write data into SDIO card register. Caller claims SDIO device. */ +static int +nxpwifi_write_reg_locked (struct sdio_func *func,u32 reg,u8 data) +{ +int ret =-1 ; + +sdio_writeb (func, data, reg, &ret); +return ret; +} + +/* This function writes data into SDIO card register. +*/ +static int +nxpwifi_write_reg (struct nxpwifi_adapter *adapter,u32 reg,u8 data) +{ +struct sdio_mmc_card *card = adapter->card; +int ret; + +sdio_claim_host (card->func); + ret =nxpwifi_write_reg_locked (card->func, reg, data); +sdio_release_host (card->func); + +return ret; +} + +/* This function reads data from SDIO card register. +*/ +static int +nxpwifi_read_reg (struct nxpwifi_adapter *adapter,u32 reg,u8 *data) +{ +struct sdio_mmc_card *card = adapter->card; +int ret =-1 ; +u8 val; + +sdio_claim_host (card->func); + val =sdio_readb (card->func, reg, &ret); +sdio_release_host (card->func); + + *data = val; + +return ret; +} + +/* This function writes multiple data into SDIO card memory. +* +* This does not work in suspended mode. +*/ +static int +nxpwifi_write_data_sync (struct nxpwifi_adapter *adapter, +u8 *buffer,u32 pkt_len,u32 port) +{ +struct sdio_mmc_card *card = adapter->card; +int ret; +u8 blk_mode = + (port &NXPWIFI_SDIO_BYTE_MODE_MASK ) ?BYTE_MODE :BLOCK_MODE ; +u32 blk_size = (blk_mode ==BLOCK_MODE ) ?NXPWIFI_SDIO_BLOCK_SIZE :1 ; +u32 blk_cnt = + (blk_mode == +BLOCK_MODE ) ? (pkt_len / +NXPWIFI_SDIO_BLOCK_SIZE ) : pkt_len; +u32 ioport = (port &NXPWIFI_SDIO_IO_PORT_MASK ); + +if (test_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags)) { +nxpwifi_dbg (adapter,ERROR , +"%s: not allowed while suspended\n" , __func__); +return -1 ; + } + +sdio_claim_host (card->func); + + ret =sdio_writesb (card->func, ioport, buffer, blk_cnt * blk_size); + +sdio_release_host (card->func); + +return ret; +} + +/* This function reads multiple data from SDIO card memory. +*/ +static int nxpwifi_read_data_sync (struct nxpwifi_adapter *adapter,u8 *buffer, +u32 len,u32 port,u8 claim) +{ +struct sdio_mmc_card *card = adapter->card; +int ret; +u8 blk_mode = (port &NXPWIFI_SDIO_BYTE_MODE_MASK ) ?BYTE_MODE + :BLOCK_MODE ; +u32 blk_size = (blk_mode ==BLOCK_MODE ) ?NXPWIFI_SDIO_BLOCK_SIZE :1 ; +u32 blk_cnt = (blk_mode ==BLOCK_MODE ) ? (len /NXPWIFI_SDIO_BLOCK_SIZE ) + : len; +u32 ioport = (port &NXPWIFI_SDIO_IO_PORT_MASK ); + +if (claim) +sdio_claim_host (card->func); + + ret =sdio_readsb (card->func, buffer, ioport, blk_cnt * blk_size); + +if (claim) +sdio_release_host (card->func); + +return ret; +} + +/* This function reads the firmware status. +*/ +static int +nxpwifi_sdio_read_fw_status (struct nxpwifi_adapter *adapter,u16 *dat) +{ +struct sdio_mmc_card *card = adapter->card; +const struct nxpwifi_sdio_card_reg *reg = card->reg; +u8 fws0, fws1; + +if (nxpwifi_read_reg (adapter, reg->status_reg_0, &fws0)) +return -1 ; + +if (nxpwifi_read_reg (adapter, reg->status_reg_1, &fws1)) +return -1 ; + + *dat = (u16)((fws1 <<8 ) | fws0); +return 0 ; +} + +/* This function checks the firmware status in card. +*/ +static int nxpwifi_check_fw_status (struct nxpwifi_adapter *adapter, +u32 poll_num) +{ +int ret =0 ; +u16 firmware_stat =0 ; +u32 tries; + +for (tries =0 ; tries < poll_num; tries++) { + ret =nxpwifi_sdio_read_fw_status (adapter, &firmware_stat); +if (ret) +continue ; +if (firmware_stat ==FIRMWARE_READY_SDIO ) { + ret =0 ; +break ; + } + +msleep (100 ); + ret =-1 ; + } + +if (firmware_stat ==FIRMWARE_READY_SDIO ) +/* firmware might pretend to be ready, when it's not. +* Wait a little bit more as a workaround. +*/ +msleep (100 ); + +return ret; +} + +/* This function checks if WLAN is the winner. +*/ +static int nxpwifi_check_winner_status (struct nxpwifi_adapter *adapter) +{ +int ret =0 ; +u8 winner =0 ; +struct sdio_mmc_card *card = adapter->card; + +if (nxpwifi_read_reg (adapter, card->reg->status_reg_0, &winner)) +return -1 ; + +if (winner) + adapter->winner =0 ; +else + adapter->winner =1 ; + +return ret; +} + +/* SDIO remove. +* +* This function removes the interface and frees up the card structure. +*/ +static void +nxpwifi_sdio_remove (struct sdio_func *func) +{ +struct sdio_mmc_card *card; +struct nxpwifi_adapter *adapter; +struct nxpwifi_private *priv; +int ret =0 ; +u16 firmware_stat; + + card =sdio_get_drvdata (func); +if (!card) +return ; + +wait_for_completion (&card->fw_done); + + adapter = card->adapter; +if (!adapter || !adapter->priv_num) +return ; + +nxpwifi_dbg (adapter,INFO ,"info: SDIO func num=%d\n" , func->num); + + ret =nxpwifi_sdio_read_fw_status (adapter, &firmware_stat); +if (!ret && firmware_stat ==FIRMWARE_READY_SDIO ) { +nxpwifi_deauthenticate_all (adapter); + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +nxpwifi_disable_auto_ds (priv); +nxpwifi_init_shutdown_fw (priv,NXPWIFI_FUNC_SHUTDOWN ); + } + +nxpwifi_remove_card (adapter); +} + +/* SDIO suspend. +* +* Kernel needs to suspend all functions separately. Therefore all +* registered functions must have drivers with suspend and resume +* methods. Failing that the kernel simply removes the whole card. +* +* If already not suspended, this function allocates and sends a host +* sleep activate request to the firmware and turns off the traffic. +*/ +static int nxpwifi_sdio_suspend (struct device *dev) +{ +struct sdio_func *func =dev_to_sdio_func (dev); +struct sdio_mmc_card *card; +struct nxpwifi_adapter *adapter; +mmc_pm_flag_t pm_flag =0 ; +int ret =0 ; + + pm_flag =sdio_get_host_pm_caps (func); +pr_debug ("cmd: %s: suspend: PM flag = 0x%x\n" , +sdio_func_id (func), pm_flag); +if (!(pm_flag &MMC_PM_KEEP_POWER )) { +dev_err (dev, +"%s: cannot remain alive while host is suspended\n" , +sdio_func_id (func)); +return -EPERM ; + } + + card =sdio_get_drvdata (func); +if (!card) { +dev_err (dev,"suspend: invalid card\n" ); +return 0 ; + } + +/* Might still be loading firmware */ +wait_for_completion (&card->fw_done); + + adapter = card->adapter; +if (!adapter) { +dev_err (dev,"adapter is not valid\n" ); +return 0 ; + } + +if (!adapter->is_up) +return -EBUSY ; + +nxpwifi_enable_wake (adapter); + +/* Enable the Host Sleep */ +if (!nxpwifi_enable_hs (adapter)) { +nxpwifi_dbg (adapter,ERROR , +"cmd: failed to suspend\n" ); +clear_bit (NXPWIFI_IS_HS_ENABLING , &adapter->work_flags); +nxpwifi_disable_wake (adapter); +return -EFAULT ; + } + +nxpwifi_dbg (adapter,INFO , +"cmd: suspend with MMC_PM_KEEP_POWER\n" ); + ret =sdio_set_host_pm_flags (func,MMC_PM_KEEP_POWER ); + +/* Indicate device suspended */ +set_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags); +clear_bit (NXPWIFI_IS_HS_ENABLING , &adapter->work_flags); + +return ret; +} + +static void nxpwifi_sdio_coredump (struct device *dev) +{ +struct sdio_func *func =dev_to_sdio_func (dev); +struct sdio_mmc_card *card; + + card =sdio_get_drvdata (func); +if (!test_and_set_bit (NXPWIFI_IFACE_WORK_DEVICE_DUMP , + &card->work_flags)) +schedule_work (&card->work); +} + +/* WLAN IDs */ +static const struct sdio_device_id nxpwifi_ids[] = { + {SDIO_DEVICE (SDIO_VENDOR_ID_NXP ,SDIO_DEVICE_ID_NXP_IW61X ), + .driver_data = (unsigned long )&nxpwifi_sdio_iw61x}, + {}, +}; + +MODULE_DEVICE_TABLE (sdio, nxpwifi_ids); + +static const struct dev_pm_ops nxpwifi_sdio_pm_ops = { + .suspend = nxpwifi_sdio_suspend, + .resume = nxpwifi_sdio_resume, +}; + +static struct sdio_driver nxpwifi_sdio = { + .name ="nxpwifi_sdio" , + .id_table = nxpwifi_ids, + .probe = nxpwifi_sdio_probe, + .remove = nxpwifi_sdio_remove, + .drv = { + .owner =THIS_MODULE , + .coredump = nxpwifi_sdio_coredump, + .pm = &nxpwifi_sdio_pm_ops, + } +}; + +/* This function wakes up the card. +* +* A host power up command is written to the card configuration +* register to wake up the card. +*/ +static int nxpwifi_pm_wakeup_card (struct nxpwifi_adapter *adapter) +{ +nxpwifi_dbg (adapter,EVENT , +"event: wakeup device...\n" ); + +return nxpwifi_write_reg (adapter,CONFIGURATION_REG ,HOST_POWER_UP ); +} + +/* This function is called after the card has woken up. +* +* The card configuration register is reset. +*/ +static int nxpwifi_pm_wakeup_card_complete (struct nxpwifi_adapter *adapter) +{ +nxpwifi_dbg (adapter,EVENT , +"cmd: wakeup device completed\n" ); + +return nxpwifi_write_reg (adapter,CONFIGURATION_REG ,0 ); +} + +static int nxpwifi_sdio_dnld_fw (struct nxpwifi_adapter *adapter, +struct nxpwifi_fw_image *fw) +{ +struct sdio_mmc_card *card = adapter->card; +int ret; + +sdio_claim_host (card->func); + ret =nxpwifi_dnld_fw (adapter, fw); +sdio_release_host (card->func); + +return ret; +} + +/* This function is used to initialize IO ports for the +* chipsets supporting SDIO new mode. +*/ +static int nxpwifi_init_sdio_new_mode (struct nxpwifi_adapter *adapter) +{ +u8 reg; +struct sdio_mmc_card *card = adapter->card; + + adapter->ioport =MEM_PORT ; + +/* enable sdio new mode */ +if (nxpwifi_read_reg (adapter, card->reg->card_cfg_2_1_reg, ®)) +return -1 ; +if (nxpwifi_write_reg (adapter, card->reg->card_cfg_2_1_reg, + reg |CMD53_NEW_MODE )) +return -1 ; + +/* Configure cmd port and enable reading rx length from the register */ +if (nxpwifi_read_reg (adapter, card->reg->cmd_cfg_0, ®)) +return -1 ; +if (nxpwifi_write_reg (adapter, card->reg->cmd_cfg_0, + reg |CMD_PORT_RD_LEN_EN )) +return -1 ; + +/* Enable Dnld/Upld ready auto reset for cmd port after cmd53 is +* completed +*/ +if (nxpwifi_read_reg (adapter, card->reg->cmd_cfg_1, ®)) +return -1 ; +if (nxpwifi_write_reg (adapter, card->reg->cmd_cfg_1, + reg |CMD_PORT_AUTO_EN )) +return -1 ; + +return 0 ; +} + +/* This function initializes the IO ports. +* +* The following operations are performed - +* - Read the IO ports (0, 1 and 2) +* - Set host interrupt Reset-To-Read to clear +* - Set auto re-enable interrupt +*/ +static int nxpwifi_init_sdio_ioport (struct nxpwifi_adapter *adapter) +{ +u8 reg; +struct sdio_mmc_card *card = adapter->card; + +if (nxpwifi_init_sdio_new_mode (adapter)) +return -1 ; + +nxpwifi_dbg (adapter,INFO , +"info: SDIO FUNC1 IO port: %#x\n" , adapter->ioport); + +/* Set Host interrupt reset to read to clear */ +if (nxpwifi_read_reg (adapter, card->reg->host_int_rsr_reg, ®)) +return -1 ; +if (nxpwifi_write_reg (adapter, card->reg->host_int_rsr_reg, + reg | card->reg->sdio_int_mask)) +return -1 ; + +/* Dnld/Upld ready set to auto reset */ +if (nxpwifi_read_reg (adapter, card->reg->card_misc_cfg_reg, ®)) +return -1 ; +if (nxpwifi_write_reg (adapter, card->reg->card_misc_cfg_reg, + reg |AUTO_RE_ENABLE_INT )) +return -1 ; + +return 0 ; +} + +/* This function sends data to the card. +*/ +static int nxpwifi_write_data_to_card (struct nxpwifi_adapter *adapter, +u8 *payload,u32 pkt_len,u32 port) +{ +u32 i =0 ; +int ret; + +do { + ret =nxpwifi_write_data_sync (adapter, payload, pkt_len, port); +if (ret) { + i++; +nxpwifi_dbg (adapter,ERROR , +"host_to_card, write iomem\t" +"(%d) failed: %d\n" , i, ret); +if (nxpwifi_write_reg (adapter,CONFIGURATION_REG ,0x04 )) +nxpwifi_dbg (adapter,ERROR , +"write CFG reg failed\n" ); + + ret =-1 ; +if (i >MAX_WRITE_IOMEM_RETRY ) +return ret; + } + }while (ret ==-1 ); + +return ret; +} + +/* This function gets the read port. +* +* If control port bit is set in MP read bitmap, the control port +* is returned, otherwise the current read port is returned and +* the value is increased (provided it does not reach the maximum +* limit, in which case it is reset to 1) +*/ +static int nxpwifi_get_rd_port (struct nxpwifi_adapter *adapter,u8 *port) +{ +struct sdio_mmc_card *card = adapter->card; +const struct nxpwifi_sdio_card_reg *reg = card->reg; +u32 rd_bitmap = card->mp_rd_bitmap; + +nxpwifi_dbg (adapter,DATA , +"data: mp_rd_bitmap=0x%08x\n" , rd_bitmap); + +if (!(rd_bitmap & reg->data_port_mask)) +return -1 ; + +if (!(card->mp_rd_bitmap & (1 << card->curr_rd_port))) +return -1 ; + +/* We are now handling the SDIO data ports */ + card->mp_rd_bitmap &= (u32)(~(1 << card->curr_rd_port)); + *port = card->curr_rd_port; + +if (++card->curr_rd_port == card->max_ports) + card->curr_rd_port = reg->start_rd_port; + +nxpwifi_dbg (adapter,DATA , +"data: port=%d mp_rd_bitmap=0x%08x -> 0x%08x\n" , + *port, rd_bitmap, card->mp_rd_bitmap); + +return 0 ; +} + +/* This function gets the write port for data. +* +* The current write port is returned if available and the value is +* increased (provided it does not reach the maximum limit, in which +* case it is reset to 1) +*/ +static int nxpwifi_get_wr_port_data (struct nxpwifi_adapter *adapter,u32 *port) +{ +struct sdio_mmc_card *card = adapter->card; +const struct nxpwifi_sdio_card_reg *reg = card->reg; +u32 wr_bitmap = card->mp_wr_bitmap; + +nxpwifi_dbg (adapter,DATA , +"data: mp_wr_bitmap=0x%08x\n" , wr_bitmap); + +if (!(wr_bitmap & card->mp_data_port_mask)) { + adapter->data_sent = true; +return -EBUSY ; + } + +if (card->mp_wr_bitmap & (1 << card->curr_wr_port)) { + card->mp_wr_bitmap &= (u32)(~(1 << card->curr_wr_port)); + *port = card->curr_wr_port; +if (++card->curr_wr_port == card->mp_end_port) + card->curr_wr_port = reg->start_wr_port; + }else { + adapter->data_sent = true; +return -EBUSY ; + } + +nxpwifi_dbg (adapter,DATA , +"data: port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n" , + *port, wr_bitmap, card->mp_wr_bitmap); + +return 0 ; +} + +/* This function polls the card status. +*/ +static int +nxpwifi_sdio_poll_card_status (struct nxpwifi_adapter *adapter,u8 bits) +{ +struct sdio_mmc_card *card = adapter->card; +u32 tries; +u8 cs; + +for (tries =0 ; tries <MAX_POLL_TRIES ; tries++) { +if (nxpwifi_read_reg (adapter, card->reg->poll_reg, &cs)) +break ; +else if ((cs & bits) == bits) +return 0 ; + +usleep_range (10 ,20 ); + } + +nxpwifi_dbg (adapter,ERROR , +"poll card status failed, tries = %d\n" , tries); + +return -1 ; +} + +/* This function disables the host interrupt. +* +* The host interrupt mask is read, the disable bit is reset and +* written back to the card host interrupt mask register. +*/ +static void nxpwifi_sdio_disable_host_int (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +struct sdio_func *func = card->func; + +sdio_claim_host (func); +nxpwifi_write_reg_locked (func, card->reg->host_int_mask_reg,0 ); +sdio_release_irq (func); +sdio_release_host (func); +} + +/* This function reads the interrupt status from card. +*/ +static void nxpwifi_interrupt_status (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +u8 sdio_ireg; +unsigned long flags; + +if (nxpwifi_read_data_sync (adapter, card->mp_regs, + card->reg->max_mp_regs, +REG_PORT |NXPWIFI_SDIO_BYTE_MODE_MASK ,0 )) { +nxpwifi_dbg (adapter,ERROR ,"read mp_regs failed\n" ); +return ; + } + + sdio_ireg = card->mp_regs[card->reg->host_int_status_reg]; +if (sdio_ireg) { +/* DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS +* For SDIO new mode CMD port interrupts +* DN_LD_CMD_PORT_HOST_INT_STATUS and/or +* UP_LD_CMD_PORT_HOST_INT_STATUS +* Clear the interrupt status register +*/ +nxpwifi_dbg (adapter,INTR , +"int: sdio_ireg = %#x\n" , sdio_ireg); +spin_lock_irqsave (&adapter->int_lock, flags); + adapter->int_status |= sdio_ireg; +spin_unlock_irqrestore (&adapter->int_lock, flags); + } +} + +/* SDIO interrupt handler. +* +* This function reads the interrupt status from firmware and handles +* the interrupt in current thread (ksdioirqd) right away. +*/ +static void +nxpwifi_sdio_interrupt (struct sdio_func *func) +{ +struct nxpwifi_adapter *adapter; +struct sdio_mmc_card *card; + + card =sdio_get_drvdata (func); +if (!card || !card->adapter) { +pr_err ("int: func=%p card=%p adapter=%p\n" , + func, card, card ? card->adapter :NULL ); +return ; + } + adapter = card->adapter; + +if (!adapter->pps_uapsd_mode && adapter->ps_state ==PS_STATE_SLEEP ) + adapter->ps_state =PS_STATE_AWAKE ; + +nxpwifi_interrupt_status (adapter); +nxpwifi_main_process (adapter); +} + +/* This function enables the host interrupt. +* +* The host interrupt enable mask is written to the card +* host interrupt mask register. +*/ +static int nxpwifi_sdio_enable_host_int (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +struct sdio_func *func = card->func; +int ret; + +sdio_claim_host (func); + +/* Request the SDIO IRQ */ + ret =sdio_claim_irq (func, nxpwifi_sdio_interrupt); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"claim irq failed: ret=%d\n" , ret); + goto out; + } + +/* Simply write the mask to the register */ + ret =nxpwifi_write_reg_locked (func, card->reg->host_int_mask_reg, + card->reg->host_int_enable); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"enable host interrupt failed\n" ); +sdio_release_irq (func); + } + +out: +sdio_release_host (func); +return ret; +} + +/* This function gets a data buffer from the card. +*/ +static int nxpwifi_sdio_card_to_host (struct nxpwifi_adapter *adapter, +u32 *type,u8 *buffer, +u32 npayload,u32 ioport) +{ +int ret; +u32 nb; + +if (!buffer) { +nxpwifi_dbg (adapter,ERROR , +"%s: buffer is NULL\n" , __func__); +return -1 ; + } + + ret =nxpwifi_read_data_sync (adapter, buffer, npayload, ioport,1 ); + +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"%s: read iomem failed: %d\n" , __func__, + ret); +return -1 ; + } + + nb =get_unaligned_le16 ((buffer)); +if (nb > npayload) { +nxpwifi_dbg (adapter,ERROR , +"%s: invalid packet, nb=%d npayload=%d\n" , + __func__, nb, npayload); +return -1 ; + } + + *type =get_unaligned_le16 ((buffer +2 )); + +return ret; +} + +/* This function downloads the firmware to the card. +* +* Firmware is downloaded to the card in blocks. Every block download +* is tested for CRC errors, and retried a number of times before +* returning failure. +*/ +static int nxpwifi_prog_fw_w_helper (struct nxpwifi_adapter *adapter, +struct nxpwifi_fw_image *fw) +{ +struct sdio_mmc_card *card = adapter->card; +const struct nxpwifi_sdio_card_reg *reg = card->reg; +int ret; +u8 *firmware = fw->fw_buf; +u32 firmware_len = fw->fw_len; +u32 offset =0 ; +u8 base0, base1; +u8 *fwbuf; +u16 len =0 ; +u32 txlen, tx_blocks =0 , tries; +u32 i =0 ; + +if (!firmware_len) { +nxpwifi_dbg (adapter,ERROR , +"firmware image not found! Terminating download\n" ); +return -1 ; + } + +nxpwifi_dbg (adapter,INFO , +"info: downloading FW image (%d bytes)\n" , + firmware_len); + +/* Assume that the allocated buffer is 8-byte aligned */ + fwbuf =kzalloc (NXPWIFI_UPLD_SIZE ,GFP_KERNEL ); +if (!fwbuf) +return -ENOMEM ; + +sdio_claim_host (card->func); + +/* Perform firmware data transfer */ +do { +/* The host polls for the DN_LD_CARD_RDY and CARD_IO_READY +* bits +*/ + ret =nxpwifi_sdio_poll_card_status (adapter,CARD_IO_READY | +DN_LD_CARD_RDY ); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"FW download with helper:\t" +"poll status timeout @ %d\n" , offset); + goto done; + } + +/* More data? */ +if (offset >= firmware_len) +break ; + +for (tries =0 ; tries <MAX_POLL_TRIES ; tries++) { + ret =nxpwifi_read_reg (adapter, reg->base_0_reg, + &base0); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"dev BASE0 register read failed:\t" +"base0=%#04X(%d). Terminating dnld\n" , + base0, base0); + goto done; + } + ret =nxpwifi_read_reg (adapter, reg->base_1_reg, + &base1); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"dev BASE1 register read failed:\t" +"base1=%#04X(%d). Terminating dnld\n" , + base1, base1); + goto done; + } + len = (u16)(((base1 &0xff ) <<8 ) | (base0 &0xff )); + +if (len) +break ; + +usleep_range (10 ,20 ); + } + +if (!len) { +break ; + }else if (len >NXPWIFI_UPLD_SIZE ) { +nxpwifi_dbg (adapter,ERROR , +"FW dnld failed @ %d, invalid length %d\n" , + offset, len); + ret =-1 ; + goto done; + } + + txlen = len; + +if (len &BIT (0 )) { + i++; +if (i >MAX_WRITE_IOMEM_RETRY ) { +nxpwifi_dbg (adapter,ERROR , +"FW dnld failed @ %d, over max retry\n" , + offset); + ret =-1 ; + goto done; + } +nxpwifi_dbg (adapter,ERROR , +"CRC indicated by the helper:\t" +"len = 0x%04X, txlen = %d\n" , len, txlen); + len &= ~BIT (0 ); +/* Setting this to 0 to resend from same offset */ + txlen =0 ; + }else { + i =0 ; + +/* Set blocksize to transfer - checking for last +* block +*/ +if (firmware_len - offset < txlen) + txlen = firmware_len - offset; + + tx_blocks = (txlen +NXPWIFI_SDIO_BLOCK_SIZE -1 ) + /NXPWIFI_SDIO_BLOCK_SIZE ; + +/* Copy payload to buffer */ +memmove (fwbuf, &firmware[offset], txlen); + } + + ret =nxpwifi_write_data_sync (adapter, fwbuf, tx_blocks * +NXPWIFI_SDIO_BLOCK_SIZE , + adapter->ioport); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"FW download, write iomem (%d) failed @ %d\n" , + i, offset); +if (nxpwifi_write_reg (adapter,CONFIGURATION_REG ,0x04 )) +nxpwifi_dbg (adapter,ERROR , +"write CFG reg failed\n" ); + + ret =-1 ; + goto done; + } + + offset += txlen; + }while (true); + +nxpwifi_dbg (adapter,MSG , +"info: FW download over, size %d bytes\n" , offset); + + ret =0 ; +done: +sdio_release_host (card->func); +kfree (fwbuf); +return ret; +} + +/* This function decodes sdio aggregation pkt. +* +* Based on the data block size and pkt_len, +* skb data will be decoded to few packets. +*/ +static void nxpwifi_deaggr_sdio_pkt (struct nxpwifi_adapter *adapter, +struct sk_buff *skb) +{ +u32 total_pkt_len, pkt_len; +struct sk_buff *skb_deaggr; +u16 blk_size; +u8 blk_num; +u8 *data; + + data = skb->data; + total_pkt_len = skb->len; + +while (total_pkt_len >= (SDIO_HEADER_OFFSET + adapter->intf_hdr_len)) { +if (total_pkt_len < adapter->sdio_rx_block_size) +break ; + blk_num = *(data +BLOCK_NUMBER_OFFSET ); + blk_size = adapter->sdio_rx_block_size * blk_num; +if (blk_size > total_pkt_len) { +nxpwifi_dbg (adapter,ERROR , +"%s: error in blk_size,\t" +"blk_num=%d, blk_size=%d, total_pkt_len=%d\n" , + __func__, blk_num, blk_size, total_pkt_len); +break ; + } + pkt_len =get_unaligned_le16 ((data + +SDIO_HEADER_OFFSET )); +if ((pkt_len +SDIO_HEADER_OFFSET ) > blk_size) { +nxpwifi_dbg (adapter,ERROR , +"%s: error in pkt_len,\t" +"pkt_len=%d, blk_size=%d\n" , + __func__, pkt_len, blk_size); +break ; + } + + skb_deaggr =nxpwifi_alloc_dma_align_buf (pkt_len,GFP_KERNEL ); +if (!skb_deaggr) +break ; +skb_put (skb_deaggr, pkt_len); +memcpy (skb_deaggr->data, data +SDIO_HEADER_OFFSET , pkt_len); +skb_pull (skb_deaggr, adapter->intf_hdr_len); + +nxpwifi_handle_rx_packet (adapter, skb_deaggr); + data += blk_size; + total_pkt_len -= blk_size; + } +} + +/* This function decodes a received packet. +* +* Based on the type, the packet is treated as either a data, or +* a command response, or an event, and the correct handler +* function is invoked. +*/ +static int nxpwifi_decode_rx_packet (struct nxpwifi_adapter *adapter, +struct sk_buff *skb,u32 upld_typ) +{ +u8 *cmd_buf; +u16 pkt_len; +struct nxpwifi_rxinfo *rx_info; + + pkt_len =get_unaligned_le16 (skb->data); + +if (upld_typ !=NXPWIFI_TYPE_AGGR_DATA ) { +skb_trim (skb, pkt_len); +skb_pull (skb, adapter->intf_hdr_len); + } + +switch (upld_typ) { +case NXPWIFI_TYPE_AGGR_DATA : +nxpwifi_dbg (adapter,INFO , +"info: --- Rx: Aggr Data packet ---\n" ); + rx_info =NXPWIFI_SKB_RXCB (skb); + rx_info->buf_type =NXPWIFI_TYPE_AGGR_DATA ; +if (adapter->rx_work_enabled) { +skb_queue_tail (&adapter->rx_data_q, skb); +atomic_inc (&adapter->rx_pending); + adapter->data_received = true; + }else { +nxpwifi_deaggr_sdio_pkt (adapter, skb); +dev_kfree_skb_any (skb); + } +break ; + +case NXPWIFI_TYPE_DATA : +nxpwifi_dbg (adapter,DATA , +"info: --- Rx: Data packet ---\n" ); +if (adapter->rx_work_enabled) { +skb_queue_tail (&adapter->rx_data_q, skb); + adapter->data_received = true; +atomic_inc (&adapter->rx_pending); + }else { +nxpwifi_handle_rx_packet (adapter, skb); + } +break ; + +case NXPWIFI_TYPE_CMD : +nxpwifi_dbg (adapter,CMD , +"info: --- Rx: Cmd Response ---\n" ); +/* take care of curr_cmd = NULL case */ +if (!adapter->curr_cmd) { + cmd_buf = adapter->upld_buf; + +if (adapter->ps_state ==PS_STATE_SLEEP_CFM ) +nxpwifi_process_sleep_confirm_resp (adapter, + skb->data, + skb->len); + +memcpy (cmd_buf, skb->data, +min_t (u32,NXPWIFI_SIZE_OF_CMD_BUFFER , + skb->len)); + +dev_kfree_skb_any (skb); + }else { + adapter->cmd_resp_received = true; + adapter->curr_cmd->resp_skb = skb; + } +break ; + +case NXPWIFI_TYPE_EVENT : +nxpwifi_dbg (adapter,EVENT , +"info: --- Rx: Event ---\n" ); + adapter->event_cause =get_unaligned_le32 (skb->data); + +if (skb->len >0 && skb->len <MAX_EVENT_SIZE ) +memcpy (adapter->event_body, + skb->data +NXPWIFI_EVENT_HEADER_LEN , + skb->len); + +/* event cause has been saved to adapter->event_cause */ + adapter->event_received = true; + adapter->event_skb = skb; + +break ; + +default : +nxpwifi_dbg (adapter,ERROR , +"unknown upload type %#x\n" , upld_typ); +dev_kfree_skb_any (skb); +break ; + } + +return 0 ; +} + +/* This function transfers received packets from card to driver, performing +* aggregation if required. +* +* For data received on control port, or if aggregation is disabled, the +* received buffers are uploaded as separate packets. However, if aggregation +* is enabled and required, the buffers are copied onto an aggregation buffer, +* provided there is space left, processed and finally uploaded. +*/ +static int nxpwifi_sdio_card_to_host_mp_aggr (struct nxpwifi_adapter *adapter, +u16 rx_len,u8 port) +{ +struct sdio_mmc_card *card = adapter->card; +s32 f_do_rx_aggr =0 ; +s32 f_do_rx_cur =0 ; +s32 f_aggr_cur =0 ; +s32 f_post_aggr_cur =0 ; +struct sk_buff *skb_deaggr; +struct sk_buff *skb =NULL ; +u32 pkt_len, pkt_type, mport, pind; +u8 *curr_ptr; + +if (!card->mpa_rx.enabled) { +nxpwifi_dbg (adapter,WARN , +"info: %s: rx aggregation disabled\n" , + __func__); + + f_do_rx_cur =1 ; + goto rx_curr_single; + } + +if (card->mp_rd_bitmap & card->reg->data_port_mask) { +/* Some more data RX pending */ +nxpwifi_dbg (adapter,INFO , +"info: %s: not last packet\n" , __func__); + +if (MP_RX_AGGR_IN_PROGRESS (card)) { +if (MP_RX_AGGR_BUF_HAS_ROOM (card, rx_len)) { + f_aggr_cur =1 ; + }else { +/* No room in Aggr buf, do rx aggr now */ + f_do_rx_aggr =1 ; + f_post_aggr_cur =1 ; + } + }else { +/* Rx aggr not in progress */ + f_aggr_cur =1 ; + } + + }else { +/* No more data RX pending */ +nxpwifi_dbg (adapter,INFO , +"info: %s: last packet\n" , __func__); + +if (MP_RX_AGGR_IN_PROGRESS (card)) { + f_do_rx_aggr =1 ; +if (MP_RX_AGGR_BUF_HAS_ROOM (card, rx_len)) + f_aggr_cur =1 ; +else +/* No room in Aggr buf, do rx aggr now */ + f_do_rx_cur =1 ; + }else { + f_do_rx_cur =1 ; + } + } + +if (f_aggr_cur) { +nxpwifi_dbg (adapter,INFO , +"info: current packet aggregation\n" ); +/* Curr pkt can be aggregated */ +mp_rx_aggr_setup (card, rx_len, port); + +if (MP_RX_AGGR_PKT_LIMIT_REACHED (card) || +mp_rx_aggr_port_limit_reached (card)) { +nxpwifi_dbg (adapter,INFO , +"info: %s: aggregated packet\t" +"limit reached\n" , __func__); +/* No more pkts allowed in Aggr buf, rx it */ + f_do_rx_aggr =1 ; + } + } + +if (f_do_rx_aggr) { +u32 port_count; +int i; + +/* do aggr RX now */ +nxpwifi_dbg (adapter,DATA , +"info: do_rx_aggr: num of packets: %d\n" , + card->mpa_rx.pkt_cnt); + +for (i =0 , port_count =0 ; i < card->max_ports; i++) +if (card->mpa_rx.ports &BIT (i)) + port_count++; + +/* Reading data from "start_port + 0" to "start_port + +* port_count -1", so decrease the count by 1 +*/ + port_count--; + mport = (adapter->ioport |SDIO_MPA_ADDR_BASE | + (port_count <<8 )) + card->mpa_rx.start_port; + +if (card->mpa_rx.pkt_cnt ==1 ) + mport = adapter->ioport + card->mpa_rx.start_port; + +if (nxpwifi_read_data_sync (adapter, card->mpa_rx.buf, + card->mpa_rx.buf_len, mport,1 )) + goto error; + + curr_ptr = card->mpa_rx.buf; + +for (pind =0 ; pind < card->mpa_rx.pkt_cnt; pind++) { +u32 *len_arr = card->mpa_rx.len_arr; + +/* get curr PKT len & type */ + pkt_len =get_unaligned_le16 (&curr_ptr[0 ]); + pkt_type =get_unaligned_le16 (&curr_ptr[2 ]); + +/* copy pkt to deaggr buf */ + skb_deaggr =nxpwifi_alloc_dma_align_buf (len_arr[pind], +GFP_KERNEL ); +if (!skb_deaggr) { +nxpwifi_dbg (adapter,ERROR ,"skb allocation failure\t" +"drop pkt len=%d type=%d\n" , + pkt_len, pkt_type); + curr_ptr += len_arr[pind]; +continue ; + } + +skb_put (skb_deaggr, len_arr[pind]); + +if ((pkt_type ==NXPWIFI_TYPE_DATA || + (pkt_type ==NXPWIFI_TYPE_AGGR_DATA && + adapter->sdio_rx_aggr_enable)) && + pkt_len <= len_arr[pind]) { +memcpy (skb_deaggr->data, curr_ptr, pkt_len); + +skb_trim (skb_deaggr, pkt_len); + +/* Process de-aggr packet */ +nxpwifi_decode_rx_packet (adapter, skb_deaggr, + pkt_type); + }else { +nxpwifi_dbg (adapter,ERROR , +"drop wrong aggr pkt:\t" +"sdio_single_port_rx_aggr=%d\t" +"type=%d len=%d max_len=%d\n" , + adapter->sdio_rx_aggr_enable, + pkt_type, pkt_len, len_arr[pind]); +dev_kfree_skb_any (skb_deaggr); + } + curr_ptr += len_arr[pind]; + } +MP_RX_AGGR_BUF_RESET (card); + } + +rx_curr_single: +if (f_do_rx_cur) { +nxpwifi_dbg (adapter,INFO ,"info: RX: port: %d, rx_len: %d\n" , + port, rx_len); + + skb =nxpwifi_alloc_dma_align_buf (rx_len,GFP_KERNEL ); +if (!skb) { +nxpwifi_dbg (adapter,ERROR , +"single skb allocated fail,\t" +"drop pkt port=%d len=%d\n" , port, rx_len); +if (nxpwifi_sdio_card_to_host (adapter, &pkt_type, + card->mpa_rx.buf, rx_len, + adapter->ioport + port)) + goto error; +return 0 ; + } + +skb_put (skb, rx_len); + +if (nxpwifi_sdio_card_to_host (adapter, &pkt_type, + skb->data, skb->len, + adapter->ioport + port)) + goto error; +if (!adapter->sdio_rx_aggr_enable && + pkt_type ==NXPWIFI_TYPE_AGGR_DATA ) { +nxpwifi_dbg (adapter,ERROR ,"drop wrong pkt type %d\t" +"current SDIO RX Aggr not enabled\n" , + pkt_type); +dev_kfree_skb_any (skb); +return 0 ; + } + +nxpwifi_decode_rx_packet (adapter, skb, pkt_type); + } +if (f_post_aggr_cur) { +nxpwifi_dbg (adapter,INFO , +"info: current packet aggregation\n" ); +/* Curr pkt can be aggregated */ +mp_rx_aggr_setup (card, rx_len, port); + } + +return 0 ; +error: +if (MP_RX_AGGR_IN_PROGRESS (card)) +MP_RX_AGGR_BUF_RESET (card); + +if (f_do_rx_cur && skb) +/* Single transfer pending. Free curr buff also */ +dev_kfree_skb_any (skb); + +return -1 ; +} + +/* This function checks the current interrupt status. +* +* The following interrupts are checked and handled by this function - +* - Data sent +* - Command sent +* - Packets received +* +* Since the firmware does not generate download ready interrupt if the +* port updated is command port only, command sent interrupt checking +* should be done manually, and for every SDIO interrupt. +* +* In case of Rx packets received, the packets are uploaded from card to +* host and processed accordingly. +*/ +static int nxpwifi_process_int_status (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +const struct nxpwifi_sdio_card_reg *reg = card->reg; +int ret =0 ; +u8 sdio_ireg; +struct sk_buff *skb; +u8 port; +u32 len_reg_l, len_reg_u; +u32 rx_blocks; +u16 rx_len; +unsigned long flags; +u32 bitmap; +u8 cr; + +spin_lock_irqsave (&adapter->int_lock, flags); + sdio_ireg = adapter->int_status; + adapter->int_status =0 ; +spin_unlock_irqrestore (&adapter->int_lock, flags); + +if (!sdio_ireg) +return ret; + +/* Following interrupt is only for SDIO new mode */ +if (sdio_ireg &DN_LD_CMD_PORT_HOST_INT_STATUS && adapter->cmd_sent) + adapter->cmd_sent = false; + +/* Following interrupt is only for SDIO new mode */ +if (sdio_ireg &UP_LD_CMD_PORT_HOST_INT_STATUS ) { +u32 pkt_type; + +/* read the len of control packet */ + rx_len = card->mp_regs[reg->cmd_rd_len_1] <<8 ; + rx_len |= (u16 )card->mp_regs[reg->cmd_rd_len_0]; + rx_blocks =DIV_ROUND_UP (rx_len,NXPWIFI_SDIO_BLOCK_SIZE ); +if (rx_len <= adapter->intf_hdr_len || + (rx_blocks *NXPWIFI_SDIO_BLOCK_SIZE ) > +NXPWIFI_RX_DATA_BUF_SIZE ) +return -1 ; + rx_len = (u16)(rx_blocks *NXPWIFI_SDIO_BLOCK_SIZE ); +nxpwifi_dbg (adapter,INFO ,"info: rx_len = %d\n" , rx_len); + + skb =nxpwifi_alloc_dma_align_buf (rx_len,GFP_KERNEL ); +if (!skb) +return -1 ; + +skb_put (skb, rx_len); + +if (nxpwifi_sdio_card_to_host (adapter, &pkt_type, skb->data, + skb->len, adapter->ioport | +CMD_PORT_SLCT )) { +nxpwifi_dbg (adapter,ERROR , +"%s: failed to card_to_host" , __func__); +dev_kfree_skb_any (skb); + goto term_cmd; + } + +if (pkt_type !=NXPWIFI_TYPE_CMD && + pkt_type !=NXPWIFI_TYPE_EVENT ) +nxpwifi_dbg (adapter,ERROR , +"%s:Received wrong packet on cmd port" , + __func__); + +nxpwifi_decode_rx_packet (adapter, skb, pkt_type); + } + +if (sdio_ireg &DN_LD_HOST_INT_STATUS ) { + bitmap = (u32 )card->mp_regs[reg->wr_bitmap_l]; + bitmap |= ((u32 )card->mp_regs[reg->wr_bitmap_u]) <<8 ; + bitmap |= ((u32 )card->mp_regs[reg->wr_bitmap_1l]) <<16 ; + bitmap |= ((u32 )card->mp_regs[reg->wr_bitmap_1u]) <<24 ; + card->mp_wr_bitmap = bitmap; + +nxpwifi_dbg (adapter,INTR , +"int: DNLD: wr_bitmap=0x%x\n" , + card->mp_wr_bitmap); +if (adapter->data_sent && + (card->mp_wr_bitmap & card->mp_data_port_mask)) { +nxpwifi_dbg (adapter,INTR , +"info: <--- Tx DONE Interrupt --->\n" ); + adapter->data_sent = false; + } + } + +nxpwifi_dbg (adapter,INTR ,"info: cmd_sent=%d data_sent=%d\n" , + adapter->cmd_sent, adapter->data_sent); +if (sdio_ireg &UP_LD_HOST_INT_STATUS ) { + bitmap = (u32 )card->mp_regs[reg->rd_bitmap_l]; + bitmap |= ((u32 )card->mp_regs[reg->rd_bitmap_u]) <<8 ; + bitmap |= ((u32 )card->mp_regs[reg->rd_bitmap_1l]) <<16 ; + bitmap |= ((u32 )card->mp_regs[reg->rd_bitmap_1u]) <<24 ; + card->mp_rd_bitmap = bitmap; +nxpwifi_dbg (adapter,INTR , +"int: UPLD: rd_bitmap=0x%x\n" , + card->mp_rd_bitmap); + +while (true) { + ret =nxpwifi_get_rd_port (adapter, &port); +if (ret) { +nxpwifi_dbg (adapter,INFO , +"info: no more rd_port available\n" ); +break ; + } + len_reg_l = reg->rd_len_p0_l + (port <<1 ); + len_reg_u = reg->rd_len_p0_u + (port <<1 ); + rx_len = ((u16 )card->mp_regs[len_reg_u]) <<8 ; + rx_len |= (u16 )card->mp_regs[len_reg_l]; +nxpwifi_dbg (adapter,INFO , +"info: RX: port=%d rx_len=%u\n" , + port, rx_len); + rx_blocks = + (rx_len +NXPWIFI_SDIO_BLOCK_SIZE - +1 ) /NXPWIFI_SDIO_BLOCK_SIZE ; +if (rx_len <= adapter->intf_hdr_len || + (card->mpa_rx.enabled && + ((rx_blocks *NXPWIFI_SDIO_BLOCK_SIZE ) > + card->mpa_rx.buf_size))) { +nxpwifi_dbg (adapter,ERROR , +"invalid rx_len=%d\n" , + rx_len); +return -1 ; + } + + rx_len = (u16)(rx_blocks *NXPWIFI_SDIO_BLOCK_SIZE ); +nxpwifi_dbg (adapter,INFO ,"info: rx_len = %d\n" , + rx_len); + +if (nxpwifi_sdio_card_to_host_mp_aggr (adapter, rx_len, + port)) { +nxpwifi_dbg (adapter,ERROR , +"card_to_host_mpa failed: int status=%#x\n" , + sdio_ireg); + goto term_cmd; + } + } + } + +return 0 ; + +term_cmd: +/* terminate cmd */ +if (nxpwifi_read_reg (adapter,CONFIGURATION_REG , &cr)) +nxpwifi_dbg (adapter,ERROR ,"read CFG reg failed\n" ); +else +nxpwifi_dbg (adapter,INFO , +"info: CFG reg val = %d\n" , cr); + +if (nxpwifi_write_reg (adapter,CONFIGURATION_REG , (cr |0x04 ))) +nxpwifi_dbg (adapter,ERROR , +"write CFG reg failed\n" ); +else +nxpwifi_dbg (adapter,INFO ,"info: write success\n" ); + +if (nxpwifi_read_reg (adapter,CONFIGURATION_REG , &cr)) +nxpwifi_dbg (adapter,ERROR , +"read CFG reg failed\n" ); +else +nxpwifi_dbg (adapter,INFO , +"info: CFG reg val =%x\n" , cr); + +return -1 ; +} + +/* This function aggregates transmission buffers in driver and downloads +* the aggregated packet to card. +* +* The individual packets are aggregated by copying into an aggregation +* buffer and then downloaded to the card. Previous unsent packets in the +* aggregation buffer are pre-copied first before new packets are added. +* Aggregation is done till there is space left in the aggregation buffer, +* or till new packets are available. +* +* The function will only download the packet to the card when aggregation +* stops, otherwise it will just aggregate the packet in aggregation buffer +* and return. +*/ +static int nxpwifi_host_to_card_mp_aggr (struct nxpwifi_adapter *adapter, +u8 *payload,u32 pkt_len,u32 port, +u32 next_pkt_len) +{ +struct sdio_mmc_card *card = adapter->card; +int ret =0 ; +s32 f_send_aggr_buf =0 ; +s32 f_send_cur_buf =0 ; +s32 f_precopy_cur_buf =0 ; +s32 f_postcopy_cur_buf =0 ; +u32 mport; +int index; + +if (!card->mpa_tx.enabled || port ==CMD_PORT_SLCT ) { +nxpwifi_dbg (adapter,WARN , +"info: %s: tx aggregation disabled\n" , + __func__); + + f_send_cur_buf =1 ; + goto tx_curr_single; + } + +if (next_pkt_len) { +/* More pkt in TX queue */ +nxpwifi_dbg (adapter,INFO , +"info: %s: more packets in queue.\n" , + __func__); + +if (MP_TX_AGGR_IN_PROGRESS (card)) { +if (MP_TX_AGGR_BUF_HAS_ROOM (card, pkt_len)) { + f_precopy_cur_buf =1 ; + +if (!(card->mp_wr_bitmap & + (1 << card->curr_wr_port)) || + !MP_TX_AGGR_BUF_HAS_ROOM + (card, pkt_len + next_pkt_len)) + f_send_aggr_buf =1 ; + }else { +/* No room in Aggr buf, send it */ + f_send_aggr_buf =1 ; + +if (!(card->mp_wr_bitmap & + (1 << card->curr_wr_port))) + f_send_cur_buf =1 ; +else + f_postcopy_cur_buf =1 ; + } + }else { +if (MP_TX_AGGR_BUF_HAS_ROOM (card, pkt_len) && + (card->mp_wr_bitmap & (1 << card->curr_wr_port))) + f_precopy_cur_buf =1 ; +else + f_send_cur_buf =1 ; + } + }else { +/* Last pkt in TX queue */ +nxpwifi_dbg (adapter,INFO , +"info: %s: Last packet in Tx Queue.\n" , + __func__); + +if (MP_TX_AGGR_IN_PROGRESS (card)) { +/* some packs in Aggr buf already */ + f_send_aggr_buf =1 ; + +if (MP_TX_AGGR_BUF_HAS_ROOM (card, pkt_len)) + f_precopy_cur_buf =1 ; +else +/* No room in Aggr buf, send it */ + f_send_cur_buf =1 ; + }else { + f_send_cur_buf =1 ; + } + } + +if (f_precopy_cur_buf) { +nxpwifi_dbg (adapter,DATA , +"data: %s: precopy current buffer\n" , + __func__); +MP_TX_AGGR_BUF_PUT (card, payload, pkt_len, port); + +if (MP_TX_AGGR_PKT_LIMIT_REACHED (card) || +mp_tx_aggr_port_limit_reached (card)) +/* No more pkts allowed in Aggr buf, send it */ + f_send_aggr_buf =1 ; + } + +if (f_send_aggr_buf) { +u32 port_count; +int i; + +nxpwifi_dbg (adapter,DATA , +"data: %s: send aggr buffer: %d %d\n" , + __func__, card->mpa_tx.start_port, + card->mpa_tx.ports); + +for (i =0 , port_count =0 ; i < card->max_ports; i++) +if (card->mpa_tx.ports &BIT (i)) + port_count++; + +/* Writing data from "start_port + 0" to "start_port + +* port_count -1", so decrease the count by 1 +*/ + port_count--; + mport = (adapter->ioport |SDIO_MPA_ADDR_BASE | + (port_count <<8 )) + card->mpa_tx.start_port; + +if (card->mpa_tx.pkt_cnt ==1 ) + mport = adapter->ioport + card->mpa_tx.start_port; + + ret =nxpwifi_write_data_to_card (adapter, card->mpa_tx.buf, + card->mpa_tx.buf_len, mport); + +/* Save the last multi port tx aggregation info to debug log */ + index = adapter->dbg.last_sdio_mp_index; + index = (index +1 ) %NXPWIFI_DBG_SDIO_MP_NUM ; + adapter->dbg.last_sdio_mp_index = index; + adapter->dbg.last_mp_wr_ports[index] = mport; + adapter->dbg.last_mp_wr_bitmap[index] = card->mp_wr_bitmap; + adapter->dbg.last_mp_wr_len[index] = card->mpa_tx.buf_len; + adapter->dbg.last_mp_curr_wr_port[index] = card->curr_wr_port; + +MP_TX_AGGR_BUF_RESET (card); + } + +tx_curr_single: +if (f_send_cur_buf) { +nxpwifi_dbg (adapter,DATA , +"data: %s: send current buffer %d\n" , + __func__, port); + ret =nxpwifi_write_data_to_card (adapter, payload, pkt_len, + adapter->ioport + port); + } + +if (f_postcopy_cur_buf) { +nxpwifi_dbg (adapter,DATA , +"data: %s: postcopy current buffer\n" , + __func__); +MP_TX_AGGR_BUF_PUT (card, payload, pkt_len, port); + } + +return ret; +} + +/* This function downloads data from driver to card. +* +* Both commands and data packets are transferred to the card by this +* function. +* +* This function adds the SDIO specific header to the front of the buffer +* before transferring. The header contains the length of the packet and +* the type. The firmware handles the packets based upon this set type. +*/ +static int nxpwifi_sdio_host_to_card (struct nxpwifi_adapter *adapter, +u8 type,struct sk_buff *skb, +struct nxpwifi_tx_param *tx_param) +{ +struct sdio_mmc_card *card = adapter->card; +int ret; +u32 buf_block_len; +u32 blk_size; +u32 port; +u8 *payload = (u8 *)skb->data; +u32 pkt_len = skb->len; + +/* Allocate buffer and copy payload */ + blk_size =NXPWIFI_SDIO_BLOCK_SIZE ; + buf_block_len = (pkt_len + blk_size -1 ) / blk_size; +put_unaligned_le16 ((u16 )pkt_len, payload +0 ); +put_unaligned_le16 ((u16 )type, payload +2 ); + +/* This is SDIO specific header +* u16 length, +* u16 type (NXPWIFI_TYPE_DATA = 0, NXPWIFI_TYPE_CMD = 1, +* NXPWIFI_TYPE_EVENT = 3) +*/ +if (type ==NXPWIFI_TYPE_DATA ) { + ret =nxpwifi_get_wr_port_data (adapter, &port); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"%s: no wr_port available\n" , + __func__); +return ret; + } + }else { + adapter->cmd_sent = true; +/* Type must be NXPWIFI_TYPE_CMD */ + +if (pkt_len <= adapter->intf_hdr_len || + pkt_len >NXPWIFI_UPLD_SIZE ) +nxpwifi_dbg (adapter,ERROR , +"%s: payload=%p, nb=%d\n" , + __func__, payload, pkt_len); + + port =CMD_PORT_SLCT ; + } + +/* Transfer data to card */ + pkt_len = buf_block_len * blk_size; + +if (tx_param) + ret =nxpwifi_host_to_card_mp_aggr (adapter, payload, pkt_len, + port, tx_param->next_pkt_len + ); +else + ret =nxpwifi_host_to_card_mp_aggr (adapter, payload, pkt_len, + port,0 ); + +if (ret) { +if (type ==NXPWIFI_TYPE_CMD ) + adapter->cmd_sent = false; +if (type ==NXPWIFI_TYPE_DATA ) { + adapter->data_sent = false; +/* restore curr_wr_port in error cases */ + card->curr_wr_port = port; + card->mp_wr_bitmap |= (u32)(1 << card->curr_wr_port); + } + }else { +if (type ==NXPWIFI_TYPE_DATA ) { +if (!(card->mp_wr_bitmap & (1 << card->curr_wr_port))) + adapter->data_sent = true; +else + adapter->data_sent = false; + } + } + +return ret; +} + +/* This function allocates the MPA Tx and Rx buffers. +*/ +static int nxpwifi_alloc_sdio_mpa_buffers (struct nxpwifi_adapter *adapter, +u32 mpa_tx_buf_size, +u32 mpa_rx_buf_size) +{ +struct sdio_mmc_card *card = adapter->card; +u32 rx_buf_size; +int ret =0 ; + + card->mpa_tx.buf =kzalloc (mpa_tx_buf_size,GFP_KERNEL ); +if (!card->mpa_tx.buf) { + ret =-1 ; + goto error; + } + + card->mpa_tx.buf_size = mpa_tx_buf_size; + + rx_buf_size =max_t (u32, mpa_rx_buf_size, + (u32 )SDIO_MAX_AGGR_BUF_SIZE ); + card->mpa_rx.buf =kzalloc (rx_buf_size,GFP_KERNEL ); +if (!card->mpa_rx.buf) { + ret =-1 ; + goto error; + } + + card->mpa_rx.buf_size = rx_buf_size; + +error: +if (ret) { +kfree (card->mpa_tx.buf); +kfree (card->mpa_rx.buf); + card->mpa_tx.buf_size =0 ; + card->mpa_rx.buf_size =0 ; + card->mpa_tx.buf =NULL ; + card->mpa_rx.buf =NULL ; + } + +return ret; +} + +/* This function unregisters the SDIO device. +* +* The SDIO IRQ is released, the function is disabled and driver +* data is set to null. +*/ +static void +nxpwifi_unregister_dev (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; + +if (adapter->card) { + card->adapter =NULL ; +sdio_claim_host (card->func); +sdio_disable_func (card->func); +sdio_release_host (card->func); + } +} + +/* This function registers the SDIO device. +* +* SDIO IRQ is claimed, block size is set and driver data is initialized. +*/ +static int nxpwifi_register_dev (struct nxpwifi_adapter *adapter) +{ +int ret; +struct sdio_mmc_card *card = adapter->card; +struct sdio_func *func = card->func; +const char *firmware = card->firmware; + +/* save adapter pointer in card */ + card->adapter = adapter; + adapter->tx_buf_size = card->tx_buf_size; + +sdio_claim_host (func); + +/* Set block size */ + ret =sdio_set_block_size (card->func,NXPWIFI_SDIO_BLOCK_SIZE ); +sdio_release_host (func); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"cannot set SDIO block size\n" ); +return ret; + } + +/* Select correct firmware (sdsd or sdiouart) firmware based on the strapping +* option +*/ +if (card->firmware_sdiouart) { +u8 val; + +nxpwifi_read_reg (adapter, card->reg->host_strap_reg, &val); +if ((val & card->reg->host_strap_mask) == card->reg->host_strap_value) + firmware = card->firmware_sdiouart; + } +strscpy (adapter->fw_name, firmware,sizeof (adapter->fw_name)); + +if (card->fw_dump_enh) { + adapter->mem_type_mapping_tbl = generic_mem_type_map; + adapter->num_mem_types =1 ; + }else { + adapter->mem_type_mapping_tbl = mem_type_mapping_tbl; + adapter->num_mem_types =ARRAY_SIZE (mem_type_mapping_tbl); + } + +return 0 ; +} + +/* This function initializes the SDIO driver. +* +* The following initializations steps are followed - +* - Read the Host interrupt status register to acknowledge +* the first interrupt got from bootloader +* - Disable host interrupt mask register +* - Get SDIO port +* - Initialize SDIO variables in card +* - Allocate MP registers +* - Allocate MPA Tx and Rx buffers +*/ +static int nxpwifi_init_sdio (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +const struct nxpwifi_sdio_card_reg *reg = card->reg; +int ret; +u8 sdio_ireg; + +sdio_set_drvdata (card->func, card); + +/* Read the host_int_status_reg for ACK the first interrupt got +* from the bootloader. If we don't do this we get a interrupt +* as soon as we register the irq. +*/ +nxpwifi_read_reg (adapter, card->reg->host_int_status_reg, &sdio_ireg); + +/* Get SDIO ioport */ +if (nxpwifi_init_sdio_ioport (adapter)) +return -EIO ; + +/* Initialize SDIO variables in card */ + card->mp_rd_bitmap =0 ; + card->mp_wr_bitmap =0 ; + card->curr_rd_port = reg->start_rd_port; + card->curr_wr_port = reg->start_wr_port; + + card->mp_data_port_mask = reg->data_port_mask; + + card->mpa_tx.buf_len =0 ; + card->mpa_tx.pkt_cnt =0 ; + card->mpa_tx.start_port =0 ; + + card->mpa_tx.enabled =1 ; + card->mpa_tx.pkt_aggr_limit = card->mp_agg_pkt_limit; + + card->mpa_rx.buf_len =0 ; + card->mpa_rx.pkt_cnt =0 ; + card->mpa_rx.start_port =0 ; + + card->mpa_rx.enabled =1 ; + card->mpa_rx.pkt_aggr_limit = card->mp_agg_pkt_limit; + +/* Allocate buffers for SDIO MP-A */ + card->mp_regs =kzalloc (reg->max_mp_regs,GFP_KERNEL ); +if (!card->mp_regs) +return -ENOMEM ; + + card->mpa_rx.len_arr =kcalloc (card->mp_agg_pkt_limit, +sizeof (*card->mpa_rx.len_arr), +GFP_KERNEL ); +if (!card->mpa_rx.len_arr) { +kfree (card->mp_regs); +return -ENOMEM ; + } + + ret =nxpwifi_alloc_sdio_mpa_buffers (adapter, + card->mp_tx_agg_buf_size, + card->mp_rx_agg_buf_size); + +/* Allocate 32k MPA Tx/Rx buffers if 64k memory allocation fails */ +if (ret && (card->mp_tx_agg_buf_size ==NXPWIFI_MP_AGGR_BSIZE_MAX || + card->mp_rx_agg_buf_size ==NXPWIFI_MP_AGGR_BSIZE_MAX )) { +/* Disable rx single port aggregation */ + adapter->host_disable_sdio_rx_aggr = true; + + ret =nxpwifi_alloc_sdio_mpa_buffers (adapter, +NXPWIFI_MP_AGGR_BSIZE_32K , +NXPWIFI_MP_AGGR_BSIZE_32K ); +if (ret) { +/* Disable multi port aggregation */ + card->mpa_tx.enabled =0 ; + card->mpa_rx.enabled =0 ; + } + } + + adapter->ext_scan = card->can_ext_scan; +return 0 ; +} + +/* This function resets the MPA Tx and Rx buffers. +*/ +static void nxpwifi_cleanup_mpa_buf (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; + +MP_TX_AGGR_BUF_RESET (card); +MP_RX_AGGR_BUF_RESET (card); +} + +/* This function cleans up the allocated card buffers. +* +* The following are freed by this function - +* - MP registers +* - MPA Tx buffer +* - MPA Rx buffer +*/ +static void nxpwifi_cleanup_sdio (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; + +cancel_work_sync (&card->work); + +kfree (card->mp_regs); +kfree (card->mpa_rx.len_arr); +kfree (card->mpa_tx.buf); +kfree (card->mpa_rx.buf); +} + +/* This function updates the MP end port in card. +*/ +static void +nxpwifi_update_mp_end_port (struct nxpwifi_adapter *adapter,u16 port) +{ +struct sdio_mmc_card *card = adapter->card; +const struct nxpwifi_sdio_card_reg *reg = card->reg; +int i; + + card->mp_end_port = port; + + card->mp_data_port_mask = reg->data_port_mask; + +if (reg->start_wr_port) { +for (i =1 ; i <= card->max_ports - card->mp_end_port; i++) + card->mp_data_port_mask &= + ~(1 << (card->max_ports - i)); + } + + card->curr_wr_port = reg->start_wr_port; + +nxpwifi_dbg (adapter,CMD , +"cmd: mp_end_port %d, data port mask 0x%x\n" , + port, card->mp_data_port_mask); +} + +static void nxpwifi_sdio_card_reset_work (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +struct sdio_func *func = card->func; +int ret; + +/* Prepare the adapter for the reset. */ +nxpwifi_shutdown_sw (adapter); +clear_bit (NXPWIFI_IFACE_WORK_DEVICE_DUMP , &card->work_flags); +clear_bit (NXPWIFI_IFACE_WORK_CARD_RESET , &card->work_flags); + +/* Run a HW reset of the SDIO interface. */ +sdio_claim_host (func); + ret =mmc_hw_reset (func->card); +sdio_release_host (func); + +switch (ret) { +case 1 : +dev_dbg (&func->dev,"SDIO HW reset asynchronous\n" ); +complete_all (adapter->fw_done); +break ; +case 0 : + ret =nxpwifi_reinit_sw (adapter); +if (ret) +dev_err (&func->dev,"reinit failed: %d\n" , ret); +break ; +default : +dev_err (&func->dev,"SDIO HW reset failed: %d\n" , ret); +break ; + } +} + +/* This function read/write firmware */ +static enum +rdwr_status nxpwifi_sdio_rdwr_firmware (struct nxpwifi_adapter *adapter, +u8 doneflag) +{ +struct sdio_mmc_card *card = adapter->card; +int ret, tries; +u8 ctrl_data =0 ; + +sdio_writeb (card->func, card->reg->fw_dump_host_ready, + card->reg->fw_dump_ctrl, &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"SDIO Write ERR\n" ); +return RDWR_STATUS_FAILURE ; + } +for (tries =0 ; tries <MAX_POLL_TRIES ; tries++) { + ctrl_data =sdio_readb (card->func, card->reg->fw_dump_ctrl, + &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"SDIO read err\n" ); +return RDWR_STATUS_FAILURE ; + } +if (ctrl_data ==FW_DUMP_DONE ) +break ; +if (doneflag && ctrl_data == doneflag) +return RDWR_STATUS_DONE ; +if (ctrl_data != card->reg->fw_dump_host_ready) { +nxpwifi_dbg (adapter,WARN , +"The ctrl reg was changed, re-try again\n" ); +sdio_writeb (card->func, card->reg->fw_dump_host_ready, + card->reg->fw_dump_ctrl, &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"SDIO write err\n" ); +return RDWR_STATUS_FAILURE ; + } + } +usleep_range (100 ,200 ); + } +if (ctrl_data == card->reg->fw_dump_host_ready) { +nxpwifi_dbg (adapter,ERROR , +"Fail to pull ctrl_data\n" ); +return RDWR_STATUS_FAILURE ; + } + +return RDWR_STATUS_SUCCESS ; +} + +/* This function dump firmware memory to file */ +static void nxpwifi_sdio_fw_dump (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +int ret =0 ; +unsigned int reg, reg_start, reg_end; +u8 *dbg_ptr, *end_ptr, dump_num, idx, i, read_reg, doneflag =0 ; +enum rdwr_status stat; +u32 memory_size; + +if (!card->can_dump_fw) +return ; + +for (idx =0 ; idx <ARRAY_SIZE (mem_type_mapping_tbl); idx++) { +struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; + +if (entry->mem_ptr) { +vfree (entry->mem_ptr); + entry->mem_ptr =NULL ; + } + entry->mem_size =0 ; + } + +nxpwifi_pm_wakeup_card (adapter); +sdio_claim_host (card->func); + +nxpwifi_dbg (adapter,MSG ,"== nxpwifi firmware dump start ==\n" ); + + stat =nxpwifi_sdio_rdwr_firmware (adapter, doneflag); +if (stat ==RDWR_STATUS_FAILURE ) + goto done; + + reg = card->reg->fw_dump_start; +/* Read the number of the memories which will dump */ + dump_num =sdio_readb (card->func, reg, &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"SDIO read memory length err\n" ); + goto done; + } + +/* Read the length of every memory which will dump */ +for (idx =0 ; idx < dump_num; idx++) { +struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; + + stat =nxpwifi_sdio_rdwr_firmware (adapter, doneflag); +if (stat ==RDWR_STATUS_FAILURE ) + goto done; + + memory_size =0 ; + reg = card->reg->fw_dump_start; +for (i =0 ; i <4 ; i++) { + read_reg =sdio_readb (card->func, reg, &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"SDIO read err\n" ); + goto done; + } + memory_size |= (read_reg << i *8 ); + reg++; + } + +if (memory_size ==0 ) { +nxpwifi_dbg (adapter,DUMP ,"Firmware dump Finished!\n" ); + ret =nxpwifi_write_reg (adapter, + card->reg->fw_dump_ctrl, +FW_DUMP_READ_DONE ); +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"SDIO write err\n" ); +return ; + } +break ; + } + +nxpwifi_dbg (adapter,DUMP , +"%s_SIZE=0x%x\n" , entry->mem_name, memory_size); + entry->mem_ptr =vmalloc (memory_size +1 ); + entry->mem_size = memory_size; +if (!entry->mem_ptr) + goto done; + dbg_ptr = entry->mem_ptr; + end_ptr = dbg_ptr + memory_size; + + doneflag = entry->done_flag; +nxpwifi_dbg (adapter,DUMP , +"Start %s output, please wait...\n" , + entry->mem_name); + +do { + stat =nxpwifi_sdio_rdwr_firmware (adapter, doneflag); +if (stat ==RDWR_STATUS_FAILURE ) + goto done; + + reg_start = card->reg->fw_dump_start; + reg_end = card->reg->fw_dump_end; +for (reg = reg_start; reg <= reg_end; reg++) { + *dbg_ptr =sdio_readb (card->func, reg, &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"SDIO read err\n" ); + goto done; + } +if (dbg_ptr < end_ptr) + dbg_ptr++; +else +nxpwifi_dbg (adapter,ERROR , +"Allocated buf not enough\n" ); + } + +if (stat !=RDWR_STATUS_DONE ) +continue ; + +nxpwifi_dbg (adapter,DUMP ,"%s done: size=0x%tx\n" , + entry->mem_name, dbg_ptr - entry->mem_ptr); +break ; + }while (1 ); + } +nxpwifi_dbg (adapter,MSG ,"== nxpwifi firmware dump end ==\n" ); + +done: +sdio_release_host (card->func); +} + +static void nxpwifi_sdio_generic_fw_dump (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +struct memory_type_mapping *entry = &generic_mem_type_map[0 ]; +unsigned int reg, reg_start, reg_end; +u8 start_flag =0 , done_flag =0 ; +u8 *dbg_ptr, *end_ptr; +enum rdwr_status stat; +int ret =-1 , tries; + +if (!card->fw_dump_enh) +return ; + +if (entry->mem_ptr) { +vfree (entry->mem_ptr); + entry->mem_ptr =NULL ; + } + entry->mem_size =0 ; + +nxpwifi_pm_wakeup_card (adapter); +sdio_claim_host (card->func); + +nxpwifi_dbg (adapter,MSG ,"== nxpwifi firmware dump start ==\n" ); + + stat =nxpwifi_sdio_rdwr_firmware (adapter, done_flag); +if (stat ==RDWR_STATUS_FAILURE ) + goto done; + + reg_start = card->reg->fw_dump_start; + reg_end = card->reg->fw_dump_end; +for (reg = reg_start; reg <= reg_end; reg++) { +for (tries =0 ; tries <MAX_POLL_TRIES ; tries++) { + start_flag =sdio_readb (card->func, reg, &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"SDIO read err\n" ); + goto done; + } +if (start_flag ==0 ) +break ; +if (tries ==MAX_POLL_TRIES ) { +nxpwifi_dbg (adapter,ERROR , +"FW not ready to dump\n" ); + ret =-1 ; + goto done; + } + } +usleep_range (100 ,200 ); + } + + entry->mem_ptr =vmalloc (0xf0000 +1 ); +if (!entry->mem_ptr) { + ret =-1 ; + goto done; + } + dbg_ptr = entry->mem_ptr; + entry->mem_size =0xf0000 ; + end_ptr = dbg_ptr + entry->mem_size; + + done_flag = entry->done_flag; +nxpwifi_dbg (adapter,DUMP , +"Start %s output, please wait...\n" , entry->mem_name); + +while (true) { + stat =nxpwifi_sdio_rdwr_firmware (adapter, done_flag); +if (stat ==RDWR_STATUS_FAILURE ) + goto done; +for (reg = reg_start; reg <= reg_end; reg++) { + *dbg_ptr =sdio_readb (card->func, reg, &ret); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"SDIO read err\n" ); + goto done; + } + dbg_ptr++; +if (dbg_ptr >= end_ptr) { +u8 *tmp_ptr; + + tmp_ptr =vmalloc (entry->mem_size +0x4000 +1 ); +if (!tmp_ptr) + goto done; + +memcpy (tmp_ptr, entry->mem_ptr, + entry->mem_size); +vfree (entry->mem_ptr); + entry->mem_ptr = tmp_ptr; + tmp_ptr =NULL ; + dbg_ptr = entry->mem_ptr + entry->mem_size; + entry->mem_size +=0x4000 ; + end_ptr = entry->mem_ptr + entry->mem_size; + } + } +if (stat ==RDWR_STATUS_DONE ) { + entry->mem_size = dbg_ptr - entry->mem_ptr; +nxpwifi_dbg (adapter,DUMP ,"dump %s done size=0x%x\n" , + entry->mem_name, entry->mem_size); + ret =0 ; +break ; + } + } +nxpwifi_dbg (adapter,MSG ,"== nxpwifi firmware dump end ==\n" ); + +done: +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"firmware dump failed\n" ); +if (entry->mem_ptr) { +vfree (entry->mem_ptr); + entry->mem_ptr =NULL ; + } + entry->mem_size =0 ; + } +sdio_release_host (card->func); +} + +static void nxpwifi_sdio_device_dump_work (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; + + adapter->devdump_data =vzalloc (NXPWIFI_FW_DUMP_SIZE ); +if (!adapter->devdump_data) +return ; + +nxpwifi_drv_info_dump (adapter); +if (card->fw_dump_enh) +nxpwifi_sdio_generic_fw_dump (adapter); +else +nxpwifi_sdio_fw_dump (adapter); +nxpwifi_prepare_fw_dump_info (adapter); +nxpwifi_upload_device_dump (adapter); +} + +static void nxpwifi_sdio_work (struct work_struct *work) +{ +struct sdio_mmc_card *card = + container_of(work, struct sdio_mmc_card, work); + +if (test_and_clear_bit (NXPWIFI_IFACE_WORK_DEVICE_DUMP , + &card->work_flags)) +nxpwifi_sdio_device_dump_work (card->adapter); +if (test_and_clear_bit (NXPWIFI_IFACE_WORK_CARD_RESET , + &card->work_flags)) +nxpwifi_sdio_card_reset_work (card->adapter); +} + +/* This function resets the card */ +static void nxpwifi_sdio_card_reset (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; + +if (!test_and_set_bit (NXPWIFI_IFACE_WORK_CARD_RESET , &card->work_flags)) +schedule_work (&card->work); +} + +/* This function dumps FW information */ +static void nxpwifi_sdio_device_dump (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; + +if (!test_and_set_bit (NXPWIFI_IFACE_WORK_DEVICE_DUMP , + &card->work_flags)) +schedule_work (&card->work); +} + +/* Function to dump SDIO function registers and SDIO scratch registers in case +* of FW crash +*/ +static int +nxpwifi_sdio_reg_dump (struct nxpwifi_adapter *adapter,char *drv_buf) +{ +char *p = drv_buf; +struct sdio_mmc_card *cardp = adapter->card; +int ret =0 ; +u8 count, func, data, index =0 , size =0 ; +u8 reg, reg_start, reg_end; +char buf[256 ], *ptr; + +if (!p) +return 0 ; + +nxpwifi_dbg (adapter,MSG ,"SDIO register dump start\n" ); + +nxpwifi_pm_wakeup_card (adapter); + +sdio_claim_host (cardp->func); + +for (count =0 ; count <5 ; count++) { +memset (buf,0 ,sizeof (buf)); + ptr = buf; + +switch (count) { +case 0 : +/* Read the registers of SDIO function0 */ + func = count; + reg_start =0 ; + reg_end =9 ; +break ; +case 1 : +/* Read the registers of SDIO function1 */ + func = count; + reg_start = cardp->reg->func1_dump_reg_start; + reg_end = cardp->reg->func1_dump_reg_end; +break ; +case 2 : + index =0 ; + func =1 ; + reg_start = cardp->reg->func1_spec_reg_table[index++]; + size = cardp->reg->func1_spec_reg_num; + reg_end = cardp->reg->func1_spec_reg_table[size -1 ]; +break ; +default : +/* Read the scratch registers of SDIO function1 */ +if (count ==4 ) +mdelay (100 ); + func =1 ; + reg_start = cardp->reg->func1_scratch_reg; + reg_end = reg_start +NXPWIFI_SDIO_SCRATCH_SIZE ; + } + +if (count !=2 ) + ptr +=sprintf (ptr,"SDIO Func%d (%#x-%#x): " , + func, reg_start, reg_end); +else + ptr +=sprintf (ptr,"SDIO Func%d: " , func); + +for (reg = reg_start; reg <= reg_end;) { +if (func ==0 ) + data =sdio_f0_readb (cardp->func, reg, &ret); +else + data =sdio_readb (cardp->func, reg, &ret); + +if (count ==2 ) + ptr +=sprintf (ptr,"(%#x) " , reg); +if (!ret) { + ptr +=sprintf (ptr,"%02x " , data); + }else { + ptr +=sprintf (ptr,"ERR" ); +break ; + } + +if (count ==2 && reg < reg_end) + reg = cardp->reg->func1_spec_reg_table[index++]; +else + reg++; + } + +nxpwifi_dbg (adapter,MSG ,"%s\n" , buf); + p +=sprintf (p,"%s\n" , buf); + } + +sdio_release_host (cardp->func); + +nxpwifi_dbg (adapter,MSG ,"SDIO register dump end\n" ); + +return p - drv_buf; +} + +/* sdio device/function initialization, code is extracted +* from init_if handler and register_dev handler. +*/ +static void nxpwifi_sdio_up_dev (struct nxpwifi_adapter *adapter) +{ +struct sdio_mmc_card *card = adapter->card; +u8 sdio_ireg; + +sdio_claim_host (card->func); +sdio_enable_func (card->func); +sdio_set_block_size (card->func,NXPWIFI_SDIO_BLOCK_SIZE ); +sdio_release_host (card->func); + +/* tx_buf_size might be changed to 3584 by firmware during +* data transfer, we will reset to default size. +*/ + adapter->tx_buf_size = card->tx_buf_size; + +/* Read the host_int_status_reg for ACK the first interrupt got +* from the bootloader. If we don't do this we get a interrupt +* as soon as we register the irq. +*/ +nxpwifi_read_reg (adapter, card->reg->host_int_status_reg, &sdio_ireg); + +if (nxpwifi_init_sdio_ioport (adapter)) +dev_err (&card->func->dev,"error enabling SDIO port\n" ); +} + +static struct nxpwifi_if_ops sdio_ops = { + .init_if = nxpwifi_init_sdio, + .cleanup_if = nxpwifi_cleanup_sdio, + .check_fw_status = nxpwifi_check_fw_status, + .check_winner_status = nxpwifi_check_winner_status, + .prog_fw = nxpwifi_prog_fw_w_helper, + .register_dev = nxpwifi_register_dev, + .unregister_dev = nxpwifi_unregister_dev, + .enable_int = nxpwifi_sdio_enable_host_int, + .disable_int = nxpwifi_sdio_disable_host_int, + .process_int_status = nxpwifi_process_int_status, + .host_to_card = nxpwifi_sdio_host_to_card, + .wakeup = nxpwifi_pm_wakeup_card, + .wakeup_complete = nxpwifi_pm_wakeup_card_complete, + +/* SDIO specific */ + .update_mp_end_port = nxpwifi_update_mp_end_port, + .cleanup_mpa_buf = nxpwifi_cleanup_mpa_buf, + .cmdrsp_complete = nxpwifi_sdio_cmdrsp_complete, + .event_complete = nxpwifi_sdio_event_complete, + .dnld_fw = nxpwifi_sdio_dnld_fw, + .card_reset = nxpwifi_sdio_card_reset, + .reg_dump = nxpwifi_sdio_reg_dump, + .device_dump = nxpwifi_sdio_device_dump, + .deaggr_pkt = nxpwifi_deaggr_sdio_pkt, + .up_dev = nxpwifi_sdio_up_dev, +}; + +module_driver (nxpwifi_sdio, sdio_register_driver, sdio_unregister_driver); + +MODULE_AUTHOR ("NXP International Ltd." ); +MODULE_DESCRIPTION ("NXP WiFi SDIO Driver version " SDIO_VERSION ); +MODULE_VERSION (SDIO_VERSION ); +MODULE_LICENSE ("GPL" ); +MODULE_FIRMWARE (IW61X_SDIO_FW_NAME );
Signature · 1 line
2.34.1
Re: [EXTERNAL] [PATCH 26/43] wifi: nxpwifi: add sdio.c
On 6/21/2024 10:51 AM, David Lin wrote:
...
Quoted 8 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +8
-0+ +/* This function unregisters the SDIO device. +* +* The SDIO IRQ is released, the function is disabled and driver +* data is set to null. +*/ +static void +nxpwifi_unregister_dev (struct nxpwifi_adapter *adapter)
drivers/net/wireless/nxp/nxpwifi/sdio.c line 1933
Quoted 10 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +10
-0+{ +struct sdio_mmc_card *card = adapter->card; + +if (adapter->card) { + card->adapter =NULL ; +sdio_claim_host (card->func); +sdio_disable_func (card->func); +sdio_release_host (card->func); + } +}
Missing call to sdio_release_irq() ?
Michael.
RE: [EXT] Re: [EXTERNAL] [PATCH 26/43] wifi: nxpwifi: add sdio.c
Quoted 23 lines · David Lin
...
Quoted 7 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +7
-0+ +/* This function unregisters the SDIO device. +* +* The SDIO IRQ is released, the function is disabled and driver +* data is set to null. +*/ +static voiddrivers/net/wireless/nxp/nxpwifi/sdio.c line 1933
Quoted 10 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +10
-0+nxpwifi_unregister_dev(struct nxpwifi_adapter *adapter) { +struct sdio_mmc_card *card = adapter->card; + +if (adapter->card) { + card->adapter =NULL ; +sdio_claim_host (card->func); +sdio_disable_func (card->func); +sdio_release_host (card->func); + } +}Missing call to
sdio_release_irq()?
Quoted 1 line
Michael.
sdio_release_irq() is called by nxpwifi_sdio_disable_host_int().
David
PATCH 26/43 wifi: nxpwifi: add sdio.c
Quoted 23 lines · David Lin
Quoted 23 lines · David Lin
...
Quoted 7 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +7
-0+ +/* This function unregisters the SDIO device. +* +* The SDIO IRQ is released, the function is disabled and driver +* data is set to null. +*/ +static voiddrivers/net/wireless/nxp/nxpwifi/sdio.c line 1933
Quoted 10 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +10
-0+nxpwifi_unregister_dev(struct nxpwifi_adapter *adapter) { +struct sdio_mmc_card *card = adapter->card; + +if (adapter->card) { + card->adapter =NULL ; +sdio_claim_host (card->func); +sdio_disable_func (card->func); +sdio_release_host (card->func); + } +}Missing call to
sdio_release_irq()?
Quoted 5 lines
Quoted 1 line
Michael.
sdio_release_irq()is called bynxpwifi_sdio_disable_host_int().David
Right, I see you calling it from nxpwifi_uninit_sw(). Maybe just align the comment then.
Michael.
RE: [EXT] [PATCH 26/43] wifi: nxpwifi: add sdio.c
Quoted 42 lines
-----Original Message-----
From: Nemanov, Michael <[email protected]>
Sent: Thursday, June 27, 2024 2:27 PM
To: David Lin <[email protected]>; [email protected]
Cc: [email protected]; [email protected]; [email protected]; [email protected]; Pete Hsieh <[email protected]>
Subject: [EXT] [PATCH 26/43] wifi: nxpwifi: addsdio.cCaution: This is an external email. Please take care when clicking links or opening attachments. When in doubt, report the message using the 'Report this email' button
Quoted 25 lines · David Lin
Quoted 24 lines · David Lin
...
Quoted 7 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +7
-0+ +/* This function unregisters the SDIO device. +* +* The SDIO IRQ is released, the function is disabled and driver +* data is set to null. +*/ +static voiddrivers/net/wireless/nxp/nxpwifi/sdio.c line 1933
Quoted 10 lines
drivers/net/wireless/nxp/nxpwifi/sdio.c new file +10
-0+nxpwifi_unregister_dev(struct nxpwifi_adapter *adapter) { +struct sdio_mmc_card *card = adapter->card; + +if (adapter->card) { + card->adapter =NULL ; +sdio_claim_host (card->func); +sdio_disable_func (card->func); +sdio_release_host (card->func); + } +}Missing call to
sdio_release_irq()?Michael.
Quoted 8 lines
Quoted 3 lines
sdio_release_irq()is called bynxpwifi_sdio_disable_host_int().David
Right, I see you calling it from
nxpwifi_uninit_sw(). Maybe just align the comment then.Michael.
I will modify the comment.
Thanks,
David
PATCH 27/43 wifi: nxpwifi: add sdio.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/sdio.h | 340 ++++++++++++++++++++++++ 1 file changed, 340 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/sdio.h
drivers/net/wireless/nxp/nxpwifi/sdio.h new file +340 -0
@@ -0,0 +1,340 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: SDIO specific definitions +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_SDIO_H +#define _NXPWIFI_SDIO_H + +#include "main.h" + +#define IW61X_SDIO_FW_NAME "nxp/sd_w61x_v1.bin.se" + +#define BLOCK_MODE 1 +#define BYTE_MODE 0 + +#define NXPWIFI_SDIO_IO_PORT_MASK 0xfffff + +#define NXPWIFI_SDIO_BYTE_MODE_MASK 0x80000000 + +#define NXPWIFI_MAX_FUNC2_REG_NUM 13 +#define NXPWIFI_SDIO_SCRATCH_SIZE 10 + +#define SDIO_MPA_ADDR_BASE 0x1000 + +#define CMD_PORT_UPLD_INT_MASK (0x1U << 6) +#define CMD_PORT_DNLD_INT_MASK (0x1U << 7) +#define HOST_TERM_CMD53 (0x1U << 2) +#define REG_PORT 0 +#define MEM_PORT 0x10000 + +#define CMD53_NEW_MODE (0x1U << 0) +#define CMD_PORT_RD_LEN_EN (0x1U << 2) +#define CMD_PORT_AUTO_EN (0x1U << 0) +#define CMD_PORT_SLCT 0x8000 +#define UP_LD_CMD_PORT_HOST_INT_STATUS (0x40U) +#define DN_LD_CMD_PORT_HOST_INT_STATUS (0x80U) + +#define NXPWIFI_MP_AGGR_BSIZE_32K (32768) +/* we leave one block of 256 bytes for DMA alignment*/ +#define NXPWIFI_MP_AGGR_BSIZE_MAX (65280) + +/* Misc. Config Register : Auto Re-enable interrupts */ +#define AUTO_RE_ENABLE_INT BIT(4) + +/* Host Control Registers : Configuration */ +#define CONFIGURATION_REG 0x00 +/* Host Control Registers : Host power up */ +#define HOST_POWER_UP (0x1U << 1) + +/* Host Control Registers : Upload host interrupt mask */ +#define UP_LD_HOST_INT_MASK (0x1U) +/* Host Control Registers : Download host interrupt mask */ +#define DN_LD_HOST_INT_MASK (0x2U) + +/* Host Control Registers : Upload host interrupt status */ +#define UP_LD_HOST_INT_STATUS (0x1U) +/* Host Control Registers : Download host interrupt status */ +#define DN_LD_HOST_INT_STATUS (0x2U) + +/* Host Control Registers : Host interrupt status */ +#define CARD_INT_STATUS_REG 0x28 + +/* Card Control Registers : Card I/O ready */ +#define CARD_IO_READY (0x1U << 3) +/* Card Control Registers : Download card ready */ +#define DN_LD_CARD_RDY (0x1U << 0) + +/* Max retry number of CMD53 write */ +#define MAX_WRITE_IOMEM_RETRY 2 + +/* SDIO Tx aggregation in progress ? */ +#define MP_TX_AGGR_IN_PROGRESS (a) ((a)->mpa_tx.pkt_cnt > 0) + +/* SDIO Tx aggregation buffer room for next packet ? */ +#define MP_TX_AGGR_BUF_HAS_ROOM (a, len) ({ \ + typeof(a) (_a) = a; \ + (((_a)->mpa_tx.buf_len + (len)) <= (_a)->mpa_tx.buf_size); \ + }) + +/* Copy current packet (SDIO Tx aggregation buffer) to SDIO buffer */ +#define MP_TX_AGGR_BUF_PUT (a, payload, pkt_len, port) do { \ + typeof(a) (_a) = (a); \ + typeof(pkt_len) (_pkt_len) = pkt_len; \ + typeof(port) (_port) = port; \ + memmove(&(_a)->mpa_tx.buf[(_a)->mpa_tx.buf_len], \ + payload, (_pkt_len)); \ + (_a)->mpa_tx.buf_len += (_pkt_len); \ + if (!(_a)->mpa_tx.pkt_cnt) \ + (_a)->mpa_tx.start_port = (_port); \ + if ((_a)->mpa_tx.start_port <= (_port)) \ + (_a)->mpa_tx.ports |= (1 << ((_a)->mpa_tx.pkt_cnt)); \ + else \ + (_a)->mpa_tx.ports |= (1 << ((_a)->mpa_tx.pkt_cnt + 1 + \ + ((_a)->max_ports - \ + (_a)->mp_end_port))); \ + (_a)->mpa_tx.pkt_cnt++; \ +} while (0) + +/* SDIO Tx aggregation limit ? */ +#define MP_TX_AGGR_PKT_LIMIT_REACHED (a) ({ \ + typeof(a) (_a) = a; \ + ((_a)->mpa_tx.pkt_cnt == (_a)->mpa_tx.pkt_aggr_limit); \ + }) + +/* Reset SDIO Tx aggregation buffer parameters */ +#define MP_TX_AGGR_BUF_RESET (a) do { \ + typeof(a) (_a) = (a); \ + (_a)->mpa_tx.pkt_cnt = 0; \ + (_a)->mpa_tx.buf_len = 0; \ + (_a)->mpa_tx.ports = 0; \ + (_a)->mpa_tx.start_port = 0; \ +} while (0) + +/* SDIO Rx aggregation limit ? */ +#define MP_RX_AGGR_PKT_LIMIT_REACHED (a) ({ \ + typeof(a) (_a) = a; \ + ((_a)->mpa_rx.pkt_cnt == (_a)->mpa_rx.pkt_aggr_limit); \ + }) + +/* SDIO Rx aggregation in progress ? */ +#define MP_RX_AGGR_IN_PROGRESS (a) ((a)->mpa_rx.pkt_cnt > 0) + +/* SDIO Rx aggregation buffer room for next packet ? */ +#define MP_RX_AGGR_BUF_HAS_ROOM (a, rx_len) ({ \ + typeof(a) (_a) = a; \ + ((((_a)->mpa_rx.buf_len + (rx_len))) <= (_a)->mpa_rx.buf_size); \ + }) + +/* Reset SDIO Rx aggregation buffer parameters */ +#define MP_RX_AGGR_BUF_RESET (a) do { \ + typeof(a) (_a) = (a); \ + (_a)->mpa_rx.pkt_cnt = 0; \ + (_a)->mpa_rx.buf_len = 0; \ + (_a)->mpa_rx.ports = 0; \ + (_a)->mpa_rx.start_port = 0; \ +} while (0) + +/* data structure for SDIO MPA TX */ +struct nxpwifi_sdio_mpa_tx { +/* multiport tx aggregation buffer pointer */ +u8 *buf; +u32 buf_len; +u32 pkt_cnt; +u32 ports; +u16 start_port; +u8 enabled; +u32 buf_size; +u32 pkt_aggr_limit; +}; + +struct nxpwifi_sdio_mpa_rx { +u8 *buf; +u32 buf_len; +u32 pkt_cnt; +u32 ports; +u16 start_port; +u32 *len_arr; +u8 enabled; +u32 buf_size; +u32 pkt_aggr_limit; +}; + +int nxpwifi_bus_register (void ); +void nxpwifi_bus_unregister (void ); + +struct nxpwifi_sdio_card_reg { +u8 start_rd_port; +u8 start_wr_port; +u8 base_0_reg; +u8 base_1_reg; +u8 poll_reg; +u8 host_int_enable; +u8 host_int_rsr_reg; +u8 host_int_status_reg; +u8 host_int_mask_reg; +u8 host_strap_reg; +u8 host_strap_mask; +u8 host_strap_value; +u8 status_reg_0; +u8 status_reg_1; +u8 sdio_int_mask; +u32 data_port_mask; +u8 io_port_0_reg; +u8 io_port_1_reg; +u8 io_port_2_reg; +u8 max_mp_regs; +u8 rd_bitmap_l; +u8 rd_bitmap_u; +u8 rd_bitmap_1l; +u8 rd_bitmap_1u; +u8 wr_bitmap_l; +u8 wr_bitmap_u; +u8 wr_bitmap_1l; +u8 wr_bitmap_1u; +u8 rd_len_p0_l; +u8 rd_len_p0_u; +u8 card_misc_cfg_reg; +u8 card_cfg_2_1_reg; +u8 cmd_rd_len_0; +u8 cmd_rd_len_1; +u8 cmd_rd_len_2; +u8 cmd_rd_len_3; +u8 cmd_cfg_0; +u8 cmd_cfg_1; +u8 cmd_cfg_2; +u8 cmd_cfg_3; +u8 fw_dump_host_ready; +u8 fw_dump_ctrl; +u8 fw_dump_start; +u8 fw_dump_end; +u8 func1_dump_reg_start; +u8 func1_dump_reg_end; +u8 func1_scratch_reg; +u8 func1_spec_reg_num; +u8 func1_spec_reg_table[NXPWIFI_MAX_FUNC2_REG_NUM ]; +}; + +struct sdio_mmc_card { +struct sdio_func *func; +struct nxpwifi_adapter *adapter; + +struct completion fw_done; +const char *firmware; +const char *firmware_sdiouart; +const struct nxpwifi_sdio_card_reg *reg; +u8 max_ports; +u8 mp_agg_pkt_limit; +u16 tx_buf_size; +u32 mp_tx_agg_buf_size; +u32 mp_rx_agg_buf_size; + +u32 mp_rd_bitmap; +u32 mp_wr_bitmap; + +u16 mp_end_port; +u32 mp_data_port_mask; + +u8 curr_rd_port; +u8 curr_wr_port; + +u8 *mp_regs; +bool can_dump_fw; +bool fw_dump_enh; +bool can_ext_scan; + +struct nxpwifi_sdio_mpa_tx mpa_tx; +struct nxpwifi_sdio_mpa_rx mpa_rx; + +struct work_struct work; +unsigned long work_flags; +}; + +struct nxpwifi_sdio_device { +const char *firmware; +const char *firmware_sdiouart; +const struct nxpwifi_sdio_card_reg *reg; +u8 max_ports; +u8 mp_agg_pkt_limit; +u16 tx_buf_size; +u32 mp_tx_agg_buf_size; +u32 mp_rx_agg_buf_size; +bool can_dump_fw; +bool fw_dump_enh; +bool can_ext_scan; +}; + +/* .cmdrsp_complete handler +*/ +static inline int nxpwifi_sdio_cmdrsp_complete (struct nxpwifi_adapter *adapter, +struct sk_buff *skb) +{ +dev_kfree_skb_any (skb); +return 0 ; +} + +/* .event_complete handler +*/ +static inline int nxpwifi_sdio_event_complete (struct nxpwifi_adapter *adapter, +struct sk_buff *skb) +{ +dev_kfree_skb_any (skb); +return 0 ; +} + +static inline bool +mp_rx_aggr_port_limit_reached (struct sdio_mmc_card *card) +{ +u8 tmp; + +if (card->curr_rd_port < card->mpa_rx.start_port) { + tmp = card->mp_end_port >>1 ; + +if (((card->max_ports - card->mpa_rx.start_port) + + card->curr_rd_port) >= tmp) +return true; + } + +if ((card->curr_rd_port - card->mpa_rx.start_port) >= + (card->mp_end_port >>1 )) +return true; + +return false; +} + +static inline bool +mp_tx_aggr_port_limit_reached (struct sdio_mmc_card *card) +{ +u16 tmp; + +if (card->curr_wr_port < card->mpa_tx.start_port) { + tmp = card->mp_end_port >>1 ; + +if (((card->max_ports - card->mpa_tx.start_port) + + card->curr_wr_port) >= tmp) +return true; + } + +if ((card->curr_wr_port - card->mpa_tx.start_port) >= + (card->mp_end_port >>1 )) +return true; + +return false; +} + +/* Prepare to copy current packet from card to SDIO Rx aggregation buffer */ +static inline void mp_rx_aggr_setup (struct sdio_mmc_card *card, +u16 rx_len,u8 port) +{ + card->mpa_rx.buf_len += rx_len; + +if (!card->mpa_rx.pkt_cnt) + card->mpa_rx.start_port = port; + + card->mpa_rx.ports |= (1 << port); + card->mpa_rx.len_arr[card->mpa_rx.pkt_cnt] = rx_len; + card->mpa_rx.pkt_cnt++; +} +#endif /* _NXPWIFI_SDIO_H */
Signature · 1 line
2.34.1
PATCH 28/43 wifi: nxpwifi: add sta_cmd.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/sta_cmd.c | 3229 ++++++++++++++++++++ 1 file changed, 3229 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_cmd.c
drivers/net/wireless/nxp/nxpwifi/sta_cmd.c new file +3229 -0
@@ -0,0 +1,3229 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: station command handling +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" +#include "11ac.h" + +static bool disable_auto_ds; + +static int +nxpwifi_cmd_sta_get_hw_spec (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_get_hw_spec *hw_spec = &cmd->params.hw_spec; + + cmd->command =cpu_to_le16 (HOST_CMD_GET_HW_SPEC ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_get_hw_spec ) + +S_DS_GEN ); +memcpy (hw_spec->permanent_addr, priv->curr_addr,ETH_ALEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_get_hw_spec (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_get_hw_spec *hw_spec = &resp->params.hw_spec; +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_ie_types_header *tlv; +struct hw_spec_api_rev *api_rev; +struct hw_spec_max_conn *max_conn; +u16 resp_size, api_id; +int i, left_len, parsed_len =0 ; + + adapter->fw_cap_info =le32_to_cpu (hw_spec->fw_cap_info); + +if (IS_SUPPORT_MULTI_BANDS (adapter)) + adapter->fw_bands = (u8 )GET_FW_DEFAULT_BANDS (adapter); +else + adapter->fw_bands =BAND_B ; + + adapter->config_bands = adapter->fw_bands; + +if (adapter->fw_bands &BAND_A ) { +if (adapter->fw_bands &BAND_GN ) { + adapter->config_bands |=BAND_AN ; + adapter->fw_bands |=BAND_AN ; + } + } + + adapter->fw_release_number =le32_to_cpu (hw_spec->fw_release_number); + adapter->fw_api_ver = (adapter->fw_release_number >>16 ) &0xff ; + adapter->number_of_antenna = +le16_to_cpu (hw_spec->number_of_antenna) &0xf ; + +if (le32_to_cpu (hw_spec->dot_11ac_dev_cap)) { + adapter->is_hw_11ac_capable = true; + +/* Copy 11AC cap */ + adapter->hw_dot_11ac_dev_cap = +le32_to_cpu (hw_spec->dot_11ac_dev_cap); + adapter->usr_dot_11ac_dev_cap_bg = adapter->hw_dot_11ac_dev_cap + & ~NXPWIFI_DEF_11AC_CAP_BF_RESET_MASK ; + adapter->usr_dot_11ac_dev_cap_a = adapter->hw_dot_11ac_dev_cap + & ~NXPWIFI_DEF_11AC_CAP_BF_RESET_MASK ; + +/* Copy 11AC mcs */ + adapter->hw_dot_11ac_mcs_support = +le32_to_cpu (hw_spec->dot_11ac_mcs_support); + adapter->usr_dot_11ac_mcs_support = + adapter->hw_dot_11ac_mcs_support; + }else { + adapter->is_hw_11ac_capable = false; + } + + resp_size =le16_to_cpu (resp->size) -S_DS_GEN ; +if (resp_size >sizeof (struct host_cmd_ds_get_hw_spec )) { +/* we have variable HW SPEC information */ + left_len = resp_size -sizeof (struct host_cmd_ds_get_hw_spec ); +while (left_len >sizeof (struct nxpwifi_ie_types_header )) { + tlv = (void *)&hw_spec->tlvs + parsed_len; +switch (le16_to_cpu (tlv->type)) { +case TLV_TYPE_API_REV : + api_rev = (struct hw_spec_api_rev *)tlv; + api_id =le16_to_cpu (api_rev->api_id); +switch (api_id) { +case KEY_API_VER_ID : + adapter->key_api_major_ver = + api_rev->major_ver; + adapter->key_api_minor_ver = + api_rev->minor_ver; +nxpwifi_dbg (adapter,INFO , +"key_api v%d.%d\n" , + adapter->key_api_major_ver, + adapter->key_api_minor_ver); +break ; +case FW_API_VER_ID : + adapter->fw_api_ver = + api_rev->major_ver; +nxpwifi_dbg (adapter,INFO , +"Firmware api version %d.%d\n" , + adapter->fw_api_ver, + api_rev->minor_ver); +break ; +case UAP_FW_API_VER_ID : +nxpwifi_dbg (adapter,INFO , +"uAP api version %d.%d\n" , + api_rev->major_ver, + api_rev->minor_ver); +break ; +case CHANRPT_API_VER_ID : +nxpwifi_dbg (adapter,INFO , +"channel report api version %d.%d\n" , + api_rev->major_ver, + api_rev->minor_ver); +break ; +case FW_HOTFIX_VER_ID : +nxpwifi_dbg (adapter,INFO , +"Firmware hotfix version %d\n" , + api_rev->major_ver); +break ; +default : +nxpwifi_dbg (adapter,FATAL , +"Unknown api_id: %d\n" , + api_id); +break ; + } +break ; +case TLV_TYPE_MAX_CONN : + max_conn = (struct hw_spec_max_conn *)tlv; + adapter->max_sta_conn = max_conn->max_sta_conn; +nxpwifi_dbg (adapter,INFO , +"max sta connections: %u\n" , + adapter->max_sta_conn); +break ; +default : +nxpwifi_dbg (adapter,FATAL , +"Unknown GET_HW_SPEC TLV type: %#x\n" , +le16_to_cpu (tlv->type)); +break ; + } + parsed_len +=le16_to_cpu (tlv->len) + +sizeof (struct nxpwifi_ie_types_header ); + left_len -=le16_to_cpu (tlv->len) + +sizeof (struct nxpwifi_ie_types_header ); + } + } + +if (adapter->key_api_major_ver <KEY_API_VER_MAJOR_V2 ) +return -EOPNOTSUPP ; + +nxpwifi_dbg (adapter,INFO , +"info: GET_HW_SPEC: fw_release_number- %#x\n" , + adapter->fw_release_number); +nxpwifi_dbg (adapter,INFO , +"info: GET_HW_SPEC: permanent addr: %pM\n" , + hw_spec->permanent_addr); +nxpwifi_dbg (adapter,INFO , +"info: GET_HW_SPEC: hw_if_version=%#x version=%#x\n" , +le16_to_cpu (hw_spec->hw_if_version), +le16_to_cpu (hw_spec->version)); + +ether_addr_copy (priv->adapter->perm_addr, hw_spec->permanent_addr); + adapter->region_code =le16_to_cpu (hw_spec->region_code); + +for (i =0 ; i <NXPWIFI_MAX_REGION_CODE ; i++) +/* Use the region code to search for the index */ +if (adapter->region_code == region_code_index[i]) +break ; + +/* If it's unidentified region code, use the default (world) */ +if (i >=NXPWIFI_MAX_REGION_CODE ) { + adapter->region_code =0x00 ; +nxpwifi_dbg (adapter,WARN , +"cmd: unknown region code, use default (USA)\n" ); + } + + adapter->hw_dot_11n_dev_cap =le32_to_cpu (hw_spec->dot_11n_dev_cap); + adapter->hw_dev_mcs_support = hw_spec->dev_mcs_support; + adapter->user_dev_mcs_support = adapter->hw_dev_mcs_support; + +if (adapter->if_ops.update_mp_end_port) { +u16 mp_end_port; + + mp_end_port =le16_to_cpu (hw_spec->mp_end_port); + adapter->if_ops.update_mp_end_port (adapter, mp_end_port); + } + +if (adapter->fw_api_ver ==NXPWIFI_FW_V15 ) + adapter->scan_chan_gap_enabled = true; + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_scan (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_802_11_scan (cmd, data_buf); +} + +static int +nxpwifi_ret_sta_802_11_scan (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret; + + ret =nxpwifi_ret_802_11_scan (priv, resp); + adapter->curr_cmd->wait_q_enabled = false; + +return ret; +} + +static int +nxpwifi_cmd_sta_802_11_get_log (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (HOST_CMD_802_11_GET_LOG ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_802_11_get_log ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_get_log (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_802_11_get_log *get_log = + &resp->params.get_log; +struct nxpwifi_ds_get_stats *stats = + (struct nxpwifi_ds_get_stats *)data_buf; + +if (stats) { + stats->mcast_tx_frame =le32_to_cpu (get_log->mcast_tx_frame); + stats->failed =le32_to_cpu (get_log->failed); + stats->retry =le32_to_cpu (get_log->retry); + stats->multi_retry =le32_to_cpu (get_log->multi_retry); + stats->frame_dup =le32_to_cpu (get_log->frame_dup); + stats->rts_success =le32_to_cpu (get_log->rts_success); + stats->rts_failure =le32_to_cpu (get_log->rts_failure); + stats->ack_failure =le32_to_cpu (get_log->ack_failure); + stats->rx_frag =le32_to_cpu (get_log->rx_frag); + stats->mcast_rx_frame =le32_to_cpu (get_log->mcast_rx_frame); + stats->fcs_error =le32_to_cpu (get_log->fcs_error); + stats->tx_frame =le32_to_cpu (get_log->tx_frame); + stats->wep_icv_error[0 ] = +le32_to_cpu (get_log->wep_icv_err_cnt[0 ]); + stats->wep_icv_error[1 ] = +le32_to_cpu (get_log->wep_icv_err_cnt[1 ]); + stats->wep_icv_error[2 ] = +le32_to_cpu (get_log->wep_icv_err_cnt[2 ]); + stats->wep_icv_error[3 ] = +le32_to_cpu (get_log->wep_icv_err_cnt[3 ]); + stats->bcn_rcv_cnt =le32_to_cpu (get_log->bcn_rcv_cnt); + stats->bcn_miss_cnt =le32_to_cpu (get_log->bcn_miss_cnt); + } + +return 0 ; +} + +static int +nxpwifi_cmd_sta_mac_multicast_adr (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_mac_multicast_adr *mcast_addr = &cmd->params.mc_addr; +struct nxpwifi_multicast_list *mcast_list = + (struct nxpwifi_multicast_list *)data_buf; + + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_mac_multicast_adr ) + +S_DS_GEN ); + cmd->command =cpu_to_le16 (HOST_CMD_MAC_MULTICAST_ADR ); + + mcast_addr->action =cpu_to_le16 (cmd_action); + mcast_addr->num_of_adrs = +cpu_to_le16 ((u16 )mcast_list->num_multicast_addr); +memcpy (mcast_addr->mac_list, mcast_list->mac_list, + mcast_list->num_multicast_addr *ETH_ALEN ); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_associate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_802_11_associate (priv, cmd, data_buf); +} + +static int +nxpwifi_ret_sta_802_11_associate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +return nxpwifi_ret_802_11_associate (priv, resp); +} + +static int +nxpwifi_cmd_sta_802_11_snmp_mib (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_802_11_snmp_mib *snmp_mib = &cmd->params.smib; +u16 *ul_temp = (u16 *)data_buf; + +nxpwifi_dbg (priv->adapter,CMD , +"cmd: SNMP_CMD: cmd_oid = 0x%x\n" , cmd_type); + cmd->command =cpu_to_le16 (HOST_CMD_802_11_SNMP_MIB ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_802_11_snmp_mib ) + +S_DS_GEN ); + + snmp_mib->oid =cpu_to_le16 ((u16 )cmd_type); +if (cmd_action ==HOST_ACT_GEN_GET ) { + snmp_mib->query_type =cpu_to_le16 (HOST_ACT_GEN_GET ); + snmp_mib->buf_size =cpu_to_le16 (MAX_SNMP_BUF_SIZE ); +le16_unaligned_add_cpu (&cmd->size,MAX_SNMP_BUF_SIZE ); + }else if (cmd_action ==HOST_ACT_GEN_SET ) { + snmp_mib->query_type =cpu_to_le16 (HOST_ACT_GEN_SET ); + snmp_mib->buf_size =cpu_to_le16 (sizeof (u16)); +put_unaligned_le16 (*ul_temp, snmp_mib->value); +le16_unaligned_add_cpu (&cmd->size,sizeof (u16)); + } + +nxpwifi_dbg (priv->adapter,CMD , +"cmd: SNMP_CMD: Action=0x%x, OID=0x%x,\t" +"OIDSize=0x%x, Value=0x%x\n" , + cmd_action, cmd_type,le16_to_cpu (snmp_mib->buf_size), +get_unaligned_le16 (snmp_mib->value)); + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_snmp_mib (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_802_11_snmp_mib *smib = &resp->params.smib; +u16 oid =le16_to_cpu (smib->oid); +u16 query_type =le16_to_cpu (smib->query_type); +u32 ul_temp; + +nxpwifi_dbg (priv->adapter,INFO , +"info: SNMP_RESP: oid value = %#x,\t" +"query_type = %#x, buf size = %#x\n" , + oid, query_type,le16_to_cpu (smib->buf_size)); +if (query_type ==HOST_ACT_GEN_GET ) { + ul_temp =get_unaligned_le16 (smib->value); +if (data_buf) + *(u32 *)data_buf = ul_temp; +switch (oid) { +case FRAG_THRESH_I : +nxpwifi_dbg (priv->adapter,INFO , +"info: SNMP_RESP: FragThsd =%u\n" , + ul_temp); +break ; +case RTS_THRESH_I : +nxpwifi_dbg (priv->adapter,INFO , +"info: SNMP_RESP: RTSThsd =%u\n" , + ul_temp); +break ; +case SHORT_RETRY_LIM_I : +nxpwifi_dbg (priv->adapter,INFO , +"info: SNMP_RESP: TxRetryCount=%u\n" , + ul_temp); +break ; +case DTIM_PERIOD_I : +nxpwifi_dbg (priv->adapter,INFO , +"info: SNMP_RESP: DTIM period=%u\n" , + ul_temp); +break ; +default : +break ; + } + } + +return 0 ; +} + +static int nxpwifi_cmd_sta_reg_access (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct nxpwifi_ds_reg_rw *reg_rw = data_buf; + + cmd->command =cpu_to_le16 (cmd_no); + +switch (cmd_no) { +case HOST_CMD_MAC_REG_ACCESS : + { +struct host_cmd_ds_mac_reg_access *mac_reg; + + cmd->size =cpu_to_le16 (sizeof (*mac_reg) +S_DS_GEN ); + mac_reg = &cmd->params.mac_reg; + mac_reg->action =cpu_to_le16 (cmd_action); + mac_reg->offset =cpu_to_le16 ((u16 )reg_rw->offset); + mac_reg->value =cpu_to_le32 (reg_rw->value); +break ; + } +case HOST_CMD_BBP_REG_ACCESS : + { +struct host_cmd_ds_bbp_reg_access *bbp_reg; + + cmd->size =cpu_to_le16 (sizeof (*bbp_reg) +S_DS_GEN ); + bbp_reg = &cmd->params.bbp_reg; + bbp_reg->action =cpu_to_le16 (cmd_action); + bbp_reg->offset =cpu_to_le16 ((u16 )reg_rw->offset); + bbp_reg->value = (u8 )reg_rw->value; +break ; + } +case HOST_CMD_RF_REG_ACCESS : + { +struct host_cmd_ds_rf_reg_access *rf_reg; + + cmd->size =cpu_to_le16 (sizeof (*rf_reg) +S_DS_GEN ); + rf_reg = &cmd->params.rf_reg; + rf_reg->action =cpu_to_le16 (cmd_action); + rf_reg->offset =cpu_to_le16 ((u16 )reg_rw->offset); + rf_reg->value = (u8 )reg_rw->value; +break ; + } +case HOST_CMD_PMIC_REG_ACCESS : + { +struct host_cmd_ds_pmic_reg_access *pmic_reg; + + cmd->size =cpu_to_le16 (sizeof (*pmic_reg) +S_DS_GEN ); + pmic_reg = &cmd->params.pmic_reg; + pmic_reg->action =cpu_to_le16 (cmd_action); + pmic_reg->offset =cpu_to_le16 ((u16 )reg_rw->offset); + pmic_reg->value = (u8 )reg_rw->value; +break ; + } +case HOST_CMD_CAU_REG_ACCESS : + { +struct host_cmd_ds_rf_reg_access *cau_reg; + + cmd->size =cpu_to_le16 (sizeof (*cau_reg) +S_DS_GEN ); + cau_reg = &cmd->params.rf_reg; + cau_reg->action =cpu_to_le16 (cmd_action); + cau_reg->offset =cpu_to_le16 ((u16 )reg_rw->offset); + cau_reg->value = (u8 )reg_rw->value; +break ; + } +case HOST_CMD_802_11_EEPROM_ACCESS : + { +struct nxpwifi_ds_read_eeprom *rd_eeprom = data_buf; +struct host_cmd_ds_802_11_eeprom_access *cmd_eeprom = + &cmd->params.eeprom; + + cmd->size =cpu_to_le16 (sizeof (*cmd_eeprom) +S_DS_GEN ); + cmd_eeprom->action =cpu_to_le16 (cmd_action); + cmd_eeprom->offset =cpu_to_le16 (rd_eeprom->offset); + cmd_eeprom->byte_count =cpu_to_le16 (rd_eeprom->byte_count); + cmd_eeprom->value =0 ; +break ; + } +default : +return -1 ; + } + +return 0 ; +} + +static int +nxpwifi_ret_sta_reg_access (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_ds_reg_rw *reg_rw; +struct nxpwifi_ds_read_eeprom *eeprom; +union reg { +struct host_cmd_ds_mac_reg_access *mac; +struct host_cmd_ds_bbp_reg_access *bbp; +struct host_cmd_ds_rf_reg_access *rf; +struct host_cmd_ds_pmic_reg_access *pmic; +struct host_cmd_ds_802_11_eeprom_access *eeprom; + } r; + +if (!data_buf) +return 0 ; + + reg_rw = data_buf; + eeprom = data_buf; +switch (cmdresp_no) { +case HOST_CMD_MAC_REG_ACCESS : + r.mac = &resp->params.mac_reg; + reg_rw->offset = (u32 )le16_to_cpu (r.mac->offset); + reg_rw->value =le32_to_cpu (r.mac->value); +break ; +case HOST_CMD_BBP_REG_ACCESS : + r.bbp = &resp->params.bbp_reg; + reg_rw->offset = (u32 )le16_to_cpu (r.bbp->offset); + reg_rw->value = (u32 )r.bbp->value; +break ; + +case HOST_CMD_RF_REG_ACCESS : + r.rf = &resp->params.rf_reg; + reg_rw->offset = (u32 )le16_to_cpu (r.rf->offset); + reg_rw->value = (u32 )r.bbp->value; +break ; +case HOST_CMD_PMIC_REG_ACCESS : + r.pmic = &resp->params.pmic_reg; + reg_rw->offset = (u32 )le16_to_cpu (r.pmic->offset); + reg_rw->value = (u32 )r.pmic->value; +break ; +case HOST_CMD_CAU_REG_ACCESS : + r.rf = &resp->params.rf_reg; + reg_rw->offset = (u32 )le16_to_cpu (r.rf->offset); + reg_rw->value = (u32 )r.rf->value; +break ; +case HOST_CMD_802_11_EEPROM_ACCESS : + r.eeprom = &resp->params.eeprom; +pr_debug ("info: EEPROM read len=%x\n" , +le16_to_cpu (r.eeprom->byte_count)); +if (eeprom->byte_count <le16_to_cpu (r.eeprom->byte_count)) { + eeprom->byte_count =0 ; +pr_debug ("info: EEPROM read length is too big\n" ); +return -1 ; + } + eeprom->offset =le16_to_cpu (r.eeprom->offset); + eeprom->byte_count =le16_to_cpu (r.eeprom->byte_count); +if (eeprom->byte_count >0 ) +memcpy (&eeprom->value, &r.eeprom->value, +min ((u16 )MAX_EEPROM_DATA , eeprom->byte_count)); +break ; +default : +return -1 ; + } +return 0 ; +} + +static int +nxpwifi_cmd_sta_rf_tx_pwr (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_rf_tx_pwr *txp = &cmd->params.txp; + + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_rf_tx_pwr ) + +S_DS_GEN ); + cmd->command =cpu_to_le16 (HOST_CMD_RF_TX_PWR ); + txp->action =cpu_to_le16 (cmd_action); + +return 0 ; +} + +static int +nxpwifi_ret_sta_rf_tx_pwr (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_rf_tx_pwr *txp = &resp->params.txp; +u16 action =le16_to_cpu (txp->action); + + priv->tx_power_level =le16_to_cpu (txp->cur_level); + +if (action ==HOST_ACT_GEN_GET ) { + priv->max_tx_power_level = txp->max_power; + priv->min_tx_power_level = txp->min_power; + } + +nxpwifi_dbg (priv->adapter,INFO , +"Current TxPower Level=%d, Max Power=%d, Min Power=%d\n" , + priv->tx_power_level, priv->max_tx_power_level, + priv->min_tx_power_level); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_rf_antenna (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_rf_ant_mimo *ant_mimo = &cmd->params.ant_mimo; +struct host_cmd_ds_rf_ant_siso *ant_siso = &cmd->params.ant_siso; +struct nxpwifi_ds_ant_cfg *ant_cfg = + (struct nxpwifi_ds_ant_cfg *)data_buf; + + cmd->command =cpu_to_le16 (HOST_CMD_RF_ANTENNA ); + +switch (cmd_action) { +case HOST_ACT_GEN_SET : +if (priv->adapter->hw_dev_mcs_support ==HT_STREAM_2X2 ) { + cmd->size =cpu_to_le16 (sizeof (struct +host_cmd_ds_rf_ant_mimo ) + +S_DS_GEN ); + ant_mimo->action_tx =cpu_to_le16 (HOST_ACT_SET_TX ); + ant_mimo->tx_ant_mode = +cpu_to_le16 ((u16 )ant_cfg->tx_ant); + ant_mimo->action_rx =cpu_to_le16 (HOST_ACT_SET_RX ); + ant_mimo->rx_ant_mode = +cpu_to_le16 ((u16 )ant_cfg->rx_ant); + }else { + cmd->size =cpu_to_le16 (sizeof (struct +host_cmd_ds_rf_ant_siso ) + +S_DS_GEN ); + ant_siso->action =cpu_to_le16 (HOST_ACT_SET_BOTH ); + ant_siso->ant_mode =cpu_to_le16 ((u16 )ant_cfg->tx_ant); + } +break ; +case HOST_ACT_GEN_GET : +if (priv->adapter->hw_dev_mcs_support ==HT_STREAM_2X2 ) { + cmd->size =cpu_to_le16 (sizeof (struct +host_cmd_ds_rf_ant_mimo ) + +S_DS_GEN ); + ant_mimo->action_tx =cpu_to_le16 (HOST_ACT_GET_TX ); + ant_mimo->action_rx =cpu_to_le16 (HOST_ACT_GET_RX ); + }else { + cmd->size =cpu_to_le16 (sizeof (struct +host_cmd_ds_rf_ant_siso ) + +S_DS_GEN ); + ant_siso->action =cpu_to_le16 (HOST_ACT_GET_BOTH ); + } +break ; + } +return 0 ; +} + +static int +nxpwifi_ret_sta_rf_antenna (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_rf_ant_mimo *ant_mimo = &resp->params.ant_mimo; +struct host_cmd_ds_rf_ant_siso *ant_siso = &resp->params.ant_siso; +struct nxpwifi_adapter *adapter = priv->adapter; + +if (adapter->hw_dev_mcs_support ==HT_STREAM_2X2 ) { + priv->tx_ant =le16_to_cpu (ant_mimo->tx_ant_mode); + priv->rx_ant =le16_to_cpu (ant_mimo->rx_ant_mode); +nxpwifi_dbg (adapter,INFO , +"RF_ANT_RESP: Tx action = 0x%x, Tx Mode = 0x%04x\t" +"Rx action = 0x%x, Rx Mode = 0x%04x\n" , +le16_to_cpu (ant_mimo->action_tx), +le16_to_cpu (ant_mimo->tx_ant_mode), +le16_to_cpu (ant_mimo->action_rx), +le16_to_cpu (ant_mimo->rx_ant_mode)); + }else { + priv->tx_ant =le16_to_cpu (ant_siso->ant_mode); + priv->rx_ant =le16_to_cpu (ant_siso->ant_mode); +nxpwifi_dbg (adapter,INFO , +"RF_ANT_RESP: action = 0x%x, Mode = 0x%04x\n" , +le16_to_cpu (ant_siso->action), +le16_to_cpu (ant_siso->ant_mode)); + } +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_deauthenticate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_802_11_deauthenticate *deauth = &cmd->params.deauth; +u8 *mac = (u8 *)data_buf; + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_DEAUTHENTICATE ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_802_11_deauthenticate ) + +S_DS_GEN ); + +/* Set AP MAC address */ +memcpy (deauth->mac_addr, mac,ETH_ALEN ); + +nxpwifi_dbg (priv->adapter,CMD ,"cmd: Deauth: %pM\n" , deauth->mac_addr); + + deauth->reason_code =cpu_to_le16 (WLAN_REASON_DEAUTH_LEAVING ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_deauthenticate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + + adapter->dbg.num_cmd_deauth++; +if (!memcmp (resp->params.deauth.mac_addr, + &priv->curr_bss_params.bss_descriptor.mac_address, +sizeof (resp->params.deauth.mac_addr))) +nxpwifi_reset_connect_state (priv,WLAN_REASON_DEAUTH_LEAVING , + false); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_mac_control (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_mac_control *mac_ctrl = &cmd->params.mac_ctrl; +u32 *action = (u32 *)data_buf; + +if (cmd_action !=HOST_ACT_GEN_SET ) { +nxpwifi_dbg (priv->adapter,ERROR , +"mac_control: only support set cmd\n" ); +return -1 ; + } + + cmd->command =cpu_to_le16 (HOST_CMD_MAC_CONTROL ); + cmd->size = +cpu_to_le16 (sizeof (struct host_cmd_ds_mac_control ) +S_DS_GEN ); + mac_ctrl->action =cpu_to_le32 (*action); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_mac_address (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (HOST_CMD_802_11_MAC_ADDRESS ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_802_11_mac_address ) + +S_DS_GEN ); + cmd->result =0 ; + + cmd->params.mac_addr.action =cpu_to_le16 (cmd_action); + +if (cmd_action ==HOST_ACT_GEN_SET ) +memcpy (cmd->params.mac_addr.mac_addr, priv->curr_addr, +ETH_ALEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_mac_address (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_802_11_mac_address *cmd_mac_addr; + + cmd_mac_addr = &resp->params.mac_addr; + +memcpy (priv->curr_addr, cmd_mac_addr->mac_addr,ETH_ALEN ); + +nxpwifi_dbg (priv->adapter,INFO , +"info: set mac address: %pM\n" , priv->curr_addr); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11d_domain_info (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_802_11d_domain_info *domain_info = + &cmd->params.domain_info; +struct nxpwifi_ietypes_domain_param_set *domain = + &domain_info->domain; +u8 no_of_triplet = adapter->domain_reg.no_of_triplet; + +nxpwifi_dbg (adapter,INFO , +"info: 11D: no_of_triplet=0x%x\n" , no_of_triplet); + + cmd->command =cpu_to_le16 (HOST_CMD_802_11D_DOMAIN_INFO ); + domain_info->action =cpu_to_le16 (cmd_action); +if (cmd_action ==HOST_ACT_GEN_GET ) { + cmd->size =cpu_to_le16 (sizeof (domain_info->action) +S_DS_GEN ); +return 0 ; + } + +/* Set domain info fields */ + domain->header.type =cpu_to_le16 (WLAN_EID_COUNTRY ); +memcpy (domain->country_code, adapter->domain_reg.country_code, +sizeof (domain->country_code)); + + domain->header.len = +cpu_to_le16 ((no_of_triplet * +sizeof (struct ieee80211_country_ie_triplet )) + +sizeof (domain->country_code)); + +if (no_of_triplet) { +memcpy (domain->triplet, adapter->domain_reg.triplet, + no_of_triplet *sizeof (struct +ieee80211_country_ie_triplet )); + + cmd->size =cpu_to_le16 (sizeof (domain_info->action) + +le16_to_cpu (domain->header.len) + +sizeof (struct nxpwifi_ie_types_header ) + +S_DS_GEN ); + }else { + cmd->size =cpu_to_le16 (sizeof (domain_info->action) +S_DS_GEN ); + } + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11d_domain_info (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_802_11d_domain_info_rsp *domain_info = + &resp->params.domain_info_resp; +struct nxpwifi_ietypes_domain_param_set *domain = &domain_info->domain; +u16 action =le16_to_cpu (domain_info->action); +u8 no_of_triplet; + + no_of_triplet = (u8)((le16_to_cpu (domain->header.len) + -IEEE80211_COUNTRY_STRING_LEN ) + /sizeof (struct ieee80211_country_ie_triplet )); + +nxpwifi_dbg (priv->adapter,INFO , +"info: 11D Domain Info Resp: no_of_triplet=%d\n" , + no_of_triplet); + +if (no_of_triplet >NXPWIFI_MAX_TRIPLET_802_11D ) { +nxpwifi_dbg (priv->adapter,FATAL , +"11D: invalid number of triplets %d returned\n" , + no_of_triplet); +return -1 ; + } + +switch (action) { +case HOST_ACT_GEN_SET :/* Proc Set Action */ +break ; +case HOST_ACT_GEN_GET : +break ; +default : +nxpwifi_dbg (priv->adapter,ERROR , +"11D: invalid action:%d\n" , domain_info->action); +return -1 ; + } + +return 0 ; +} + +static int nxpwifi_set_aes_key (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +struct nxpwifi_ds_encrypt_key *enc_key, +struct host_cmd_ds_802_11_key_material *km) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u16 size, len =KEY_PARAMS_FIXED_LEN ; + +if (enc_key->is_igtk_key) { +nxpwifi_dbg (adapter,INFO , +"%s: Set CMAC AES Key\n" , __func__); +if (enc_key->is_rx_seq_valid) +memcpy (km->key_param_set.key_params.cmac_aes.ipn, + enc_key->pn, enc_key->pn_len); + km->key_param_set.key_info &=cpu_to_le16 (~KEY_MCAST ); + km->key_param_set.key_info |=cpu_to_le16 (KEY_IGTK ); + km->key_param_set.key_type =KEY_TYPE_ID_AES_CMAC ; + km->key_param_set.key_params.cmac_aes.key_len = +cpu_to_le16 (enc_key->key_len); +memcpy (km->key_param_set.key_params.cmac_aes.key, + enc_key->key_material, enc_key->key_len); + len +=sizeof (struct nxpwifi_cmac_aes_param ); + }else if (enc_key->is_igtk_def_key) { +nxpwifi_dbg (adapter,INFO , +"%s: Set CMAC default Key index\n" , __func__); + km->key_param_set.key_type =KEY_TYPE_ID_AES_CMAC_DEF ; + km->key_param_set.key_idx = enc_key->key_index &KEY_INDEX_MASK ; + }else { +nxpwifi_dbg (adapter,INFO , +"%s: Set AES Key\n" , __func__); +if (enc_key->is_rx_seq_valid) +memcpy (km->key_param_set.key_params.aes.pn, + enc_key->pn, enc_key->pn_len); + km->key_param_set.key_type =KEY_TYPE_ID_AES ; + km->key_param_set.key_params.aes.key_len = +cpu_to_le16 (enc_key->key_len); +memcpy (km->key_param_set.key_params.aes.key, + enc_key->key_material, enc_key->key_len); + len +=sizeof (struct nxpwifi_aes_param ); + } + + km->key_param_set.len =cpu_to_le16 (len); + size = len +sizeof (struct nxpwifi_ie_types_header ) + +sizeof (km->action) +S_DS_GEN ; + cmd->size =cpu_to_le16 (size); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_key_material (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_ds_encrypt_key *enc_key = + (struct nxpwifi_ds_encrypt_key *)data_buf; +u8 *mac = enc_key->mac_addr; +u16 key_info, len =KEY_PARAMS_FIXED_LEN ; +struct host_cmd_ds_802_11_key_material *km = + &cmd->params.key_material; + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_KEY_MATERIAL ); + km->action =cpu_to_le16 (cmd_action); + +if (cmd_action ==HOST_ACT_GEN_GET ) { +nxpwifi_dbg (adapter,INFO ,"%s: Get key\n" , __func__); + km->key_param_set.key_idx = + enc_key->key_index &KEY_INDEX_MASK ; + km->key_param_set.type =cpu_to_le16 (TLV_TYPE_KEY_PARAM_V2 ); + km->key_param_set.len =cpu_to_le16 (KEY_PARAMS_FIXED_LEN ); +memcpy (km->key_param_set.mac_addr, mac,ETH_ALEN ); + +if (enc_key->key_index &NXPWIFI_KEY_INDEX_UNICAST ) + key_info =KEY_UNICAST ; +else + key_info =KEY_MCAST ; + +if (enc_key->is_igtk_key) + key_info |=KEY_IGTK ; + + km->key_param_set.key_info =cpu_to_le16 (key_info); + + cmd->size =cpu_to_le16 (sizeof (struct nxpwifi_ie_types_header ) + +S_DS_GEN +KEY_PARAMS_FIXED_LEN + +sizeof (km->action)); +return 0 ; + } + +memset (&km->key_param_set,0 , +sizeof (struct nxpwifi_ie_type_key_param_set )); + +if (enc_key->key_disable) { +nxpwifi_dbg (adapter,INFO ,"%s: Remove key\n" , __func__); + km->action =cpu_to_le16 (HOST_ACT_GEN_REMOVE ); + km->key_param_set.type =cpu_to_le16 (TLV_TYPE_KEY_PARAM_V2 ); + km->key_param_set.len =cpu_to_le16 (KEY_PARAMS_FIXED_LEN ); + km->key_param_set.key_idx = enc_key->key_index &KEY_INDEX_MASK ; + key_info =KEY_MCAST |KEY_UNICAST ; + km->key_param_set.key_info =cpu_to_le16 (key_info); +memcpy (km->key_param_set.mac_addr, mac,ETH_ALEN ); + cmd->size =cpu_to_le16 (sizeof (struct nxpwifi_ie_types_header ) + +S_DS_GEN +KEY_PARAMS_FIXED_LEN + +sizeof (km->action)); +return 0 ; + } + + km->action =cpu_to_le16 (HOST_ACT_GEN_SET ); + km->key_param_set.key_idx = enc_key->key_index &KEY_INDEX_MASK ; + km->key_param_set.type =cpu_to_le16 (TLV_TYPE_KEY_PARAM_V2 ); + key_info =KEY_ENABLED ; +memcpy (km->key_param_set.mac_addr, mac,ETH_ALEN ); + +if (enc_key->key_len <=WLAN_KEY_LEN_WEP104 ) { +nxpwifi_dbg (adapter,INFO ,"%s: Set WEP Key\n" , __func__); + len +=sizeof (struct nxpwifi_wep_param ); + km->key_param_set.len =cpu_to_le16 (len); + km->key_param_set.key_type =KEY_TYPE_ID_WEP ; + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { + key_info |=KEY_MCAST |KEY_UNICAST ; + }else { +if (enc_key->is_current_wep_key) { + key_info |=KEY_MCAST |KEY_UNICAST ; +if (km->key_param_set.key_idx == + (priv->wep_key_curr_index &KEY_INDEX_MASK )) + key_info |=KEY_DEFAULT ; + }else { +if (is_broadcast_ether_addr (mac)) + key_info |=KEY_MCAST ; +else + key_info |=KEY_UNICAST |KEY_DEFAULT ; + } + } + km->key_param_set.key_info =cpu_to_le16 (key_info); + + km->key_param_set.key_params.wep.key_len = +cpu_to_le16 (enc_key->key_len); +memcpy (km->key_param_set.key_params.wep.key, + enc_key->key_material, enc_key->key_len); + + cmd->size =cpu_to_le16 (sizeof (struct nxpwifi_ie_types_header ) + + len +sizeof (km->action) +S_DS_GEN ); +return 0 ; + } + +if (is_broadcast_ether_addr (mac)) + key_info |=KEY_MCAST |KEY_RX_KEY ; +else + key_info |=KEY_UNICAST |KEY_TX_KEY |KEY_RX_KEY ; + +/* Enable default key for WPA/WPA2 */ +if (!priv->wpa_is_gtk_set) + key_info |=KEY_DEFAULT ; + + km->key_param_set.key_info =cpu_to_le16 (key_info); + +if (enc_key->key_len ==WLAN_KEY_LEN_CCMP ) +return nxpwifi_set_aes_key (priv, cmd, enc_key, km); + +if (enc_key->key_len ==WLAN_KEY_LEN_TKIP ) { +nxpwifi_dbg (adapter,INFO , +"%s: Set TKIP Key\n" , __func__); +if (enc_key->is_rx_seq_valid) +memcpy (km->key_param_set.key_params.tkip.pn, + enc_key->pn, enc_key->pn_len); + km->key_param_set.key_type =KEY_TYPE_ID_TKIP ; + km->key_param_set.key_params.tkip.key_len = +cpu_to_le16 (enc_key->key_len); +memcpy (km->key_param_set.key_params.tkip.key, + enc_key->key_material, enc_key->key_len); + + len +=sizeof (struct nxpwifi_tkip_param ); + km->key_param_set.len =cpu_to_le16 (len); + cmd->size =cpu_to_le16 (sizeof (struct nxpwifi_ie_types_header ) + + len +sizeof (km->action) +S_DS_GEN ); + } + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_key_material (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_802_11_key_material *key; +int len; + + key = &resp->params.key_material; + + len =le16_to_cpu (key->key_param_set.key_params.aes.key_len); +if (len >sizeof (key->key_param_set.key_params.aes.key)) +return -EINVAL ; + +if (le16_to_cpu (key->action) ==HOST_ACT_GEN_SET ) { +if ((le16_to_cpu (key->key_param_set.key_info) &KEY_MCAST )) { +nxpwifi_dbg (priv->adapter,INFO , +"info: key: GTK is set\n" ); + priv->wpa_is_gtk_set = true; + priv->scan_block = false; + priv->port_open = true; + } + } + +if (key->key_param_set.key_type !=KEY_TYPE_ID_AES ) +return 0 ; + +memset (priv->aes_key.key_param_set.key_params.aes.key,0 , +sizeof (key->key_param_set.key_params.aes.key)); + priv->aes_key.key_param_set.key_params.aes.key_len =cpu_to_le16 (len); +memcpy (priv->aes_key.key_param_set.key_params.aes.key, + key->key_param_set.key_params.aes.key, len); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_bg_scan_config (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_802_11_bg_scan_config (priv, cmd, data_buf); +} + +static int +nxpwifi_cmd_sta_802_11_bg_scan_query (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_802_11_bg_scan_query (cmd); +} + +static int +nxpwifi_ret_sta_802_11_bg_scan_query (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret; + + ret =nxpwifi_ret_802_11_scan (priv, resp); +cfg80211_sched_scan_results (priv->wdev.wiphy,0 ); +nxpwifi_dbg (adapter,CMD , +"info: CMD_RESP: BG_SCAN result is ready!\n" ); + +return ret; +} + +static int +nxpwifi_cmd_sta_wmm_get_status (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (HOST_CMD_WMM_GET_STATUS ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_wmm_get_status ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_wmm_get_status (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +return nxpwifi_ret_wmm_get_status (priv, resp); +} + +static int +nxpwifi_cmd_sta_802_11_subsc_evt (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_802_11_subsc_evt *subsc_evt = &cmd->params.subsc_evt; +struct nxpwifi_ds_misc_subsc_evt *subsc_evt_cfg = + (struct nxpwifi_ds_misc_subsc_evt *)data_buf; +struct nxpwifi_ie_types_rssi_threshold *rssi_tlv; +u16 event_bitmap; +u8 *pos; + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_SUBSCRIBE_EVENT ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_802_11_subsc_evt ) + +S_DS_GEN ); + + subsc_evt->action =cpu_to_le16 (subsc_evt_cfg->action); +nxpwifi_dbg (priv->adapter,CMD , +"cmd: action: %d\n" , subsc_evt_cfg->action); + +/*For query requests, no configuration TLV structures are to be added.*/ +if (subsc_evt_cfg->action ==HOST_ACT_GEN_GET ) +return 0 ; + + subsc_evt->events =cpu_to_le16 (subsc_evt_cfg->events); + + event_bitmap = subsc_evt_cfg->events; +nxpwifi_dbg (priv->adapter,CMD ,"cmd: event bitmap : %16x\n" , + event_bitmap); + +if ((subsc_evt_cfg->action ==HOST_ACT_BITWISE_CLR || + subsc_evt_cfg->action ==HOST_ACT_BITWISE_SET ) && + event_bitmap ==0 ) { +nxpwifi_dbg (priv->adapter,ERROR , +"Error: No event specified\t" +"for bitwise action type\n" ); +return -EINVAL ; + } + +/* Append TLV structures for each of the specified events for +* subscribing or re-configuring. This is not required for +* bitwise unsubscribing request. +*/ +if (subsc_evt_cfg->action ==HOST_ACT_BITWISE_CLR ) +return 0 ; + + pos = ((u8 *)subsc_evt) + +sizeof (struct host_cmd_ds_802_11_subsc_evt ); + +if (event_bitmap &BITMASK_BCN_RSSI_LOW ) { + rssi_tlv = (struct nxpwifi_ie_types_rssi_threshold *)pos; + + rssi_tlv->header.type =cpu_to_le16 (TLV_TYPE_RSSI_LOW ); + rssi_tlv->header.len = +cpu_to_le16 (sizeof (struct nxpwifi_ie_types_rssi_threshold ) - +sizeof (struct nxpwifi_ie_types_header )); + rssi_tlv->abs_value = subsc_evt_cfg->bcn_l_rssi_cfg.abs_value; + rssi_tlv->evt_freq = subsc_evt_cfg->bcn_l_rssi_cfg.evt_freq; + +nxpwifi_dbg (priv->adapter,EVENT , +"Cfg Beacon Low Rssi event,\t" +"RSSI:-%d dBm, Freq:%d\n" , + subsc_evt_cfg->bcn_l_rssi_cfg.abs_value, + subsc_evt_cfg->bcn_l_rssi_cfg.evt_freq); + + pos +=sizeof (struct nxpwifi_ie_types_rssi_threshold ); +le16_unaligned_add_cpu + (&cmd->size, +sizeof (struct nxpwifi_ie_types_rssi_threshold )); + } + +if (event_bitmap &BITMASK_BCN_RSSI_HIGH ) { + rssi_tlv = (struct nxpwifi_ie_types_rssi_threshold *)pos; + + rssi_tlv->header.type =cpu_to_le16 (TLV_TYPE_RSSI_HIGH ); + rssi_tlv->header.len = +cpu_to_le16 (sizeof (struct nxpwifi_ie_types_rssi_threshold ) - +sizeof (struct nxpwifi_ie_types_header )); + rssi_tlv->abs_value = subsc_evt_cfg->bcn_h_rssi_cfg.abs_value; + rssi_tlv->evt_freq = subsc_evt_cfg->bcn_h_rssi_cfg.evt_freq; + +nxpwifi_dbg (priv->adapter,EVENT , +"Cfg Beacon High Rssi event,\t" +"RSSI:-%d dBm, Freq:%d\n" , + subsc_evt_cfg->bcn_h_rssi_cfg.abs_value, + subsc_evt_cfg->bcn_h_rssi_cfg.evt_freq); + + pos +=sizeof (struct nxpwifi_ie_types_rssi_threshold ); +le16_unaligned_add_cpu + (&cmd->size, +sizeof (struct nxpwifi_ie_types_rssi_threshold )); + } + +return 0 ; +} + +static int +nxpwifi_ret_sta_subsc_evt (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_802_11_subsc_evt *cmd_sub_event = + &resp->params.subsc_evt; + +/* For every subscribe event command (Get/Set/Clear), FW reports the +* current set of subscribed events +*/ +nxpwifi_dbg (priv->adapter,EVENT , +"Bitmap of currently subscribed events: %16x\n" , +le16_to_cpu (cmd_sub_event->events)); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_tx_rate_query (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (HOST_CMD_802_11_TX_RATE_QUERY ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_tx_rate_query ) + +S_DS_GEN ); + priv->tx_rate =0 ; + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_tx_rate_query (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ + priv->tx_rate = resp->params.tx_rate.tx_rate; + priv->tx_htinfo = resp->params.tx_rate.ht_info; +if (!priv->is_data_rate_auto) + priv->data_rate = +nxpwifi_index_to_data_rate (priv, priv->tx_rate, + priv->tx_htinfo); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_mem_access (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct nxpwifi_ds_mem_rw *mem_rw = + (struct nxpwifi_ds_mem_rw *)data_buf; +struct host_cmd_ds_mem_access *mem_access = (void *)&cmd->params.mem; + + cmd->command =cpu_to_le16 (HOST_CMD_MEM_ACCESS ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_mem_access ) + +S_DS_GEN ); + + mem_access->action =cpu_to_le16 (cmd_action); + mem_access->addr =cpu_to_le32 (mem_rw->addr); + mem_access->value =cpu_to_le32 (mem_rw->value); + +return 0 ; +} + +static int +nxpwifi_ret_sta_mem_access (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_mem_access *mem = (void *)&resp->params.mem; + + priv->mem_rw.addr =le32_to_cpu (mem->addr); + priv->mem_rw.value =le32_to_cpu (mem->value); + +return 0 ; +} + +static u32 nxpwifi_parse_cal_cfg (u8 *src,size_t len,u8 *dst) +{ +u8 *s = src, *d = dst; + +while (s - src < len) { +if (*s && (isspace (*s) || *s =='\t' )) { + s++; +continue ; + } +if (isxdigit (*s)) { +if (kstrtou8 (s,16 , d)) +return 0 ; + d++; + s +=2 ; + }else { + s++; + } + } + +return d - dst; +} + +static int +nxpwifi_cmd_sta_cfg_data (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct property *prop = data_buf; +u32 len; +u8 *data = (u8 *)cmd +S_DS_GEN ; +int ret; + +if (prop) { + len = prop->length; + ret =of_property_read_u8_array (adapter->dt_node, prop->name, + data, len); +if (ret) +return ret; +nxpwifi_dbg (adapter,INFO , +"download cfg_data from device tree: %s\n" , + prop->name); + }else if (adapter->cal_data->data && adapter->cal_data->size >0 ) { + len =nxpwifi_parse_cal_cfg ((u8 *)adapter->cal_data->data, + adapter->cal_data->size, data); +nxpwifi_dbg (adapter,INFO , +"download cfg_data from config file\n" ); + }else { +return -1 ; + } + + cmd->command =cpu_to_le16 (HOST_CMD_CFG_DATA ); + cmd->size =cpu_to_le16 (S_DS_GEN + len); + +return 0 ; +} + +static int +nxpwifi_ret_sta_cfg_data (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +if (resp->result !=HOST_RESULT_OK ) { +nxpwifi_dbg (priv->adapter,ERROR ,"Cal data cmd resp failed\n" ); +return -1 ; + } + +return 0 ; +} + +static int +nxpwifi_cmd_sta_ver_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (cmd_no); + cmd->params.verext.version_str_sel = + (u8)(get_unaligned ((u32 *)data_buf)); +memcpy (&cmd->params, data_buf,sizeof (struct host_cmd_ds_version_ext )); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_version_ext ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_ver_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_version_ext *ver_ext = &resp->params.verext; +struct host_cmd_ds_version_ext *version_ext = + (struct host_cmd_ds_version_ext *)data_buf; + +if (test_and_clear_bit (NXPWIFI_IS_REQUESTING_FW_VEREXT , &priv->adapter->work_flags)) { +if (strncmp (ver_ext->version_str,"ChipRev:20, BB:9b(10.00), RF:40(21)" , +NXPWIFI_VERSION_STR_LENGTH ) ==0 ) { +struct nxpwifi_ds_auto_ds auto_ds = { + .auto_ds =DEEP_SLEEP_OFF , + }; + +nxpwifi_dbg (priv->adapter,MSG , +"Bad HW revision detected, disabling deep sleep\n" ); + +if (nxpwifi_send_cmd (priv,HOST_CMD_802_11_PS_MODE_ENH , +DIS_AUTO_PS ,BITMAP_AUTO_DS , &auto_ds, false)) { +nxpwifi_dbg (priv->adapter,MSG , +"Disabling deep sleep failed.\n" ); + } + } + +return 0 ; + } + +if (version_ext) { + version_ext->version_str_sel = ver_ext->version_str_sel; +memcpy (version_ext->version_str, ver_ext->version_str, +NXPWIFI_VERSION_STR_LENGTH ); +memcpy (priv->version_str, ver_ext->version_str, +NXPWIFI_VERSION_STR_LENGTH ); + +/* Ensure the version string from the firmware is 0-terminated */ + priv->version_str[NXPWIFI_VERSION_STR_LENGTH -1 ] ='\0' ; + } +return 0 ; +} + +static int +nxpwifi_cmd_append_rpn_expression (struct nxpwifi_private *priv, +struct nxpwifi_mef_entry *mef_entry, +u8 **buffer) +{ +struct nxpwifi_mef_filter *filter = mef_entry->filter; +int i, byte_len; +u8 *stack_ptr = *buffer; + +for (i =0 ; i <NXPWIFI_MEF_MAX_FILTERS ; i++) { + filter = &mef_entry->filter[i]; +if (!filter->filt_type) +break ; +put_unaligned_le32 ((u32 )filter->repeat, stack_ptr); + stack_ptr +=4 ; + *stack_ptr =TYPE_DNUM ; + stack_ptr +=1 ; + + byte_len = filter->byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ]; +memcpy (stack_ptr, filter->byte_seq, byte_len); + stack_ptr += byte_len; + *stack_ptr = byte_len; + stack_ptr +=1 ; + *stack_ptr =TYPE_BYTESEQ ; + stack_ptr +=1 ; +put_unaligned_le32 ((u32 )filter->offset, stack_ptr); + stack_ptr +=4 ; + *stack_ptr =TYPE_DNUM ; + stack_ptr +=1 ; + + *stack_ptr = filter->filt_type; + stack_ptr +=1 ; + +if (filter->filt_action) { + *stack_ptr = filter->filt_action; + stack_ptr +=1 ; + } + +if (stack_ptr - *buffer >STACK_NBYTES ) +return -1 ; + } + + *buffer = stack_ptr; +return 0 ; +} + +static int +nxpwifi_cmd_sta_mef_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_mef_cfg *mef_cfg = &cmd->params.mef_cfg; +struct nxpwifi_ds_mef_cfg *mef = + (struct nxpwifi_ds_mef_cfg *)data_buf; +struct nxpwifi_fw_mef_entry *mef_entry =NULL ; +u8 *pos = (u8 *)mef_cfg; +u16 i; + + cmd->command =cpu_to_le16 (HOST_CMD_MEF_CFG ); + + mef_cfg->criteria =cpu_to_le32 (mef->criteria); + mef_cfg->num_entries =cpu_to_le16 (mef->num_entries); + pos +=sizeof (*mef_cfg); + +for (i =0 ; i < mef->num_entries; i++) { + mef_entry = (struct nxpwifi_fw_mef_entry *)pos; + mef_entry->mode = mef->mef_entry[i].mode; + mef_entry->action = mef->mef_entry[i].action; + pos +=sizeof (*mef_entry); + +if (nxpwifi_cmd_append_rpn_expression (priv, + &mef->mef_entry[i], &pos)) +return -1 ; + + mef_entry->exprsize = +cpu_to_le16 (pos - mef_entry->expr); + } + cmd->size =cpu_to_le16 ((u16)(pos - (u8 *)mef_cfg) +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_rssi_info (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (HOST_CMD_RSSI_INFO ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_802_11_rssi_info ) + +S_DS_GEN ); + cmd->params.rssi_info.action =cpu_to_le16 (cmd_action); + cmd->params.rssi_info.ndata =cpu_to_le16 (priv->data_avg_factor); + cmd->params.rssi_info.nbcn =cpu_to_le16 (priv->bcn_avg_factor); + +/* Reset SNR/NF/RSSI values in private structure */ + priv->data_rssi_last =0 ; + priv->data_nf_last =0 ; + priv->data_rssi_avg =0 ; + priv->data_nf_avg =0 ; + priv->bcn_rssi_last =0 ; + priv->bcn_nf_last =0 ; + priv->bcn_rssi_avg =0 ; + priv->bcn_nf_avg =0 ; + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_rssi_info (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_802_11_rssi_info_rsp *rssi_info_rsp = + &resp->params.rssi_info_rsp; +struct nxpwifi_ds_misc_subsc_evt *subsc_evt = + &priv->async_subsc_evt_storage; + + priv->data_rssi_last =le16_to_cpu (rssi_info_rsp->data_rssi_last); + priv->data_nf_last =le16_to_cpu (rssi_info_rsp->data_nf_last); + + priv->data_rssi_avg =le16_to_cpu (rssi_info_rsp->data_rssi_avg); + priv->data_nf_avg =le16_to_cpu (rssi_info_rsp->data_nf_avg); + + priv->bcn_rssi_last =le16_to_cpu (rssi_info_rsp->bcn_rssi_last); + priv->bcn_nf_last =le16_to_cpu (rssi_info_rsp->bcn_nf_last); + + priv->bcn_rssi_avg =le16_to_cpu (rssi_info_rsp->bcn_rssi_avg); + priv->bcn_nf_avg =le16_to_cpu (rssi_info_rsp->bcn_nf_avg); + +if (priv->subsc_evt_rssi_state ==EVENT_HANDLED ) +return 0 ; + +memset (subsc_evt,0x00 ,sizeof (struct nxpwifi_ds_misc_subsc_evt )); + +/* Resubscribe low and high rssi events with new thresholds */ + subsc_evt->events =BITMASK_BCN_RSSI_LOW |BITMASK_BCN_RSSI_HIGH ; + subsc_evt->action =HOST_ACT_BITWISE_SET ; +if (priv->subsc_evt_rssi_state ==RSSI_LOW_RECVD ) { + subsc_evt->bcn_l_rssi_cfg.abs_value =abs (priv->bcn_rssi_avg - + priv->cqm_rssi_hyst); + subsc_evt->bcn_h_rssi_cfg.abs_value =abs (priv->cqm_rssi_thold); + }else if (priv->subsc_evt_rssi_state ==RSSI_HIGH_RECVD ) { + subsc_evt->bcn_l_rssi_cfg.abs_value =abs (priv->cqm_rssi_thold); + subsc_evt->bcn_h_rssi_cfg.abs_value =abs (priv->bcn_rssi_avg + + priv->cqm_rssi_hyst); + } + subsc_evt->bcn_l_rssi_cfg.evt_freq =1 ; + subsc_evt->bcn_h_rssi_cfg.evt_freq =1 ; + + priv->subsc_evt_rssi_state =EVENT_HANDLED ; + +nxpwifi_send_cmd (priv,HOST_CMD_802_11_SUBSCRIBE_EVENT , +0 ,0 , subsc_evt, false); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_func_init (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +if (priv->adapter->hw_status ==NXPWIFI_HW_STATUS_RESET ) + priv->adapter->hw_status =NXPWIFI_HW_STATUS_READY ; + cmd->command =cpu_to_le16 (cmd_no); + cmd->size =cpu_to_le16 (S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_func_shutdown (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + priv->adapter->hw_status =NXPWIFI_HW_STATUS_RESET ; + cmd->command =cpu_to_le16 (cmd_no); + cmd->size =cpu_to_le16 (S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_11n_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_11n_cfg (priv, cmd, cmd_action, data_buf); +} + +static int +nxpwifi_cmd_sta_11n_addba_req (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_11n_addba_req (cmd, data_buf); +} + +static int +nxpwifi_ret_sta_11n_addba_req (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +return nxpwifi_ret_11n_addba_req (priv, resp); +} + +static int +nxpwifi_cmd_sta_11n_addba_rsp (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_11n_addba_rsp_gen (priv, cmd, data_buf); +} + +static int +nxpwifi_ret_sta_11n_addba_rsp (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +return nxpwifi_ret_11n_addba_resp (priv, resp); +} + +static int +nxpwifi_cmd_sta_11n_delba (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_11n_delba (cmd, data_buf); +} + +static int +nxpwifi_ret_sta_11n_delba (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +return nxpwifi_ret_11n_delba (priv, resp); +} + +static int +nxpwifi_cmd_sta_tx_power_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct nxpwifi_types_power_group *pg_tlv; +struct host_cmd_ds_txpwr_cfg *cmd_txp_cfg = &cmd->params.txp_cfg; +struct host_cmd_ds_txpwr_cfg *txp = + (struct host_cmd_ds_txpwr_cfg *)data_buf; + + cmd->command =cpu_to_le16 (HOST_CMD_TXPWR_CFG ); + cmd->size = +cpu_to_le16 (S_DS_GEN +sizeof (struct host_cmd_ds_txpwr_cfg )); +switch (cmd_action) { +case HOST_ACT_GEN_SET : +if (txp->mode) { + pg_tlv = (struct nxpwifi_types_power_group + *)((unsigned long )txp + +sizeof (struct host_cmd_ds_txpwr_cfg )); +memmove (cmd_txp_cfg, txp, +sizeof (struct host_cmd_ds_txpwr_cfg ) + +sizeof (struct nxpwifi_types_power_group ) + +le16_to_cpu (pg_tlv->length)); + + pg_tlv = (struct nxpwifi_types_power_group *)((u8 *) + cmd_txp_cfg + +sizeof (struct host_cmd_ds_txpwr_cfg )); + cmd->size =cpu_to_le16 (le16_to_cpu (cmd->size) + +sizeof (struct nxpwifi_types_power_group ) + +le16_to_cpu (pg_tlv->length)); + }else { +memmove (cmd_txp_cfg, txp,sizeof (*txp)); + } + cmd_txp_cfg->action =cpu_to_le16 (cmd_action); +break ; +case HOST_ACT_GEN_GET : + cmd_txp_cfg->action =cpu_to_le16 (cmd_action); +break ; + } + +return 0 ; +} + +static int nxpwifi_get_power_level (struct nxpwifi_private *priv,void *data_buf) +{ +int length, max_power =-1 , min_power =-1 ; +struct nxpwifi_types_power_group *pg_tlv_hdr; +struct nxpwifi_power_group *pg; + +if (!data_buf) +return -1 ; + + pg_tlv_hdr = (struct nxpwifi_types_power_group *)((u8 *)data_buf); + pg = (struct nxpwifi_power_group *) + ((u8 *)pg_tlv_hdr +sizeof (struct nxpwifi_types_power_group )); + length =le16_to_cpu (pg_tlv_hdr->length); + +/* At least one structure required to update power */ +if (length <sizeof (struct nxpwifi_power_group )) +return 0 ; + + max_power = pg->power_max; + min_power = pg->power_min; + length -=sizeof (struct nxpwifi_power_group ); + +while (length >=sizeof (struct nxpwifi_power_group )) { + pg++; +if (max_power < pg->power_max) + max_power = pg->power_max; + +if (min_power > pg->power_min) + min_power = pg->power_min; + + length -=sizeof (struct nxpwifi_power_group ); + } + priv->min_tx_power_level = (u8 )min_power; + priv->max_tx_power_level = (u8 )max_power; + +return 0 ; +} + +static int +nxpwifi_ret_sta_tx_power_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_txpwr_cfg *txp_cfg = &resp->params.txp_cfg; +struct nxpwifi_types_power_group *pg_tlv_hdr; +struct nxpwifi_power_group *pg; +u16 action =le16_to_cpu (txp_cfg->action); +u16 tlv_buf_left; + + pg_tlv_hdr = (struct nxpwifi_types_power_group *) + ((u8 *)txp_cfg + +sizeof (struct host_cmd_ds_txpwr_cfg )); + + pg = (struct nxpwifi_power_group *) + ((u8 *)pg_tlv_hdr + +sizeof (struct nxpwifi_types_power_group )); + + tlv_buf_left =le16_to_cpu (resp->size) -S_DS_GEN -sizeof (*txp_cfg); +if (tlv_buf_left < +le16_to_cpu (pg_tlv_hdr->length) +sizeof (*pg_tlv_hdr)) +return 0 ; + +switch (action) { +case HOST_ACT_GEN_GET : +if (adapter->hw_status ==NXPWIFI_HW_STATUS_INITIALIZING ) +nxpwifi_get_power_level (priv, pg_tlv_hdr); + + priv->tx_power_level = (u16 )pg->power_min; +break ; + +case HOST_ACT_GEN_SET : +if (!le32_to_cpu (txp_cfg->mode)) +break ; + +if (pg->power_max == pg->power_min) + priv->tx_power_level = (u16 )pg->power_min; +break ; +default : +nxpwifi_dbg (adapter,ERROR , +"CMD_RESP: unknown cmd action %d\n" , + action); +return 0 ; + } +nxpwifi_dbg (adapter,INFO , +"info: Current TxPower Level = %d, Max Power=%d, Min Power=%d\n" , + priv->tx_power_level, priv->max_tx_power_level, + priv->min_tx_power_level); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_tx_rate_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_tx_rate_cfg *rate_cfg = &cmd->params.tx_rate_cfg; +u16 *pbitmap_rates = (u16 *)data_buf; +struct nxpwifi_rate_scope *rate_scope; +struct nxpwifi_rate_drop_pattern *rate_drop; +u32 i; + + cmd->command =cpu_to_le16 (HOST_CMD_TX_RATE_CFG ); + + rate_cfg->action =cpu_to_le16 (cmd_action); + rate_cfg->cfg_index =0 ; + + rate_scope = (struct nxpwifi_rate_scope *)((u8 *)rate_cfg + +sizeof (struct host_cmd_ds_tx_rate_cfg )); + rate_scope->type =cpu_to_le16 (TLV_TYPE_RATE_SCOPE ); + rate_scope->length =cpu_to_le16 + (sizeof (*rate_scope) -sizeof (struct nxpwifi_ie_types_header )); +if (pbitmap_rates) { + rate_scope->hr_dsss_rate_bitmap =cpu_to_le16 (pbitmap_rates[0 ]); + rate_scope->ofdm_rate_bitmap =cpu_to_le16 (pbitmap_rates[1 ]); +for (i =0 ; i <ARRAY_SIZE (rate_scope->ht_mcs_rate_bitmap); i++) + rate_scope->ht_mcs_rate_bitmap[i] = +cpu_to_le16 (pbitmap_rates[2 + i]); +if (priv->adapter->fw_api_ver ==NXPWIFI_FW_V15 ) { +for (i =0 ; + i <ARRAY_SIZE (rate_scope->vht_mcs_rate_bitmap); + i++) + rate_scope->vht_mcs_rate_bitmap[i] = +cpu_to_le16 (pbitmap_rates[10 + i]); + } + }else { + rate_scope->hr_dsss_rate_bitmap = +cpu_to_le16 (priv->bitmap_rates[0 ]); + rate_scope->ofdm_rate_bitmap = +cpu_to_le16 (priv->bitmap_rates[1 ]); +for (i =0 ; i <ARRAY_SIZE (rate_scope->ht_mcs_rate_bitmap); i++) + rate_scope->ht_mcs_rate_bitmap[i] = +cpu_to_le16 (priv->bitmap_rates[2 + i]); +if (priv->adapter->fw_api_ver ==NXPWIFI_FW_V15 ) { +for (i =0 ; + i <ARRAY_SIZE (rate_scope->vht_mcs_rate_bitmap); + i++) + rate_scope->vht_mcs_rate_bitmap[i] = +cpu_to_le16 (priv->bitmap_rates[10 + i]); + } + } + + rate_drop = (struct nxpwifi_rate_drop_pattern *)((u8 *)rate_scope + +sizeof (struct nxpwifi_rate_scope )); + rate_drop->type =cpu_to_le16 (TLV_TYPE_RATE_DROP_CONTROL ); + rate_drop->length =cpu_to_le16 (sizeof (rate_drop->rate_drop_mode)); + rate_drop->rate_drop_mode =0 ; + + cmd->size = +cpu_to_le16 (S_DS_GEN +sizeof (struct host_cmd_ds_tx_rate_cfg ) + +sizeof (struct nxpwifi_rate_scope ) + +sizeof (struct nxpwifi_rate_drop_pattern )); + +return 0 ; +} + +static void nxpwifi_ret_rate_scope (struct nxpwifi_private *priv,u8 *tlv_buf) +{ +struct nxpwifi_rate_scope *rate_scope; +int i; + + rate_scope = (struct nxpwifi_rate_scope *)tlv_buf; + priv->bitmap_rates[0 ] = +le16_to_cpu (rate_scope->hr_dsss_rate_bitmap); + priv->bitmap_rates[1 ] = +le16_to_cpu (rate_scope->ofdm_rate_bitmap); +for (i =0 ; i <ARRAY_SIZE (rate_scope->ht_mcs_rate_bitmap); i++) + priv->bitmap_rates[2 + i] = +le16_to_cpu (rate_scope->ht_mcs_rate_bitmap[i]); + +if (priv->adapter->fw_api_ver ==NXPWIFI_FW_V15 ) { +for (i =0 ; i <ARRAY_SIZE (rate_scope->vht_mcs_rate_bitmap); + i++) + priv->bitmap_rates[10 + i] = +le16_to_cpu (rate_scope->vht_mcs_rate_bitmap[i]); + } +} + +static int +nxpwifi_ret_sta_tx_rate_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_tx_rate_cfg *rate_cfg = &resp->params.tx_rate_cfg; +struct nxpwifi_ie_types_header *head; +u16 tlv, tlv_buf_len, tlv_buf_left; +u8 *tlv_buf; + + tlv_buf = ((u8 *)rate_cfg) +sizeof (struct host_cmd_ds_tx_rate_cfg ); + tlv_buf_left =le16_to_cpu (resp->size) -S_DS_GEN -sizeof (*rate_cfg); + +while (tlv_buf_left >=sizeof (*head)) { + head = (struct nxpwifi_ie_types_header *)tlv_buf; + tlv =le16_to_cpu (head->type); + tlv_buf_len =le16_to_cpu (head->len); + +if (tlv_buf_left < (sizeof (*head) + tlv_buf_len)) +break ; + +switch (tlv) { +case TLV_TYPE_RATE_SCOPE : +nxpwifi_ret_rate_scope (priv, tlv_buf); +break ; +/* Add RATE_DROP tlv here */ + } + + tlv_buf += (sizeof (*head) + tlv_buf_len); + tlv_buf_left -= (sizeof (*head) + tlv_buf_len); + } + + priv->is_data_rate_auto =nxpwifi_is_rate_auto (priv); + +if (priv->is_data_rate_auto) + priv->data_rate =0 ; +else +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_TX_RATE_QUERY , +HOST_ACT_GEN_GET ,0 ,NULL , false); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_reconfigure_rx_buff (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_recfg_tx_buf (priv, cmd, cmd_action, data_buf); +} + +static int +nxpwifi_ret_sta_reconfigure_rx_buff (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +if (0xffff != (u16 )le16_to_cpu (resp->params.tx_buf.buff_size)) { + adapter->tx_buf_size = + (u16 )le16_to_cpu (resp->params.tx_buf.buff_size); + adapter->tx_buf_size = + (adapter->tx_buf_size /NXPWIFI_SDIO_BLOCK_SIZE ) * +NXPWIFI_SDIO_BLOCK_SIZE ; + adapter->curr_tx_buf_size = adapter->tx_buf_size; +nxpwifi_dbg (adapter,CMD ,"cmd: curr_tx_buf_size=%d\n" , + adapter->curr_tx_buf_size); + +if (adapter->if_ops.update_mp_end_port) { +u16 mp_end_port; + + mp_end_port = +le16_to_cpu (resp->params.tx_buf.mp_end_port); + adapter->if_ops.update_mp_end_port (adapter, + mp_end_port); + } + } + +return 0 ; +} + +static int +nxpwifi_cmd_sta_chan_report_request (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_issue_chan_report_request (priv, cmd, data_buf); +} + +static int +nxpwifi_cmf_sta_amsdu_aggr_ctrl (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_amsdu_aggr_ctrl (cmd, cmd_action, data_buf); +} + +static int +nxpwifi_cmd_sta_robust_coex (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_robust_coex *coex = &cmd->params.coex; +bool *is_timeshare = (bool *)data_buf; +struct nxpwifi_ie_types_robust_coex *coex_tlv; + + cmd->command =cpu_to_le16 (HOST_CMD_ROBUST_COEX ); + cmd->size =cpu_to_le16 (sizeof (*coex) +sizeof (*coex_tlv) +S_DS_GEN ); + + coex->action =cpu_to_le16 (cmd_action); + coex_tlv = (struct nxpwifi_ie_types_robust_coex *) + ((u8 *)coex +sizeof (*coex)); + coex_tlv->header.type =cpu_to_le16 (TLV_TYPE_ROBUST_COEX ); + coex_tlv->header.len =cpu_to_le16 (sizeof (coex_tlv->mode)); + +if (coex->action ==HOST_ACT_GEN_GET ) +return 0 ; + +if (*is_timeshare) + coex_tlv->mode =cpu_to_le32 (NXPWIFI_COEX_MODE_TIMESHARE ); +else + coex_tlv->mode =cpu_to_le32 (NXPWIFI_COEX_MODE_SPATIAL ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_robust_coex (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_robust_coex *coex = &resp->params.coex; +bool *is_timeshare = (bool *)data_buf; +struct nxpwifi_ie_types_robust_coex *coex_tlv; +u16 action =le16_to_cpu (coex->action); +u32 mode; + + coex_tlv = (struct nxpwifi_ie_types_robust_coex + *)((u8 *)coex +sizeof (struct host_cmd_ds_robust_coex )); +if (action ==HOST_ACT_GEN_GET ) { + mode =le32_to_cpu (coex_tlv->mode); +if (mode ==NXPWIFI_COEX_MODE_TIMESHARE ) + *is_timeshare = true; +else + *is_timeshare = false; + } + +return 0 ; +} + +static int +nxpwifi_cmd_sta_enh_power_mode (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_802_11_ps_mode_enh *psmode_enh = + &cmd->params.psmode_enh; +u16 ps_bitmap = (u16 )cmd_type; +struct nxpwifi_ds_auto_ds *auto_ds = + (struct nxpwifi_ds_auto_ds *)data_buf; +u8 *tlv; +u16 cmd_size =0 ; + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_PS_MODE_ENH ); +if (cmd_action ==DIS_AUTO_PS ) { + psmode_enh->action =cpu_to_le16 (DIS_AUTO_PS ); + psmode_enh->params.ps_bitmap =cpu_to_le16 (ps_bitmap); + cmd->size =cpu_to_le16 (S_DS_GEN +sizeof (psmode_enh->action) + +sizeof (psmode_enh->params.ps_bitmap)); + }else if (cmd_action ==GET_PS ) { + psmode_enh->action =cpu_to_le16 (GET_PS ); + psmode_enh->params.ps_bitmap =cpu_to_le16 (ps_bitmap); + cmd->size =cpu_to_le16 (S_DS_GEN +sizeof (psmode_enh->action) + +sizeof (psmode_enh->params.ps_bitmap)); + }else if (cmd_action ==EN_AUTO_PS ) { + psmode_enh->action =cpu_to_le16 (EN_AUTO_PS ); + psmode_enh->params.ps_bitmap =cpu_to_le16 (ps_bitmap); + cmd_size =S_DS_GEN +sizeof (psmode_enh->action) + +sizeof (psmode_enh->params.ps_bitmap); + tlv = (u8 *)cmd + cmd_size; +if (ps_bitmap &BITMAP_STA_PS ) { +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_ie_types_ps_param *ps_tlv = + (struct nxpwifi_ie_types_ps_param *)tlv; +struct nxpwifi_ps_param *ps_mode = &ps_tlv->param; + + ps_tlv->header.type =cpu_to_le16 (TLV_TYPE_PS_PARAM ); + ps_tlv->header.len =cpu_to_le16 (sizeof (*ps_tlv) - +sizeof (struct nxpwifi_ie_types_header )); + cmd_size +=sizeof (*ps_tlv); + tlv +=sizeof (*ps_tlv); +nxpwifi_dbg (priv->adapter,CMD , +"cmd: PS Command: Enter PS\n" ); + ps_mode->null_pkt_interval = +cpu_to_le16 (adapter->null_pkt_interval); + ps_mode->multiple_dtims = +cpu_to_le16 (adapter->multiple_dtim); + ps_mode->bcn_miss_timeout = +cpu_to_le16 (adapter->bcn_miss_time_out); + ps_mode->local_listen_interval = +cpu_to_le16 (adapter->local_listen_interval); + ps_mode->delay_to_ps = +cpu_to_le16 (adapter->delay_to_ps); + ps_mode->mode =cpu_to_le16 (adapter->enhanced_ps_mode); + } +if (ps_bitmap &BITMAP_AUTO_DS ) { +struct nxpwifi_ie_types_auto_ds_param *auto_ds_tlv = + (struct nxpwifi_ie_types_auto_ds_param *)tlv; +u16 idletime =0 ; + + auto_ds_tlv->header.type = +cpu_to_le16 (TLV_TYPE_AUTO_DS_PARAM ); + auto_ds_tlv->header.len = +cpu_to_le16 (sizeof (*auto_ds_tlv) - +sizeof (struct nxpwifi_ie_types_header )); + cmd_size +=sizeof (*auto_ds_tlv); + tlv +=sizeof (*auto_ds_tlv); +if (auto_ds) + idletime = auto_ds->idle_time; +nxpwifi_dbg (priv->adapter,CMD , +"cmd: PS Command: Enter Auto Deep Sleep\n" ); + auto_ds_tlv->deep_sleep_timeout =cpu_to_le16 (idletime); + } + cmd->size =cpu_to_le16 (cmd_size); + } +return 0 ; +} + +static int +nxpwifi_ret_sta_enh_power_mode (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_802_11_ps_mode_enh *ps_mode = + &resp->params.psmode_enh; +struct nxpwifi_ds_pm_cfg *pm_cfg = + (struct nxpwifi_ds_pm_cfg *)data_buf; +u16 action =le16_to_cpu (ps_mode->action); +u16 ps_bitmap =le16_to_cpu (ps_mode->params.ps_bitmap); +u16 auto_ps_bitmap = +le16_to_cpu (ps_mode->params.ps_bitmap); + +nxpwifi_dbg (adapter,INFO , +"info: %s: PS_MODE cmd reply result=%#x action=%#X\n" , + __func__, resp->result, action); +if (action ==EN_AUTO_PS ) { +if (auto_ps_bitmap &BITMAP_AUTO_DS ) { +nxpwifi_dbg (adapter,CMD , +"cmd: Enabled auto deep sleep\n" ); + priv->adapter->is_deep_sleep = true; + } +if (auto_ps_bitmap &BITMAP_STA_PS ) { +nxpwifi_dbg (adapter,CMD , +"cmd: Enabled STA power save\n" ); +if (adapter->sleep_period.period) +nxpwifi_dbg (adapter,CMD , +"cmd: set to uapsd/pps mode\n" ); + } + }else if (action ==DIS_AUTO_PS ) { +if (ps_bitmap &BITMAP_AUTO_DS ) { + priv->adapter->is_deep_sleep = false; +nxpwifi_dbg (adapter,CMD , +"cmd: Disabled auto deep sleep\n" ); + } +if (ps_bitmap &BITMAP_STA_PS ) { +nxpwifi_dbg (adapter,CMD , +"cmd: Disabled STA power save\n" ); +if (adapter->sleep_period.period) { + adapter->delay_null_pkt = false; + adapter->tx_lock_flag = false; + adapter->pps_uapsd_mode = false; + } + } + }else if (action ==GET_PS ) { +if (ps_bitmap &BITMAP_STA_PS ) + adapter->ps_mode =NXPWIFI_802_11_POWER_MODE_PSP ; +else + adapter->ps_mode =NXPWIFI_802_11_POWER_MODE_CAM ; + +nxpwifi_dbg (adapter,CMD , +"cmd: ps_bitmap=%#x\n" , ps_bitmap); + +if (pm_cfg) { +/* This section is for get power save mode */ +if (ps_bitmap &BITMAP_STA_PS ) + pm_cfg->param.ps_mode =1 ; +else + pm_cfg->param.ps_mode =0 ; + } + } +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_hs_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_802_11_hs_cfg_enh *hs_cfg = &cmd->params.opt_hs_cfg; +struct nxpwifi_hs_config_param *hscfg_param = + (struct nxpwifi_hs_config_param *)data_buf; +u8 *tlv = (u8 *)hs_cfg +sizeof (struct host_cmd_ds_802_11_hs_cfg_enh ); +struct nxpwifi_ps_param_in_hs *psparam_tlv =NULL ; +bool hs_activate = false; +u16 size; + +if (!hscfg_param) +/* New Activate command */ + hs_activate = true; + cmd->command =cpu_to_le16 (HOST_CMD_802_11_HS_CFG_ENH ); + +if (!hs_activate && + hscfg_param->conditions !=cpu_to_le32 (HS_CFG_CANCEL ) && + (adapter->arp_filter_size >0 && + adapter->arp_filter_size <=ARP_FILTER_MAX_BUF_SIZE )) { +nxpwifi_dbg (adapter,CMD , +"cmd: Attach %d bytes ArpFilter to HSCfg cmd\n" , + adapter->arp_filter_size); +memcpy (((u8 *)hs_cfg) + +sizeof (struct host_cmd_ds_802_11_hs_cfg_enh ), + adapter->arp_filter, adapter->arp_filter_size); + size = adapter->arp_filter_size + +sizeof (struct host_cmd_ds_802_11_hs_cfg_enh ) + +S_DS_GEN ; + tlv = (u8 *)hs_cfg + +sizeof (struct host_cmd_ds_802_11_hs_cfg_enh ) + + adapter->arp_filter_size; + }else { + size =S_DS_GEN +sizeof (struct host_cmd_ds_802_11_hs_cfg_enh ); + } +if (hs_activate) { + hs_cfg->action =cpu_to_le16 (HS_ACTIVATE ); + hs_cfg->params.hs_activate.resp_ctrl =cpu_to_le16 (RESP_NEEDED ); + + adapter->hs_activated_manually = true; +nxpwifi_dbg (priv->adapter,CMD , +"cmd: Activating host sleep manually\n" ); + }else { + hs_cfg->action =cpu_to_le16 (HS_CONFIGURE ); + hs_cfg->params.hs_config.conditions = hscfg_param->conditions; + hs_cfg->params.hs_config.gpio = hscfg_param->gpio; + hs_cfg->params.hs_config.gap = hscfg_param->gap; + + size +=sizeof (struct nxpwifi_ps_param_in_hs ); + psparam_tlv = (struct nxpwifi_ps_param_in_hs *)tlv; + psparam_tlv->header.type = +cpu_to_le16 (TLV_TYPE_PS_PARAMS_IN_HS ); + psparam_tlv->header.len = +cpu_to_le16 (sizeof (struct nxpwifi_ps_param_in_hs ) + -sizeof (struct nxpwifi_ie_types_header )); + psparam_tlv->hs_wake_int =cpu_to_le32 (HS_DEF_WAKE_INTERVAL ); + psparam_tlv->hs_inact_timeout = +cpu_to_le32 (HS_DEF_INACTIVITY_TIMEOUT ); + +nxpwifi_dbg (adapter,CMD , +"cmd: HS_CFG_CMD: condition:0x%x gpio:0x%x gap:0x%x\n" , + hs_cfg->params.hs_config.conditions, + hs_cfg->params.hs_config.gpio, + hs_cfg->params.hs_config.gap); + } + cmd->size =cpu_to_le16 (size); + +return 0 ; +} + +static int +nxpwifi_ret_sta_802_11_hs_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +return nxpwifi_ret_802_11_hs_cfg (priv, resp); +} + +static int +nxpwifi_cmd_sta_set_bss_mode (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (cmd_no); +if (priv->bss_mode ==NL80211_IFTYPE_STATION ) + cmd->params.bss_mode.con_type =CONNECTION_TYPE_INFRA ; +else if (priv->bss_mode ==NL80211_IFTYPE_AP ) + cmd->params.bss_mode.con_type =CONNECTION_TYPE_AP ; + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_set_bss_mode ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_802_11_scan_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_802_11_scan_ext (priv, cmd, data_buf); +} + +static int +nxpwifi_ret_sta_802_11_scan_ext (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret; + + ret =nxpwifi_ret_802_11_scan_ext (priv, resp); + adapter->curr_cmd->wait_q_enabled = false; + +return ret; +} + +static int +nxpwifi_cmd_sta_coalesce_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_coalesce_cfg *coalesce_cfg = + &cmd->params.coalesce_cfg; +struct nxpwifi_ds_coalesce_cfg *cfg = + (struct nxpwifi_ds_coalesce_cfg *)data_buf; +struct coalesce_filt_field_param *param; +u16 cnt, idx, length; +struct coalesce_receive_filt_rule *rule; + + cmd->command =cpu_to_le16 (HOST_CMD_COALESCE_CFG ); + cmd->size =cpu_to_le16 (S_DS_GEN ); + + coalesce_cfg->action =cpu_to_le16 (cmd_action); + coalesce_cfg->num_of_rules =cpu_to_le16 (cfg->num_of_rules); + rule = (void *)coalesce_cfg->rule_data; + +for (cnt =0 ; cnt < cfg->num_of_rules; cnt++) { + rule->header.type =cpu_to_le16 (TLV_TYPE_COALESCE_RULE ); + rule->max_coalescing_delay = +cpu_to_le16 (cfg->rule[cnt].max_coalescing_delay); + rule->pkt_type = cfg->rule[cnt].pkt_type; + rule->num_of_fields = cfg->rule[cnt].num_of_fields; + + length =0 ; + + param = rule->params; +for (idx =0 ; idx < cfg->rule[cnt].num_of_fields; idx++) { + param->operation = cfg->rule[cnt].params[idx].operation; + param->operand_len = + cfg->rule[cnt].params[idx].operand_len; + param->offset = +cpu_to_le16 (cfg->rule[cnt].params[idx].offset); +memcpy (param->operand_byte_stream, + cfg->rule[cnt].params[idx].operand_byte_stream, + param->operand_len); + + length +=sizeof (struct coalesce_filt_field_param ); + + param++; + } + +/* Total rule length is sizeof max_coalescing_delay(u16), +* num_of_fields(u8), pkt_type(u8) and total length of the all +* params +*/ + rule->header.len =cpu_to_le16 (length +sizeof (u16) + +sizeof (u8) +sizeof (u8)); + +/* Add the rule length to the command size*/ +le16_unaligned_add_cpu (&cmd->size, +le16_to_cpu (rule->header.len) + +sizeof (struct nxpwifi_ie_types_header )); + + rule = (void *)((u8 *)rule->params + length); + } + +/* Add sizeof action, num_of_rules to total command length */ +le16_unaligned_add_cpu (&cmd->size,sizeof (u16) +sizeof (u16)); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_mgmt_frame_reg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (cmd_no); + cmd->params.reg_mask.action =cpu_to_le16 (cmd_action); + cmd->params.reg_mask.mask = +cpu_to_le32 (get_unaligned ((u32 *)data_buf)); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_mgmt_frame_reg ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_remain_on_chan (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (cmd_no); +memcpy (&cmd->params, data_buf, +sizeof (struct host_cmd_ds_remain_on_chan )); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_remain_on_chan ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_remain_on_chan (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_remain_on_chan *resp_cfg = &resp->params.roc_cfg; +struct host_cmd_ds_remain_on_chan *roc_cfg = + (struct host_cmd_ds_remain_on_chan *)data_buf; + +if (roc_cfg) +memcpy (roc_cfg, resp_cfg,sizeof (*roc_cfg)); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_gtk_rekey_offload (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_gtk_rekey_params *rekey = &cmd->params.rekey; +struct cfg80211_gtk_rekey_data *data = + (struct cfg80211_gtk_rekey_data *)data_buf; +u64 rekey_ctr; + + cmd->command =cpu_to_le16 (HOST_CMD_GTK_REKEY_OFFLOAD_CFG ); + cmd->size =cpu_to_le16 (sizeof (*rekey) +S_DS_GEN ); + + rekey->action =cpu_to_le16 (cmd_action); +if (cmd_action ==HOST_ACT_GEN_SET ) { +memcpy (rekey->kek, data->kek,NL80211_KEK_LEN ); +memcpy (rekey->kck, data->kck,NL80211_KCK_LEN ); + rekey_ctr =be64_to_cpup ((__be64 *)data->replay_ctr); + rekey->replay_ctr_low =cpu_to_le32 ((u32 )rekey_ctr); + rekey->replay_ctr_high = +cpu_to_le32 ((u32)((u64 )rekey_ctr >>32 )); + } + +return 0 ; +} + +static int +nxpwifi_cmd_sta_11ac_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +return nxpwifi_cmd_11ac_cfg (priv, cmd, cmd_action, data_buf); +} + +static int +nxpwifi_cmd_sta_hs_wakeup_reason (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (HOST_CMD_HS_WAKEUP_REASON ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_wakeup_reason ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_hs_wakeup_reason (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_wakeup_reason *wakeup_reason = + (struct host_cmd_ds_wakeup_reason *)data_buf; + wakeup_reason->wakeup_reason = + resp->params.hs_wakeup_reason.wakeup_reason; + +return 0 ; +} + +static int +nxpwifi_cmd_sta_mc_policy (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_multi_chan_policy *mc_pol = &cmd->params.mc_policy; +const u16 *drcs_info = data_buf; + + mc_pol->action =cpu_to_le16 (cmd_action); + mc_pol->policy =cpu_to_le16 (*drcs_info); + cmd->command =cpu_to_le16 (HOST_CMD_MC_POLICY ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_multi_chan_policy ) + +S_DS_GEN ); +return 0 ; +} + +static int +nxpwifi_cmd_sta_sdio_rx_aggr_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_sdio_sp_rx_aggr_cfg *cfg = + &cmd->params.sdio_rx_aggr_cfg; + + cmd->command =cpu_to_le16 (HOST_CMD_SDIO_SP_RX_AGGR_CFG ); + cmd->size = +cpu_to_le16 (sizeof (struct host_cmd_sdio_sp_rx_aggr_cfg ) + +S_DS_GEN ); + cfg->action = cmd_action; +if (cmd_action ==HOST_ACT_GEN_SET ) + cfg->enable = *(u8 *)data_buf; + +return 0 ; +} + +static int +nxpwifi_ret_sta_sdio_rx_aggr_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_sdio_sp_rx_aggr_cfg *cfg = + &resp->params.sdio_rx_aggr_cfg; + + adapter->sdio_rx_aggr_enable = cfg->enable; + adapter->sdio_rx_block_size =le16_to_cpu (cfg->block_size); + +return 0 ; +} + +static int +nxpwifi_cmd_sta_get_chan_info (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_sta_configure *sta_cfg_cmd = &cmd->params.sta_cfg; +struct host_cmd_tlv_channel_band *tlv_band_channel = + (struct host_cmd_tlv_channel_band *)sta_cfg_cmd->tlv_buffer; + + cmd->command =cpu_to_le16 (HOST_CMD_STA_CONFIGURE ); + cmd->size =cpu_to_le16 (sizeof (*sta_cfg_cmd) + +sizeof (*tlv_band_channel) +S_DS_GEN ); + sta_cfg_cmd->action =cpu_to_le16 (cmd_action); +memset (tlv_band_channel,0 ,sizeof (*tlv_band_channel)); + tlv_band_channel->header.type =cpu_to_le16 (TLV_TYPE_CHANNELBANDLIST ); + tlv_band_channel->header.len =cpu_to_le16 (sizeof (*tlv_band_channel) - +sizeof (struct nxpwifi_ie_types_header )); + +return 0 ; +} + +static int +nxpwifi_ret_sta_get_chan_info (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_sta_configure *sta_cfg_cmd = &resp->params.sta_cfg; +struct nxpwifi_channel_band *channel_band = + (struct nxpwifi_channel_band *)data_buf; +struct host_cmd_tlv_channel_band *tlv_band_channel; + + tlv_band_channel = + (struct host_cmd_tlv_channel_band *)sta_cfg_cmd->tlv_buffer; +memcpy (&channel_band->band_config, &tlv_band_channel->band_config, +sizeof (struct nxpwifi_band_config )); + channel_band->channel = tlv_band_channel->channel; + +return 0 ; +} + +static int +nxpwifi_cmd_sta_chan_region_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ +struct host_cmd_ds_chan_region_cfg *reg = &cmd->params.reg_cfg; + + cmd->command =cpu_to_le16 (HOST_CMD_CHAN_REGION_CFG ); + cmd->size =cpu_to_le16 (sizeof (*reg) +S_DS_GEN ); + +if (cmd_action ==HOST_ACT_GEN_GET ) + reg->action =cpu_to_le16 (cmd_action); + +return 0 ; +} + +static struct ieee80211_regdomain * +nxpwifi_create_custom_regdomain (struct nxpwifi_private *priv, +u8 *buf,u16 buf_len) +{ +u16 num_chan = buf_len /2 ; +struct ieee80211_regdomain *regd; +struct ieee80211_reg_rule *rule; +bool new_rule; +int idx, freq, prev_freq =0 ; +u32 bw, prev_bw =0 ; +u8 chflags, prev_chflags =0 , valid_rules =0 ; + +if (WARN_ON_ONCE (num_chan >NL80211_MAX_SUPP_REG_RULES )) +return ERR_PTR (-EINVAL ); + + regd =kzalloc (struct_size (regd, reg_rules, num_chan),GFP_KERNEL ); +if (!regd) +return ERR_PTR (-ENOMEM ); + +for (idx =0 ; idx < num_chan; idx++) { +u8 chan; +enum nl80211_band band; + + chan = *buf++; +if (!chan) { +kfree (regd); +return NULL ; + } + chflags = *buf++; + band = (chan <=14 ) ?NL80211_BAND_2GHZ :NL80211_BAND_5GHZ ; + freq =ieee80211_channel_to_frequency (chan, band); + new_rule = false; + +if (chflags &NXPWIFI_CHANNEL_DISABLED ) +continue ; + +if (band ==NL80211_BAND_5GHZ ) { +if (!(chflags &NXPWIFI_CHANNEL_NOHT80 )) + bw =MHZ_TO_KHZ (80 ); +else if (!(chflags &NXPWIFI_CHANNEL_NOHT40 )) + bw =MHZ_TO_KHZ (40 ); +else + bw =MHZ_TO_KHZ (20 ); + }else { +if (!(chflags &NXPWIFI_CHANNEL_NOHT40 )) + bw =MHZ_TO_KHZ (40 ); +else + bw =MHZ_TO_KHZ (20 ); + } + +if (idx ==0 || prev_chflags != chflags || prev_bw != bw || + freq - prev_freq >20 ) { + valid_rules++; + new_rule = true; + } + + rule = ®d->reg_rules[valid_rules -1 ]; + + rule->freq_range.end_freq_khz =MHZ_TO_KHZ (freq +10 ); + + prev_chflags = chflags; + prev_freq = freq; + prev_bw = bw; + +if (!new_rule) +continue ; + + rule->freq_range.start_freq_khz =MHZ_TO_KHZ (freq -10 ); + rule->power_rule.max_eirp =DBM_TO_MBM (19 ); + +if (chflags &NXPWIFI_CHANNEL_PASSIVE ) + rule->flags =NL80211_RRF_NO_IR ; + +if (chflags &NXPWIFI_CHANNEL_DFS ) + rule->flags =NL80211_RRF_DFS ; + + rule->freq_range.max_bandwidth_khz = bw; + } + + regd->n_reg_rules = valid_rules; + regd->alpha2[0 ] ='9' ; + regd->alpha2[1 ] ='9' ; + +return regd; +} + +static int +nxpwifi_ret_sta_chan_region_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_chan_region_cfg *reg = &resp->params.reg_cfg; +u16 action =le16_to_cpu (reg->action); +u16 tlv, tlv_buf_len, tlv_buf_left; +struct nxpwifi_ie_types_header *head; +struct ieee80211_regdomain *regd; +u8 *tlv_buf; + +if (action !=HOST_ACT_GEN_GET ) +return 0 ; + + tlv_buf = (u8 *)reg +sizeof (*reg); + tlv_buf_left =le16_to_cpu (resp->size) -S_DS_GEN -sizeof (*reg); + +while (tlv_buf_left >=sizeof (*head)) { + head = (struct nxpwifi_ie_types_header *)tlv_buf; + tlv =le16_to_cpu (head->type); + tlv_buf_len =le16_to_cpu (head->len); + +if (tlv_buf_left < (sizeof (*head) + tlv_buf_len)) +break ; + +switch (tlv) { +case TLV_TYPE_CHAN_ATTR_CFG : +nxpwifi_dbg_dump (priv->adapter,CMD_D ,"CHAN:" , + (u8 *)head +sizeof (*head), + tlv_buf_len); + regd =nxpwifi_create_custom_regdomain (priv, (u8 *)head + +sizeof (*head), + tlv_buf_len); +if (!IS_ERR (regd)) + priv->adapter->regd = regd; +break ; + } + + tlv_buf += (sizeof (*head) + tlv_buf_len); + tlv_buf_left -= (sizeof (*head) + tlv_buf_len); + } + +return 0 ; +} + +static int +nxpwifi_cmd_sta_pkt_aggr_ctrl (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (cmd_no); + cmd->params.pkt_aggr_ctrl.action =cpu_to_le16 (cmd_action); + cmd->params.pkt_aggr_ctrl.enable =cpu_to_le16 (*(u16 *)data_buf); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_pkt_aggr_ctrl ) + +S_DS_GEN ); + +return 0 ; +} + +static int +nxpwifi_ret_sta_pkt_aggr_ctrl (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf) +{ +struct host_cmd_ds_pkt_aggr_ctrl *pkt_aggr_ctrl = + &resp->params.pkt_aggr_ctrl; +struct nxpwifi_adapter *adapter = priv->adapter; + + adapter->bus_aggr.enable =le16_to_cpu (pkt_aggr_ctrl->enable); +if (adapter->bus_aggr.enable) + adapter->intf_hdr_len =INTF_HEADER_LEN ; + adapter->bus_aggr.mode =NXPWIFI_BUS_AGGR_MODE_LEN_V2 ; + adapter->bus_aggr.tx_aggr_max_size = +le16_to_cpu (pkt_aggr_ctrl->tx_aggr_max_size); + adapter->bus_aggr.tx_aggr_max_num = +le16_to_cpu (pkt_aggr_ctrl->tx_aggr_max_num); + adapter->bus_aggr.tx_aggr_align = +le16_to_cpu (pkt_aggr_ctrl->tx_aggr_align); + +return 0 ; +} + +static const struct nxpwifi_cmd_entry cmd_table_sta[] = { + {.cmd_no =HOST_CMD_GET_HW_SPEC , + .prepare_cmd = nxpwifi_cmd_sta_get_hw_spec, + .cmd_resp = nxpwifi_ret_sta_get_hw_spec}, + {.cmd_no =HOST_CMD_802_11_SCAN , + .prepare_cmd = nxpwifi_cmd_sta_802_11_scan, + .cmd_resp = nxpwifi_ret_sta_802_11_scan}, + {.cmd_no =HOST_CMD_802_11_GET_LOG , + .prepare_cmd = nxpwifi_cmd_sta_802_11_get_log, + .cmd_resp = nxpwifi_ret_sta_802_11_get_log}, + {.cmd_no =HOST_CMD_MAC_MULTICAST_ADR , + .prepare_cmd = nxpwifi_cmd_sta_mac_multicast_adr, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_802_11_ASSOCIATE , + .prepare_cmd = nxpwifi_cmd_sta_802_11_associate, + .cmd_resp = nxpwifi_ret_sta_802_11_associate}, + {.cmd_no =HOST_CMD_802_11_SNMP_MIB , + .prepare_cmd = nxpwifi_cmd_sta_802_11_snmp_mib, + .cmd_resp = nxpwifi_ret_sta_802_11_snmp_mib}, + {.cmd_no =HOST_CMD_MAC_REG_ACCESS , + .prepare_cmd = nxpwifi_cmd_sta_reg_access, + .cmd_resp = nxpwifi_ret_sta_reg_access}, + {.cmd_no =HOST_CMD_BBP_REG_ACCESS , + .prepare_cmd = nxpwifi_cmd_sta_reg_access, + .cmd_resp = nxpwifi_ret_sta_reg_access}, + {.cmd_no =HOST_CMD_RF_REG_ACCESS , + .prepare_cmd = nxpwifi_cmd_sta_reg_access, + .cmd_resp = nxpwifi_ret_sta_reg_access}, + {.cmd_no =HOST_CMD_RF_TX_PWR , + .prepare_cmd = nxpwifi_cmd_sta_rf_tx_pwr, + .cmd_resp = nxpwifi_ret_sta_rf_tx_pwr}, + {.cmd_no =HOST_CMD_RF_ANTENNA , + .prepare_cmd = nxpwifi_cmd_sta_rf_antenna, + .cmd_resp = nxpwifi_ret_sta_rf_antenna}, + {.cmd_no =HOST_CMD_802_11_DEAUTHENTICATE , + .prepare_cmd = nxpwifi_cmd_sta_802_11_deauthenticate, + .cmd_resp = nxpwifi_ret_sta_802_11_deauthenticate}, + {.cmd_no =HOST_CMD_MAC_CONTROL , + .prepare_cmd = nxpwifi_cmd_sta_mac_control, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_802_11_MAC_ADDRESS , + .prepare_cmd = nxpwifi_cmd_sta_802_11_mac_address, + .cmd_resp = nxpwifi_ret_sta_802_11_mac_address}, + {.cmd_no =HOST_CMD_802_11_EEPROM_ACCESS , + .prepare_cmd = nxpwifi_cmd_sta_reg_access, + .cmd_resp = nxpwifi_ret_sta_reg_access}, + {.cmd_no =HOST_CMD_802_11D_DOMAIN_INFO , + .prepare_cmd = nxpwifi_cmd_sta_802_11d_domain_info, + .cmd_resp = nxpwifi_ret_sta_802_11d_domain_info}, + {.cmd_no =HOST_CMD_802_11_KEY_MATERIAL , + .prepare_cmd = nxpwifi_cmd_sta_802_11_key_material, + .cmd_resp = nxpwifi_ret_sta_802_11_key_material}, + {.cmd_no =HOST_CMD_802_11_BG_SCAN_CONFIG , + .prepare_cmd = nxpwifi_cmd_sta_802_11_bg_scan_config, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_802_11_BG_SCAN_QUERY , + .prepare_cmd = nxpwifi_cmd_sta_802_11_bg_scan_query, + .cmd_resp = nxpwifi_ret_sta_802_11_bg_scan_query}, + {.cmd_no =HOST_CMD_WMM_GET_STATUS , + .prepare_cmd = nxpwifi_cmd_sta_wmm_get_status, + .cmd_resp = nxpwifi_ret_sta_wmm_get_status}, + {.cmd_no =HOST_CMD_802_11_SUBSCRIBE_EVENT , + .prepare_cmd = nxpwifi_cmd_sta_802_11_subsc_evt, + .cmd_resp = nxpwifi_ret_sta_subsc_evt}, + {.cmd_no =HOST_CMD_802_11_TX_RATE_QUERY , + .prepare_cmd = nxpwifi_cmd_sta_802_11_tx_rate_query, + .cmd_resp = nxpwifi_ret_sta_802_11_tx_rate_query}, + {.cmd_no =HOST_CMD_MEM_ACCESS , + .prepare_cmd = nxpwifi_cmd_sta_mem_access, + .cmd_resp = nxpwifi_ret_sta_mem_access}, + {.cmd_no =HOST_CMD_CFG_DATA , + .prepare_cmd = nxpwifi_cmd_sta_cfg_data, + .cmd_resp = nxpwifi_ret_sta_cfg_data}, + {.cmd_no =HOST_CMD_VERSION_EXT , + .prepare_cmd = nxpwifi_cmd_sta_ver_ext, + .cmd_resp = nxpwifi_ret_sta_ver_ext}, + {.cmd_no =HOST_CMD_MEF_CFG , + .prepare_cmd = nxpwifi_cmd_sta_mef_cfg, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_RSSI_INFO , + .prepare_cmd = nxpwifi_cmd_sta_802_11_rssi_info, + .cmd_resp = nxpwifi_ret_sta_802_11_rssi_info}, + {.cmd_no =HOST_CMD_FUNC_INIT , + .prepare_cmd = nxpwifi_cmd_sta_func_init, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_FUNC_SHUTDOWN , + .prepare_cmd = nxpwifi_cmd_sta_func_shutdown, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_PMIC_REG_ACCESS , + .prepare_cmd = nxpwifi_cmd_sta_reg_access, + .cmd_resp = nxpwifi_ret_sta_reg_access}, + {.cmd_no =HOST_CMD_11N_CFG , + .prepare_cmd = nxpwifi_cmd_sta_11n_cfg, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_11N_ADDBA_REQ , + .prepare_cmd = nxpwifi_cmd_sta_11n_addba_req, + .cmd_resp = nxpwifi_ret_sta_11n_addba_req}, + {.cmd_no =HOST_CMD_11N_ADDBA_RSP , + .prepare_cmd = nxpwifi_cmd_sta_11n_addba_rsp, + .cmd_resp = nxpwifi_ret_sta_11n_addba_rsp}, + {.cmd_no =HOST_CMD_11N_DELBA , + .prepare_cmd = nxpwifi_cmd_sta_11n_delba, + .cmd_resp = nxpwifi_ret_sta_11n_delba}, + {.cmd_no =HOST_CMD_TXPWR_CFG , + .prepare_cmd = nxpwifi_cmd_sta_tx_power_cfg, + .cmd_resp = nxpwifi_ret_sta_tx_power_cfg}, + {.cmd_no =HOST_CMD_TX_RATE_CFG , + .prepare_cmd = nxpwifi_cmd_sta_tx_rate_cfg, + .cmd_resp = nxpwifi_ret_sta_tx_rate_cfg}, + {.cmd_no =HOST_CMD_RECONFIGURE_TX_BUFF , + .prepare_cmd = nxpwifi_cmd_sta_reconfigure_rx_buff, + .cmd_resp = nxpwifi_ret_sta_reconfigure_rx_buff}, + {.cmd_no =HOST_CMD_CHAN_REPORT_REQUEST , + .prepare_cmd = nxpwifi_cmd_sta_chan_report_request, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_AMSDU_AGGR_CTRL , + .prepare_cmd = nxpwifi_cmf_sta_amsdu_aggr_ctrl, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_ROBUST_COEX , + .prepare_cmd = nxpwifi_cmd_sta_robust_coex, + .cmd_resp = nxpwifi_ret_sta_robust_coex}, + {.cmd_no =HOST_CMD_802_11_PS_MODE_ENH , + .prepare_cmd = nxpwifi_cmd_sta_enh_power_mode, + .cmd_resp = nxpwifi_ret_sta_enh_power_mode}, + {.cmd_no =HOST_CMD_802_11_HS_CFG_ENH , + .prepare_cmd = nxpwifi_cmd_sta_802_11_hs_cfg, + .cmd_resp = nxpwifi_ret_sta_802_11_hs_cfg}, + {.cmd_no =HOST_CMD_CAU_REG_ACCESS , + .prepare_cmd = nxpwifi_cmd_sta_reg_access, + .cmd_resp = nxpwifi_ret_sta_reg_access}, + {.cmd_no =HOST_CMD_SET_BSS_MODE , + .prepare_cmd = nxpwifi_cmd_sta_set_bss_mode, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_802_11_SCAN_EXT , + .prepare_cmd = nxpwifi_cmd_sta_802_11_scan_ext, + .cmd_resp = nxpwifi_ret_sta_802_11_scan_ext}, + {.cmd_no =HOST_CMD_COALESCE_CFG , + .prepare_cmd = nxpwifi_cmd_sta_coalesce_cfg, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_MGMT_FRAME_REG , + .prepare_cmd = nxpwifi_cmd_sta_mgmt_frame_reg, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_REMAIN_ON_CHAN , + .prepare_cmd = nxpwifi_cmd_sta_remain_on_chan, + .cmd_resp = nxpwifi_ret_sta_remain_on_chan}, + {.cmd_no =HOST_CMD_GTK_REKEY_OFFLOAD_CFG , + .prepare_cmd = nxpwifi_cmd_sta_gtk_rekey_offload, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_11AC_CFG , + .prepare_cmd = nxpwifi_cmd_sta_11ac_cfg, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_HS_WAKEUP_REASON , + .prepare_cmd = nxpwifi_cmd_sta_hs_wakeup_reason, + .cmd_resp = nxpwifi_ret_sta_hs_wakeup_reason}, + {.cmd_no =HOST_CMD_MC_POLICY , + .prepare_cmd = nxpwifi_cmd_sta_mc_policy, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_FW_DUMP_EVENT , + .prepare_cmd = nxpwifi_cmd_fill_head_only, + .cmd_resp =NULL }, + {.cmd_no =HOST_CMD_SDIO_SP_RX_AGGR_CFG , + .prepare_cmd = nxpwifi_cmd_sta_sdio_rx_aggr_cfg, + .cmd_resp = nxpwifi_ret_sta_sdio_rx_aggr_cfg}, + {.cmd_no =HOST_CMD_STA_CONFIGURE , + .prepare_cmd = nxpwifi_cmd_sta_get_chan_info, + .cmd_resp = nxpwifi_ret_sta_get_chan_info}, + {.cmd_no =HOST_CMD_CHAN_REGION_CFG , + .prepare_cmd = nxpwifi_cmd_sta_chan_region_cfg, + .cmd_resp = nxpwifi_ret_sta_chan_region_cfg}, + {.cmd_no =HOST_CMD_PACKET_AGGR_CTRL , + .prepare_cmd = nxpwifi_cmd_sta_pkt_aggr_ctrl,
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.34.1
Part of the diff is not shown here. View the raw message.
PATCH 29/43 wifi: nxpwifi: add sta_event.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/sta_event.c | 858 +++++++++++++++++++ 1 file changed, 858 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_event.c
drivers/net/wireless/nxp/nxpwifi/sta_event.c new file +858 -0
@@ -0,0 +1,858 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: station event handling +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" + +static int +nxpwifi_sta_event_link_lost (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u16 reason_code; + + adapter->dbg.num_event_link_lost++; +if (priv->media_connected) { + reason_code =get_unaligned_le16 (adapter->event_body); + adapter->priv_link_lost = priv; + adapter->host_mlme_link_lost = true; +queue_work (adapter->host_mlme_workqueue, + &adapter->host_mlme_work); + } + +return 0 ; +} + +static int +nxpwifi_sta_event_link_sensed (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +if (!netif_carrier_ok (priv->netdev)) +netif_carrier_on (priv->netdev); +nxpwifi_wake_up_net_dev_queue (priv->netdev, adapter); + +return 0 ; +} + +static int +nxpwifi_sta_event_deauthenticated (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u16 reason_code; + +if (priv->wps.session_enable) { +nxpwifi_dbg (adapter,INFO , +"info: receive deauth event in wps session\n" ); + }else { + adapter->dbg.num_event_deauth++; +if (priv->media_connected) { + reason_code = +get_unaligned_le16 (adapter->event_body); +nxpwifi_reset_connect_state (priv, reason_code, true); + } + } + +return 0 ; +} + +static int +nxpwifi_sta_event_disassociated (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u16 reason_code; + +if (priv->wps.session_enable) { +nxpwifi_dbg (adapter,INFO , +"info: receive disassoc event in wps session\n" ); + }else { + adapter->dbg.num_event_disassoc++; +if (priv->media_connected) { + reason_code = +get_unaligned_le16 (adapter->event_body); +nxpwifi_reset_connect_state (priv, reason_code, true); + } + } + +return 0 ; +} + +static int +nxpwifi_sta_event_ps_awake (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +if (!adapter->pps_uapsd_mode && + priv->port_open && + priv->media_connected && adapter->sleep_period.period) { + adapter->pps_uapsd_mode = true; +nxpwifi_dbg (adapter,EVENT , +"event: PPS/UAPSD mode activated\n" ); + } + adapter->tx_lock_flag = false; +if (adapter->pps_uapsd_mode && adapter->gen_null_pkt) { +if (nxpwifi_check_last_packet_indication (priv)) { +if (adapter->data_sent || + (adapter->if_ops.is_port_ready && + !adapter->if_ops.is_port_ready (priv))) { + adapter->ps_state =PS_STATE_AWAKE ; + adapter->pm_wakeup_card_req = false; + adapter->pm_wakeup_fw_try = false; +del_timer (&adapter->wakeup_timer); + }else { +if (!nxpwifi_send_null_packet + (priv, + NXPWIFI_TxPD_POWER_MGMT_NULL_PACKET | + NXPWIFI_TxPD_POWER_MGMT_LAST_PACKET)) + adapter->ps_state =PS_STATE_SLEEP ; + } + +return 0 ; + } + } + + adapter->ps_state =PS_STATE_AWAKE ; + adapter->pm_wakeup_card_req = false; + adapter->pm_wakeup_fw_try = false; +del_timer (&adapter->wakeup_timer); + +return 0 ; +} + +static int +nxpwifi_sta_event_ps_sleep (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + + adapter->ps_state =PS_STATE_PRE_SLEEP ; +nxpwifi_check_ps_cond (adapter); + +return 0 ; +} + +static int +nxpwifi_sta_event_mic_err_multicast (struct nxpwifi_private *priv) +{ +cfg80211_michael_mic_failure (priv->netdev, priv->cfg_bssid, +NL80211_KEYTYPE_GROUP , +-1 ,NULL ,GFP_KERNEL ); + +return 0 ; +} + +static int +nxpwifi_sta_event_mic_err_unicast (struct nxpwifi_private *priv) +{ +cfg80211_michael_mic_failure (priv->netdev, priv->cfg_bssid, +NL80211_KEYTYPE_PAIRWISE , +-1 ,NULL ,GFP_KERNEL ); + +return 0 ; +} + +static int +nxpwifi_sta_event_deep_sleep_awake (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + + adapter->if_ops.wakeup_complete (adapter); +if (adapter->is_deep_sleep) + adapter->is_deep_sleep = false; + +return 0 ; +} + +static int +nxpwifi_sta_event_wmm_status_change (struct nxpwifi_private *priv) +{ +return nxpwifi_send_cmd (priv,HOST_CMD_WMM_GET_STATUS , +0 ,0 ,NULL , false); +} + +static int +nxpwifi_sta_event_bs_scan_report (struct nxpwifi_private *priv) +{ +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_BG_SCAN_QUERY , +HOST_ACT_GEN_GET ,0 ,NULL , false); +} + +static int +nxpwifi_sta_event_rssi_low (struct nxpwifi_private *priv) +{ +cfg80211_cqm_rssi_notify (priv->netdev, +NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW , +0 ,GFP_KERNEL ); + priv->subsc_evt_rssi_state =RSSI_LOW_RECVD ; + +return nxpwifi_send_cmd (priv,HOST_CMD_RSSI_INFO , +HOST_ACT_GEN_GET ,0 ,NULL , false); +} + +static int +nxpwifi_sta_event_rssi_high (struct nxpwifi_private *priv) +{ +cfg80211_cqm_rssi_notify (priv->netdev, +NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH , +0 ,GFP_KERNEL ); + priv->subsc_evt_rssi_state =RSSI_HIGH_RECVD ; + +return nxpwifi_send_cmd (priv,HOST_CMD_RSSI_INFO , +HOST_ACT_GEN_GET ,0 ,NULL , false); +} + +static int +nxpwifi_sta_event_port_release (struct nxpwifi_private *priv) +{ + priv->port_open = true; + +return 0 ; +} + +static int +nxpwifi_sta_event_addba (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +return nxpwifi_send_cmd (priv,HOST_CMD_11N_ADDBA_RSP , +HOST_ACT_GEN_SET ,0 , + adapter->event_body, false); +} + +static int +nxpwifi_sta_event_delba (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +nxpwifi_11n_delete_ba_stream (priv, adapter->event_body); + +return 0 ; +} + +static int +nxpwifi_sta_event_bs_stream_timeout (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_11n_batimeout *event = + (struct host_cmd_ds_11n_batimeout *)adapter->event_body; + +nxpwifi_11n_ba_stream_timeout (priv, event); + +return 0 ; +} + +static int +nxpwifi_sta_event_amsdu_aggr_ctrl (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u16 ctrl; + + ctrl =get_unaligned_le16 (adapter->event_body); + adapter->tx_buf_size =min_t (u16, adapter->curr_tx_buf_size, ctrl); + +return 0 ; +} + +static int +nxpwifi_sta_event_hs_act_req (struct nxpwifi_private *priv) +{ +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_HS_CFG_ENH , +0 ,0 ,NULL , false); +} + +static int +nxpwifi_sta_event_channel_switch_ann (struct nxpwifi_private *priv) +{ +struct nxpwifi_bssdescriptor *bss_desc; + + bss_desc = &priv->curr_bss_params.bss_descriptor; + priv->csa_expire_time = jiffies +msecs_to_jiffies (DFS_CHAN_MOVE_TIME ); + priv->csa_chan = bss_desc->channel; +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_DEAUTHENTICATE , +HOST_ACT_GEN_SET ,0 , + bss_desc->mac_address, false); +} + +static int +nxpwifi_sta_event_radar_detected (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +return nxpwifi_11h_handle_radar_detected (priv, adapter->event_skb); +} + +static int +nxpwifi_sta_event_channel_report_rdy (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +return nxpwifi_11h_handle_chanrpt_ready (priv, adapter->event_skb); +} + +static int +nxpwifi_sta_event_tx_data_pause (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +nxpwifi_process_tx_pause_event (priv, adapter->event_skb); + +return 0 ; +} + +static int +nxpwifi_sta_event_ext_scan_report (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +void *buf = adapter->event_skb->data; +int ret =0 ; + +/* We intend to skip this event during suspend, but handle +* it in interface disabled case +*/ +if (adapter->ext_scan && (!priv->scan_aborting || + !netif_running (priv->netdev))) + ret =nxpwifi_handle_event_ext_scan_report (priv, buf); + +return ret; +} + +static int +nxpwifi_sta_event_rxba_sync (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +nxpwifi_11n_rxba_sync_event (priv, adapter->event_body, + adapter->event_skb->len - +sizeof (adapter->event_cause)); + +return 0 ; +} + +static int +nxpwifi_sta_event_remain_on_chan_expired (struct nxpwifi_private *priv) +{ +if (priv->auth_flag &HOST_MLME_AUTH_PENDING ) { + priv->auth_flag =0 ; + priv->auth_alg =WLAN_AUTH_NONE ; + }else { +cfg80211_remain_on_channel_expired (&priv->wdev, + priv->roc_cfg.cookie, + &priv->roc_cfg.chan, +GFP_ATOMIC ); + } + +memset (&priv->roc_cfg,0x00 ,sizeof (struct nxpwifi_roc_cfg )); + +return 0 ; +} + +static int +nxpwifi_sta_event_bg_scan_stopped (struct nxpwifi_private *priv) +{ +cfg80211_sched_scan_stopped (priv->wdev.wiphy,0 ); +if (priv->sched_scanning) + priv->sched_scanning = false; + +return 0 ; +} + +static int +nxpwifi_sta_event_multi_chan_info (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +nxpwifi_process_multi_chan_event (priv, adapter->event_skb); + +return 0 ; +} + +static int +nxpwifi_sta_event_tx_status_report (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +nxpwifi_parse_tx_status_event (priv, adapter->event_body); + +return 0 ; +} + +static int +nxpwifi_sta_event_bt_coex_wlan_para_change (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +if (!adapter->ignore_btcoex_events) +nxpwifi_bt_coex_wlan_param_update_event (priv, + adapter->event_skb); + +return 0 ; +} + +static const struct nxpwifi_evt_entry evt_table_sta[] = { + {.event_cause =EVENT_LINK_LOST , + .event_handler = nxpwifi_sta_event_link_lost}, + {.event_cause =EVENT_LINK_SENSED , + .event_handler = nxpwifi_sta_event_link_sensed}, + {.event_cause =EVENT_DEAUTHENTICATED , + .event_handler = nxpwifi_sta_event_deauthenticated}, + {.event_cause =EVENT_DISASSOCIATED , + .event_handler = nxpwifi_sta_event_disassociated}, + {.event_cause =EVENT_PS_AWAKE , + .event_handler = nxpwifi_sta_event_ps_awake}, + {.event_cause =EVENT_PS_SLEEP , + .event_handler = nxpwifi_sta_event_ps_sleep}, + {.event_cause =EVENT_MIC_ERR_MULTICAST , + .event_handler = nxpwifi_sta_event_mic_err_multicast}, + {.event_cause =EVENT_MIC_ERR_UNICAST , + .event_handler = nxpwifi_sta_event_mic_err_unicast}, + {.event_cause =EVENT_DEEP_SLEEP_AWAKE , + .event_handler = nxpwifi_sta_event_deep_sleep_awake}, + {.event_cause =EVENT_WMM_STATUS_CHANGE , + .event_handler = nxpwifi_sta_event_wmm_status_change}, + {.event_cause =EVENT_BG_SCAN_REPORT , + .event_handler = nxpwifi_sta_event_bs_scan_report}, + {.event_cause =EVENT_RSSI_LOW , + .event_handler = nxpwifi_sta_event_rssi_low}, + {.event_cause =EVENT_RSSI_HIGH , + .event_handler = nxpwifi_sta_event_rssi_high}, + {.event_cause =EVENT_PORT_RELEASE , + .event_handler = nxpwifi_sta_event_port_release}, + {.event_cause =EVENT_ADDBA , + .event_handler = nxpwifi_sta_event_addba}, + {.event_cause =EVENT_DELBA , + .event_handler = nxpwifi_sta_event_delba}, + {.event_cause =EVENT_BA_STREAM_TIEMOUT , + .event_handler = nxpwifi_sta_event_bs_stream_timeout}, + {.event_cause =EVENT_AMSDU_AGGR_CTRL , + .event_handler = nxpwifi_sta_event_amsdu_aggr_ctrl}, + {.event_cause =EVENT_HS_ACT_REQ , + .event_handler = nxpwifi_sta_event_hs_act_req}, + {.event_cause =EVENT_CHANNEL_SWITCH_ANN , + .event_handler = nxpwifi_sta_event_channel_switch_ann}, + {.event_cause =EVENT_RADAR_DETECTED , + .event_handler = nxpwifi_sta_event_radar_detected}, + {.event_cause =EVENT_CHANNEL_REPORT_RDY , + .event_handler = nxpwifi_sta_event_channel_report_rdy}, + {.event_cause =EVENT_TX_DATA_PAUSE , + .event_handler = nxpwifi_sta_event_tx_data_pause}, + {.event_cause =EVENT_EXT_SCAN_REPORT , + .event_handler = nxpwifi_sta_event_ext_scan_report}, + {.event_cause =EVENT_RXBA_SYNC , + .event_handler = nxpwifi_sta_event_rxba_sync}, + {.event_cause =EVENT_REMAIN_ON_CHAN_EXPIRED , + .event_handler = nxpwifi_sta_event_remain_on_chan_expired}, + {.event_cause =EVENT_BG_SCAN_STOPPED , + .event_handler = nxpwifi_sta_event_bg_scan_stopped}, + {.event_cause =EVENT_MULTI_CHAN_INFO , + .event_handler = nxpwifi_sta_event_multi_chan_info}, + {.event_cause =EVENT_TX_STATUS_REPORT , + .event_handler = nxpwifi_sta_event_tx_status_report}, + {.event_cause =EVENT_BT_COEX_WLAN_PARA_CHANGE , + .event_handler = nxpwifi_sta_event_bt_coex_wlan_para_change}, + {.event_cause =EVENT_DUMMY_HOST_WAKEUP_SIGNAL , + .event_handler =NULL }, + {.event_cause =EVENT_MIB_CHANGED , + .event_handler =NULL }, + {.event_cause =EVENT_INIT_DONE , + .event_handler =NULL }, + {.event_cause =EVENT_SNR_LOW , + .event_handler =NULL }, + {.event_cause =EVENT_MAX_FAIL , + .event_handler =NULL }, + {.event_cause =EVENT_SNR_HIGH , + .event_handler =NULL }, + {.event_cause =EVENT_DATA_RSSI_LOW , + .event_handler =NULL }, + {.event_cause =EVENT_DATA_SNR_LOW , + .event_handler =NULL }, + {.event_cause =EVENT_DATA_RSSI_HIGH , + .event_handler =NULL }, + {.event_cause =EVENT_DATA_SNR_HIGH , + .event_handler =NULL }, + {.event_cause =EVENT_LINK_QUALITY , + .event_handler =NULL }, + {.event_cause =EVENT_PRE_BEACON_LOST , + .event_handler =NULL }, + {.event_cause =EVENT_WEP_ICV_ERR , + .event_handler =NULL }, + {.event_cause =EVENT_BW_CHANGE , + .event_handler =NULL }, + {.event_cause =EVENT_HOSTWAKE_STAIE , + .event_handler =NULL }, + {.event_cause =EVENT_UNKNOWN_DEBUG , + .event_handler =NULL }, +}; + +static void nxpwifi_process_uap_tx_pause (struct nxpwifi_private *priv, +struct nxpwifi_ie_types_header *tlv) +{ +struct nxpwifi_tx_pause_tlv *tp; +struct nxpwifi_sta_node *sta_ptr; + + tp = (void *)tlv; +nxpwifi_dbg (priv->adapter,EVENT , +"uap tx_pause: %pM pause=%d, pkts=%d\n" , + tp->peermac, tp->tx_pause, + tp->pkt_cnt); + +if (ether_addr_equal (tp->peermac, priv->netdev->dev_addr)) { +if (tp->tx_pause) + priv->port_open = false; +else + priv->port_open = true; + }else if (is_multicast_ether_addr (tp->peermac)) { +nxpwifi_update_ralist_tx_pause (priv, tp->peermac, tp->tx_pause); + }else { +spin_lock_bh (&priv->sta_list_spinlock); + sta_ptr =nxpwifi_get_sta_entry (priv, tp->peermac); +if (sta_ptr && sta_ptr->tx_pause != tp->tx_pause) { + sta_ptr->tx_pause = tp->tx_pause; +spin_unlock_bh (&priv->sta_list_spinlock); +nxpwifi_update_ralist_tx_pause (priv, tp->peermac, + tp->tx_pause); + }else { +spin_unlock_bh (&priv->sta_list_spinlock); + } + } +} + +static void nxpwifi_process_sta_tx_pause (struct nxpwifi_private *priv, +struct nxpwifi_ie_types_header *tlv) +{ +struct nxpwifi_tx_pause_tlv *tp; + + tp = (void *)tlv; +nxpwifi_dbg (priv->adapter,EVENT , +"sta tx_pause: %pM pause=%d, pkts=%d\n" , + tp->peermac, tp->tx_pause, + tp->pkt_cnt); + +if (ether_addr_equal (tp->peermac, priv->cfg_bssid)) { +if (tp->tx_pause) + priv->port_open = false; +else + priv->port_open = true; + } +} + +/* This function resets the connection state. +* +* The function is invoked after receiving a disconnect event from firmware, +* and performs the following actions - +* - Set media status to disconnected +* - Clean up Tx and Rx packets +* - Resets SNR/NF/RSSI value in driver +* - Resets security configurations in driver +* - Enables auto data rate +* - Saves the previous SSID and BSSID so that they can +* be used for re-association, if required +* - Erases current SSID and BSSID information +* - Sends a disconnect event to upper layers/applications. +*/ +void nxpwifi_reset_connect_state (struct nxpwifi_private *priv,u16 reason_code, +bool from_ap) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +if (!priv->media_connected) +return ; + +nxpwifi_dbg (adapter,INFO , +"info: handles disconnect event\n" ); + + priv->media_connected = false; + + priv->auth_flag =0 ; + priv->auth_alg =WLAN_AUTH_NONE ; + + priv->scan_block = false; + priv->port_open = false; + +/* Free Tx and Rx packets, report disconnect to upper layer */ +nxpwifi_clean_txrx (priv); + +/* Reset SNR/NF/RSSI values */ + priv->data_rssi_last =0 ; + priv->data_nf_last =0 ; + priv->data_rssi_avg =0 ; + priv->data_nf_avg =0 ; + priv->bcn_rssi_last =0 ; + priv->bcn_nf_last =0 ; + priv->bcn_rssi_avg =0 ; + priv->bcn_nf_avg =0 ; + priv->rxpd_rate =0 ; + priv->rxpd_htinfo =0 ; + priv->sec_info.wpa_enabled = false; + priv->sec_info.wpa2_enabled = false; + priv->wpa_ie_len =0 ; + + priv->sec_info.encryption_mode =0 ; + +/* Enable auto data rate */ + priv->is_data_rate_auto = true; + priv->data_rate =0 ; + + priv->assoc_resp_ht_param =0 ; + priv->ht_param_present = false; + +if ((GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA || +GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) && priv->hist_data) +nxpwifi_hist_data_reset (priv); + +/* Memorize the previous SSID and BSSID so +* it could be used for re-assoc +*/ + +nxpwifi_dbg (adapter,INFO , +"info: previous SSID=%s, SSID len=%u\n" , + priv->prev_ssid.ssid, priv->prev_ssid.ssid_len); + +nxpwifi_dbg (adapter,INFO , +"info: current SSID=%s, SSID len=%u\n" , + priv->curr_bss_params.bss_descriptor.ssid.ssid, + priv->curr_bss_params.bss_descriptor.ssid.ssid_len); + +memcpy (&priv->prev_ssid, + &priv->curr_bss_params.bss_descriptor.ssid, +sizeof (struct cfg80211_ssid )); + +memcpy (priv->prev_bssid, + priv->curr_bss_params.bss_descriptor.mac_address,ETH_ALEN ); + +/* Need to erase the current SSID and BSSID info */ +memset (&priv->curr_bss_params,0x00 ,sizeof (priv->curr_bss_params)); + + adapter->tx_lock_flag = false; + adapter->pps_uapsd_mode = false; + +if (test_bit (NXPWIFI_IS_CMD_TIMEDOUT , &adapter->work_flags) && + adapter->curr_cmd) +return ; + + priv->media_connected = false; +nxpwifi_dbg (adapter,MSG , +"info: successfully disconnected from %pM: reason code %d\n" , + priv->cfg_bssid, reason_code); + +if (priv->bss_mode ==NL80211_IFTYPE_STATION ) { +if (adapter->host_mlme_link_lost) +nxpwifi_host_mlme_disconnect (adapter->priv_link_lost, + reason_code,NULL ); +else +cfg80211_disconnected (priv->netdev, reason_code,NULL , +0 , !from_ap,GFP_KERNEL ); + } +eth_zero_addr (priv->cfg_bssid); + +nxpwifi_stop_net_dev_queue (priv->netdev, adapter); +if (netif_carrier_ok (priv->netdev)) +netif_carrier_off (priv->netdev); + +if (!ISSUPP_FIRMWARE_SUPPLICANT (priv->adapter->fw_cap_info)) +return ; + +nxpwifi_send_cmd (priv,HOST_CMD_GTK_REKEY_OFFLOAD_CFG , +HOST_ACT_GEN_REMOVE ,0 ,NULL , false); +} + +void nxpwifi_process_multi_chan_event (struct nxpwifi_private *priv, +struct sk_buff *event_skb) +{ +struct nxpwifi_ie_types_multi_chan_info *chan_info; +struct nxpwifi_ie_types_mc_group_info *grp_info; +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_ie_types_header *tlv; +u16 tlv_buf_left, tlv_type, tlv_len; +int intf_num, bss_type, bss_num, i; +struct nxpwifi_private *intf_priv; + + tlv_buf_left = event_skb->len -sizeof (u32); + chan_info = (void *)event_skb->data +sizeof (u32); + +if (le16_to_cpu (chan_info->header.type) !=TLV_TYPE_MULTI_CHAN_INFO || + tlv_buf_left <sizeof (struct nxpwifi_ie_types_multi_chan_info )) { +nxpwifi_dbg (adapter,ERROR , +"unknown TLV in chan_info event\n" ); +return ; + } + + adapter->usb_mc_status =le16_to_cpu (chan_info->status); +nxpwifi_dbg (adapter,EVENT ,"multi chan operation %s\n" , + adapter->usb_mc_status ?"started" :"over" ); + + tlv_buf_left -=sizeof (struct nxpwifi_ie_types_multi_chan_info ); + tlv = (struct nxpwifi_ie_types_header *)chan_info->tlv_buffer; + +while (tlv_buf_left >= (int )sizeof (struct nxpwifi_ie_types_header )) { + tlv_type =le16_to_cpu (tlv->type); + tlv_len =le16_to_cpu (tlv->len); +if ((sizeof (struct nxpwifi_ie_types_header ) + tlv_len) > + tlv_buf_left) { +nxpwifi_dbg (adapter,ERROR ,"wrong tlv: tlvLen=%d,\t" +"tlvBufLeft=%d\n" , tlv_len, tlv_buf_left); +break ; + } +if (tlv_type !=TLV_TYPE_MC_GROUP_INFO ) { +nxpwifi_dbg (adapter,ERROR ,"wrong tlv type: 0x%x\n" , + tlv_type); +break ; + } + + grp_info = (struct nxpwifi_ie_types_mc_group_info *)tlv; + intf_num = grp_info->intf_num; +for (i =0 ; i < intf_num; i++) { + bss_type = grp_info->bss_type_numlist[i] >>4 ; + bss_num = grp_info->bss_type_numlist[i] &BSS_NUM_MASK ; + intf_priv =nxpwifi_get_priv_by_id (adapter, bss_num, + bss_type); +if (!intf_priv) { +nxpwifi_dbg (adapter,ERROR , +"Invalid bss_type bss_num\t" +"in multi channel event\n" ); +continue ; + } + } + + tlv_buf_left -=sizeof (struct nxpwifi_ie_types_header ) + + tlv_len; + tlv = (void *)((u8 *)tlv + tlv_len + +sizeof (struct nxpwifi_ie_types_header )); + } +} + +void nxpwifi_process_tx_pause_event (struct nxpwifi_private *priv, +struct sk_buff *event_skb) +{ +struct nxpwifi_ie_types_header *tlv; +u16 tlv_type, tlv_len; +int tlv_buf_left; + +if (!priv->media_connected) { +nxpwifi_dbg (priv->adapter,ERROR , +"tx_pause event while disconnected; bss_role=%d\n" , + priv->bss_role); +return ; + } + + tlv_buf_left = event_skb->len -sizeof (u32); + tlv = (void *)event_skb->data +sizeof (u32); + +while (tlv_buf_left >= (int )sizeof (struct nxpwifi_ie_types_header )) { + tlv_type =le16_to_cpu (tlv->type); + tlv_len =le16_to_cpu (tlv->len); +if ((sizeof (struct nxpwifi_ie_types_header ) + tlv_len) > + tlv_buf_left) { +nxpwifi_dbg (priv->adapter,ERROR , +"wrong tlv: tlvLen=%d, tlvBufLeft=%d\n" , + tlv_len, tlv_buf_left); +break ; + } +if (tlv_type ==TLV_TYPE_TX_PAUSE ) { +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) +nxpwifi_process_sta_tx_pause (priv, tlv); +else +nxpwifi_process_uap_tx_pause (priv, tlv); + } + + tlv_buf_left -=sizeof (struct nxpwifi_ie_types_header ) + + tlv_len; + tlv = (void *)((u8 *)tlv + tlv_len + +sizeof (struct nxpwifi_ie_types_header )); + } +} + +/* This function handles coex events generated by firmware */ +void nxpwifi_bt_coex_wlan_param_update_event (struct nxpwifi_private *priv, +struct sk_buff *event_skb) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_ie_types_header *tlv; +struct nxpwifi_ie_types_btcoex_aggr_win_size *winsizetlv; +struct nxpwifi_ie_types_btcoex_scan_time *scantlv; +s32 len = event_skb->len -sizeof (u32); +u8 *cur_ptr = event_skb->data +sizeof (u32); +u16 tlv_type, tlv_len; + +while (len >=sizeof (struct nxpwifi_ie_types_header )) { + tlv = (struct nxpwifi_ie_types_header *)cur_ptr; + tlv_len =le16_to_cpu (tlv->len); + tlv_type =le16_to_cpu (tlv->type); + +if ((tlv_len +sizeof (struct nxpwifi_ie_types_header )) > len) +break ; +switch (tlv_type) { +case TLV_BTCOEX_WL_AGGR_WINSIZE : + winsizetlv = + (struct nxpwifi_ie_types_btcoex_aggr_win_size *)tlv; + adapter->coex_win_size = winsizetlv->coex_win_size; + adapter->coex_tx_win_size = + winsizetlv->tx_win_size; + adapter->coex_rx_win_size = + winsizetlv->rx_win_size; +nxpwifi_coex_ampdu_rxwinsize (adapter); +nxpwifi_update_ampdu_txwinsize (adapter); +break ; + +case TLV_BTCOEX_WL_SCANTIME : + scantlv = + (struct nxpwifi_ie_types_btcoex_scan_time *)tlv; + adapter->coex_scan = scantlv->coex_scan; + adapter->coex_min_scan_time =le16_to_cpu (scantlv->min_scan_time); + adapter->coex_max_scan_time =le16_to_cpu (scantlv->max_scan_time); +break ; + +default : +break ; + } + + len -= tlv_len +sizeof (struct nxpwifi_ie_types_header ); + cur_ptr += tlv_len + +sizeof (struct nxpwifi_ie_types_header ); + } + +dev_dbg (adapter->dev,"coex_scan=%d min_scan=%d coex_win=%d, tx_win=%d rx_win=%d\n" , + adapter->coex_scan, adapter->coex_min_scan_time, + adapter->coex_win_size, adapter->coex_tx_win_size, + adapter->coex_rx_win_size); +} + +/* This function handles events generated by firmware. +* +* This is a generic function and handles all events. +* +* Event specific routines are called by this function based +* upon the generated event cause. +*/ +int nxpwifi_process_sta_event (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u32 eventcause = adapter->event_cause; +int evt, ret =0 ; + +for (evt =0 ; evt <ARRAY_SIZE (evt_table_sta); evt++) { +if (eventcause == evt_table_sta[evt].event_cause) { +if (evt_table_sta[evt].event_handler) + ret = evt_table_sta[evt].event_handler (priv); +break ; + } + } + +if (evt ==ARRAY_SIZE (evt_table_sta)) +nxpwifi_dbg (adapter,EVENT , +"%s: unknown event id: %#x\n" , + __func__, eventcause); +else +nxpwifi_dbg (adapter,EVENT , +"%s: event id: %#x\n" , + __func__, eventcause); + +return ret; +}
Signature · 1 line
2.34.1
PATCH 30/43 wifi: nxpwifi: add sta_ioctl.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/sta_ioctl.c | 1320 ++++++++++++++++++ 1 file changed, 1320 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_ioctl.c
drivers/net/wireless/nxp/nxpwifi/sta_ioctl.c new file +1320 -0
@@ -0,0 +1,1320 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: functions for station ioctl +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" +#include "cfg80211.h" + +static int disconnect_on_suspend; + +/* Copies the multicast address list from device to driver. +* +* This function does not validate the destination memory for +* size, and the calling function must ensure enough memory is +* available. +*/ +int nxpwifi_copy_mcast_addr (struct nxpwifi_multicast_list *mlist, +struct net_device *dev) +{ +int i =0 ; +struct netdev_hw_addr *ha; + +netdev_for_each_mc_addr (ha, dev) +memcpy (&mlist->mac_list[i++], ha->addr,ETH_ALEN ); + +return i; +} + +/* Wait queue completion handler. +* +* This function waits on a cmd wait queue. It also cancels the pending +* request after waking up, in case of errors. +*/ +int nxpwifi_wait_queue_complete (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_queued) +{ +int status; + +/* Wait for completion */ + status =wait_event_interruptible_timeout (adapter->cmd_wait_q.wait, + *cmd_queued->condition, + (12 *HZ )); +if (status <=0 ) { +if (status ==0 ) + status = -ETIMEDOUT ; +nxpwifi_dbg (adapter,ERROR ,"cmd_wait_q terminated: %d\n" , + status); +nxpwifi_cancel_all_pending_cmd (adapter); +return status; + } + + status = adapter->cmd_wait_q.status; + adapter->cmd_wait_q.status =0 ; + +return status; +} + +/* This function prepares the correct firmware command and +* issues it to set the multicast list. +* +* This function can be used to enable promiscuous mode, or enable all +* multicast packets, or to enable selective multicast. +*/ +int +nxpwifi_request_set_multicast_list (struct nxpwifi_private *priv, +struct nxpwifi_multicast_list *mcast_list) +{ +int ret =0 ; +u16 old_pkt_filter; + + old_pkt_filter = priv->curr_pkt_filter; + +if (mcast_list->mode ==NXPWIFI_PROMISC_MODE ) { +nxpwifi_dbg (priv->adapter,INFO , +"info: Enable Promiscuous mode\n" ); + priv->curr_pkt_filter |=HOST_ACT_MAC_PROMISCUOUS_ENABLE ; + priv->curr_pkt_filter &= + ~HOST_ACT_MAC_ALL_MULTICAST_ENABLE ; + }else { +/* Multicast */ + priv->curr_pkt_filter &= ~HOST_ACT_MAC_PROMISCUOUS_ENABLE ; +if (mcast_list->mode ==NXPWIFI_ALL_MULTI_MODE ) { +nxpwifi_dbg (priv->adapter,INFO , +"info: Enabling All Multicast!\n" ); + priv->curr_pkt_filter |= +HOST_ACT_MAC_ALL_MULTICAST_ENABLE ; + }else { + priv->curr_pkt_filter &= + ~HOST_ACT_MAC_ALL_MULTICAST_ENABLE ; +nxpwifi_dbg (priv->adapter,INFO , +"info: Set multicast list=%d\n" , + mcast_list->num_multicast_addr); +/* Send multicast addresses to firmware */ + ret =nxpwifi_send_cmd (priv, +HOST_CMD_MAC_MULTICAST_ADR , +HOST_ACT_GEN_SET ,0 , + mcast_list, false); + } + } +nxpwifi_dbg (priv->adapter,INFO , +"info: old_pkt_filter=%#x, curr_pkt_filter=%#x\n" , + old_pkt_filter, priv->curr_pkt_filter); +if (old_pkt_filter != priv->curr_pkt_filter) { + ret =nxpwifi_send_cmd (priv,HOST_CMD_MAC_CONTROL , +HOST_ACT_GEN_SET , +0 , &priv->curr_pkt_filter, false); + } + +return ret; +} + +/* This function fills bss descriptor structure using provided +* information. +* beacon_ie buffer is allocated in this function. It is caller's +* responsibility to free the memory. +*/ +int nxpwifi_fill_new_bss_desc (struct nxpwifi_private *priv, +struct cfg80211_bss *bss, +struct nxpwifi_bssdescriptor *bss_desc) +{ +u8 *beacon_ie; +size_t beacon_ie_len; +struct nxpwifi_bss_priv *bss_priv = (void *)bss->priv; +const struct cfg80211_bss_ies *ies; + +rcu_read_lock (); + ies =rcu_dereference (bss->ies); + beacon_ie =kmemdup (ies->data, ies->len,GFP_ATOMIC ); + beacon_ie_len = ies->len; + bss_desc->timestamp = ies->tsf; +rcu_read_unlock (); + +if (!beacon_ie) { +nxpwifi_dbg (priv->adapter,ERROR , +" failed to alloc beacon_ie\n" ); +return -ENOMEM ; + } + +memcpy (bss_desc->mac_address, bss->bssid,ETH_ALEN ); + bss_desc->rssi = bss->signal; +/* The caller of this function will free beacon_ie */ + bss_desc->beacon_buf = beacon_ie; + bss_desc->beacon_buf_size = beacon_ie_len; + bss_desc->beacon_period = bss->beacon_interval; + bss_desc->cap_info_bitmap = bss->capability; + bss_desc->bss_band = bss_priv->band; + bss_desc->fw_tsf = bss_priv->fw_tsf; +if (bss_desc->cap_info_bitmap &WLAN_CAPABILITY_PRIVACY ) { +nxpwifi_dbg (priv->adapter,INFO , +"info: InterpretIE: AP WEP enabled\n" ); + bss_desc->privacy =NXPWIFI_802_11_PRIV_FILTER_8021X_WEP ; + }else { + bss_desc->privacy =NXPWIFI_802_11_PRIV_FILTER_ACCEPT_ALL ; + } + bss_desc->bss_mode =NL80211_IFTYPE_STATION ; + +/* Disable 11ac by default. Enable it only where there +* exist VHT_CAP IE in AP beacon +*/ + bss_desc->disable_11ac = true; + +if (bss_desc->cap_info_bitmap &WLAN_CAPABILITY_SPECTRUM_MGMT ) + bss_desc->sensed_11h = true; + +return nxpwifi_update_bss_desc_with_ie (priv->adapter, bss_desc); +} + +void nxpwifi_dnld_txpwr_table (struct nxpwifi_private *priv) +{ +if (priv->adapter->dt_node) { +char txpwr[] = {"nxp,00_txpwrlimit" }; + +memcpy (&txpwr[8 ], priv->adapter->country_code,2 ); +nxpwifi_dnld_dt_cfgdata (priv, priv->adapter->dt_node, txpwr); + } +} + +static int nxpwifi_process_country_ie (struct nxpwifi_private *priv, +struct cfg80211_bss *bss) +{ +const u8 *country_ie; +u8 country_ie_len; +struct nxpwifi_802_11d_domain_reg *domain_info = + &priv->adapter->domain_reg; + +rcu_read_lock (); + country_ie =ieee80211_bss_get_ie (bss,WLAN_EID_COUNTRY ); +if (!country_ie) { +rcu_read_unlock (); +return 0 ; + } + + country_ie_len = country_ie[1 ]; +if (country_ie_len <IEEE80211_COUNTRY_IE_MIN_LEN ) { +rcu_read_unlock (); +return 0 ; + } + +if (!strncmp (priv->adapter->country_code, &country_ie[2 ],2 )) { +rcu_read_unlock (); +nxpwifi_dbg (priv->adapter,INFO , +"11D: skip setting domain info in FW\n" ); +return 0 ; + } + +if (country_ie_len > + (IEEE80211_COUNTRY_STRING_LEN +NXPWIFI_MAX_TRIPLET_802_11D )) { +rcu_read_unlock (); +nxpwifi_dbg (priv->adapter,ERROR , +"11D: country_ie_len overflow!, deauth AP\n" ); +return -EINVAL ; + } + +memcpy (priv->adapter->country_code, &country_ie[2 ],2 ); + + domain_info->country_code[0 ] = country_ie[2 ]; + domain_info->country_code[1 ] = country_ie[3 ]; + domain_info->country_code[2 ] =' ' ; + + country_ie_len -=IEEE80211_COUNTRY_STRING_LEN ; + + domain_info->no_of_triplet = + country_ie_len /sizeof (struct ieee80211_country_ie_triplet ); + +memcpy ((u8 *)domain_info->triplet, + &country_ie[2 ] +IEEE80211_COUNTRY_STRING_LEN , country_ie_len); + +rcu_read_unlock (); + +if (nxpwifi_send_cmd (priv,HOST_CMD_802_11D_DOMAIN_INFO , +HOST_ACT_GEN_SET ,0 ,NULL , false)) { +nxpwifi_dbg (priv->adapter,ERROR , +"11D: setting domain info in FW fail\n" ); +return -1 ; + } + +nxpwifi_dnld_txpwr_table (priv); + +return 0 ; +} + +/* In infra mode, an deauthentication is performed +* first. +*/ +int nxpwifi_bss_start (struct nxpwifi_private *priv,struct cfg80211_bss *bss, +struct cfg80211_ssid *req_ssid) +{ +int ret; +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_bssdescriptor *bss_desc =NULL ; +u8 config_bands; + + priv->scan_block = false; + +if (adapter->region_code ==0x00 && +nxpwifi_process_country_ie (priv, bss)) +return -EINVAL ; + +/* Allocate and fill new bss descriptor */ + bss_desc =kzalloc (sizeof (*bss_desc),GFP_KERNEL ); +if (!bss_desc) +return -ENOMEM ; + + ret =nxpwifi_fill_new_bss_desc (priv, bss, bss_desc); +if (ret) + goto done; + +if (nxpwifi_band_to_radio_type (bss_desc->bss_band) == +HOST_SCAN_RADIO_TYPE_BG ) { + config_bands =BAND_B |BAND_G |BAND_GN ; + }else { + config_bands =BAND_A |BAND_AN ; +if (adapter->fw_bands &BAND_AAC ) + config_bands |=BAND_AAC ; + } + +if (!((config_bands | adapter->fw_bands) & ~adapter->fw_bands)) + adapter->config_bands = config_bands; + + ret =nxpwifi_check_network_compatibility (priv, bss_desc); +if (ret) + goto done; + +if (nxpwifi_11h_get_csa_closed_channel (priv) == (u8 )bss_desc->channel) { +nxpwifi_dbg (adapter,ERROR , +"Attempt to reconnect on csa closed chan(%d)\n" , + bss_desc->channel); + ret =-1 ; + goto done; + } + +nxpwifi_stop_net_dev_queue (priv->netdev, adapter); +if (netif_carrier_ok (priv->netdev)) +netif_carrier_off (priv->netdev); + +/* Clear any past association response stored for +* application retrieval +*/ + priv->assoc_rsp_size =0 ; + ret =nxpwifi_associate (priv, bss_desc); + +/* If auth type is auto and association fails using open mode, +* try to connect using shared mode +*/ +if (ret ==WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG && + priv->sec_info.is_authtype_auto && + priv->sec_info.wep_enabled) { + priv->sec_info.authentication_mode = +NL80211_AUTHTYPE_SHARED_KEY ; + ret =nxpwifi_associate (priv, bss_desc); + } + +done: +/* beacon_ie buffer was allocated in function +* nxpwifi_fill_new_bss_desc(). Free it now. +*/ +if (bss_desc) +kfree (bss_desc->beacon_buf); +kfree (bss_desc); + +if (ret <0 ) + priv->attempted_bss_desc =NULL ; + +return ret; +} + +/* IOCTL request handler to set host sleep configuration. +* +* This function prepares the correct firmware command and +* issues it. +*/ +int nxpwifi_set_hs_params (struct nxpwifi_private *priv,u16 action, +int cmd_type,struct nxpwifi_ds_hs_cfg *hs_cfg) + +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int status =0 ; +u32 prev_cond =0 ; + +if (!hs_cfg) +return -ENOMEM ; + +switch (action) { +case HOST_ACT_GEN_SET : +if (adapter->pps_uapsd_mode) { +nxpwifi_dbg (adapter,INFO , +"info: Host Sleep IOCTL\t" +"is blocked in UAPSD/PPS mode\n" ); + status =-1 ; +break ; + } +if (hs_cfg->is_invoke_hostcmd) { +if (hs_cfg->conditions ==HS_CFG_CANCEL ) { +if (!test_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags)) +/* Already cancelled */ +break ; +/* Save previous condition */ + prev_cond =le32_to_cpu (adapter->hs_cfg + .conditions); + adapter->hs_cfg.conditions = +cpu_to_le32 (hs_cfg->conditions); + }else if (hs_cfg->conditions) { + adapter->hs_cfg.conditions = +cpu_to_le32 (hs_cfg->conditions); + adapter->hs_cfg.gpio = (u8 )hs_cfg->gpio; +if (hs_cfg->gap) + adapter->hs_cfg.gap = (u8 )hs_cfg->gap; + }else if (adapter->hs_cfg.conditions == +cpu_to_le32 (HS_CFG_CANCEL )) { +/* Return failure if no parameters for HS +* enable +*/ + status =-1 ; +break ; + } + + status =nxpwifi_send_cmd (priv, +HOST_CMD_802_11_HS_CFG_ENH , +HOST_ACT_GEN_SET ,0 , + &adapter->hs_cfg, + cmd_type ==NXPWIFI_SYNC_CMD ); + +if (hs_cfg->conditions ==HS_CFG_CANCEL ) +/* Restore previous condition */ + adapter->hs_cfg.conditions = +cpu_to_le32 (prev_cond); + }else { + adapter->hs_cfg.conditions = +cpu_to_le32 (hs_cfg->conditions); + adapter->hs_cfg.gpio = (u8 )hs_cfg->gpio; + adapter->hs_cfg.gap = (u8 )hs_cfg->gap; + } +break ; +case HOST_ACT_GEN_GET : + hs_cfg->conditions =le32_to_cpu (adapter->hs_cfg.conditions); + hs_cfg->gpio = adapter->hs_cfg.gpio; + hs_cfg->gap = adapter->hs_cfg.gap; +break ; +default : + status =-1 ; +break ; + } + +return status; +} + +/* Sends IOCTL request to cancel the existing Host Sleep configuration. +* +* This function allocates the IOCTL request buffer, fills it +* with requisite parameters and calls the IOCTL handler. +*/ +int nxpwifi_cancel_hs (struct nxpwifi_private *priv,int cmd_type) +{ +struct nxpwifi_ds_hs_cfg hscfg; + + hscfg.conditions =HS_CFG_CANCEL ; + hscfg.is_invoke_hostcmd = true; + +return nxpwifi_set_hs_params (priv,HOST_ACT_GEN_SET , + cmd_type, &hscfg); +} +EXPORT_SYMBOL_GPL (nxpwifi_cancel_hs); + +/* Sends IOCTL request to cancel the existing Host Sleep configuration. +* +* This function allocates the IOCTL request buffer, fills it +* with requisite parameters and calls the IOCTL handler. +*/ +int nxpwifi_enable_hs(struct nxpwifi_adapter *adapter) +{ + struct nxpwifi_ds_hs_cfg hscfg; + struct nxpwifi_private *priv; + int i; + + if (disconnect_on_suspend) { + for (i = 0; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; + if (priv) + nxpwifi_deauthenticate(priv, NULL); + } + } + + priv = nxpwifi_get_priv(adapter, NXPWIFI_BSS_ROLE_STA); + + if (priv && priv->sched_scanning) { +#ifdef CONFIG_PM + if (priv->wdev.wiphy->wowlan_config && + !priv->wdev.wiphy->wowlan_config->nd_config) { +#endif + nxpwifi_dbg(adapter, CMD, "aborting bgscan!\n"); + nxpwifi_stop_bg_scan(priv); + cfg80211_sched_scan_stopped(priv->wdev.wiphy, 0); +#ifdef CONFIG_PM + } +#endif + } + + if (adapter->hs_activated) { + nxpwifi_dbg(adapter, CMD, + "cmd: HS Already activated\n"); + return true; + } + + adapter->hs_activate_wait_q_woken = false; + + memset(&hscfg, 0, sizeof(hscfg)); + hscfg.is_invoke_hostcmd = true; + + set_bit(NXPWIFI_IS_HS_ENABLING, &adapter->work_flags); + nxpwifi_cancel_all_pending_cmd(adapter); + + if (nxpwifi_set_hs_params(nxpwifi_get_priv(adapter, + NXPWIFI_BSS_ROLE_STA), + HOST_ACT_GEN_SET, NXPWIFI_SYNC_CMD, + &hscfg)) { + nxpwifi_dbg(adapter, ERROR, + "IOCTL request HS enable failed\n"); + return false; + } + + if (wait_event_interruptible_timeout(adapter->hs_activate_wait_q, + adapter->hs_activate_wait_q_woken, + (10 * HZ)) <= 0) { + nxpwifi_dbg(adapter, ERROR, + "hs_activate_wait_q terminated\n"); + return false; + } + + return true; +} +EXPORT_SYMBOL_GPL(nxpwifi_enable_hs); + +/* IOCTL request handler to get BSS information. + * + * This function collates the information from different driver structures + * to send to the user. + */ +int nxpwifi_get_bss_info(struct nxpwifi_private *priv, + struct nxpwifi_bss_info *info) +{ + struct nxpwifi_adapter *adapter = priv->adapter; + struct nxpwifi_bssdescriptor *bss_desc; + + if (!info) + return -1; + + bss_desc = &priv->curr_bss_params.bss_descriptor; + + info->bss_mode = priv->bss_mode; + + memcpy(&info->ssid, &bss_desc->ssid, sizeof(struct cfg80211_ssid)); + + memcpy(&info->bssid, &bss_desc->mac_address, ETH_ALEN); + + info->bss_chan = bss_desc->channel; + + memcpy(info->country_code, adapter->country_code, + IEEE80211_COUNTRY_STRING_LEN); + + info->media_connected = priv->media_connected; + + info->max_power_level = priv->max_tx_power_level; + info->min_power_level = priv->min_tx_power_level; + + info->bcn_nf_last = priv->bcn_nf_last; + + if (priv->sec_info.wep_enabled) + info->wep_status = true; + else + info->wep_status = false; + + info->is_hs_configured = test_bit(NXPWIFI_IS_HS_CONFIGURED, + &adapter->work_flags); + info->is_deep_sleep = adapter->is_deep_sleep; + + return 0; +} + +/* The function disables auto deep sleep mode. + */ +int nxpwifi_disable_auto_ds(struct nxpwifi_private *priv) +{ + struct nxpwifi_ds_auto_ds auto_ds = { + .auto_ds = DEEP_SLEEP_OFF, + }; + + return nxpwifi_send_cmd(priv, HOST_CMD_802_11_PS_MODE_ENH, + DIS_AUTO_PS, BITMAP_AUTO_DS, &auto_ds, true); +} +EXPORT_SYMBOL_GPL(nxpwifi_disable_auto_ds); + +/* Sends IOCTL request to get the data rate. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int nxpwifi_drv_get_data_rate(struct nxpwifi_private *priv, u32 *rate) +{ + int ret; + + ret = nxpwifi_send_cmd(priv, HOST_CMD_802_11_TX_RATE_QUERY, + HOST_ACT_GEN_GET, 0, NULL, true); + + if (!ret) { + if (priv->is_data_rate_auto) + *rate = nxpwifi_index_to_data_rate(priv, priv->tx_rate, + priv->tx_htinfo); + else + *rate = priv->data_rate; + } + + return ret; +} + +/* IOCTL request handler to set tx power configuration. + * + * This function prepares the correct firmware command and + * issues it. + * + * For non-auto power mode, all the following power groups are set - + * - Modulation class HR/DSSS + * - Modulation class OFDM + * - Modulation class HTBW20 + * - Modulation class HTBW40 + */ +int nxpwifi_set_tx_power(struct nxpwifi_private *priv, + struct nxpwifi_power_cfg *power_cfg) +{ + int ret; + struct host_cmd_ds_txpwr_cfg *txp_cfg; + struct nxpwifi_types_power_group *pg_tlv; + struct nxpwifi_power_group *pg; + u8 *buf; + u16 dbm = 0; + + if (!power_cfg->is_power_auto) { + dbm = (u16)power_cfg->power_level; + if (dbm < priv->min_tx_power_level || + dbm > priv->max_tx_power_level) { + nxpwifi_dbg(priv->adapter, ERROR, + "txpower value %d dBm\t" + "is out of range (%d dBm-%d dBm)\n", + dbm, priv->min_tx_power_level, + priv->max_tx_power_level); + return -1; + } + } + buf = kzalloc(NXPWIFI_SIZE_OF_CMD_BUFFER, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + txp_cfg = (struct host_cmd_ds_txpwr_cfg *)buf; + txp_cfg->action = cpu_to_le16(HOST_ACT_GEN_SET); + if (!power_cfg->is_power_auto) { + u16 dbm_min = power_cfg->is_power_fixed ? + dbm : priv->min_tx_power_level; + + txp_cfg->mode = cpu_to_le32(1); + pg_tlv = (struct nxpwifi_types_power_group *) + (buf + sizeof(struct host_cmd_ds_txpwr_cfg)); + pg_tlv->type = cpu_to_le16(TLV_TYPE_POWER_GROUP); + pg_tlv->length = + cpu_to_le16(4 * sizeof(struct nxpwifi_power_group)); + pg = (struct nxpwifi_power_group *) + (buf + sizeof(struct host_cmd_ds_txpwr_cfg) + + sizeof(struct nxpwifi_types_power_group)); + /* Power group for modulation class HR/DSSS */ + pg->first_rate_code = 0x00; + pg->last_rate_code = 0x03; + pg->modulation_class = MOD_CLASS_HR_DSSS; + pg->power_step = 0; + pg->power_min = (s8)dbm_min; + pg->power_max = (s8)dbm; + pg++; + /* Power group for modulation class OFDM */ + pg->first_rate_code = 0x00; + pg->last_rate_code = 0x07; + pg->modulation_class = MOD_CLASS_OFDM; + pg->power_step = 0; + pg->power_min = (s8)dbm_min; + pg->power_max = (s8)dbm; + pg++; + /* Power group for modulation class HTBW20 */ + pg->first_rate_code = 0x00; + pg->last_rate_code = 0x20; + pg->modulation_class = MOD_CLASS_HT; + pg->power_step = 0; + pg->power_min = (s8)dbm_min; + pg->power_max = (s8)dbm; + pg->ht_bandwidth = HT_BW_20; + pg++; + /* Power group for modulation class HTBW40 */ + pg->first_rate_code = 0x00; + pg->last_rate_code = 0x20; + pg->modulation_class = MOD_CLASS_HT; + pg->power_step = 0; + pg->power_min = (s8)dbm_min; + pg->power_max = (s8)dbm; + pg->ht_bandwidth = HT_BW_40; + } + ret = nxpwifi_send_cmd(priv, HOST_CMD_TXPWR_CFG, + HOST_ACT_GEN_SET, 0, buf, true); + + kfree(buf); + return ret; +} + +/* IOCTL request handler to get power save mode. + * + * This function prepares the correct firmware command and + * issues it. + */ +int nxpwifi_drv_set_power(struct nxpwifi_private *priv, u32 *ps_mode) +{ + int ret; + struct nxpwifi_adapter *adapter = priv->adapter; + u16 sub_cmd; + + if (*ps_mode) + adapter->ps_mode = NXPWIFI_802_11_POWER_MODE_PSP; + else + adapter->ps_mode = NXPWIFI_802_11_POWER_MODE_CAM; + sub_cmd = (*ps_mode) ? EN_AUTO_PS : DIS_AUTO_PS; + ret = nxpwifi_send_cmd(priv, HOST_CMD_802_11_PS_MODE_ENH, + sub_cmd, BITMAP_STA_PS, NULL, true); + if (!ret && sub_cmd == DIS_AUTO_PS) + ret = nxpwifi_send_cmd(priv, HOST_CMD_802_11_PS_MODE_ENH, + GET_PS, 0, NULL, false); + + return ret; +} + +/* IOCTL request handler to set/reset WPA IE. + * + * The supplied WPA IE is treated as a opaque buffer. Only the first field + * is checked to determine WPA version. If buffer length is zero, the existing + * WPA IE is reset. + */ +static int nxpwifi_set_wpa_ie(struct nxpwifi_private *priv, + u8 *ie_data_ptr, u16 ie_len) +{ + if (ie_len) { + if (ie_len > sizeof(priv->wpa_ie)) { + nxpwifi_dbg(priv->adapter, ERROR, + "failed to copy WPA IE, too big\n"); + return -1; + } + memcpy(priv->wpa_ie, ie_data_ptr, ie_len); + priv->wpa_ie_len = ie_len; + nxpwifi_dbg(priv->adapter, CMD, + "cmd: Set Wpa_ie_len=%d IE=%#x\n", + priv->wpa_ie_len, priv->wpa_ie[0]); + + if (priv->wpa_ie[0] == WLAN_EID_VENDOR_SPECIFIC) { + priv->sec_info.wpa_enabled = true; + } else if (priv->wpa_ie[0] == WLAN_EID_RSN) { + priv->sec_info.wpa2_enabled = true; + } else { + priv->sec_info.wpa_enabled = false; + priv->sec_info.wpa2_enabled = false; + } + } else { + memset(priv->wpa_ie, 0, sizeof(priv->wpa_ie)); + priv->wpa_ie_len = 0; + nxpwifi_dbg(priv->adapter, INFO, + "info: reset wpa_ie_len=%d IE=%#x\n", + priv->wpa_ie_len, priv->wpa_ie[0]); + priv->sec_info.wpa_enabled = false; + priv->sec_info.wpa2_enabled = false; + } + + return 0; +} + +/* IOCTL request handler to set/reset WPS IE. + * + * The supplied WPS IE is treated as a opaque buffer. Only the first field + * is checked to internally enable WPS. If buffer length is zero, the existing + * WPS IE is reset. + */ +static int nxpwifi_set_wps_ie(struct nxpwifi_private *priv, + u8 *ie_data_ptr, u16 ie_len) +{ + if (ie_len) { + if (ie_len > NXPWIFI_MAX_VSIE_LEN) { + nxpwifi_dbg(priv->adapter, ERROR, + "info: failed to copy WPS IE, too big\n"); + return -1; + } + + priv->wps_ie = kzalloc(NXPWIFI_MAX_VSIE_LEN, GFP_KERNEL); + if (!priv->wps_ie) + return -ENOMEM; + + memcpy(priv->wps_ie, ie_data_ptr, ie_len); + priv->wps_ie_len = ie_len; + nxpwifi_dbg(priv->adapter, CMD, + "cmd: Set wps_ie_len=%d IE=%#x\n", + priv->wps_ie_len, priv->wps_ie[0]); + } else { + kfree(priv->wps_ie); + priv->wps_ie_len = ie_len; + nxpwifi_dbg(priv->adapter, INFO, + "info: Reset wps_ie_len=%d\n", priv->wps_ie_len); + } + return 0; +} + +/* IOCTL request handler to set WEP network key. + * + * This function prepares the correct firmware command and + * issues it, after validation checks. + */ +static int +nxpwifi_sec_ioctl_set_wep_key(struct nxpwifi_private *priv, + struct nxpwifi_ds_encrypt_key *encrypt_key) +{ + struct nxpwifi_adapter *adapter = priv->adapter; + int ret; + struct nxpwifi_wep_key *wep_key; + int index; + + if (priv->wep_key_curr_index >= NUM_WEP_KEYS) + priv->wep_key_curr_index = 0; + wep_key = &priv->wep_key[priv->wep_key_curr_index]; + index = encrypt_key->key_index; + if (encrypt_key->key_disable) { + priv->sec_info.wep_enabled = 0; + } else if (!encrypt_key->key_len) { + /* Copy the required key as the current key */ + wep_key = &priv->wep_key[index]; + if (!wep_key->key_length) { + nxpwifi_dbg(adapter, ERROR, + "key not set, so cannot enable it\n"); + return -1; + } + + memcpy(encrypt_key->key_material, + wep_key->key_material, wep_key->key_length); + encrypt_key->key_len = wep_key->key_length; + + priv->wep_key_curr_index = (u16)index; + priv->sec_info.wep_enabled = 1; + } else { + wep_key = &priv->wep_key[index]; + memset(wep_key, 0, sizeof(struct nxpwifi_wep_key)); + /* Copy the key in the driver */ + memcpy(wep_key->key_material, + encrypt_key->key_material, + encrypt_key->key_len); + wep_key->key_index = index; + wep_key->key_length = encrypt_key->key_len; + priv->sec_info.wep_enabled = 1; + } + if (wep_key->key_length) { + void *enc_key; + + if (encrypt_key->key_disable) { + memset(&priv->wep_key[index], 0, + sizeof(struct nxpwifi_wep_key)); + goto done; + } + + enc_key = encrypt_key; + + /* Send request to firmware */ + ret = nxpwifi_send_cmd(priv, HOST_CMD_802_11_KEY_MATERIAL, + HOST_ACT_GEN_SET, 0, enc_key, false); + if (ret) + return ret; + } + +done: + if (priv->sec_info.wep_enabled) + priv->curr_pkt_filter |= HOST_ACT_MAC_WEP_ENABLE; + else + priv->curr_pkt_filter &= ~HOST_ACT_MAC_WEP_ENABLE; + + ret = nxpwifi_send_cmd(priv, HOST_CMD_MAC_CONTROL, + HOST_ACT_GEN_SET, 0, + &priv->curr_pkt_filter, true); + + return ret; +} + +/* IOCTL request handler to set WPA key. + * + * This function prepares the correct firmware command and + * issues it, after validation checks. + * + * Current driver only supports key length of up to 32 bytes. + * + * This function can also be used to disable a currently set key. + */ +static int +nxpwifi_sec_ioctl_set_wpa_key(struct nxpwifi_private *priv, + struct nxpwifi_ds_encrypt_key *encrypt_key) +{ + int ret; + u8 remove_key = false; + + /* Current driver only supports key length of up to 32 bytes */ + if (encrypt_key->key_len > WLAN_MAX_KEY_LEN) { + nxpwifi_dbg(priv->adapter, ERROR, + "key length too long\n"); + return -1; + } + + if (!encrypt_key->key_index) + encrypt_key->key_index = NXPWIFI_KEY_INDEX_UNICAST; + + if (remove_key) + ret = nxpwifi_send_cmd(priv, HOST_CMD_802_11_KEY_MATERIAL, + HOST_ACT_GEN_SET, + !KEY_INFO_ENABLED, encrypt_key, true); + else + ret = nxpwifi_send_cmd(priv, HOST_CMD_802_11_KEY_MATERIAL, + HOST_ACT_GEN_SET, + KEY_INFO_ENABLED, encrypt_key, true); + + return ret; +} + +/* IOCTL request handler to set/get network keys. + * + * This is a generic key handling function which supports WEP and WPA. + */ +static int +nxpwifi_sec_ioctl_encrypt_key(struct nxpwifi_private *priv, + struct nxpwifi_ds_encrypt_key *encrypt_key) +{ + int status; + + if (encrypt_key->key_len > WLAN_KEY_LEN_WEP104) + status = nxpwifi_sec_ioctl_set_wpa_key(priv, encrypt_key); + else + status = nxpwifi_sec_ioctl_set_wep_key(priv, encrypt_key); + + return status; +} + +/* This function returns the driver version. + */ +int +nxpwifi_drv_get_driver_version(struct nxpwifi_adapter *adapter, char *version, + int max_len) +{ + union { + __le32 l; + u8 c[4]; + } ver; + char fw_ver[32]; + + ver.l = cpu_to_le32(adapter->fw_release_number); + sprintf(fw_ver, "%u.%u.%u.p%u", ver.c[2], ver.c[1], ver.c[0], ver.c[3]); + + snprintf(version, max_len, driver_version, fw_ver); + + nxpwifi_dbg(adapter, MSG, "info: NXPWIFI VERSION: %s\n", version); + + return 0; +} + +/* Sends IOCTL request to set encoding parameters. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int nxpwifi_set_encode(struct nxpwifi_private *priv, struct key_params *kp, + const u8 *key, int key_len, u8 key_index, + const u8 *mac_addr, int disable) +{ + struct nxpwifi_ds_encrypt_key encrypt_key; + + memset(&encrypt_key, 0, sizeof(encrypt_key)); + encrypt_key.key_len = key_len; + encrypt_key.key_index = key_index; + + if (kp && kp->cipher == WLAN_CIPHER_SUITE_AES_CMAC) + encrypt_key.is_igtk_key = true; + + if (!disable) { + if (key_len) + memcpy(encrypt_key.key_material, key, key_len); + else + encrypt_key.is_current_wep_key = true; + + if (mac_addr) + memcpy(encrypt_key.mac_addr, mac_addr, ETH_ALEN); + if (kp && kp->seq && kp->seq_len) { + memcpy(encrypt_key.pn, kp->seq, kp->seq_len); + encrypt_key.pn_len = kp->seq_len; + encrypt_key.is_rx_seq_valid = true; + } + } else { + encrypt_key.key_disable = true; + if (mac_addr) + memcpy(encrypt_key.mac_addr, mac_addr, ETH_ALEN); + } + + return nxpwifi_sec_ioctl_encrypt_key(priv, &encrypt_key); +} + +/* Sends IOCTL request to get extended version. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int +nxpwifi_get_ver_ext(struct nxpwifi_private *priv, u32 version_str_sel) +{ + struct nxpwifi_ver_ext ver_ext; + + memset(&ver_ext, 0, sizeof(ver_ext)); + ver_ext.version_str_sel = version_str_sel; + if (nxpwifi_send_cmd(priv, HOST_CMD_VERSION_EXT, + HOST_ACT_GEN_GET, 0, &ver_ext, true)) + return -1; + + return 0; +} + +int +nxpwifi_remain_on_chan_cfg(struct nxpwifi_private *priv, u16 action, + struct ieee80211_channel *chan, + unsigned int duration) +{ + struct host_cmd_ds_remain_on_chan roc_cfg; + u8 sc; + + memset(&roc_cfg, 0, sizeof(roc_cfg)); + roc_cfg.action = cpu_to_le16(action); + if (action == HOST_ACT_GEN_SET) { + roc_cfg.band_cfg = chan->band; + sc = nxpwifi_chan_type_to_sec_chan_offset(NL80211_CHAN_NO_HT); + roc_cfg.band_cfg |= (sc << 2); + + roc_cfg.channel = + ieee80211_frequency_to_channel(chan->center_freq); + roc_cfg.duration = cpu_to_le32(duration); + } + if (nxpwifi_send_cmd(priv, HOST_CMD_REMAIN_ON_CHAN, + action, 0, &roc_cfg, true)) { + nxpwifi_dbg(priv->adapter, ERROR, + "failed to remain on channel\n"); + return -1; + } + + return roc_cfg.status; +} + +/* Sends IOCTL request to get statistics information. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int +nxpwifi_get_stats_info(struct nxpwifi_private *priv, + struct nxpwifi_ds_get_stats *log) +{ + return nxpwifi_send_cmd(priv, HOST_CMD_802_11_GET_LOG, + HOST_ACT_GEN_GET, 0, log, true); +} + +/* IOCTL request handler to read/write register. + * + * This function prepares the correct firmware command and + * issues it. + * + * Access to the following registers are supported - + * - MAC + * - BBP + * - RF + * - PMIC + * - CAU + */ +static int nxpwifi_reg_mem_ioctl_reg_rw(struct nxpwifi_private *priv, + struct nxpwifi_ds_reg_rw *reg_rw, + u16 action) +{ + u16 cmd_no; + + switch (reg_rw->type) { + case NXPWIFI_REG_MAC: + cmd_no = HOST_CMD_MAC_REG_ACCESS; + break; + case NXPWIFI_REG_BBP: + cmd_no = HOST_CMD_BBP_REG_ACCESS; + break; + case NXPWIFI_REG_RF: + cmd_no = HOST_CMD_RF_REG_ACCESS; + break; + case NXPWIFI_REG_PMIC: + cmd_no = HOST_CMD_PMIC_REG_ACCESS; + break; + case NXPWIFI_REG_CAU: + cmd_no = HOST_CMD_CAU_REG_ACCESS; + break; + default: + return -1; + } + + return nxpwifi_send_cmd(priv, cmd_no, action, 0, reg_rw, true); +} + +/* Sends IOCTL request to write to a register. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int +nxpwifi_reg_write(struct nxpwifi_private *priv, u32 reg_type, + u32 reg_offset, u32 reg_value) +{ + struct nxpwifi_ds_reg_rw reg_rw; + + reg_rw.type = reg_type; + reg_rw.offset = reg_offset; + reg_rw.value = reg_value; + + return nxpwifi_reg_mem_ioctl_reg_rw(priv, ®_rw, HOST_ACT_GEN_SET); +} + +/* Sends IOCTL request to read from a register. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int +nxpwifi_reg_read(struct nxpwifi_private *priv, u32 reg_type, + u32 reg_offset, u32 *value) +{ + int ret; + struct nxpwifi_ds_reg_rw reg_rw; + + reg_rw.type = reg_type; + reg_rw.offset = reg_offset; + ret = nxpwifi_reg_mem_ioctl_reg_rw(priv, ®_rw, HOST_ACT_GEN_GET); + + if (ret) + goto done; + + *value = reg_rw.value; + +done: + return ret; +} + +/* Sends IOCTL request to read from EEPROM. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int +nxpwifi_eeprom_read(struct nxpwifi_private *priv, u16 offset, u16 bytes, + u8 *value) +{ + int ret; + struct nxpwifi_ds_read_eeprom rd_eeprom; + + rd_eeprom.offset = offset; + rd_eeprom.byte_count = bytes; + + /* Send request to firmware */ + ret = nxpwifi_send_cmd(priv, HOST_CMD_802_11_EEPROM_ACCESS, + HOST_ACT_GEN_GET, 0, &rd_eeprom, true); + + if (!ret) + memcpy(value, rd_eeprom.value, + min((u16)MAX_EEPROM_DATA, rd_eeprom.byte_count)); + return ret; +} + +/* This function sets a generic IE. In addition to generic IE, it can + * also handle WPA and WPA2 IEs. + */ +static int +nxpwifi_set_gen_ie_helper(struct nxpwifi_private *priv, u8 *ie_data_ptr, + u16 ie_len) +{ + struct ieee_types_vendor_header *pvendor_ie; + static const u8 wpa_oui[] = { 0x00, 0x50, 0xf2, 0x01 }; + static const u8 wps_oui[] = { 0x00, 0x50, 0xf2, 0x04 }; + u16 unparsed_len = ie_len, cur_ie_len; + + /* If the passed length is zero, reset the buffer */ + if (!ie_len) { + priv->gen_ie_buf_len = 0; + priv->wps.session_enable = false; + return 0; + } else if (!ie_data_ptr || + ie_len <= sizeof(struct ieee_types_header)) { + return -1; + } + pvendor_ie = (struct ieee_types_vendor_header *)ie_data_ptr; + + while (pvendor_ie) { + cur_ie_len = pvendor_ie->len + sizeof(struct ieee_types_header); + + if (pvendor_ie->element_id == WLAN_EID_RSN) { + /* IE is a WPA/WPA2 IE so call set_wpa function */ + nxpwifi_set_wpa_ie(priv, (u8 *)pvendor_ie, cur_ie_len); + priv->wps.session_enable = false; + goto next_ie; + } + + if (pvendor_ie->element_id == WLAN_EID_VENDOR_SPECIFIC) { + /* Test to see if it is a WPA IE, if not, then + * it is a gen IE + */ + if (!memcmp(&pvendor_ie->oui, wpa_oui, + sizeof(wpa_oui))) { + /* IE is a WPA/WPA2 IE so call set_wpa function + */ + nxpwifi_set_wpa_ie(priv, (u8 *)pvendor_ie, + cur_ie_len); + priv->wps.session_enable = false; + goto next_ie; + } + + if (!memcmp(&pvendor_ie->oui, wps_oui, + sizeof(wps_oui))) { + /* Test to see if it is a WPS IE, + * if so, enable wps session flag + */ + priv->wps.session_enable = true; + nxpwifi_dbg(priv->adapter, MSG, + "WPS Session Enabled.\n"); + nxpwifi_set_wps_ie(priv, (u8 *)pvendor_ie, + cur_ie_len); + goto next_ie; + } + } + + /* Verify that the passed length is not larger than the + * available space remaining in the buffer + */ + if (cur_ie_len < + (sizeof(priv->gen_ie_buf) - priv->gen_ie_buf_len)) { + /* Append the passed data to the end + * of the genIeBuffer + */ + memcpy(priv->gen_ie_buf + priv->gen_ie_buf_len, + (u8 *)pvendor_ie, cur_ie_len); + /* Increment the stored buffer length by the + * size passed + */ + priv->gen_ie_buf_len += cur_ie_len; + } + +next_ie: + unparsed_len -= cur_ie_len; + + if (unparsed_len <= sizeof(struct ieee_types_header)) + pvendor_ie = NULL; + else + pvendor_ie = (struct ieee_types_vendor_header *) + (((u8 *)pvendor_ie) + cur_ie_len); + } + + return 0; +} + +/* IOCTL request handler to set/get generic IE. + * + * In addition to various generic IEs, this function can also be + * used to set the ARP filter. + */ +static int nxpwifi_misc_ioctl_gen_ie(struct nxpwifi_private *priv, + struct nxpwifi_ds_misc_gen_ie *gen_ie, + u16 action) +{ + struct nxpwifi_adapter *adapter = priv->adapter; + + switch (gen_ie->type) { + case NXPWIFI_IE_TYPE_GEN_IE: + if (action == HOST_ACT_GEN_GET) { + gen_ie->len = priv->wpa_ie_len; + memcpy(gen_ie->ie_data, priv->wpa_ie, gen_ie->len); + } else { + nxpwifi_set_gen_ie_helper(priv, gen_ie->ie_data, + (u16)gen_ie->len); + } + break; + case NXPWIFI_IE_TYPE_ARP_FILTER: + memset(adapter->arp_filter, 0, sizeof(adapter->arp_filter)); + if (gen_ie->len > ARP_FILTER_MAX_BUF_SIZE) { + adapter->arp_filter_size = 0; + nxpwifi_dbg(adapter, ERROR, + "invalid ARP filter size\n"); + return -1; + } + memcpy(adapter->arp_filter, gen_ie->ie_data, gen_ie->len); + adapter->arp_filter_size = gen_ie->len; + break; + default: + nxpwifi_dbg(adapter, ERROR, "invalid IE type\n"); + return -1; + } + return 0; +} + +/* Sends IOCTL request to set a generic IE. + * + * This function allocates the IOCTL request buffer, fills it + * with requisite parameters and calls the IOCTL handler. + */ +int +nxpwifi_set_gen_ie(struct nxpwifi_private *priv, const u8 *ie, int ie_len) +{ + struct nxpwifi_ds_misc_gen_ie gen_ie; + + if (ie_len > IEEE_MAX_IE_SIZE) + return -EFAULT; + + gen_ie.type = NXPWIFI_IE_TYPE_GEN_IE; + gen_ie.len = ie_len; + memcpy(gen_ie.ie_data, ie, ie_len); + if (nxpwifi_misc_ioctl_gen_ie(priv, &gen_ie, HOST_ACT_GEN_SET)) + return -EFAULT; + + return 0; +} + +/* This function get Host Sleep wake up reason. + */ +int nxpwifi_get_wakeup_reason(struct nxpwifi_private *priv, u16 action, + int cmd_type, + struct nxpwifi_ds_wakeup_reason *wakeup_reason) +{ + int status = 0; + + status = nxpwifi_send_cmd(priv, HOST_CMD_HS_WAKEUP_REASON, + HOST_ACT_GEN_GET, 0, wakeup_reason, + cmd_type == NXPWIFI_SYNC_CMD); + + return status; +} + +int nxpwifi_get_chan_info(struct nxpwifi_private *priv, + struct nxpwifi_channel_band *channel_band) +{ + int status = 0; + + status = nxpwifi_send_cmd(priv, HOST_CMD_STA_CONFIGURE, + HOST_ACT_GEN_GET, 0, channel_band, + NXPWIFI_SYNC_CMD); + + return status; +}
Signature · 1 line
2.34.1
PATCH 31/43 wifi: nxpwifi: add sta_rx.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/sta_rx.c | 244 ++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_rx.c
drivers/net/wireless/nxp/nxpwifi/sta_rx.c new file +244 -0
@@ -0,0 +1,244 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: station RX data handling +* +* Copyright 2011-2024 NXP +*/ + +#include <uapi/linux/ipv6.h> +#include <net/ndisc.h> +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "11n_aggr.h" +#include "11n_rxreorder.h" + +/* This function checks if a frame is IPv4 ARP or IPv6 Neighbour advertisement +* frame. If frame has both source and destination mac address as same, this +* function drops such gratuitous frames. +*/ +static bool +nxpwifi_discard_gratuitous_arp (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +const struct nxpwifi_arp_eth_header *arp; +struct ethhdr *eth; +struct ipv6hdr *ipv6; +struct icmp6hdr *icmpv6; + + eth = (struct ethhdr *)skb->data; +switch (ntohs (eth->h_proto)) { +case ETH_P_ARP : + arp = (void *)(skb->data +sizeof (struct ethhdr )); +if (arp->hdr.ar_op ==htons (ARPOP_REPLY ) || + arp->hdr.ar_op ==htons (ARPOP_REQUEST )) { +if (!memcmp (arp->ar_sip, arp->ar_tip,4 )) +return true; + } +break ; +case ETH_P_IPV6 : + ipv6 = (void *)(skb->data +sizeof (struct ethhdr )); + icmpv6 = (void *)(skb->data +sizeof (struct ethhdr ) + +sizeof (struct ipv6hdr )); +if (icmpv6->icmp6_type ==NDISC_NEIGHBOUR_ADVERTISEMENT ) { +if (!memcmp (&ipv6->saddr, &ipv6->daddr, +sizeof (struct in6_addr ))) +return true; + } +break ; +default : +break ; + } + +return false; +} + +/* This function processes the received packet and forwards it +* to kernel/upper layer. +* +* This function parses through the received packet and determines +* if it is a debug packet or normal packet. +* +* For non-debug packets, the function chops off unnecessary leading +* header bytes, reconstructs the packet as an ethernet frame or +* 802.2/llc/snap frame as required, and sends it to kernel/upper layer. +* +* The completion callback is called after processing in complete. +*/ +int nxpwifi_process_rx_packet (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +int ret; +struct rx_packet_hdr *rx_pkt_hdr; +struct rxpd *local_rx_pd; +int hdr_chop; +struct ethhdr *eth; +u16 rx_pkt_off, rx_pkt_len; +u8 adj_rx_rate =0 ; + + local_rx_pd = (struct rxpd *)(skb->data); + + rx_pkt_off =le16_to_cpu (local_rx_pd->rx_pkt_offset); + rx_pkt_len =le16_to_cpu (local_rx_pd->rx_pkt_length); + rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_off; + +if (sizeof (rx_pkt_hdr->eth803_hdr) +sizeof (rfc1042_header) + + rx_pkt_off > skb->len) { + priv->stats.rx_dropped++; +dev_kfree_skb_any (skb); +return -1 ; + } + +if (sizeof (*rx_pkt_hdr) + rx_pkt_off <= skb->len && + ((!memcmp (&rx_pkt_hdr->rfc1042_hdr, bridge_tunnel_header, +sizeof (bridge_tunnel_header))) || + (!memcmp (&rx_pkt_hdr->rfc1042_hdr, rfc1042_header, +sizeof (rfc1042_header)) && + rx_pkt_hdr->rfc1042_hdr.snap_type !=htons (ETH_P_AARP ) && + rx_pkt_hdr->rfc1042_hdr.snap_type !=htons (ETH_P_IPX )))) { +/* Replace the 803 header and rfc1042 header (llc/snap) with an +* EthernetII header, keep the src/dst and snap_type +* (ethertype). +* The firmware only passes up SNAP frames converting +* all RX Data from 802.11 to 802.2/LLC/SNAP frames. +* To create the Ethernet II, just move the src, dst address +* right before the snap_type. +*/ + eth = (struct ethhdr *) + ((u8 *)&rx_pkt_hdr->eth803_hdr + +sizeof (rx_pkt_hdr->eth803_hdr) + +sizeof (rx_pkt_hdr->rfc1042_hdr) + -sizeof (rx_pkt_hdr->eth803_hdr.h_dest) + -sizeof (rx_pkt_hdr->eth803_hdr.h_source) + -sizeof (rx_pkt_hdr->rfc1042_hdr.snap_type)); + +memcpy (eth->h_source, rx_pkt_hdr->eth803_hdr.h_source, +sizeof (eth->h_source)); +memcpy (eth->h_dest, rx_pkt_hdr->eth803_hdr.h_dest, +sizeof (eth->h_dest)); + +/* Chop off the rxpd + the excess memory from the 802.2/llc/snap +* header that was removed. +*/ + hdr_chop = (u8 *)eth - (u8 *)local_rx_pd; + }else { +/* Chop off the rxpd */ + hdr_chop = (u8 *)&rx_pkt_hdr->eth803_hdr - (u8 *)local_rx_pd; + } + +/* Chop off the leading header bytes so the it points to the start of +* either the reconstructed EthII frame or the 802.2/llc/snap frame +*/ +skb_pull (skb, hdr_chop); + +if (priv->hs2_enabled && +nxpwifi_discard_gratuitous_arp (priv, skb)) { +nxpwifi_dbg (priv->adapter,INFO ,"Bypassed Gratuitous ARP\n" ); +dev_kfree_skb_any (skb); +return 0 ; + } + +/* Only stash RX bitrate for unicast packets. */ +if (likely (!is_multicast_ether_addr (rx_pkt_hdr->eth803_hdr.h_dest))) { + priv->rxpd_rate = local_rx_pd->rx_rate; + priv->rxpd_htinfo = local_rx_pd->ht_info; + } + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA || +GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { + adj_rx_rate =nxpwifi_adjust_data_rate (priv, + local_rx_pd->rx_rate, + local_rx_pd->ht_info); +nxpwifi_hist_data_add (priv, adj_rx_rate, local_rx_pd->snr, + local_rx_pd->nf); + } + + ret =nxpwifi_recv_packet (priv, skb); +if (ret ==-1 ) +nxpwifi_dbg (priv->adapter,ERROR , +"recv packet failed\n" ); + +return ret; +} + +/* This function processes the received buffer. +* +* The function looks into the RxPD and performs sanity tests on the +* received buffer to ensure its a valid packet, before processing it +* further. If the packet is determined to be aggregated, it is +* de-aggregated accordingly. Non-unicast packets are sent directly to +* the kernel/upper layers. Unicast packets are handed over to the +* Rx reordering routine if 11n is enabled. +* +* The completion callback is called after processing in complete. +*/ +int nxpwifi_process_sta_rx_packet (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret =0 ; +struct rxpd *local_rx_pd; +struct rx_packet_hdr *rx_pkt_hdr; +u8 ta[ETH_ALEN ]; +u16 rx_pkt_type, rx_pkt_offset, rx_pkt_length, seq_num; + + local_rx_pd = (struct rxpd *)(skb->data); + rx_pkt_type =le16_to_cpu (local_rx_pd->rx_pkt_type); + rx_pkt_offset =le16_to_cpu (local_rx_pd->rx_pkt_offset); + rx_pkt_length =le16_to_cpu (local_rx_pd->rx_pkt_length); + seq_num =le16_to_cpu (local_rx_pd->seq_num); + + rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_offset; + +if ((rx_pkt_offset + rx_pkt_length) > skb->len || +sizeof (rx_pkt_hdr->eth803_hdr) + rx_pkt_offset > skb->len) { +nxpwifi_dbg (adapter,ERROR , +"wrong rx packet: len=%d, rx_pkt_offset=%d, rx_pkt_length=%d\n" , + skb->len, rx_pkt_offset, rx_pkt_length); + priv->stats.rx_dropped++; +dev_kfree_skb_any (skb); +return ret; + } + +if (rx_pkt_type ==PKT_TYPE_MGMT ) { + ret =nxpwifi_process_mgmt_packet (priv, skb); +if (ret) +nxpwifi_dbg (adapter,DATA ,"Rx of mgmt packet failed" ); +dev_kfree_skb_any (skb); +return ret; + } + +/* If the packet is not an unicast packet then send the packet +* directly to os. Don't pass thru rx reordering +*/ +if (!IS_11N_ENABLED (priv) || + !ether_addr_equal_unaligned (priv->curr_addr, + rx_pkt_hdr->eth803_hdr.h_dest)) { +nxpwifi_process_rx_packet (priv, skb); +return ret; + } + +if (nxpwifi_queuing_ra_based (priv)) { +memcpy (ta, rx_pkt_hdr->eth803_hdr.h_source,ETH_ALEN ); + }else { +if (rx_pkt_type !=PKT_TYPE_BAR && + local_rx_pd->priority <MAX_NUM_TID ) + priv->rx_seq[local_rx_pd->priority] = seq_num; +memcpy (ta, priv->curr_bss_params.bss_descriptor.mac_address, +ETH_ALEN ); + } + +/* Reorder and send to OS */ + ret =nxpwifi_11n_rx_reorder_pkt (priv, seq_num, local_rx_pd->priority, + ta, (u8 )rx_pkt_type, skb); + +if (ret || rx_pkt_type ==PKT_TYPE_BAR ) +dev_kfree_skb_any (skb); + +if (ret) + priv->stats.rx_dropped++; + +return ret; +}
Signature · 1 line
2.34.1
PATCH 32/43 wifi: nxpwifi: add sta_tx.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/sta_tx.c | 215 ++++++++++++++++++++++ 1 file changed, 215 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_tx.c
drivers/net/wireless/nxp/nxpwifi/sta_tx.c new file +215 -0
@@ -0,0 +1,215 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: station TX data handling +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" + +/* This function fills the TxPD for tx packets. +* +* The Tx buffer received by this function should already have the +* header space allocated for TxPD. +* +* This function inserts the TxPD in between interface header and actual +* data and adjusts the buffer pointers accordingly. +* +* The following TxPD fields are set by this function, as required - +* - BSS number +* - Tx packet length and offset +* - Priority +* - Packet delay +* - Priority specific Tx control +* - Flags +*/ +void nxpwifi_process_sta_txpd (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct txpd *local_tx_pd; +struct nxpwifi_txinfo *tx_info =NXPWIFI_SKB_TXCB (skb); +unsigned int pad; +u16 pkt_type, pkt_length, pkt_offset; +int hroom = adapter->intf_hdr_len; +u32 tx_control; + + pkt_type =nxpwifi_is_skb_mgmt_frame (skb) ?PKT_TYPE_MGMT :0 ; + + pad = ((uintptr_t )skb->data - (sizeof (*local_tx_pd) + hroom)) & + (NXPWIFI_DMA_ALIGN_SZ -1 ); +skb_push (skb,sizeof (*local_tx_pd) + pad); + + local_tx_pd = (struct txpd *)skb->data; +memset (local_tx_pd,0 ,sizeof (struct txpd )); + local_tx_pd->bss_num = priv->bss_num; + local_tx_pd->bss_type = priv->bss_type; + + pkt_length = (u16)(skb->len - (sizeof (struct txpd ) + pad)); +if (pkt_type ==PKT_TYPE_MGMT ) + pkt_length -=NXPWIFI_MGMT_FRAME_HEADER_SIZE ; + local_tx_pd->tx_pkt_length =cpu_to_le16 (pkt_length); + + local_tx_pd->priority = (u8 )skb->priority; + local_tx_pd->pkt_delay_2ms = +nxpwifi_wmm_compute_drv_pkt_delay (priv, skb); + +if (tx_info->flags &NXPWIFI_BUF_FLAG_EAPOL_TX_STATUS || + tx_info->flags &NXPWIFI_BUF_FLAG_ACTION_TX_STATUS ) { + local_tx_pd->tx_token_id = tx_info->ack_frame_id; + local_tx_pd->flags |=NXPWIFI_TXPD_FLAGS_REQ_TX_STATUS ; + } + +if (local_tx_pd->priority < +ARRAY_SIZE (priv->wmm.user_pri_pkt_tx_ctrl)) { +/* Set the priority specific tx_control field, setting of 0 will +* cause the default value to be used later in this function +*/ + tx_control = + priv->wmm.user_pri_pkt_tx_ctrl[local_tx_pd->priority]; + local_tx_pd->tx_control =cpu_to_le32 (tx_control); + } + +if (adapter->pps_uapsd_mode) { +if (nxpwifi_check_last_packet_indication (priv)) { + adapter->tx_lock_flag = true; + local_tx_pd->flags = + NXPWIFI_TxPD_POWER_MGMT_LAST_PACKET; + } + } + +/* Offset of actual data */ + pkt_offset =sizeof (struct txpd ) + pad; +if (pkt_type ==PKT_TYPE_MGMT ) { +/* Set the packet type and add header for management frame */ + local_tx_pd->tx_pkt_type =cpu_to_le16 (pkt_type); + pkt_offset +=NXPWIFI_MGMT_FRAME_HEADER_SIZE ; + } + + local_tx_pd->tx_pkt_offset =cpu_to_le16 (pkt_offset); + +/* make space for adapter->intf_hdr_len */ +skb_push (skb, hroom); + +if (!local_tx_pd->tx_control) +/* TxCtrl set by user or default */ + local_tx_pd->tx_control =cpu_to_le32 (priv->pkt_tx_ctrl); +} + +/* This function tells firmware to send a NULL data packet. +* +* The function creates a NULL data packet with TxPD and sends to the +* firmware for transmission, with highest priority setting. +*/ +int nxpwifi_send_null_packet (struct nxpwifi_private *priv,u8 flags) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct txpd *local_tx_pd; +struct nxpwifi_tx_param tx_param; +/* sizeof(struct txpd) + Interface specific header */ +#define NULL_PACKET_HDR 64 +u32 data_len =NULL_PACKET_HDR ; +struct sk_buff *skb; +int ret; +struct nxpwifi_txinfo *tx_info =NULL ; + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return -1 ; + +if (!priv->media_connected) +return -1 ; + +if (adapter->data_sent) +return -1 ; + +if (adapter->if_ops.is_port_ready && + !adapter->if_ops.is_port_ready (priv)) +return -1 ; + + skb =dev_alloc_skb (data_len); +if (!skb) +return -1 ; + + tx_info =NXPWIFI_SKB_TXCB (skb); +memset (tx_info,0 ,sizeof (*tx_info)); + tx_info->bss_num = priv->bss_num; + tx_info->bss_type = priv->bss_type; + tx_info->pkt_len = data_len - + (sizeof (struct txpd ) + adapter->intf_hdr_len); +skb_reserve (skb,sizeof (struct txpd ) + adapter->intf_hdr_len); +skb_push (skb,sizeof (struct txpd )); + + local_tx_pd = (struct txpd *)skb->data; + local_tx_pd->tx_control =cpu_to_le32 (priv->pkt_tx_ctrl); + local_tx_pd->flags = flags; + local_tx_pd->priority =WMM_HIGHEST_PRIORITY ; + local_tx_pd->tx_pkt_offset =cpu_to_le16 (sizeof (struct txpd )); + local_tx_pd->bss_num = priv->bss_num; + local_tx_pd->bss_type = priv->bss_type; + +skb_push (skb, adapter->intf_hdr_len); + tx_param.next_pkt_len =0 ; + ret = adapter->if_ops.host_to_card (adapter,NXPWIFI_TYPE_DATA , + skb, &tx_param); + +switch (ret) { +case -EBUSY : +dev_kfree_skb_any (skb); +nxpwifi_dbg (adapter,ERROR , +"%s: host_to_card failed: ret=%d\n" , + __func__, ret); + adapter->dbg.num_tx_host_to_card_failure++; +break ; +case -1 : +dev_kfree_skb_any (skb); +nxpwifi_dbg (adapter,ERROR , +"%s: host_to_card failed: ret=%d\n" , + __func__, ret); + adapter->dbg.num_tx_host_to_card_failure++; +break ; +case 0 : +dev_kfree_skb_any (skb); +nxpwifi_dbg (adapter,DATA , +"data: %s: host_to_card succeeded\n" , + __func__); + adapter->tx_lock_flag = true; +break ; +case -EINPROGRESS : + adapter->tx_lock_flag = true; +break ; +default : +break ; + } + +return ret; +} + +/* This function checks if we need to send last packet indication. +*/ +u8 +nxpwifi_check_last_packet_indication (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u8 ret = false; + +if (!adapter->sleep_period.period) +return ret; +if (nxpwifi_wmm_lists_empty (adapter)) + ret = true; + +if (ret && !adapter->cmd_sent && !adapter->curr_cmd && + !is_command_pending (adapter)) { + adapter->delay_null_pkt = false; + ret = true; + }else { + ret = false; + adapter->delay_null_pkt = true; + } +return ret; +}
Signature · 1 line
2.34.1
PATCH 33/43 wifi: nxpwifi: add txrx.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/txrx.c | 362 ++++++++++++++++++++++++ 1 file changed, 362 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/txrx.c
drivers/net/wireless/nxp/nxpwifi/txrx.c new file +362 -0
@@ -0,0 +1,362 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: generic TX/RX data handling +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "ioctl.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "wmm.h" + +/* This function processes the received buffer. +* +* Main responsibility of this function is to parse the RxPD to +* identify the correct interface this packet is headed for and +* forwarding it to the associated handling function, where the +* packet will be further processed and sent to kernel/upper layer +* if required. +*/ +int nxpwifi_handle_rx_packet (struct nxpwifi_adapter *adapter, +struct sk_buff *skb) +{ +struct nxpwifi_private *priv = +nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +struct rxpd *local_rx_pd; +struct nxpwifi_rxinfo *rx_info =NXPWIFI_SKB_RXCB (skb); +int ret; + + local_rx_pd = (struct rxpd *)(skb->data); +/* Get the BSS number from rxpd, get corresponding priv */ + priv =nxpwifi_get_priv_by_id (adapter, local_rx_pd->bss_num & +BSS_NUM_MASK , local_rx_pd->bss_type); +if (!priv) + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); + +if (!priv) { +nxpwifi_dbg (adapter,ERROR , +"data: priv not found. Drop RX packet\n" ); +dev_kfree_skb_any (skb); +return -1 ; + } + +nxpwifi_dbg_dump (adapter,DAT_D ,"rx pkt:" , skb->data, +min_t (size_t, skb->len,DEBUG_DUMP_DATA_MAX_LEN )); + +memset (rx_info,0 ,sizeof (*rx_info)); + rx_info->bss_num = priv->bss_num; + rx_info->bss_type = priv->bss_type; + +if (priv->bss_role ==NXPWIFI_BSS_ROLE_UAP ) + ret =nxpwifi_process_uap_rx_packet (priv, skb); +else + ret =nxpwifi_process_sta_rx_packet (priv, skb); + +return ret; +} +EXPORT_SYMBOL_GPL (nxpwifi_handle_rx_packet); + +/* This function sends a packet to device. +* +* It processes the packet to add the TxPD, checks condition and +* sends the processed packet to firmware for transmission. +* +* On successful completion, the function calls the completion callback +* and logs the time. +*/ +int nxpwifi_process_tx (struct nxpwifi_private *priv,struct sk_buff *skb, +struct nxpwifi_tx_param *tx_param) +{ +int hroom, ret; +struct nxpwifi_adapter *adapter = priv->adapter; +struct txpd *local_tx_pd =NULL ; +struct nxpwifi_sta_node *dest_node; +struct ethhdr *hdr = (void *)skb->data; + +if (unlikely (!skb->len || +skb_headroom (skb) <NXPWIFI_MIN_DATA_HEADER_LEN )) { + ret = -EINVAL ; + goto out; + } + + hroom = adapter->intf_hdr_len; + +if (priv->bss_role ==NXPWIFI_BSS_ROLE_UAP ) { + dest_node =nxpwifi_get_sta_entry (priv, hdr->h_dest); +if (dest_node) { + dest_node->stats.tx_bytes += skb->len; + dest_node->stats.tx_packets++; + } + +nxpwifi_process_uap_txpd (priv, skb); + }else { +nxpwifi_process_sta_txpd (priv, skb); + } + +if ((adapter->data_sent || adapter->tx_lock_flag)) { +skb_queue_tail (&adapter->tx_data_q, skb); +atomic_inc (&adapter->tx_queued); +return 0 ; + } + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) + local_tx_pd = (struct txpd *)(skb->data + hroom); + ret = adapter->if_ops.host_to_card (adapter, +NXPWIFI_TYPE_DATA , + skb, tx_param); +nxpwifi_dbg_dump (adapter,DAT_D ,"tx pkt:" , skb->data, +min_t (size_t, skb->len,DEBUG_DUMP_DATA_MAX_LEN )); + +out: +switch (ret) { +case -ENOSR : +nxpwifi_dbg (adapter,DATA ,"data: -ENOSR is returned\n" ); +break ; +case -EBUSY : +if ((GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) && + adapter->pps_uapsd_mode && adapter->tx_lock_flag) { + priv->adapter->tx_lock_flag = false; +if (local_tx_pd) + local_tx_pd->flags =0 ; + } +nxpwifi_dbg (adapter,ERROR ,"data: -EBUSY is returned\n" ); +break ; +case -1 : +nxpwifi_dbg (adapter,ERROR , +"nxpwifi_write_data_async failed: 0x%X\n" , + ret); + adapter->dbg.num_tx_host_to_card_failure++; +nxpwifi_write_data_complete (adapter, skb,0 , ret); +break ; +case -EINPROGRESS : +break ; +case -EINVAL : +nxpwifi_dbg (adapter,ERROR , +"malformed skb (length: %u, headroom: %u)\n" , + skb->len,skb_headroom (skb)); + fallthrough; +case 0 : +nxpwifi_write_data_complete (adapter, skb,0 , ret); +break ; +default : +break ; + } + +return ret; +} + +static int nxpwifi_host_to_card (struct nxpwifi_adapter *adapter, +struct sk_buff *skb, +struct nxpwifi_tx_param *tx_param) +{ +struct txpd *local_tx_pd =NULL ; +u8 *head_ptr = skb->data; +int ret =0 ; +struct nxpwifi_private *priv; +struct nxpwifi_txinfo *tx_info; + + tx_info =NXPWIFI_SKB_TXCB (skb); + priv =nxpwifi_get_priv_by_id (adapter, tx_info->bss_num, + tx_info->bss_type); +if (!priv) { +nxpwifi_dbg (adapter,ERROR , +"data: priv not found. Drop TX packet\n" ); + adapter->dbg.num_tx_host_to_card_failure++; +nxpwifi_write_data_complete (adapter, skb,0 ,0 ); +return ret; + } +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) + local_tx_pd = (struct txpd *)(head_ptr + adapter->intf_hdr_len); + + ret = adapter->if_ops.host_to_card (adapter, +NXPWIFI_TYPE_DATA , + skb, tx_param); + +switch (ret) { +case -ENOSR : +nxpwifi_dbg (adapter,ERROR ,"data: -ENOSR is returned\n" ); +break ; +case -EBUSY : +if ((GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) && + adapter->pps_uapsd_mode && + adapter->tx_lock_flag) { + priv->adapter->tx_lock_flag = false; +if (local_tx_pd) + local_tx_pd->flags =0 ; + } +skb_queue_head (&adapter->tx_data_q, skb); +if (tx_info->flags &NXPWIFI_BUF_FLAG_AGGR_PKT ) +atomic_add (tx_info->aggr_num, &adapter->tx_queued); +else +atomic_inc (&adapter->tx_queued); +nxpwifi_dbg (adapter,ERROR ,"data: -EBUSY is returned\n" ); +break ; +case -1 : +nxpwifi_dbg (adapter,ERROR , +"nxpwifi_write_data_async failed: 0x%X\n" , ret); + adapter->dbg.num_tx_host_to_card_failure++; +nxpwifi_write_data_complete (adapter, skb,0 , ret); +break ; +case -EINPROGRESS : +break ; +case 0 : +nxpwifi_write_data_complete (adapter, skb,0 , ret); +break ; +default : +break ; + } +return ret; +} + +static int +nxpwifi_dequeue_tx_queue (struct nxpwifi_adapter *adapter) +{ +struct sk_buff *skb, *skb_next; +struct nxpwifi_txinfo *tx_info; +struct nxpwifi_tx_param tx_param; + + skb =skb_dequeue (&adapter->tx_data_q); +if (!skb) +return -1 ; + + tx_info =NXPWIFI_SKB_TXCB (skb); +if (tx_info->flags &NXPWIFI_BUF_FLAG_AGGR_PKT ) +atomic_sub (tx_info->aggr_num, &adapter->tx_queued); +else +atomic_dec (&adapter->tx_queued); + +if (!skb_queue_empty (&adapter->tx_data_q)) + skb_next =skb_peek (&adapter->tx_data_q); +else + skb_next =NULL ; + tx_param.next_pkt_len = ((skb_next) ? skb_next->len :0 ); +if (!tx_param.next_pkt_len) { +if (!nxpwifi_wmm_lists_empty (adapter)) + tx_param.next_pkt_len =1 ; + } +return nxpwifi_host_to_card (adapter, skb, &tx_param); +} + +void +nxpwifi_process_tx_queue (struct nxpwifi_adapter *adapter) +{ +do { +if (adapter->data_sent || adapter->tx_lock_flag) +break ; +if (nxpwifi_dequeue_tx_queue (adapter)) +break ; + }while (!skb_queue_empty (&adapter->tx_data_q)); +} + +/* Packet send completion callback handler. +* +* It either frees the buffer directly or forwards it to another +* completion callback which checks conditions, updates statistics, +* wakes up stalled traffic queue if required, and then frees the buffer. +*/ +int nxpwifi_write_data_complete (struct nxpwifi_adapter *adapter, +struct sk_buff *skb,int aggr,int status) +{ +struct nxpwifi_private *priv; +struct nxpwifi_txinfo *tx_info; +struct netdev_queue *txq; +int index; + +if (!skb) +return 0 ; + + tx_info =NXPWIFI_SKB_TXCB (skb); + priv =nxpwifi_get_priv_by_id (adapter, tx_info->bss_num, + tx_info->bss_type); +if (!priv) + goto done; + +nxpwifi_set_trans_start (priv->netdev); + +if (tx_info->flags &NXPWIFI_BUF_FLAG_BRIDGED_PKT ) +atomic_dec_return (&adapter->pending_bridged_pkts); + +if (tx_info->flags &NXPWIFI_BUF_FLAG_AGGR_PKT ) + goto done; + +if (!status) { + priv->stats.tx_packets++; + priv->stats.tx_bytes += tx_info->pkt_len; +if (priv->tx_timeout_cnt) + priv->tx_timeout_cnt =0 ; + }else { + priv->stats.tx_errors++; + } + +if (aggr) +/* For skb_aggr, do not wake up tx queue */ + goto done; + +atomic_dec (&adapter->tx_pending); + + index = nxpwifi_1d_to_wmm_queue[skb->priority]; +if (atomic_dec_return (&priv->wmm_tx_pending[index]) <LOW_TX_PENDING ) { + txq =netdev_get_tx_queue (priv->netdev, index); +if (netif_tx_queue_stopped (txq)) { +netif_tx_wake_queue (txq); +nxpwifi_dbg (adapter,DATA ,"wake queue: %d\n" , index); + } + } +done: +dev_kfree_skb_any (skb); + +return 0 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_write_data_complete); + +void nxpwifi_parse_tx_status_event (struct nxpwifi_private *priv, +void *event_body) +{ +struct tx_status_event *tx_status = (void *)priv->adapter->event_body; +struct sk_buff *ack_skb; +struct nxpwifi_txinfo *tx_info; + +if (!tx_status->tx_token_id) +return ; + +spin_lock_bh (&priv->ack_status_lock); + ack_skb =idr_remove (&priv->ack_status_frames, tx_status->tx_token_id); +spin_unlock_bh (&priv->ack_status_lock); + +if (ack_skb) { + tx_info =NXPWIFI_SKB_TXCB (ack_skb); + +if (tx_info->flags &NXPWIFI_BUF_FLAG_EAPOL_TX_STATUS ) { +/* consumes ack_skb */ +skb_complete_wifi_ack (ack_skb, !tx_status->status); + }else { +/* Remove broadcast address which was added by driver */ +memmove (ack_skb->data + +sizeof (struct ieee80211_hdr_3addr ) + +NXPWIFI_MGMT_FRAME_HEADER_SIZE +sizeof (u16), + ack_skb->data + +sizeof (struct ieee80211_hdr_3addr ) + +NXPWIFI_MGMT_FRAME_HEADER_SIZE +sizeof (u16) + +ETH_ALEN , ack_skb->len - + (sizeof (struct ieee80211_hdr_3addr ) + +NXPWIFI_MGMT_FRAME_HEADER_SIZE +sizeof (u16) + +ETH_ALEN )); + ack_skb->len = ack_skb->len -ETH_ALEN ; +/* Remove driver's proprietary header including 2 bytes +* of packet length and pass actual management frame buffer +* to cfg80211. +*/ +cfg80211_mgmt_tx_status (&priv->wdev, tx_info->cookie, + ack_skb->data + +NXPWIFI_MGMT_FRAME_HEADER_SIZE + +sizeof (u16), ack_skb->len - + (NXPWIFI_MGMT_FRAME_HEADER_SIZE + +sizeof (u16)), + !tx_status->status,GFP_ATOMIC ); +dev_kfree_skb_any (ack_skb); + } + } +}
Signature · 1 line
2.34.1