[deliverable/linux.git] / drivers / net / wireless / ti / wlcore / wlcore_i.h

/*
 * This file is part of wl1271
 *
 * Copyright (C) 1998-2009 Texas Instruments. All rights reserved.
 * Copyright (C) 2008-2009 Nokia Corporation
 *
 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#ifndef __WLCORE_I_H__
#define __WLCORE_I_H__

#include <linux/mutex.h>
#include <linux/completion.h>
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/bitops.h>
#include <net/mac80211.h>

#include "conf.h"
#include "ini.h"

/*
 * wl127x and wl128x are using the same NVS file name. However, the
 * ini parameters between them are different.  The driver validates
 * the correct NVS size in wl1271_boot_upload_nvs().
 */
#define WL12XX_NVS_NAME "ti-connectivity/wl1271-nvs.bin"

#define WL1271_TX_SECURITY_LO16(s) ((u16)((s) & 0xffff))
#define WL1271_TX_SECURITY_HI32(s) ((u32)(((s) >> 16) & 0xffffffff))
#define WL1271_TX_SQN_POST_RECOVERY_PADDING 0xff

#define WL1271_CIPHER_SUITE_GEM 0x00147201

#define WL1271_BUSY_WORD_CNT 1
#define WL1271_BUSY_WORD_LEN (WL1271_BUSY_WORD_CNT * sizeof(u32))

#define WL1271_ELP_HW_STATE_ASLEEP 0
#define WL1271_ELP_HW_STATE_IRQ    1

#define WL1271_DEFAULT_BEACON_INT  100
#define WL1271_DEFAULT_DTIM_PERIOD 1

#define WL12XX_MAX_ROLES           4
#define WL12XX_MAX_LINKS           12
#define WL12XX_INVALID_ROLE_ID     0xff
#define WL12XX_INVALID_LINK_ID     0xff

/* the driver supports the 2.4Ghz and 5Ghz bands */
#define WLCORE_NUM_BANDS           2

#define WL12XX_MAX_RATE_POLICIES 16
#define WLCORE_MAX_KLV_TEMPLATES 4

/* Defined by FW as 0. Will not be freed or allocated. */
#define WL12XX_SYSTEM_HLID         0

/*
 * When in AP-mode, we allow (at least) this number of packets
 * to be transmitted to FW for a STA in PS-mode. Only when packets are
 * present in the FW buffers it will wake the sleeping STA. We want to put
 * enough packets for the driver to transmit all of its buffered data before
 * the STA goes to sleep again. But we don't want to take too much memory
 * as it might hurt the throughput of active STAs.
 */
#define WL1271_PS_STA_MAX_PACKETS  2

#define WL1271_AP_BSS_INDEX        0
#define WL1271_AP_DEF_BEACON_EXP   20

enum wlcore_state {
	WLCORE_STATE_OFF,
	WLCORE_STATE_RESTARTING,
	WLCORE_STATE_ON,
};

enum wl12xx_fw_type {
	WL12XX_FW_TYPE_NONE,
	WL12XX_FW_TYPE_NORMAL,
	WL12XX_FW_TYPE_MULTI,
	WL12XX_FW_TYPE_PLT,
};

struct wl1271;

enum {
	FW_VER_CHIP,
	FW_VER_IF_TYPE,
	FW_VER_MAJOR,
	FW_VER_SUBTYPE,
	FW_VER_MINOR,

	NUM_FW_VER
};

struct wl1271_chip {
	u32 id;
	char fw_ver_str[ETHTOOL_BUSINFO_LEN];
	unsigned int fw_ver[NUM_FW_VER];
	char phy_fw_ver_str[ETHTOOL_BUSINFO_LEN];
};

#define NUM_TX_QUEUES              4

#define AP_MAX_STATIONS            8

struct wl_fw_packet_counters {
	/* Cumulative counter of released packets per AC */
	u8 tx_released_pkts[NUM_TX_QUEUES];

	/* Cumulative counter of freed packets per HLID */
	u8 tx_lnk_free_pkts[WL12XX_MAX_LINKS];

	/* Cumulative counter of released Voice memory blocks */
	u8 tx_voice_released_blks;

	/* Tx rate of the last transmitted packet */
	u8 tx_last_rate;

	u8 padding[2];
} __packed;

/* FW status registers */
struct wl_fw_status_1 {
	__le32 intr;
	u8  fw_rx_counter;
	u8  drv_rx_counter;
	u8  reserved;
	u8  tx_results_counter;
	__le32 rx_pkt_descs[0];
} __packed;

/*
 * Each HW arch has a different number of Rx descriptors.
 * The length of the status depends on it, since it holds an array
 * of descriptors.
 */
#define WLCORE_FW_STATUS_1_LEN(num_rx_desc) \
		(sizeof(struct wl_fw_status_1) + \
		(sizeof(((struct wl_fw_status_1 *)0)->rx_pkt_descs[0])) * \
		num_rx_desc)

struct wl_fw_status_2 {
	__le32 fw_localtime;

	/*
	 * A bitmap (where each bit represents a single HLID)
	 * to indicate if the station is in PS mode.
	 */
	__le32 link_ps_bitmap;

	/*
	 * A bitmap (where each bit represents a single HLID) to indicate
	 * if the station is in Fast mode
	 */
	__le32 link_fast_bitmap;

	/* Cumulative counter of total released mem blocks since FW-reset */
	__le32 total_released_blks;

	/* Size (in Memory Blocks) of TX pool */
	__le32 tx_total;

	struct wl_fw_packet_counters counters;

	__le32 log_start_addr;

	/* Private status to be used by the lower drivers */
	u8 priv[0];
} __packed;

#define WL1271_MAX_CHANNELS 64
struct wl1271_scan {
	struct cfg80211_scan_request *req;
	unsigned long scanned_ch[BITS_TO_LONGS(WL1271_MAX_CHANNELS)];
	bool failed;
	u8 state;
	u8 ssid[IEEE80211_MAX_SSID_LEN+1];
	size_t ssid_len;
};

struct wl1271_if_operations {
	int __must_check (*read)(struct device *child, int addr, void *buf,
				 size_t len, bool fixed);
	int __must_check (*write)(struct device *child, int addr, void *buf,
				  size_t len, bool fixed);
	void (*reset)(struct device *child);
	void (*init)(struct device *child);
	int (*power)(struct device *child, bool enable);
	void (*set_block_size) (struct device *child, unsigned int blksz);
};

struct wlcore_platdev_data {
	struct wl12xx_platform_data *pdata;
	struct wl1271_if_operations *if_ops;
};

#define MAX_NUM_KEYS 14
#define MAX_KEY_SIZE 32

struct wl1271_ap_key {
	u8 id;
	u8 key_type;
	u8 key_size;
	u8 key[MAX_KEY_SIZE];
	u8 hlid;
	u32 tx_seq_32;
	u16 tx_seq_16;
};

enum wl12xx_flags {
	WL1271_FLAG_GPIO_POWER,
	WL1271_FLAG_TX_QUEUE_STOPPED,
	WL1271_FLAG_TX_PENDING,
	WL1271_FLAG_IN_ELP,
	WL1271_FLAG_ELP_REQUESTED,
	WL1271_FLAG_IRQ_RUNNING,
	WL1271_FLAG_FW_TX_BUSY,
	WL1271_FLAG_DUMMY_PACKET_PENDING,
	WL1271_FLAG_SUSPENDED,
	WL1271_FLAG_PENDING_WORK,
	WL1271_FLAG_SOFT_GEMINI,
	WL1271_FLAG_RECOVERY_IN_PROGRESS,
	WL1271_FLAG_VIF_CHANGE_IN_PROGRESS,
	WL1271_FLAG_INTENDED_FW_RECOVERY,
	WL1271_FLAG_IO_FAILED,
};

enum wl12xx_vif_flags {
	WLVIF_FLAG_INITIALIZED,
	WLVIF_FLAG_STA_ASSOCIATED,
	WLVIF_FLAG_STA_AUTHORIZED,
	WLVIF_FLAG_IBSS_JOINED,
	WLVIF_FLAG_AP_STARTED,
	WLVIF_FLAG_IN_PS,
	WLVIF_FLAG_STA_STATE_SENT,
	WLVIF_FLAG_RX_STREAMING_STARTED,
	WLVIF_FLAG_PSPOLL_FAILURE,
	WLVIF_FLAG_CS_PROGRESS,
	WLVIF_FLAG_AP_PROBE_RESP_SET,
	WLVIF_FLAG_IN_USE,
};

struct wl12xx_vif;

struct wl1271_link {
	/* AP-mode - TX queue per AC in link */
	struct sk_buff_head tx_queue[NUM_TX_QUEUES];

	/* accounting for allocated / freed packets in FW */
	u8 allocated_pkts;
	u8 prev_freed_pkts;

	u8 addr[ETH_ALEN];

	/* bitmap of TIDs where RX BA sessions are active for this link */
	u8 ba_bitmap;

	/* The wlvif this link belongs to. Might be null for global links */
	struct wl12xx_vif *wlvif;

	/*
	 * total freed FW packets on the link - used for tracking the
	 * AES/TKIP PN across recoveries. Re-initialized each time
	 * from the wl1271_station structure.
	 */
	u64 total_freed_pkts;
};

#define WL1271_MAX_RX_FILTERS 5
#define WL1271_RX_FILTER_MAX_FIELDS 8

#define WL1271_RX_FILTER_ETH_HEADER_SIZE 14
#define WL1271_RX_FILTER_MAX_FIELDS_SIZE 95
#define RX_FILTER_FIELD_OVERHEAD				\
	(sizeof(struct wl12xx_rx_filter_field) - sizeof(u8 *))
#define WL1271_RX_FILTER_MAX_PATTERN_SIZE			\
	(WL1271_RX_FILTER_MAX_FIELDS_SIZE - RX_FILTER_FIELD_OVERHEAD)

#define WL1271_RX_FILTER_FLAG_MASK                BIT(0)
#define WL1271_RX_FILTER_FLAG_IP_HEADER           0
#define WL1271_RX_FILTER_FLAG_ETHERNET_HEADER     BIT(1)

enum rx_filter_action {
	FILTER_DROP = 0,
	FILTER_SIGNAL = 1,
	FILTER_FW_HANDLE = 2
};

enum plt_mode {
	PLT_OFF = 0,
	PLT_ON = 1,
	PLT_FEM_DETECT = 2,
};

struct wl12xx_rx_filter_field {
	__le16 offset;
	u8 len;
	u8 flags;
	u8 *pattern;
} __packed;

struct wl12xx_rx_filter {
	u8 action;
	int num_fields;
	struct wl12xx_rx_filter_field fields[WL1271_RX_FILTER_MAX_FIELDS];
};

struct wl1271_station {
	u8 hlid;
	bool in_connection;
};

struct wl12xx_vif {
	struct wl1271 *wl;
	struct list_head list;
	unsigned long flags;
	u8 bss_type;
	u8 p2p; /* we are using p2p role */
	u8 role_id;

	/* sta/ibss specific */
	u8 dev_role_id;
	u8 dev_hlid;

	union {
		struct {
			u8 hlid;

			u8 basic_rate_idx;
			u8 ap_rate_idx;
			u8 p2p_rate_idx;

			u8 klv_template_id;

			bool qos;
			/* channel type we started the STA role with */
			enum nl80211_channel_type role_chan_type;
		} sta;
		struct {
			u8 global_hlid;
			u8 bcast_hlid;

			/* HLIDs bitmap of associated stations */
			unsigned long sta_hlid_map[BITS_TO_LONGS(
							WL12XX_MAX_LINKS)];

			/* recoreded keys - set here before AP startup */
			struct wl1271_ap_key *recorded_keys[MAX_NUM_KEYS];

			u8 mgmt_rate_idx;
			u8 bcast_rate_idx;
			u8 ucast_rate_idx[CONF_TX_MAX_AC_COUNT];
		} ap;
	};

	/* the hlid of the last transmitted skb */
	int last_tx_hlid;

	/* counters of packets per AC, across all links in the vif */
	int tx_queue_count[NUM_TX_QUEUES];

	unsigned long links_map[BITS_TO_LONGS(WL12XX_MAX_LINKS)];

	u8 ssid[IEEE80211_MAX_SSID_LEN + 1];
	u8 ssid_len;

	/* The current band */
	enum ieee80211_band band;
	int channel;
	enum nl80211_channel_type channel_type;

	u32 bitrate_masks[WLCORE_NUM_BANDS];
	u32 basic_rate_set;

	/*
	 * currently configured rate set:
	 *	bits  0-15 - 802.11abg rates
	 *	bits 16-23 - 802.11n   MCS index mask
	 * support only 1 stream, thus only 8 bits for the MCS rates (0-7).
	 */
	u32 basic_rate;
	u32 rate_set;

	/* probe-req template for the current AP */
	struct sk_buff *probereq;

	/* Beaconing interval (needed for ad-hoc) */
	u32 beacon_int;

	/* Default key (for WEP) */
	u32 default_key;

	/* Our association ID */
	u16 aid;

	/* retry counter for PSM entries */
	u8 psm_entry_retry;

	/* in dBm */
	int power_level;

	int rssi_thold;
	int last_rssi_event;

	/* save the current encryption type for auto-arp config */
	u8 encryption_type;
	__be32 ip_addr;

	/* RX BA constraint value */
	bool ba_support;
	bool ba_allowed;

	bool wmm_enabled;

	/* Rx Streaming */
	struct work_struct rx_streaming_enable_work;
	struct work_struct rx_streaming_disable_work;
	struct timer_list rx_streaming_timer;

	struct delayed_work channel_switch_work;
	struct delayed_work connection_loss_work;

	/* number of in connection stations */
	int inconn_count;

	/*
	 * This vif's queues are mapped to mac80211 HW queues as:
	 * VO - hw_queue_base
	 * VI - hw_queue_base + 1
	 * BE - hw_queue_base + 2
	 * BK - hw_queue_base + 3
	 */
	int hw_queue_base;

	/*
	 * This struct must be last!
	 * data that has to be saved acrossed reconfigs (e.g. recovery)
	 * should be declared in this struct.
	 */
	struct {
		u8 persistent[0];

		/*
		 * total freed FW packets on the link - used for
		 * storing the AES/TKIP PN during recovery, as this
		 * structure is not zeroed out.
		 */
		u64 total_freed_pkts;
	};
};

static inline struct wl12xx_vif *wl12xx_vif_to_data(struct ieee80211_vif *vif)
{
	WARN_ON(!vif);
	return (struct wl12xx_vif *)vif->drv_priv;
}

static inline
struct ieee80211_vif *wl12xx_wlvif_to_vif(struct wl12xx_vif *wlvif)
{
	return container_of((void *)wlvif, struct ieee80211_vif, drv_priv);
}

#define wl12xx_for_each_wlvif(wl, wlvif) \
		list_for_each_entry(wlvif, &wl->wlvif_list, list)

#define wl12xx_for_each_wlvif_continue(wl, wlvif) \
		list_for_each_entry_continue(wlvif, &wl->wlvif_list, list)

#define wl12xx_for_each_wlvif_bss_type(wl, wlvif, _bss_type)	\
		wl12xx_for_each_wlvif(wl, wlvif)		\
			if (wlvif->bss_type == _bss_type)

#define wl12xx_for_each_wlvif_sta(wl, wlvif)	\
		wl12xx_for_each_wlvif_bss_type(wl, wlvif, BSS_TYPE_STA_BSS)

#define wl12xx_for_each_wlvif_ap(wl, wlvif)	\
		wl12xx_for_each_wlvif_bss_type(wl, wlvif, BSS_TYPE_AP_BSS)

int wl1271_plt_start(struct wl1271 *wl, const enum plt_mode plt_mode);
int wl1271_plt_stop(struct wl1271 *wl);
int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif);
void wl12xx_queue_recovery_work(struct wl1271 *wl);
size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen);
int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
					u16 offset, u8 flags,
					u8 *pattern, u8 len);
void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter);
struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void);
int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter);
void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,
				     u8 *buf);

#define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */

#define SESSION_COUNTER_MAX 6 /* maximum value for the session counter */
#define SESSION_COUNTER_INVALID 7 /* used with dummy_packet */

#define WL1271_DEFAULT_POWER_LEVEL 0

#define WL1271_TX_QUEUE_LOW_WATERMARK  32
#define WL1271_TX_QUEUE_HIGH_WATERMARK 256

#define WL1271_DEFERRED_QUEUE_LIMIT    64

/* WL1271 needs a 200ms sleep after power on, and a 20ms sleep before power
   on in case is has been shut down shortly before */
#define WL1271_PRE_POWER_ON_SLEEP 20 /* in milliseconds */
#define WL1271_POWER_ON_SLEEP 200 /* in milliseconds */

/* Macros to handle wl1271.sta_rate_set */
#define HW_BG_RATES_MASK	0xffff
#define HW_HT_RATES_OFFSET	16
#define HW_MIMO_RATES_OFFSET	24

#define WL12XX_HW_BLOCK_SIZE	256

#endif /* __WLCORE_I_H__ */
Commit	Line	Data
f5fc0f86 LC	1	/*
	2	* This file is part of wl1271
	3	*
	4	* Copyright (C) 1998-2009 Texas Instruments. All rights reserved.
	5	* Copyright (C) 2008-2009 Nokia Corporation
	6	*
	7	* Contact: Luciano Coelho <luciano.coelho@nokia.com>
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License
	11	* version 2 as published by the Free Software Foundation.
	12	*
	13	* This program is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	21	* 02110-1301 USA
	22	*
	23	*/
	24
8388569a LC	25	#ifndef __WLCORE_I_H__
8388569a LC	26	#define __WLCORE_I_H__
f5fc0f86 LC	27
	28	#include <linux/mutex.h>
	29	#include <linux/completion.h>
	30	#include <linux/spinlock.h>
	31	#include <linux/list.h>
	32	#include <linux/bitops.h>
	33	#include <net/mac80211.h>
	34
00d20100 SL	35	#include "conf.h"
00d20100 SL	36	#include "ini.h"
2b60100b	37
5aa42346 SL	38	/*
	39	* wl127x and wl128x are using the same NVS file name. However, the
	40	* ini parameters between them are different. The driver validates
	41	* the correct NVS size in wl1271_boot_upload_nvs().
	42	*/
	43	#define WL12XX_NVS_NAME "ti-connectivity/wl1271-nvs.bin"
152ee6e0	44
04e36fc5 JO	45	#define WL1271_TX_SECURITY_LO16(s) ((u16)((s) & 0xffff))
04e36fc5 JO	46	#define WL1271_TX_SECURITY_HI32(s) ((u32)(((s) >> 16) & 0xffffffff))
b992c682	47	#define WL1271_TX_SQN_POST_RECOVERY_PADDING 0xff
04e36fc5	48
7a55724e JO	49	#define WL1271_CIPHER_SUITE_GEM 0x00147201
7a55724e JO	50
259da430	51	#define WL1271_BUSY_WORD_CNT 1
545f1da8	52	#define WL1271_BUSY_WORD_LEN (WL1271_BUSY_WORD_CNT * sizeof(u32))
f5fc0f86 LC	53
	54	#define WL1271_ELP_HW_STATE_ASLEEP 0
	55	#define WL1271_ELP_HW_STATE_IRQ 1
	56
d94cd297 JO	57	#define WL1271_DEFAULT_BEACON_INT 100
	58	#define WL1271_DEFAULT_DTIM_PERIOD 1
	59
c690ec81	60	#define WL12XX_MAX_ROLES 4
f80c2d12	61	#define WL12XX_MAX_LINKS 12
7f097988 EP	62	#define WL12XX_INVALID_ROLE_ID 0xff
7f097988 EP	63	#define WL12XX_INVALID_LINK_ID 0xff
e51ae9be	64
091185d6 AN	65	/* the driver supports the 2.4Ghz and 5Ghz bands */
	66	#define WLCORE_NUM_BANDS 2
	67
e5a359f8	68	#define WL12XX_MAX_RATE_POLICIES 16
001e39a8	69	#define WLCORE_MAX_KLV_TEMPLATES 4
e5a359f8	70
e51ae9be	71	/* Defined by FW as 0. Will not be freed or allocated. */
f4df1bd5	72	#define WL12XX_SYSTEM_HLID 0
e51ae9be	73
b622d992	74	/*
9b17f1b3	75	* When in AP-mode, we allow (at least) this number of packets
b622d992 AN	76	* to be transmitted to FW for a STA in PS-mode. Only when packets are
	77	* present in the FW buffers it will wake the sleeping STA. We want to put
	78	* enough packets for the driver to transmit all of its buffered data before
9b17f1b3	79	* the STA goes to sleep again. But we don't want to take too much memory
b622d992	80	* as it might hurt the throughput of active STAs.
b622d992	81	*/
9b17f1b3	82	#define WL1271_PS_STA_MAX_PACKETS 2
b622d992	83
98bdaabb	84	#define WL1271_AP_BSS_INDEX 0
98bdaabb AN	85	#define WL1271_AP_DEF_BEACON_EXP 20
98bdaabb AN	86
4cc53383 IY	87	enum wlcore_state {
	88	WLCORE_STATE_OFF,
	89	WLCORE_STATE_RESTARTING,
	90	WLCORE_STATE_ON,
3fcdab70 EP	91	};
	92
	93	enum wl12xx_fw_type {
	94	WL12XX_FW_TYPE_NONE,
	95	WL12XX_FW_TYPE_NORMAL,
4549d09c	96	WL12XX_FW_TYPE_MULTI,
3fcdab70	97	WL12XX_FW_TYPE_PLT,
f5fc0f86 LC	98	};
f5fc0f86 LC	99
f5fc0f86 LC	100	struct wl1271;
f5fc0f86 LC	101
e7ddf549 LC	102	enum {
	103	FW_VER_CHIP,
	104	FW_VER_IF_TYPE,
	105	FW_VER_MAJOR,
	106	FW_VER_SUBTYPE,
	107	FW_VER_MINOR,
	108
	109	NUM_FW_VER
	110	};
	111
f5fc0f86 LC	112	struct wl1271_chip {
f5fc0f86 LC	113	u32 id;
4b7fac77	114	char fw_ver_str[ETHTOOL_BUSINFO_LEN];
e7ddf549	115	unsigned int fw_ver[NUM_FW_VER];
1defbeb0	116	char phy_fw_ver_str[ETHTOOL_BUSINFO_LEN];
f5fc0f86 LC	117	};
f5fc0f86 LC	118
f5fc0f86	119	#define NUM_TX_QUEUES 4
f5fc0f86	120
c47e8229	121	#define AP_MAX_STATIONS 8
beb6c880	122
6bac40a6 AN	123	struct wl_fw_packet_counters {
	124	/* Cumulative counter of released packets per AC */
	125	u8 tx_released_pkts[NUM_TX_QUEUES];
	126
	127	/* Cumulative counter of freed packets per HLID */
	128	u8 tx_lnk_free_pkts[WL12XX_MAX_LINKS];
	129
	130	/* Cumulative counter of released Voice memory blocks */
	131	u8 tx_voice_released_blks;
	132
4d703847 AN	133	/* Tx rate of the last transmitted packet */
	134	u8 tx_last_rate;
	135
	136	u8 padding[2];
6bac40a6 AN	137	} __packed;
6bac40a6 AN	138
4d56ad9c	139	/* FW status registers */
0afd04e5	140	struct wl_fw_status_1 {
d0f63b20	141	__le32 intr;
f5fc0f86 LC	142	u8 fw_rx_counter;
	143	u8 drv_rx_counter;
	144	u8 reserved;
	145	u8 tx_results_counter;
0afd04e5 AN	146	__le32 rx_pkt_descs[0];
	147	} __packed;
	148
	149	/*
	150	* Each HW arch has a different number of Rx descriptors.
	151	* The length of the status depends on it, since it holds an array
	152	* of descriptors.
	153	*/
	154	#define WLCORE_FW_STATUS_1_LEN(num_rx_desc) \
	155	(sizeof(struct wl_fw_status_1) + \
	156	(sizeof(((struct wl_fw_status_1 )0)->rx_pkt_descs[0])) \
	157	num_rx_desc)
	158
	159	struct wl_fw_status_2 {
d0f63b20	160	__le32 fw_localtime;
beb6c880 AN	161
	162	/*
	163	* A bitmap (where each bit represents a single HLID)
	164	* to indicate if the station is in PS mode.
	165	*/
	166	__le32 link_ps_bitmap;
	167
4d56ad9c EP	168	/*
	169	* A bitmap (where each bit represents a single HLID) to indicate
	170	* if the station is in Fast mode
	171	*/
	172	__le32 link_fast_bitmap;
f5fc0f86	173
4d56ad9c EP	174	/* Cumulative counter of total released mem blocks since FW-reset */
4d56ad9c EP	175	__le32 total_released_blks;
c8bde243	176
4d56ad9c EP	177	/* Size (in Memory Blocks) of TX pool */
4d56ad9c EP	178	__le32 tx_total;
c8bde243	179
6bac40a6	180	struct wl_fw_packet_counters counters;
c8bde243	181
4d56ad9c	182	__le32 log_start_addr;
6bac40a6 AN	183
	184	/* Private status to be used by the lower drivers */
	185	u8 priv[0];
4d56ad9c	186	} __packed;
c8bde243	187
4a31c11c	188	#define WL1271_MAX_CHANNELS 64
abb0b3bf	189	struct wl1271_scan {
4fb26fa9	190	struct cfg80211_scan_request *req;
4a31c11c	191	unsigned long scanned_ch[BITS_TO_LONGS(WL1271_MAX_CHANNELS)];
78abd320	192	bool failed;
abb0b3bf	193	u8 state;
3b40c040	194	u8 ssid[IEEE80211_MAX_SSID_LEN+1];
abb0b3bf	195	size_t ssid_len;
abb0b3bf TP	196	};
abb0b3bf TP	197
8197b711	198	struct wl1271_if_operations {
f1a26e63 IY	199	int __must_check (read)(struct device child, int addr, void *buf,
	200	size_t len, bool fixed);
	201	int __must_check (write)(struct device child, int addr, void *buf,
	202	size_t len, bool fixed);
a390e85c FB	203	void (reset)(struct device child);
	204	void (init)(struct device child);
	205	int (power)(struct device child, bool enable);
	206	void (set_block_size) (struct device child, unsigned int blksz);
8197b711 TP	207	};
8197b711 TP	208
afb43e6d LC	209	struct wlcore_platdev_data {
	210	struct wl12xx_platform_data *pdata;
	211	struct wl1271_if_operations *if_ops;
	212	};
	213
7f179b46 AN	214	#define MAX_NUM_KEYS 14
	215	#define MAX_KEY_SIZE 32
	216
	217	struct wl1271_ap_key {
	218	u8 id;
	219	u8 key_type;
	220	u8 key_size;
	221	u8 key[MAX_KEY_SIZE];
	222	u8 hlid;
	223	u32 tx_seq_32;
	224	u16 tx_seq_16;
	225	};
	226
72c2d9e5	227	enum wl12xx_flags {
72c2d9e5 EP	228	WL1271_FLAG_GPIO_POWER,
72c2d9e5 EP	229	WL1271_FLAG_TX_QUEUE_STOPPED,
b07d4037	230	WL1271_FLAG_TX_PENDING,
72c2d9e5	231	WL1271_FLAG_IN_ELP,
a665d6e2	232	WL1271_FLAG_ELP_REQUESTED,
72c2d9e5	233	WL1271_FLAG_IRQ_RUNNING,
72c2d9e5	234	WL1271_FLAG_FW_TX_BUSY,
990f5de7	235	WL1271_FLAG_DUMMY_PACKET_PENDING,
f44e5868 EP	236	WL1271_FLAG_SUSPENDED,
f44e5868 EP	237	WL1271_FLAG_PENDING_WORK,
77ddaa10	238	WL1271_FLAG_SOFT_GEMINI,
baacb9ae	239	WL1271_FLAG_RECOVERY_IN_PROGRESS,
4549d09c	240	WL1271_FLAG_VIF_CHANGE_IN_PROGRESS,
e9ba7152	241	WL1271_FLAG_INTENDED_FW_RECOVERY,
4455556d	242	WL1271_FLAG_IO_FAILED,
72c2d9e5 EP	243	};
72c2d9e5 EP	244
ba8447f6	245	enum wl12xx_vif_flags {
10c8cd01	246	WLVIF_FLAG_INITIALIZED,
ba8447f6	247	WLVIF_FLAG_STA_ASSOCIATED,
9fd6f21b	248	WLVIF_FLAG_STA_AUTHORIZED,
eee514e3	249	WLVIF_FLAG_IBSS_JOINED,
53d40d0b	250	WLVIF_FLAG_AP_STARTED,
5c0dc2fc	251	WLVIF_FLAG_IN_PS,
8181aecc	252	WLVIF_FLAG_STA_STATE_SENT,
0744bdb6	253	WLVIF_FLAG_RX_STREAMING_STARTED,
836d6600	254	WLVIF_FLAG_PSPOLL_FAILURE,
52630c5d	255	WLVIF_FLAG_CS_PROGRESS,
560f0024	256	WLVIF_FLAG_AP_PROBE_RESP_SET,
a0c7b782	257	WLVIF_FLAG_IN_USE,
ba8447f6 EP	258	};
ba8447f6 EP	259
1e0708a9 AN	260	struct wl12xx_vif;
1e0708a9 AN	261
a8c0ddb5 AN	262	struct wl1271_link {
	263	/* AP-mode - TX queue per AC in link */
	264	struct sk_buff_head tx_queue[NUM_TX_QUEUES];
09039f42	265
9b17f1b3 AN	266	/* accounting for allocated / freed packets in FW */
	267	u8 allocated_pkts;
	268	u8 prev_freed_pkts;
b622d992 AN	269
b622d992 AN	270	u8 addr[ETH_ALEN];
0f9c8250 AN	271
	272	/* bitmap of TIDs where RX BA sessions are active for this link */
	273	u8 ba_bitmap;
1e0708a9 AN	274
	275	/* The wlvif this link belongs to. Might be null for global links */
	276	struct wl12xx_vif *wlvif;
93d5d100 AN	277
	278	/*
	279	* total freed FW packets on the link - used for tracking the
	280	* AES/TKIP PN across recoveries. Re-initialized each time
	281	* from the wl1271_station structure.
	282	*/
	283	u64 total_freed_pkts;
a8c0ddb5 AN	284	};
a8c0ddb5 AN	285
c21eebb5	286	#define WL1271_MAX_RX_FILTERS 5
a6eab0c8	287	#define WL1271_RX_FILTER_MAX_FIELDS 8
b95d7cef ES	288
	289	#define WL1271_RX_FILTER_ETH_HEADER_SIZE 14
	290	#define WL1271_RX_FILTER_MAX_FIELDS_SIZE 95
	291	#define RX_FILTER_FIELD_OVERHEAD \
	292	(sizeof(struct wl12xx_rx_filter_field) - sizeof(u8 *))
	293	#define WL1271_RX_FILTER_MAX_PATTERN_SIZE \
	294	(WL1271_RX_FILTER_MAX_FIELDS_SIZE - RX_FILTER_FIELD_OVERHEAD)
	295
	296	#define WL1271_RX_FILTER_FLAG_MASK BIT(0)
	297	#define WL1271_RX_FILTER_FLAG_IP_HEADER 0
	298	#define WL1271_RX_FILTER_FLAG_ETHERNET_HEADER BIT(1)
	299
a6eab0c8 ES	300	enum rx_filter_action {
	301	FILTER_DROP = 0,
	302	FILTER_SIGNAL = 1,
	303	FILTER_FW_HANDLE = 2
	304	};
	305
7019c80e YS	306	enum plt_mode {
	307	PLT_OFF = 0,
	308	PLT_ON = 1,
	309	PLT_FEM_DETECT = 2,
	310	};
	311
a6eab0c8 ES	312	struct wl12xx_rx_filter_field {
	313	__le16 offset;
	314	u8 len;
	315	u8 flags;
	316	u8 *pattern;
	317	} __packed;
	318
	319	struct wl12xx_rx_filter {
	320	u8 action;
	321	int num_fields;
	322	struct wl12xx_rx_filter_field fields[WL1271_RX_FILTER_MAX_FIELDS];
	323	};
	324
f84f7d78 AN	325	struct wl1271_station {
f84f7d78 AN	326	u8 hlid;
426001a6	327	bool in_connection;
f5fc0f86 LC	328	};
f5fc0f86 LC	329
87fbcb0f	330	struct wl12xx_vif {
252efa4f	331	struct wl1271 *wl;
87627214	332	struct list_head list;
ba8447f6	333	unsigned long flags;
536129c8	334	u8 bss_type;
fb0e707c	335	u8 p2p; /* we are using p2p role */
0603d891	336	u8 role_id;
536129c8	337
7edebf56 EP	338	/* sta/ibss specific */
7edebf56 EP	339	u8 dev_role_id;
afaf8bdb	340	u8 dev_hlid;
7edebf56	341
154da67c EP	342	union {
	343	struct {
	344	u8 hlid;
e5a359f8 EP	345
	346	u8 basic_rate_idx;
	347	u8 ap_rate_idx;
	348	u8 p2p_rate_idx;
5ec8a448	349
001e39a8 EP	350	u8 klv_template_id;
001e39a8 EP	351
5ec8a448	352	bool qos;
5f9b6777 AN	353	/* channel type we started the STA role with */
5f9b6777 AN	354	enum nl80211_channel_type role_chan_type;
154da67c	355	} sta;
a8ab39a4 EP	356	struct {
	357	u8 global_hlid;
	358	u8 bcast_hlid;
c7ffb902 EP	359
	360	/* HLIDs bitmap of associated stations */
	361	unsigned long sta_hlid_map[BITS_TO_LONGS(
	362	WL12XX_MAX_LINKS)];
170d0e67 EP	363
	364	/* recoreded keys - set here before AP startup */
	365	struct wl1271_ap_key *recorded_keys[MAX_NUM_KEYS];
e5a359f8 EP	366
	367	u8 mgmt_rate_idx;
	368	u8 bcast_rate_idx;
	369	u8 ucast_rate_idx[CONF_TX_MAX_AC_COUNT];
a8ab39a4	370	} ap;
154da67c EP	371	};
154da67c EP	372
4438aca9 EP	373	/* the hlid of the last transmitted skb */
	374	int last_tx_hlid;
	375
8591d424 AN	376	/* counters of packets per AC, across all links in the vif */
	377	int tx_queue_count[NUM_TX_QUEUES];
	378
c7ffb902 EP	379	unsigned long links_map[BITS_TO_LONGS(WL12XX_MAX_LINKS)];
c7ffb902 EP	380
1fe9f161 EP	381	u8 ssid[IEEE80211_MAX_SSID_LEN + 1];
	382	u8 ssid_len;
	383
1b92f15e EP	384	/* The current band */
1b92f15e EP	385	enum ieee80211_band band;
61f845f4	386	int channel;
83d08d3f	387	enum nl80211_channel_type channel_type;
1b92f15e	388
091185d6	389	u32 bitrate_masks[WLCORE_NUM_BANDS];
87fbcb0f	390	u32 basic_rate_set;
30d0c8fd EP	391
	392	/*
	393	* currently configured rate set:
	394	* bits 0-15 - 802.11abg rates
	395	* bits 16-23 - 802.11n MCS index mask
	396	* support only 1 stream, thus only 8 bits for the MCS rates (0-7).
	397	*/
d2d66c56	398	u32 basic_rate;
30d0c8fd	399	u32 rate_set;
bddb29b8 EP	400
	401	/* probe-req template for the current AP */
	402	struct sk_buff *probereq;
6840e37a	403
6a899796 EP	404	/* Beaconing interval (needed for ad-hoc) */
	405	u32 beacon_int;
	406
f75c753f EP	407	/* Default key (for WEP) */
	408	u32 default_key;
	409
6840e37a EP	410	/* Our association ID */
6840e37a EP	411	u16 aid;
98b86253	412
74ec8395 EP	413	/* retry counter for PSM entries */
74ec8395 EP	414	u8 psm_entry_retry;
04324d99	415
6bd65029 EP	416	/* in dBm */
	417	int power_level;
	418
04324d99 EP	419	int rssi_thold;
04324d99 EP	420	int last_rssi_event;
d0802abd	421
5ec8a448 EP	422	/* save the current encryption type for auto-arp config */
	423	u8 encryption_type;
	424	__be32 ip_addr;
	425
d0802abd EP	426	/* RX BA constraint value */
	427	bool ba_support;
	428	bool ba_allowed;
48e93e40	429
d50529c0 EP	430	bool wmm_enabled;
d50529c0 EP	431
9eb599e9 EP	432	/* Rx Streaming */
	433	struct work_struct rx_streaming_enable_work;
	434	struct work_struct rx_streaming_disable_work;
	435	struct timer_list rx_streaming_timer;
	436
c50a2825 EP	437	struct delayed_work channel_switch_work;
	438	struct delayed_work connection_loss_work;
	439
426001a6 EP	440	/* number of in connection stations */
	441	int inconn_count;
	442
1c33db78 AN	443	/*
	444	* This vif's queues are mapped to mac80211 HW queues as:
	445	* VO - hw_queue_base
	446	* VI - hw_queue_base + 1
	447	* BE - hw_queue_base + 2
	448	* BK - hw_queue_base + 3
	449	*/
	450	int hw_queue_base;
	451
48e93e40 EP	452	/*
	453	* This struct must be last!
	454	* data that has to be saved acrossed reconfigs (e.g. recovery)
	455	* should be declared in this struct.
	456	*/
	457	struct {
	458	u8 persistent[0];
93d5d100	459
48e93e40	460	/*
93d5d100 AN	461	* total freed FW packets on the link - used for
	462	* storing the AES/TKIP PN during recovery, as this
	463	* structure is not zeroed out.
48e93e40	464	*/
93d5d100	465	u64 total_freed_pkts;
48e93e40	466	};
87fbcb0f EP	467	};
	468
	469	static inline struct wl12xx_vif wl12xx_vif_to_data(struct ieee80211_vif vif)
	470	{
f4d02007	471	WARN_ON(!vif);
87fbcb0f EP	472	return (struct wl12xx_vif *)vif->drv_priv;
	473	}
	474
	475	static inline
	476	struct ieee80211_vif wl12xx_wlvif_to_vif(struct wl12xx_vif wlvif)
	477	{
	478	return container_of((void *)wlvif, struct ieee80211_vif, drv_priv);
	479	}
	480
87627214 EP	481	#define wl12xx_for_each_wlvif(wl, wlvif) \
	482	list_for_each_entry(wlvif, &wl->wlvif_list, list)
	483
e4120df9 EP	484	#define wl12xx_for_each_wlvif_continue(wl, wlvif) \
	485	list_for_each_entry_continue(wlvif, &wl->wlvif_list, list)
	486
4b730b6a EP	487	#define wl12xx_for_each_wlvif_bss_type(wl, wlvif, _bss_type) \
	488	wl12xx_for_each_wlvif(wl, wlvif) \
	489	if (wlvif->bss_type == _bss_type)
	490
	491	#define wl12xx_for_each_wlvif_sta(wl, wlvif) \
	492	wl12xx_for_each_wlvif_bss_type(wl, wlvif, BSS_TYPE_STA_BSS)
	493
	494	#define wl12xx_for_each_wlvif_ap(wl, wlvif) \
	495	wl12xx_for_each_wlvif_bss_type(wl, wlvif, BSS_TYPE_AP_BSS)
	496
7019c80e	497	int wl1271_plt_start(struct wl1271 *wl, const enum plt_mode plt_mode);
f5fc0f86	498	int wl1271_plt_stop(struct wl1271 *wl);
9eb599e9	499	int wl1271_recalc_rx_streaming(struct wl1271 wl, struct wl12xx_vif wlvif);
baacb9ae	500	void wl12xx_queue_recovery_work(struct wl1271 *wl);
95dac04f	501	size_t wl12xx_copy_fwlog(struct wl1271 wl, u8 memblock, size_t maxlen);
a6eab0c8 ES	502	int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
	503	u16 offset, u8 flags,
	504	u8 *pattern, u8 len);
	505	void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter);
	506	struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void);
	507	int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter);
	508	void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,
	509	u8 *buf);
f5fc0f86 LC	510
	511	#define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */
	512
98b86253 EP	513	#define SESSION_COUNTER_MAX 6 /* maximum value for the session counter */
98b86253 EP	514	#define SESSION_COUNTER_INVALID 7 /* used with dummy_packet */
f5fc0f86 LC	515
	516	#define WL1271_DEFAULT_POWER_LEVEL 0
	517
787b2dc4 IY	518	#define WL1271_TX_QUEUE_LOW_WATERMARK 32
787b2dc4 IY	519	#define WL1271_TX_QUEUE_HIGH_WATERMARK 256
f5fc0f86	520
a620865e IY	521	#define WL1271_DEFERRED_QUEUE_LIMIT 64
a620865e IY	522
01ac17ec JO	523	/* WL1271 needs a 200ms sleep after power on, and a 20ms sleep before power
01ac17ec JO	524	on in case is has been shut down shortly before */
e8a8b252 SW	525	#define WL1271_PRE_POWER_ON_SLEEP 20 /* in milliseconds */
e8a8b252 SW	526	#define WL1271_POWER_ON_SLEEP 200 /* in milliseconds */
f5fc0f86	527
e8b03a2b SL	528	/* Macros to handle wl1271.sta_rate_set */
	529	#define HW_BG_RATES_MASK 0xffff
	530	#define HW_HT_RATES_OFFSET 16
b3a47ee0	531	#define HW_MIMO_RATES_OFFSET 24
e8b03a2b	532
95dac04f IY	533	#define WL12XX_HW_BLOCK_SIZE 256
95dac04f IY	534
8388569a	535	#endif /* __WLCORE_I_H__ */