d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
be4c9e4b3b
freebsd-skq/sys/net80211/ieee80211_phy.c
sam 84c4dbca4f Update PLCP<->rate mapping support: 
o correct mapping of CCK rates to PLCP; was using nonstandard Ralink
  values which just happened to also be used by Zydas (so went unnoticed)
o change ieee80211_plcp2rate api to take a phy type instead of a flag
  that indicates ofdm/!ofdm
o update drivers to match (restore per-driver code to map rate->PLCP)

Reviewed by:	sephe, weongyo, thompsa
2008-05-12 00:32:52 +00:00

478 lines
15 KiB
C
Raw Blame History

/*-
* Copyright (c) 2007-2008 Sam Leffler, Errno Consulting
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
/*
* IEEE 802.11 PHY-related support.
*/
#include "opt_inet.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/socket.h>
#include <net/if.h>
#include <net/if_media.h>
#include <net80211/ieee80211_var.h>
#include <net80211/ieee80211_phy.h>
#ifdef notyet
struct ieee80211_ds_plcp_hdr {
uint8_t i_signal;
uint8_t i_service;
uint16_t i_length;
uint16_t i_crc;
} __packed;
#endif /* notyet */
/* shorthands to compact tables for readability */
#define OFDM IEEE80211_T_OFDM
#define CCK IEEE80211_T_CCK
#define TURBO IEEE80211_T_TURBO
#define PBCC (IEEE80211_T_HT+1) /* XXX */
static struct ieee80211_rate_table ieee80211_11b_table = {
4, /* number of rates, XXX no PBCC */
{ 0 },
{
/* short ctrl */
/* Preamble dot11Rate Rate */
/* 1 Mb */ { CCK, 1000, 0x00, (0x80| 2), 0 },
/* 2 Mb */ { CCK, 2000, 0x04, (0x80| 4), 1 },
/* 5.5 Mb */ { CCK, 5500, 0x04, (0x80|11), 1 },
/* 11 Mb */ { CCK, 11000, 0x04, (0x80|22), 1 },
/* 22 Mb */ { PBCC, 22000, 0x04, 44, 3 }
},
};
static struct ieee80211_rate_table ieee80211_11g_table = {
12, /* number of rates */
{ 0 },
{
/* short ctrl */
/* Preamble dot11Rate Rate */
/* 1 Mb */ { CCK, 1000, 0x00, (0x80| 2), 0 },
/* 2 Mb */ { CCK, 2000, 0x04, (0x80| 4), 1 },
/* 5.5 Mb */ { CCK, 5500, 0x04, (0x80|11), 2 },
/* 11 Mb */ { CCK, 11000, 0x04, (0x80|22), 3 },
/* 6 Mb */ { OFDM, 6000, 0x00, 12, 4 },
/* 9 Mb */ { OFDM, 9000, 0x00, 18, 4 },
/* 12 Mb */ { OFDM, 12000, 0x00, 24, 6 },
/* 18 Mb */ { OFDM, 18000, 0x00, 36, 6 },
/* 24 Mb */ { OFDM, 24000, 0x00, 48, 8 },
/* 36 Mb */ { OFDM, 36000, 0x00, 72, 8 },
/* 48 Mb */ { OFDM, 48000, 0x00, 96, 8 },
/* 54 Mb */ { OFDM, 54000, 0x00, 108, 8 }
},
};
static struct ieee80211_rate_table ieee80211_11a_table = {
8, /* number of rates */
{ 0 },
{
/* short ctrl */
/* Preamble dot11Rate Rate */
/* 6 Mb */ { OFDM, 6000, 0x00, (0x80|12), 0 },
/* 9 Mb */ { OFDM, 9000, 0x00, 18, 0 },
/* 12 Mb */ { OFDM, 12000, 0x00, (0x80|24), 2 },
/* 18 Mb */ { OFDM, 18000, 0x00, 36, 2 },
/* 24 Mb */ { OFDM, 24000, 0x00, (0x80|48), 4 },
/* 36 Mb */ { OFDM, 36000, 0x00, 72, 4 },
/* 48 Mb */ { OFDM, 48000, 0x00, 96, 4 },
/* 54 Mb */ { OFDM, 54000, 0x00, 108, 4 }
},
};
static struct ieee80211_rate_table ieee80211_half_table = {
8, /* number of rates */
{ 0 },
{
/* short ctrl */
/* Preamble dot11Rate Rate */
/* 6 Mb */ { OFDM, 3000, 0x00, (0x80| 6), 0 },
/* 9 Mb */ { OFDM, 4500, 0x00, 9, 0 },
/* 12 Mb */ { OFDM, 6000, 0x00, (0x80|12), 2 },
/* 18 Mb */ { OFDM, 9000, 0x00, 18, 2 },
/* 24 Mb */ { OFDM, 12000, 0x00, (0x80|24), 4 },
/* 36 Mb */ { OFDM, 18000, 0x00, 36, 4 },
/* 48 Mb */ { OFDM, 24000, 0x00, 48, 4 },
/* 54 Mb */ { OFDM, 27000, 0x00, 54, 4 }
},
};
static struct ieee80211_rate_table ieee80211_quarter_table = {
8, /* number of rates */
{ 0 },
{
/* short ctrl */
/* Preamble dot11Rate Rate */
/* 6 Mb */ { OFDM, 1500, 0x00, (0x80| 3), 0 },
/* 9 Mb */ { OFDM, 2250, 0x00, 4, 0 },
/* 12 Mb */ { OFDM, 3000, 0x00, (0x80| 6), 2 },
/* 18 Mb */ { OFDM, 4500, 0x00, 9, 2 },
/* 24 Mb */ { OFDM, 6000, 0x00, (0x80|12), 4 },
/* 36 Mb */ { OFDM, 9000, 0x00, 18, 4 },
/* 48 Mb */ { OFDM, 12000, 0x00, 24, 4 },
/* 54 Mb */ { OFDM, 13500, 0x00, 27, 4 }
},
};
static struct ieee80211_rate_table ieee80211_turbog_table = {
7, /* number of rates */
{ 0 },
{
/* short ctrl */
/* Preamble dot11Rate Rate */
/* 6 Mb */ { TURBO, 6000, 0x00, (0x80|12), 0 },
/* 12 Mb */ { TURBO, 12000, 0x00, (0x80|24), 1 },
/* 18 Mb */ { TURBO, 18000, 0x00, 36, 1 },
/* 24 Mb */ { TURBO, 24000, 0x00, (0x80|48), 3 },
/* 36 Mb */ { TURBO, 36000, 0x00, 72, 3 },
/* 48 Mb */ { TURBO, 48000, 0x00, 96, 3 },
/* 54 Mb */ { TURBO, 54000, 0x00, 108, 3 }
},
};
static struct ieee80211_rate_table ieee80211_turboa_table = {
8, /* number of rates */
{ 0 },
{
/* short ctrl */
/* Preamble dot11Rate Rate */
/* 6 Mb */ { TURBO, 6000, 0x00, (0x80|12), 0 },
/* 9 Mb */ { TURBO, 9000, 0x00, 18, 0 },
/* 12 Mb */ { TURBO, 12000, 0x00, (0x80|24), 2 },
/* 18 Mb */ { TURBO, 18000, 0x00, 36, 2 },
/* 24 Mb */ { TURBO, 24000, 0x00, (0x80|48), 4 },
/* 36 Mb */ { TURBO, 36000, 0x00, 72, 4 },
/* 48 Mb */ { TURBO, 48000, 0x00, 96, 4 },
/* 54 Mb */ { TURBO, 54000, 0x00, 108, 4 }
},
};
#undef OFDM
#undef CCK
#undef TURBO
#undef XR
/*
* Setup a rate table's reverse lookup table and fill in
* ack durations. The reverse lookup tables are assumed
* to be initialized to zero (or at least the first entry).
* We use this as a key that indicates whether or not
* we've previously setup the reverse lookup table.
*
* XXX not reentrant, but shouldn't matter
*/
static void
ieee80211_setup_ratetable(struct ieee80211_rate_table *rt)
{
#define N(a) (sizeof(a)/sizeof(a[0]))
#define WLAN_CTRL_FRAME_SIZE \
(sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN)
int i;
for (i = 0; i < N(rt->rateCodeToIndex); i++)
rt->rateCodeToIndex[i] = (uint8_t) -1;
for (i = 0; i < rt->rateCount; i++) {
uint8_t code = rt->info[i].dot11Rate;
uint8_t cix = rt->info[i].ctlRateIndex;
uint8_t ctl_rate = rt->info[cix].dot11Rate;
rt->rateCodeToIndex[code] = i;
if (code & IEEE80211_RATE_BASIC) {
/*
* Map w/o basic rate bit too.
*/
code &= IEEE80211_RATE_VAL;
rt->rateCodeToIndex[code] = i;
}
/*
* XXX for 11g the control rate to use for 5.5 and 11 Mb/s
* depends on whether they are marked as basic rates;
* the static tables are setup with an 11b-compatible
* 2Mb/s rate which will work but is suboptimal
*
* NB: Control rate is always less than or equal to the
* current rate, so control rate's reverse lookup entry
* has been installed and following call is safe.
*/
rt->info[i].lpAckDuration = ieee80211_compute_duration(rt,
WLAN_CTRL_FRAME_SIZE, ctl_rate, 0);
rt->info[i].spAckDuration = ieee80211_compute_duration(rt,
WLAN_CTRL_FRAME_SIZE, ctl_rate, IEEE80211_F_SHPREAMBLE);
}
#undef WLAN_CTRL_FRAME_SIZE
#undef N
}
/* Setup all rate tables */
static void
ieee80211_phy_init(void)
{
#define N(arr) (int)(sizeof(arr) / sizeof(arr[0]))
static struct ieee80211_rate_table * const ratetables[] = {
&ieee80211_half_table,
&ieee80211_quarter_table,
&ieee80211_11a_table,
&ieee80211_11g_table,
&ieee80211_turbog_table,
&ieee80211_turboa_table,
&ieee80211_turboa_table,
&ieee80211_11a_table,
&ieee80211_11g_table,
&ieee80211_11b_table
};
int i;
for (i = 0; i < N(ratetables); ++i)
ieee80211_setup_ratetable(ratetables[i]);
#undef N
}
SYSINIT(wlan_phy, SI_SUB_DRIVERS, SI_ORDER_FIRST, ieee80211_phy_init, NULL);
const struct ieee80211_rate_table *
ieee80211_get_ratetable(struct ieee80211_channel *c)
{
const struct ieee80211_rate_table *rt;
/* XXX HT */
if (IEEE80211_IS_CHAN_HALF(c))
rt = &ieee80211_half_table;
else if (IEEE80211_IS_CHAN_QUARTER(c))
rt = &ieee80211_quarter_table;
else if (IEEE80211_IS_CHAN_HTA(c))
rt = &ieee80211_11a_table; /* XXX */
else if (IEEE80211_IS_CHAN_HTG(c))
rt = &ieee80211_11g_table; /* XXX */
else if (IEEE80211_IS_CHAN_108G(c))
rt = &ieee80211_turbog_table;
else if (IEEE80211_IS_CHAN_ST(c))
rt = &ieee80211_turboa_table;
else if (IEEE80211_IS_CHAN_TURBO(c))
rt = &ieee80211_turboa_table;
else if (IEEE80211_IS_CHAN_A(c))
rt = &ieee80211_11a_table;
else if (IEEE80211_IS_CHAN_ANYG(c))
rt = &ieee80211_11g_table;
else if (IEEE80211_IS_CHAN_B(c))
rt = &ieee80211_11b_table;
else {
/* NB: should not get here */
panic("%s: no rate table for channel; freq %u flags 0x%x\n",
__func__, c->ic_freq, c->ic_flags);
}
return rt;
}
/*
* Convert PLCP signal/rate field to 802.11 rate (.5Mbits/s)
*
* Note we do no parameter checking; this routine is mainly
* used to derive an 802.11 rate for constructing radiotap
* header data for rx frames.
*
* XXX might be a candidate for inline
*/
uint8_t
ieee80211_plcp2rate(uint8_t plcp, enum ieee80211_phytype type)
{
if (type == IEEE80211_T_OFDM) {
static const uint8_t ofdm_plcp2rate[16] = {
[0xb] = 12,
[0xf] = 18,
[0xa] = 24,
[0xe] = 36,
[0x9] = 48,
[0xd] = 72,
[0x8] = 96,
[0xc] = 108
};
return ofdm_plcp2rate[plcp & 0xf];
}
if (type == IEEE80211_T_CCK) {
static const uint8_t cck_plcp2rate[16] = {
[0xa] = 2, /* 0x0a */
[0x4] = 4, /* 0x14 */
[0x7] = 11, /* 0x37 */
[0xe] = 22, /* 0x6e */
[0xc] = 44, /* 0xdc , actually PBCC */
};
return cck_plcp2rate[plcp & 0xf];
}
return 0;
}
/*
* Covert 802.11 rate to PLCP signal.
*/
uint8_t
ieee80211_rate2plcp(int rate, enum ieee80211_phytype type)
{
/* XXX ignore type for now since rates are unique */
switch (rate) {
/* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
case 12: return 0xb;
case 18: return 0xf;
case 24: return 0xa;
case 36: return 0xe;
case 48: return 0x9;
case 72: return 0xd;
case 96: return 0x8;
case 108: return 0xc;
/* CCK rates (IEEE Std 802.11b-1999 page 15, subclause 18.2.3.3) */
case 2: return 10;
case 4: return 20;
case 11: return 55;
case 22: return 110;
/* IEEE Std 802.11g-2003 page 19, subclause 19.3.2.1 */
case 44: return 220;
}
return 0; /* XXX unsupported/unknown rate */
}
/*
* Compute the time to transmit a frame of length frameLen bytes
* using the specified rate, phy, and short preamble setting.
* SIFS is included.
*/
uint16_t
ieee80211_compute_duration(const struct ieee80211_rate_table *rt,
uint32_t frameLen, uint16_t rate, int isShortPreamble)
{
uint8_t rix = rt->rateCodeToIndex[rate];
uint32_t bitsPerSymbol, numBits, numSymbols, phyTime, txTime;
uint32_t kbps;
KASSERT(rix != (uint8_t)-1, ("rate %d has no info", rate));
kbps = rt->info[rix].rateKbps;
if (kbps == 0) /* XXX bandaid for channel changes */
return 0;
switch (rt->info[rix].phy) {
case IEEE80211_T_CCK:
#define CCK_SIFS_TIME 10
#define CCK_PREAMBLE_BITS 144
#define CCK_PLCP_BITS 48
phyTime = CCK_PREAMBLE_BITS + CCK_PLCP_BITS;
if (isShortPreamble && rt->info[rix].shortPreamble)
phyTime >>= 1;
numBits = frameLen << 3;
txTime = CCK_SIFS_TIME + phyTime
+ ((numBits * 1000)/kbps);
break;
#undef CCK_SIFS_TIME
#undef CCK_PREAMBLE_BITS
#undef CCK_PLCP_BITS
case IEEE80211_T_OFDM:
#define OFDM_SIFS_TIME 16
#define OFDM_PREAMBLE_TIME 20
#define OFDM_PLCP_BITS 22
#define OFDM_SYMBOL_TIME 4
#define OFDM_SIFS_TIME_HALF 32
#define OFDM_PREAMBLE_TIME_HALF 40
#define OFDM_PLCP_BITS_HALF 22
#define OFDM_SYMBOL_TIME_HALF 8
#define OFDM_SIFS_TIME_QUARTER 64
#define OFDM_PREAMBLE_TIME_QUARTER 80
#define OFDM_PLCP_BITS_QUARTER 22
#define OFDM_SYMBOL_TIME_QUARTER 16
if (rt == &ieee80211_half_table) {
bitsPerSymbol = (kbps * OFDM_SYMBOL_TIME_QUARTER) / 1000;
KASSERT(bitsPerSymbol != 0, ("1/2 rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_SIFS_TIME_QUARTER
+ OFDM_PREAMBLE_TIME_QUARTER
+ (numSymbols * OFDM_SYMBOL_TIME_QUARTER);
} else if (rt == &ieee80211_quarter_table) {
bitsPerSymbol = (kbps * OFDM_SYMBOL_TIME_HALF) / 1000;
KASSERT(bitsPerSymbol != 0, ("1/4 rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_SIFS_TIME_HALF
+ OFDM_PREAMBLE_TIME_HALF
+ (numSymbols * OFDM_SYMBOL_TIME_HALF);
} else { /* full rate channel */
bitsPerSymbol = (kbps * OFDM_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("full rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_SIFS_TIME
+ OFDM_PREAMBLE_TIME
+ (numSymbols * OFDM_SYMBOL_TIME);
}
break;
#undef OFDM_SIFS_TIME
#undef OFDM_PREAMBLE_TIME
#undef OFDM_PLCP_BITS
#undef OFDM_SYMBOL_TIME
case IEEE80211_T_TURBO:
#define TURBO_SIFS_TIME 8
#define TURBO_PREAMBLE_TIME 14
#define TURBO_PLCP_BITS 22
#define TURBO_SYMBOL_TIME 4
/* we still save OFDM rates in kbps - so double them */
bitsPerSymbol = ((kbps << 1) * TURBO_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("turbo bps"));
numBits = TURBO_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = TURBO_SIFS_TIME + TURBO_PREAMBLE_TIME
+ (numSymbols * TURBO_SYMBOL_TIME);
break;
#undef TURBO_SIFS_TIME
#undef TURBO_PREAMBLE_TIME
#undef TURBO_PLCP_BITS
#undef TURBO_SYMBOL_TIME
default:
panic("%s: unknown phy %u (rate %u)\n", __func__,
rt->info[rix].phy, rate);
break;
}
return txTime;
}
Reference in New Issue View Git Blame Copy Permalink