path: root/target/linux/package/ieee80211-dscape/src/include/net/ieee80211.h

/*
 * Low-level hardware driver -- IEEE 802.11 driver (80211.o) interface
 * Copyright 2002-2005, Devicescape Software, Inc.
 *
 * 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.
 */

#ifndef IEEE80211_H
#define IEEE80211_H

#include "ieee80211_shared.h"

/* Note! Only ieee80211_tx_status_irqsafe() and ieee80211_rx_irqsave() can be
 * called in hardware interrupt context. The low-level driver must not call any
 * other functions in hardware interrupt context. If there is a need for such
 * call, the low-level driver should first ACK the interrupt and perform the
 * IEEE 802.11 code call after this, e.g., from a scheduled tasklet (in
 * software interrupt context).
 */

/*
 * Frame format used when passing frame between low-level hardware drivers
 * and IEEE 802.11 driver the same as used in the wireless media, i.e.,
 * buffers start with IEEE 802.11 header and include the same octets that
 * are sent over air.
 *
 * If hardware uses IEEE 802.3 headers (and perform 802.3 <-> 802.11
 * conversion in firmware), upper layer 802.11 code needs to be changed to
 * support this.
 *
 * If the receive frame format is not the same as the real frame sent
 * on the wireless media (e.g., due to padding etc.), upper layer 802.11 code
 * could be updated to provide support for such format assuming this would
 * optimize the performance, e.g., by removing need to re-allocation and
 * copying of the data.
 */

/* Interface version (used for compatibility verification) */
#define IEEE80211_VERSION 2


/* Channel information structure. Low-level driver is expected to fill in chan,
 * freq, and val fields. Other fields will be filled in by 80211.o based on
 * hostapd information and low-level driver does not need to use them. The
 * limits for each channel will be provided in 'struct ieee80211_conf' when
 * configuring the low-level driver with hw->config callback. */
struct ieee80211_channel {
	short chan; /* channel number (IEEE 802.11) */
	short freq; /* frequency in MHz */
	int val; /* hw specific value for the channel */
	int flag; /* flag for hostapd use (IEEE80211_CHAN_*) */
        unsigned char power_level;
        unsigned char antenna_max;
};

struct ieee80211_rate {
	int rate; /* rate in 100 kbps */
	int val; /* hw specific value for the rate */
	int flags; /* IEEE80211_RATE_ flags */
	int val2; /* hw specific value for the rate when using short preamble
		   * (only when IEEE80211_RATE_PREAMBLE2 flag is set, i.e., for
		   * 2, 5.5, and 11 Mbps) */
	signed char min_rssi_ack;
	unsigned char min_rssi_ack_delta;

	/* following fields are set by 80211.o and need not be filled by the
	 * low-level driver */
	int rate_inv; /* inverse of the rate (LCM(all rates) / rate) for
		       * optimizing channel utilization estimates */
};

struct ieee80211_hw_modes {
	int mode;
	int num_channels;
	struct ieee80211_channel *channels;
	int num_rates;
        struct ieee80211_rate *rates;
	int xr_end; /* only used with Atheros XR */
};

struct ieee80211_tx_queue_params {
	int aifs; /* 0 .. 255; -1 = use default */
	int cw_min; /* 2^n-1: 1, 3, 7, .. , 1023; 0 = use default */
	int cw_max; /* 2^n-1: 1, 3, 7, .. , 1023; 0 = use default */
	int burst_time; /* maximum burst time in 0.1 ms (i.e., 10 = 1 ms);
			 * 0 = disabled */
};

#define NUM_TX_DATA_QUEUES 6

struct ieee80211_tx_queue_stats_data {
	unsigned int len; /* num packets in queue */
	unsigned int limit; /* queue len (soft) limit */
	unsigned int count; /* total num frames sent */
};

struct ieee80211_tx_queue_stats {
	struct ieee80211_tx_queue_stats_data data[NUM_TX_DATA_QUEUES];
};

#ifndef IEEE80211_TX_QUEUE_NUMS
#define IEEE80211_TX_QUEUE_NUMS
/* TODO: these need to be synchronized with hostapd_ioctl.h; make a shared
 * header file that can be included into low-level drivers, 80211.o, and
 * hostapd */
enum {
	IEEE80211_TX_QUEUE_DATA0 = 0,
	IEEE80211_TX_QUEUE_DATA1 = 1,
	IEEE80211_TX_QUEUE_DATA2 = 2,
	IEEE80211_TX_QUEUE_DATA3 = 3,
	IEEE80211_TX_QUEUE_DATA4 = 4,
	IEEE80211_TX_QUEUE_SVP = 5,
	IEEE80211_TX_QUEUE_AFTER_BEACON = 6,
	IEEE80211_TX_QUEUE_BEACON = 7
};
#endif /* IEEE80211_TX_QUEUE_NUMS */


struct ieee80211_low_level_stats {
	unsigned int dot11ACKFailureCount;
	unsigned int dot11RTSFailureCount;
        unsigned int dot11FCSErrorCount;
	unsigned int dot11RTSSuccessCount;
};

/* Transmit control fields. This data structure is passed to low-level driver
 * with each TX frame. The low-level driver is responsible of configuring
 * hardware to use given values (depending on what is supported). */
#define HW_KEY_IDX_INVALID -1

struct ieee80211_tx_control {
	enum { PKT_NORMAL = 0, PKT_PROBE_RESP } pkt_type;
	int tx_rate; /* Transmit rate, given as the hw specific value for the
		      * rate (from struct ieee80211_rate) */
	int rts_cts_rate; /* Transmit rate for RTS/CTS frame, given as the hw
			   * specific value for the rate (from
			   * struct ieee80211_rate) */
	/* 1 = only first attempt, 2 = one retry, .. */
	unsigned int retry_limit:8;
	/* duration field for RTS/CTS frame */
	unsigned int rts_cts_duration:16;
	/* TODO: change these bit flags to use one unsigned int variable and
	 * defines with BIT(n). These are copied to TX status structure and
	 * this will make the code faster and smaller. */
	unsigned int req_tx_status:1; /* request TX status callback for this
				       * frame */
	unsigned int do_not_encrypt:1; /* send this frame without encryption;
			       * e.g., for EAPOL frames */
	unsigned int use_rts_cts:1; /* Use RTS-CTS before sending frame. */
	unsigned int use_cts_protect:1; /* Use CTS protection for the frame
					 * (e.g., for combined 802.11g /
					 * 802.11b networks) */
        unsigned int no_ack:1; /* Tell the low level not to wait for an ack */
	unsigned int rate_ctrl_probe:1;
	unsigned int clear_dst_mask:1;
	unsigned int requeue:1;
	 /* following three flags are only used with Atheros Super A/G */
	unsigned int compress:1;
	unsigned int turbo_prime_notify:1; /* notify HostaAPd after frame
					    * transmission */
	unsigned int fast_frame:1;

	unsigned int atheros_xr:1; /* only used with Atheros XR */

        unsigned int power_level:8; /* per-packet transmit power level, in dBm
				     */
	unsigned int antenna_sel:4; /* 0 = default/diversity,
				     * 1 = Ant0, 2 = Ant1 */
	int key_idx:8; /* -1 = do not encrypt, >= 0 keyidx from hw->set_key()
			*/
	int icv_len:8; /* Length of the ICV/MIC field in octets */
	int iv_len:8; /* Length of the IV field in octets */
	unsigned int queue:4; /* hardware queue to use for this frame;
		      * 0 = highest, hw->queues-1 = lowest */
	unsigned int sw_retry_attempt:4; /* no. of times hw has tried to
		      * transmit frame (not incl. hw retries) */

#if 0
	int rateidx; /* internal 80211.o rateidx, to be copied to tx_status */
	int alt_retry_rate; /* retry rate for the last retries, given as the
			     * hw specific value for the rate (from
			     * struct ieee80211_rate). To be used to limit
			     * packet dropping when probing higher rates, if hw
			     * supports multiple retry rates. -1 = not used */
#endif
};

#define IEEE80211_CB_MAGIC 0xAAB80211

struct ieee80211_tx_packet_data {
        unsigned int magic;
        struct ieee80211_tx_control control;
        unsigned long jiffies;
        struct ieee80211_sub_if_data *sdata;
};

#define RX_FLAG_MMIC_ERROR       0x1
#define RX_FLAG_DECRYPTED        0x2
#define RX_FLAG_XR_DOUBLE_CHIRP  0x4

/* Receive status. The low-level driver should provide this information
 * (the subset supported by hardware) to the 802.11 code with each received
 * frame.
 * Current implementation copies this into skb->cb, so it must be less than
 * 48 bytes. */
struct ieee80211_rx_status {
#if 0
        u64 hosttime;
	u64 mactime;
#endif
        int freq; /* receive frequency in Mhz */
        int channel;
        int phymode;
        int ssi;
        int antenna;
        int rate;
        int flag;
};

/* Transmit status. The low-level driver should provide this information
 * (the subset supported by hardware) to the 802.11 code for each transmit
 * frame. */
struct ieee80211_tx_status {
	/* flags copied from struct ieee80211_tx_control) */
	unsigned int req_tx_status:1; /* whether TX status was explicitly
				       * requested */
	unsigned int rate_ctrl_probe:1; /* whether this was a probe packet from
					 * rate control */
	unsigned int tx_filtered:1;

	/* following three fields are only used with Atheros Super A/G */
	unsigned int turbo_prime_notify:1; /* notify HostAPd - CTS for Turbo
					    * Prime is sent */
        int queue_length;      /* information about TX queue */
        int queue_number;

	int ack; /* whether the TX frame was ACKed */
	int ack_signal; /* measured signal strength of the ACK frame */
	int excessive_retries;
	int retry_count;
	int rateidx; /* internal 80211.o rateidx, to be copied to tx_status */
};


struct ieee80211_conf {
	int channel;			/* IEEE 802.11 channel number */
	int freq;			/* MHz */
	int channel_val;		/* hw specific value for the channel */

	int mode;			/* IW_MODE_ */

	int phymode;			/* MODE_IEEE80211A, .. */
        unsigned int regulatory_domain;
        int adm_status;

        int beacon_int;

	/* Bitfields, grouped together */

	int sw_encrypt:1;
	int sw_decrypt:1;
	int short_slot_time:1;		/* use IEEE 802.11g Short Slot Time */
        int ssid_hidden:1;		/* do not broadcast the ssid */

        /* these fields are used by low level drivers for hardware
         * that generate beacons independently */
        u8 *ssid;
	size_t ssid_len;
	u8 *generic_elem;
	size_t generic_elem_len;

        u8 power_level;			/* transmit power limit for current
					 * regulatory domain; in dBm */
        u8 antenna_max;			/* maximum antenna gain */
	short tx_power_reduction; /* in 0.1 dBm */

	int antenna_sel;		/* default antenna conf:
					 *	0 = default/diversity,
			  		 *	1 = Ant0,
					 *	2 = Ant1 */

	int calib_int;			/* hw/radio calibration interval in
					 * seconds */
        int antenna_def;
        int antenna_mode;

	u8 bssid_mask[ETH_ALEN];	/* ff:ff:ff:ff:ff:ff = 1 BSSID */
	int bss_count;

	int atheros_super_ag_compression;
	int atheros_super_ag_fast_frame;
	int atheros_super_ag_burst;
	int atheros_super_ag_wme_ele;
	int atheros_super_ag_turbo_g;
	int atheros_super_ag_turbo_prime;

	int atheros_xr;

	u8 client_bssid[ETH_ALEN];

	/* Following five fields are used for IEEE 802.11H */
	unsigned int radar_detect;
	unsigned int spect_mgmt;
	unsigned int quiet_duration; /* duration of quiet period */
	unsigned int quiet_offset; /* how far into the beacon is the quiet
				    * period */
	unsigned int quiet_period;
};


typedef enum { ALG_NONE, ALG_WEP, ALG_TKIP, ALG_CCMP, ALG_NULL }
ieee80211_key_alg;


struct ieee80211_key_conf {

	int hw_key_idx;			/* filled + used by low-level driver */
	ieee80211_key_alg alg;
	int keylen;

        int force_sw_encrypt:1;		/* to be cleared by low-level driver */
	int keyidx:8;			/* WEP key index */
	int default_tx_key:1;		/* This key is the new default TX key
			       		 * (used only for broadcast keys). */
	int default_wep_only:1; /* static WEP is the only configured security
				 * policy; this allows some low-level drivers
				 * to determine when hwaccel can be used */
        u8 key[0];
};

#define IEEE80211_SCAN_START 1
#define IEEE80211_SCAN_END   2

struct ieee80211_scan_conf {
        int scan_channel;     /* IEEE 802.11 channel number to do passive scan
			       * on */
        int scan_freq;        /* new freq in MHz to switch to for passive scan
			       */
	int scan_channel_val; /* hw specific value for the channel */
        int scan_phymode;     /* MODE_IEEE80211A, .. */
        unsigned char scan_power_level;
        unsigned char scan_antenna_max;


        int running_channel; /* IEEE 802.11 channel number we operate on
			      * normally */
        int running_freq;    /* freq in MHz we're operating on normally */
	int running_channel_val; /* hw specific value for the channel */
        int running_phymode;
        unsigned char running_power_level;
        unsigned char running_antenna_max;

        int scan_time;       /* time a scan will take in us */
        int tries;

        struct sk_buff *skb; /* skb to transmit before changing channels, maybe
			      * NULL for none */
        struct ieee80211_tx_control *tx_control;

};

#ifndef IW_MODE_ADHOC
#define IW_MODE_ADHOC 1
#endif

#ifndef IW_MODE_INFRA
#define IW_MODE_INFRA 2
#endif

#ifndef IW_MODE_MASTER
#define IW_MODE_MASTER 3
#endif

#ifndef IW_MODE_MONITOR
#define IW_MODE_MONITOR 6
#endif

#define IEEE80211_SEQ_COUNTER_RX	0
#define IEEE80211_SEQ_COUNTER_TX	1

typedef enum {
	SET_KEY, DISABLE_KEY, REMOVE_ALL_KEYS,
	ENABLE_COMPRESSION, DISABLE_COMPRESSION
} set_key_cmd;

/* Configuration block used by the low-level driver to tell 802.11 code about
 * supported hardware features and to pass function pointers for callback
 * functions. */
struct ieee80211_hw {
	int version; /* IEEE80211_VERSION */

	/* Driver name */
	char *name;

	/* TODO: frame_type 802.11/802.3, sw_encryption requirements */

	/* Some wireless LAN chipsets generate beacons in the hardware/firmware
	 * and others rely on host generated beacons. This option is used to
	 * configure upper layer IEEE 802.11 module to generate beacons. The
	 * low-level driver can use ieee80211_beacon_get() to fetch next
	 * beacon frame. */
	int host_gen_beacon:1;


	/* Some devices handle decryption internally and do not
	 * indicate whether the frame was encrypted (unencrypted frames
	 * will be dropped by the hardware, unless specifically allowed
	 * through) */
        int device_hides_wep:1;

	/* Whether RX frames passed to ieee80211_rx() include FCS in the end
	 */
	int rx_includes_fcs:1;

	/* Some wireless LAN chipsets buffer broadcast/multicast frames for
	 * power saving stations in the hardware/firmware and others rely on
	 * the host system for such buffering. This option is used to
	 * configure upper layer IEEE 802.11 to buffer broadcast/multicast
	 * frames when there are power saving stations so that low-level driver
	 * can fetch them with ieee80211_get_buffered_bc(). */
	int host_broadcast_ps_buffering:1;

	int wep_include_iv:1;
	int data_nullfunc_ack:1; /* will data nullfunc frames get proper
                                  * TX status callback */

	/* Force sw version of encryption for TKIP packets if WMM is enabled.
	 */
	int no_tkip_wmm_hwaccel:1;

        /* 1 if the payload needs to be padded at even boundaries after the
	 * header */
        unsigned int extra_hdr_room:1;

	/* Some devices handle Michael MIC internally and do not include MIC in
	 * the received packets given to 80211.o. device_strips_mic must be set
	 * for such devices. ISWEP bit is still expected to be set in the IEEE
	 * 802.11 header with this option unlike with device_hides_wep option.
	 */
	unsigned int device_strips_mic:1;

	/* 1 = low-level driver supports skb fraglist (NETIF_F_FRAGLIST), i.e.,
	 * more than one skb per frame */
	unsigned int fraglist;

        /* This is the time in us to change channels
         */
        int channel_change_time;

	int num_modes;
	struct ieee80211_hw_modes *modes;

	/* Handler that 802.11 module calls for each transmitted frame.
	 * skb contains the buffer starting from the IEEE 802.11 header.
	 * The low-level driver should send the frame out based on
	 * configuration in the TX control data. */
	int (*tx)(struct net_device *dev, struct sk_buff *skb,
		  struct ieee80211_tx_control *control);

	/* Handler for performing hardware reset. */
	int (*reset)(struct net_device *dev);

	/* Handler that is called when any netdevice attached to the hardware
	 * device is set UP for the first time. This can be used, e.g., to
	 * enable interrupts and beacon sending. */
	int (*open)(struct net_device *dev);

	/* Handler that is called when the last netdevice attached to the
	 * hardware device is set DOWN. This can be used, e.g., to disable
	 * interrupts and beacon sending. */
	int (*stop)(struct net_device *dev);

	/* Handler for configuration requests. IEEE 802.11 code calls this
	 * function to change hardware configuration, e.g., channel. */
	int (*config)(struct net_device *dev, struct ieee80211_conf *conf);

	/* Set TIM bit handler. If the hardware/firmware takes care of beacon
	 * generation, IEEE 802.11 code uses this function to tell the
	 * low-level to set (or clear if set==0) TIM bit for the given aid. If
	 * host system is used to generate beacons, this handler is not used
	 * and low-level driver should set it to NULL. */
	int (*set_tim)(struct net_device *dev, int aid, int set);

	/* Set encryption key. IEEE 802.11 module calls this function to set
	 * encryption keys. addr is ff:ff:ff:ff:ff:ff for default keys and
	 * station hwaddr for individual keys. aid of the station is given
	 * to help low-level driver in selecting which key->hw_key_idx to use
	 * for this key. TX control data will use the hw_key_idx selected by
	 * the low-level driver. */
	int (*set_key)(struct net_device *dev, set_key_cmd cmd, u8 *addr,
                       struct ieee80211_key_conf *key, int aid);

	/* Set TX key index for default/broadcast keys. This is needed in cases
	 * where wlan card is doing full WEP/TKIP encapsulation (wep_include_iv
	 * is not set), in other cases, this function pointer can be set to
	 * NULL since 80211.o takes care of selecting the key index for each
	 * TX frame. */
	int (*set_key_idx)(struct net_device *dev, int idx);

	/* Enable/disable IEEE 802.1X. This item requests wlan card to pass
	 * unencrypted EAPOL-Key frames even when encryption is configured.
	 * If the wlan card does not require such a configuration, this
	 * function pointer can be set to NULL. 80211.o */
	int (*set_ieee8021x)(struct net_device *dev, int use_ieee8021x);

	/* Set port authorization state (IEEE 802.1X PAE) to be authorized
	 * (authorized=1) or unauthorized (authorized=0). This function can be
	 * used if the wlan hardware or low-level driver implements PAE.
	 * 80211.o module will anyway filter frames based on authorization
	 * state, so this function pointer can be NULL if low-level driver does
	 * not require event notification about port state changes. */
	int (*set_port_auth)(struct net_device *dev, u8 *addr, int authorized);

        /* Ask the hardware to do a passive scan on a new channel. The hardware
         * will do what ever is required to nicely leave the current channel
         * including transmit any CTS packets, etc. */
        int (*passive_scan)(struct net_device *dev, int state,
                            struct ieee80211_scan_conf *conf);

        /* return low-level statistics */
	int (*get_stats)(struct net_device *dev,
			 struct ieee80211_low_level_stats *stats);

        /* Enable/disable test modes; mode = IEEE80211_TEST_* */
	int (*test_mode)(struct net_device *dev, int mode);

	/* Configuration of test parameters */
	int (*test_param)(struct net_device *dev, int param, int value);

	/* Change MAC address. addr is pointer to struct sockaddr. */
	int (*set_mac_address)(struct net_device *dev, void *addr);

        /* For devices that generate their own beacons and probe response
         * or association responses this updates the state of privacy_invoked
         * returns 0 for success or an error number */

        int (*set_privacy_invoked)(struct net_device *dev,
                                   int privacy_invoked);

	/* For devices that have internal sequence counters, allow 802.11
	 * code to access the current value of a counter */
	int (*get_sequence_counter)(struct net_device *dev,
	                            u8* addr, u8 keyidx, u8 txrx,
				    u32* iv32, u16* iv16);

	/* Configuration of RTS threshold (if device needs it) */
	int (*set_rts_threshold)(struct net_device *dev, u32 value);

	/* Configuration of fragmentation threshold (if device needs it) */
	int (*set_frag_threshold)(struct net_device *dev, u32 value);

	/* Configuration of retry limits (if device needs it) */
	int (*set_retry_limit)(struct net_device *dev, u32 short_retry,
			       u32 long_retr);

	/* Number of STAs in STA table notification (NULL = disabled) */
	void (*sta_table_notification)(struct net_device *dev, int num_sta);

	/* Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
	 * bursting) for a hardware TX queue.
	 * queue = IEEE80211_TX_QUEUE_*. */
	int (*conf_tx)(struct net_device *dev, int queue,
		       const struct ieee80211_tx_queue_params *params);

	/* Get statistics of the current TX queue status. This is used to get
	 * number of currently queued packets (queue length), maximum queue
	 * size (limit), and total number of packets sent using each TX queue
	 * (count). This information is used for WMM to find out which TX
	 * queues have room for more packets and by hostapd to provide
	 * statistics about the current queueing state to external programs. */
	int (*get_tx_stats)(struct net_device *dev,
			    struct ieee80211_tx_queue_stats *stats);

	/* Number of available hardware TX queues for data packets.
	 * WMM requires at least four queues. */
	int queues;

	/* Get the current TSF timer value from firmware/hardware. Currently,
	 * this is only used for IBSS mode debugging and, as such, is not a
	 * required function. */
	u64 (*get_tsf)(struct net_device *dev);

	/* Reset the TSF timer and allow firmware/hardware to synchronize with
	 * other STAs in the IBSS. This is only used in IBSS mode. This
	 * function is optional if the firmware/hardware takes full care of
	 * TSF synchronization. */
	void (*reset_tsf)(struct net_device *dev);

	/* Setup beacon data for IBSS beacons. Unlike access point (Master),
	 * IBSS uses a fixed beacon frame which is configured using this
	 * function. This handler is required only for IBSS mode. */
	int (*beacon_update)(struct net_device *dev, struct sk_buff *skb,
			     struct ieee80211_tx_control *control);

	/* Determine whether the last IBSS beacon was sent by us. This is
	 * needed only for IBSS mode and the result of this function is used to
	 * determine whether to reply to Probe Requests. */
	int (*tx_last_beacon)(struct net_device *dev);

	/* Optional handler for XR-in-use notification. */
	int (*atheros_xr_in_use)(struct net_device *dev, int in_use);
};

/* Allocate a new hardware device. This must be called once for each
 * hardware device. The returned pointer must be used to refer to this
 * device when calling other functions. 802.11 code allocates a private data
 * area for the low-level driver. The size of this area is given as
 * priv_data_len. ieee80211_dev_hw_data() is used to get a pointer to the
 * private data area.
 *
 * Note: in this version of the interface the returned pointer is struct
 * net_device *. This may change in the future and low-level driver should
 * not refer the device data directly to remain compatible with the future
 * versions of the interface. */
struct net_device *ieee80211_alloc_hw(size_t priv_data_len,
				      void (*setup)(struct net_device *));

/* Register hardware device to the IEEE 802.11 code and kernel. Low-level
 * drivers must call this function before using any other IEEE 802.11
 * function. */
int ieee80211_register_hw(struct net_device *dev, struct ieee80211_hw *hw);

/* This function is allowed to update hardware configuration (e.g., list of
 * supported operation modes and rates). */
int ieee80211_update_hw(struct net_device *dev, struct ieee80211_hw *hw);

/* Unregister a hardware device. This function instructs 802.11 code to free
 * allocated resources and unregister netdevices from the kernel. */
void ieee80211_unregister_hw(struct net_device *dev);

/* Free allocated net_device including private data of a driver. */
void ieee80211_free_hw(struct net_device *dev);

/* Receive frame callback function. The low-level driver uses this function to
 * send received frames to the IEEE 802.11 code. Receive buffer (skb) must
 * start with IEEE 802.11 header. */
void ieee80211_rx(struct net_device *dev, struct sk_buff *skb,
		  struct ieee80211_rx_status *status);
void ieee80211_rx_irqsafe(struct net_device *dev, struct sk_buff *skb,
			  struct ieee80211_rx_status *status);

/* Transmit status callback function. The low-level driver must call this
 * function to report transmit status for all the TX frames that had
 * req_tx_status set in the transmit control fields. In addition, this should
 * be called at least for all unicast frames to provide information for TX rate
 * control algorithm. In order to maintain all statistics, this function is
 * recommended to be called after each frame, including multicast/broadcast, is
 * sent. */
void ieee80211_tx_status(struct net_device *dev, struct sk_buff *skb,
			 struct ieee80211_tx_status *status);
void ieee80211_tx_status_irqsafe(struct net_device *dev, struct sk_buff *skb,
				 struct ieee80211_tx_status *status);

/* Beacon generation function. If the beacon frames are generated by the host
 * system (i.e., not in hardware/firmware), the low-level driver uses this
 * function to receive the next beacon frame from the 802.11 code. The
 * low-level is responsible for calling this function before beacon data is
 * needed (e.g., based on hardware interrupt). Returned skb is used only once
 * and low-level driver is responsible of freeing it. */
struct sk_buff * ieee80211_beacon_get(struct net_device *dev, int bss_idx,
				      struct ieee80211_tx_control *control);

/* Function for accessing buffered broadcast and multicast frames. If
 * hardware/firmware does not implement buffering of broadcast/multicast
 * frames when power saving is used, 802.11 code buffers them in the host
 * memory. The low-level driver uses this function to fetch next buffered
 * frame. In most cases, this is used when generating beacon frame. This
 * function returns a pointer to the next buffered skb or NULL if no more
 * buffered frames are available.
 *
 * Note: buffered frames are returned only after DTIM beacon frame was
 * generated with ieee80211_beacon_get() and the low-level driver must thus
 * call ieee80211_beacon_get() first. ieee80211_get_buffered_bc() returns
 * NULL if the previous generated beacon was not DTIM, so the low-level driver
 * does not need to check for DTIM beacons separately and should be able to
 * use common code for all beacons. */
struct sk_buff *
ieee80211_get_buffered_bc(struct net_device *dev, int bss_idx,
			  struct ieee80211_tx_control *control);

/* Low level drivers that have their own MLME and MAC indicate
 * the aid for an associating station with this call */
int ieee80211_set_aid_for_sta(struct net_device *dev, u8 *peer_address,
			      u16 aid);


/* Given an sk_buff with a raw 802.11 header at the data pointer this function
 * returns the 802.11 header length in bytes (not including encryption
 * headers). If the data in the sk_buff is too short to contain a valid 802.11
 * header the function returns 0.
 */
int ieee80211_get_hdrlen_from_skb(struct sk_buff *skb);

/* Like ieee80211_get_hdrlen_from_skb() but takes a FC in CPU order. */
int ieee80211_get_hdrlen(u16 fc);

/* Function for net interface operation. IEEE 802.11 may use multiple kernel
 * netdevices for each hardware device. The low-level driver does not "see"
 * these interfaces, so it should use this function to perform netif
 * operations on all interface. */
typedef enum {
	NETIF_ATTACH, NETIF_DETACH, NETIF_START, NETIF_STOP, NETIF_WAKE,
	NETIF_IS_STOPPED, NETIF_UPDATE_TX_START
} Netif_Oper;
int ieee80211_netif_oper(struct net_device *dev, Netif_Oper op);


/*
 * Function to get hardware configuration information
 * by the low level driver should it need it.
 */
struct ieee80211_conf *
ieee80211_get_hw_conf(struct net_device *dev);


/* Return a pointer to the low-level private data area for the given device. */
void * ieee80211_dev_hw_data(struct net_device *dev);
/* Return a pointer to network statistics data area for the given device. */
void * ieee80211_dev_stats(struct net_device *dev);

/* Function to indicate Radar Detection. The low level driver must call this
 * function to indicate the presence of radar in the current channel.
 * Additionally the radar type also could be sent */
int  ieee80211_radar_status(struct net_device *dev, int channel, int radar,
			    int radar_type);

/* Test modes */
enum {
	IEEE80211_TEST_DISABLE = 0 /* terminate testing */,
	IEEE80211_TEST_UNMASK_CHANNELS = 1 /* allow all channels to be used */,
	IEEE80211_TEST_CONTINUOUS_TX = 2,
};

/* Test parameters */
enum {
	/* TX power in hardware specific raw value */
	IEEE80211_TEST_PARAM_TX_POWER_RAW = 0,
	/* TX rate in hardware specific raw value */
	IEEE80211_TEST_PARAM_TX_RATE_RAW = 1,
	/* Continuous TX pattern (32-bit) */
	IEEE80211_TEST_PARAM_TX_PATTERN = 2,
	/* TX power in 0.1 dBm, 100 = 10 dBm */
	IEEE80211_TEST_PARAM_TX_POWER = 3,
	/* TX rate in 100 kbps, 540 = 54 Mbps */
	IEEE80211_TEST_PARAM_TX_RATE = 4,
	IEEE80211_TEST_PARAM_TX_ANT_SEL_RAW = 5,
};

/* ieee80211_tx_led called with state == 1 when the first frame is queued
 *   with state == 0 when the last frame is transmitted and tx queue is empty
 */
void ieee80211_tx_led(int state, struct net_device *dev);
/* ieee80211_rx_led is called each time frame is received, state is not used
 * (== 2)
 */
void ieee80211_rx_led(int state, struct net_device *dev);


/* IEEE 802.11 defines */

#define FCS_LEN 4

#define WLAN_FC_PVER		0x0003
#define WLAN_FC_TODS		0x0100
#define WLAN_FC_FROMDS		0x0200
#define WLAN_FC_MOREFRAG	0x0400
#define WLAN_FC_RETRY		0x0800
#define WLAN_FC_PWRMGT		0x1000
#define WLAN_FC_MOREDATA	0x2000
#define WLAN_FC_ISWEP		0x4000
#define WLAN_FC_ORDER		0x8000

#define WLAN_FC_GET_TYPE(fc)	(((fc) & 0x000c) >> 2)
#define WLAN_FC_GET_STYPE(fc)	(((fc) & 0x00f0) >> 4)

#define WLAN_GET_SEQ_FRAG(seq)	((seq) & 0x000f)
#define WLAN_GET_SEQ_SEQ(seq)	((seq) >> 4)

#define WLAN_FC_DATA_PRESENT(fc) (((fc) & 0x4c) == 0x08)

#define WLAN_FC_TYPE_MGMT	0
#define WLAN_FC_TYPE_CTRL	1
#define WLAN_FC_TYPE_DATA	2

/* management */
#define WLAN_FC_STYPE_ASSOC_REQ		0
#define WLAN_FC_STYPE_ASSOC_RESP	1
#define WLAN_FC_STYPE_REASSOC_REQ	2
#define WLAN_FC_STYPE_REASSOC_RESP	3
#define WLAN_FC_STYPE_PROBE_REQ		4
#define WLAN_FC_STYPE_PROBE_RESP	5
#define WLAN_FC_STYPE_BEACON		8
#define WLAN_FC_STYPE_ATIM		9
#define WLAN_FC_STYPE_DISASSOC		10
#define WLAN_FC_STYPE_AUTH		11
#define WLAN_FC_STYPE_DEAUTH		12
#define WLAN_FC_STYPE_ACTION		13

/* control */
#define WLAN_FC_STYPE_PSPOLL		10
#define WLAN_FC_STYPE_RTS		11
#define WLAN_FC_STYPE_CTS		12
#define WLAN_FC_STYPE_ACK		13
#define WLAN_FC_STYPE_CFEND		14
#define WLAN_FC_STYPE_CFENDACK		15

/* data */
#define WLAN_FC_STYPE_DATA		0
#define WLAN_FC_STYPE_DATA_CFACK	1
#define WLAN_FC_STYPE_DATA_CFPOLL	2
#define WLAN_FC_STYPE_DATA_CFACKPOLL	3
#define WLAN_FC_STYPE_NULLFUNC		4
#define WLAN_FC_STYPE_CFACK		5
#define WLAN_FC_STYPE_CFPOLL		6
#define WLAN_FC_STYPE_CFACKPOLL		7
#define WLAN_FC_STYPE_QOS_DATA		8
#define WLAN_FC_STYPE_QOS_DATA_CFACK	9
#define WLAN_FC_STYPE_QOS_DATA_CFPOLL	10
#define WLAN_FC_STYPE_QOS_DATA_CFACKPOLL 11
#define WLAN_FC_STYPE_QOS_NULLFUNC	12
#define WLAN_FC_STYPE_QOS_CFACK		13
#define WLAN_FC_STYPE_QOS_CFPOLL	14
#define WLAN_FC_STYPE_QOS_CFACKPOLL	15


#define IEEE80211_MAX_FRAG_THRESHOLD 2346
#define IEEE80211_MAX_RTS_THRESHOLD 2347

struct ieee80211_hdr {
	u16 frame_control;
	u16 duration_id;
	u8 addr1[6];
	u8 addr2[6];
	u8 addr3[6];
	u16 seq_ctrl;
	u8 addr4[6];
} __attribute__ ((packed));

/* return a pointer to the source address (SA) */
static inline u8 *ieee80211_get_SA(struct ieee80211_hdr *hdr)
{
	u8 *raw = (u8 *) hdr;
	u8 tofrom = (*(raw+1)) & 3; /* get the TODS and FROMDS bits */

	switch (tofrom) {
		case 2:
			return hdr->addr3;
		case 3:
			return hdr->addr4;
	}
	return hdr->addr2;
}

/* return a pointer to the destination address (DA) */
static inline u8 *ieee80211_get_DA(struct ieee80211_hdr *hdr)
{
	u8 *raw = (u8 *) hdr;
	u8 to_ds = (*(raw+1)) & 1; /* get the TODS bit */

	if (to_ds)
		return hdr->addr3;
	return hdr->addr1;
}

static inline int ieee80211_get_morefrag(struct ieee80211_hdr *hdr)
{
	return (le16_to_cpu(hdr->frame_control) & WLAN_FC_MOREFRAG) != 0;
}

#endif /* IEEE80211_H */