/* rt2x00.h
|
*
|
* Copyright (C) 2004 - 2005 rt2x00-2.0.0-b3 SourceForge Project
|
* <http://rt2x00.serialmonkey.com>
|
* 2006 rtnet adaption by Daniel Gregorek
|
* <dxg@gmx.de>
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* 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.,
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
|
/*
|
Module: rt2x00
|
Abstract: rt2x00 global information.
|
Supported chipsets: RT2560
|
*/
|
|
#ifndef RT2X00_H
|
#define RT2X00_H
|
|
#include <linux/netdevice.h>
|
#include <linux/wireless.h>
|
|
#include <rtnet_port.h>
|
#include <rtwlan.h>
|
|
#define MAX_UNITS 2
|
|
/*
|
* Module information.
|
*/
|
#define DRV_NAME "rt2x00"
|
#define DRV_VERSION "0.1"
|
#define DRV_AUTHOR "Daniel Gregorek <dxg@gmx.de>"
|
//#define CONFIG_RT2X00_DEBUG
|
|
/*
|
* Debug defines.
|
* The debug variable will be exported by the device specific module.
|
* For this reason this variable must be set to extern to make it accessible
|
* to the core module as well.
|
*/
|
#ifdef CONFIG_RT2X00_DEBUG
|
extern int rt2x00_debug_level;
|
#define DEBUG_PRINTK(__message...) \
|
do { \
|
rtdm_printk(__message); \
|
} while (0)
|
#else /* CONFIG_RT2X00_DEBUG */
|
#define DEBUG_PRINTK(__message...) \
|
do { \
|
} while (0)
|
#endif /* CONFIG_RT2X00_DEBUG */
|
|
/*
|
* Various debug levels.
|
* PANIC and ERROR indicates serious problems within the module,
|
* these should never be ignored and thus we will always print the message.
|
*/
|
#define PANIC(__message, __args...) \
|
rtdm_printk(KERN_PANIC DRV_NAME "->%s: Panic - " __message, \
|
__FUNCTION__, ##__args);
|
#define ERROR(__message, __args...) \
|
rtdm_printk(KERN_ERR DRV_NAME "->%s: Error - " __message, \
|
__FUNCTION__, ##__args);
|
#define WARNING(__message, __args...) \
|
rtdm_printk(KERN_WARNING DRV_NAME "->%s: Warning - " __message, \
|
__FUNCTION__, ##__args);
|
#define NOTICE(__message, __args...) \
|
rtdm_printk(KERN_NOTICE DRV_NAME "->%s: Notice - " __message, \
|
__FUNCTION__, ##__args);
|
#define INFO(__message, __args...) \
|
rtdm_printk(KERN_INFO DRV_NAME "->%s: Info - " __message, \
|
__FUNCTION__, ##__args);
|
#define DEBUG(__message, __args...) \
|
DEBUG_PRINTK(KERN_DEBUG DRV_NAME "->%s: Debug - " __message, \
|
__FUNCTION__, ##__args);
|
|
/*
|
* RT2x00 ring types.
|
*/
|
|
/*
|
* Ring names.
|
*/
|
#define RING_RX 0x01 /* Ring used for receiving packets. */
|
#define RING_TX 0x02 /* Ring used for transmitting normal packets. */
|
|
/*
|
* Ring sizes.
|
*/
|
#define DATA_FRAME_SIZE 2432
|
#define MGMT_FRAME_SIZE 256
|
|
/*
|
* RT2x00 xmit flags.
|
*/
|
#define XMIT_IFS_SIFS 0x0001
|
#define XMIT_IFS_BACKOFF 0x0002
|
#define XMIT_IFS_NEW_BACKOFF 0x0004
|
#define XMIT_IFS_NONE 0x0008
|
#define XMIT_NEW_SEQUENCE 0x0010
|
#define XMIT_ACK 0x0020
|
#define XMIT_TIMESTAMP 0x0040
|
#define XMIT_RTS 0x0080
|
#define XMIT_OFDM 0x0100
|
#define XMIT_LONG_RETRY 0x0200
|
#define XMIT_MORE_FRAGS 0x0400
|
#define XMIT_SHORT_PREAMBLE 0x0800
|
#define XMIT_START 0x1000
|
|
/*
|
* RT2x00 Statistics flags.
|
*/
|
#define STATS_TX_RESULT 0x01
|
#define STATS_TX_RETRY_COUNT 0x02
|
#define STATS_RX_CRC 0x10
|
#define STATS_RX_PHYSICAL 0x20
|
#define STATS_RX_QUALITY 0x40
|
#define STATS_RX_DROP 0x80
|
|
/*
|
* TX result flags.
|
*/
|
#define TX_SUCCESS 0
|
#define TX_SUCCESS_RETRY 1
|
#define TX_FAIL_RETRY 2
|
#define TX_FAIL_INVALID 3
|
#define TX_FAIL_OTHER 4
|
|
/*
|
* Channel type defines.
|
*/
|
#define CHANNEL_OFDM 0x01
|
#define CHANNEL_UNII_LOW 0x02
|
#define CHANNEL_HIPERLAN2 0x04
|
#define CHANNEL_UNII_HIGH 0x08
|
|
#define CHANNEL_OFDM_MIN 1
|
#define CHANNEL_OFDM_MAX 14
|
#define CHANNEL_UNII_LOW_MIN 36
|
#define CHANNEL_UNII_LOW_MAX 64
|
#define CHANNEL_HIPERLAN2_MIN 100
|
#define CHANNEL_HIPERLAN2_MAX 140
|
#define CHANNEL_UNII_HIGH_MIN 149
|
#define CHANNEL_UNII_HIGH_MAX 161
|
|
/*
|
* Device 802.11abg capabilities.
|
*/
|
static struct _rt2x00_capabilities {
|
u8 txpower[6];
|
u8 bitrate[12];
|
} __attribute__ ((packed)) capabilities = {
|
/*
|
* tx-power.
|
*/
|
.txpower = {
|
3, 12, 25, 50, 75, 100,
|
},
|
|
/*
|
* Bitrates
|
*/
|
.bitrate = {
|
2, 4, 11, 22, /* CCK. */
|
12, 18, 24, 36, 48, 72, 96, 108, /* OFDM. */
|
},
|
};
|
|
struct _rt2x00_config {
|
u8 config_flags;
|
#define CONFIG_DROP_BCAST 0x0001
|
#define CONFIG_DROP_MCAST 0x0002
|
#define CONFIG_AUTORESP 0x0004
|
|
u8 antenna_tx;
|
u8 antenna_rx;
|
|
u8 bssid[ETH_ALEN];
|
u8 short_retry;
|
u8 long_retry;
|
|
u8 channel;
|
u8 bitrate; /* 0.5Mbit/sec */
|
u8 txpower; /* % */
|
|
u8 bbpsens;
|
|
/*
|
* LED status
|
*/
|
u8 led_status;
|
|
u16 __pad2; /* For alignment only. */
|
|
/*
|
* Duration values in us.
|
*/
|
u8 plcp;
|
u8 sifs;
|
u8 slot_time;
|
|
/*
|
* Configuration values that have to be updated to device.
|
*/
|
u16 update_flags;
|
#define UPDATE_ALL_CONFIG 0xffff
|
#define UPDATE_BSSID 0x0001
|
#define UPDATE_PACKET_FILTER 0x0002
|
#define UPDATE_CHANNEL 0x0004
|
#define UPDATE_BITRATE 0x0008
|
#define UPDATE_RETRY 0x0010
|
#define UPDATE_TXPOWER 0x0020
|
#define UPDATE_ANTENNA 0x0040
|
#define UPDATE_DURATION 0x0080
|
#define UPDATE_PREAMBLE 0x0100
|
#define UPDATE_AUTORESP 0x0200
|
#define UPDATE_LED_STATUS 0x0400
|
#define UPDATE_BBPSENS 0x0800
|
|
} __attribute__((packed));
|
|
struct _rt2x00_core {
|
/*
|
* RT2x00 device status flags (atomic read/write access).
|
*/
|
unsigned long flags;
|
|
#define DEVICE_ENABLED 0 /* Device has been opened. */
|
#define DEVICE_AWAKE 1 /* Device is not suspended. */
|
#define DEVICE_RADIO_ON 2 /* Device antenna is enabled. */
|
#define DEVICE_CONFIG_UPDATE 3 /* Device is updating configuration. */
|
|
/*
|
* Device handler.
|
*/
|
struct _rt2x00_dev_handler *handler;
|
|
/*
|
* RTnet device we belong to.
|
*/
|
struct rtnet_device *rtnet_dev;
|
|
/*
|
* RTwlan stack structure.
|
*/
|
struct rtwlan_device *rtwlan_dev;
|
|
/*
|
* Device configuration.
|
*/
|
struct _rt2x00_config config;
|
|
void *priv;
|
|
} __attribute__((packed));
|
|
/*
|
* Device specific handlers.
|
*/
|
struct _rt2x00_dev_handler {
|
/*
|
* Device specific module.
|
*/
|
struct module *dev_module;
|
|
/*
|
* Initialization handlers.
|
*/
|
int (*dev_probe)(struct _rt2x00_core *core, void *priv);
|
int (*dev_remove)(struct _rt2x00_core *core);
|
|
/*
|
* Radio control.
|
*/
|
int (*dev_radio_on)(struct _rt2x00_core *core);
|
int (*dev_radio_off)(struct _rt2x00_core *core);
|
|
/*
|
* Configuration handlers.
|
*/
|
int (*dev_update_config)(struct _rt2x00_core *core, u16 update_flags);
|
|
/*
|
* xmit handler.
|
*/
|
int (*dev_xmit_packet)(struct _rt2x00_core *core, struct rtskb *rtskb,
|
u16 rate, u16 xmit_flags);
|
|
/*
|
* Handler for direct access to register from core.
|
*/
|
int (*dev_register_access)(struct _rt2x00_core *core, int request,
|
u32 address, u32 *value);
|
|
} __attribute__((packed));
|
|
static inline void *rt2x00_priv(const struct _rt2x00_core *core)
|
{
|
return core->priv;
|
}
|
|
/*
|
* Duration calculations
|
* The rate variable passed is: 2 * real_rate (in Mb/s).
|
* Therefore length has to be multiplied with 8 to convert bytes to bits and mulltiply the length
|
* with 2 to compensate for the difference between real_rate and the rate variable.
|
*/
|
#define ACK_SIZE 14
|
#define IEEE80211_HEADER 24
|
|
static inline u16 get_duration(const unsigned int size, const u8 rate)
|
{
|
return ((size * 8 * 2) / rate);
|
}
|
|
static inline u16 get_duration_res(const unsigned int size, const u8 rate)
|
{
|
return ((size * 8 * 2) % rate);
|
}
|
|
static inline u16 get_preamble(const struct _rt2x00_config *config)
|
{
|
return 144;
|
}
|
|
/*
|
* Register handlers.
|
* We store the position of a register field inside a field structure,
|
* This will simplify the process of setting and reading a certain field
|
* inside the register.
|
*/
|
struct _rt2x00_field16 {
|
u16 bit_offset;
|
u16 bit_mask;
|
} __attribute__((packed));
|
|
struct _rt2x00_field32 {
|
u32 bit_offset;
|
u32 bit_mask;
|
} __attribute__((packed));
|
|
#define FIELD16(__offset, __mask) \
|
((struct _rt2x00_field16){ (__offset), (__mask) })
|
#define FIELD32(__offset, __mask) \
|
((struct _rt2x00_field32){ (__offset), (__mask) })
|
|
static inline void rt2x00_set_field32(u32 *reg,
|
const struct _rt2x00_field32 field,
|
const u32 value)
|
{
|
*reg &= cpu_to_le32(~(field.bit_mask));
|
*reg |= cpu_to_le32((value << field.bit_offset) & field.bit_mask);
|
}
|
|
static inline void rt2x00_set_field32_nb(u32 *reg,
|
const struct _rt2x00_field32 field,
|
const u32 value)
|
{
|
*reg &= ~(field.bit_mask);
|
*reg |= (value << field.bit_offset) & field.bit_mask;
|
}
|
|
static inline u32 rt2x00_get_field32(const u32 reg,
|
const struct _rt2x00_field32 field)
|
{
|
return (le32_to_cpu(reg) & field.bit_mask) >> field.bit_offset;
|
}
|
|
static inline u32 rt2x00_get_field32_nb(const u32 reg,
|
const struct _rt2x00_field32 field)
|
{
|
return (reg & field.bit_mask) >> field.bit_offset;
|
}
|
|
static inline void rt2x00_set_field16(u16 *reg,
|
const struct _rt2x00_field16 field,
|
const u16 value)
|
{
|
*reg &= cpu_to_le16(~(field.bit_mask));
|
*reg |= cpu_to_le16((value << field.bit_offset) & field.bit_mask);
|
}
|
|
static inline void rt2x00_set_field16_nb(u16 *reg,
|
const struct _rt2x00_field16 field,
|
const u16 value)
|
{
|
*reg &= ~(field.bit_mask);
|
*reg |= (value << field.bit_offset) & field.bit_mask;
|
}
|
|
static inline u16 rt2x00_get_field16(const u16 reg,
|
const struct _rt2x00_field16 field)
|
{
|
return (le16_to_cpu(reg) & field.bit_mask) >> field.bit_offset;
|
}
|
|
static inline u16 rt2x00_get_field16_nb(const u16 reg,
|
const struct _rt2x00_field16 field)
|
{
|
return (reg & field.bit_mask) >> field.bit_offset;
|
}
|
|
/*
|
* rf register sructure for channel selection.
|
*/
|
struct _rf_channel {
|
u32 rf1;
|
u32 rf2;
|
u32 rf3;
|
u32 rf4;
|
} __attribute__((packed));
|
|
/*
|
* Chipset identification
|
* The chipset on the device is composed of a RT and RF chip.
|
* The chipset combination is important for determining device capabilities.
|
*/
|
struct _rt2x00_chip {
|
u16 rt;
|
u16 rf;
|
} __attribute__((packed));
|
|
/*
|
* Set chipset data.
|
* Some rf values for RT2400 devices are equal to rf values for RT2500 devices.
|
* To prevent problems, all rf values will be masked to clearly seperate each chipset.
|
*/
|
static inline void set_chip(struct _rt2x00_chip *chipset, const u16 rt,
|
const u16 rf)
|
{
|
INFO("Chipset detected - rt: %04x, rf: %04x.\n", rt, rf);
|
|
chipset->rt = rt;
|
chipset->rf = rf | (chipset->rt & 0xff00);
|
}
|
|
static inline char rt2x00_rt(const struct _rt2x00_chip *chipset, const u16 chip)
|
{
|
return (chipset->rt == chip);
|
}
|
|
static inline char rt2x00_rf(const struct _rt2x00_chip *chipset, const u16 chip)
|
{
|
return (chipset->rf == chip);
|
}
|
|
static inline u16 rt2x00_get_rf(const struct _rt2x00_chip *chipset)
|
{
|
return chipset->rf;
|
}
|
|
/*
|
* _data_ring
|
* Data rings are used by the device to send and receive packets.
|
* The data_addr is the base address of the data memory.
|
* Device specifice information is pointed to by the priv pointer.
|
* The index values may only be changed with the functions ring_index_inc()
|
* and ring_index_done_inc().
|
*/
|
struct _data_ring {
|
/*
|
* Base address of packet ring.
|
*/
|
dma_addr_t data_dma;
|
void *data_addr;
|
|
/*
|
* Private device specific data.
|
*/
|
void *priv;
|
struct _rt2x00_core *core;
|
|
/*
|
* Current index values.
|
*/
|
u8 index;
|
u8 index_done;
|
|
/*
|
* Ring type set with RING_* define.
|
*/
|
u8 ring_type;
|
|
/*
|
* Number of entries in this ring.
|
*/
|
u8 max_entries;
|
|
/*
|
* Size of packet and descriptor in bytes.
|
*/
|
u16 entry_size;
|
u16 desc_size;
|
|
/*
|
* Total allocated memory size.
|
*/
|
u32 mem_size;
|
} __attribute__((packed));
|
|
/*
|
* Number of entries in a packet ring.
|
*/
|
#define RX_ENTRIES 8
|
#define TX_ENTRIES 8
|
#define ATIM_ENTRIES 1
|
#define PRIO_ENTRIES 2
|
#define BEACON_ENTRIES 1
|
|
/*
|
* Initialization and cleanup routines.
|
*/
|
static inline void rt2x00_init_ring(struct _rt2x00_core *core,
|
struct _data_ring *ring, const u8 ring_type,
|
const u16 max_entries, const u16 entry_size,
|
const u16 desc_size)
|
{
|
ring->core = core;
|
ring->index = 0;
|
ring->index_done = 0;
|
ring->ring_type = ring_type;
|
ring->max_entries = max_entries;
|
ring->entry_size = entry_size;
|
ring->desc_size = desc_size;
|
ring->mem_size =
|
ring->max_entries * (ring->desc_size + ring->entry_size);
|
}
|
|
static inline void rt2x00_deinit_ring(struct _data_ring *ring)
|
{
|
ring->core = NULL;
|
ring->index = 0;
|
ring->index_done = 0;
|
ring->ring_type = 0;
|
ring->max_entries = 0;
|
ring->entry_size = 0;
|
ring->desc_size = 0;
|
ring->mem_size = 0;
|
}
|
|
/*
|
* Ring index manipulation functions.
|
*/
|
static inline void rt2x00_ring_index_inc(struct _data_ring *ring)
|
{
|
ring->index = (++ring->index < ring->max_entries) ? ring->index : 0;
|
}
|
|
static inline void rt2x00_ring_index_done_inc(struct _data_ring *ring)
|
{
|
ring->index_done =
|
(++ring->index_done < ring->max_entries) ? ring->index_done : 0;
|
}
|
|
static inline void rt2x00_ring_clear_index(struct _data_ring *ring)
|
{
|
ring->index = 0;
|
ring->index_done = 0;
|
}
|
|
static inline u8 rt2x00_ring_empty(struct _data_ring *ring)
|
{
|
return ring->index_done == ring->index;
|
}
|
|
static inline u8 rt2x00_ring_free_entries(struct _data_ring *ring)
|
{
|
if (ring->index >= ring->index_done)
|
return ring->max_entries - (ring->index - ring->index_done);
|
else
|
return ring->index_done - ring->index;
|
}
|
|
/*
|
* Return PLCP value matching the rate.
|
* PLCP values according to ieee802.11a-1999 p.14.
|
*/
|
static inline u8 rt2x00_get_plcp(const u8 rate)
|
{
|
u8 counter = 0x00;
|
u8 plcp[12] = {
|
0x00, 0x01, 0x02, 0x03, /* CCK. */
|
0x0b, 0x0f, 0x0a, 0x0e, 0x09, 0x0d, 0x08, 0x0c, /* OFDM. */
|
};
|
|
for (; counter < 12; counter++) {
|
if (capabilities.bitrate[counter] == rate)
|
return plcp[counter];
|
}
|
|
return 0xff;
|
}
|
|
#define OFDM_CHANNEL(__channel) \
|
((__channel) >= CHANNEL_OFDM_MIN && (__channel) <= CHANNEL_OFDM_MAX)
|
#define UNII_LOW_CHANNEL(__channel) \
|
((__channel) >= CHANNEL_UNII_LOW_MIN && \
|
(__channel) <= CHANNEL_UNII_LOW_MAX)
|
#define HIPERLAN2_CHANNEL(__channel) \
|
((__channel) >= CHANNEL_HIPERLAN2_MIN && \
|
(__channel) <= CHANNEL_HIPERLAN2_MAX)
|
#define UNII_HIGH_CHANNEL(__channel) \
|
((__channel) >= CHANNEL_UNII_HIGH_MIN && \
|
(__channel) <= CHANNEL_UNII_HIGH_MAX)
|
|
/*
|
* Return the index value of the channel starting from the first channel of the range.
|
* Where range can be OFDM, UNII (low), HiperLAN2 or UNII (high).
|
*/
|
static inline int rt2x00_get_channel_index(const u8 channel)
|
{
|
if (OFDM_CHANNEL(channel))
|
return (channel - 1);
|
|
if (channel % 4)
|
return -EINVAL;
|
|
if (UNII_LOW_CHANNEL(channel))
|
return ((channel - CHANNEL_UNII_LOW_MIN) / 4);
|
else if (HIPERLAN2_CHANNEL(channel))
|
return ((channel - CHANNEL_HIPERLAN2_MIN) / 4);
|
else if (UNII_HIGH_CHANNEL(channel))
|
return ((channel - CHANNEL_UNII_HIGH_MIN) / 4);
|
return -EINVAL;
|
}
|
|
/*
|
* RT2x00 core module functions that can be used in the device specific modules.
|
*/
|
extern struct rtnet_device *
|
rt2x00_core_probe(struct _rt2x00_dev_handler *handler, void *priv,
|
u32 sizeof_dev);
|
extern void rt2x00_core_remove(struct rtnet_device *rtnet_dev);
|
|
#endif
|
