mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-06 10:57:46 +00:00
Code Issues Releases Wiki Activity

b43: Rewrite LO calibration algorithm

Browse source 
This patch distributes the Local Oscillator calibration bursts over time,
so that calibration only happens when it's actually needed.
Currently we periodically perform a recalibration of the whole table.
The table is huge and this takes lots of time. Additionally only small bits
of the table are actually needed at a given time. So instead of maintaining
a huge table with all possible calibration values, we create dynamic calibration
settings that
a) We only calibrate when they are actually needed.
b) Are cached for some time until they expire.
So a recalibration might happen if we need a calibration setting that's not
cached, or if the active calibration setting expires.
Currently the expire timeout is set to 30 seconds. We may raise that in future.

This patch reduces overall memory consumption by nuking the
huge static calibration tables.

This patch has been tested on several 4306, 4311 and 4318 flavours.

Signed-off-by: Michael Buesch <mb@bu3sch.de>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
Michael Buesch 2008-04-20 16:03:32 +02:00 committed by John W. Linville
parent 2afc49015d
commit f5eda47f45
8 changed files with 390 additions and 680 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

75
drivers/net/wireless/b43/debugfs.c
View file

@ -270,24 +270,22 @@ static int restart_write_file(struct b43_wldev *dev,
return err; return err;
} }
static ssize_t append_lo_table(ssize_t count, char *buf, const size_t bufsize, static unsigned long calc_expire_secs(unsigned long now,
struct b43_loctl table[B43_NR_BB][B43_NR_RF]) unsigned long time,
unsigned long expire)
{ {
unsigned int i, j; expire = time + expire;
struct b43_loctl *ctl;
for (i = 0; i < B43_NR_BB; i++) { if (time_after(now, expire))
for (j = 0; j < B43_NR_RF; j++) { return 0; /* expired */
ctl = &(table[i][j]); if (expire < now) {
fappend("(bbatt %2u, rfatt %2u) -> " /* jiffies wrapped */
"(I %+3d, Q %+3d, Used: %d, Calibrated: %d)\n", expire -= MAX_JIFFY_OFFSET;
i, j, ctl->i, ctl->q, now -= MAX_JIFFY_OFFSET;
ctl->used,
b43_loctl_is_calibrated(ctl));
}
} }
B43_WARN_ON(expire < now);
return count; return (expire - now) / HZ;
} }
static ssize_t loctls_read_file(struct b43_wldev *dev, static ssize_t loctls_read_file(struct b43_wldev *dev,
@ -296,27 +294,45 @@ static ssize_t loctls_read_file(struct b43_wldev *dev,
ssize_t count = 0; ssize_t count = 0;
struct b43_txpower_lo_control *lo; struct b43_txpower_lo_control *lo;
int i, err = 0; int i, err = 0;
struct b43_lo_calib *cal;
unsigned long now = jiffies;
struct b43_phy *phy = &dev->phy;
if (dev->phy.type != B43_PHYTYPE_G) { if (phy->type != B43_PHYTYPE_G) {
fappend("Device is not a G-PHY\n"); fappend("Device is not a G-PHY\n");
err = -ENODEV; err = -ENODEV;
goto out; goto out;
} }
lo = dev->phy.lo_control; lo = phy->lo_control;
fappend("-- Local Oscillator calibration data --\n\n"); fappend("-- Local Oscillator calibration data --\n\n");
fappend("Measured: %d, Rebuild: %d, HW-power-control: %d\n", fappend("HW-power-control enabled: %d\n",
lo->lo_measured,
lo->rebuild,
dev->phy.hardware_power_control); dev->phy.hardware_power_control);
fappend("TX Bias: 0x%02X, TX Magn: 0x%02X\n", fappend("TX Bias: 0x%02X, TX Magn: 0x%02X (expire in %lu sec)\n",
lo->tx_bias, lo->tx_magn); lo->tx_bias, lo->tx_magn,
fappend("Power Vector: 0x%08X%08X\n", calc_expire_secs(now, lo->txctl_measured_time,
B43_LO_TXCTL_EXPIRE));
fappend("Power Vector: 0x%08X%08X (expires in %lu sec)\n",
(unsigned int)((lo->power_vector & 0xFFFFFFFF00000000ULL) >> 32), (unsigned int)((lo->power_vector & 0xFFFFFFFF00000000ULL) >> 32),
(unsigned int)(lo->power_vector & 0x00000000FFFFFFFFULL)); (unsigned int)(lo->power_vector & 0x00000000FFFFFFFFULL),
fappend("\nControl table WITH PADMIX:\n"); calc_expire_secs(now, lo->pwr_vec_read_time,
count = append_lo_table(count, buf, bufsize, lo->with_padmix); B43_LO_PWRVEC_EXPIRE));
fappend("\nControl table WITHOUT PADMIX:\n");
count = append_lo_table(count, buf, bufsize, lo->no_padmix); fappend("\nCalibrated settings:\n");
list_for_each_entry(cal, &lo->calib_list, list) {
bool active;
active = (b43_compare_bbatt(&cal->bbatt, &phy->bbatt) &&
b43_compare_rfatt(&cal->rfatt, &phy->rfatt));
fappend("BB(%d), RF(%d,%d) -> I=%d, Q=%d "
"(expires in %lu sec)%s\n",
cal->bbatt.att,
cal->rfatt.att, cal->rfatt.with_padmix,
cal->ctl.i, cal->ctl.q,
calc_expire_secs(now, cal->calib_time,
B43_LO_CALIB_EXPIRE),
active ? " ACTIVE" : "");
}
fappend("\nUsed RF attenuation values: Value(WithPadmix flag)\n"); fappend("\nUsed RF attenuation values: Value(WithPadmix flag)\n");
for (i = 0; i < lo->rfatt_list.len; i++) { for (i = 0; i < lo->rfatt_list.len; i++) {
fappend("%u(%d), ", fappend("%u(%d), ",
@ -351,7 +367,7 @@ static ssize_t b43_debugfs_read(struct file *file, char __user *userbuf,
struct b43_dfs_file *dfile; struct b43_dfs_file *dfile;
ssize_t uninitialized_var(ret); ssize_t uninitialized_var(ret);
char *buf; char *buf;
const size_t bufsize = 1024 * 128; const size_t bufsize = 1024 * 16; /* 16 kiB buffer */
const size_t buforder = get_order(bufsize); const size_t buforder = get_order(bufsize);
int err = 0; int err = 0;
@ -380,8 +396,6 @@ static ssize_t b43_debugfs_read(struct file *file, char __user *userbuf,
err = -ENOMEM; err = -ENOMEM;
goto out_unlock; goto out_unlock;
} }
/* Sparse warns about the following memset, because it has a big
* size value. That warning is bogus, so I will ignore it. --mb */
memset(buf, 0, bufsize); memset(buf, 0, bufsize);
if (dfops->take_irqlock) { if (dfops->take_irqlock) {
spin_lock_irq(&dev->wl->irq_lock); spin_lock_irq(&dev->wl->irq_lock);
@ -523,6 +537,7 @@ static void b43_add_dynamic_debug(struct b43_wldev *dev)
add_dyn_dbg("debug_dmaverbose", B43_DBG_DMAVERBOSE, 0); add_dyn_dbg("debug_dmaverbose", B43_DBG_DMAVERBOSE, 0);
add_dyn_dbg("debug_pwork_fast", B43_DBG_PWORK_FAST, 0); add_dyn_dbg("debug_pwork_fast", B43_DBG_PWORK_FAST, 0);
add_dyn_dbg("debug_pwork_stop", B43_DBG_PWORK_STOP, 0); add_dyn_dbg("debug_pwork_stop", B43_DBG_PWORK_STOP, 0);
add_dyn_dbg("debug_lo", B43_DBG_LO, 0);
#undef add_dyn_dbg #undef add_dyn_dbg
} }

1
drivers/net/wireless/b43/debugfs.h
View file

@ -10,6 +10,7 @@ enum b43_dyndbg { /* Dynamic debugging features */
B43_DBG_DMAVERBOSE, B43_DBG_DMAVERBOSE,
B43_DBG_PWORK_FAST, B43_DBG_PWORK_FAST,
B43_DBG_PWORK_STOP, B43_DBG_PWORK_STOP,
B43_DBG_LO,
__B43_NR_DYNDBG, __B43_NR_DYNDBG,
}; };

713
drivers/net/wireless/b43/lo.c
View file

@ -36,10 +36,22 @@
#include <linux/sched.h> #include <linux/sched.h>
/* Define to 1 to always calibrate all possible LO control pairs. static struct b43_lo_calib * b43_find_lo_calib(struct b43_txpower_lo_control *lo,
* This is a workaround until we fix the partial LO calibration optimization. */ const struct b43_bbatt *bbatt,
#define B43_CALIB_ALL_LOCTLS 1 const struct b43_rfatt *rfatt)
{
struct b43_lo_calib *c;
list_for_each_entry(c, &lo->calib_list, list) {
if (!b43_compare_bbatt(&c->bbatt, bbatt))
continue;
if (!b43_compare_rfatt(&c->rfatt, rfatt))
continue;
return c;
}
return NULL;
}
/* Write the LocalOscillator Control (adjust) value-pair. */ /* Write the LocalOscillator Control (adjust) value-pair. */
static void b43_lo_write(struct b43_wldev *dev, struct b43_loctl *control) static void b43_lo_write(struct b43_wldev *dev, struct b43_loctl *control)
@ -64,183 +76,6 @@ static void b43_lo_write(struct b43_wldev *dev, struct b43_loctl *control)
b43_phy_write(dev, reg, value); b43_phy_write(dev, reg, value);
} }
static int assert_rfatt_and_bbatt(const struct b43_rfatt *rfatt,
const struct b43_bbatt *bbatt,
struct b43_wldev *dev)
{
int err = 0;
/* Check the attenuation values against the LO control array sizes. */
if (unlikely(rfatt->att >= B43_NR_RF)) {
b43err(dev->wl, "rfatt(%u) >= size of LO array\n", rfatt->att);
err = -EINVAL;
}
if (unlikely(bbatt->att >= B43_NR_BB)) {
b43err(dev->wl, "bbatt(%u) >= size of LO array\n", bbatt->att);
err = -EINVAL;
}
return err;
}
#if !B43_CALIB_ALL_LOCTLS
static
struct b43_loctl *b43_get_lo_g_ctl_nopadmix(struct b43_wldev *dev,
const struct b43_rfatt *rfatt,
const struct b43_bbatt *bbatt)
{
struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control;
if (assert_rfatt_and_bbatt(rfatt, bbatt, dev))
return &(lo->no_padmix[0][0]); /* Just prevent a crash */
return &(lo->no_padmix[bbatt->att][rfatt->att]);
}
#endif /* !B43_CALIB_ALL_LOCTLS */
struct b43_loctl *b43_get_lo_g_ctl(struct b43_wldev *dev,
const struct b43_rfatt *rfatt,
const struct b43_bbatt *bbatt)
{
struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control;
if (assert_rfatt_and_bbatt(rfatt, bbatt, dev))
return &(lo->no_padmix[0][0]); /* Just prevent a crash */
if (rfatt->with_padmix)
return &(lo->with_padmix[bbatt->att][rfatt->att]);
return &(lo->no_padmix[bbatt->att][rfatt->att]);
}
/* Call a function for every possible LO control value-pair. */
static void b43_call_for_each_loctl(struct b43_wldev *dev,
void (*func) (struct b43_wldev *,
struct b43_loctl *))
{
struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *ctl = phy->lo_control;
int i, j;
for (i = 0; i < B43_NR_BB; i++) {
for (j = 0; j < B43_NR_RF; j++)
func(dev, &(ctl->with_padmix[i][j]));
}
for (i = 0; i < B43_NR_BB; i++) {
for (j = 0; j < B43_NR_RF; j++)
func(dev, &(ctl->no_padmix[i][j]));
}
}
static u16 lo_b_r15_loop(struct b43_wldev *dev)
{
int i;
u16 ret = 0;
for (i = 0; i < 10; i++) {
b43_phy_write(dev, 0x0015, 0xAFA0);
udelay(1);
b43_phy_write(dev, 0x0015, 0xEFA0);
udelay(10);
b43_phy_write(dev, 0x0015, 0xFFA0);
udelay(40);
ret += b43_phy_read(dev, 0x002C);
}
return ret;
}
void b43_lo_b_measure(struct b43_wldev *dev)
{
struct b43_phy *phy = &dev->phy;
u16 regstack[12] = { 0 };
u16 mls;
u16 fval;
int i, j;
regstack[0] = b43_phy_read(dev, 0x0015);
regstack[1] = b43_radio_read16(dev, 0x0052) & 0xFFF0;
if (phy->radio_ver == 0x2053) {
regstack[2] = b43_phy_read(dev, 0x000A);
regstack[3] = b43_phy_read(dev, 0x002A);
regstack[4] = b43_phy_read(dev, 0x0035);
regstack[5] = b43_phy_read(dev, 0x0003);
regstack[6] = b43_phy_read(dev, 0x0001);
regstack[7] = b43_phy_read(dev, 0x0030);
regstack[8] = b43_radio_read16(dev, 0x0043);
regstack[9] = b43_radio_read16(dev, 0x007A);
regstack[10] = b43_read16(dev, 0x03EC);
regstack[11] = b43_radio_read16(dev, 0x0052) & 0x00F0;
b43_phy_write(dev, 0x0030, 0x00FF);
b43_write16(dev, 0x03EC, 0x3F3F);
b43_phy_write(dev, 0x0035, regstack[4] & 0xFF7F);
b43_radio_write16(dev, 0x007A, regstack[9] & 0xFFF0);
}
b43_phy_write(dev, 0x0015, 0xB000);
b43_phy_write(dev, 0x002B, 0x0004);
if (phy->radio_ver == 0x2053) {
b43_phy_write(dev, 0x002B, 0x0203);
b43_phy_write(dev, 0x002A, 0x08A3);
}
phy->minlowsig[0] = 0xFFFF;
for (i = 0; i < 4; i++) {
b43_radio_write16(dev, 0x0052, regstack[1] | i);
lo_b_r15_loop(dev);
}
for (i = 0; i < 10; i++) {
b43_radio_write16(dev, 0x0052, regstack[1] | i);
mls = lo_b_r15_loop(dev) / 10;
if (mls < phy->minlowsig[0]) {
phy->minlowsig[0] = mls;
phy->minlowsigpos[0] = i;
}
}
b43_radio_write16(dev, 0x0052, regstack[1] | phy->minlowsigpos[0]);
phy->minlowsig[1] = 0xFFFF;
for (i = -4; i < 5; i += 2) {
for (j = -4; j < 5; j += 2) {
if (j < 0)
fval = (0x0100 * i) + j + 0x0100;
else
fval = (0x0100 * i) + j;
b43_phy_write(dev, 0x002F, fval);
mls = lo_b_r15_loop(dev) / 10;
if (mls < phy->minlowsig[1]) {
phy->minlowsig[1] = mls;
phy->minlowsigpos[1] = fval;
}
}
}
phy->minlowsigpos[1] += 0x0101;
b43_phy_write(dev, 0x002F, phy->minlowsigpos[1]);
if (phy->radio_ver == 0x2053) {
b43_phy_write(dev, 0x000A, regstack[2]);
b43_phy_write(dev, 0x002A, regstack[3]);
b43_phy_write(dev, 0x0035, regstack[4]);
b43_phy_write(dev, 0x0003, regstack[5]);
b43_phy_write(dev, 0x0001, regstack[6]);
b43_phy_write(dev, 0x0030, regstack[7]);
b43_radio_write16(dev, 0x0043, regstack[8]);
b43_radio_write16(dev, 0x007A, regstack[9]);
b43_radio_write16(dev, 0x0052,
(b43_radio_read16(dev, 0x0052) & 0x000F)
| regstack[11]);
b43_write16(dev, 0x03EC, regstack[10]);
}
b43_phy_write(dev, 0x0015, regstack[0]);
}
static u16 lo_measure_feedthrough(struct b43_wldev *dev, static u16 lo_measure_feedthrough(struct b43_wldev *dev,
u16 lna, u16 pga, u16 trsw_rx) u16 lna, u16 pga, u16 trsw_rx)
{ {
@ -438,48 +273,26 @@ static void lo_measure_txctl_values(struct b43_wldev *dev)
b43_radio_write16(dev, 0x52, b43_radio_read16(dev, 0x52) b43_radio_write16(dev, 0x52, b43_radio_read16(dev, 0x52)
& 0xFFF0); /* TX bias == 0 */ & 0xFFF0); /* TX bias == 0 */
} }
lo->txctl_measured_time = jiffies;
} }
static void lo_read_power_vector(struct b43_wldev *dev) static void lo_read_power_vector(struct b43_wldev *dev)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control; struct b43_txpower_lo_control *lo = phy->lo_control;
u16 i; int i;
u64 tmp; u64 tmp;
u64 power_vector = 0; u64 power_vector = 0;
int rf_offset, bb_offset;
struct b43_loctl *loctl;
for (i = 0; i < 8; i += 2) { for (i = 0; i < 8; i += 2) {
tmp = b43_shm_read16(dev, B43_SHM_SHARED, 0x310 + i); tmp = b43_shm_read16(dev, B43_SHM_SHARED, 0x310 + i);
/* Clear the top byte. We get holes in the bitmap... */
tmp &= 0xFF;
power_vector |= (tmp << (i * 8)); power_vector |= (tmp << (i * 8));
/* Clear the vector on the device. */ /* Clear the vector on the device. */
b43_shm_write16(dev, B43_SHM_SHARED, 0x310 + i, 0); b43_shm_write16(dev, B43_SHM_SHARED, 0x310 + i, 0);
} }
if (power_vector) if (power_vector)
lo->power_vector = power_vector; lo->power_vector = power_vector;
power_vector = lo->power_vector; lo->pwr_vec_read_time = jiffies;
for (i = 0; i < 64; i++) {
if (power_vector & ((u64) 1ULL << i)) {
/* Now figure out which b43_loctl corresponds
* to this bit.
*/
rf_offset = i / lo->rfatt_list.len;
bb_offset = i % lo->rfatt_list.len; //FIXME?
loctl =
b43_get_lo_g_ctl(dev,
&lo->rfatt_list.list[rf_offset],
&lo->bbatt_list.list[bb_offset]);
/* And mark it as "used", as the device told us
* through the bitmap it is using it.
*/
loctl->used = 1;
}
}
} }
/* 802.11/LO/GPHY/MeasuringGains */ /* 802.11/LO/GPHY/MeasuringGains */
@ -609,8 +422,6 @@ static void lo_measure_setup(struct b43_wldev *dev,
b43_phy_write(dev, B43_PHY_CCK(0x16), 0x410); b43_phy_write(dev, B43_PHY_CCK(0x16), 0x410);
b43_phy_write(dev, B43_PHY_CCK(0x17), 0x820); b43_phy_write(dev, B43_PHY_CCK(0x17), 0x820);
} }
if (!lo->rebuild && b43_has_hardware_pctl(phy))
lo_read_power_vector(dev);
if (phy->rev >= 2) { if (phy->rev >= 2) {
sav->phy_analogover = b43_phy_read(dev, B43_PHY_ANALOGOVER); sav->phy_analogover = b43_phy_read(dev, B43_PHY_ANALOGOVER);
sav->phy_analogoverval = sav->phy_analogoverval =
@ -691,8 +502,12 @@ static void lo_measure_setup(struct b43_wldev *dev,
b43_radio_read16(dev, 0x51); /* dummy read */ b43_radio_read16(dev, 0x51); /* dummy read */
if (phy->type == B43_PHYTYPE_G) if (phy->type == B43_PHYTYPE_G)
b43_phy_write(dev, B43_PHY_CCK(0x2F), 0); b43_phy_write(dev, B43_PHY_CCK(0x2F), 0);
if (lo->rebuild)
/* Re-measure the txctl values, if needed. */
if (time_before(lo->txctl_measured_time,
jiffies - B43_LO_TXCTL_EXPIRE))
lo_measure_txctl_values(dev); lo_measure_txctl_values(dev);
if (phy->type == B43_PHYTYPE_G && phy->rev >= 3) { if (phy->type == B43_PHYTYPE_G && phy->rev >= 3) {
b43_phy_write(dev, B43_PHY_LO_MASK, 0xC078); b43_phy_write(dev, B43_PHY_LO_MASK, 0xC078);
} else { } else {
@ -707,7 +522,6 @@ static void lo_measure_restore(struct b43_wldev *dev,
struct lo_g_saved_values *sav) struct lo_g_saved_values *sav)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control;
u16 tmp; u16 tmp;
if (phy->rev >= 2) { if (phy->rev >= 2) {
@ -722,14 +536,6 @@ static void lo_measure_restore(struct b43_wldev *dev,
tmp = (phy->pga_gain | 0xEFA0); tmp = (phy->pga_gain | 0xEFA0);
b43_phy_write(dev, B43_PHY_PGACTL, tmp); b43_phy_write(dev, B43_PHY_PGACTL, tmp);
} }
if (b43_has_hardware_pctl(phy)) {
b43_gphy_dc_lt_init(dev);
} else {
if (lo->rebuild)
b43_lo_g_adjust_to(dev, 3, 2, 0);
else
b43_lo_g_adjust(dev);
}
if (phy->type == B43_PHYTYPE_G) { if (phy->type == B43_PHYTYPE_G) {
if (phy->rev >= 3) if (phy->rev >= 3)
b43_phy_write(dev, B43_PHY_CCK(0x2E), 0xC078); b43_phy_write(dev, B43_PHY_CCK(0x2E), 0xC078);
@ -793,7 +599,6 @@ static int lo_probe_possible_loctls(struct b43_wldev *dev,
struct b43_lo_g_statemachine *d) struct b43_lo_g_statemachine *d)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control;
struct b43_loctl test_loctl; struct b43_loctl test_loctl;
struct b43_loctl orig_loctl; struct b43_loctl orig_loctl;
struct b43_loctl prev_loctl = { struct b43_loctl prev_loctl = {
@ -852,7 +657,7 @@ static int lo_probe_possible_loctls(struct b43_wldev *dev,
found_lower = 1; found_lower = 1;
d->lowest_feedth = feedth; d->lowest_feedth = feedth;
if ((d->nr_measured < 2) && if ((d->nr_measured < 2) &&
(!has_loopback_gain(phy) || lo->rebuild)) !has_loopback_gain(phy))
break; break;
} }
} }
@ -874,7 +679,6 @@ static void lo_probe_loctls_statemachine(struct b43_wldev *dev,
int *max_rx_gain) int *max_rx_gain)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control;
struct b43_lo_g_statemachine d; struct b43_lo_g_statemachine d;
u16 feedth; u16 feedth;
int found_lower; int found_lower;
@ -883,18 +687,18 @@ static void lo_probe_loctls_statemachine(struct b43_wldev *dev,
d.nr_measured = 0; d.nr_measured = 0;
d.state_val_multiplier = 1; d.state_val_multiplier = 1;
if (has_loopback_gain(phy) && !lo->rebuild) if (has_loopback_gain(phy))
d.state_val_multiplier = 3; d.state_val_multiplier = 3;
memcpy(&d.min_loctl, loctl, sizeof(struct b43_loctl)); memcpy(&d.min_loctl, loctl, sizeof(struct b43_loctl));
if (has_loopback_gain(phy) && lo->rebuild) if (has_loopback_gain(phy))
max_repeat = 4; max_repeat = 4;
do { do {
b43_lo_write(dev, &d.min_loctl); b43_lo_write(dev, &d.min_loctl);
feedth = lo_measure_feedthrough(dev, phy->lna_gain, feedth = lo_measure_feedthrough(dev, phy->lna_gain,
phy->pga_gain, phy->pga_gain,
phy->trsw_rx_gain); phy->trsw_rx_gain);
if (!lo->rebuild && feedth < 0x258) { if (feedth < 0x258) {
if (feedth >= 0x12C) if (feedth >= 0x12C)
*max_rx_gain += 6; *max_rx_gain += 6;
else else
@ -944,278 +748,188 @@ static void lo_probe_loctls_statemachine(struct b43_wldev *dev,
} while (++repeat_cnt < max_repeat); } while (++repeat_cnt < max_repeat);
} }
#if B43_CALIB_ALL_LOCTLS static
static const struct b43_rfatt b43_full_rfatt_list_items[] = { struct b43_lo_calib * b43_calibrate_lo_setting(struct b43_wldev *dev,
{ .att = 0, .with_padmix = 0, }, const struct b43_bbatt *bbatt,
{ .att = 1, .with_padmix = 0, }, const struct b43_rfatt *rfatt)
{ .att = 2, .with_padmix = 0, },
{ .att = 3, .with_padmix = 0, },
{ .att = 4, .with_padmix = 0, },
{ .att = 5, .with_padmix = 0, },
{ .att = 6, .with_padmix = 0, },
{ .att = 7, .with_padmix = 0, },
{ .att = 8, .with_padmix = 0, },
{ .att = 9, .with_padmix = 0, },
{ .att = 10, .with_padmix = 0, },
{ .att = 11, .with_padmix = 0, },
{ .att = 12, .with_padmix = 0, },
{ .att = 13, .with_padmix = 0, },
{ .att = 14, .with_padmix = 0, },
{ .att = 15, .with_padmix = 0, },
{ .att = 0, .with_padmix = 1, },
{ .att = 1, .with_padmix = 1, },
{ .att = 2, .with_padmix = 1, },
{ .att = 3, .with_padmix = 1, },
{ .att = 4, .with_padmix = 1, },
{ .att = 5, .with_padmix = 1, },
{ .att = 6, .with_padmix = 1, },
{ .att = 7, .with_padmix = 1, },
{ .att = 8, .with_padmix = 1, },
{ .att = 9, .with_padmix = 1, },
{ .att = 10, .with_padmix = 1, },
{ .att = 11, .with_padmix = 1, },
{ .att = 12, .with_padmix = 1, },
{ .att = 13, .with_padmix = 1, },
{ .att = 14, .with_padmix = 1, },
{ .att = 15, .with_padmix = 1, },
};
static const struct b43_rfatt_list b43_full_rfatt_list = {
.list = b43_full_rfatt_list_items,
.len = ARRAY_SIZE(b43_full_rfatt_list_items),
};
static const struct b43_bbatt b43_full_bbatt_list_items[] = {
{ .att = 0, },
{ .att = 1, },
{ .att = 2, },
{ .att = 3, },
{ .att = 4, },
{ .att = 5, },
{ .att = 6, },
{ .att = 7, },
{ .att = 8, },
{ .att = 9, },
{ .att = 10, },
{ .att = 11, },
};
static const struct b43_bbatt_list b43_full_bbatt_list = {
.list = b43_full_bbatt_list_items,
.len = ARRAY_SIZE(b43_full_bbatt_list_items),
};
#endif /* B43_CALIB_ALL_LOCTLS */
static void lo_measure(struct b43_wldev *dev)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control;
struct b43_loctl loctl = { struct b43_loctl loctl = {
.i = 0, .i = 0,
.q = 0, .q = 0,
}; };
struct b43_loctl *ploctl;
int max_rx_gain; int max_rx_gain;
int rfidx, bbidx; struct b43_lo_calib *cal;
const struct b43_bbatt_list *bbatt_list; struct lo_g_saved_values uninitialized_var(saved_regs);
const struct b43_rfatt_list *rfatt_list;
/* Values from the "TXCTL Register and Value Table" */ /* Values from the "TXCTL Register and Value Table" */
u16 txctl_reg; u16 txctl_reg;
u16 txctl_value; u16 txctl_value;
u16 pad_mix_gain; u16 pad_mix_gain;
bbatt_list = &lo->bbatt_list; saved_regs.old_channel = phy->channel;
rfatt_list = &lo->rfatt_list; b43_mac_suspend(dev);
#if B43_CALIB_ALL_LOCTLS lo_measure_setup(dev, &saved_regs);
bbatt_list = &b43_full_bbatt_list;
rfatt_list = &b43_full_rfatt_list;
#endif
txctl_reg = lo_txctl_register_table(dev, &txctl_value, &pad_mix_gain); txctl_reg = lo_txctl_register_table(dev, &txctl_value, &pad_mix_gain);
for (rfidx = 0; rfidx < rfatt_list->len; rfidx++) { b43_radio_write16(dev, 0x43,
(b43_radio_read16(dev, 0x43) & 0xFFF0)
| rfatt->att);
b43_radio_write16(dev, txctl_reg,
(b43_radio_read16(dev, txctl_reg) & ~txctl_value)
| (rfatt->with_padmix) ? txctl_value : 0);
b43_radio_write16(dev, 0x43, (b43_radio_read16(dev, 0x43) max_rx_gain = rfatt->att * 2;
& 0xFFF0) | max_rx_gain += bbatt->att / 2;
rfatt_list->list[rfidx].att); if (rfatt->with_padmix)
b43_radio_write16(dev, txctl_reg, max_rx_gain -= pad_mix_gain;
(b43_radio_read16(dev, txctl_reg) if (has_loopback_gain(phy))
& ~txctl_value) max_rx_gain += phy->max_lb_gain;
| (rfatt_list->list[rfidx].with_padmix ? lo_measure_gain_values(dev, max_rx_gain,
txctl_value : 0)); has_loopback_gain(phy));
for (bbidx = 0; bbidx < bbatt_list->len; bbidx++) { b43_phy_set_baseband_attenuation(dev, bbatt->att);
if (lo->rebuild) { lo_probe_loctls_statemachine(dev, &loctl, &max_rx_gain);
#if B43_CALIB_ALL_LOCTLS
ploctl = b43_get_lo_g_ctl(dev,
&rfatt_list->list[rfidx],
&bbatt_list->list[bbidx]);
#else
ploctl = b43_get_lo_g_ctl_nopadmix(dev,
&rfatt_list->
list[rfidx],
&bbatt_list->
list[bbidx]);
#endif
} else {
ploctl = b43_get_lo_g_ctl(dev,
&rfatt_list->list[rfidx],
&bbatt_list->list[bbidx]);
if (!ploctl->used)
continue;
}
memcpy(&loctl, ploctl, sizeof(loctl));
loctl.i = 0;
loctl.q = 0;
max_rx_gain = rfatt_list->list[rfidx].att * 2; lo_measure_restore(dev, &saved_regs);
max_rx_gain += bbatt_list->list[bbidx].att / 2; b43_mac_enable(dev);
if (rfatt_list->list[rfidx].with_padmix)
max_rx_gain -= pad_mix_gain;
if (has_loopback_gain(phy))
max_rx_gain += phy->max_lb_gain;
lo_measure_gain_values(dev, max_rx_gain,
has_loopback_gain(phy));
b43_phy_set_baseband_attenuation(dev, if (b43_debug(dev, B43_DBG_LO)) {
bbatt_list->list[bbidx].att); b43dbg(dev->wl, "LO: Calibrated for BB(%u), RF(%u,%u) "
lo_probe_loctls_statemachine(dev, &loctl, &max_rx_gain); "=> I=%d Q=%d\n",
if (phy->type == B43_PHYTYPE_B) { bbatt->att, rfatt->att, rfatt->with_padmix,
loctl.i++; loctl.i, loctl.q);
loctl.q++;
}
b43_loctl_set_calibrated(&loctl, 1);
memcpy(ploctl, &loctl, sizeof(loctl));
}
} }
}
#if B43_DEBUG cal = kmalloc(sizeof(*cal), GFP_KERNEL);
static void do_validate_loctl(struct b43_wldev *dev, struct b43_loctl *control) if (!cal) {
{ b43warn(dev->wl, "LO calib: out of memory\n");
const int is_initializing = (b43_status(dev) == B43_STAT_UNINIT); return NULL;
int i = control->i;
int q = control->q;
if (b43_loctl_is_calibrated(control)) {
if ((abs(i) > 16) || (abs(q) > 16))
goto error;
} else {
if (control->used)
goto error;
if (dev->phy.lo_control->rebuild) {
control->i = 0;
control->q = 0;
if ((i != B43_LOCTL_POISON) ||
(q != B43_LOCTL_POISON))
goto error;
}
} }
if (is_initializing && control->used) memcpy(&cal->bbatt, bbatt, sizeof(*bbatt));
goto error; memcpy(&cal->rfatt, rfatt, sizeof(*rfatt));
memcpy(&cal->ctl, &loctl, sizeof(loctl));
cal->calib_time = jiffies;
INIT_LIST_HEAD(&cal->list);
return; return cal;
error:
b43err(dev->wl, "LO control pair validation failed "
"(I: %d, Q: %d, used %u, calib: %u, initing: %d)\n",
i, q, control->used,
b43_loctl_is_calibrated(control),
is_initializing);
} }
static void validate_all_loctls(struct b43_wldev *dev) /* Get a calibrated LO setting for the given attenuation values.
* Might return a NULL pointer under OOM! */
static
struct b43_lo_calib * b43_get_calib_lo_settings(struct b43_wldev *dev,
const struct b43_bbatt *bbatt,
const struct b43_rfatt *rfatt)
{ {
b43_call_for_each_loctl(dev, do_validate_loctl); struct b43_txpower_lo_control *lo = dev->phy.lo_control;
struct b43_lo_calib *c;
c = b43_find_lo_calib(lo, bbatt, rfatt);
if (c)
return c;
/* Not in the list of calibrated LO settings.
* Calibrate it now. */
c = b43_calibrate_lo_setting(dev, bbatt, rfatt);
if (!c)
return NULL;
list_add(&c->list, &lo->calib_list);
return c;
} }
static void do_reset_calib(struct b43_wldev *dev, struct b43_loctl *control) void b43_gphy_dc_lt_init(struct b43_wldev *dev, bool update_all)
{
if (dev->phy.lo_control->rebuild ||
control->used) {
b43_loctl_set_calibrated(control, 0);
control->i = B43_LOCTL_POISON;
control->q = B43_LOCTL_POISON;
}
}
static void reset_all_loctl_calibration_states(struct b43_wldev *dev)
{
b43_call_for_each_loctl(dev, do_reset_calib);
}
#else /* B43_DEBUG */
static inline void validate_all_loctls(struct b43_wldev *dev) { }
static inline void reset_all_loctl_calibration_states(struct b43_wldev *dev) { }
#endif /* B43_DEBUG */
void b43_lo_g_measure(struct b43_wldev *dev)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct lo_g_saved_values uninitialized_var(sav); struct b43_txpower_lo_control *lo = phy->lo_control;
int i;
int rf_offset, bb_offset;
const struct b43_rfatt *rfatt;
const struct b43_bbatt *bbatt;
u64 power_vector;
bool table_changed = 0;
B43_WARN_ON((phy->type != B43_PHYTYPE_B) && BUILD_BUG_ON(B43_DC_LT_SIZE != 32);
(phy->type != B43_PHYTYPE_G)); B43_WARN_ON(lo->rfatt_list.len * lo->bbatt_list.len > 64);
sav.old_channel = phy->channel; power_vector = lo->power_vector;
lo_measure_setup(dev, &sav); if (!update_all && !power_vector)
reset_all_loctl_calibration_states(dev); return; /* Nothing to do. */
lo_measure(dev);
lo_measure_restore(dev, &sav);
validate_all_loctls(dev); /* Suspend the MAC now to avoid continuous suspend/enable
* cycles in the loop. */
b43_mac_suspend(dev);
phy->lo_control->lo_measured = 1; for (i = 0; i < B43_DC_LT_SIZE * 2; i++) {
phy->lo_control->rebuild = 0; struct b43_lo_calib *cal;
} int idx;
u16 val;
#if B43_DEBUG if (!update_all && !(power_vector & (((u64)1ULL) << i)))
static void validate_loctl_calibration(struct b43_wldev *dev, continue;
struct b43_loctl *loctl, /* Update the table entry for this power_vector bit.
struct b43_rfatt *rfatt, * The table rows are RFatt entries and columns are BBatt. */
struct b43_bbatt *bbatt) bb_offset = i / lo->rfatt_list.len;
{ rf_offset = i % lo->rfatt_list.len;
if (b43_loctl_is_calibrated(loctl)) bbatt = &(lo->bbatt_list.list[bb_offset]);
return; rfatt = &(lo->rfatt_list.list[rf_offset]);
if (!dev->phy.lo_control->lo_measured) {
/* On init we set the attenuation values before we cal = b43_calibrate_lo_setting(dev, bbatt, rfatt);
* calibrated the LO. I guess that's OK. */ if (!cal) {
return; b43warn(dev->wl, "LO: Could not "
"calibrate DC table entry\n");
continue;
}
/*FIXME: Is Q really in the low nibble? */
val = (u8)(cal->ctl.q);
val |= ((u8)(cal->ctl.i)) << 4;
kfree(cal);
/* Get the index into the hardware DC LT. */
idx = i / 2;
/* Change the table in memory. */
if (i % 2) {
/* Change the high byte. */
lo->dc_lt[idx] = (lo->dc_lt[idx] & 0x00FF)
| ((val & 0x00FF) << 8);
} else {
/* Change the low byte. */
lo->dc_lt[idx] = (lo->dc_lt[idx] & 0xFF00)
| (val & 0x00FF);
}
table_changed = 1;
} }
b43err(dev->wl, "Adjusting Local Oscillator to an uncalibrated " if (table_changed) {
"control pair: rfatt=%u,%spadmix bbatt=%u\n", /* The table changed in memory. Update the hardware table. */
rfatt->att, for (i = 0; i < B43_DC_LT_SIZE; i++)
(rfatt->with_padmix) ? "" : "no-", b43_phy_write(dev, 0x3A0 + i, lo->dc_lt[i]);
bbatt->att);
}
#else
static inline void validate_loctl_calibration(struct b43_wldev *dev,
struct b43_loctl *loctl,
struct b43_rfatt *rfatt,
struct b43_bbatt *bbatt)
{
}
#endif
static inline void fixup_rfatt_for_txcontrol(struct b43_rfatt *rf,
u8 tx_control)
{
if (tx_control & B43_TXCTL_TXMIX) {
if (rf->att < 5)
rf->att = 4;
} }
b43_mac_enable(dev);
}
/* Fixup the RF attenuation value for the case where we are
* using the PAD mixer. */
static inline void b43_lo_fixup_rfatt(struct b43_rfatt *rf)
{
if (!rf->with_padmix)
return;
if ((rf->att != 1) && (rf->att != 2) && (rf->att != 3))
rf->att = 4;
} }
void b43_lo_g_adjust(struct b43_wldev *dev) void b43_lo_g_adjust(struct b43_wldev *dev)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_lo_calib *cal;
struct b43_rfatt rf; struct b43_rfatt rf;
struct b43_loctl *loctl;
memcpy(&rf, &phy->rfatt, sizeof(rf)); memcpy(&rf, &phy->rfatt, sizeof(rf));
fixup_rfatt_for_txcontrol(&rf, phy->tx_control); b43_lo_fixup_rfatt(&rf);
loctl = b43_get_lo_g_ctl(dev, &rf, &phy->bbatt); cal = b43_get_calib_lo_settings(dev, &phy->bbatt, &rf);
validate_loctl_calibration(dev, loctl, &rf, &phy->bbatt); if (!cal)
b43_lo_write(dev, loctl); return;
b43_lo_write(dev, &cal->ctl);
} }
void b43_lo_g_adjust_to(struct b43_wldev *dev, void b43_lo_g_adjust_to(struct b43_wldev *dev,
@ -1223,39 +937,102 @@ void b43_lo_g_adjust_to(struct b43_wldev *dev,
{ {
struct b43_rfatt rf; struct b43_rfatt rf;
struct b43_bbatt bb; struct b43_bbatt bb;
struct b43_loctl *loctl; struct b43_lo_calib *cal;
memset(&rf, 0, sizeof(rf)); memset(&rf, 0, sizeof(rf));
memset(&bb, 0, sizeof(bb)); memset(&bb, 0, sizeof(bb));
rf.att = rfatt; rf.att = rfatt;
bb.att = bbatt; bb.att = bbatt;
fixup_rfatt_for_txcontrol(&rf, tx_control); b43_lo_fixup_rfatt(&rf);
loctl = b43_get_lo_g_ctl(dev, &rf, &bb); cal = b43_get_calib_lo_settings(dev, &bb, &rf);
validate_loctl_calibration(dev, loctl, &rf, &bb); if (!cal)
b43_lo_write(dev, loctl); return;
b43_lo_write(dev, &cal->ctl);
} }
static void do_mark_unused(struct b43_wldev *dev, struct b43_loctl *control) /* Periodic LO maintanance work */
{ void b43_lo_g_maintanance_work(struct b43_wldev *dev)
control->used = 0;
}
void b43_lo_g_ctl_mark_all_unused(struct b43_wldev *dev)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control; struct b43_txpower_lo_control *lo = phy->lo_control;
unsigned long now;
unsigned long expire;
struct b43_lo_calib *cal, *tmp;
bool current_item_expired = 0;
bool hwpctl;
b43_call_for_each_loctl(dev, do_mark_unused); if (!lo)
lo->rebuild = 1; return;
now = jiffies;
hwpctl = b43_has_hardware_pctl(phy);
if (hwpctl) {
/* Read the power vector and update it, if needed. */
expire = now - B43_LO_PWRVEC_EXPIRE;
if (time_before(lo->pwr_vec_read_time, expire)) {
lo_read_power_vector(dev);
b43_gphy_dc_lt_init(dev, 0);
}
//FIXME Recalc the whole DC table from time to time?
}
if (hwpctl)
return;
/* Search for expired LO settings. Remove them.
* Recalibrate the current setting, if expired. */
expire = now - B43_LO_CALIB_EXPIRE;
list_for_each_entry_safe(cal, tmp, &lo->calib_list, list) {
if (!time_before(cal->calib_time, expire))
continue;
/* This item expired. */
if (b43_compare_bbatt(&cal->bbatt, &phy->bbatt) &&
b43_compare_rfatt(&cal->rfatt, &phy->rfatt)) {
B43_WARN_ON(current_item_expired);
current_item_expired = 1;
}
if (b43_debug(dev, B43_DBG_LO)) {
b43dbg(dev->wl, "LO: Item BB(%u), RF(%u,%u), "
"I=%d, Q=%d expired\n",
cal->bbatt.att, cal->rfatt.att,
cal->rfatt.with_padmix,
cal->ctl.i, cal->ctl.q);
}
list_del(&cal->list);
kfree(cal);
}
if (current_item_expired || unlikely(list_empty(&lo->calib_list))) {
/* Recalibrate currently used LO setting. */
if (b43_debug(dev, B43_DBG_LO))
b43dbg(dev->wl, "LO: Recalibrating current LO setting\n");
cal = b43_calibrate_lo_setting(dev, &phy->bbatt, &phy->rfatt);
if (cal) {
list_add(&cal->list, &lo->calib_list);
b43_lo_write(dev, &cal->ctl);
} else
b43warn(dev->wl, "Failed to recalibrate current LO setting\n");
}
} }
void b43_lo_g_ctl_mark_cur_used(struct b43_wldev *dev) void b43_lo_g_cleanup(struct b43_wldev *dev)
{
struct b43_txpower_lo_control *lo = dev->phy.lo_control;
struct b43_lo_calib *cal, *tmp;
if (!lo)
return;
list_for_each_entry_safe(cal, tmp, &lo->calib_list, list) {
list_del(&cal->list);
kfree(cal);
}
}
/* LO Initialization */
void b43_lo_g_init(struct b43_wldev *dev)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
struct b43_rfatt rf;
memcpy(&rf, &phy->rfatt, sizeof(rf)); if (b43_has_hardware_pctl(phy)) {
fixup_rfatt_for_txcontrol(&rf, phy->tx_control); lo_read_power_vector(dev);
b43_gphy_dc_lt_init(dev, 1);
b43_get_lo_g_ctl(dev, &rf, &phy->bbatt)->used = 1; }
} }

113
drivers/net/wireless/b43/lo.h
View file

@ -10,82 +10,63 @@ struct b43_loctl {
/* Control values. */ /* Control values. */
s8 i; s8 i;
s8 q; s8 q;
/* "Used by hardware" flag. */
bool used;
#ifdef CONFIG_B43_DEBUG
/* Is this lo-control-array entry calibrated? */
bool calibrated;
#endif
}; };
/* Debugging: Poison value for i and q values. */ /* Debugging: Poison value for i and q values. */
#define B43_LOCTL_POISON 111 #define B43_LOCTL_POISON 111
/* loctl->calibrated debugging mechanism */ /* This struct holds calibrated LO settings for a set of
#ifdef CONFIG_B43_DEBUG * Baseband and RF attenuation settings. */
static inline void b43_loctl_set_calibrated(struct b43_loctl *loctl, struct b43_lo_calib {
bool calibrated) /* The set of attenuation values this set of LO
{ * control values is calibrated for. */
loctl->calibrated = calibrated; struct b43_bbatt bbatt;
} struct b43_rfatt rfatt;
static inline bool b43_loctl_is_calibrated(struct b43_loctl *loctl) /* The set of control values for the LO. */
{ struct b43_loctl ctl;
return loctl->calibrated; /* The time when these settings were calibrated (in jiffies) */
} unsigned long calib_time;
#else /* List. */
static inline void b43_loctl_set_calibrated(struct b43_loctl *loctl, struct list_head list;
bool calibrated) };
{
}
static inline bool b43_loctl_is_calibrated(struct b43_loctl *loctl)
{
return 1;
}
#endif
/* TX Power LO Control Array. /* Size of the DC Lookup Table in 16bit words. */
* Value-pairs to adjust the LocalOscillator are stored #define B43_DC_LT_SIZE 32
* in this structure.
* There are two different set of values. One for "Flag is Set" /* Local Oscillator calibration information */
* and one for "Flag is Unset".
* By "Flag" the flag in struct b43_rfatt is meant.
* The Value arrays are two-dimensional. The first index
* is the baseband attenuation and the second index
* is the radio attenuation.
* Use b43_get_lo_g_ctl() to retrieve a value from the lists.
*/
struct b43_txpower_lo_control { struct b43_txpower_lo_control {
#define B43_NR_BB 12 /* Lists of RF and BB attenuation values for this device.
#define B43_NR_RF 16 * Used for building hardware power control tables. */
/* LO Control values, with PAD Mixer */
struct b43_loctl with_padmix[B43_NR_BB][B43_NR_RF];
/* LO Control values, without PAD Mixer */
struct b43_loctl no_padmix[B43_NR_BB][B43_NR_RF];
/* Flag to indicate a complete rebuild of the two tables above
* to the LO measuring code. */
bool rebuild;
/* Lists of valid RF and BB attenuation values for this device. */
struct b43_rfatt_list rfatt_list; struct b43_rfatt_list rfatt_list;
struct b43_bbatt_list bbatt_list; struct b43_bbatt_list bbatt_list;
/* The DC Lookup Table is cached in memory here.
* Note that this is only used for Hardware Power Control. */
u16 dc_lt[B43_DC_LT_SIZE];
/* List of calibrated control values (struct b43_lo_calib). */
struct list_head calib_list;
/* Last time the power vector was read (jiffies). */
unsigned long pwr_vec_read_time;
/* Last time the txctl values were measured (jiffies). */
unsigned long txctl_measured_time;
/* Current TX Bias value */ /* Current TX Bias value */
u8 tx_bias; u8 tx_bias;
/* Current TX Magnification Value (if used by the device) */ /* Current TX Magnification Value (if used by the device) */
u8 tx_magn; u8 tx_magn;
/* GPHY LO is measured. */
bool lo_measured;
/* Saved device PowerVector */ /* Saved device PowerVector */
u64 power_vector; u64 power_vector;
}; };
/* Measure the BPHY Local Oscillator. */ /* Calibration expire timeouts.
void b43_lo_b_measure(struct b43_wldev *dev); * Timeouts must be multiple of 15 seconds. To make sure
/* Measure the BPHY/GPHY Local Oscillator. */ * the item really expired when the 15 second timer hits, we
void b43_lo_g_measure(struct b43_wldev *dev); * subtract two additional seconds from the timeout. */
#define B43_LO_CALIB_EXPIRE (HZ * (30 - 2))
#define B43_LO_PWRVEC_EXPIRE (HZ * (30 - 2))
#define B43_LO_TXCTL_EXPIRE (HZ * (180 - 4))
/* Adjust the Local Oscillator to the saved attenuation /* Adjust the Local Oscillator to the saved attenuation
* and txctl values. * and txctl values.
@ -95,18 +76,10 @@ void b43_lo_g_adjust(struct b43_wldev *dev);
void b43_lo_g_adjust_to(struct b43_wldev *dev, void b43_lo_g_adjust_to(struct b43_wldev *dev,
u16 rfatt, u16 bbatt, u16 tx_control); u16 rfatt, u16 bbatt, u16 tx_control);
/* Mark all possible b43_lo_g_ctl as "unused" */ void b43_gphy_dc_lt_init(struct b43_wldev *dev, bool update_all);
void b43_lo_g_ctl_mark_all_unused(struct b43_wldev *dev);
/* Mark the b43_lo_g_ctl corresponding to the current
* attenuation values as used.
*/
void b43_lo_g_ctl_mark_cur_used(struct b43_wldev *dev);
/* Get a reference to a LO Control value pair in the void b43_lo_g_maintanance_work(struct b43_wldev *dev);
* TX Power LO Control Array. void b43_lo_g_cleanup(struct b43_wldev *dev);
*/ void b43_lo_g_init(struct b43_wldev *dev);
struct b43_loctl *b43_get_lo_g_ctl(struct b43_wldev *dev,
const struct b43_rfatt *rfatt,
const struct b43_bbatt *bbatt);
#endif /* B43_LO_H_ */ #endif /* B43_LO_H_ */

26
drivers/net/wireless/b43/main.c
View file

@ -2308,7 +2308,7 @@ static void b43_gpio_cleanup(struct b43_wldev *dev)
} }
/* http://bcm-specs.sipsolutions.net/EnableMac */ /* http://bcm-specs.sipsolutions.net/EnableMac */
static void b43_mac_enable(struct b43_wldev *dev) void b43_mac_enable(struct b43_wldev *dev)
{ {
dev->mac_suspended--; dev->mac_suspended--;
B43_WARN_ON(dev->mac_suspended < 0); B43_WARN_ON(dev->mac_suspended < 0);
@ -2331,7 +2331,7 @@ static void b43_mac_enable(struct b43_wldev *dev)
} }
/* http://bcm-specs.sipsolutions.net/SuspendMAC */ /* http://bcm-specs.sipsolutions.net/SuspendMAC */
static void b43_mac_suspend(struct b43_wldev *dev) void b43_mac_suspend(struct b43_wldev *dev)
{ {
int i; int i;
u32 tmp; u32 tmp;
@ -2503,6 +2503,7 @@ static void b43_chip_exit(struct b43_wldev *dev)
{ {
b43_radio_turn_off(dev, 1); b43_radio_turn_off(dev, 1);
b43_gpio_cleanup(dev); b43_gpio_cleanup(dev);
b43_lo_g_cleanup(dev);
/* firmware is released later */ /* firmware is released later */
} }
@ -2609,28 +2610,12 @@ static int b43_chip_init(struct b43_wldev *dev)
return err; return err;
} }
static void b43_periodic_every120sec(struct b43_wldev *dev)
{
struct b43_phy *phy = &dev->phy;
if (phy->type != B43_PHYTYPE_G || phy->rev < 2)
return;
b43_mac_suspend(dev);
b43_lo_g_measure(dev);
b43_mac_enable(dev);
if (b43_has_hardware_pctl(phy))
b43_lo_g_ctl_mark_all_unused(dev);
}
static void b43_periodic_every60sec(struct b43_wldev *dev) static void b43_periodic_every60sec(struct b43_wldev *dev)
{ {
struct b43_phy *phy = &dev->phy; struct b43_phy *phy = &dev->phy;
if (phy->type != B43_PHYTYPE_G) if (phy->type != B43_PHYTYPE_G)
return; return;
if (!b43_has_hardware_pctl(phy))
b43_lo_g_ctl_mark_all_unused(dev);
if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_RSSI) { if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_RSSI) {
b43_mac_suspend(dev); b43_mac_suspend(dev);
b43_calc_nrssi_slope(dev); b43_calc_nrssi_slope(dev);
@ -2682,6 +2667,7 @@ static void b43_periodic_every15sec(struct b43_wldev *dev)
} }
} }
b43_phy_xmitpower(dev); //FIXME: unless scanning? b43_phy_xmitpower(dev); //FIXME: unless scanning?
b43_lo_g_maintanance_work(dev);
//TODO for APHY (temperature?) //TODO for APHY (temperature?)
atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT); atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT);
@ -2693,8 +2679,6 @@ static void do_periodic_work(struct b43_wldev *dev)
unsigned int state; unsigned int state;
state = dev->periodic_state; state = dev->periodic_state;
if (state % 8 == 0)
b43_periodic_every120sec(dev);
if (state % 4 == 0) if (state % 4 == 0)
b43_periodic_every60sec(dev); b43_periodic_every60sec(dev);
if (state % 2 == 0) if (state % 2 == 0)
@ -3668,8 +3652,8 @@ static void setup_struct_phy_for_init(struct b43_wldev *dev,
lo = phy->lo_control; lo = phy->lo_control;
if (lo) { if (lo) {
memset(lo, 0, sizeof(*(phy->lo_control))); memset(lo, 0, sizeof(*(phy->lo_control)));
lo->rebuild = 1;
lo->tx_bias = 0xFF; lo->tx_bias = 0xFF;
INIT_LIST_HEAD(&lo->calib_list);
} }
phy->max_lb_gain = 0; phy->max_lb_gain = 0;
phy->trsw_rx_gain = 0; phy->trsw_rx_gain = 0;

3
drivers/net/wireless/b43/main.h
View file

@ -114,4 +114,7 @@ void b43_controller_restart(struct b43_wldev *dev, const char *reason);
#define B43_PS_ASLEEP (1 << 3) /* Force device asleep */ #define B43_PS_ASLEEP (1 << 3) /* Force device asleep */
void b43_power_saving_ctl_bits(struct b43_wldev *dev, unsigned int ps_flags); void b43_power_saving_ctl_bits(struct b43_wldev *dev, unsigned int ps_flags);
void b43_mac_suspend(struct b43_wldev *dev);
void b43_mac_enable(struct b43_wldev *dev);
#endif /* B43_MAIN_H_ */ #endif /* B43_MAIN_H_ */

123
drivers/net/wireless/b43/phy.c
View file

@ -145,8 +145,7 @@ static void generate_rfatt_list(struct b43_wldev *dev,
{.att = 9,.with_padmix = 1,}, {.att = 9,.with_padmix = 1,},
}; };
if ((phy->type == B43_PHYTYPE_A && phy->rev < 5) || if (!b43_has_hardware_pctl(phy)) {
(phy->type == B43_PHYTYPE_G && phy->rev < 6)) {
/* Software pctl */ /* Software pctl */
list->list = rfatt_0; list->list = rfatt_0;
list->len = ARRAY_SIZE(rfatt_0); list->len = ARRAY_SIZE(rfatt_0);
@ -158,7 +157,7 @@ static void generate_rfatt_list(struct b43_wldev *dev,
/* Hardware pctl */ /* Hardware pctl */
list->list = rfatt_1; list->list = rfatt_1;
list->len = ARRAY_SIZE(rfatt_1); list->len = ARRAY_SIZE(rfatt_1);
list->min_val = 2; list->min_val = 0;
list->max_val = 14; list->max_val = 14;
return; return;
} }
@ -346,6 +345,7 @@ void b43_set_txpower_g(struct b43_wldev *dev,
/* Save the values for later */ /* Save the values for later */
phy->tx_control = tx_control; phy->tx_control = tx_control;
memcpy(&phy->rfatt, rfatt, sizeof(*rfatt)); memcpy(&phy->rfatt, rfatt, sizeof(*rfatt));
phy->rfatt.with_padmix = !!(tx_control & B43_TXCTL_TXMIX);
memcpy(&phy->bbatt, bbatt, sizeof(*bbatt)); memcpy(&phy->bbatt, bbatt, sizeof(*bbatt));
if (b43_debug(dev, B43_DBG_XMITPOWER)) { if (b43_debug(dev, B43_DBG_XMITPOWER)) {
@ -559,11 +559,6 @@ static void b43_gphy_gain_lt_init(struct b43_wldev *dev)
u16 tmp; u16 tmp;
u8 rf, bb; u8 rf, bb;
if (!lo->lo_measured) {
b43_phy_write(dev, 0x3FF, 0);
return;
}
for (rf = 0; rf < lo->rfatt_list.len; rf++) { for (rf = 0; rf < lo->rfatt_list.len; rf++) {
for (bb = 0; bb < lo->bbatt_list.len; bb++) { for (bb = 0; bb < lo->bbatt_list.len; bb++) {
if (nr_written >= 0x40) if (nr_written >= 0x40)
@ -581,42 +576,6 @@ static void b43_gphy_gain_lt_init(struct b43_wldev *dev)
} }
} }
/* GPHY_DC_Lookup_Table */
void b43_gphy_dc_lt_init(struct b43_wldev *dev)
{
struct b43_phy *phy = &dev->phy;
struct b43_txpower_lo_control *lo = phy->lo_control;
struct b43_loctl *loctl0;
struct b43_loctl *loctl1;
int i;
int rf_offset, bb_offset;
u16 tmp;
for (i = 0; i < lo->rfatt_list.len + lo->bbatt_list.len; i += 2) {
rf_offset = i / lo->rfatt_list.len;
bb_offset = i % lo->rfatt_list.len;
loctl0 = b43_get_lo_g_ctl(dev, &lo->rfatt_list.list[rf_offset],
&lo->bbatt_list.list[bb_offset]);
if (i + 1 < lo->rfatt_list.len * lo->bbatt_list.len) {
rf_offset = (i + 1) / lo->rfatt_list.len;
bb_offset = (i + 1) % lo->rfatt_list.len;
loctl1 =
b43_get_lo_g_ctl(dev,
&lo->rfatt_list.list[rf_offset],
&lo->bbatt_list.list[bb_offset]);
} else
loctl1 = loctl0;
tmp = ((u16) loctl0->q & 0xF);
tmp |= ((u16) loctl0->i & 0xF) << 4;
tmp |= ((u16) loctl1->q & 0xF) << 8;
tmp |= ((u16) loctl1->i & 0xF) << 12; //FIXME?
b43_phy_write(dev, 0x3A0 + (i / 2), tmp);
}
}
static void hardware_pctl_init_aphy(struct b43_wldev *dev) static void hardware_pctl_init_aphy(struct b43_wldev *dev)
{ {
//TODO //TODO
@ -643,7 +602,7 @@ static void hardware_pctl_init_gphy(struct b43_wldev *dev)
b43_phy_write(dev, 0x0801, b43_phy_read(dev, 0x0801) b43_phy_write(dev, 0x0801, b43_phy_read(dev, 0x0801)
& 0xFFBF); & 0xFFBF);
b43_gphy_dc_lt_init(dev); b43_gphy_dc_lt_init(dev, 1);
} }
/* HardwarePowerControl init for A and G PHY */ /* HardwarePowerControl init for A and G PHY */
@ -967,7 +926,7 @@ static void b43_phy_initb2(struct b43_wldev *dev)
b43_phy_write(dev, 0x0032, 0x00CA); b43_phy_write(dev, 0x0032, 0x00CA);
b43_phy_write(dev, 0x0032, 0x00CC); b43_phy_write(dev, 0x0032, 0x00CC);
b43_phy_write(dev, 0x0035, 0x07C2); b43_phy_write(dev, 0x0035, 0x07C2);
b43_lo_b_measure(dev); //XXX won't trigger b43_lo_b_measure(dev);
b43_phy_write(dev, 0x0026, 0xCC00); b43_phy_write(dev, 0x0026, 0xCC00);
if (phy->radio_ver != 0x2050) if (phy->radio_ver != 0x2050)
b43_phy_write(dev, 0x0026, 0xCE00); b43_phy_write(dev, 0x0026, 0xCE00);
@ -1017,7 +976,7 @@ static void b43_phy_initb4(struct b43_wldev *dev)
b43_phy_write(dev, 0x0032, 0x00E0); b43_phy_write(dev, 0x0032, 0x00E0);
b43_phy_write(dev, 0x0035, 0x07C2); b43_phy_write(dev, 0x0035, 0x07C2);
b43_lo_b_measure(dev); //XXX won't trigger b43_lo_b_measure(dev);
b43_phy_write(dev, 0x0026, 0xCC00); b43_phy_write(dev, 0x0026, 0xCC00);
if (phy->radio_ver == 0x2050) if (phy->radio_ver == 0x2050)
@ -1259,19 +1218,9 @@ static void b43_phy_initb6(struct b43_wldev *dev)
b43_phy_write(dev, 0x0002, (b43_phy_read(dev, 0x0002) & 0xFFC0) b43_phy_write(dev, 0x0002, (b43_phy_read(dev, 0x0002) & 0xFFC0)
| 0x0004); | 0x0004);
} }
if (phy->type == B43_PHYTYPE_B) { if (phy->type == B43_PHYTYPE_B)
b43_write16(dev, 0x03E6, 0x8140); B43_WARN_ON(1);
b43_phy_write(dev, 0x0016, 0x0410); else if (phy->type == B43_PHYTYPE_G)
b43_phy_write(dev, 0x0017, 0x0820);
b43_phy_write(dev, 0x0062, 0x0007);
b43_radio_init2050(dev);
b43_lo_g_measure(dev);
if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_RSSI) {
b43_calc_nrssi_slope(dev);
b43_calc_nrssi_threshold(dev);
}
b43_phy_init_pctl(dev);
} else if (phy->type == B43_PHYTYPE_G)
b43_write16(dev, 0x03E6, 0x0); b43_write16(dev, 0x03E6, 0x0);
} }
@ -1534,34 +1483,31 @@ static void b43_phy_initg(struct b43_wldev *dev)
else else
b43_radio_write16(dev, 0x0078, phy->initval); b43_radio_write16(dev, 0x0078, phy->initval);
} }
if (phy->lo_control->tx_bias == 0xFF) { b43_lo_g_init(dev);
b43_lo_g_measure(dev); if (has_tx_magnification(phy)) {
b43_radio_write16(dev, 0x52,
(b43_radio_read16(dev, 0x52) & 0xFF00)
| phy->lo_control->tx_bias | phy->
lo_control->tx_magn);
} else { } else {
if (has_tx_magnification(phy)) { b43_radio_write16(dev, 0x52,
b43_radio_write16(dev, 0x52, (b43_radio_read16(dev, 0x52) & 0xFFF0)
(b43_radio_read16(dev, 0x52) & 0xFF00) | phy->lo_control->tx_bias);
| phy->lo_control->tx_bias | phy->
lo_control->tx_magn);
} else {
b43_radio_write16(dev, 0x52,
(b43_radio_read16(dev, 0x52) & 0xFFF0)
| phy->lo_control->tx_bias);
}
if (phy->rev >= 6) {
b43_phy_write(dev, B43_PHY_CCK(0x36),
(b43_phy_read(dev, B43_PHY_CCK(0x36))
& 0x0FFF) | (phy->lo_control->
tx_bias << 12));
}
if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_PACTRL)
b43_phy_write(dev, B43_PHY_CCK(0x2E), 0x8075);
else
b43_phy_write(dev, B43_PHY_CCK(0x2E), 0x807F);
if (phy->rev < 2)
b43_phy_write(dev, B43_PHY_CCK(0x2F), 0x101);
else
b43_phy_write(dev, B43_PHY_CCK(0x2F), 0x202);
} }
if (phy->rev >= 6) {
b43_phy_write(dev, B43_PHY_CCK(0x36),
(b43_phy_read(dev, B43_PHY_CCK(0x36))
& 0x0FFF) | (phy->lo_control->
tx_bias << 12));
}
if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_PACTRL)
b43_phy_write(dev, B43_PHY_CCK(0x2E), 0x8075);
else
b43_phy_write(dev, B43_PHY_CCK(0x2E), 0x807F);
if (phy->rev < 2)
b43_phy_write(dev, B43_PHY_CCK(0x2F), 0x101);
else
b43_phy_write(dev, B43_PHY_CCK(0x2F), 0x202);
if (phy->gmode || phy->rev >= 2) { if (phy->gmode || phy->rev >= 2) {
b43_lo_g_adjust(dev); b43_lo_g_adjust(dev);
b43_phy_write(dev, B43_PHY_LO_MASK, 0x8078); b43_phy_write(dev, B43_PHY_LO_MASK, 0x8078);
@ -1821,10 +1767,8 @@ void b43_phy_xmitpower(struct b43_wldev *dev)
bbatt_delta -= 4 * rfatt_delta; bbatt_delta -= 4 * rfatt_delta;
/* So do we finally need to adjust something? */ /* So do we finally need to adjust something? */
if ((rfatt_delta == 0) && (bbatt_delta == 0)) { if ((rfatt_delta == 0) && (bbatt_delta == 0))
b43_lo_g_ctl_mark_cur_used(dev);
return; return;
}
/* Calculate the new attenuation values. */ /* Calculate the new attenuation values. */
bbatt = phy->bbatt.att; bbatt = phy->bbatt.att;
@ -1870,7 +1814,6 @@ void b43_phy_xmitpower(struct b43_wldev *dev)
b43_radio_lock(dev); b43_radio_lock(dev);
b43_set_txpower_g(dev, &phy->bbatt, &phy->rfatt, b43_set_txpower_g(dev, &phy->bbatt, &phy->rfatt,
phy->tx_control); phy->tx_control);
b43_lo_g_ctl_mark_cur_used(dev);
b43_radio_unlock(dev); b43_radio_unlock(dev);
b43_phy_unlock(dev); b43_phy_unlock(dev);
break; break;

16
drivers/net/wireless/b43/phy.h
View file

@ -225,7 +225,6 @@ int b43_phy_init(struct b43_wldev *dev);
void b43_set_rx_antenna(struct b43_wldev *dev, int antenna); void b43_set_rx_antenna(struct b43_wldev *dev, int antenna);
void b43_phy_xmitpower(struct b43_wldev *dev); void b43_phy_xmitpower(struct b43_wldev *dev);
void b43_gphy_dc_lt_init(struct b43_wldev *dev);
/* Returns the boolean whether the board has HardwarePowerControl */ /* Returns the boolean whether the board has HardwarePowerControl */
bool b43_has_hardware_pctl(struct b43_phy *phy); bool b43_has_hardware_pctl(struct b43_phy *phy);
@ -252,6 +251,14 @@ struct b43_rfatt_list {
u8 max_val; u8 max_val;
}; };
/* Returns true, if the values are the same. */
static inline bool b43_compare_rfatt(const struct b43_rfatt *a,
const struct b43_rfatt *b)
{
return ((a->att == b->att) &&
(a->with_padmix == b->with_padmix));
}
/* Baseband Attenuation */ /* Baseband Attenuation */
struct b43_bbatt { struct b43_bbatt {
u8 att; /* Attenuation value */ u8 att; /* Attenuation value */
@ -265,6 +272,13 @@ struct b43_bbatt_list {
u8 max_val; u8 max_val;
}; };
/* Returns true, if the values are the same. */
static inline bool b43_compare_bbatt(const struct b43_bbatt *a,
const struct b43_bbatt *b)
{
return (a->att == b->att);
}
/* tx_control bits. */ /* tx_control bits. */
#define B43_TXCTL_PA3DB 0x40 /* PA Gain 3dB */ #define B43_TXCTL_PA3DB 0x40 /* PA Gain 3dB */
#define B43_TXCTL_PA2DB 0x20 /* PA Gain 2dB */ #define B43_TXCTL_PA2DB 0x20 /* PA Gain 2dB */