drivers/net/wireless/microchip/wilc1000/netdev.h - third_party/linux - Git at Google


            
            /* SPDX-License-Identifier: GPL-2.0 */

            
            /*

            
             * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.

            
             * All rights reserved.

            
             */


            #ifndef WILC_NETDEV_H

            
            #define WILC_NETDEV_H


            #include <linux/tcp.h>

            
            #include <linux/ieee80211.h>

            
            #include <net/cfg80211.h>

            
            #include <net/ieee80211_radiotap.h>

            
            #include <linux/if_arp.h>

            
            #include <linux/gpio/consumer.h>

            
            #include <linux/rculist.h>

            
            #include <uapi/linux/if_ether.h>


            #include "hif.h"

            
            #include "wlan.h"

            
            #include "wlan_cfg.h"


            #define FLOW_CONTROL_LOWER_THRESHOLD		128

            
            #define FLOW_CONTROL_UPPER_THRESHOLD		256


            #define PMKID_FOUND				1

            
            #define NUM_STA_ASSOCIATED			8


            #define TCP_ACK_FILTER_LINK_SPEED_THRESH	54

            
            #define DEFAULT_LINK_SPEED			72


            #define TX_BACKOFF_WEIGHT_MS			1


            #define wilc_for_each_vif(w, v) \

            
            	struct wilc *_w = w; \

            
            	list_for_each_entry_srcu(v, &_w->vif_list, list, \

            
            				 srcu_read_lock_held(&_w->srcu))


            struct wilc_wfi_stats {

            
            	unsigned long rx_packets;

            
            	unsigned long tx_packets;

            
            	unsigned long rx_bytes;

            
            	unsigned long tx_bytes;

            
            	u64 rx_time;

            
            	u64 tx_time;


            };


            struct wilc_wfi_key {

            
            	u8 *key;

            
            	u8 *seq;

            
            	int key_len;

            
            	int seq_len;

            
            	u32 cipher;

            
            };


            struct sta_info {

            
            	u8 sta_associated_bss[WILC_MAX_NUM_STA][ETH_ALEN];

            
            };


            /* Parameters needed for host interface for remaining on channel */

            
            struct wilc_wfi_p2p_listen_params {

            
            	struct ieee80211_channel *listen_ch;

            
            	u32 listen_duration;

            
            	u64 listen_cookie;

            
            };


            static const u32 wilc_cipher_suites[] = {

            
            	WLAN_CIPHER_SUITE_TKIP,

            
            	WLAN_CIPHER_SUITE_CCMP,

            
            	WLAN_CIPHER_SUITE_AES_CMAC

            
            };


            #define CHAN2G(_channel, _freq, _flags) {	 \

            
            	.band             = NL80211_BAND_2GHZ, \

            
            	.center_freq      = (_freq),		 \

            
            	.hw_value         = (_channel),		 \

            
            	.flags            = (_flags),		 \

            
            	.max_antenna_gain = 0,			 \

            
            	.max_power        = 30,			 \

            
            }


            static const struct ieee80211_channel wilc_2ghz_channels[] = {

            
            	CHAN2G(1,  2412, 0),

            
            	CHAN2G(2,  2417, 0),

            
            	CHAN2G(3,  2422, 0),

            
            	CHAN2G(4,  2427, 0),

            
            	CHAN2G(5,  2432, 0),

            
            	CHAN2G(6,  2437, 0),

            
            	CHAN2G(7,  2442, 0),

            
            	CHAN2G(8,  2447, 0),

            
            	CHAN2G(9,  2452, 0),

            
            	CHAN2G(10, 2457, 0),

            
            	CHAN2G(11, 2462, 0),

            
            	CHAN2G(12, 2467, 0),

            
            	CHAN2G(13, 2472, 0),

            
            	CHAN2G(14, 2484, 0)

            
            };


            #define RATETAB_ENT(_rate, _hw_value, _flags) {	\

            
            	.bitrate  = (_rate),			\

            
            	.hw_value = (_hw_value),		\

            
            	.flags    = (_flags),			\

            
            }


            static struct ieee80211_rate wilc_bitrates[] = {

            
            	RATETAB_ENT(10,  0,  0),

            
            	RATETAB_ENT(20,  1,  0),

            
            	RATETAB_ENT(55,  2,  0),

            
            	RATETAB_ENT(110, 3,  0),

            
            	RATETAB_ENT(60,  9,  0),

            
            	RATETAB_ENT(90,  6,  0),

            
            	RATETAB_ENT(120, 7,  0),

            
            	RATETAB_ENT(180, 8,  0),

            
            	RATETAB_ENT(240, 9,  0),

            
            	RATETAB_ENT(360, 10, 0),

            
            	RATETAB_ENT(480, 11, 0),

            
            	RATETAB_ENT(540, 12, 0)

            
            };


            struct wilc_priv {

            
            	struct wireless_dev wdev;

            
            	struct cfg80211_scan_request *scan_req;


            	struct wilc_wfi_p2p_listen_params remain_on_ch_params;

            
            	u64 tx_cookie;


            	bool cfg_scanning;


            	u8 associated_bss[ETH_ALEN];

            
            	struct sta_info assoc_stainfo;

            
            	struct sk_buff *skb;

            
            	struct net_device *dev;

            
            	struct host_if_drv *hif_drv;

            
            	struct wilc_pmkid_attr pmkid_list;


            	/* The real interface that the monitor is on */

            
            	struct net_device *real_ndev;

            
            	struct wilc_wfi_key *wilc_gtk[WILC_MAX_NUM_STA];

            
            	struct wilc_wfi_key *wilc_ptk[WILC_MAX_NUM_STA];

            
            	struct wilc_wfi_key *wilc_igtk[2];

            
            	u8 wilc_groupkey;


            	/* mutexes */

            
            	struct mutex scan_req_lock;

            
            	bool p2p_listen_state;

            
            	int scanned_cnt;


            	u64 inc_roc_cookie;

            
            };


            #define MAX_TCP_SESSION                25

            
            #define MAX_PENDING_ACKS               256


            struct ack_session_info {

            
            	u32 seq_num;

            
            	u32 bigger_ack_num;

            
            	u16 src_port;

            
            	u16 dst_port;

            
            	u16 status;

            
            };


            struct pending_acks {

            
            	u32 ack_num;

            
            	u32 session_index;

            
            	struct txq_entry_t  *txqe;

            
            };


            struct tcp_ack_filter {

            
            	struct ack_session_info ack_session_info[2 * MAX_TCP_SESSION];

            
            	struct pending_acks pending_acks[MAX_PENDING_ACKS];

            
            	u32 pending_base;

            
            	u32 tcp_session;

            
            	u32 pending_acks_idx;

            
            	bool enabled;

            
            };


            struct wilc_vif {

            
            	u8 idx;

            
            	u8 iftype;

            
            	int monitor_flag;

            
            	int mac_opened;

            
            	u32 mgmt_reg_stypes;

            
            	struct net_device_stats netstats;

            
            	struct wilc *wilc;

            
            	u8 bssid[ETH_ALEN];

            
            	struct host_if_drv *hif_drv;

            
            	struct net_device *ndev;

            
            	struct timer_list during_ip_timer;

            
            	struct timer_list periodic_rssi;

            
            	struct rf_info periodic_stat;

            
            	struct tcp_ack_filter ack_filter;

            
            	bool connecting;

            
            	struct wilc_priv priv;

            
            	struct list_head list;

            
            	struct cfg80211_bss *bss;

            
            	struct cfg80211_external_auth_params auth;

            
            };


            struct wilc_tx_queue_status {

            
            	u8 buffer[AC_BUFFER_SIZE];

            
            	u16 end_index;

            
            	u16 cnt[NQUEUES];

            
            	u16 sum;

            
            	bool initialized;

            
            };


            struct wilc {

            
            	struct wiphy *wiphy;

            
            	const struct wilc_hif_func *hif_func;

            
            	int io_type;

            
            	s8 mac_status;

            
            	struct clk *rtc_clk;

            
            	bool initialized;

            
            	u32 chipid;

            
            	bool power_save_mode;

            
            	int dev_irq_num;

            
            	int close;

            
            	u8 vif_num;

            
            	struct list_head vif_list;


            	/* protect vif list */

            
            	struct mutex vif_mutex;

            
            	/* Sleepable RCU struct to manipulate vif list. Sleepable version is

            
            	 * needed over the classic RCU version because the driver's current

            
            	 * design involves some sleeping code while manipulating a vif

            
            	 * retrieved from vif list (so in a SRCU critical section), like:

            
            	 * - sending commands to the chip, using info from retrieved vif

            
            	 * - registering a new monitoring net device

            
            	 */

            
            	struct srcu_struct srcu;

            
            	u8 open_ifcs;


            	/* protect head of transmit queue */

            
            	struct mutex txq_add_to_head_cs;


            	/* protect txq_entry_t transmit queue */

            
            	spinlock_t txq_spinlock;


            	/* protect rxq_entry_t receiver queue */

            
            	struct mutex rxq_cs;


            	/* lock to protect hif access */

            
            	struct mutex hif_cs;


            	struct completion cfg_event;

            
            	struct completion sync_event;

            
            	struct completion txq_event;

            
            	struct completion txq_thread_started;


            	struct task_struct *txq_thread;


            	int quit;


            	/* lock to protect issue of wid command to firmware */

            
            	struct mutex cfg_cmd_lock;

            
            	struct wilc_cfg_frame cfg_frame;

            
            	u32 cfg_frame_offset;

            
            	u8 cfg_seq_no;


            	u8 *rx_buffer;

            
            	u32 rx_buffer_offset;

            
            	u8 *tx_buffer;

            
            	u32 *vmm_table;


            	struct txq_handle txq[NQUEUES];

            
            	int txq_entries;


            	struct wilc_tx_queue_status tx_q_limit;

            
            	struct rxq_entry_t rxq_head;


            	const struct firmware *firmware;


            	struct device *dev;


            	struct workqueue_struct *hif_workqueue;

            
            	struct wilc_cfg cfg;

            
            	void *bus_data;

            
            	struct net_device *monitor_dev;


            	/* deinit lock */

            
            	struct mutex deinit_lock;

            
            	u8 sta_ch;

            
            	u8 op_ch;

            
            	struct ieee80211_channel channels[ARRAY_SIZE(wilc_2ghz_channels)];

            
            	struct ieee80211_rate bitrates[ARRAY_SIZE(wilc_bitrates)];

            
            	struct ieee80211_supported_band band;

            
            	u32 cipher_suites[ARRAY_SIZE(wilc_cipher_suites)];

            
            	u8 nv_mac_address[ETH_ALEN];

            
            };


            struct wilc_wfi_mon_priv {

            
            	struct net_device *real_ndev;

            
            };


            void wilc_frmw_to_host(struct wilc *wilc, u8 *buff, u32 size, u32 pkt_offset);

            
            void wilc_mac_indicate(struct wilc *wilc);

            
            void wilc_netdev_cleanup(struct wilc *wilc);

            
            void wilc_wfi_mgmt_rx(struct wilc *wilc, u8 *buff, u32 size, bool is_auth);

            
            void wilc_wlan_set_bssid(struct net_device *wilc_netdev, const u8 *bssid,

            
            			 u8 mode);

            
            struct wilc_vif *wilc_netdev_ifc_init(struct wilc *wl, const char *name,

            
            				      int vif_type, enum nl80211_iftype type,

            
            				      bool rtnl_locked);

            
            #endif
	/* SPDX-License-Identifier: GPL-2.0 */
	/*
	* Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
	* All rights reserved.
	*/

	#ifndef WILC_NETDEV_H
	#define WILC_NETDEV_H

	#include <linux/tcp.h>
	#include <linux/ieee80211.h>
	#include <net/cfg80211.h>
	#include <net/ieee80211_radiotap.h>
	#include <linux/if_arp.h>
	#include <linux/gpio/consumer.h>
	#include <linux/rculist.h>
	#include <uapi/linux/if_ether.h>

	#include "hif.h"
	#include "wlan.h"
	#include "wlan_cfg.h"

	#define FLOW_CONTROL_LOWER_THRESHOLD 128
	#define FLOW_CONTROL_UPPER_THRESHOLD 256

	#define PMKID_FOUND 1
	#define NUM_STA_ASSOCIATED 8

	#define TCP_ACK_FILTER_LINK_SPEED_THRESH 54
	#define DEFAULT_LINK_SPEED 72

	#define TX_BACKOFF_WEIGHT_MS 1

	#define wilc_for_each_vif(w, v) \
	struct wilc *_w = w; \
	list_for_each_entry_srcu(v, &_w->vif_list, list, \
	srcu_read_lock_held(&_w->srcu))

	struct wilc_wfi_stats {
	unsigned long rx_packets;
	unsigned long tx_packets;
	unsigned long rx_bytes;
	unsigned long tx_bytes;
	u64 rx_time;
	u64 tx_time;

	};

	struct wilc_wfi_key {
	u8 *key;
	u8 *seq;
	int key_len;
	int seq_len;
	u32 cipher;
	};

	struct sta_info {
	u8 sta_associated_bss[WILC_MAX_NUM_STA][ETH_ALEN];
	};

	/* Parameters needed for host interface for remaining on channel */
	struct wilc_wfi_p2p_listen_params {
	struct ieee80211_channel *listen_ch;
	u32 listen_duration;
	u64 listen_cookie;
	};

	static const u32 wilc_cipher_suites[] = {
	WLAN_CIPHER_SUITE_TKIP,
	WLAN_CIPHER_SUITE_CCMP,
	WLAN_CIPHER_SUITE_AES_CMAC
	};

	#define CHAN2G(_channel, _freq, _flags) { \
	.band = NL80211_BAND_2GHZ, \
	.center_freq = (_freq), \
	.hw_value = (_channel), \
	.flags = (_flags), \
	.max_antenna_gain = 0, \
	.max_power = 30, \
	}

	static const struct ieee80211_channel wilc_2ghz_channels[] = {
	CHAN2G(1, 2412, 0),
	CHAN2G(2, 2417, 0),
	CHAN2G(3, 2422, 0),
	CHAN2G(4, 2427, 0),
	CHAN2G(5, 2432, 0),
	CHAN2G(6, 2437, 0),
	CHAN2G(7, 2442, 0),
	CHAN2G(8, 2447, 0),
	CHAN2G(9, 2452, 0),
	CHAN2G(10, 2457, 0),
	CHAN2G(11, 2462, 0),
	CHAN2G(12, 2467, 0),
	CHAN2G(13, 2472, 0),
	CHAN2G(14, 2484, 0)
	};

	#define RATETAB_ENT(_rate, _hw_value, _flags) { \
	.bitrate = (_rate), \
	.hw_value = (_hw_value), \
	.flags = (_flags), \
	}

	static struct ieee80211_rate wilc_bitrates[] = {
	RATETAB_ENT(10, 0, 0),
	RATETAB_ENT(20, 1, 0),
	RATETAB_ENT(55, 2, 0),
	RATETAB_ENT(110, 3, 0),
	RATETAB_ENT(60, 9, 0),
	RATETAB_ENT(90, 6, 0),
	RATETAB_ENT(120, 7, 0),
	RATETAB_ENT(180, 8, 0),
	RATETAB_ENT(240, 9, 0),
	RATETAB_ENT(360, 10, 0),
	RATETAB_ENT(480, 11, 0),
	RATETAB_ENT(540, 12, 0)
	};

	struct wilc_priv {
	struct wireless_dev wdev;
	struct cfg80211_scan_request *scan_req;

	struct wilc_wfi_p2p_listen_params remain_on_ch_params;
	u64 tx_cookie;

	bool cfg_scanning;

	u8 associated_bss[ETH_ALEN];
	struct sta_info assoc_stainfo;
	struct sk_buff *skb;
	struct net_device *dev;
	struct host_if_drv *hif_drv;
	struct wilc_pmkid_attr pmkid_list;

	/* The real interface that the monitor is on */
	struct net_device *real_ndev;
	struct wilc_wfi_key *wilc_gtk[WILC_MAX_NUM_STA];
	struct wilc_wfi_key *wilc_ptk[WILC_MAX_NUM_STA];
	struct wilc_wfi_key *wilc_igtk[2];
	u8 wilc_groupkey;

	/* mutexes */
	struct mutex scan_req_lock;
	bool p2p_listen_state;
	int scanned_cnt;

	u64 inc_roc_cookie;
	};

	#define MAX_TCP_SESSION 25
	#define MAX_PENDING_ACKS 256

	struct ack_session_info {
	u32 seq_num;
	u32 bigger_ack_num;
	u16 src_port;
	u16 dst_port;
	u16 status;
	};

	struct pending_acks {
	u32 ack_num;
	u32 session_index;
	struct txq_entry_t *txqe;
	};

	struct tcp_ack_filter {
	struct ack_session_info ack_session_info[2 * MAX_TCP_SESSION];
	struct pending_acks pending_acks[MAX_PENDING_ACKS];
	u32 pending_base;
	u32 tcp_session;
	u32 pending_acks_idx;
	bool enabled;
	};

	struct wilc_vif {
	u8 idx;
	u8 iftype;
	int monitor_flag;
	int mac_opened;
	u32 mgmt_reg_stypes;
	struct net_device_stats netstats;
	struct wilc *wilc;
	u8 bssid[ETH_ALEN];
	struct host_if_drv *hif_drv;
	struct net_device *ndev;
	struct timer_list during_ip_timer;
	struct timer_list periodic_rssi;
	struct rf_info periodic_stat;
	struct tcp_ack_filter ack_filter;
	bool connecting;
	struct wilc_priv priv;
	struct list_head list;
	struct cfg80211_bss *bss;
	struct cfg80211_external_auth_params auth;
	};

	struct wilc_tx_queue_status {
	u8 buffer[AC_BUFFER_SIZE];
	u16 end_index;
	u16 cnt[NQUEUES];
	u16 sum;
	bool initialized;
	};

	struct wilc {
	struct wiphy *wiphy;
	const struct wilc_hif_func *hif_func;
	int io_type;
	s8 mac_status;
	struct clk *rtc_clk;
	bool initialized;
	u32 chipid;
	bool power_save_mode;
	int dev_irq_num;
	int close;
	u8 vif_num;
	struct list_head vif_list;

	/* protect vif list */
	struct mutex vif_mutex;
	/* Sleepable RCU struct to manipulate vif list. Sleepable version is
	* needed over the classic RCU version because the driver's current
	* design involves some sleeping code while manipulating a vif
	* retrieved from vif list (so in a SRCU critical section), like:
	* - sending commands to the chip, using info from retrieved vif
	* - registering a new monitoring net device
	*/
	struct srcu_struct srcu;
	u8 open_ifcs;

	/* protect head of transmit queue */
	struct mutex txq_add_to_head_cs;

	/* protect txq_entry_t transmit queue */
	spinlock_t txq_spinlock;

	/* protect rxq_entry_t receiver queue */
	struct mutex rxq_cs;

	/* lock to protect hif access */
	struct mutex hif_cs;

	struct completion cfg_event;
	struct completion sync_event;
	struct completion txq_event;
	struct completion txq_thread_started;

	struct task_struct *txq_thread;

	int quit;

	/* lock to protect issue of wid command to firmware */
	struct mutex cfg_cmd_lock;
	struct wilc_cfg_frame cfg_frame;
	u32 cfg_frame_offset;
	u8 cfg_seq_no;

	u8 *rx_buffer;
	u32 rx_buffer_offset;
	u8 *tx_buffer;
	u32 *vmm_table;

	struct txq_handle txq[NQUEUES];
	int txq_entries;

	struct wilc_tx_queue_status tx_q_limit;
	struct rxq_entry_t rxq_head;

	const struct firmware *firmware;

	struct device *dev;

	struct workqueue_struct *hif_workqueue;
	struct wilc_cfg cfg;
	void *bus_data;
	struct net_device *monitor_dev;

	/* deinit lock */
	struct mutex deinit_lock;
	u8 sta_ch;
	u8 op_ch;
	struct ieee80211_channel channels[ARRAY_SIZE(wilc_2ghz_channels)];
	struct ieee80211_rate bitrates[ARRAY_SIZE(wilc_bitrates)];
	struct ieee80211_supported_band band;
	u32 cipher_suites[ARRAY_SIZE(wilc_cipher_suites)];
	u8 nv_mac_address[ETH_ALEN];
	};

	struct wilc_wfi_mon_priv {
	struct net_device *real_ndev;
	};

	void wilc_frmw_to_host(struct wilc wilc, u8 buff, u32 size, u32 pkt_offset);
	void wilc_mac_indicate(struct wilc *wilc);
	void wilc_netdev_cleanup(struct wilc *wilc);
	void wilc_wfi_mgmt_rx(struct wilc wilc, u8 buff, u32 size, bool is_auth);
	void wilc_wlan_set_bssid(struct net_device wilc_netdev, const u8 bssid,
	u8 mode);
	struct wilc_vif wilc_netdev_ifc_init(struct wilc wl, const char *name,
	int vif_type, enum nl80211_iftype type,
	bool rtnl_locked);
	#endif