hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next-2.6

This commit is contained in:
David S. Miller 2009-02-09 23:30:44 -08:00
parent 4cdc44a231 99e0fca674
commit 4b53b361e0
101 changed files with 4276 additions and 2805 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
drivers/net/wireless/ath5k/base.c
View File

@ -310,6 +310,19 @@ static inline void ath5k_txbuf_free(struct ath5k_softc *sc,
bf->skb = NULL; bf->skb = NULL;
} }
static inline void ath5k_rxbuf_free(struct ath5k_softc *sc,
struct ath5k_buf *bf)
{
BUG_ON(!bf);
if (!bf->skb)
return;
pci_unmap_single(sc->pdev, bf->skbaddr, sc->rxbufsize,
PCI_DMA_FROMDEVICE);
dev_kfree_skb_any(bf->skb);
bf->skb = NULL;
}
/* Queues setup */ /* Queues setup */
static struct ath5k_txq *ath5k_txq_setup(struct ath5k_softc *sc, static struct ath5k_txq *ath5k_txq_setup(struct ath5k_softc *sc,
int qtype, int subtype); int qtype, int subtype);
@ -1343,7 +1356,7 @@ ath5k_desc_free(struct ath5k_softc *sc, struct pci_dev *pdev)
list_for_each_entry(bf, &sc->txbuf, list) list_for_each_entry(bf, &sc->txbuf, list)
ath5k_txbuf_free(sc, bf); ath5k_txbuf_free(sc, bf);
list_for_each_entry(bf, &sc->rxbuf, list) list_for_each_entry(bf, &sc->rxbuf, list)
ath5k_txbuf_free(sc, bf); ath5k_rxbuf_free(sc, bf);
/* Free memory associated with all descriptors */ /* Free memory associated with all descriptors */
pci_free_consistent(pdev, sc->desc_len, sc->desc, sc->desc_daddr); pci_free_consistent(pdev, sc->desc_len, sc->desc, sc->desc_daddr);

35
drivers/net/wireless/ath9k/core.h
View File

@ -131,8 +131,18 @@ struct ath_interrupt_stats {
u32 dtim; u32 dtim;
}; };
struct ath_legacy_rc_stats {
u32 success;
};
struct ath_11n_rc_stats {
u32 success;
};
struct ath_stats { struct ath_stats {
struct ath_interrupt_stats istats; struct ath_interrupt_stats istats;
struct ath_legacy_rc_stats legacy_rcstats[12]; /* max(11a,11b,11g) */
struct ath_11n_rc_stats n_rcstats[16]; /* 0..15 MCS rates */
}; };
struct ath9k_debug { struct ath9k_debug {
@ -141,6 +151,7 @@ struct ath9k_debug {
struct dentry *debugfs_phy; struct dentry *debugfs_phy;
struct dentry *debugfs_dma; struct dentry *debugfs_dma;
struct dentry *debugfs_interrupt; struct dentry *debugfs_interrupt;
struct dentry *debugfs_rcstat;
struct ath_stats stats; struct ath_stats stats;
}; };
@ -148,6 +159,7 @@ void DPRINTF(struct ath_softc *sc, int dbg_mask, const char *fmt, ...);
int ath9k_init_debug(struct ath_softc *sc); int ath9k_init_debug(struct ath_softc *sc);
void ath9k_exit_debug(struct ath_softc *sc); void ath9k_exit_debug(struct ath_softc *sc);
void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status); void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status);
void ath_debug_stat_rc(struct ath_softc *sc, struct sk_buff *skb);
#else #else
@ -170,6 +182,11 @@ static inline void ath_debug_stat_interrupt(struct ath_softc *sc,
{ {
} }
static inline void ath_debug_stat_rc(struct ath_softc *sc,
struct sk_buff *skb)
{
}
#endif /* CONFIG_ATH9K_DEBUG */ #endif /* CONFIG_ATH9K_DEBUG */
struct ath_config { struct ath_config {
@ -233,7 +250,6 @@ struct ath_buf_state {
#define bf_isht(bf) (bf->bf_state.bf_type & BUF_HT) #define bf_isht(bf) (bf->bf_state.bf_type & BUF_HT)
#define bf_isretried(bf) (bf->bf_state.bf_type & BUF_RETRY) #define bf_isretried(bf) (bf->bf_state.bf_type & BUF_RETRY)
#define bf_isxretried(bf) (bf->bf_state.bf_type & BUF_XRETRY) #define bf_isxretried(bf) (bf->bf_state.bf_type & BUF_XRETRY)
#define bf_isshpreamble(bf) (bf->bf_state.bf_type & BUF_SHORT_PREAMBLE)
#define bf_isbar(bf) (bf->bf_state.bf_type & BUF_BAR) #define bf_isbar(bf) (bf->bf_state.bf_type & BUF_BAR)
#define bf_ispspoll(bf) (bf->bf_state.bf_type & BUF_PSPOLL) #define bf_ispspoll(bf) (bf->bf_state.bf_type & BUF_PSPOLL)
#define bf_isaggrburst(bf) (bf->bf_state.bf_type & BUF_AGGR_BURST) #define bf_isaggrburst(bf) (bf->bf_state.bf_type & BUF_AGGR_BURST)
@ -600,6 +616,8 @@ struct ath_ani {
/********************/ /********************/
#define ATH_LED_PIN 1 #define ATH_LED_PIN 1
#define ATH_LED_ON_DURATION_IDLE 350 /* in msecs */
#define ATH_LED_OFF_DURATION_IDLE 250 /* in msecs */
enum ath_led_type { enum ath_led_type {
ATH_LED_RADIO, ATH_LED_RADIO,
@ -656,12 +674,6 @@ struct ath_rfkill {
#define ATH_RSSI_DUMMY_MARKER 0x127 #define ATH_RSSI_DUMMY_MARKER 0x127
#define ATH_RATE_DUMMY_MARKER 0 #define ATH_RATE_DUMMY_MARKER 0
enum PROT_MODE {
PROT_M_NONE = 0,
PROT_M_RTSCTS,
PROT_M_CTSONLY
};
#define SC_OP_INVALID BIT(0) #define SC_OP_INVALID BIT(0)
#define SC_OP_BEACONS BIT(1) #define SC_OP_BEACONS BIT(1)
#define SC_OP_RXAGGR BIT(2) #define SC_OP_RXAGGR BIT(2)
@ -677,6 +689,7 @@ enum PROT_MODE {
#define SC_OP_RFKILL_SW_BLOCKED BIT(12) #define SC_OP_RFKILL_SW_BLOCKED BIT(12)
#define SC_OP_RFKILL_HW_BLOCKED BIT(13) #define SC_OP_RFKILL_HW_BLOCKED BIT(13)
#define SC_OP_WAIT_FOR_BEACON BIT(14) #define SC_OP_WAIT_FOR_BEACON BIT(14)
#define SC_OP_LED_ON BIT(15)
struct ath_bus_ops { struct ath_bus_ops {
void (*read_cachesize)(struct ath_softc *sc, int *csz); void (*read_cachesize)(struct ath_softc *sc, int *csz);
@ -712,7 +725,6 @@ struct ath_softc {
u8 sc_splitmic; u8 sc_splitmic;
atomic_t ps_usecount; atomic_t ps_usecount;
enum ath9k_int sc_imask; enum ath9k_int sc_imask;
enum PROT_MODE sc_protmode;
enum ath9k_ht_extprotspacing sc_ht_extprotspacing; enum ath9k_ht_extprotspacing sc_ht_extprotspacing;
enum ath9k_ht_macmode tx_chan_width; enum ath9k_ht_macmode tx_chan_width;
@ -725,10 +737,17 @@ struct ath_softc {
struct ath_rate_table *hw_rate_table[ATH9K_MODE_MAX]; struct ath_rate_table *hw_rate_table[ATH9K_MODE_MAX];
struct ath_rate_table *cur_rate_table; struct ath_rate_table *cur_rate_table;
struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS]; struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS];
struct ath_led radio_led; struct ath_led radio_led;
struct ath_led assoc_led; struct ath_led assoc_led;
struct ath_led tx_led; struct ath_led tx_led;
struct ath_led rx_led; struct ath_led rx_led;
struct delayed_work ath_led_blink_work;
int led_on_duration;
int led_off_duration;
int led_on_cnt;
int led_off_cnt;
struct ath_rfkill rf_kill; struct ath_rfkill rf_kill;
struct ath_ani sc_ani; struct ath_ani sc_ani;
struct ath9k_node_stats sc_halstats; struct ath9k_node_stats sc_halstats;

100
drivers/net/wireless/ath9k/debug.c
View File

@ -222,6 +222,98 @@ static const struct file_operations fops_interrupt = {
.owner = THIS_MODULE .owner = THIS_MODULE
}; };
static void ath_debug_stat_11n_rc(struct ath_softc *sc, struct sk_buff *skb)
{
struct ath_tx_info_priv *tx_info_priv = NULL;
struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
struct ieee80211_tx_rate *rates = tx_info->status.rates;
int final_ts_idx, idx;
tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
final_ts_idx = tx_info_priv->tx.ts_rateindex;
idx = sc->cur_rate_table->info[rates[final_ts_idx].idx].dot11rate;
sc->sc_debug.stats.n_rcstats[idx].success++;
}
static void ath_debug_stat_legacy_rc(struct ath_softc *sc, struct sk_buff *skb)
{
struct ath_tx_info_priv *tx_info_priv = NULL;
struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
struct ieee80211_tx_rate *rates = tx_info->status.rates;
int final_ts_idx, idx;
tx_info_priv = ATH_TX_INFO_PRIV(tx_info);
final_ts_idx = tx_info_priv->tx.ts_rateindex;
idx = rates[final_ts_idx].idx;
sc->sc_debug.stats.legacy_rcstats[idx].success++;
}
void ath_debug_stat_rc(struct ath_softc *sc, struct sk_buff *skb)
{
if (conf_is_ht(&sc->hw->conf))
ath_debug_stat_11n_rc(sc, skb);
else
ath_debug_stat_legacy_rc(sc, skb);
}
static ssize_t ath_read_file_stat_11n_rc(struct file *file,
char __user *user_buf,
size_t count, loff_t *ppos)
{
struct ath_softc *sc = file->private_data;
char buf[512];
unsigned int len = 0;
int i = 0;
len += sprintf(buf, "%7s %13s\n\n", "Rate", "Success");
for (i = 0; i <= 15; i++) {
len += snprintf(buf + len, sizeof(buf) - len,
"%5s%3d: %8u\n", "MCS", i,
sc->sc_debug.stats.n_rcstats[i].success);
}
return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}
static ssize_t ath_read_file_stat_legacy_rc(struct file *file,
char __user *user_buf,
size_t count, loff_t *ppos)
{
struct ath_softc *sc = file->private_data;
char buf[512];
unsigned int len = 0;
int i = 0;
len += sprintf(buf, "%7s %13s\n\n", "Rate", "Success");
for (i = 0; i < sc->cur_rate_table->rate_cnt; i++) {
len += snprintf(buf + len, sizeof(buf) - len, "%5u: %12u\n",
sc->cur_rate_table->info[i].ratekbps / 1000,
sc->sc_debug.stats.legacy_rcstats[i].success);
}
return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}
static ssize_t read_file_rcstat(struct file *file, char __user *user_buf,
size_t count, loff_t *ppos)
{
struct ath_softc *sc = file->private_data;
if (conf_is_ht(&sc->hw->conf))
return ath_read_file_stat_11n_rc(file, user_buf, count, ppos);
else
return ath_read_file_stat_legacy_rc(file, user_buf, count ,ppos);
}
static const struct file_operations fops_rcstat = {
.read = read_file_rcstat,
.open = ath9k_debugfs_open,
.owner = THIS_MODULE
};
int ath9k_init_debug(struct ath_softc *sc) int ath9k_init_debug(struct ath_softc *sc)
{ {
@ -248,6 +340,13 @@ int ath9k_init_debug(struct ath_softc *sc)
if (!sc->sc_debug.debugfs_interrupt) if (!sc->sc_debug.debugfs_interrupt)
goto err; goto err;
sc->sc_debug.debugfs_rcstat = debugfs_create_file("rcstat",
S_IRUGO,
sc->sc_debug.debugfs_phy,
sc, &fops_rcstat);
if (!sc->sc_debug.debugfs_rcstat)
goto err;
return 0; return 0;
err: err:
ath9k_exit_debug(sc); ath9k_exit_debug(sc);
@ -256,6 +355,7 @@ err:
void ath9k_exit_debug(struct ath_softc *sc) void ath9k_exit_debug(struct ath_softc *sc)
{ {
debugfs_remove(sc->sc_debug.debugfs_rcstat);
debugfs_remove(sc->sc_debug.debugfs_interrupt); debugfs_remove(sc->sc_debug.debugfs_interrupt);
debugfs_remove(sc->sc_debug.debugfs_dma); debugfs_remove(sc->sc_debug.debugfs_dma);
debugfs_remove(sc->sc_debug.debugfs_phy); debugfs_remove(sc->sc_debug.debugfs_phy);

2
drivers/net/wireless/ath9k/hw.c
View File

@ -267,7 +267,7 @@ static int ath9k_hw_get_radiorev(struct ath_hal *ah)
static void ath9k_hw_disablepcie(struct ath_hal *ah) static void ath9k_hw_disablepcie(struct ath_hal *ah)
{ {
if (!AR_SREV_9100(ah)) if (AR_SREV_9100(ah))
return; return;
REG_WRITE(ah, AR_PCIE_SERDES, 0x9248fc00); REG_WRITE(ah, AR_PCIE_SERDES, 0x9248fc00);

3
drivers/net/wireless/ath9k/mac.c
View File

@ -344,9 +344,6 @@ void ath9k_hw_set11n_ratescenario(struct ath_hal *ah, struct ath_desc *ds,
struct ar5416_desc *last_ads = AR5416DESC(lastds); struct ar5416_desc *last_ads = AR5416DESC(lastds);
u32 ds_ctl0; u32 ds_ctl0;
(void) nseries;
(void) rtsctsDuration;
if (flags & (ATH9K_TXDESC_RTSENA | ATH9K_TXDESC_CTSENA)) { if (flags & (ATH9K_TXDESC_RTSENA | ATH9K_TXDESC_CTSENA)) {
ds_ctl0 = ads->ds_ctl0; ds_ctl0 = ads->ds_ctl0;

102
drivers/net/wireless/ath9k/main.c
View File

@ -935,6 +935,32 @@ static void ath9k_bss_assoc_info(struct ath_softc *sc,
/* LED functions */ /* LED functions */
/********************************/ /********************************/
static void ath_led_blink_work(struct work_struct *work)
{
struct ath_softc *sc = container_of(work, struct ath_softc,
ath_led_blink_work.work);
if (!(sc->sc_flags & SC_OP_LED_ASSOCIATED))
return;
ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN,
(sc->sc_flags & SC_OP_LED_ON) ? 1 : 0);
queue_delayed_work(sc->hw->workqueue, &sc->ath_led_blink_work,
(sc->sc_flags & SC_OP_LED_ON) ?
msecs_to_jiffies(sc->led_off_duration) :
msecs_to_jiffies(sc->led_on_duration));
sc->led_on_duration =
max((ATH_LED_ON_DURATION_IDLE - sc->led_on_cnt), 25);
sc->led_off_duration =
max((ATH_LED_OFF_DURATION_IDLE - sc->led_off_cnt), 10);
sc->led_on_cnt = sc->led_off_cnt = 0;
if (sc->sc_flags & SC_OP_LED_ON)
sc->sc_flags &= ~SC_OP_LED_ON;
else
sc->sc_flags |= SC_OP_LED_ON;
}
static void ath_led_brightness(struct led_classdev *led_cdev, static void ath_led_brightness(struct led_classdev *led_cdev,
enum led_brightness brightness) enum led_brightness brightness)
{ {
@ -944,16 +970,27 @@ static void ath_led_brightness(struct led_classdev *led_cdev,
switch (brightness) { switch (brightness) {
case LED_OFF: case LED_OFF:
if (led->led_type == ATH_LED_ASSOC || if (led->led_type == ATH_LED_ASSOC ||
led->led_type == ATH_LED_RADIO) led->led_type == ATH_LED_RADIO) {
ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN,
(led->led_type == ATH_LED_RADIO));
sc->sc_flags &= ~SC_OP_LED_ASSOCIATED; sc->sc_flags &= ~SC_OP_LED_ASSOCIATED;
ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, if (led->led_type == ATH_LED_RADIO)
(led->led_type == ATH_LED_RADIO) ? 1 : sc->sc_flags &= ~SC_OP_LED_ON;
!!(sc->sc_flags & SC_OP_LED_ASSOCIATED)); } else {
sc->led_off_cnt++;
}
break; break;
case LED_FULL: case LED_FULL:
if (led->led_type == ATH_LED_ASSOC) if (led->led_type == ATH_LED_ASSOC) {
sc->sc_flags |= SC_OP_LED_ASSOCIATED; sc->sc_flags |= SC_OP_LED_ASSOCIATED;
ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 0); queue_delayed_work(sc->hw->workqueue,
&sc->ath_led_blink_work, 0);
} else if (led->led_type == ATH_LED_RADIO) {
ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 0);
sc->sc_flags |= SC_OP_LED_ON;
} else {
sc->led_on_cnt++;
}
break; break;
default: default:
break; break;
@ -989,6 +1026,7 @@ static void ath_unregister_led(struct ath_led *led)
static void ath_deinit_leds(struct ath_softc *sc) static void ath_deinit_leds(struct ath_softc *sc)
{ {
cancel_delayed_work_sync(&sc->ath_led_blink_work);
ath_unregister_led(&sc->assoc_led); ath_unregister_led(&sc->assoc_led);
sc->sc_flags &= ~SC_OP_LED_ASSOCIATED; sc->sc_flags &= ~SC_OP_LED_ASSOCIATED;
ath_unregister_led(&sc->tx_led); ath_unregister_led(&sc->tx_led);
@ -1008,9 +1046,11 @@ static void ath_init_leds(struct ath_softc *sc)
/* LED off, active low */ /* LED off, active low */
ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 1); ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 1);
INIT_DELAYED_WORK(&sc->ath_led_blink_work, ath_led_blink_work);
trigger = ieee80211_get_radio_led_name(sc->hw); trigger = ieee80211_get_radio_led_name(sc->hw);
snprintf(sc->radio_led.name, sizeof(sc->radio_led.name), snprintf(sc->radio_led.name, sizeof(sc->radio_led.name),
"ath9k-%s:radio", wiphy_name(sc->hw->wiphy)); "ath9k-%s::radio", wiphy_name(sc->hw->wiphy));
ret = ath_register_led(sc, &sc->radio_led, trigger); ret = ath_register_led(sc, &sc->radio_led, trigger);
sc->radio_led.led_type = ATH_LED_RADIO; sc->radio_led.led_type = ATH_LED_RADIO;
if (ret) if (ret)
@ -1018,7 +1058,7 @@ static void ath_init_leds(struct ath_softc *sc)
trigger = ieee80211_get_assoc_led_name(sc->hw); trigger = ieee80211_get_assoc_led_name(sc->hw);
snprintf(sc->assoc_led.name, sizeof(sc->assoc_led.name), snprintf(sc->assoc_led.name, sizeof(sc->assoc_led.name),
"ath9k-%s:assoc", wiphy_name(sc->hw->wiphy)); "ath9k-%s::assoc", wiphy_name(sc->hw->wiphy));
ret = ath_register_led(sc, &sc->assoc_led, trigger); ret = ath_register_led(sc, &sc->assoc_led, trigger);
sc->assoc_led.led_type = ATH_LED_ASSOC; sc->assoc_led.led_type = ATH_LED_ASSOC;
if (ret) if (ret)
@ -1026,7 +1066,7 @@ static void ath_init_leds(struct ath_softc *sc)
trigger = ieee80211_get_tx_led_name(sc->hw); trigger = ieee80211_get_tx_led_name(sc->hw);
snprintf(sc->tx_led.name, sizeof(sc->tx_led.name), snprintf(sc->tx_led.name, sizeof(sc->tx_led.name),
"ath9k-%s:tx", wiphy_name(sc->hw->wiphy)); "ath9k-%s::tx", wiphy_name(sc->hw->wiphy));
ret = ath_register_led(sc, &sc->tx_led, trigger); ret = ath_register_led(sc, &sc->tx_led, trigger);
sc->tx_led.led_type = ATH_LED_TX; sc->tx_led.led_type = ATH_LED_TX;
if (ret) if (ret)
@ -1034,7 +1074,7 @@ static void ath_init_leds(struct ath_softc *sc)
trigger = ieee80211_get_rx_led_name(sc->hw); trigger = ieee80211_get_rx_led_name(sc->hw);
snprintf(sc->rx_led.name, sizeof(sc->rx_led.name), snprintf(sc->rx_led.name, sizeof(sc->rx_led.name),
"ath9k-%s:rx", wiphy_name(sc->hw->wiphy)); "ath9k-%s::rx", wiphy_name(sc->hw->wiphy));
ret = ath_register_led(sc, &sc->rx_led, trigger); ret = ath_register_led(sc, &sc->rx_led, trigger);
sc->rx_led.led_type = ATH_LED_RX; sc->rx_led.led_type = ATH_LED_RX;
if (ret) if (ret)
@ -1217,7 +1257,7 @@ static int ath_init_sw_rfkill(struct ath_softc *sc)
} }
snprintf(sc->rf_kill.rfkill_name, sizeof(sc->rf_kill.rfkill_name), snprintf(sc->rf_kill.rfkill_name, sizeof(sc->rf_kill.rfkill_name),
"ath9k-%s:rfkill", wiphy_name(sc->hw->wiphy)); "ath9k-%s::rfkill", wiphy_name(sc->hw->wiphy));
sc->rf_kill.rfkill->name = sc->rf_kill.rfkill_name; sc->rf_kill.rfkill->name = sc->rf_kill.rfkill_name;
sc->rf_kill.rfkill->data = sc; sc->rf_kill.rfkill->data = sc;
sc->rf_kill.rfkill->toggle_radio = ath_sw_toggle_radio; sc->rf_kill.rfkill->toggle_radio = ath_sw_toggle_radio;
@ -1957,25 +1997,6 @@ static int ath9k_start(struct ieee80211_hw *hw)
if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT) if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT)
sc->sc_imask |= ATH9K_INT_CST; sc->sc_imask |= ATH9K_INT_CST;
/*
* Enable MIB interrupts when there are hardware phy counters.
* Note we only do this (at the moment) for station mode.
*/
if (ath9k_hw_phycounters(sc->sc_ah) &&
((sc->sc_ah->ah_opmode == NL80211_IFTYPE_STATION) ||
(sc->sc_ah->ah_opmode == NL80211_IFTYPE_ADHOC)))
sc->sc_imask |= ATH9K_INT_MIB;
/*
* Some hardware processes the TIM IE and fires an
* interrupt when the TIM bit is set. For hardware
* that does, if not overridden by configuration,
* enable the TIM interrupt when operating as station.
*/
if ((sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_ENHANCEDPM) &&
(sc->sc_ah->ah_opmode == NL80211_IFTYPE_STATION) &&
!sc->sc_config.swBeaconProcess)
sc->sc_imask |= ATH9K_INT_TIM;
ath_cache_conf_rate(sc, &hw->conf); ath_cache_conf_rate(sc, &hw->conf);
sc->sc_flags &= ~SC_OP_INVALID; sc->sc_flags &= ~SC_OP_INVALID;
@ -2124,6 +2145,27 @@ static int ath9k_add_interface(struct ieee80211_hw *hw,
/* Set the device opmode */ /* Set the device opmode */
sc->sc_ah->ah_opmode = ic_opmode; sc->sc_ah->ah_opmode = ic_opmode;
/*
* Enable MIB interrupts when there are hardware phy counters.
* Note we only do this (at the moment) for station mode.
*/
if (ath9k_hw_phycounters(sc->sc_ah) &&
((conf->type == NL80211_IFTYPE_STATION) ||
(conf->type == NL80211_IFTYPE_ADHOC)))
sc->sc_imask |= ATH9K_INT_MIB;
/*
* Some hardware processes the TIM IE and fires an
* interrupt when the TIM bit is set. For hardware
* that does, if not overridden by configuration,
* enable the TIM interrupt when operating as station.
*/
if ((sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_ENHANCEDPM) &&
(conf->type == NL80211_IFTYPE_STATION) &&
!sc->sc_config.swBeaconProcess)
sc->sc_imask |= ATH9K_INT_TIM;
ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_imask);
if (conf->type == NL80211_IFTYPE_AP) { if (conf->type == NL80211_IFTYPE_AP) {
/* TODO: is this a suitable place to start ANI for AP mode? */ /* TODO: is this a suitable place to start ANI for AP mode? */
/* Start ANI */ /* Start ANI */

175
drivers/net/wireless/ath9k/rc.c
View File

@ -631,8 +631,7 @@ static u8 ath_rc_setvalid_htrates(struct ath_rate_priv *ath_rc_priv,
static u8 ath_rc_ratefind_ht(struct ath_softc *sc, static u8 ath_rc_ratefind_ht(struct ath_softc *sc,
struct ath_rate_priv *ath_rc_priv, struct ath_rate_priv *ath_rc_priv,
struct ath_rate_table *rate_table, struct ath_rate_table *rate_table,
int probe_allowed, int *is_probing, int *is_probing)
int is_retry)
{ {
u32 dt, best_thruput, this_thruput, now_msec; u32 dt, best_thruput, this_thruput, now_msec;
u8 rate, next_rate, best_rate, maxindex, minindex; u8 rate, next_rate, best_rate, maxindex, minindex;
@ -714,13 +713,6 @@ static u8 ath_rc_ratefind_ht(struct ath_softc *sc,
} }
rate = best_rate; rate = best_rate;
/* if we are retrying for more than half the number
* of max retries, use the min rate for the next retry
*/
if (is_retry)
rate = ath_rc_priv->valid_rate_index[minindex];
ath_rc_priv->rssi_last_lookup = rssi_last; ath_rc_priv->rssi_last_lookup = rssi_last;
/* /*
@ -728,13 +720,12 @@ static u8 ath_rc_ratefind_ht(struct ath_softc *sc,
* non-monoticity of 11g's rate table * non-monoticity of 11g's rate table
*/ */
if (rate >= ath_rc_priv->rate_max_phy && probe_allowed) { if (rate >= ath_rc_priv->rate_max_phy) {
rate = ath_rc_priv->rate_max_phy; rate = ath_rc_priv->rate_max_phy;
/* Probe the next allowed phy state */ /* Probe the next allowed phy state */
/* FIXME:XXXX Check to make sure ratMax is checked properly */
if (ath_rc_get_nextvalid_txrate(rate_table, if (ath_rc_get_nextvalid_txrate(rate_table,
ath_rc_priv, rate, &next_rate) && ath_rc_priv, rate, &next_rate) &&
(now_msec - ath_rc_priv->probe_time > (now_msec - ath_rc_priv->probe_time >
rate_table->probe_interval) && rate_table->probe_interval) &&
(ath_rc_priv->hw_maxretry_pktcnt >= 1)) { (ath_rc_priv->hw_maxretry_pktcnt >= 1)) {
@ -756,14 +747,17 @@ static u8 ath_rc_ratefind_ht(struct ath_softc *sc,
return rate; return rate;
} }
static void ath_rc_rate_set_series(struct ath_rate_table *rate_table , static void ath_rc_rate_set_series(struct ath_rate_table *rate_table,
struct ieee80211_tx_rate *rate, struct ieee80211_tx_rate *rate,
struct ieee80211_tx_rate_control *txrc,
u8 tries, u8 rix, int rtsctsenable) u8 tries, u8 rix, int rtsctsenable)
{ {
rate->count = tries; rate->count = tries;
rate->idx = rix; rate->idx = rix;
if (rtsctsenable) if (txrc->short_preamble)
rate->flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
if (txrc->rts || rtsctsenable)
rate->flags |= IEEE80211_TX_RC_USE_RTS_CTS; rate->flags |= IEEE80211_TX_RC_USE_RTS_CTS;
if (WLAN_RC_PHY_40(rate_table->info[rix].phy)) if (WLAN_RC_PHY_40(rate_table->info[rix].phy))
rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH; rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
@ -773,6 +767,43 @@ static void ath_rc_rate_set_series(struct ath_rate_table *rate_table ,
rate->flags |= IEEE80211_TX_RC_MCS; rate->flags |= IEEE80211_TX_RC_MCS;
} }
static void ath_rc_rate_set_rtscts(struct ath_softc *sc,
struct ath_rate_table *rate_table,
struct ieee80211_tx_info *tx_info)
{
struct ieee80211_tx_rate *rates = tx_info->control.rates;
int i = 0, rix = 0, cix, enable_g_protection = 0;
/* get the cix for the lowest valid rix */
for (i = 3; i >= 0; i--) {
if (rates[i].count && (rates[i].idx >= 0)) {
rix = rates[i].idx;
break;
}
}
cix = rate_table->info[rix].ctrl_rate;
/* All protection frames are transmited at 2Mb/s for 802.11g,
* otherwise we transmit them at 1Mb/s */
if (sc->hw->conf.channel->band == IEEE80211_BAND_2GHZ &&
!conf_is_ht(&sc->hw->conf))
enable_g_protection = 1;
/*
* If 802.11g protection is enabled, determine whether to use RTS/CTS or
* just CTS. Note that this is only done for OFDM/HT unicast frames.
*/
if ((sc->sc_flags & SC_OP_PROTECT_ENABLE) &&
!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK) &&
(rate_table->info[rix].phy == WLAN_RC_PHY_OFDM ||
WLAN_RC_PHY_HT(rate_table->info[rix].phy))) {
rates[0].flags |= IEEE80211_TX_RC_USE_CTS_PROTECT;
cix = rate_table->info[enable_g_protection].ctrl_rate;
}
tx_info->control.rts_cts_rate_idx = cix;
}
static u8 ath_rc_rate_getidx(struct ath_softc *sc, static u8 ath_rc_rate_getidx(struct ath_softc *sc,
struct ath_rate_priv *ath_rc_priv, struct ath_rate_priv *ath_rc_priv,
struct ath_rate_table *rate_table, struct ath_rate_table *rate_table,
@ -804,54 +835,56 @@ static u8 ath_rc_rate_getidx(struct ath_softc *sc,
static void ath_rc_ratefind(struct ath_softc *sc, static void ath_rc_ratefind(struct ath_softc *sc,
struct ath_rate_priv *ath_rc_priv, struct ath_rate_priv *ath_rc_priv,
int num_tries, int num_rates, struct ieee80211_tx_rate_control *txrc)
struct ieee80211_tx_info *tx_info, int *is_probe,
int is_retry)
{ {
u8 try_per_rate = 0, i = 0, rix, nrix;
struct ath_rate_table *rate_table; struct ath_rate_table *rate_table;
struct sk_buff *skb = txrc->skb;
struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
struct ieee80211_tx_rate *rates = tx_info->control.rates; struct ieee80211_tx_rate *rates = tx_info->control.rates;
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
__le16 fc = hdr->frame_control;
u8 try_per_rate = 0, i = 0, rix, nrix;
int is_probe = 0;
rate_table = sc->cur_rate_table; rate_table = sc->cur_rate_table;
rix = ath_rc_ratefind_ht(sc, ath_rc_priv, rate_table, 1, rix = ath_rc_ratefind_ht(sc, ath_rc_priv, rate_table, &is_probe);
is_probe, is_retry);
nrix = rix; nrix = rix;
if (*is_probe) { if (is_probe) {
/* set one try for probe rates. For the /* set one try for probe rates. For the
* probes don't enable rts */ * probes don't enable rts */
ath_rc_rate_set_series(rate_table, ath_rc_rate_set_series(rate_table, &rates[i++], txrc,
&rates[i++], 1, nrix, 0); 1, nrix, 0);
try_per_rate = (num_tries/num_rates); try_per_rate = (ATH_11N_TXMAXTRY/4);
/* Get the next tried/allowed rate. No RTS for the next series /* Get the next tried/allowed rate. No RTS for the next series
* after the probe rate * after the probe rate
*/ */
nrix = ath_rc_rate_getidx(sc, nrix = ath_rc_rate_getidx(sc, ath_rc_priv,
ath_rc_priv, rate_table, nrix, 1, 0); rate_table, nrix, 1, 0);
ath_rc_rate_set_series(rate_table, ath_rc_rate_set_series(rate_table, &rates[i++], txrc,
&rates[i++], try_per_rate, nrix, 0); try_per_rate, nrix, 0);
} else { } else {
try_per_rate = (num_tries/num_rates); try_per_rate = (ATH_11N_TXMAXTRY/4);
/* Set the choosen rate. No RTS for first series entry. */ /* Set the choosen rate. No RTS for first series entry. */
ath_rc_rate_set_series(rate_table, ath_rc_rate_set_series(rate_table, &rates[i++], txrc,
&rates[i++], try_per_rate, nrix, 0); try_per_rate, nrix, 0);
} }
/* Fill in the other rates for multirate retry */ /* Fill in the other rates for multirate retry */
for ( ; i < num_rates; i++) { for ( ; i < 4; i++) {
u8 try_num; u8 try_num;
u8 min_rate; u8 min_rate;
try_num = ((i + 1) == num_rates) ? try_num = ((i + 1) == 4) ?
num_tries - (try_per_rate * i) : try_per_rate ; ATH_11N_TXMAXTRY - (try_per_rate * i) : try_per_rate ;
min_rate = (((i + 1) == num_rates) && 0); min_rate = (((i + 1) == 4) && 0);
nrix = ath_rc_rate_getidx(sc, ath_rc_priv, nrix = ath_rc_rate_getidx(sc, ath_rc_priv,
rate_table, nrix, 1, min_rate); rate_table, nrix, 1, min_rate);
/* All other rates in the series have RTS enabled */ /* All other rates in the series have RTS enabled */
ath_rc_rate_set_series(rate_table, ath_rc_rate_set_series(rate_table, &rates[i], txrc,
&rates[i], try_num, nrix, 1); try_num, nrix, 1);
} }
/* /*
@ -880,6 +913,24 @@ static void ath_rc_ratefind(struct ath_softc *sc,
rates[3].flags = rates[2].flags; rates[3].flags = rates[2].flags;
} }
} }
/*
* Force hardware to use computed duration for next
* fragment by disabling multi-rate retry, which
* updates duration based on the multi-rate duration table.
*
* FIXME: Fix duration
*/
if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK) &&
(ieee80211_has_morefrags(fc) ||
(le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG))) {
rates[1].count = rates[2].count = rates[3].count = 0;
rates[1].idx = rates[2].idx = rates[3].idx = 0;
rates[0].count = ATH_TXMAXTRY;
}
/* Setup RTS/CTS */
ath_rc_rate_set_rtscts(sc, rate_table, tx_info);
} }
static bool ath_rc_update_per(struct ath_softc *sc, static bool ath_rc_update_per(struct ath_softc *sc,
@ -1394,16 +1445,16 @@ static void ath_rc_init(struct ath_softc *sc,
if (!rateset->rs_nrates) { if (!rateset->rs_nrates) {
/* No working rate, just initialize valid rates */ /* No working rate, just initialize valid rates */
hi = ath_rc_init_validrates(ath_rc_priv, rate_table, hi = ath_rc_init_validrates(ath_rc_priv, rate_table,
ath_rc_priv->ht_cap); ath_rc_priv->ht_cap);
} else { } else {
/* Use intersection of working rates and valid rates */ /* Use intersection of working rates and valid rates */
hi = ath_rc_setvalid_rates(ath_rc_priv, rate_table, hi = ath_rc_setvalid_rates(ath_rc_priv, rate_table,
rateset, ath_rc_priv->ht_cap); rateset, ath_rc_priv->ht_cap);
if (ath_rc_priv->ht_cap & WLAN_RC_HT_FLAG) { if (ath_rc_priv->ht_cap & WLAN_RC_HT_FLAG) {
hthi = ath_rc_setvalid_htrates(ath_rc_priv, hthi = ath_rc_setvalid_htrates(ath_rc_priv,
rate_table, rate_table,
ht_mcs, ht_mcs,
ath_rc_priv->ht_cap); ath_rc_priv->ht_cap);
} }
hi = A_MAX(hi, hthi); hi = A_MAX(hi, hthi);
} }
@ -1479,6 +1530,22 @@ static void ath_tx_status(void *priv, struct ieee80211_supported_band *sband,
(is_underrun) ? ATH_11N_TXMAXTRY : (is_underrun) ? ATH_11N_TXMAXTRY :
tx_info_priv->tx.ts_longretry); tx_info_priv->tx.ts_longretry);
/* Check if aggregation has to be enabled for this tid */
if (conf_is_ht(&sc->hw->conf)) {
if (ieee80211_is_data_qos(fc)) {
u8 *qc, tid;
struct ath_node *an;
qc = ieee80211_get_qos_ctl(hdr);
tid = qc[0] & 0xf;
an = (struct ath_node *)sta->drv_priv;
if(ath_tx_aggr_check(sc, an, tid))
ieee80211_start_tx_ba_session(sc->hw, hdr->addr1, tid);
}
}
ath_debug_stat_rc(sc, skb);
exit: exit:
kfree(tx_info_priv); kfree(tx_info_priv);
} }
@ -1489,11 +1556,9 @@ static void ath_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta,
struct ieee80211_supported_band *sband = txrc->sband; struct ieee80211_supported_band *sband = txrc->sband;
struct sk_buff *skb = txrc->skb; struct sk_buff *skb = txrc->skb;
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
struct ath_softc *sc = priv;
struct ieee80211_hw *hw = sc->hw;
struct ath_rate_priv *ath_rc_priv = priv_sta;
struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
int is_probe = 0; struct ath_softc *sc = priv;
struct ath_rate_priv *ath_rc_priv = priv_sta;
__le16 fc = hdr->frame_control; __le16 fc = hdr->frame_control;
/* lowest rate for management and multicast/broadcast frames */ /* lowest rate for management and multicast/broadcast frames */
@ -1506,23 +1571,7 @@ static void ath_get_rate(void *priv, struct ieee80211_sta *sta, void *priv_sta,
} }
/* Find tx rate for unicast frames */ /* Find tx rate for unicast frames */
ath_rc_ratefind(sc, ath_rc_priv, ATH_11N_TXMAXTRY, 4, ath_rc_ratefind(sc, ath_rc_priv, txrc);
tx_info, &is_probe, false);
/* Check if aggregation has to be enabled for this tid */
if (conf_is_ht(&hw->conf)) {
if (ieee80211_is_data_qos(fc)) {
u8 *qc, tid;
struct ath_node *an;
qc = ieee80211_get_qos_ctl(hdr);
tid = qc[0] & 0xf;
an = (struct ath_node *)sta->drv_priv;
if(ath_tx_aggr_check(sc, an, tid))
ieee80211_start_tx_ba_session(hw, hdr->addr1, tid);
}
}
} }
static void ath_rate_init(void *priv, struct ieee80211_supported_band *sband, static void ath_rate_init(void *priv, struct ieee80211_supported_band *sband,

11
drivers/net/wireless/ath9k/reg.h
View File

@ -1198,18 +1198,7 @@ enum {
#define AR_CFP_VAL 0x0000FFFF #define AR_CFP_VAL 0x0000FFFF
#define AR_RX_FILTER 0x803C #define AR_RX_FILTER 0x803C
#define AR_RX_FILTER_ALL 0x00000000
#define AR_RX_UCAST 0x00000001
#define AR_RX_MCAST 0x00000002
#define AR_RX_BCAST 0x00000004
#define AR_RX_CONTROL 0x00000008
#define AR_RX_BEACON 0x00000010
#define AR_RX_PROM 0x00000020
#define AR_RX_PROBE_REQ 0x00000080
#define AR_RX_MY_BEACON 0x00000200
#define AR_RX_COMPR_BAR 0x00000400 #define AR_RX_COMPR_BAR 0x00000400
#define AR_RX_COMPR_BA 0x00000800
#define AR_RX_UNCOM_BA_BAR 0x00001000
#define AR_MCAST_FIL0 0x8040 #define AR_MCAST_FIL0 0x8040
#define AR_MCAST_FIL1 0x8044 #define AR_MCAST_FIL1 0x8044

33
drivers/net/wireless/ath9k/regd.c
View File

@ -154,12 +154,20 @@ const struct ieee80211_regdomain *ath9k_world_regdomain(struct ath_hal *ah)
} }
} }
/* Enable adhoc on 5 GHz if allowed by 11d */ /* Frequency is one where radar detection is required */
static void ath9k_reg_apply_5ghz_adhoc_flags(struct wiphy *wiphy, static bool ath9k_is_radar_freq(u16 center_freq)
{
return (center_freq >= 5260 && center_freq <= 5700);
}
/*
* Enable adhoc on 5 GHz if allowed by 11d.
* Remove passive scan if channel is allowed by 11d,
* except when on radar frequencies.
*/
static void ath9k_reg_apply_5ghz_beaconing_flags(struct wiphy *wiphy,
enum reg_set_by setby) enum reg_set_by setby)
{ {
struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
struct ath_softc *sc = hw->priv;
struct ieee80211_supported_band *sband; struct ieee80211_supported_band *sband;
const struct ieee80211_reg_rule *reg_rule; const struct ieee80211_reg_rule *reg_rule;
struct ieee80211_channel *ch; struct ieee80211_channel *ch;
@ -169,8 +177,7 @@ static void ath9k_reg_apply_5ghz_adhoc_flags(struct wiphy *wiphy,
if (setby != REGDOM_SET_BY_COUNTRY_IE) if (setby != REGDOM_SET_BY_COUNTRY_IE)
return; return;
if (!test_bit(ATH9K_MODE_11A, if (!wiphy->bands[IEEE80211_BAND_5GHZ])
sc->sc_ah->ah_caps.wireless_modes))
return; return;
sband = wiphy->bands[IEEE80211_BAND_5GHZ]; sband = wiphy->bands[IEEE80211_BAND_5GHZ];
@ -185,7 +192,11 @@ static void ath9k_reg_apply_5ghz_adhoc_flags(struct wiphy *wiphy,
* it by applying our static world regdomain by default during * it by applying our static world regdomain by default during
* probe */ * probe */
if (!(reg_rule->flags & NL80211_RRF_NO_IBSS)) if (!(reg_rule->flags & NL80211_RRF_NO_IBSS))
ch->flags &= ~NL80211_RRF_NO_IBSS; ch->flags &= ~IEEE80211_CHAN_NO_IBSS;
if (!ath9k_is_radar_freq(ch->center_freq))
continue;
if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN))
ch->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
} }
} }
@ -250,9 +261,7 @@ void ath9k_reg_apply_radar_flags(struct wiphy *wiphy)
for (i = 0; i < sband->n_channels; i++) { for (i = 0; i < sband->n_channels; i++) {
ch = &sband->channels[i]; ch = &sband->channels[i];
if (ch->center_freq < 5260) if (!ath9k_is_radar_freq(ch->center_freq))
continue;
if (ch->center_freq > 5700)
continue; continue;
/* We always enable radar detection/DFS on this /* We always enable radar detection/DFS on this
* frequency range. Additionally we also apply on * frequency range. Additionally we also apply on
@ -282,10 +291,10 @@ void ath9k_reg_apply_world_flags(struct wiphy *wiphy, enum reg_set_by setby)
case 0x63: case 0x63:
case 0x66: case 0x66:
case 0x67: case 0x67:
ath9k_reg_apply_5ghz_adhoc_flags(wiphy, setby); ath9k_reg_apply_5ghz_beaconing_flags(wiphy, setby);
break; break;
case 0x68: case 0x68:
ath9k_reg_apply_5ghz_adhoc_flags(wiphy, setby); ath9k_reg_apply_5ghz_beaconing_flags(wiphy, setby);
ath9k_reg_apply_active_scan_flags(wiphy, setby); ath9k_reg_apply_active_scan_flags(wiphy, setby);
break; break;
} }

138
drivers/net/wireless/ath9k/xmit.c
View File

@ -677,6 +677,7 @@ int ath_tx_aggr_start(struct ath_softc *sc, struct ieee80211_sta *sta,
txtid = ATH_AN_2_TID(an, tid); txtid = ATH_AN_2_TID(an, tid);
txtid->state |= AGGR_ADDBA_PROGRESS; txtid->state |= AGGR_ADDBA_PROGRESS;
ath_tx_pause_tid(sc, txtid); ath_tx_pause_tid(sc, txtid);
*ssn = txtid->seq_start;
} }
return 0; return 0;
@ -1385,8 +1386,6 @@ static int setup_tx_flags(struct ath_softc *sc, struct sk_buff *skb,
if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK) if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK)
flags |= ATH9K_TXDESC_NOACK; flags |= ATH9K_TXDESC_NOACK;
if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
flags |= ATH9K_TXDESC_RTSENA;
return flags; return flags;
} }
@ -1432,137 +1431,86 @@ static u32 ath_pkt_duration(struct ath_softc *sc, u8 rix, struct ath_buf *bf,
static void ath_buf_set_rate(struct ath_softc *sc, struct ath_buf *bf) static void ath_buf_set_rate(struct ath_softc *sc, struct ath_buf *bf)
{ {
struct ath_hal *ah = sc->sc_ah; struct ath_rate_table *rt = sc->cur_rate_table;
struct ath_rate_table *rt;
struct ath_desc *ds = bf->bf_desc;
struct ath_desc *lastds = bf->bf_lastbf->bf_desc;
struct ath9k_11n_rate_series series[4]; struct ath9k_11n_rate_series series[4];
struct sk_buff *skb; struct sk_buff *skb;
struct ieee80211_tx_info *tx_info; struct ieee80211_tx_info *tx_info;
struct ieee80211_tx_rate *rates; struct ieee80211_tx_rate *rates;
struct ieee80211_hdr *hdr; int i, flags = 0;
struct ieee80211_hw *hw = sc->hw; u8 rix = 0, ctsrate = 0;
int i, flags, rtsctsena = 0, enable_g_protection = 0;
u32 ctsduration = 0;
u8 rix = 0, cix, ctsrate = 0;
__le16 fc;
memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4); memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
skb = (struct sk_buff *)bf->bf_mpdu; skb = (struct sk_buff *)bf->bf_mpdu;
hdr = (struct ieee80211_hdr *)skb->data;
fc = hdr->frame_control;
tx_info = IEEE80211_SKB_CB(skb); tx_info = IEEE80211_SKB_CB(skb);
rates = tx_info->control.rates; rates = tx_info->control.rates;
if (ieee80211_has_morefrags(fc) || /*
(le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG)) { * We check if Short Preamble is needed for the CTS rate by
rates[1].count = rates[2].count = rates[3].count = 0; * checking the BSS's global flag.
rates[1].idx = rates[2].idx = rates[3].idx = 0; * But for the rate series, IEEE80211_TX_RC_USE_SHORT_PREAMBLE is used.
rates[0].count = ATH_TXMAXTRY; */
} if (sc->sc_flags & SC_OP_PREAMBLE_SHORT)
ctsrate = rt->info[tx_info->control.rts_cts_rate_idx].ratecode |
/* get the cix for the lowest valid rix */ rt->info[tx_info->control.rts_cts_rate_idx].short_preamble;
rt = sc->cur_rate_table; else
for (i = 3; i >= 0; i--) { ctsrate = rt->info[tx_info->control.rts_cts_rate_idx].ratecode;
if (rates[i].count && (rates[i].idx >= 0)) {
rix = rates[i].idx;
break;
}
}
flags = (bf->bf_flags & (ATH9K_TXDESC_RTSENA | ATH9K_TXDESC_CTSENA));
cix = rt->info[rix].ctrl_rate;
/* All protection frames are transmited at 2Mb/s for 802.11g,
* otherwise we transmit them at 1Mb/s */
if (hw->conf.channel->band == IEEE80211_BAND_2GHZ &&
!conf_is_ht(&hw->conf))
enable_g_protection = 1;
/* /*
* If 802.11g protection is enabled, determine whether to use RTS/CTS or * ATH9K_TXDESC_RTSENA and ATH9K_TXDESC_CTSENA are mutually exclusive.
* just CTS. Note that this is only done for OFDM/HT unicast frames. * Check the first rate in the series to decide whether RTS/CTS
* or CTS-to-self has to be used.
*/ */
if (sc->sc_protmode != PROT_M_NONE && !(bf->bf_flags & ATH9K_TXDESC_NOACK) if (rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
&& (rt->info[rix].phy == WLAN_RC_PHY_OFDM || flags = ATH9K_TXDESC_CTSENA;
WLAN_RC_PHY_HT(rt->info[rix].phy))) { else if (rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
if (sc->sc_protmode == PROT_M_RTSCTS) flags = ATH9K_TXDESC_RTSENA;
flags = ATH9K_TXDESC_RTSENA;
else if (sc->sc_protmode == PROT_M_CTSONLY)
flags = ATH9K_TXDESC_CTSENA;
cix = rt->info[enable_g_protection].ctrl_rate; /* FIXME: Handle aggregation protection */
rtsctsena = 1;
}
/* For 11n, the default behavior is to enable RTS for hw retried frames.
* We enable the global flag here and let rate series flags determine
* which rates will actually use RTS.
*/
if ((ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT) && bf_isdata(bf)) {
/* 802.11g protection not needed, use our default behavior */
if (!rtsctsena)
flags = ATH9K_TXDESC_RTSENA;
}
/* Set protection if aggregate protection on */
if (sc->sc_config.ath_aggr_prot && if (sc->sc_config.ath_aggr_prot &&
(!bf_isaggr(bf) || (bf_isaggr(bf) && bf->bf_al < 8192))) { (!bf_isaggr(bf) || (bf_isaggr(bf) && bf->bf_al < 8192))) {
flags = ATH9K_TXDESC_RTSENA; flags = ATH9K_TXDESC_RTSENA;
cix = rt->info[enable_g_protection].ctrl_rate;
rtsctsena = 1;
} }
/* For AR5416 - RTS cannot be followed by a frame larger than 8K */ /* For AR5416 - RTS cannot be followed by a frame larger than 8K */
if (bf_isaggr(bf) && (bf->bf_al > ah->ah_caps.rts_aggr_limit)) if (bf_isaggr(bf) && (bf->bf_al > sc->sc_ah->ah_caps.rts_aggr_limit))
flags &= ~(ATH9K_TXDESC_RTSENA); flags &= ~(ATH9K_TXDESC_RTSENA);
/*
* CTS transmit rate is derived from the transmit rate by looking in the
* h/w rate table. We must also factor in whether or not a short
* preamble is to be used. NB: cix is set above where RTS/CTS is enabled
*/
ctsrate = rt->info[cix].ratecode |
(bf_isshpreamble(bf) ? rt->info[cix].short_preamble : 0);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (!rates[i].count || (rates[i].idx < 0)) if (!rates[i].count || (rates[i].idx < 0))
continue; continue;
rix = rates[i].idx; rix = rates[i].idx;
series[i].Rate = rt->info[rix].ratecode |
(bf_isshpreamble(bf) ? rt->info[rix].short_preamble : 0);
series[i].Tries = rates[i].count; series[i].Tries = rates[i].count;
series[i].ChSel = sc->sc_tx_chainmask;
series[i].RateFlags = ( if (rates[i].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
(rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS) ? series[i].Rate = rt->info[rix].ratecode |
ATH9K_RATESERIES_RTS_CTS : 0) | rt->info[rix].short_preamble;
((rates[i].flags & IEEE80211_TX_RC_40_MHZ_WIDTH) ? else
ATH9K_RATESERIES_2040 : 0) | series[i].Rate = rt->info[rix].ratecode;
((rates[i].flags & IEEE80211_TX_RC_SHORT_GI) ?
ATH9K_RATESERIES_HALFGI : 0); if (rates[i].flags & IEEE80211_TX_RC_USE_RTS_CTS)
series[i].RateFlags |= ATH9K_RATESERIES_RTS_CTS;
if (rates[i].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
series[i].RateFlags |= ATH9K_RATESERIES_2040;
if (rates[i].flags & IEEE80211_TX_RC_SHORT_GI)
series[i].RateFlags |= ATH9K_RATESERIES_HALFGI;
series[i].PktDuration = ath_pkt_duration(sc, rix, bf, series[i].PktDuration = ath_pkt_duration(sc, rix, bf,
(rates[i].flags & IEEE80211_TX_RC_40_MHZ_WIDTH) != 0, (rates[i].flags & IEEE80211_TX_RC_40_MHZ_WIDTH) != 0,
(rates[i].flags & IEEE80211_TX_RC_SHORT_GI), (rates[i].flags & IEEE80211_TX_RC_SHORT_GI),
bf_isshpreamble(bf)); (rates[i].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE));
series[i].ChSel = sc->sc_tx_chainmask;
if (rtsctsena)
series[i].RateFlags |= ATH9K_RATESERIES_RTS_CTS;
} }
/* set dur_update_en for l-sig computation except for PS-Poll frames */ /* set dur_update_en for l-sig computation except for PS-Poll frames */
ath9k_hw_set11n_ratescenario(ah, ds, lastds, !bf_ispspoll(bf), ath9k_hw_set11n_ratescenario(sc->sc_ah, bf->bf_desc,
ctsrate, ctsduration, bf->bf_lastbf->bf_desc,
series, 4, flags); !bf_ispspoll(bf), ctsrate,
0, series, 4, flags);
if (sc->sc_config.ath_aggr_prot && flags) if (sc->sc_config.ath_aggr_prot && flags)
ath9k_hw_set11n_burstduration(ah, ds, 8192); ath9k_hw_set11n_burstduration(sc->sc_ah, bf->bf_desc, 8192);
} }
static int ath_tx_setup_buffer(struct ath_softc *sc, struct ath_buf *bf, static int ath_tx_setup_buffer(struct ath_softc *sc, struct ath_buf *bf,
@ -1592,8 +1540,6 @@ static int ath_tx_setup_buffer(struct ath_softc *sc, struct ath_buf *bf,
bf->bf_state.bf_type |= BUF_BAR; bf->bf_state.bf_type |= BUF_BAR;
if (ieee80211_is_pspoll(fc)) if (ieee80211_is_pspoll(fc))
bf->bf_state.bf_type |= BUF_PSPOLL; bf->bf_state.bf_type |= BUF_PSPOLL;
if (sc->sc_flags & SC_OP_PREAMBLE_SHORT)
bf->bf_state.bf_type |= BUF_SHORT_PREAMBLE;
if ((conf_is_ht(&sc->hw->conf) && !is_pae(skb) && if ((conf_is_ht(&sc->hw->conf) && !is_pae(skb) &&
(tx_info->flags & IEEE80211_TX_CTL_AMPDU))) (tx_info->flags & IEEE80211_TX_CTL_AMPDU)))
bf->bf_state.bf_type |= BUF_HT; bf->bf_state.bf_type |= BUF_HT;

1
drivers/net/wireless/b43/Makefile
View File

@ -6,6 +6,7 @@ b43-y += phy_g.o
b43-y += phy_a.o b43-y += phy_a.o
b43-$(CONFIG_B43_NPHY) += phy_n.o b43-$(CONFIG_B43_NPHY) += phy_n.o
b43-$(CONFIG_B43_PHY_LP) += phy_lp.o b43-$(CONFIG_B43_PHY_LP) += phy_lp.o
b43-$(CONFIG_B43_PHY_LP) += tables_lpphy.o
b43-y += sysfs.o b43-y += sysfs.o
b43-y += xmit.o b43-y += xmit.o
b43-y += lo.o b43-y += lo.o

220
drivers/net/wireless/b43/phy_lp.c
View File

@ -3,7 +3,7 @@
Broadcom B43 wireless driver Broadcom B43 wireless driver
IEEE 802.11g LP-PHY driver IEEE 802.11g LP-PHY driver
Copyright (c) 2008 Michael Buesch <mb@bu3sch.de> Copyright (c) 2008-2009 Michael Buesch <mb@bu3sch.de>
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -25,6 +25,7 @@
#include "b43.h" #include "b43.h"
#include "phy_lp.h" #include "phy_lp.h"
#include "phy_common.h" #include "phy_common.h"
#include "tables_lpphy.h"
static int b43_lpphy_op_allocate(struct b43_wldev *dev) static int b43_lpphy_op_allocate(struct b43_wldev *dev)
@ -57,8 +58,221 @@ static void b43_lpphy_op_free(struct b43_wldev *dev)
dev->phy.lp = NULL; dev->phy.lp = NULL;
} }
static void lpphy_table_init(struct b43_wldev *dev)
{
//TODO
}
static void lpphy_baseband_rev0_1_init(struct b43_wldev *dev)
{
B43_WARN_ON(1);//TODO rev < 2 not supported, yet.
}
static void lpphy_baseband_rev2plus_init(struct b43_wldev *dev)
{
struct ssb_bus *bus = dev->dev->bus;
struct b43_phy_lp *lpphy = dev->phy.lp;
b43_phy_write(dev, B43_LPPHY_AFE_DAC_CTL, 0x50);
b43_phy_write(dev, B43_LPPHY_AFE_CTL, 0x8800);
b43_phy_write(dev, B43_LPPHY_AFE_CTL_OVR, 0);
b43_phy_write(dev, B43_LPPHY_AFE_CTL_OVRVAL, 0);
b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_0, 0);
b43_phy_write(dev, B43_LPPHY_RF_OVERRIDE_2, 0);
b43_phy_write(dev, B43_PHY_OFDM(0xF9), 0);
b43_phy_write(dev, B43_LPPHY_TR_LOOKUP_1, 0);
b43_phy_set(dev, B43_LPPHY_ADC_COMPENSATION_CTL, 0x10);
b43_phy_maskset(dev, B43_LPPHY_OFDMSYNCTHRESH0, 0xFF00, 0x78);
b43_phy_maskset(dev, B43_LPPHY_DCOFFSETTRANSIENT, 0xF8FF, 0x200);
b43_phy_maskset(dev, B43_LPPHY_DCOFFSETTRANSIENT, 0xFF00, 0x7F);
b43_phy_maskset(dev, B43_LPPHY_GAINDIRECTMISMATCH, 0xFF0F, 0x40);
b43_phy_maskset(dev, B43_LPPHY_PREAMBLECONFIRMTO, 0xFF00, 0x2);
b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, ~0x4000);
b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, ~0x2000);
b43_phy_set(dev, B43_PHY_OFDM(0x10A), 0x1);
b43_phy_maskset(dev, B43_PHY_OFDM(0x10A), 0xFF01, 0x10);
b43_phy_maskset(dev, B43_PHY_OFDM(0xDF), 0xFF00, 0xF4);
b43_phy_maskset(dev, B43_PHY_OFDM(0xDF), 0x00FF, 0xF100);
b43_phy_write(dev, B43_LPPHY_CLIPTHRESH, 0x48);
b43_phy_maskset(dev, B43_LPPHY_HIGAINDB, 0xFF00, 0x46);
b43_phy_maskset(dev, B43_PHY_OFDM(0xE4), 0xFF00, 0x10);
b43_phy_maskset(dev, B43_LPPHY_PWR_THRESH1, 0xFFF0, 0x9);
b43_phy_mask(dev, B43_LPPHY_GAINDIRECTMISMATCH, ~0xF);
b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0x00FF, 0x5500);
b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0xF81F, 0xA0);
b43_phy_maskset(dev, B43_LPPHY_GAINDIRECTMISMATCH, 0xE0FF, 0x300);
b43_phy_maskset(dev, B43_LPPHY_HIGAINDB, 0x00FF, 0x2A00);
if ((bus->chip_id == 0x4325) && (bus->chip_rev == 0)) {
b43_phy_maskset(dev, B43_LPPHY_LOWGAINDB, 0x00FF, 0x2100);
b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0xFF00, 0xA);
} else {
b43_phy_maskset(dev, B43_LPPHY_LOWGAINDB, 0x00FF, 0x1E00);
b43_phy_maskset(dev, B43_LPPHY_VERYLOWGAINDB, 0xFF00, 0xD);
}
b43_phy_maskset(dev, B43_PHY_OFDM(0xFE), 0xFFE0, 0x1F);
b43_phy_maskset(dev, B43_PHY_OFDM(0xFF), 0xFFE0, 0xC);
b43_phy_maskset(dev, B43_PHY_OFDM(0x100), 0xFF00, 0x19);
b43_phy_maskset(dev, B43_PHY_OFDM(0xFF), 0x03FF, 0x3C00);
b43_phy_maskset(dev, B43_PHY_OFDM(0xFE), 0xFC1F, 0x3E0);
b43_phy_maskset(dev, B43_PHY_OFDM(0xFF), 0xFFE0, 0xC);
b43_phy_maskset(dev, B43_PHY_OFDM(0x100), 0x00FF, 0x1900);
b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0x83FF, 0x5800);
b43_phy_maskset(dev, B43_LPPHY_CLIPCTRTHRESH, 0xFFE0, 0x12);
b43_phy_maskset(dev, B43_LPPHY_GAINMISMATCH, 0x0FFF, 0x9000);
b43_lptab_write(dev, B43_LPTAB16(0x08, 0x14), 0);
b43_lptab_write(dev, B43_LPTAB16(0x08, 0x12), 0x40);
if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x40);
b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL, 0xF0FF, 0xB00);
b43_phy_maskset(dev, B43_LPPHY_SYNCPEAKCNT, 0xFFF8, 0x6);
b43_phy_maskset(dev, B43_LPPHY_MINPWR_LEVEL, 0x00FF, 0x9D00);
b43_phy_maskset(dev, B43_LPPHY_MINPWR_LEVEL, 0xFF00, 0xA1);
} else /* 5GHz */
b43_phy_mask(dev, B43_LPPHY_CRSGAIN_CTL, ~0x40);
b43_phy_maskset(dev, B43_LPPHY_CRS_ED_THRESH, 0xFF00, 0xB3);
b43_phy_maskset(dev, B43_LPPHY_CRS_ED_THRESH, 0x00FF, 0xAD00);
b43_phy_maskset(dev, B43_LPPHY_INPUT_PWRDB, 0xFF00, lpphy->rx_pwr_offset);
b43_phy_set(dev, B43_LPPHY_RESET_CTL, 0x44);
b43_phy_write(dev, B43_LPPHY_RESET_CTL, 0x80);
b43_phy_write(dev, B43_LPPHY_AFE_RSSI_CTL_0, 0xA954);
b43_phy_write(dev, B43_LPPHY_AFE_RSSI_CTL_1,
0x2000 | ((u16)lpphy->rssi_gs << 10) |
((u16)lpphy->rssi_vc << 4) | lpphy->rssi_vf);
}
static void lpphy_baseband_init(struct b43_wldev *dev)
{
lpphy_table_init(dev);
if (dev->phy.rev >= 2)
lpphy_baseband_rev2plus_init(dev);
else
lpphy_baseband_rev0_1_init(dev);
}
struct b2062_freqdata {
u16 freq;
u8 data[6];
};
/* Initialize the 2062 radio. */
static void lpphy_2062_init(struct b43_wldev *dev)
{
struct ssb_bus *bus = dev->dev->bus;
u32 crystalfreq, pdiv, tmp, ref;
unsigned int i;
const struct b2062_freqdata *fd = NULL;
static const struct b2062_freqdata freqdata_tab[] = {
{ .freq = 12000, .data[0] = 6, .data[1] = 6, .data[2] = 6,
.data[3] = 6, .data[4] = 10, .data[5] = 6, },
{ .freq = 13000, .data[0] = 4, .data[1] = 4, .data[2] = 4,
.data[3] = 4, .data[4] = 11, .data[5] = 7, },
{ .freq = 14400, .data[0] = 3, .data[1] = 3, .data[2] = 3,
.data[3] = 3, .data[4] = 12, .data[5] = 7, },
{ .freq = 16200, .data[0] = 3, .data[1] = 3, .data[2] = 3,
.data[3] = 3, .data[4] = 13, .data[5] = 8, },
{ .freq = 18000, .data[0] = 2, .data[1] = 2, .data[2] = 2,
.data[3] = 2, .data[4] = 14, .data[5] = 8, },
{ .freq = 19200, .data[0] = 1, .data[1] = 1, .data[2] = 1,
.data[3] = 1, .data[4] = 14, .data[5] = 9, },
};
b2062_upload_init_table(dev);
b43_radio_write(dev, B2062_N_TX_CTL3, 0);
b43_radio_write(dev, B2062_N_TX_CTL4, 0);
b43_radio_write(dev, B2062_N_TX_CTL5, 0);
b43_radio_write(dev, B2062_N_PDN_CTL0, 0x40);
b43_radio_write(dev, B2062_N_PDN_CTL0, 0);
b43_radio_write(dev, B2062_N_CALIB_TS, 0x10);
b43_radio_write(dev, B2062_N_CALIB_TS, 0);
if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
b43_radio_set(dev, B2062_N_TSSI_CTL0, 0x1);
else
b43_radio_mask(dev, B2062_N_TSSI_CTL0, ~0x1);
/* Get the crystal freq, in Hz. */
crystalfreq = bus->chipco.pmu.crystalfreq * 1000;
B43_WARN_ON(!(bus->chipco.capabilities & SSB_CHIPCO_CAP_PMU));
B43_WARN_ON(crystalfreq == 0);
if (crystalfreq >= 30000000) {
pdiv = 1;
b43_radio_mask(dev, B2062_S_RFPLL_CTL1, 0xFFFB);
} else {
pdiv = 2;
b43_radio_set(dev, B2062_S_RFPLL_CTL1, 0x4);
}
tmp = (800000000 * pdiv + crystalfreq) / (32000000 * pdiv);
tmp = (tmp - 1) & 0xFF;
b43_radio_write(dev, B2062_S_RFPLL_CTL18, tmp);
tmp = (2 * crystalfreq + 1000000 * pdiv) / (2000000 * pdiv);
tmp = ((tmp & 0xFF) - 1) & 0xFFFF;
b43_radio_write(dev, B2062_S_RFPLL_CTL19, tmp);
ref = (1000 * pdiv + 2 * crystalfreq) / (2000 * pdiv);
ref &= 0xFFFF;
for (i = 0; i < ARRAY_SIZE(freqdata_tab); i++) {
if (ref < freqdata_tab[i].freq) {
fd = &freqdata_tab[i];
break;
}
}
if (!fd)
fd = &freqdata_tab[ARRAY_SIZE(freqdata_tab) - 1];
b43dbg(dev->wl, "b2062: Using crystal tab entry %u kHz.\n",
fd->freq); /* FIXME: Keep this printk until the code is fully debugged. */
b43_radio_write(dev, B2062_S_RFPLL_CTL8,
((u16)(fd->data[1]) << 4) | fd->data[0]);
b43_radio_write(dev, B2062_S_RFPLL_CTL9,
((u16)(fd->data[3]) << 4) | fd->data[2]);
b43_radio_write(dev, B2062_S_RFPLL_CTL10, fd->data[4]);
b43_radio_write(dev, B2062_S_RFPLL_CTL11, fd->data[5]);
}
/* Initialize the 2063 radio. */
static void lpphy_2063_init(struct b43_wldev *dev)
{
//TODO
}
static void lpphy_sync_stx(struct b43_wldev *dev)
{
//TODO
}
static void lpphy_radio_init(struct b43_wldev *dev)
{
/* The radio is attached through the 4wire bus. */
b43_phy_set(dev, B43_LPPHY_FOURWIRE_CTL, 0x2);
udelay(1);
b43_phy_mask(dev, B43_LPPHY_FOURWIRE_CTL, 0xFFFD);
udelay(1);
if (dev->phy.rev < 2) {
lpphy_2062_init(dev);
} else {
lpphy_2063_init(dev);
lpphy_sync_stx(dev);
b43_phy_write(dev, B43_PHY_OFDM(0xF0), 0x5F80);
b43_phy_write(dev, B43_PHY_OFDM(0xF1), 0);
//TODO Do something on the backplane
}
}
static int b43_lpphy_op_init(struct b43_wldev *dev) static int b43_lpphy_op_init(struct b43_wldev *dev)
{ {
/* TODO: band SPROM */
lpphy_baseband_init(dev);
lpphy_radio_init(dev);
//TODO //TODO
return 0; return 0;
@ -115,7 +329,9 @@ static int b43_lpphy_op_switch_channel(struct b43_wldev *dev,
static unsigned int b43_lpphy_op_get_default_chan(struct b43_wldev *dev) static unsigned int b43_lpphy_op_get_default_chan(struct b43_wldev *dev)
{ {
return 1; /* Default to channel 1 */ if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
return 1;
return 36;
} }
static void b43_lpphy_op_set_rx_antenna(struct b43_wldev *dev, int antenna) static void b43_lpphy_op_set_rx_antenna(struct b43_wldev *dev, int antenna)

315
drivers/net/wireless/b43/phy_lp.h
View File

@ -4,8 +4,281 @@
/* Definitions for the LP-PHY */ /* Definitions for the LP-PHY */
/* The CCK PHY register range. */
#define B43_LPPHY_B_VERSION B43_PHY_CCK(0x00) /* B PHY version */
#define B43_LPPHY_B_BBCONFIG B43_PHY_CCK(0x01) /* B PHY BBConfig */
#define B43_LPPHY_B_RX_STAT0 B43_PHY_CCK(0x04) /* B PHY RX Status0 */
#define B43_LPPHY_B_RX_STAT1 B43_PHY_CCK(0x05) /* B PHY RX Status1 */
#define B43_LPPHY_B_CRS_THRESH B43_PHY_CCK(0x06) /* B PHY CRS Thresh */
#define B43_LPPHY_B_TXERROR B43_PHY_CCK(0x07) /* B PHY TxError */
#define B43_LPPHY_B_CHANNEL B43_PHY_CCK(0x08) /* B PHY Channel */
#define B43_LPPHY_B_WORKAROUND B43_PHY_CCK(0x09) /* B PHY workaround */
#define B43_LPPHY_B_TEST B43_PHY_CCK(0x0A) /* B PHY Test */
#define B43_LPPHY_B_FOURWIRE_ADDR B43_PHY_CCK(0x0B) /* B PHY Fourwire Address */
#define B43_LPPHY_B_FOURWIRE_DATA_HI B43_PHY_CCK(0x0C) /* B PHY Fourwire Data Hi */
#define B43_LPPHY_B_FOURWIRE_DATA_LO B43_PHY_CCK(0x0D) /* B PHY Fourwire Data Lo */
#define B43_LPPHY_B_BIST_STAT B43_PHY_CCK(0x0E) /* B PHY Bist Status */
#define B43_LPPHY_PA_RAMP_TX_TO B43_PHY_CCK(0x10) /* PA Ramp TX Timeout */
#define B43_LPPHY_RF_SYNTH_DC_TIMER B43_PHY_CCK(0x11) /* RF Synth DC Timer */
#define B43_LPPHY_PA_RAMP_TX_TIME_IN B43_PHY_CCK(0x12) /* PA ramp TX Time in */
#define B43_LPPHY_RX_FILTER_TIME_IN B43_PHY_CCK(0x13) /* RX Filter Time in */
#define B43_LPPHY_PLL_COEFF_S B43_PHY_CCK(0x18) /* PLL Coefficient(s) */
#define B43_LPPHY_PLL_OUT B43_PHY_CCK(0x19) /* PLL Out */
#define B43_LPPHY_RSSI_THRES B43_PHY_CCK(0x20) /* RSSI Threshold */
#define B43_LPPHY_IQ_THRES_HH B43_PHY_CCK(0x21) /* IQ Threshold HH */
#define B43_LPPHY_IQ_THRES_H B43_PHY_CCK(0x22) /* IQ Threshold H */
#define B43_LPPHY_IQ_THRES_L B43_PHY_CCK(0x23) /* IQ Threshold L */
#define B43_LPPHY_IQ_THRES_LL B43_PHY_CCK(0x24) /* IQ Threshold LL */
#define B43_LPPHY_AGC_GAIN B43_PHY_CCK(0x25) /* AGC Gain */
#define B43_LPPHY_LNA_GAIN_RANGE B43_PHY_CCK(0x26) /* LNA Gain Range */
#define B43_LPPHY_JSSI B43_PHY_CCK(0x27) /* JSSI */
#define B43_LPPHY_TSSI_CTL B43_PHY_CCK(0x28) /* TSSI Control */
#define B43_LPPHY_TSSI B43_PHY_CCK(0x29) /* TSSI */
#define B43_LPPHY_TR_LOSS B43_PHY_CCK(0x2A) /* TR Loss */
#define B43_LPPHY_LO_LEAKAGE B43_PHY_CCK(0x2B) /* LO Leakage */
#define B43_LPPHY_LO_RSSIACC B43_PHY_CCK(0x2C) /* LO RSSIAcc */
#define B43_LPPHY_LO_IQ_MAG_ACC B43_PHY_CCK(0x2D) /* LO IQ Mag Acc */
#define B43_LPPHY_TX_DCOFFSET1 B43_PHY_CCK(0x2E) /* TX DCOffset1 */
#define B43_LPPHY_TX_DCOFFSET2 B43_PHY_CCK(0x2F) /* TX DCOffset2 */
#define B43_LPPHY_SYNCPEAKCNT B43_PHY_CCK(0x30) /* SyncPeakCnt */
#define B43_LPPHY_SYNCFREQ B43_PHY_CCK(0x31) /* SyncFreq */
#define B43_LPPHY_SYNCDIVERSITYCTL B43_PHY_CCK(0x32) /* SyncDiversityControl */
#define B43_LPPHY_PEAKENERGYL B43_PHY_CCK(0x33) /* PeakEnergyL */
#define B43_LPPHY_PEAKENERGYH B43_PHY_CCK(0x34) /* PeakEnergyH */
#define B43_LPPHY_SYNCCTL B43_PHY_CCK(0x35) /* SyncControl */
#define B43_LPPHY_DSSSSTEP B43_PHY_CCK(0x38) /* DsssStep */
#define B43_LPPHY_DSSSWARMUP B43_PHY_CCK(0x39) /* DsssWarmup */
#define B43_LPPHY_DSSSSIGPOW B43_PHY_CCK(0x3D) /* DsssSigPow */
#define B43_LPPHY_SFDDETECTBLOCKTIME B43_PHY_CCK(0x40) /* SfdDetectBlockTIme */
#define B43_LPPHY_SFDTO B43_PHY_CCK(0x41) /* SFDTimeOut */
#define B43_LPPHY_SFDCTL B43_PHY_CCK(0x42) /* SFDControl */
#define B43_LPPHY_RXDBG B43_PHY_CCK(0x43) /* rxDebug */
#define B43_LPPHY_RX_DELAYCOMP B43_PHY_CCK(0x44) /* RX DelayComp */
#define B43_LPPHY_CRSDROPOUTTO B43_PHY_CCK(0x45) /* CRSDropoutTimeout */
#define B43_LPPHY_PSEUDOSHORTTO B43_PHY_CCK(0x46) /* PseudoShortTimeout */
#define B43_LPPHY_PR3931 B43_PHY_CCK(0x47) /* PR3931 */
#define B43_LPPHY_DSSSCOEFF1 B43_PHY_CCK(0x48) /* DSSSCoeff1 */
#define B43_LPPHY_DSSSCOEFF2 B43_PHY_CCK(0x49) /* DSSSCoeff2 */
#define B43_LPPHY_CCKCOEFF1 B43_PHY_CCK(0x4A) /* CCKCoeff1 */
#define B43_LPPHY_CCKCOEFF2 B43_PHY_CCK(0x4B) /* CCKCoeff2 */
#define B43_LPPHY_TRCORR B43_PHY_CCK(0x4C) /* TRCorr */
#define B43_LPPHY_ANGLESCALE B43_PHY_CCK(0x4D) /* AngleScale */
#define B43_LPPHY_OPTIONALMODES2 B43_PHY_CCK(0x4F) /* OptionalModes2 */
#define B43_LPPHY_CCKLMSSTEPSIZE B43_PHY_CCK(0x50) /* CCKLMSStepSize */
#define B43_LPPHY_DFEBYPASS B43_PHY_CCK(0x51) /* DFEBypass */
#define B43_LPPHY_CCKSTARTDELAYLONG B43_PHY_CCK(0x52) /* CCKStartDelayLong */
#define B43_LPPHY_CCKSTARTDELAYSHORT B43_PHY_CCK(0x53) /* CCKStartDelayShort */
#define B43_LPPHY_PPROCCHDELAY B43_PHY_CCK(0x54) /* PprocChDelay */
#define B43_LPPHY_PPROCONOFF B43_PHY_CCK(0x55) /* PProcOnOff */
#define B43_LPPHY_LNAGAINTWOBIT10 B43_PHY_CCK(0x5B) /* LNAGainTwoBit10 */
#define B43_LPPHY_LNAGAINTWOBIT32 B43_PHY_CCK(0x5C) /* LNAGainTwoBit32 */
#define B43_LPPHY_OPTIONALMODES B43_PHY_CCK(0x5D) /* OptionalModes */
#define B43_LPPHY_B_RX_STAT2 B43_PHY_CCK(0x5E) /* B PHY RX Status2 */
#define B43_LPPHY_B_RX_STAT3 B43_PHY_CCK(0x5F) /* B PHY RX Status3 */
#define B43_LPPHY_PWDNDACDELAY B43_PHY_CCK(0x63) /* pwdnDacDelay */
#define B43_LPPHY_FINEDIGIGAIN_CTL B43_PHY_CCK(0x67) /* FineDigiGain Control */
#define B43_LPPHY_LG2GAINTBLLNA8 B43_PHY_CCK(0x68) /* Lg2GainTblLNA8 */
#define B43_LPPHY_LG2GAINTBLLNA28 B43_PHY_CCK(0x69) /* Lg2GainTblLNA28 */
#define B43_LPPHY_GAINTBLLNATRSW B43_PHY_CCK(0x6A) /* GainTblLNATrSw */
#define B43_LPPHY_PEAKENERGY B43_PHY_CCK(0x6B) /* PeakEnergy */
#define B43_LPPHY_LG2INITGAIN B43_PHY_CCK(0x6C) /* lg2InitGain */
#define B43_LPPHY_BLANKCOUNTLNAPGA B43_PHY_CCK(0x6D) /* BlankCountLnaPga */
#define B43_LPPHY_LNAGAINTWOBIT54 B43_PHY_CCK(0x6E) /* LNAGainTwoBit54 */
#define B43_LPPHY_LNAGAINTWOBIT76 B43_PHY_CCK(0x6F) /* LNAGainTwoBit76 */
#define B43_LPPHY_JSSICTL B43_PHY_CCK(0x70) /* JSSIControl */
#define B43_LPPHY_LG2GAINTBLLNA44 B43_PHY_CCK(0x71) /* Lg2GainTblLNA44 */
#define B43_LPPHY_LG2GAINTBLLNA62 B43_PHY_CCK(0x72) /* Lg2GainTblLNA62 */
/* The OFDM PHY register range. */
#define B43_LPPHY_VERSION B43_PHY_OFDM(0x00) /* Version */
#define B43_LPPHY_BBCONFIG B43_PHY_OFDM(0x01) /* BBConfig */
#define B43_LPPHY_RX_STAT0 B43_PHY_OFDM(0x04) /* RX Status0 */
#define B43_LPPHY_RX_STAT1 B43_PHY_OFDM(0x05) /* RX Status1 */
#define B43_LPPHY_TX_ERROR B43_PHY_OFDM(0x07) /* TX Error */
#define B43_LPPHY_CHANNEL B43_PHY_OFDM(0x08) /* Channel */
#define B43_LPPHY_WORKAROUND B43_PHY_OFDM(0x09) /* workaround */
#define B43_LPPHY_FOURWIRE_ADDR B43_PHY_OFDM(0x0B) /* Fourwire Address */
#define B43_LPPHY_FOURWIREDATAHI B43_PHY_OFDM(0x0C) /* FourwireDataHi */
#define B43_LPPHY_FOURWIREDATALO B43_PHY_OFDM(0x0D) /* FourwireDataLo */
#define B43_LPPHY_BISTSTAT0 B43_PHY_OFDM(0x0E) /* BistStatus0 */
#define B43_LPPHY_BISTSTAT1 B43_PHY_OFDM(0x0F) /* BistStatus1 */
#define B43_LPPHY_CRSGAIN_CTL B43_PHY_OFDM(0x10) /* crsgain Control */
#define B43_LPPHY_OFDMPWR_THRESH0 B43_PHY_OFDM(0x11) /* ofdmPower Thresh0 */
#define B43_LPPHY_OFDMPWR_THRESH1 B43_PHY_OFDM(0x12) /* ofdmPower Thresh1 */
#define B43_LPPHY_OFDMPWR_THRESH2 B43_PHY_OFDM(0x13) /* ofdmPower Thresh2 */
#define B43_LPPHY_DSSSPWR_THRESH0 B43_PHY_OFDM(0x14) /* dsssPower Thresh0 */
#define B43_LPPHY_DSSSPWR_THRESH1 B43_PHY_OFDM(0x15) /* dsssPower Thresh1 */
#define B43_LPPHY_MINPWR_LEVEL B43_PHY_OFDM(0x16) /* MinPower Level */
#define B43_LPPHY_OFDMSYNCTHRESH0 B43_PHY_OFDM(0x17) /* ofdmSyncThresh0 */
#define B43_LPPHY_OFDMSYNCTHRESH1 B43_PHY_OFDM(0x18) /* ofdmSyncThresh1 */
#define B43_LPPHY_FINEFREQEST B43_PHY_OFDM(0x19) /* FineFreqEst */
#define B43_LPPHY_IDLEAFTERPKTRXTO B43_PHY_OFDM(0x1A) /* IDLEafterPktRXTimeout */
#define B43_LPPHY_LTRN_CTL B43_PHY_OFDM(0x1B) /* LTRN Control */
#define B43_LPPHY_DCOFFSETTRANSIENT B43_PHY_OFDM(0x1C) /* DCOffsetTransient */
#define B43_LPPHY_PREAMBLEINTO B43_PHY_OFDM(0x1D) /* PreambleInTimeout */
#define B43_LPPHY_PREAMBLECONFIRMTO B43_PHY_OFDM(0x1E) /* PreambleConfirmTimeout */
#define B43_LPPHY_CLIPTHRESH B43_PHY_OFDM(0x1F) /* ClipThresh */
#define B43_LPPHY_CLIPCTRTHRESH B43_PHY_OFDM(0x20) /* ClipCtrThresh */
#define B43_LPPHY_OFDMSYNCTIMER_CTL B43_PHY_OFDM(0x21) /* ofdmSyncTimer Control */
#define B43_LPPHY_WAITFORPHYSELTO B43_PHY_OFDM(0x22) /* WaitforPHYSelTimeout */
#define B43_LPPHY_HIGAINDB B43_PHY_OFDM(0x23) /* HiGainDB */
#define B43_LPPHY_LOWGAINDB B43_PHY_OFDM(0x24) /* LowGainDB */
#define B43_LPPHY_VERYLOWGAINDB B43_PHY_OFDM(0x25) /* VeryLowGainDB */
#define B43_LPPHY_GAINMISMATCH B43_PHY_OFDM(0x26) /* gainMismatch */
#define B43_LPPHY_GAINDIRECTMISMATCH B43_PHY_OFDM(0x27) /* gaindirectMismatch */
#define B43_LPPHY_PWR_THRESH0 B43_PHY_OFDM(0x28) /* Power Thresh0 */
#define B43_LPPHY_PWR_THRESH1 B43_PHY_OFDM(0x29) /* Power Thresh1 */
#define B43_LPPHY_DETECTOR_DELAY_ADJUST B43_PHY_OFDM(0x2A) /* Detector Delay Adjust */
#define B43_LPPHY_REDUCED_DETECTOR_DELAY B43_PHY_OFDM(0x2B) /* Reduced Detector Delay */
#define B43_LPPHY_DATA_TO B43_PHY_OFDM(0x2C) /* data Timeout */
#define B43_LPPHY_CORRELATOR_DIS_DELAY B43_PHY_OFDM(0x2D) /* correlator Dis Delay */
#define B43_LPPHY_DIVERSITY_GAINBACK B43_PHY_OFDM(0x2E) /* Diversity GainBack */
#define B43_LPPHY_DSSS_CONFIRM_CNT B43_PHY_OFDM(0x2F) /* DSSS Confirm Cnt */
#define B43_LPPHY_DC_BLANK_INT B43_PHY_OFDM(0x30) /* DC Blank Interval */
#define B43_LPPHY_GAIN_MISMATCH_LIMIT B43_PHY_OFDM(0x31) /* gain Mismatch Limit */
#define B43_LPPHY_CRS_ED_THRESH B43_PHY_OFDM(0x32) /* crs ed thresh */
#define B43_LPPHY_PHASE_SHIFT_CTL B43_PHY_OFDM(0x33) /* phase shift Control */
#define B43_LPPHY_INPUT_PWRDB B43_PHY_OFDM(0x34) /* Input PowerDB */
#define B43_LPPHY_OFDM_SYNC_CTL B43_PHY_OFDM(0x35) /* ofdm sync Control */
#define B43_LPPHY_AFE_ADC_CTL_0 B43_PHY_OFDM(0x36) /* Afe ADC Control 0 */
#define B43_LPPHY_AFE_ADC_CTL_1 B43_PHY_OFDM(0x37) /* Afe ADC Control 1 */
#define B43_LPPHY_AFE_ADC_CTL_2 B43_PHY_OFDM(0x38) /* Afe ADC Control 2 */
#define B43_LPPHY_AFE_DAC_CTL B43_PHY_OFDM(0x39) /* Afe DAC Control */
#define B43_LPPHY_AFE_CTL B43_PHY_OFDM(0x3A) /* Afe Control */
#define B43_LPPHY_AFE_CTL_OVR B43_PHY_OFDM(0x3B) /* Afe Control Ovr */
#define B43_LPPHY_AFE_CTL_OVRVAL B43_PHY_OFDM(0x3C) /* Afe Control OvrVal */
#define B43_LPPHY_AFE_RSSI_CTL_0 B43_PHY_OFDM(0x3D) /* Afe RSSI Control 0 */
#define B43_LPPHY_AFE_RSSI_CTL_1 B43_PHY_OFDM(0x3E) /* Afe RSSI Control 1 */
#define B43_LPPHY_AFE_RSSI_SEL B43_PHY_OFDM(0x3F) /* Afe RSSI Sel */
#define B43_LPPHY_RADAR_THRESH B43_PHY_OFDM(0x40) /* Radar Thresh */
#define B43_LPPHY_RADAR_BLANK_INT B43_PHY_OFDM(0x41) /* Radar blank Interval */
#define B43_LPPHY_RADAR_MIN_FM_INT B43_PHY_OFDM(0x42) /* Radar min fm Interval */
#define B43_LPPHY_RADAR_GAIN_TO B43_PHY_OFDM(0x43) /* Radar gain timeout */
#define B43_LPPHY_RADAR_PULSE_TO B43_PHY_OFDM(0x44) /* Radar pulse timeout */
#define B43_LPPHY_RADAR_DETECT_FM_CTL B43_PHY_OFDM(0x45) /* Radar detect FM Control */
#define B43_LPPHY_RADAR_DETECT_EN B43_PHY_OFDM(0x46) /* Radar detect En */
#define B43_LPPHY_RADAR_RD_DATA_REG B43_PHY_OFDM(0x47) /* Radar Rd Data Reg */
#define B43_LPPHY_LP_PHY_CTL B43_PHY_OFDM(0x48) /* LP PHY Control */
#define B43_LPPHY_CLASSIFIER_CTL B43_PHY_OFDM(0x49) /* classifier Control */
#define B43_LPPHY_RESET_CTL B43_PHY_OFDM(0x4A) /* reset Control */
#define B43_LPPHY_CLKEN_CTL B43_PHY_OFDM(0x4B) /* ClkEn Control */
#define B43_LPPHY_RF_OVERRIDE_0 B43_PHY_OFDM(0x4C) /* RF Override 0 */
#define B43_LPPHY_RF_OVERRIDE_VAL_0 B43_PHY_OFDM(0x4D) /* RF Override Val 0 */
#define B43_LPPHY_TR_LOOKUP_1 B43_PHY_OFDM(0x4E) /* TR Lookup 1 */
#define B43_LPPHY_TR_LOOKUP_2 B43_PHY_OFDM(0x4F) /* TR Lookup 2 */
#define B43_LPPHY_RSSISELLOOKUP1 B43_PHY_OFDM(0x50) /* RssiSelLookup1 */
#define B43_LPPHY_IQLO_CAL_CMD B43_PHY_OFDM(0x51) /* iqlo Cal Cmd */
#define B43_LPPHY_IQLO_CAL_CMD_N_NUM B43_PHY_OFDM(0x52) /* iqlo Cal Cmd N num */
#define B43_LPPHY_IQLO_CAL_CMD_G_CTL B43_PHY_OFDM(0x53) /* iqlo Cal Cmd G control */
#define B43_LPPHY_MACINT_DBG_REGISTER B43_PHY_OFDM(0x54) /* macint Debug Register */
#define B43_LPPHY_TABLE_ADDR B43_PHY_OFDM(0x55) /* Table Address */
#define B43_LPPHY_TABLEDATALO B43_PHY_OFDM(0x56) /* TabledataLo */
#define B43_LPPHY_TABLEDATAHI B43_PHY_OFDM(0x57) /* TabledataHi */
#define B43_LPPHY_PHY_CRS_ENABLE_ADDR B43_PHY_OFDM(0x58) /* phy CRS Enable Address */
#define B43_LPPHY_IDLETIME_CTL B43_PHY_OFDM(0x59) /* Idletime Control */
#define B43_LPPHY_IDLETIME_CRS_ON_LO B43_PHY_OFDM(0x5A) /* Idletime CRS On Lo */
#define B43_LPPHY_IDLETIME_CRS_ON_HI B43_PHY_OFDM(0x5B) /* Idletime CRS On Hi */
#define B43_LPPHY_IDLETIME_MEAS_TIME_LO B43_PHY_OFDM(0x5C) /* Idletime Meas Time Lo */
#define B43_LPPHY_IDLETIME_MEAS_TIME_HI B43_PHY_OFDM(0x5D) /* Idletime Meas Time Hi */
#define B43_LPPHY_RESET_LEN_OFDM_TX_ADDR B43_PHY_OFDM(0x5E) /* Reset len Ofdm TX Address */
#define B43_LPPHY_RESET_LEN_OFDM_RX_ADDR B43_PHY_OFDM(0x5F) /* Reset len Ofdm RX Address */
#define B43_LPPHY_REG_CRS_ENABLE B43_PHY_OFDM(0x60) /* reg crs enable */
#define B43_LPPHY_PLCP_TMT_STR0_CTR_MIN B43_PHY_OFDM(0x61) /* PLCP Tmt Str0 Ctr Min */
#define B43_LPPHY_PKT_FSM_RESET_LEN_VAL B43_PHY_OFDM(0x62) /* Pkt fsm Reset Len Value */
#define B43_LPPHY_READSYM2RESET_CTL B43_PHY_OFDM(0x63) /* readsym2reset Control */
#define B43_LPPHY_DC_FILTER_DELAY1 B43_PHY_OFDM(0x64) /* Dc filter delay1 */
#define B43_LPPHY_PACKET_RX_ACTIVE_TO B43_PHY_OFDM(0x65) /* packet rx Active timeout */
#define B43_LPPHY_ED_TOVAL B43_PHY_OFDM(0x66) /* ed timeoutValue */
#define B43_LPPHY_HOLD_CRS_ON_VAL B43_PHY_OFDM(0x67) /* hold CRS On Value */
#define B43_LPPHY_OFDM_TX_PHY_CRS_DELAY_VAL B43_PHY_OFDM(0x69) /* ofdm tx phy CRS Delay Value */
#define B43_LPPHY_CCK_TX_PHY_CRS_DELAY_VAL B43_PHY_OFDM(0x6A) /* cck tx phy CRS Delay Value */
#define B43_LPPHY_ED_ON_CONFIRM_TIMER_VAL B43_PHY_OFDM(0x6B) /* Ed on confirm Timer Value */
#define B43_LPPHY_ED_OFFSET_CONFIRM_TIMER_VAL B43_PHY_OFDM(0x6C) /* Ed offset confirm Timer Value */
#define B43_LPPHY_PHY_CRS_OFFSET_TIMER_VAL B43_PHY_OFDM(0x6D) /* phy CRS offset Timer Value */
#define B43_LPPHY_ADC_COMPENSATION_CTL B43_PHY_OFDM(0x70) /* ADC Compensation Control */
#define B43_LPPHY_LOG2_RBPSK_ADDR B43_PHY_OFDM(0x71) /* log2 RBPSK Address */
#define B43_LPPHY_LOG2_RQPSK_ADDR B43_PHY_OFDM(0x72) /* log2 RQPSK Address */
#define B43_LPPHY_LOG2_R16QAM_ADDR B43_PHY_OFDM(0x73) /* log2 R16QAM Address */
#define B43_LPPHY_LOG2_R64QAM_ADDR B43_PHY_OFDM(0x74) /* log2 R64QAM Address */
#define B43_LPPHY_OFFSET_BPSK_ADDR B43_PHY_OFDM(0x75) /* offset BPSK Address */
#define B43_LPPHY_OFFSET_QPSK_ADDR B43_PHY_OFDM(0x76) /* offset QPSK Address */
#define B43_LPPHY_OFFSET_16QAM_ADDR B43_PHY_OFDM(0x77) /* offset 16QAM Address */
#define B43_LPPHY_OFFSET_64QAM_ADDR B43_PHY_OFDM(0x78) /* offset 64QAM Address */
#define B43_LPPHY_ALPHA1 B43_PHY_OFDM(0x79) /* Alpha1 */
#define B43_LPPHY_ALPHA2 B43_PHY_OFDM(0x7A) /* Alpha2 */
#define B43_LPPHY_BETA1 B43_PHY_OFDM(0x7B) /* Beta1 */
#define B43_LPPHY_BETA2 B43_PHY_OFDM(0x7C) /* Beta2 */
#define B43_LPPHY_LOOP_NUM_ADDR B43_PHY_OFDM(0x7D) /* Loop Num Address */
#define B43_LPPHY_STR_COLLMAX_SMPL_ADDR B43_PHY_OFDM(0x7E) /* Str Collmax Sample Address */
#define B43_LPPHY_MAX_SMPL_COARSE_FINE_ADDR B43_PHY_OFDM(0x7F) /* Max Sample Coarse/Fine Address */
#define B43_LPPHY_MAX_SMPL_COARSE_STR0CTR_ADDR B43_PHY_OFDM(0x80) /* Max Sample Coarse/Str0Ctr Address */
#define B43_LPPHY_IQ_ENABLE_WAIT_TIME_ADDR B43_PHY_OFDM(0x81) /* IQ Enable Wait Time Address */
#define B43_LPPHY_IQ_NUM_SMPLS_ADDR B43_PHY_OFDM(0x82) /* IQ Num Samples Address */
#define B43_LPPHY_IQ_ACC_HI_ADDR B43_PHY_OFDM(0x83) /* IQ Acc Hi Address */
#define B43_LPPHY_IQ_ACC_LO_ADDR B43_PHY_OFDM(0x84) /* IQ Acc Lo Address */
#define B43_LPPHY_IQ_I_PWR_ACC_HI_ADDR B43_PHY_OFDM(0x85) /* IQ I PWR Acc Hi Address */
#define B43_LPPHY_IQ_I_PWR_ACC_LO_ADDR B43_PHY_OFDM(0x86) /* IQ I PWR Acc Lo Address */
#define B43_LPPHY_IQ_Q_PWR_ACC_HI_ADDR B43_PHY_OFDM(0x87) /* IQ Q PWR Acc Hi Address */
#define B43_LPPHY_IQ_Q_PWR_ACC_LO_ADDR B43_PHY_OFDM(0x88) /* IQ Q PWR Acc Lo Address */
#define B43_LPPHY_MAXNUMSTEPS B43_PHY_OFDM(0x89) /* MaxNumsteps */
#define B43_LPPHY_ROTORPHASE_ADDR B43_PHY_OFDM(0x8A) /* RotorPhase Address */
#define B43_LPPHY_ADVANCEDRETARDROTOR_ADDR B43_PHY_OFDM(0x8B) /* AdvancedRetardRotor Address */
#define B43_LPPHY_RSSIADCDELAY_CTL_ADDR B43_PHY_OFDM(0x8D) /* rssiAdcdelay Control Address */
#define B43_LPPHY_TSSISTAT_ADDR B43_PHY_OFDM(0x8E) /* tssiStatus Address */
#define B43_LPPHY_TEMPSENSESTAT_ADDR B43_PHY_OFDM(0x8F) /* tempsenseStatus Address */
#define B43_LPPHY_TEMPSENSE_CTL_ADDR B43_PHY_OFDM(0x90) /* tempsense Control Address */
#define B43_LPPHY_WRSSISTAT_ADDR B43_PHY_OFDM(0x91) /* wrssistatus Address */
#define B43_LPPHY_MUFACTORADDR B43_PHY_OFDM(0x92) /* mufactoraddr */
#define B43_LPPHY_SCRAMSTATE_ADDR B43_PHY_OFDM(0x93) /* scramstate Address */
#define B43_LPPHY_TXHOLDOFFADDR B43_PHY_OFDM(0x94) /* txholdoffaddr */
#define B43_LPPHY_PKTGAINVAL_ADDR B43_PHY_OFDM(0x95) /* pktgainval Address */
#define B43_LPPHY_COARSEESTIM_ADDR B43_PHY_OFDM(0x96) /* Coarseestim Address */
#define B43_LPPHY_STATE_TRANSITION_ADDR B43_PHY_OFDM(0x97) /* state Transition Address */
#define B43_LPPHY_TRN_OFFSET_ADDR B43_PHY_OFDM(0x98) /* TRN offset Address */
#define B43_LPPHY_NUM_ROTOR_ADDR B43_PHY_OFDM(0x99) /* Num Rotor Address */
#define B43_LPPHY_VITERBI_OFFSET_ADDR B43_PHY_OFDM(0x9A) /* Viterbi Offset Address */
#define B43_LPPHY_SMPL_COLLECT_WAIT_ADDR B43_PHY_OFDM(0x9B) /* Sample collect wait Address */
#define B43_LPPHY_A_PHY_CTL_ADDR B43_PHY_OFDM(0x9C) /* A PHY Control Address */
#define B43_LPPHY_NUM_PASS_THROUGH_ADDR B43_PHY_OFDM(0x9D) /* Num Pass Through Address */
#define B43_LPPHY_RX_COMP_COEFF_S B43_PHY_OFDM(0x9E) /* RX Comp coefficient(s) */
#define B43_LPPHY_CPAROTATEVAL B43_PHY_OFDM(0x9F) /* cpaRotateValue */
#define B43_LPPHY_SMPL_PLAY_COUNT B43_PHY_OFDM(0xA0) /* Sample play count */
#define B43_LPPHY_SMPL_PLAY_BUFFER_CTL B43_PHY_OFDM(0xA1) /* Sample play Buffer Control */
#define B43_LPPHY_FOURWIRE_CTL B43_PHY_OFDM(0xA2) /* fourwire Control */
#define B43_LPPHY_CPA_TAILCOUNT_VAL B43_PHY_OFDM(0xA3) /* CPA TailCount Value */
#define B43_LPPHY_TX_PWR_CTL_CMD B43_PHY_OFDM(0xA4) /* TX Power Control Cmd */
#define B43_LPPHY_TX_PWR_CTL_NNUM B43_PHY_OFDM(0xA5) /* TX Power Control Nnum */
#define B43_LPPHY_TX_PWR_CTL_IDLETSSI B43_PHY_OFDM(0xA6) /* TX Power Control IdleTssi */
#define B43_LPPHY_TX_PWR_CTL_TARGETPWR B43_PHY_OFDM(0xA7) /* TX Power Control TargetPower */
#define B43_LPPHY_TX_PWR_CTL_DELTAPWR_LIMIT B43_PHY_OFDM(0xA8) /* TX Power Control DeltaPower Limit */
#define B43_LPPHY_TX_PWR_CTL_BASEINDEX B43_PHY_OFDM(0xA9) /* TX Power Control BaseIndex */
#define B43_LPPHY_TX_PWR_CTL_PWR_INDEX B43_PHY_OFDM(0xAA) /* TX Power Control Power Index */
#define B43_LPPHY_TX_PWR_CTL_STAT B43_PHY_OFDM(0xAB) /* TX Power Control Status */
#define B43_LPPHY_LP_RF_SIGNAL_LUT B43_PHY_OFDM(0xAC) /* LP RF signal LUT */
#define B43_LPPHY_RX_RADIO_CTL_FILTER_STATE B43_PHY_OFDM(0xAD) /* RX Radio Control Filter State */
#define B43_LPPHY_RX_RADIO_CTL B43_PHY_OFDM(0xAE) /* RX Radio Control */
#define B43_LPPHY_NRSSI_STAT_ADDR B43_PHY_OFDM(0xAF) /* NRSSI status Address */
#define B43_LPPHY_RF_OVERRIDE_2 B43_PHY_OFDM(0xB0) /* RF override 2 */
#define B43_LPPHY_RF_OVERRIDE_2_VAL B43_PHY_OFDM(0xB1) /* RF override 2 val */
#define B43_LPPHY_PS_CTL_OVERRIDE_VAL0 B43_PHY_OFDM(0xB2) /* PS Control override val0 */
#define B43_LPPHY_PS_CTL_OVERRIDE_VAL1 B43_PHY_OFDM(0xB3) /* PS Control override val1 */
#define B43_LPPHY_PS_CTL_OVERRIDE_VAL2 B43_PHY_OFDM(0xB4) /* PS Control override val2 */
#define B43_LPPHY_TX_GAIN_CTL_OVERRIDE_VAL B43_PHY_OFDM(0xB5) /* TX gain Control override val */
#define B43_LPPHY_RX_GAIN_CTL_OVERRIDE_VAL B43_PHY_OFDM(0xB6) /* RX gain Control override val */
#define B43_LPPHY_AFE_DDFS B43_PHY_OFDM(0xB7) /* AFE DDFS */
#define B43_LPPHY_AFE_DDFS_POINTER_INIT B43_PHY_OFDM(0xB8) /* AFE DDFS pointer init */
#define B43_LPPHY_AFE_DDFS_INCR_INIT B43_PHY_OFDM(0xB9) /* AFE DDFS incr init */
#define B43_LPPHY_MRCNOISEREDUCTION B43_PHY_OFDM(0xBA) /* mrcNoiseReduction */
#define B43_LPPHY_TRLOOKUP3 B43_PHY_OFDM(0xBB) /* TRLookup3 */
#define B43_LPPHY_TRLOOKUP4 B43_PHY_OFDM(0xBC) /* TRLookup4 */
#define B43_LPPHY_RADAR_FIFO_STAT B43_PHY_OFDM(0xBD) /* Radar FIFO Status */
#define B43_LPPHY_GPIO_OUTEN B43_PHY_OFDM(0xBE) /* GPIO Out enable */
#define B43_LPPHY_GPIO_SELECT B43_PHY_OFDM(0xBF) /* GPIO Select */
#define B43_LPPHY_GPIO_OUT B43_PHY_OFDM(0xC0) /* GPIO Out */
/* Radio register access decorators. */
#define B43_LP_RADIO(radio_reg) (radio_reg) #define B43_LP_RADIO(radio_reg) (radio_reg)
#define B43_LP_NORTH(radio_reg) B43_LP_RADIO(radio_reg) #define B43_LP_NORTH(radio_reg) B43_LP_RADIO(radio_reg)
#define B43_LP_SOUTH(radio_reg) B43_LP_RADIO((radio_reg) | 0x4000) #define B43_LP_SOUTH(radio_reg) B43_LP_RADIO((radio_reg) | 0x4000)
@ -530,7 +803,47 @@
struct b43_phy_lp { struct b43_phy_lp {
//TODO /* Transmit isolation medium band */
u8 tx_isolation_med_band; /* FIXME initial value? */
/* Transmit isolation low band */
u8 tx_isolation_low_band; /* FIXME initial value? */
/* Transmit isolation high band */
u8 tx_isolation_hi_band; /* FIXME initial value? */
/* Receive power offset */
u8 rx_pwr_offset; /* FIXME initial value? */
/* TSSI transmit count */
u16 tssi_tx_count; /* FIXME initial value? */
/* TSSI index */
u16 tssi_idx; /* FIXME initial value? */
/* TSSI npt */
u16 tssi_npt; /* FIXME initial value? */
/* Target TX frequency */
u16 tgt_tx_freq; /* FIXME initial value? */
/* Transmit power index override */
s8 tx_pwr_idx_over; /* FIXME initial value? */
/* RSSI vf */
u8 rssi_vf; /* FIXME initial value? */
/* RSSI vc */
u8 rssi_vc; /* FIXME initial value? */
/* RSSI gs */
u8 rssi_gs; /* FIXME initial value? */
/* RC cap */
u8 rc_cap; /* FIXME initial value? */
/* BX arch */
u8 bx_arch; /* FIXME initial value? */
/* Full calibration channel */
u8 full_calib_chan; /* FIXME initial value? */
/* Transmit iqlocal best coeffs */
bool tx_iqloc_best_coeffs_valid;
u8 tx_iqloc_best_coeffs[11];
}; };

333
drivers/net/wireless/b43/tables_lpphy.c Normal file
View File

@ -0,0 +1,333 @@
/*
Broadcom B43 wireless driver
IEEE 802.11g LP-PHY and radio device data tables
Copyright (c) 2009 Michael Buesch <mb@bu3sch.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; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "b43.h"
#include "tables_lpphy.h"
#include "phy_common.h"
#include "phy_lp.h"
/* Entry of the 2062 radio init table */
struct b2062_init_tab_entry {
u16 offset;
u16 value_a;
u16 value_g;
u8 flags;
};
#define B2062_FLAG_A 0x01 /* Flag: Init in A mode */
#define B2062_FLAG_G 0x02 /* Flag: Init in G mode */
static const struct b2062_init_tab_entry b2062_init_tab[] = {
/* { .offset = B2062_N_COMM1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = 0x0001, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_N_COMM4, .value_a = 0x0001, .value_g = 0x0000, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_COMM5, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM6, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM7, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM8, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM9, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM10, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM11, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM12, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM13, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM14, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_COMM15, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_PDN_CTL0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_N_PDN_CTL1, .value_a = 0x0000, .value_g = 0x00CA, .flags = B2062_FLAG_G, },
/* { .offset = B2062_N_PDN_CTL2, .value_a = 0x0018, .value_g = 0x0018, .flags = 0, }, */
{ .offset = B2062_N_PDN_CTL3, .value_a = 0x0000, .value_g = 0x0000, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_N_PDN_CTL4, .value_a = 0x0015, .value_g = 0x002A, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_GEN_CTL0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_IQ_CALIB, .value_a = 0x0001, .value_g = 0x0001, .flags = 0, }, */
{ .offset = B2062_N_LGENC, .value_a = 0x00DB, .value_g = 0x00FF, .flags = B2062_FLAG_A, },
/* { .offset = B2062_N_LGENA_LPF, .value_a = 0x0001, .value_g = 0x0001, .flags = 0, }, */
/* { .offset = B2062_N_LGENA_BIAS0, .value_a = 0x0041, .value_g = 0x0041, .flags = 0, }, */
/* { .offset = B2062_N_LGNEA_BIAS1, .value_a = 0x0002, .value_g = 0x0002, .flags = 0, }, */
/* { .offset = B2062_N_LGENA_CTL0, .value_a = 0x0032, .value_g = 0x0032, .flags = 0, }, */
/* { .offset = B2062_N_LGENA_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_LGENA_CTL2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_N_LGENA_TUNE0, .value_a = 0x00DD, .value_g = 0x0000, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_LGENA_TUNE1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_N_LGENA_TUNE2, .value_a = 0x00DD, .value_g = 0x0000, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_N_LGENA_TUNE3, .value_a = 0x0077, .value_g = 0x00B5, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_N_LGENA_CTL3, .value_a = 0x0000, .value_g = 0x00FF, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_LGENA_CTL4, .value_a = 0x001F, .value_g = 0x001F, .flags = 0, }, */
/* { .offset = B2062_N_LGENA_CTL5, .value_a = 0x0032, .value_g = 0x0032, .flags = 0, }, */
/* { .offset = B2062_N_LGENA_CTL6, .value_a = 0x0032, .value_g = 0x0032, .flags = 0, }, */
{ .offset = B2062_N_LGENA_CTL7, .value_a = 0x0033, .value_g = 0x0033, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_RXA_CTL0, .value_a = 0x0009, .value_g = 0x0009, .flags = 0, }, */
{ .offset = B2062_N_RXA_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = B2062_FLAG_G, },
/* { .offset = B2062_N_RXA_CTL2, .value_a = 0x0018, .value_g = 0x0018, .flags = 0, }, */
/* { .offset = B2062_N_RXA_CTL3, .value_a = 0x0027, .value_g = 0x0027, .flags = 0, }, */
/* { .offset = B2062_N_RXA_CTL4, .value_a = 0x0028, .value_g = 0x0028, .flags = 0, }, */
/* { .offset = B2062_N_RXA_CTL5, .value_a = 0x0007, .value_g = 0x0007, .flags = 0, }, */
/* { .offset = B2062_N_RXA_CTL6, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_RXA_CTL7, .value_a = 0x0008, .value_g = 0x0008, .flags = 0, }, */
{ .offset = B2062_N_RXBB_CTL0, .value_a = 0x0082, .value_g = 0x0080, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_RXBB_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_CTL2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_GAIN0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_N_RXBB_GAIN1, .value_a = 0x0004, .value_g = 0x0004, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_N_RXBB_GAIN2, .value_a = 0x0000, .value_g = 0x0000, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_RXBB_GAIN3, .value_a = 0x0011, .value_g = 0x0011, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_RSSI0, .value_a = 0x0043, .value_g = 0x0043, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_RSSI1, .value_a = 0x0033, .value_g = 0x0033, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_CALIB0, .value_a = 0x0010, .value_g = 0x0010, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_CALIB1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_CALIB2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_BIAS0, .value_a = 0x0006, .value_g = 0x0006, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_BIAS1, .value_a = 0x002A, .value_g = 0x002A, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_BIAS2, .value_a = 0x00AA, .value_g = 0x00AA, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_BIAS3, .value_a = 0x0021, .value_g = 0x0021, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_BIAS4, .value_a = 0x00AA, .value_g = 0x00AA, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_BIAS5, .value_a = 0x0022, .value_g = 0x0022, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_RSSI2, .value_a = 0x0001, .value_g = 0x0001, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_RSSI3, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_RSSI4, .value_a = 0x0001, .value_g = 0x0001, .flags = 0, }, */
/* { .offset = B2062_N_RXBB_RSSI5, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL0, .value_a = 0x0001, .value_g = 0x0001, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL2, .value_a = 0x0084, .value_g = 0x0084, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_N_TX_CTL4, .value_a = 0x0003, .value_g = 0x0003, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_N_TX_CTL5, .value_a = 0x0002, .value_g = 0x0002, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_TX_CTL6, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL7, .value_a = 0x0058, .value_g = 0x0058, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL8, .value_a = 0x0082, .value_g = 0x0082, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL9, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_TX_CTL_A, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_TX_GC2G, .value_a = 0x00FF, .value_g = 0x00FF, .flags = 0, }, */
/* { .offset = B2062_N_TX_GC5G, .value_a = 0x00FF, .value_g = 0x00FF, .flags = 0, }, */
{ .offset = B2062_N_TX_TUNE, .value_a = 0x0088, .value_g = 0x001B, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_N_TX_PAD, .value_a = 0x0088, .value_g = 0x0088, .flags = 0, }, */
/* { .offset = B2062_N_TX_PGA, .value_a = 0x0088, .value_g = 0x0088, .flags = 0, }, */
/* { .offset = B2062_N_TX_PADAUX, .value_a = 0x0033, .value_g = 0x0033, .flags = 0, }, */
/* { .offset = B2062_N_TX_PGAAUX, .value_a = 0x0033, .value_g = 0x0033, .flags = 0, }, */
/* { .offset = B2062_N_TSSI_CTL0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_TSSI_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_TSSI_CTL2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_IQ_CALIB_CTL0, .value_a = 0x0033, .value_g = 0x0033, .flags = 0, }, */
/* { .offset = B2062_N_IQ_CALIB_CTL1, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
/* { .offset = B2062_N_IQ_CALIB_CTL2, .value_a = 0x0032, .value_g = 0x0032, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_TS, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_CTL0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_CTL1, .value_a = 0x0015, .value_g = 0x0015, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_CTL2, .value_a = 0x000F, .value_g = 0x000F, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_CTL3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_CTL4, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_DBG0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_DBG1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_DBG2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_CALIB_DBG3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_PSENSE_CTL0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_PSENSE_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_PSENSE_CTL2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_N_TEST_BUF0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RADIO_ID_CODE, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_COMM4, .value_a = 0x0001, .value_g = 0x0000, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_COMM5, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM6, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM7, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM8, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM9, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM10, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM11, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM12, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM13, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM14, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_COMM15, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_PDS_CTL0, .value_a = 0x00FF, .value_g = 0x00FF, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_PDS_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_PDS_CTL2, .value_a = 0x008E, .value_g = 0x008E, .flags = 0, }, */
/* { .offset = B2062_S_PDS_CTL3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_BG_CTL0, .value_a = 0x0006, .value_g = 0x0006, .flags = 0, }, */
/* { .offset = B2062_S_BG_CTL1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_BG_CTL2, .value_a = 0x0011, .value_g = 0x0011, .flags = 0, }, */
{ .offset = B2062_S_LGENG_CTL0, .value_a = 0x00F8, .value_g = 0x00D8, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_LGENG_CTL1, .value_a = 0x003C, .value_g = 0x0024, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_LGENG_CTL2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_LGENG_CTL3, .value_a = 0x0041, .value_g = 0x0041, .flags = 0, }, */
/* { .offset = B2062_S_LGENG_CTL4, .value_a = 0x0002, .value_g = 0x0002, .flags = 0, }, */
/* { .offset = B2062_S_LGENG_CTL5, .value_a = 0x0033, .value_g = 0x0033, .flags = 0, }, */
/* { .offset = B2062_S_LGENG_CTL6, .value_a = 0x0022, .value_g = 0x0022, .flags = 0, }, */
/* { .offset = B2062_S_LGENG_CTL7, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_LGENG_CTL8, .value_a = 0x0088, .value_g = 0x0080, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_LGENG_CTL9, .value_a = 0x0088, .value_g = 0x0088, .flags = 0, }, */
{ .offset = B2062_S_LGENG_CTL10, .value_a = 0x0088, .value_g = 0x0080, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_LGENG_CTL11, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL0, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL1, .value_a = 0x0007, .value_g = 0x0007, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL2, .value_a = 0x00AF, .value_g = 0x00AF, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL3, .value_a = 0x0012, .value_g = 0x0012, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL4, .value_a = 0x000B, .value_g = 0x000B, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL5, .value_a = 0x005F, .value_g = 0x005F, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL6, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL7, .value_a = 0x0040, .value_g = 0x0040, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL8, .value_a = 0x0052, .value_g = 0x0052, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL9, .value_a = 0x0026, .value_g = 0x0026, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL10, .value_a = 0x0003, .value_g = 0x0003, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL11, .value_a = 0x0036, .value_g = 0x0036, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL12, .value_a = 0x0057, .value_g = 0x0057, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL13, .value_a = 0x0011, .value_g = 0x0011, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL14, .value_a = 0x0075, .value_g = 0x0075, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL15, .value_a = 0x00B4, .value_g = 0x00B4, .flags = 0, }, */
/* { .offset = B2062_S_REFPLL_CTL16, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_RFPLL_CTL0, .value_a = 0x0098, .value_g = 0x0098, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL1, .value_a = 0x0010, .value_g = 0x0010, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_RFPLL_CTL2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RFPLL_CTL3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RFPLL_CTL4, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_RFPLL_CTL5, .value_a = 0x0043, .value_g = 0x0043, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL6, .value_a = 0x0047, .value_g = 0x0047, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL7, .value_a = 0x000C, .value_g = 0x000C, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL8, .value_a = 0x0011, .value_g = 0x0011, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL9, .value_a = 0x0011, .value_g = 0x0011, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL10, .value_a = 0x000E, .value_g = 0x000E, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL11, .value_a = 0x0008, .value_g = 0x0008, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL12, .value_a = 0x0033, .value_g = 0x0033, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL13, .value_a = 0x000A, .value_g = 0x000A, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL14, .value_a = 0x0006, .value_g = 0x0006, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_RFPLL_CTL15, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RFPLL_CTL16, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RFPLL_CTL17, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_RFPLL_CTL18, .value_a = 0x003E, .value_g = 0x003E, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL19, .value_a = 0x0013, .value_g = 0x0013, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_RFPLL_CTL20, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_RFPLL_CTL21, .value_a = 0x0062, .value_g = 0x0062, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL22, .value_a = 0x0007, .value_g = 0x0007, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL23, .value_a = 0x0016, .value_g = 0x0016, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL24, .value_a = 0x005C, .value_g = 0x005C, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL25, .value_a = 0x0095, .value_g = 0x0095, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_RFPLL_CTL26, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RFPLL_CTL27, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RFPLL_CTL28, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RFPLL_CTL29, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_RFPLL_CTL30, .value_a = 0x00A0, .value_g = 0x00A0, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL31, .value_a = 0x0004, .value_g = 0x0004, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_RFPLL_CTL32, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
{ .offset = B2062_S_RFPLL_CTL33, .value_a = 0x00CC, .value_g = 0x00CC, .flags = B2062_FLAG_A | B2062_FLAG_G, },
{ .offset = B2062_S_RFPLL_CTL34, .value_a = 0x0007, .value_g = 0x0007, .flags = B2062_FLAG_A | B2062_FLAG_G, },
/* { .offset = B2062_S_RXG_CNT0, .value_a = 0x0010, .value_g = 0x0010, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT1, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT2, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT3, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT4, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT5, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT6, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT7, .value_a = 0x0005, .value_g = 0x0005, .flags = 0, }, */
{ .offset = B2062_S_RXG_CNT8, .value_a = 0x000F, .value_g = 0x000F, .flags = B2062_FLAG_A, },
/* { .offset = B2062_S_RXG_CNT9, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT10, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT11, .value_a = 0x0066, .value_g = 0x0066, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT12, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT13, .value_a = 0x0044, .value_g = 0x0044, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT14, .value_a = 0x00A0, .value_g = 0x00A0, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT15, .value_a = 0x0004, .value_g = 0x0004, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT16, .value_a = 0x0000, .value_g = 0x0000, .flags = 0, }, */
/* { .offset = B2062_S_RXG_CNT17, .value_a = 0x0055, .value_g = 0x0055, .flags = 0, }, */
};
void b2062_upload_init_table(struct b43_wldev *dev)
{
const struct b2062_init_tab_entry *e;
unsigned int i;
for (i = 0; i < ARRAY_SIZE(b2062_init_tab); i++) {
e = &b2062_init_tab[i];
if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
if (!(e->flags & B2062_FLAG_G))
continue;
b43_radio_write(dev, e->offset, e->value_g);
} else {
if (!(e->flags & B2062_FLAG_A))
continue;
b43_radio_write(dev, e->offset, e->value_a);
}
}
}
u32 b43_lptab_read(struct b43_wldev *dev, u32 offset)
{
u32 type, value;
type = offset & B43_LPTAB_TYPEMASK;
offset &= ~B43_LPTAB_TYPEMASK;
B43_WARN_ON(offset > 0xFFFF);
switch (type) {
case B43_LPTAB_8BIT:
b43_phy_write(dev, B43_LPPHY_TABLE_ADDR, offset);
value = b43_phy_read(dev, B43_LPPHY_TABLEDATALO) & 0xFF;
break;
case B43_LPTAB_16BIT:
b43_phy_write(dev, B43_LPPHY_TABLE_ADDR, offset);
value = b43_phy_read(dev, B43_LPPHY_TABLEDATALO);
break;
case B43_LPTAB_32BIT:
b43_phy_write(dev, B43_LPPHY_TABLE_ADDR, offset);
value = b43_phy_read(dev, B43_LPPHY_TABLEDATAHI);
value <<= 16;
value |= b43_phy_read(dev, B43_LPPHY_TABLEDATALO);
break;
default:
B43_WARN_ON(1);
value = 0;
}
return value;
}
void b43_lptab_write(struct b43_wldev *dev, u32 offset, u32 value)
{
u32 type;
type = offset & B43_LPTAB_TYPEMASK;
offset &= ~B43_LPTAB_TYPEMASK;
B43_WARN_ON(offset > 0xFFFF);
switch (type) {
case B43_LPTAB_8BIT:
B43_WARN_ON(value & ~0xFF);
b43_phy_write(dev, B43_LPPHY_TABLE_ADDR, offset);
b43_phy_write(dev, B43_LPPHY_TABLEDATALO, value);
break;
case B43_LPTAB_16BIT:
B43_WARN_ON(value & ~0xFFFF);
b43_phy_write(dev, B43_LPPHY_TABLE_ADDR, offset);
b43_phy_write(dev, B43_LPPHY_TABLEDATALO, value);
break;
case B43_LPTAB_32BIT:
b43_phy_write(dev, B43_LPPHY_TABLE_ADDR, offset);
b43_phy_write(dev, B43_LPPHY_TABLEDATAHI, value >> 16);
b43_phy_write(dev, B43_LPPHY_TABLEDATALO, value);
break;
default:
B43_WARN_ON(1);
}
}

23
drivers/net/wireless/b43/tables_lpphy.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef B43_TABLES_LPPHY_H_
#define B43_TABLES_LPPHY_H_
#define B43_LPTAB_TYPEMASK 0xF0000000
#define B43_LPTAB_8BIT 0x10000000
#define B43_LPTAB_16BIT 0x20000000
#define B43_LPTAB_32BIT 0x30000000
#define B43_LPTAB8(table, offset) (((table) << 10) | (offset) | B43_LPTAB_8BIT)
#define B43_LPTAB16(table, offset) (((table) << 10) | (offset) | B43_LPTAB_16BIT)
#define B43_LPTAB32(table, offset) (((table) << 10) | (offset) | B43_LPTAB_32BIT)
/* Table definitions */
#define B43_LPTAB_TXPWR_R2PLUS B43_LPTAB32(0x07, 0) /* TX power lookup table (rev >= 2) */
#define B43_LPTAB_TXPWR_R0_1 B43_LPTAB32(0xA0, 0) /* TX power lookup table (rev < 2) */
u32 b43_lptab_read(struct b43_wldev *dev, u32 offset);
void b43_lptab_write(struct b43_wldev *dev, u32 offset, u32 value);
void b2062_upload_init_table(struct b43_wldev *dev);
#endif /* B43_TABLES_LPPHY_H_ */

8
drivers/net/wireless/b43legacy/leds.c
View File

@ -146,12 +146,12 @@ static void b43legacy_map_led(struct b43legacy_wldev *dev,
case B43legacy_LED_TRANSFER: case B43legacy_LED_TRANSFER:
case B43legacy_LED_APTRANSFER: case B43legacy_LED_APTRANSFER:
snprintf(name, sizeof(name), snprintf(name, sizeof(name),
"b43legacy-%s:tx", wiphy_name(hw->wiphy)); "b43legacy-%s::tx", wiphy_name(hw->wiphy));
b43legacy_register_led(dev, &dev->led_tx, name, b43legacy_register_led(dev, &dev->led_tx, name,
ieee80211_get_tx_led_name(hw), ieee80211_get_tx_led_name(hw),
led_index, activelow); led_index, activelow);
snprintf(name, sizeof(name), snprintf(name, sizeof(name),
"b43legacy-%s:rx", wiphy_name(hw->wiphy)); "b43legacy-%s::rx", wiphy_name(hw->wiphy));
b43legacy_register_led(dev, &dev->led_rx, name, b43legacy_register_led(dev, &dev->led_rx, name,
ieee80211_get_rx_led_name(hw), ieee80211_get_rx_led_name(hw),
led_index, activelow); led_index, activelow);
@ -161,7 +161,7 @@ static void b43legacy_map_led(struct b43legacy_wldev *dev,
case B43legacy_LED_RADIO_B: case B43legacy_LED_RADIO_B:
case B43legacy_LED_MODE_BG: case B43legacy_LED_MODE_BG:
snprintf(name, sizeof(name), snprintf(name, sizeof(name),
"b43legacy-%s:radio", wiphy_name(hw->wiphy)); "b43legacy-%s::radio", wiphy_name(hw->wiphy));
b43legacy_register_led(dev, &dev->led_radio, name, b43legacy_register_led(dev, &dev->led_radio, name,
b43legacy_rfkill_led_name(dev), b43legacy_rfkill_led_name(dev),
led_index, activelow); led_index, activelow);
@ -172,7 +172,7 @@ static void b43legacy_map_led(struct b43legacy_wldev *dev,
case B43legacy_LED_WEIRD: case B43legacy_LED_WEIRD:
case B43legacy_LED_ASSOC: case B43legacy_LED_ASSOC:
snprintf(name, sizeof(name), snprintf(name, sizeof(name),
"b43legacy-%s:assoc", wiphy_name(hw->wiphy)); "b43legacy-%s::assoc", wiphy_name(hw->wiphy));
b43legacy_register_led(dev, &dev->led_assoc, name, b43legacy_register_led(dev, &dev->led_assoc, name,
ieee80211_get_assoc_led_name(hw), ieee80211_get_assoc_led_name(hw),
led_index, activelow); led_index, activelow);

4
drivers/net/wireless/hostap/hostap_80211_rx.c
View File

@ -193,7 +193,7 @@ hdr->f.status = s; hdr->f.len = l; hdr->f.data = d
if (prism_header) if (prism_header)
skb_pull(skb, phdrlen); skb_pull(skb, phdrlen);
skb->pkt_type = PACKET_OTHERHOST; skb->pkt_type = PACKET_OTHERHOST;
skb->protocol = __constant_htons(ETH_P_802_2); skb->protocol = cpu_to_be16(ETH_P_802_2);
memset(skb->cb, 0, sizeof(skb->cb)); memset(skb->cb, 0, sizeof(skb->cb));
netif_rx(skb); netif_rx(skb);
@ -1094,7 +1094,7 @@ void hostap_80211_rx(struct net_device *dev, struct sk_buff *skb,
if (skb2 != NULL) { if (skb2 != NULL) {
/* send to wireless media */ /* send to wireless media */
skb2->dev = dev; skb2->dev = dev;
skb2->protocol = __constant_htons(ETH_P_802_3); skb2->protocol = cpu_to_be16(ETH_P_802_3);
skb_reset_mac_header(skb2); skb_reset_mac_header(skb2);
skb_reset_network_header(skb2); skb_reset_network_header(skb2);
/* skb2->network_header += ETH_HLEN; */ /* skb2->network_header += ETH_HLEN; */

8
drivers/net/wireless/hostap/hostap_ap.c
View File

@ -609,7 +609,7 @@ static void hostap_ap_tx_cb(struct sk_buff *skb, int ok, void *data)
skb->dev = ap->local->apdev; skb->dev = ap->local->apdev;
skb_pull(skb, hostap_80211_get_hdrlen(fc)); skb_pull(skb, hostap_80211_get_hdrlen(fc));
skb->pkt_type = PACKET_OTHERHOST; skb->pkt_type = PACKET_OTHERHOST;
skb->protocol = __constant_htons(ETH_P_802_2); skb->protocol = cpu_to_be16(ETH_P_802_2);
memset(skb->cb, 0, sizeof(skb->cb)); memset(skb->cb, 0, sizeof(skb->cb));
netif_rx(skb); netif_rx(skb);
} }
@ -2281,7 +2281,7 @@ void hostap_rx(struct net_device *dev, struct sk_buff *skb,
WLAN_FC_GET_STYPE(fc) == IEEE80211_STYPE_BEACON) WLAN_FC_GET_STYPE(fc) == IEEE80211_STYPE_BEACON)
goto drop; goto drop;
skb->protocol = __constant_htons(ETH_P_HOSTAP); skb->protocol = cpu_to_be16(ETH_P_HOSTAP);
handle_ap_item(local, skb, rx_stats); handle_ap_item(local, skb, rx_stats);
return; return;
@ -2310,7 +2310,7 @@ static void schedule_packet_send(local_info_t *local, struct sta_info *sta)
hdr = (struct ieee80211_hdr_4addr *) skb_put(skb, 16); hdr = (struct ieee80211_hdr_4addr *) skb_put(skb, 16);
/* Generate a fake pspoll frame to start packet delivery */ /* Generate a fake pspoll frame to start packet delivery */
hdr->frame_ctl = __constant_cpu_to_le16( hdr->frame_ctl = cpu_to_le16(
IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL); IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL);
memcpy(hdr->addr1, local->dev->dev_addr, ETH_ALEN); memcpy(hdr->addr1, local->dev->dev_addr, ETH_ALEN);
memcpy(hdr->addr2, sta->addr, ETH_ALEN); memcpy(hdr->addr2, sta->addr, ETH_ALEN);
@ -2754,7 +2754,7 @@ ap_tx_ret hostap_handle_sta_tx(local_info_t *local, struct hostap_tx_data *tx)
if (meta->flags & HOSTAP_TX_FLAGS_ADD_MOREDATA) { if (meta->flags & HOSTAP_TX_FLAGS_ADD_MOREDATA) {
/* indicate to STA that more frames follow */ /* indicate to STA that more frames follow */
hdr->frame_ctl |= hdr->frame_ctl |=
__constant_cpu_to_le16(IEEE80211_FCTL_MOREDATA); cpu_to_le16(IEEE80211_FCTL_MOREDATA);
} }
if (meta->flags & HOSTAP_TX_FLAGS_BUFFERED_FRAME) { if (meta->flags & HOSTAP_TX_FLAGS_BUFFERED_FRAME) {

6
drivers/net/wireless/hostap/hostap_ioctl.c
View File

@ -1638,7 +1638,7 @@ static int prism2_request_hostscan(struct net_device *dev,
memset(&scan_req, 0, sizeof(scan_req)); memset(&scan_req, 0, sizeof(scan_req));
scan_req.channel_list = cpu_to_le16(local->channel_mask & scan_req.channel_list = cpu_to_le16(local->channel_mask &
local->scan_channel_mask); local->scan_channel_mask);
scan_req.txrate = __constant_cpu_to_le16(HFA384X_RATES_1MBPS); scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
if (ssid) { if (ssid) {
if (ssid_len > 32) if (ssid_len > 32)
return -EINVAL; return -EINVAL;
@ -1668,7 +1668,7 @@ static int prism2_request_scan(struct net_device *dev)
memset(&scan_req, 0, sizeof(scan_req)); memset(&scan_req, 0, sizeof(scan_req));
scan_req.channel_list = cpu_to_le16(local->channel_mask & scan_req.channel_list = cpu_to_le16(local->channel_mask &
local->scan_channel_mask); local->scan_channel_mask);
scan_req.txrate = __constant_cpu_to_le16(HFA384X_RATES_1MBPS); scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS);
/* FIX: /* FIX:
* It seems to be enough to set roaming mode for a short moment to * It seems to be enough to set roaming mode for a short moment to
@ -2514,7 +2514,7 @@ static int prism2_ioctl_priv_prism2_param(struct net_device *dev,
u16 rate; u16 rate;
memset(&scan_req, 0, sizeof(scan_req)); memset(&scan_req, 0, sizeof(scan_req));
scan_req.channel_list = __constant_cpu_to_le16(0x3fff); scan_req.channel_list = cpu_to_le16(0x3fff);
switch (value) { switch (value) {
case 1: rate = HFA384X_RATES_1MBPS; break; case 1: rate = HFA384X_RATES_1MBPS; break;
case 2: rate = HFA384X_RATES_2MBPS; break; case 2: rate = HFA384X_RATES_2MBPS; break;

1
drivers/net/wireless/ipw2x00/Kconfig
View File

@ -150,6 +150,7 @@ config IPW2200_DEBUG
config LIBIPW config LIBIPW
tristate tristate
depends on PCI && WLAN_80211
select WIRELESS_EXT select WIRELESS_EXT
select CRYPTO select CRYPTO
select CRYPTO_ARC4 select CRYPTO_ARC4

2
drivers/net/wireless/ipw2x00/ipw2200.c
View File

@ -8272,7 +8272,7 @@ static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
skb_reset_mac_header(skb); skb_reset_mac_header(skb);
skb->pkt_type = PACKET_OTHERHOST; skb->pkt_type = PACKET_OTHERHOST;
skb->protocol = __constant_htons(ETH_P_80211_STATS); skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
memset(skb->cb, 0, sizeof(rxb->skb->cb)); memset(skb->cb, 0, sizeof(rxb->skb->cb));
netif_rx(skb); netif_rx(skb);
rxb->skb = NULL; rxb->skb = NULL;

2
drivers/net/wireless/iwlwifi/Makefile
View File

@ -8,7 +8,7 @@ iwlcore-$(CONFIG_IWLWIFI_RFKILL) += iwl-rfkill.o
iwlcore-$(CONFIG_IWLAGN_SPECTRUM_MEASUREMENT) += iwl-spectrum.o iwlcore-$(CONFIG_IWLAGN_SPECTRUM_MEASUREMENT) += iwl-spectrum.o
obj-$(CONFIG_IWLAGN) += iwlagn.o obj-$(CONFIG_IWLAGN) += iwlagn.o
iwlagn-objs := iwl-agn.o iwl-agn-rs.o iwl-agn-hcmd-check.o iwlagn-objs := iwl-agn.o iwl-agn-rs.o
iwlagn-$(CONFIG_IWL4965) += iwl-4965.o iwlagn-$(CONFIG_IWL4965) += iwl-4965.o
iwlagn-$(CONFIG_IWL5000) += iwl-5000.o iwlagn-$(CONFIG_IWL5000) += iwl-5000.o

5
drivers/net/wireless/iwlwifi/iwl-100.c
View File

@ -46,7 +46,7 @@
#include "iwl-5000-hw.h" #include "iwl-5000-hw.h"
/* Highest firmware API version supported */ /* Highest firmware API version supported */
#define IWL100_UCODE_API_MAX 1 #define IWL100_UCODE_API_MAX 2
/* Lowest firmware API version supported */ /* Lowest firmware API version supported */
#define IWL100_UCODE_API_MIN 1 #define IWL100_UCODE_API_MIN 1
@ -66,5 +66,8 @@ struct iwl_cfg iwl100_bgn_cfg = {
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_A,
.valid_rx_ant = ANT_AB,
.need_pll_cfg = true,
}; };

14
drivers/net/wireless/iwlwifi/iwl-3945-led.c
View File

@ -137,7 +137,7 @@ static int iwl3945_led_off(struct iwl_priv *priv, int led_id)
.off = 0, .off = 0,
.interval = IWL_DEF_LED_INTRVL .interval = IWL_DEF_LED_INTRVL
}; };
IWL_DEBUG_LED("led off %d\n", led_id); IWL_DEBUG_LED(priv, "led off %d\n", led_id);
return iwl_send_led_cmd(priv, &led_cmd); return iwl_send_led_cmd(priv, &led_cmd);
} }
@ -174,7 +174,7 @@ static void iwl3945_led_brightness_set(struct led_classdev *led_cdev,
case LED_FULL: case LED_FULL:
if (led->type == IWL_LED_TRG_ASSOC) { if (led->type == IWL_LED_TRG_ASSOC) {
priv->allow_blinking = 1; priv->allow_blinking = 1;
IWL_DEBUG_LED("MAC is associated\n"); IWL_DEBUG_LED(priv, "MAC is associated\n");
} }
if (led->led_on) if (led->led_on)
led->led_on(priv, IWL_LED_LINK); led->led_on(priv, IWL_LED_LINK);
@ -182,7 +182,7 @@ static void iwl3945_led_brightness_set(struct led_classdev *led_cdev,
case LED_OFF: case LED_OFF:
if (led->type == IWL_LED_TRG_ASSOC) { if (led->type == IWL_LED_TRG_ASSOC) {
priv->allow_blinking = 0; priv->allow_blinking = 0;
IWL_DEBUG_LED("MAC is disassociated\n"); IWL_DEBUG_LED(priv, "MAC is disassociated\n");
} }
if (led->led_off) if (led->led_off)
led->led_off(priv, IWL_LED_LINK); led->led_off(priv, IWL_LED_LINK);
@ -316,7 +316,7 @@ int iwl3945_led_register(struct iwl_priv *priv)
trigger = ieee80211_get_radio_led_name(priv->hw); trigger = ieee80211_get_radio_led_name(priv->hw);
snprintf(priv->led39[IWL_LED_TRG_RADIO].name, snprintf(priv->led39[IWL_LED_TRG_RADIO].name,
sizeof(priv->led39[IWL_LED_TRG_RADIO].name), "iwl-%s:radio", sizeof(priv->led39[IWL_LED_TRG_RADIO].name), "iwl-%s::radio",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
priv->led39[IWL_LED_TRG_RADIO].led_on = iwl3945_led_on; priv->led39[IWL_LED_TRG_RADIO].led_on = iwl3945_led_on;
@ -332,7 +332,7 @@ int iwl3945_led_register(struct iwl_priv *priv)
trigger = ieee80211_get_assoc_led_name(priv->hw); trigger = ieee80211_get_assoc_led_name(priv->hw);
snprintf(priv->led39[IWL_LED_TRG_ASSOC].name, snprintf(priv->led39[IWL_LED_TRG_ASSOC].name,
sizeof(priv->led39[IWL_LED_TRG_ASSOC].name), "iwl-%s:assoc", sizeof(priv->led39[IWL_LED_TRG_ASSOC].name), "iwl-%s::assoc",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
ret = iwl3945_led_register_led(priv, ret = iwl3945_led_register_led(priv,
@ -349,7 +349,7 @@ int iwl3945_led_register(struct iwl_priv *priv)
trigger = ieee80211_get_rx_led_name(priv->hw); trigger = ieee80211_get_rx_led_name(priv->hw);
snprintf(priv->led39[IWL_LED_TRG_RX].name, snprintf(priv->led39[IWL_LED_TRG_RX].name,
sizeof(priv->led39[IWL_LED_TRG_RX].name), "iwl-%s:RX", sizeof(priv->led39[IWL_LED_TRG_RX].name), "iwl-%s::RX",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
ret = iwl3945_led_register_led(priv, ret = iwl3945_led_register_led(priv,
@ -365,7 +365,7 @@ int iwl3945_led_register(struct iwl_priv *priv)
trigger = ieee80211_get_tx_led_name(priv->hw); trigger = ieee80211_get_tx_led_name(priv->hw);
snprintf(priv->led39[IWL_LED_TRG_TX].name, snprintf(priv->led39[IWL_LED_TRG_TX].name,
sizeof(priv->led39[IWL_LED_TRG_TX].name), "iwl-%s:TX", sizeof(priv->led39[IWL_LED_TRG_TX].name), "iwl-%s::TX",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
ret = iwl3945_led_register_led(priv, ret = iwl3945_led_register_led(priv,

86
drivers/net/wireless/iwlwifi/iwl-3945-rs.c
View File

@ -183,7 +183,7 @@ static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta *rs_sta)
int unflushed = 0; int unflushed = 0;
int i; int i;
unsigned long flags; unsigned long flags;
struct iwl_priv *priv = rs_sta->priv; struct iwl_priv *priv __maybe_unused = rs_sta->priv;
/* /*
* For each rate, if we have collected data on that rate * For each rate, if we have collected data on that rate
@ -197,7 +197,7 @@ static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta *rs_sta)
spin_lock_irqsave(&rs_sta->lock, flags); spin_lock_irqsave(&rs_sta->lock, flags);
if (time_after(jiffies, rs_sta->win[i].stamp + if (time_after(jiffies, rs_sta->win[i].stamp +
IWL_RATE_WIN_FLUSH)) { IWL_RATE_WIN_FLUSH)) {
IWL_DEBUG_RATE("flushing %d samples of rate " IWL_DEBUG_RATE(priv, "flushing %d samples of rate "
"index %d\n", "index %d\n",
rs_sta->win[i].counter, i); rs_sta->win[i].counter, i);
iwl3945_clear_window(&rs_sta->win[i]); iwl3945_clear_window(&rs_sta->win[i]);
@ -216,12 +216,12 @@ static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta *rs_sta)
static void iwl3945_bg_rate_scale_flush(unsigned long data) static void iwl3945_bg_rate_scale_flush(unsigned long data)
{ {
struct iwl3945_rs_sta *rs_sta = (void *)data; struct iwl3945_rs_sta *rs_sta = (void *)data;
struct iwl_priv *priv = rs_sta->priv; struct iwl_priv *priv __maybe_unused = rs_sta->priv;
int unflushed = 0; int unflushed = 0;
unsigned long flags; unsigned long flags;
u32 packet_count, duration, pps; u32 packet_count, duration, pps;
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
unflushed = iwl3945_rate_scale_flush_windows(rs_sta); unflushed = iwl3945_rate_scale_flush_windows(rs_sta);
@ -236,7 +236,7 @@ static void iwl3945_bg_rate_scale_flush(unsigned long data)
duration = duration =
jiffies_to_msecs(jiffies - rs_sta->last_partial_flush); jiffies_to_msecs(jiffies - rs_sta->last_partial_flush);
IWL_DEBUG_RATE("Tx'd %d packets in %dms\n", IWL_DEBUG_RATE(priv, "Tx'd %d packets in %dms\n",
packet_count, duration); packet_count, duration);
/* Determine packets per second */ /* Determine packets per second */
@ -256,7 +256,7 @@ static void iwl3945_bg_rate_scale_flush(unsigned long data)
rs_sta->flush_time = msecs_to_jiffies(duration); rs_sta->flush_time = msecs_to_jiffies(duration);
IWL_DEBUG_RATE("new flush period: %d msec ave %d\n", IWL_DEBUG_RATE(priv, "new flush period: %d msec ave %d\n",
duration, packet_count); duration, packet_count);
mod_timer(&rs_sta->rate_scale_flush, jiffies + mod_timer(&rs_sta->rate_scale_flush, jiffies +
@ -274,7 +274,7 @@ static void iwl3945_bg_rate_scale_flush(unsigned long data)
spin_unlock_irqrestore(&rs_sta->lock, flags); spin_unlock_irqrestore(&rs_sta->lock, flags);
IWL_DEBUG_RATE("leave\n"); IWL_DEBUG_RATE(priv, "leave\n");
} }
/** /**
@ -290,10 +290,10 @@ static void iwl3945_collect_tx_data(struct iwl3945_rs_sta *rs_sta,
{ {
unsigned long flags; unsigned long flags;
s32 fail_count; s32 fail_count;
struct iwl_priv *priv = rs_sta->priv; struct iwl_priv *priv __maybe_unused = rs_sta->priv;
if (!retries) { if (!retries) {
IWL_DEBUG_RATE("leave: retries == 0 -- should be at least 1\n"); IWL_DEBUG_RATE(priv, "leave: retries == 0 -- should be at least 1\n");
return; return;
} }
@ -347,7 +347,7 @@ static void rs_rate_init(void *priv_r, struct ieee80211_supported_band *sband,
struct iwl_priv *priv = (struct iwl_priv *)priv_r; struct iwl_priv *priv = (struct iwl_priv *)priv_r;
int i; int i;
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
/* TODO: what is a good starting rate for STA? About middle? Maybe not /* TODO: what is a good starting rate for STA? About middle? Maybe not
* the lowest or the highest rate.. Could consider using RSSI from * the lowest or the highest rate.. Could consider using RSSI from
@ -370,7 +370,7 @@ static void rs_rate_init(void *priv_r, struct ieee80211_supported_band *sband,
} }
IWL_DEBUG_RATE("leave\n"); IWL_DEBUG_RATE(priv, "leave\n");
} }
static void *rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir) static void *rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
@ -396,11 +396,11 @@ static void *rs_alloc_sta(void *iwl_priv, struct ieee80211_sta *sta, gfp_t gfp)
* as well just put all the information there. * as well just put all the information there.
*/ */
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
rs_sta = kzalloc(sizeof(struct iwl3945_rs_sta), gfp); rs_sta = kzalloc(sizeof(struct iwl3945_rs_sta), gfp);
if (!rs_sta) { if (!rs_sta) {
IWL_DEBUG_RATE("leave: ENOMEM\n"); IWL_DEBUG_RATE(priv, "leave: ENOMEM\n");
return NULL; return NULL;
} }
@ -428,7 +428,7 @@ static void *rs_alloc_sta(void *iwl_priv, struct ieee80211_sta *sta, gfp_t gfp)
for (i = 0; i < IWL_RATE_COUNT_3945; i++) for (i = 0; i < IWL_RATE_COUNT_3945; i++)
iwl3945_clear_window(&rs_sta->win[i]); iwl3945_clear_window(&rs_sta->win[i]);
IWL_DEBUG_RATE("leave\n"); IWL_DEBUG_RATE(priv, "leave\n");
return rs_sta; return rs_sta;
} }
@ -438,14 +438,14 @@ static void rs_free_sta(void *iwl_priv, struct ieee80211_sta *sta,
{ {
struct iwl3945_sta_priv *psta = (void *) sta->drv_priv; struct iwl3945_sta_priv *psta = (void *) sta->drv_priv;
struct iwl3945_rs_sta *rs_sta = priv_sta; struct iwl3945_rs_sta *rs_sta = priv_sta;
struct iwl_priv *priv = rs_sta->priv; struct iwl_priv *priv __maybe_unused = rs_sta->priv;
psta->rs_sta = NULL; psta->rs_sta = NULL;
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
del_timer_sync(&rs_sta->rate_scale_flush); del_timer_sync(&rs_sta->rate_scale_flush);
kfree(rs_sta); kfree(rs_sta);
IWL_DEBUG_RATE("leave\n"); IWL_DEBUG_RATE(priv, "leave\n");
} }
@ -466,18 +466,18 @@ static void rs_tx_status(void *priv_rate, struct ieee80211_supported_band *sband
struct iwl3945_rs_sta *rs_sta = priv_sta; struct iwl3945_rs_sta *rs_sta = priv_sta;
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
retries = info->status.rates[0].count; retries = info->status.rates[0].count;
first_index = sband->bitrates[info->status.rates[0].idx].hw_value; first_index = sband->bitrates[info->status.rates[0].idx].hw_value;
if ((first_index < 0) || (first_index >= IWL_RATE_COUNT_3945)) { if ((first_index < 0) || (first_index >= IWL_RATE_COUNT_3945)) {
IWL_DEBUG_RATE("leave: Rate out of bounds: %d\n", first_index); IWL_DEBUG_RATE(priv, "leave: Rate out of bounds: %d\n", first_index);
return; return;
} }
if (!priv_sta) { if (!priv_sta) {
IWL_DEBUG_RATE("leave: No STA priv data to update!\n"); IWL_DEBUG_RATE(priv, "leave: No STA priv data to update!\n");
return; return;
} }
@ -511,7 +511,7 @@ static void rs_tx_status(void *priv_rate, struct ieee80211_supported_band *sband
iwl3945_collect_tx_data(rs_sta, iwl3945_collect_tx_data(rs_sta,
&rs_sta->win[scale_rate_index], &rs_sta->win[scale_rate_index],
0, current_count, scale_rate_index); 0, current_count, scale_rate_index);
IWL_DEBUG_RATE("Update rate %d for %d retries.\n", IWL_DEBUG_RATE(priv, "Update rate %d for %d retries.\n",
scale_rate_index, current_count); scale_rate_index, current_count);
retries -= current_count; retries -= current_count;
@ -521,7 +521,7 @@ static void rs_tx_status(void *priv_rate, struct ieee80211_supported_band *sband
/* Update the last index window with success/failure based on ACK */ /* Update the last index window with success/failure based on ACK */
IWL_DEBUG_RATE("Update rate %d with %s.\n", IWL_DEBUG_RATE(priv, "Update rate %d with %s.\n",
last_index, last_index,
(info->flags & IEEE80211_TX_STAT_ACK) ? (info->flags & IEEE80211_TX_STAT_ACK) ?
"success" : "failure"); "success" : "failure");
@ -546,7 +546,7 @@ static void rs_tx_status(void *priv_rate, struct ieee80211_supported_band *sband
spin_unlock_irqrestore(&rs_sta->lock, flags); spin_unlock_irqrestore(&rs_sta->lock, flags);
IWL_DEBUG_RATE("leave\n"); IWL_DEBUG_RATE(priv, "leave\n");
return; return;
} }
@ -556,7 +556,7 @@ static u16 iwl3945_get_adjacent_rate(struct iwl3945_rs_sta *rs_sta,
{ {
u8 high = IWL_RATE_INVALID; u8 high = IWL_RATE_INVALID;
u8 low = IWL_RATE_INVALID; u8 low = IWL_RATE_INVALID;
struct iwl_priv *priv = rs_sta->priv; struct iwl_priv *priv __maybe_unused = rs_sta->priv;
/* 802.11A walks to the next literal adjacent rate in /* 802.11A walks to the next literal adjacent rate in
* the rate table */ * the rate table */
@ -596,7 +596,7 @@ static u16 iwl3945_get_adjacent_rate(struct iwl3945_rs_sta *rs_sta,
break; break;
if (rate_mask & (1 << low)) if (rate_mask & (1 << low))
break; break;
IWL_DEBUG_RATE("Skipping masked lower rate: %d\n", low); IWL_DEBUG_RATE(priv, "Skipping masked lower rate: %d\n", low);
} }
high = index; high = index;
@ -609,7 +609,7 @@ static u16 iwl3945_get_adjacent_rate(struct iwl3945_rs_sta *rs_sta,
break; break;
if (rate_mask & (1 << high)) if (rate_mask & (1 << high))
break; break;
IWL_DEBUG_RATE("Skipping masked higher rate: %d\n", high); IWL_DEBUG_RATE(priv, "Skipping masked higher rate: %d\n", high);
} }
return (high << 8) | low; return (high << 8) | low;
@ -655,7 +655,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
struct iwl_priv *priv = (struct iwl_priv *)priv_r; struct iwl_priv *priv = (struct iwl_priv *)priv_r;
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
if (sta) if (sta)
rate_mask = sta->supp_rates[sband->band]; rate_mask = sta->supp_rates[sband->band];
@ -666,7 +666,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
if ((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA || if ((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA ||
is_multicast_ether_addr(hdr->addr1) || is_multicast_ether_addr(hdr->addr1) ||
!sta || !priv_sta) { !sta || !priv_sta) {
IWL_DEBUG_RATE("leave: No STA priv data to update!\n"); IWL_DEBUG_RATE(priv, "leave: No STA priv data to update!\n");
if (!rate_mask) if (!rate_mask)
info->control.rates[0].idx = info->control.rates[0].idx =
rate_lowest_index(sband, NULL); rate_lowest_index(sband, NULL);
@ -693,7 +693,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
u8 sta_id = iwl3945_hw_find_station(priv, hdr->addr1); u8 sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
if (sta_id == IWL_INVALID_STATION) { if (sta_id == IWL_INVALID_STATION) {
IWL_DEBUG_RATE("LQ: ADD station %pm\n", IWL_DEBUG_RATE(priv, "LQ: ADD station %pm\n",
hdr->addr1); hdr->addr1);
sta_id = iwl3945_add_station(priv, sta_id = iwl3945_add_station(priv,
hdr->addr1, 0, CMD_ASYNC); hdr->addr1, 0, CMD_ASYNC);
@ -728,7 +728,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
(window->success_counter < IWL_RATE_MIN_SUCCESS_TH))) { (window->success_counter < IWL_RATE_MIN_SUCCESS_TH))) {
spin_unlock_irqrestore(&rs_sta->lock, flags); spin_unlock_irqrestore(&rs_sta->lock, flags);
IWL_DEBUG_RATE("Invalid average_tpt on rate %d: " IWL_DEBUG_RATE(priv, "Invalid average_tpt on rate %d: "
"counter: %d, success_counter: %d, " "counter: %d, success_counter: %d, "
"expected_tpt is %sNULL\n", "expected_tpt is %sNULL\n",
index, index,
@ -761,7 +761,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
scale_action = 1; scale_action = 1;
if ((window->success_ratio < IWL_RATE_DECREASE_TH) || !current_tpt) { if ((window->success_ratio < IWL_RATE_DECREASE_TH) || !current_tpt) {
IWL_DEBUG_RATE("decrease rate because of low success_ratio\n"); IWL_DEBUG_RATE(priv, "decrease rate because of low success_ratio\n");
scale_action = -1; scale_action = -1;
} else if ((low_tpt == IWL_INVALID_VALUE) && } else if ((low_tpt == IWL_INVALID_VALUE) &&
(high_tpt == IWL_INVALID_VALUE)) (high_tpt == IWL_INVALID_VALUE))
@ -769,7 +769,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
else if ((low_tpt != IWL_INVALID_VALUE) && else if ((low_tpt != IWL_INVALID_VALUE) &&
(high_tpt != IWL_INVALID_VALUE) && (high_tpt != IWL_INVALID_VALUE) &&
(low_tpt < current_tpt) && (high_tpt < current_tpt)) { (low_tpt < current_tpt) && (high_tpt < current_tpt)) {
IWL_DEBUG_RATE("No action -- low [%d] & high [%d] < " IWL_DEBUG_RATE(priv, "No action -- low [%d] & high [%d] < "
"current_tpt [%d]\n", "current_tpt [%d]\n",
low_tpt, high_tpt, current_tpt); low_tpt, high_tpt, current_tpt);
scale_action = 0; scale_action = 0;
@ -778,14 +778,14 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
if (high_tpt > current_tpt) if (high_tpt > current_tpt)
scale_action = 1; scale_action = 1;
else { else {
IWL_DEBUG_RATE IWL_DEBUG_RATE(priv,
("decrease rate because of high tpt\n"); "decrease rate because of high tpt\n");
scale_action = -1; scale_action = -1;
} }
} else if (low_tpt != IWL_INVALID_VALUE) { } else if (low_tpt != IWL_INVALID_VALUE) {
if (low_tpt > current_tpt) { if (low_tpt > current_tpt) {
IWL_DEBUG_RATE IWL_DEBUG_RATE(priv,
("decrease rate because of low tpt\n"); "decrease rate because of low tpt\n");
scale_action = -1; scale_action = -1;
} else } else
scale_action = 1; scale_action = 1;
@ -797,7 +797,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
scale_action = 0; scale_action = 0;
} else if (scale_action == 1) { } else if (scale_action == 1) {
if (window->success_ratio < IWL_SUCCESS_UP_TH) { if (window->success_ratio < IWL_SUCCESS_UP_TH) {
IWL_DEBUG_RATE("No action -- success_ratio [%d] < " IWL_DEBUG_RATE(priv, "No action -- success_ratio [%d] < "
"SUCCESS UP\n", window->success_ratio); "SUCCESS UP\n", window->success_ratio);
scale_action = 0; scale_action = 0;
} }
@ -820,7 +820,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
break; break;
} }
IWL_DEBUG_RATE("Selected %d (action %d) - low %d high %d\n", IWL_DEBUG_RATE(priv, "Selected %d (action %d) - low %d high %d\n",
index, scale_action, low, high); index, scale_action, low, high);
out: out:
@ -832,7 +832,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
else else
info->control.rates[0].idx = rs_sta->last_txrate_idx; info->control.rates[0].idx = rs_sta->last_txrate_idx;
IWL_DEBUG_RATE("leave: %d\n", index); IWL_DEBUG_RATE(priv, "leave: %d\n", index);
} }
#ifdef CONFIG_MAC80211_DEBUGFS #ifdef CONFIG_MAC80211_DEBUGFS
@ -915,7 +915,7 @@ void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
struct ieee80211_sta *sta; struct ieee80211_sta *sta;
struct iwl3945_sta_priv *psta; struct iwl3945_sta_priv *psta;
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
rcu_read_lock(); rcu_read_lock();
@ -934,7 +934,7 @@ void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
switch (priv->band) { switch (priv->band) {
case IEEE80211_BAND_2GHZ: case IEEE80211_BAND_2GHZ:
/* TODO: this always does G, not a regression */ /* TODO: this always does G, not a regression */
if (priv->active39_rxon.flags & RXON_FLG_TGG_PROTECT_MSK) { if (priv->active_rxon.flags & RXON_FLG_TGG_PROTECT_MSK) {
rs_sta->tgg = 1; rs_sta->tgg = 1;
rs_sta->expected_tpt = iwl3945_expected_tpt_g_prot; rs_sta->expected_tpt = iwl3945_expected_tpt_g_prot;
} else } else
@ -955,11 +955,11 @@ void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
if (rssi == 0) if (rssi == 0)
rssi = IWL_MIN_RSSI_VAL; rssi = IWL_MIN_RSSI_VAL;
IWL_DEBUG(IWL_DL_INFO | IWL_DL_RATE, "Network RSSI: %d\n", rssi); IWL_DEBUG_RATE(priv, "Network RSSI: %d\n", rssi);
rs_sta->start_rate = iwl3945_get_rate_index_by_rssi(rssi, priv->band); rs_sta->start_rate = iwl3945_get_rate_index_by_rssi(rssi, priv->band);
IWL_DEBUG_RATE("leave: rssi %d assign rate index: " IWL_DEBUG_RATE(priv, "leave: rssi %d assign rate index: "
"%d (plcp 0x%x)\n", rssi, rs_sta->start_rate, "%d (plcp 0x%x)\n", rssi, rs_sta->start_rate,
iwl3945_rates[rs_sta->start_rate].plcp); iwl3945_rates[rs_sta->start_rate].plcp);
rcu_read_unlock(); rcu_read_unlock();

130
drivers/net/wireless/iwlwifi/iwl-3945.c
View File

@ -170,7 +170,7 @@ void iwl3945_disable_events(struct iwl_priv *priv)
iwl_release_nic_access(priv); iwl_release_nic_access(priv);
if (IWL_EVT_DISABLE && (array_size == IWL_EVT_DISABLE_SIZE)) { if (IWL_EVT_DISABLE && (array_size == IWL_EVT_DISABLE_SIZE)) {
IWL_DEBUG_INFO("Disabling selected uCode log events at 0x%x\n", IWL_DEBUG_INFO(priv, "Disabling selected uCode log events at 0x%x\n",
disable_ptr); disable_ptr);
ret = iwl_grab_nic_access(priv); ret = iwl_grab_nic_access(priv);
for (i = 0; i < IWL_EVT_DISABLE_SIZE; i++) for (i = 0; i < IWL_EVT_DISABLE_SIZE; i++)
@ -180,9 +180,9 @@ void iwl3945_disable_events(struct iwl_priv *priv)
iwl_release_nic_access(priv); iwl_release_nic_access(priv);
} else { } else {
IWL_DEBUG_INFO("Selected uCode log events may be disabled\n"); IWL_DEBUG_INFO(priv, "Selected uCode log events may be disabled\n");
IWL_DEBUG_INFO(" by writing \"1\"s into disable bitmap\n"); IWL_DEBUG_INFO(priv, " by writing \"1\"s into disable bitmap\n");
IWL_DEBUG_INFO(" in SRAM at 0x%x, size %d u32s\n", IWL_DEBUG_INFO(priv, " in SRAM at 0x%x, size %d u32s\n",
disable_ptr, array_size); disable_ptr, array_size);
} }
@ -251,7 +251,7 @@ int iwl3945_rs_next_rate(struct iwl_priv *priv, int rate)
break; break;
case IEEE80211_BAND_2GHZ: case IEEE80211_BAND_2GHZ:
if (!(priv->sta_supp_rates & IWL_OFDM_RATES_MASK) && if (!(priv->sta_supp_rates & IWL_OFDM_RATES_MASK) &&
iwl3945_is_associated(priv)) { iwl_is_associated(priv)) {
if (rate == IWL_RATE_11M_INDEX) if (rate == IWL_RATE_11M_INDEX)
next_rate = IWL_RATE_5M_INDEX; next_rate = IWL_RATE_5M_INDEX;
} }
@ -338,11 +338,11 @@ static void iwl3945_rx_reply_tx(struct iwl_priv *priv,
info->flags |= ((status & TX_STATUS_MSK) == TX_STATUS_SUCCESS) ? info->flags |= ((status & TX_STATUS_MSK) == TX_STATUS_SUCCESS) ?
IEEE80211_TX_STAT_ACK : 0; IEEE80211_TX_STAT_ACK : 0;
IWL_DEBUG_TX("Tx queue %d Status %s (0x%08x) plcp rate %d retries %d\n", IWL_DEBUG_TX(priv, "Tx queue %d Status %s (0x%08x) plcp rate %d retries %d\n",
txq_id, iwl3945_get_tx_fail_reason(status), status, txq_id, iwl3945_get_tx_fail_reason(status), status,
tx_resp->rate, tx_resp->failure_frame); tx_resp->rate, tx_resp->failure_frame);
IWL_DEBUG_TX_REPLY("Tx queue reclaim %d\n", index); IWL_DEBUG_TX_REPLY(priv, "Tx queue reclaim %d\n", index);
iwl3945_tx_queue_reclaim(priv, txq_id, index); iwl3945_tx_queue_reclaim(priv, txq_id, index);
if (iwl_check_bits(status, TX_ABORT_REQUIRED_MSK)) if (iwl_check_bits(status, TX_ABORT_REQUIRED_MSK))
@ -362,7 +362,7 @@ static void iwl3945_rx_reply_tx(struct iwl_priv *priv,
void iwl3945_hw_rx_statistics(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb) void iwl3945_hw_rx_statistics(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
{ {
struct iwl_rx_packet *pkt = (void *)rxb->skb->data; struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
IWL_DEBUG_RX("Statistics notification received (%d vs %d).\n", IWL_DEBUG_RX(priv, "Statistics notification received (%d vs %d).\n",
(int)sizeof(struct iwl3945_notif_statistics), (int)sizeof(struct iwl3945_notif_statistics),
le32_to_cpu(pkt->len)); le32_to_cpu(pkt->len));
@ -496,13 +496,13 @@ static void _iwl3945_dbg_report_frame(struct iwl_priv *priv,
* MAC addresses show just the last byte (for brevity), * MAC addresses show just the last byte (for brevity),
* but you can hack it to show more, if you'd like to. */ * but you can hack it to show more, if you'd like to. */
if (dataframe) if (dataframe)
IWL_DEBUG_RX("%s: mhd=0x%04x, dst=0x%02x, " IWL_DEBUG_RX(priv, "%s: mhd=0x%04x, dst=0x%02x, "
"len=%u, rssi=%d, chnl=%d, rate=%d, \n", "len=%u, rssi=%d, chnl=%d, rate=%d, \n",
title, le16_to_cpu(fc), header->addr1[5], title, le16_to_cpu(fc), header->addr1[5],
length, rssi, channel, rate); length, rssi, channel, rate);
else { else {
/* src/dst addresses assume managed mode */ /* src/dst addresses assume managed mode */
IWL_DEBUG_RX("%s: 0x%04x, dst=0x%02x, " IWL_DEBUG_RX(priv, "%s: 0x%04x, dst=0x%02x, "
"src=0x%02x, rssi=%u, tim=%lu usec, " "src=0x%02x, rssi=%u, tim=%lu usec, "
"phy=0x%02x, chnl=%d\n", "phy=0x%02x, chnl=%d\n",
title, le16_to_cpu(fc), header->addr1[5], title, le16_to_cpu(fc), header->addr1[5],
@ -563,14 +563,14 @@ static void iwl3945_pass_packet_to_mac80211(struct iwl_priv *priv,
/* We received data from the HW, so stop the watchdog */ /* We received data from the HW, so stop the watchdog */
if (unlikely((len + IWL39_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) { if (unlikely((len + IWL39_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
IWL_DEBUG_DROP("Corruption detected!\n"); IWL_DEBUG_DROP(priv, "Corruption detected!\n");
return; return;
} }
/* We only process data packets if the interface is open */ /* We only process data packets if the interface is open */
if (unlikely(!priv->is_open)) { if (unlikely(!priv->is_open)) {
IWL_DEBUG_DROP_LIMIT IWL_DEBUG_DROP_LIMIT(priv,
("Dropping packet while interface is not open.\n"); "Dropping packet while interface is not open.\n");
return; return;
} }
@ -579,7 +579,8 @@ static void iwl3945_pass_packet_to_mac80211(struct iwl_priv *priv,
skb_put(rxb->skb, le16_to_cpu(rx_hdr->len)); skb_put(rxb->skb, le16_to_cpu(rx_hdr->len));
if (!iwl3945_mod_params.sw_crypto) if (!iwl3945_mod_params.sw_crypto)
iwl3945_set_decrypted_flag(priv, rxb->skb, iwl_set_decrypted_flag(priv,
(struct ieee80211_hdr *)rxb->skb->data,
le32_to_cpu(rx_end->status), stats); le32_to_cpu(rx_end->status), stats);
#ifdef CONFIG_IWL3945_LEDS #ifdef CONFIG_IWL3945_LEDS
@ -625,15 +626,14 @@ static void iwl3945_rx_reply_rx(struct iwl_priv *priv,
rx_status.flag |= RX_FLAG_SHORTPRE; rx_status.flag |= RX_FLAG_SHORTPRE;
if ((unlikely(rx_stats->phy_count > 20))) { if ((unlikely(rx_stats->phy_count > 20))) {
IWL_DEBUG_DROP IWL_DEBUG_DROP(priv, "dsp size out of range [0,20]: %d/n",
("dsp size out of range [0,20]: " rx_stats->phy_count);
"%d/n", rx_stats->phy_count);
return; return;
} }
if (!(rx_end->status & RX_RES_STATUS_NO_CRC32_ERROR) if (!(rx_end->status & RX_RES_STATUS_NO_CRC32_ERROR)
|| !(rx_end->status & RX_RES_STATUS_NO_RXE_OVERFLOW)) { || !(rx_end->status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
IWL_DEBUG_RX("Bad CRC or FIFO: 0x%08X.\n", rx_end->status); IWL_DEBUG_RX(priv, "Bad CRC or FIFO: 0x%08X.\n", rx_end->status);
return; return;
} }
@ -672,7 +672,7 @@ static void iwl3945_rx_reply_rx(struct iwl_priv *priv,
} }
IWL_DEBUG_STATS("Rssi %d noise %d qual %d sig_avg %d noise_diff %d\n", IWL_DEBUG_STATS(priv, "Rssi %d noise %d qual %d sig_avg %d noise_diff %d\n",
rx_status.signal, rx_status.noise, rx_status.qual, rx_status.signal, rx_status.noise, rx_status.qual,
rx_stats_sig_avg, rx_stats_noise_diff); rx_stats_sig_avg, rx_stats_noise_diff);
@ -680,7 +680,7 @@ static void iwl3945_rx_reply_rx(struct iwl_priv *priv,
network_packet = iwl3945_is_network_packet(priv, header); network_packet = iwl3945_is_network_packet(priv, header);
IWL_DEBUG_STATS_LIMIT("[%c] %d RSSI:%d Signal:%u, Noise:%u, Rate:%u\n", IWL_DEBUG_STATS_LIMIT(priv, "[%c] %d RSSI:%d Signal:%u, Noise:%u, Rate:%u\n",
network_packet ? '*' : ' ', network_packet ? '*' : ' ',
le16_to_cpu(rx_hdr->channel), le16_to_cpu(rx_hdr->channel),
rx_status.signal, rx_status.signal, rx_status.signal, rx_status.signal,
@ -798,7 +798,7 @@ u8 iwl3945_hw_find_station(struct iwl_priv *priv, const u8 *addr)
goto out; goto out;
} }
IWL_DEBUG_INFO("can not find STA %pM (total %d)\n", IWL_DEBUG_INFO(priv, "can not find STA %pM (total %d)\n",
addr, priv->num_stations); addr, priv->num_stations);
out: out:
spin_unlock_irqrestore(&priv->sta_lock, flags); spin_unlock_irqrestore(&priv->sta_lock, flags);
@ -873,7 +873,7 @@ void iwl3945_hw_build_tx_cmd_rate(struct iwl_priv *priv, struct iwl_cmd *cmd,
/* CCK */ /* CCK */
tx->supp_rates[1] = (rate_mask & 0xF); tx->supp_rates[1] = (rate_mask & 0xF);
IWL_DEBUG_RATE("Tx sta id: %d, rate: %d (plcp), flags: 0x%4X " IWL_DEBUG_RATE(priv, "Tx sta id: %d, rate: %d (plcp), flags: 0x%4X "
"cck/ofdm mask: 0x%x/0x%x\n", sta_id, "cck/ofdm mask: 0x%x/0x%x\n", sta_id,
tx->rate, le32_to_cpu(tx->tx_flags), tx->rate, le32_to_cpu(tx->tx_flags),
tx->supp_rates[1], tx->supp_rates[0]); tx->supp_rates[1], tx->supp_rates[0]);
@ -898,7 +898,7 @@ u8 iwl3945_sync_sta(struct iwl_priv *priv, int sta_id, u16 tx_rate, u8 flags)
iwl_send_add_sta(priv, iwl_send_add_sta(priv,
(struct iwl_addsta_cmd *)&station->sta, flags); (struct iwl_addsta_cmd *)&station->sta, flags);
IWL_DEBUG_RATE("SCALE sync station %d to rate %d\n", IWL_DEBUG_RATE(priv, "SCALE sync station %d to rate %d\n",
sta_id, tx_rate); sta_id, tx_rate);
return sta_id; return sta_id;
} }
@ -1063,7 +1063,7 @@ static int iwl3945_apm_init(struct iwl_priv *priv)
{ {
int ret = 0; int ret = 0;
iwl3945_power_init_handle(priv); iwl_power_initialize(priv);
iwl_set_bit(priv, CSR_GIO_CHICKEN_BITS, iwl_set_bit(priv, CSR_GIO_CHICKEN_BITS,
CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER); CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
@ -1079,7 +1079,7 @@ static int iwl3945_apm_init(struct iwl_priv *priv)
iwl_poll_direct_bit(priv, CSR_GP_CNTRL, iwl_poll_direct_bit(priv, CSR_GP_CNTRL,
CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000); CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
if (ret < 0) { if (ret < 0) {
IWL_DEBUG_INFO("Failed to init the card\n"); IWL_DEBUG_INFO(priv, "Failed to init the card\n");
goto out; goto out;
} }
@ -1111,31 +1111,31 @@ static void iwl3945_nic_config(struct iwl_priv *priv)
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
if (rev_id & PCI_CFG_REV_ID_BIT_RTP) if (rev_id & PCI_CFG_REV_ID_BIT_RTP)
IWL_DEBUG_INFO("RTP type \n"); IWL_DEBUG_INFO(priv, "RTP type \n");
else if (rev_id & PCI_CFG_REV_ID_BIT_BASIC_SKU) { else if (rev_id & PCI_CFG_REV_ID_BIT_BASIC_SKU) {
IWL_DEBUG_INFO("3945 RADIO-MB type\n"); IWL_DEBUG_INFO(priv, "3945 RADIO-MB type\n");
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR39_HW_IF_CONFIG_REG_BIT_3945_MB); CSR39_HW_IF_CONFIG_REG_BIT_3945_MB);
} else { } else {
IWL_DEBUG_INFO("3945 RADIO-MM type\n"); IWL_DEBUG_INFO(priv, "3945 RADIO-MM type\n");
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR39_HW_IF_CONFIG_REG_BIT_3945_MM); CSR39_HW_IF_CONFIG_REG_BIT_3945_MM);
} }
if (EEPROM_SKU_CAP_OP_MODE_MRC == eeprom->sku_cap) { if (EEPROM_SKU_CAP_OP_MODE_MRC == eeprom->sku_cap) {
IWL_DEBUG_INFO("SKU OP mode is mrc\n"); IWL_DEBUG_INFO(priv, "SKU OP mode is mrc\n");
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR39_HW_IF_CONFIG_REG_BIT_SKU_MRC); CSR39_HW_IF_CONFIG_REG_BIT_SKU_MRC);
} else } else
IWL_DEBUG_INFO("SKU OP mode is basic\n"); IWL_DEBUG_INFO(priv, "SKU OP mode is basic\n");
if ((eeprom->board_revision & 0xF0) == 0xD0) { if ((eeprom->board_revision & 0xF0) == 0xD0) {
IWL_DEBUG_INFO("3945ABG revision is 0x%X\n", IWL_DEBUG_INFO(priv, "3945ABG revision is 0x%X\n",
eeprom->board_revision); eeprom->board_revision);
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE); CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
} else { } else {
IWL_DEBUG_INFO("3945ABG revision is 0x%X\n", IWL_DEBUG_INFO(priv, "3945ABG revision is 0x%X\n",
eeprom->board_revision); eeprom->board_revision);
iwl_clear_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_clear_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE); CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
@ -1144,10 +1144,10 @@ static void iwl3945_nic_config(struct iwl_priv *priv)
if (eeprom->almgor_m_version <= 1) { if (eeprom->almgor_m_version <= 1) {
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_A); CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_A);
IWL_DEBUG_INFO("Card M type A version is 0x%X\n", IWL_DEBUG_INFO(priv, "Card M type A version is 0x%X\n",
eeprom->almgor_m_version); eeprom->almgor_m_version);
} else { } else {
IWL_DEBUG_INFO("Card M type B version is 0x%X\n", IWL_DEBUG_INFO(priv, "Card M type B version is 0x%X\n",
eeprom->almgor_m_version); eeprom->almgor_m_version);
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_B); CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_B);
@ -1155,10 +1155,10 @@ static void iwl3945_nic_config(struct iwl_priv *priv)
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
if (eeprom->sku_cap & EEPROM_SKU_CAP_SW_RF_KILL_ENABLE) if (eeprom->sku_cap & EEPROM_SKU_CAP_SW_RF_KILL_ENABLE)
IWL_DEBUG_RF_KILL("SW RF KILL supported in EEPROM.\n"); IWL_DEBUG_RF_KILL(priv, "SW RF KILL supported in EEPROM.\n");
if (eeprom->sku_cap & EEPROM_SKU_CAP_HW_RF_KILL_ENABLE) if (eeprom->sku_cap & EEPROM_SKU_CAP_HW_RF_KILL_ENABLE)
IWL_DEBUG_RF_KILL("HW RF KILL supported in EEPROM.\n"); IWL_DEBUG_RF_KILL(priv, "HW RF KILL supported in EEPROM.\n");
} }
int iwl3945_hw_nic_init(struct iwl_priv *priv) int iwl3945_hw_nic_init(struct iwl_priv *priv)
@ -1176,7 +1176,7 @@ int iwl3945_hw_nic_init(struct iwl_priv *priv)
rc = pci_read_config_byte(priv->pci_dev, PCI_REVISION_ID, &rev_id); rc = pci_read_config_byte(priv->pci_dev, PCI_REVISION_ID, &rev_id);
if (rc) if (rc)
return rc; return rc;
IWL_DEBUG_INFO("HW Revision ID = 0x%X\n", rev_id); IWL_DEBUG_INFO(priv, "HW Revision ID = 0x%X\n", rev_id);
rc = priv->cfg->ops->lib->apm_ops.set_pwr_src(priv, IWL_PWR_SRC_VMAIN); rc = priv->cfg->ops->lib->apm_ops.set_pwr_src(priv, IWL_PWR_SRC_VMAIN);
if(rc) if(rc)
@ -1285,7 +1285,7 @@ static int iwl3945_apm_stop_master(struct iwl_priv *priv)
out: out:
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
IWL_DEBUG_INFO("stop master\n"); IWL_DEBUG_INFO(priv, "stop master\n");
return ret; return ret;
} }
@ -1390,7 +1390,7 @@ static int iwl3945_hw_reg_txpower_get_temperature(struct iwl_priv *priv)
/* driver's okay range is -260 to +25. /* driver's okay range is -260 to +25.
* human readable okay range is 0 to +285 */ * human readable okay range is 0 to +285 */
IWL_DEBUG_INFO("Temperature: %d\n", temperature + IWL_TEMP_CONVERT); IWL_DEBUG_INFO(priv, "Temperature: %d\n", temperature + IWL_TEMP_CONVERT);
/* handle insane temp reading */ /* handle insane temp reading */
if (iwl3945_hw_reg_temp_out_of_range(temperature)) { if (iwl3945_hw_reg_temp_out_of_range(temperature)) {
@ -1427,20 +1427,20 @@ static int is_temp_calib_needed(struct iwl_priv *priv)
/* get absolute value */ /* get absolute value */
if (temp_diff < 0) { if (temp_diff < 0) {
IWL_DEBUG_POWER("Getting cooler, delta %d,\n", temp_diff); IWL_DEBUG_POWER(priv, "Getting cooler, delta %d,\n", temp_diff);
temp_diff = -temp_diff; temp_diff = -temp_diff;
} else if (temp_diff == 0) } else if (temp_diff == 0)
IWL_DEBUG_POWER("Same temp,\n"); IWL_DEBUG_POWER(priv, "Same temp,\n");
else else
IWL_DEBUG_POWER("Getting warmer, delta %d,\n", temp_diff); IWL_DEBUG_POWER(priv, "Getting warmer, delta %d,\n", temp_diff);
/* if we don't need calibration, *don't* update last_temperature */ /* if we don't need calibration, *don't* update last_temperature */
if (temp_diff < IWL_TEMPERATURE_LIMIT_TIMER) { if (temp_diff < IWL_TEMPERATURE_LIMIT_TIMER) {
IWL_DEBUG_POWER("Timed thermal calib not needed\n"); IWL_DEBUG_POWER(priv, "Timed thermal calib not needed\n");
return 0; return 0;
} }
IWL_DEBUG_POWER("Timed thermal calib needed\n"); IWL_DEBUG_POWER(priv, "Timed thermal calib needed\n");
/* assume that caller will actually do calib ... /* assume that caller will actually do calib ...
* update the "last temperature" value */ * update the "last temperature" value */
@ -1689,27 +1689,27 @@ static void iwl3945_hw_reg_set_scan_power(struct iwl_priv *priv, u32 scan_tbl_in
* Configures power settings for all rates for the current channel, * Configures power settings for all rates for the current channel,
* using values from channel info struct, and send to NIC * using values from channel info struct, and send to NIC
*/ */
int iwl3945_send_tx_power(struct iwl_priv *priv) static int iwl3945_send_tx_power(struct iwl_priv *priv)
{ {
int rate_idx, i; int rate_idx, i;
const struct iwl_channel_info *ch_info = NULL; const struct iwl_channel_info *ch_info = NULL;
struct iwl3945_txpowertable_cmd txpower = { struct iwl3945_txpowertable_cmd txpower = {
.channel = priv->active39_rxon.channel, .channel = priv->active_rxon.channel,
}; };
txpower.band = (priv->band == IEEE80211_BAND_5GHZ) ? 0 : 1; txpower.band = (priv->band == IEEE80211_BAND_5GHZ) ? 0 : 1;
ch_info = iwl_get_channel_info(priv, ch_info = iwl_get_channel_info(priv,
priv->band, priv->band,
le16_to_cpu(priv->active39_rxon.channel)); le16_to_cpu(priv->active_rxon.channel));
if (!ch_info) { if (!ch_info) {
IWL_ERR(priv, IWL_ERR(priv,
"Failed to get channel info for channel %d [%d]\n", "Failed to get channel info for channel %d [%d]\n",
le16_to_cpu(priv->active39_rxon.channel), priv->band); le16_to_cpu(priv->active_rxon.channel), priv->band);
return -EINVAL; return -EINVAL;
} }
if (!is_channel_valid(ch_info)) { if (!is_channel_valid(ch_info)) {
IWL_DEBUG_POWER("Not calling TX_PWR_TABLE_CMD on " IWL_DEBUG_POWER(priv, "Not calling TX_PWR_TABLE_CMD on "
"non-Tx channel.\n"); "non-Tx channel.\n");
return 0; return 0;
} }
@ -1722,7 +1722,7 @@ int iwl3945_send_tx_power(struct iwl_priv *priv)
txpower.power[i].tpc = ch_info->power_info[i].tpc; txpower.power[i].tpc = ch_info->power_info[i].tpc;
txpower.power[i].rate = iwl3945_rates[rate_idx].plcp; txpower.power[i].rate = iwl3945_rates[rate_idx].plcp;
IWL_DEBUG_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n", IWL_DEBUG_POWER(priv, "ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
le16_to_cpu(txpower.channel), le16_to_cpu(txpower.channel),
txpower.band, txpower.band,
txpower.power[i].tpc.tx_gain, txpower.power[i].tpc.tx_gain,
@ -1735,7 +1735,7 @@ int iwl3945_send_tx_power(struct iwl_priv *priv)
txpower.power[i].tpc = ch_info->power_info[i].tpc; txpower.power[i].tpc = ch_info->power_info[i].tpc;
txpower.power[i].rate = iwl3945_rates[rate_idx].plcp; txpower.power[i].rate = iwl3945_rates[rate_idx].plcp;
IWL_DEBUG_POWER("ch %d:%d rf %d dsp %3d rate code 0x%02x\n", IWL_DEBUG_POWER(priv, "ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
le16_to_cpu(txpower.channel), le16_to_cpu(txpower.channel),
txpower.band, txpower.band,
txpower.power[i].tpc.tx_gain, txpower.power[i].tpc.tx_gain,
@ -1926,12 +1926,12 @@ int iwl3945_hw_reg_set_txpower(struct iwl_priv *priv, s8 power)
u8 i; u8 i;
if (priv->tx_power_user_lmt == power) { if (priv->tx_power_user_lmt == power) {
IWL_DEBUG_POWER("Requested Tx power same as current " IWL_DEBUG_POWER(priv, "Requested Tx power same as current "
"limit: %ddBm.\n", power); "limit: %ddBm.\n", power);
return 0; return 0;
} }
IWL_DEBUG_POWER("Setting upper limit clamp to %ddBm.\n", power); IWL_DEBUG_POWER(priv, "Setting upper limit clamp to %ddBm.\n", power);
priv->tx_power_user_lmt = power; priv->tx_power_user_lmt = power;
/* set up new Tx powers for each and every channel, 2.4 and 5.x */ /* set up new Tx powers for each and every channel, 2.4 and 5.x */
@ -2041,7 +2041,7 @@ static u16 iwl3945_hw_reg_get_ch_grp_index(struct iwl_priv *priv,
} else } else
group_index = 0; /* 2.4 GHz, group 0 */ group_index = 0; /* 2.4 GHz, group 0 */
IWL_DEBUG_POWER("Chnl %d mapped to grp %d\n", ch_info->channel, IWL_DEBUG_POWER(priv, "Chnl %d mapped to grp %d\n", ch_info->channel,
group_index); group_index);
return group_index; return group_index;
} }
@ -2108,7 +2108,7 @@ static void iwl3945_hw_reg_init_channel_groups(struct iwl_priv *priv)
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom; struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
const struct iwl3945_eeprom_txpower_group *group; const struct iwl3945_eeprom_txpower_group *group;
IWL_DEBUG_POWER("Initializing factory calib info from EEPROM\n"); IWL_DEBUG_POWER(priv, "Initializing factory calib info from EEPROM\n");
for (i = 0; i < IWL_NUM_TX_CALIB_GROUPS; i++) { for (i = 0; i < IWL_NUM_TX_CALIB_GROUPS; i++) {
s8 *clip_pwrs; /* table of power levels for each rate */ s8 *clip_pwrs; /* table of power levels for each rate */
@ -2224,7 +2224,7 @@ int iwl3945_txpower_set_from_eeprom(struct iwl_priv *priv)
eeprom->groups[ch_info->group_index]. eeprom->groups[ch_info->group_index].
temperature); temperature);
IWL_DEBUG_POWER("Delta index for channel %d: %d [%d]\n", IWL_DEBUG_POWER(priv, "Delta index for channel %d: %d [%d]\n",
ch_info->channel, delta_index, temperature + ch_info->channel, delta_index, temperature +
IWL_TEMP_CONVERT); IWL_TEMP_CONVERT);
@ -2372,7 +2372,9 @@ static u16 iwl3945_get_hcmd_size(u8 cmd_id, u16 len)
{ {
switch (cmd_id) { switch (cmd_id) {
case REPLY_RXON: case REPLY_RXON:
return (u16) sizeof(struct iwl3945_rxon_cmd); return sizeof(struct iwl3945_rxon_cmd);
case POWER_TABLE_CMD:
return sizeof(struct iwl3945_powertable_cmd);
default: default:
return len; return len;
} }
@ -2409,7 +2411,7 @@ int iwl3945_init_hw_rate_table(struct iwl_priv *priv)
switch (priv->band) { switch (priv->band) {
case IEEE80211_BAND_5GHZ: case IEEE80211_BAND_5GHZ:
IWL_DEBUG_RATE("Select A mode rate scale\n"); IWL_DEBUG_RATE(priv, "Select A mode rate scale\n");
/* If one of the following CCK rates is used, /* If one of the following CCK rates is used,
* have it fall back to the 6M OFDM rate */ * have it fall back to the 6M OFDM rate */
for (i = IWL_RATE_1M_INDEX_TABLE; for (i = IWL_RATE_1M_INDEX_TABLE;
@ -2427,12 +2429,12 @@ int iwl3945_init_hw_rate_table(struct iwl_priv *priv)
break; break;
case IEEE80211_BAND_2GHZ: case IEEE80211_BAND_2GHZ:
IWL_DEBUG_RATE("Select B/G mode rate scale\n"); IWL_DEBUG_RATE(priv, "Select B/G mode rate scale\n");
/* If an OFDM rate is used, have it fall back to the /* If an OFDM rate is used, have it fall back to the
* 1M CCK rates */ * 1M CCK rates */
if (!(priv->sta_supp_rates & IWL_OFDM_RATES_MASK) && if (!(priv->sta_supp_rates & IWL_OFDM_RATES_MASK) &&
iwl3945_is_associated(priv)) { iwl_is_associated(priv)) {
index = IWL_FIRST_CCK_RATE; index = IWL_FIRST_CCK_RATE;
for (i = IWL_RATE_6M_INDEX_TABLE; for (i = IWL_RATE_6M_INDEX_TABLE;
@ -2552,7 +2554,7 @@ static int iwl3945_verify_bsm(struct iwl_priv *priv)
u32 reg; u32 reg;
u32 val; u32 val;
IWL_DEBUG_INFO("Begin verify bsm\n"); IWL_DEBUG_INFO(priv, "Begin verify bsm\n");
/* verify BSM SRAM contents */ /* verify BSM SRAM contents */
val = iwl_read_prph(priv, BSM_WR_DWCOUNT_REG); val = iwl_read_prph(priv, BSM_WR_DWCOUNT_REG);
@ -2570,7 +2572,7 @@ static int iwl3945_verify_bsm(struct iwl_priv *priv)
} }
} }
IWL_DEBUG_INFO("BSM bootstrap uCode image OK\n"); IWL_DEBUG_INFO(priv, "BSM bootstrap uCode image OK\n");
return 0; return 0;
} }
@ -2647,7 +2649,7 @@ static int iwl3945_load_bsm(struct iwl_priv *priv)
u32 done; u32 done;
u32 reg_offset; u32 reg_offset;
IWL_DEBUG_INFO("Begin load bsm\n"); IWL_DEBUG_INFO(priv, "Begin load bsm\n");
/* make sure bootstrap program is no larger than BSM's SRAM size */ /* make sure bootstrap program is no larger than BSM's SRAM size */
if (len > IWL39_MAX_BSM_SIZE) if (len > IWL39_MAX_BSM_SIZE)
@ -2704,7 +2706,7 @@ static int iwl3945_load_bsm(struct iwl_priv *priv)
udelay(10); udelay(10);
} }
if (i < 100) if (i < 100)
IWL_DEBUG_INFO("BSM write complete, poll %d iterations\n", i); IWL_DEBUG_INFO(priv, "BSM write complete, poll %d iterations\n", i);
else { else {
IWL_ERR(priv, "BSM write did not complete!\n"); IWL_ERR(priv, "BSM write did not complete!\n");
return -EIO; return -EIO;

8
drivers/net/wireless/iwlwifi/iwl-3945.h
View File

@ -222,9 +222,6 @@ extern int __must_check iwl3945_send_cmd(struct iwl_priv *priv,
struct iwl_host_cmd *cmd); struct iwl_host_cmd *cmd);
extern unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv, extern unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
struct ieee80211_hdr *hdr,int left); struct ieee80211_hdr *hdr,int left);
extern void iwl3945_set_decrypted_flag(struct iwl_priv *priv, struct sk_buff *skb,
u32 decrypt_res,
struct ieee80211_rx_status *stats);
/* /*
* Currently used by iwl-3945-rs... look at restructuring so that it doesn't * Currently used by iwl-3945-rs... look at restructuring so that it doesn't
@ -303,11 +300,6 @@ extern int iwl3945_txpower_set_from_eeprom(struct iwl_priv *priv);
extern u8 iwl3945_sync_sta(struct iwl_priv *priv, int sta_id, extern u8 iwl3945_sync_sta(struct iwl_priv *priv, int sta_id,
u16 tx_rate, u8 flags); u16 tx_rate, u8 flags);
static inline int iwl3945_is_associated(struct iwl_priv *priv)
{
return (priv->active39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) ? 1 : 0;
}
extern const struct iwl_channel_info *iwl3945_get_channel_info( extern const struct iwl_channel_info *iwl3945_get_channel_info(
const struct iwl_priv *priv, enum ieee80211_band band, u16 channel); const struct iwl_priv *priv, enum ieee80211_band band, u16 channel);

130
drivers/net/wireless/iwlwifi/iwl-4965.c
View File

@ -76,7 +76,7 @@ static int iwl4965_verify_bsm(struct iwl_priv *priv)
u32 reg; u32 reg;
u32 val; u32 val;
IWL_DEBUG_INFO("Begin verify bsm\n"); IWL_DEBUG_INFO(priv, "Begin verify bsm\n");
/* verify BSM SRAM contents */ /* verify BSM SRAM contents */
val = iwl_read_prph(priv, BSM_WR_DWCOUNT_REG); val = iwl_read_prph(priv, BSM_WR_DWCOUNT_REG);
@ -94,7 +94,7 @@ static int iwl4965_verify_bsm(struct iwl_priv *priv)
} }
} }
IWL_DEBUG_INFO("BSM bootstrap uCode image OK\n"); IWL_DEBUG_INFO(priv, "BSM bootstrap uCode image OK\n");
return 0; return 0;
} }
@ -144,7 +144,7 @@ static int iwl4965_load_bsm(struct iwl_priv *priv)
u32 reg_offset; u32 reg_offset;
int ret; int ret;
IWL_DEBUG_INFO("Begin load bsm\n"); IWL_DEBUG_INFO(priv, "Begin load bsm\n");
priv->ucode_type = UCODE_RT; priv->ucode_type = UCODE_RT;
@ -201,7 +201,7 @@ static int iwl4965_load_bsm(struct iwl_priv *priv)
udelay(10); udelay(10);
} }
if (i < 100) if (i < 100)
IWL_DEBUG_INFO("BSM write complete, poll %d iterations\n", i); IWL_DEBUG_INFO(priv, "BSM write complete, poll %d iterations\n", i);
else { else {
IWL_ERR(priv, "BSM write did not complete!\n"); IWL_ERR(priv, "BSM write did not complete!\n");
return -EIO; return -EIO;
@ -257,7 +257,7 @@ static int iwl4965_set_ucode_ptrs(struct iwl_priv *priv)
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
IWL_DEBUG_INFO("Runtime uCode pointers are set.\n"); IWL_DEBUG_INFO(priv, "Runtime uCode pointers are set.\n");
return ret; return ret;
} }
@ -279,7 +279,7 @@ static void iwl4965_init_alive_start(struct iwl_priv *priv)
if (priv->card_alive_init.is_valid != UCODE_VALID_OK) { if (priv->card_alive_init.is_valid != UCODE_VALID_OK) {
/* We had an error bringing up the hardware, so take it /* We had an error bringing up the hardware, so take it
* all the way back down so we can try again */ * all the way back down so we can try again */
IWL_DEBUG_INFO("Initialize Alive failed.\n"); IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
goto restart; goto restart;
} }
@ -289,7 +289,7 @@ static void iwl4965_init_alive_start(struct iwl_priv *priv)
if (iwl_verify_ucode(priv)) { if (iwl_verify_ucode(priv)) {
/* Runtime instruction load was bad; /* Runtime instruction load was bad;
* take it all the way back down so we can try again */ * take it all the way back down so we can try again */
IWL_DEBUG_INFO("Bad \"initialize\" uCode load.\n"); IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
goto restart; goto restart;
} }
@ -299,11 +299,11 @@ static void iwl4965_init_alive_start(struct iwl_priv *priv)
/* Send pointers to protocol/runtime uCode image ... init code will /* Send pointers to protocol/runtime uCode image ... init code will
* load and launch runtime uCode, which will send us another "Alive" * load and launch runtime uCode, which will send us another "Alive"
* notification. */ * notification. */
IWL_DEBUG_INFO("Initialization Alive received.\n"); IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
if (iwl4965_set_ucode_ptrs(priv)) { if (iwl4965_set_ucode_ptrs(priv)) {
/* Runtime instruction load won't happen; /* Runtime instruction load won't happen;
* take it all the way back down so we can try again */ * take it all the way back down so we can try again */
IWL_DEBUG_INFO("Couldn't set up uCode pointers.\n"); IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
goto restart; goto restart;
} }
return; return;
@ -354,7 +354,7 @@ static int iwl4965_apm_init(struct iwl_priv *priv)
ret = iwl_poll_direct_bit(priv, CSR_GP_CNTRL, ret = iwl_poll_direct_bit(priv, CSR_GP_CNTRL,
CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000); CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
if (ret < 0) { if (ret < 0) {
IWL_DEBUG_INFO("Failed to init the card\n"); IWL_DEBUG_INFO(priv, "Failed to init the card\n");
goto out; goto out;
} }
@ -437,7 +437,7 @@ static int iwl4965_apm_stop_master(struct iwl_priv *priv)
CSR_RESET_REG_FLAG_MASTER_DISABLED, 100); CSR_RESET_REG_FLAG_MASTER_DISABLED, 100);
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
IWL_DEBUG_INFO("stop master\n"); IWL_DEBUG_INFO(priv, "stop master\n");
return 0; return 0;
} }
@ -526,7 +526,7 @@ static void iwl4965_chain_noise_reset(struct iwl_priv *priv)
IWL_ERR(priv, IWL_ERR(priv,
"Could not send REPLY_PHY_CALIBRATION_CMD\n"); "Could not send REPLY_PHY_CALIBRATION_CMD\n");
data->state = IWL_CHAIN_NOISE_ACCUMULATE; data->state = IWL_CHAIN_NOISE_ACCUMULATE;
IWL_DEBUG_CALIB("Run chain_noise_calibrate\n"); IWL_DEBUG_CALIB(priv, "Run chain_noise_calibrate\n");
} }
} }
@ -558,7 +558,7 @@ static void iwl4965_gain_computation(struct iwl_priv *priv,
data->delta_gain_code[i] = 0; data->delta_gain_code[i] = 0;
} }
} }
IWL_DEBUG_CALIB("delta_gain_codes: a %d b %d c %d\n", IWL_DEBUG_CALIB(priv, "delta_gain_codes: a %d b %d c %d\n",
data->delta_gain_code[0], data->delta_gain_code[0],
data->delta_gain_code[1], data->delta_gain_code[1],
data->delta_gain_code[2]); data->delta_gain_code[2]);
@ -576,7 +576,7 @@ static void iwl4965_gain_computation(struct iwl_priv *priv,
ret = iwl_send_cmd_pdu(priv, REPLY_PHY_CALIBRATION_CMD, ret = iwl_send_cmd_pdu(priv, REPLY_PHY_CALIBRATION_CMD,
sizeof(cmd), &cmd); sizeof(cmd), &cmd);
if (ret) if (ret)
IWL_DEBUG_CALIB("fail sending cmd " IWL_DEBUG_CALIB(priv, "fail sending cmd "
"REPLY_PHY_CALIBRATION_CMD \n"); "REPLY_PHY_CALIBRATION_CMD \n");
/* TODO we might want recalculate /* TODO we might want recalculate
@ -669,7 +669,7 @@ static void iwl4965_tx_queue_set_status(struct iwl_priv *priv,
txq->sched_retry = scd_retry; txq->sched_retry = scd_retry;
IWL_DEBUG_INFO("%s %s Queue %d on AC %d\n", IWL_DEBUG_INFO(priv, "%s %s Queue %d on AC %d\n",
active ? "Activate" : "Deactivate", active ? "Activate" : "Deactivate",
scd_retry ? "BA" : "AC", txq_id, tx_fifo_id); scd_retry ? "BA" : "AC", txq_id, tx_fifo_id);
} }
@ -968,7 +968,7 @@ static int iwl4965_interpolate_chan(struct iwl_priv *priv, u32 channel,
ch_i2 = priv->calib_info->band_info[s].ch2.ch_num; ch_i2 = priv->calib_info->band_info[s].ch2.ch_num;
chan_info->ch_num = (u8) channel; chan_info->ch_num = (u8) channel;
IWL_DEBUG_TXPOWER("channel %d subband %d factory cal ch %d & %d\n", IWL_DEBUG_TXPOWER(priv, "channel %d subband %d factory cal ch %d & %d\n",
channel, s, ch_i1, ch_i2); channel, s, ch_i1, ch_i2);
for (c = 0; c < EEPROM_TX_POWER_TX_CHAINS; c++) { for (c = 0; c < EEPROM_TX_POWER_TX_CHAINS; c++) {
@ -998,19 +998,19 @@ static int iwl4965_interpolate_chan(struct iwl_priv *priv, u32 channel,
m1->pa_det, ch_i2, m1->pa_det, ch_i2,
m2->pa_det); m2->pa_det);
IWL_DEBUG_TXPOWER IWL_DEBUG_TXPOWER(priv,
("chain %d meas %d AP1=%d AP2=%d AP=%d\n", c, m, "chain %d meas %d AP1=%d AP2=%d AP=%d\n", c, m,
m1->actual_pow, m2->actual_pow, omeas->actual_pow); m1->actual_pow, m2->actual_pow, omeas->actual_pow);
IWL_DEBUG_TXPOWER IWL_DEBUG_TXPOWER(priv,
("chain %d meas %d NI1=%d NI2=%d NI=%d\n", c, m, "chain %d meas %d NI1=%d NI2=%d NI=%d\n", c, m,
m1->gain_idx, m2->gain_idx, omeas->gain_idx); m1->gain_idx, m2->gain_idx, omeas->gain_idx);
IWL_DEBUG_TXPOWER IWL_DEBUG_TXPOWER(priv,
("chain %d meas %d PA1=%d PA2=%d PA=%d\n", c, m, "chain %d meas %d PA1=%d PA2=%d PA=%d\n", c, m,
m1->pa_det, m2->pa_det, omeas->pa_det); m1->pa_det, m2->pa_det, omeas->pa_det);
IWL_DEBUG_TXPOWER IWL_DEBUG_TXPOWER(priv,
("chain %d meas %d T1=%d T2=%d T=%d\n", c, m, "chain %d meas %d T1=%d T2=%d T=%d\n", c, m,
m1->temperature, m2->temperature, m1->temperature, m2->temperature,
omeas->temperature); omeas->temperature);
} }
} }
@ -1312,7 +1312,7 @@ static int iwl4965_fill_txpower_tbl(struct iwl_priv *priv, u8 band, u16 channel,
user_target_power = 2 * priv->tx_power_user_lmt; user_target_power = 2 * priv->tx_power_user_lmt;
/* Get current (RXON) channel, band, width */ /* Get current (RXON) channel, band, width */
IWL_DEBUG_TXPOWER("chan %d band %d is_fat %d\n", channel, band, IWL_DEBUG_TXPOWER(priv, "chan %d band %d is_fat %d\n", channel, band,
is_fat); is_fat);
ch_info = iwl_get_channel_info(priv, priv->band, channel); ch_info = iwl_get_channel_info(priv, priv->band, channel);
@ -1329,7 +1329,7 @@ static int iwl4965_fill_txpower_tbl(struct iwl_priv *priv, u8 band, u16 channel,
return -EINVAL; return -EINVAL;
} }
IWL_DEBUG_TXPOWER("channel %d belongs to txatten group %d\n", IWL_DEBUG_TXPOWER(priv, "channel %d belongs to txatten group %d\n",
channel, txatten_grp); channel, txatten_grp);
if (is_fat) { if (is_fat) {
@ -1379,7 +1379,7 @@ static int iwl4965_fill_txpower_tbl(struct iwl_priv *priv, u8 band, u16 channel,
voltage_compensation = voltage_compensation =
iwl4965_get_voltage_compensation(voltage, init_voltage); iwl4965_get_voltage_compensation(voltage, init_voltage);
IWL_DEBUG_TXPOWER("curr volt %d eeprom volt %d volt comp %d\n", IWL_DEBUG_TXPOWER(priv, "curr volt %d eeprom volt %d volt comp %d\n",
init_voltage, init_voltage,
voltage, voltage_compensation); voltage, voltage_compensation);
@ -1410,13 +1410,13 @@ static int iwl4965_fill_txpower_tbl(struct iwl_priv *priv, u8 band, u16 channel,
factory_gain_index[c] = measurement->gain_idx; factory_gain_index[c] = measurement->gain_idx;
factory_actual_pwr[c] = measurement->actual_pow; factory_actual_pwr[c] = measurement->actual_pow;
IWL_DEBUG_TXPOWER("chain = %d\n", c); IWL_DEBUG_TXPOWER(priv, "chain = %d\n", c);
IWL_DEBUG_TXPOWER("fctry tmp %d, " IWL_DEBUG_TXPOWER(priv, "fctry tmp %d, "
"curr tmp %d, comp %d steps\n", "curr tmp %d, comp %d steps\n",
factory_temp, current_temp, factory_temp, current_temp,
temperature_comp[c]); temperature_comp[c]);
IWL_DEBUG_TXPOWER("fctry idx %d, fctry pwr %d\n", IWL_DEBUG_TXPOWER(priv, "fctry idx %d, fctry pwr %d\n",
factory_gain_index[c], factory_gain_index[c],
factory_actual_pwr[c]); factory_actual_pwr[c]);
} }
@ -1449,7 +1449,7 @@ static int iwl4965_fill_txpower_tbl(struct iwl_priv *priv, u8 band, u16 channel,
if (target_power > power_limit) if (target_power > power_limit)
target_power = power_limit; target_power = power_limit;
IWL_DEBUG_TXPOWER("rate %d sat %d reg %d usr %d tgt %d\n", IWL_DEBUG_TXPOWER(priv, "rate %d sat %d reg %d usr %d tgt %d\n",
i, saturation_power - back_off_table[i], i, saturation_power - back_off_table[i],
current_regulatory, user_target_power, current_regulatory, user_target_power,
target_power); target_power);
@ -1473,7 +1473,7 @@ static int iwl4965_fill_txpower_tbl(struct iwl_priv *priv, u8 band, u16 channel,
voltage_compensation + voltage_compensation +
atten_value); atten_value);
/* IWL_DEBUG_TXPOWER("calculated txpower index %d\n", /* IWL_DEBUG_TXPOWER(priv, "calculated txpower index %d\n",
power_index); */ power_index); */
if (power_index < get_min_power_index(i, band)) if (power_index < get_min_power_index(i, band))
@ -1506,7 +1506,7 @@ static int iwl4965_fill_txpower_tbl(struct iwl_priv *priv, u8 band, u16 channel,
tx_power.s.dsp_predis_atten[c] = tx_power.s.dsp_predis_atten[c] =
gain_table[band][power_index].dsp; gain_table[band][power_index].dsp;
IWL_DEBUG_TXPOWER("chain %d mimo %d index %d " IWL_DEBUG_TXPOWER(priv, "chain %d mimo %d index %d "
"gain 0x%02x dsp %d\n", "gain 0x%02x dsp %d\n",
c, atten_value, power_index, c, atten_value, power_index,
tx_power.s.radio_tx_gain[c], tx_power.s.radio_tx_gain[c],
@ -1581,7 +1581,7 @@ static int iwl4965_send_rxon_assoc(struct iwl_priv *priv)
rxon2->ofdm_ht_dual_stream_basic_rates) && rxon2->ofdm_ht_dual_stream_basic_rates) &&
(rxon1->rx_chain == rxon2->rx_chain) && (rxon1->rx_chain == rxon2->rx_chain) &&
(rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) { (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
IWL_DEBUG_INFO("Using current RXON_ASSOC. Not resending.\n"); IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC. Not resending.\n");
return 0; return 0;
} }
@ -1638,7 +1638,7 @@ static int iwl4965_hw_channel_switch(struct iwl_priv *priv, u16 channel)
rc = iwl4965_fill_txpower_tbl(priv, band, channel, is_fat, rc = iwl4965_fill_txpower_tbl(priv, band, channel, is_fat,
ctrl_chan_high, &cmd.tx_power); ctrl_chan_high, &cmd.tx_power);
if (rc) { if (rc) {
IWL_DEBUG_11H("error:%d fill txpower_tbl\n", rc); IWL_DEBUG_11H(priv, "error:%d fill txpower_tbl\n", rc);
return rc; return rc;
} }
@ -1703,13 +1703,13 @@ static int iwl4965_hw_get_temperature(const struct iwl_priv *priv)
if (test_bit(STATUS_TEMPERATURE, &priv->status) && if (test_bit(STATUS_TEMPERATURE, &priv->status) &&
(priv->statistics.flag & STATISTICS_REPLY_FLG_FAT_MODE_MSK)) { (priv->statistics.flag & STATISTICS_REPLY_FLG_FAT_MODE_MSK)) {
IWL_DEBUG_TEMP("Running FAT temperature calibration\n"); IWL_DEBUG_TEMP(priv, "Running FAT temperature calibration\n");
R1 = (s32)le32_to_cpu(priv->card_alive_init.therm_r1[1]); R1 = (s32)le32_to_cpu(priv->card_alive_init.therm_r1[1]);
R2 = (s32)le32_to_cpu(priv->card_alive_init.therm_r2[1]); R2 = (s32)le32_to_cpu(priv->card_alive_init.therm_r2[1]);
R3 = (s32)le32_to_cpu(priv->card_alive_init.therm_r3[1]); R3 = (s32)le32_to_cpu(priv->card_alive_init.therm_r3[1]);
R4 = le32_to_cpu(priv->card_alive_init.therm_r4[1]); R4 = le32_to_cpu(priv->card_alive_init.therm_r4[1]);
} else { } else {
IWL_DEBUG_TEMP("Running temperature calibration\n"); IWL_DEBUG_TEMP(priv, "Running temperature calibration\n");
R1 = (s32)le32_to_cpu(priv->card_alive_init.therm_r1[0]); R1 = (s32)le32_to_cpu(priv->card_alive_init.therm_r1[0]);
R2 = (s32)le32_to_cpu(priv->card_alive_init.therm_r2[0]); R2 = (s32)le32_to_cpu(priv->card_alive_init.therm_r2[0]);
R3 = (s32)le32_to_cpu(priv->card_alive_init.therm_r3[0]); R3 = (s32)le32_to_cpu(priv->card_alive_init.therm_r3[0]);
@ -1729,7 +1729,7 @@ static int iwl4965_hw_get_temperature(const struct iwl_priv *priv)
vt = sign_extend( vt = sign_extend(
le32_to_cpu(priv->statistics.general.temperature), 23); le32_to_cpu(priv->statistics.general.temperature), 23);
IWL_DEBUG_TEMP("Calib values R[1-3]: %d %d %d R4: %d\n", R1, R2, R3, vt); IWL_DEBUG_TEMP(priv, "Calib values R[1-3]: %d %d %d R4: %d\n", R1, R2, R3, vt);
if (R3 == R1) { if (R3 == R1) {
IWL_ERR(priv, "Calibration conflict R1 == R3\n"); IWL_ERR(priv, "Calibration conflict R1 == R3\n");
@ -1742,7 +1742,7 @@ static int iwl4965_hw_get_temperature(const struct iwl_priv *priv)
temperature /= (R3 - R1); temperature /= (R3 - R1);
temperature = (temperature * 97) / 100 + TEMPERATURE_CALIB_KELVIN_OFFSET; temperature = (temperature * 97) / 100 + TEMPERATURE_CALIB_KELVIN_OFFSET;
IWL_DEBUG_TEMP("Calibrated temperature: %dK, %dC\n", IWL_DEBUG_TEMP(priv, "Calibrated temperature: %dK, %dC\n",
temperature, KELVIN_TO_CELSIUS(temperature)); temperature, KELVIN_TO_CELSIUS(temperature));
return temperature; return temperature;
@ -1765,7 +1765,7 @@ static int iwl4965_is_temp_calib_needed(struct iwl_priv *priv)
int temp_diff; int temp_diff;
if (!test_bit(STATUS_STATISTICS, &priv->status)) { if (!test_bit(STATUS_STATISTICS, &priv->status)) {
IWL_DEBUG_TEMP("Temperature not updated -- no statistics.\n"); IWL_DEBUG_TEMP(priv, "Temperature not updated -- no statistics.\n");
return 0; return 0;
} }
@ -1773,19 +1773,19 @@ static int iwl4965_is_temp_calib_needed(struct iwl_priv *priv)
/* get absolute value */ /* get absolute value */
if (temp_diff < 0) { if (temp_diff < 0) {
IWL_DEBUG_POWER("Getting cooler, delta %d, \n", temp_diff); IWL_DEBUG_POWER(priv, "Getting cooler, delta %d, \n", temp_diff);
temp_diff = -temp_diff; temp_diff = -temp_diff;
} else if (temp_diff == 0) } else if (temp_diff == 0)
IWL_DEBUG_POWER("Same temp, \n"); IWL_DEBUG_POWER(priv, "Same temp, \n");
else else
IWL_DEBUG_POWER("Getting warmer, delta %d, \n", temp_diff); IWL_DEBUG_POWER(priv, "Getting warmer, delta %d, \n", temp_diff);
if (temp_diff < IWL_TEMPERATURE_THRESHOLD) { if (temp_diff < IWL_TEMPERATURE_THRESHOLD) {
IWL_DEBUG_POWER("Thermal txpower calib not needed\n"); IWL_DEBUG_POWER(priv, "Thermal txpower calib not needed\n");
return 0; return 0;
} }
IWL_DEBUG_POWER("Thermal txpower calib needed\n"); IWL_DEBUG_POWER(priv, "Thermal txpower calib needed\n");
return 1; return 1;
} }
@ -1800,12 +1800,12 @@ static void iwl4965_temperature_calib(struct iwl_priv *priv)
if (priv->temperature != temp) { if (priv->temperature != temp) {
if (priv->temperature) if (priv->temperature)
IWL_DEBUG_TEMP("Temperature changed " IWL_DEBUG_TEMP(priv, "Temperature changed "
"from %dC to %dC\n", "from %dC to %dC\n",
KELVIN_TO_CELSIUS(priv->temperature), KELVIN_TO_CELSIUS(priv->temperature),
KELVIN_TO_CELSIUS(temp)); KELVIN_TO_CELSIUS(temp));
else else
IWL_DEBUG_TEMP("Temperature " IWL_DEBUG_TEMP(priv, "Temperature "
"initialized to %dC\n", "initialized to %dC\n",
KELVIN_TO_CELSIUS(temp)); KELVIN_TO_CELSIUS(temp));
} }
@ -1995,8 +1995,8 @@ static u16 iwl4965_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data)
addsta->add_immediate_ba_tid = cmd->add_immediate_ba_tid; addsta->add_immediate_ba_tid = cmd->add_immediate_ba_tid;
addsta->remove_immediate_ba_tid = cmd->remove_immediate_ba_tid; addsta->remove_immediate_ba_tid = cmd->remove_immediate_ba_tid;
addsta->add_immediate_ba_ssn = cmd->add_immediate_ba_ssn; addsta->add_immediate_ba_ssn = cmd->add_immediate_ba_ssn;
addsta->reserved1 = __constant_cpu_to_le16(0); addsta->reserved1 = cpu_to_le16(0);
addsta->reserved2 = __constant_cpu_to_le32(0); addsta->reserved2 = cpu_to_le32(0);
return (u16)sizeof(struct iwl4965_addsta_cmd); return (u16)sizeof(struct iwl4965_addsta_cmd);
} }
@ -2022,7 +2022,7 @@ static int iwl4965_tx_status_reply_tx(struct iwl_priv *priv,
int i, sh, idx; int i, sh, idx;
u16 seq; u16 seq;
if (agg->wait_for_ba) if (agg->wait_for_ba)
IWL_DEBUG_TX_REPLY("got tx response w/o block-ack\n"); IWL_DEBUG_TX_REPLY(priv, "got tx response w/o block-ack\n");
agg->frame_count = tx_resp->frame_count; agg->frame_count = tx_resp->frame_count;
agg->start_idx = start_idx; agg->start_idx = start_idx;
@ -2036,7 +2036,7 @@ static int iwl4965_tx_status_reply_tx(struct iwl_priv *priv,
idx = start_idx; idx = start_idx;
/* FIXME: code repetition */ /* FIXME: code repetition */
IWL_DEBUG_TX_REPLY("FrameCnt = %d, StartIdx=%d idx=%d\n", IWL_DEBUG_TX_REPLY(priv, "FrameCnt = %d, StartIdx=%d idx=%d\n",
agg->frame_count, agg->start_idx, idx); agg->frame_count, agg->start_idx, idx);
info = IEEE80211_SKB_CB(priv->txq[txq_id].txb[idx].skb[0]); info = IEEE80211_SKB_CB(priv->txq[txq_id].txb[idx].skb[0]);
@ -2047,9 +2047,9 @@ static int iwl4965_tx_status_reply_tx(struct iwl_priv *priv,
iwl_hwrate_to_tx_control(priv, rate_n_flags, info); iwl_hwrate_to_tx_control(priv, rate_n_flags, info);
/* FIXME: code repetition end */ /* FIXME: code repetition end */
IWL_DEBUG_TX_REPLY("1 Frame 0x%x failure :%d\n", IWL_DEBUG_TX_REPLY(priv, "1 Frame 0x%x failure :%d\n",
status & 0xff, tx_resp->failure_frame); status & 0xff, tx_resp->failure_frame);
IWL_DEBUG_TX_REPLY("Rate Info rate_n_flags=%x\n", rate_n_flags); IWL_DEBUG_TX_REPLY(priv, "Rate Info rate_n_flags=%x\n", rate_n_flags);
agg->wait_for_ba = 0; agg->wait_for_ba = 0;
} else { } else {
@ -2069,7 +2069,7 @@ static int iwl4965_tx_status_reply_tx(struct iwl_priv *priv,
AGG_TX_STATE_ABORT_MSK)) AGG_TX_STATE_ABORT_MSK))
continue; continue;
IWL_DEBUG_TX_REPLY("FrameCnt = %d, txq_id=%d idx=%d\n", IWL_DEBUG_TX_REPLY(priv, "FrameCnt = %d, txq_id=%d idx=%d\n",
agg->frame_count, txq_id, idx); agg->frame_count, txq_id, idx);
hdr = iwl_tx_queue_get_hdr(priv, txq_id, idx); hdr = iwl_tx_queue_get_hdr(priv, txq_id, idx);
@ -2083,7 +2083,7 @@ static int iwl4965_tx_status_reply_tx(struct iwl_priv *priv,
return -1; return -1;
} }
IWL_DEBUG_TX_REPLY("AGG Frame i=%d idx %d seq=%d\n", IWL_DEBUG_TX_REPLY(priv, "AGG Frame i=%d idx %d seq=%d\n",
i, idx, SEQ_TO_SN(sc)); i, idx, SEQ_TO_SN(sc));
sh = idx - start; sh = idx - start;
@ -2101,13 +2101,13 @@ static int iwl4965_tx_status_reply_tx(struct iwl_priv *priv,
sh = 0; sh = 0;
} }
bitmap |= 1ULL << sh; bitmap |= 1ULL << sh;
IWL_DEBUG_TX_REPLY("start=%d bitmap=0x%llx\n", IWL_DEBUG_TX_REPLY(priv, "start=%d bitmap=0x%llx\n",
start, (unsigned long long)bitmap); start, (unsigned long long)bitmap);
} }
agg->bitmap = bitmap; agg->bitmap = bitmap;
agg->start_idx = start; agg->start_idx = start;
IWL_DEBUG_TX_REPLY("Frames %d start_idx=%d bitmap=0x%llx\n", IWL_DEBUG_TX_REPLY(priv, "Frames %d start_idx=%d bitmap=0x%llx\n",
agg->frame_count, agg->start_idx, agg->frame_count, agg->start_idx,
(unsigned long long)agg->bitmap); (unsigned long long)agg->bitmap);
@ -2176,7 +2176,7 @@ static void iwl4965_rx_reply_tx(struct iwl_priv *priv,
if (txq->q.read_ptr != (scd_ssn & 0xff)) { if (txq->q.read_ptr != (scd_ssn & 0xff)) {
index = iwl_queue_dec_wrap(scd_ssn & 0xff, txq->q.n_bd); index = iwl_queue_dec_wrap(scd_ssn & 0xff, txq->q.n_bd);
IWL_DEBUG_TX_REPLY("Retry scheduler reclaim scd_ssn " IWL_DEBUG_TX_REPLY(priv, "Retry scheduler reclaim scd_ssn "
"%d index %d\n", scd_ssn , index); "%d index %d\n", scd_ssn , index);
freed = iwl_tx_queue_reclaim(priv, txq_id, index); freed = iwl_tx_queue_reclaim(priv, txq_id, index);
priv->stations[sta_id].tid[tid].tfds_in_queue -= freed; priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
@ -2199,7 +2199,7 @@ static void iwl4965_rx_reply_tx(struct iwl_priv *priv,
le32_to_cpu(tx_resp->rate_n_flags), le32_to_cpu(tx_resp->rate_n_flags),
info); info);
IWL_DEBUG_TX_REPLY("TXQ %d status %s (0x%08x) " IWL_DEBUG_TX_REPLY(priv, "TXQ %d status %s (0x%08x) "
"rate_n_flags 0x%x retries %d\n", "rate_n_flags 0x%x retries %d\n",
txq_id, txq_id,
iwl_get_tx_fail_reason(status), status, iwl_get_tx_fail_reason(status), status,
@ -2247,7 +2247,7 @@ static int iwl4965_calc_rssi(struct iwl_priv *priv,
if (valid_antennae & (1 << i)) if (valid_antennae & (1 << i))
max_rssi = max(ncphy->rssi_info[i << 1], max_rssi); max_rssi = max(ncphy->rssi_info[i << 1], max_rssi);
IWL_DEBUG_STATS("Rssi In A %d B %d C %d Max %d AGC dB %d\n", IWL_DEBUG_STATS(priv, "Rssi In A %d B %d C %d Max %d AGC dB %d\n",
ncphy->rssi_info[0], ncphy->rssi_info[2], ncphy->rssi_info[4], ncphy->rssi_info[0], ncphy->rssi_info[2], ncphy->rssi_info[4],
max_rssi, agc); max_rssi, agc);

169
drivers/net/wireless/iwlwifi/iwl-5000.c
View File

@ -43,6 +43,7 @@
#include "iwl-sta.h" #include "iwl-sta.h"
#include "iwl-helpers.h" #include "iwl-helpers.h"
#include "iwl-5000-hw.h" #include "iwl-5000-hw.h"
#include "iwl-6000-hw.h"
/* Highest firmware API version supported */ /* Highest firmware API version supported */
#define IWL5000_UCODE_API_MAX 1 #define IWL5000_UCODE_API_MAX 1
@ -84,7 +85,7 @@ static int iwl5000_apm_stop_master(struct iwl_priv *priv)
CSR_RESET_REG_FLAG_MASTER_DISABLED, 100); CSR_RESET_REG_FLAG_MASTER_DISABLED, 100);
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
IWL_DEBUG_INFO("stop master\n"); IWL_DEBUG_INFO(priv, "stop master\n");
return 0; return 0;
} }
@ -108,7 +109,8 @@ static int iwl5000_apm_init(struct iwl_priv *priv)
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG, iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A); CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A);
iwl_set_bit(priv, CSR_ANA_PLL_CFG, CSR50_ANA_PLL_CFG_VAL); if (priv->cfg->need_pll_cfg)
iwl_set_bit(priv, CSR_ANA_PLL_CFG, CSR50_ANA_PLL_CFG_VAL);
/* set "initialization complete" bit to move adapter /* set "initialization complete" bit to move adapter
* D0U* --> D0A* state */ * D0U* --> D0A* state */
@ -118,7 +120,7 @@ static int iwl5000_apm_init(struct iwl_priv *priv)
ret = iwl_poll_direct_bit(priv, CSR_GP_CNTRL, ret = iwl_poll_direct_bit(priv, CSR_GP_CNTRL,
CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000); CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
if (ret < 0) { if (ret < 0) {
IWL_DEBUG_INFO("Failed to init the card\n"); IWL_DEBUG_INFO(priv, "Failed to init the card\n");
return ret; return ret;
} }
@ -176,7 +178,8 @@ static int iwl5000_apm_reset(struct iwl_priv *priv)
/* FIXME: put here L1A -L0S w/a */ /* FIXME: put here L1A -L0S w/a */
iwl_set_bit(priv, CSR_ANA_PLL_CFG, CSR50_ANA_PLL_CFG_VAL); if (priv->cfg->need_pll_cfg)
iwl_set_bit(priv, CSR_ANA_PLL_CFG, CSR50_ANA_PLL_CFG_VAL);
/* set "initialization complete" bit to move adapter /* set "initialization complete" bit to move adapter
* D0U* --> D0A* state */ * D0U* --> D0A* state */
@ -186,7 +189,7 @@ static int iwl5000_apm_reset(struct iwl_priv *priv)
ret = iwl_poll_direct_bit(priv, CSR_GP_CNTRL, ret = iwl_poll_direct_bit(priv, CSR_GP_CNTRL,
CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000); CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
if (ret < 0) { if (ret < 0) {
IWL_DEBUG_INFO("Failed to init the card\n"); IWL_DEBUG_INFO(priv, "Failed to init the card\n");
goto out; goto out;
} }
@ -338,7 +341,7 @@ static void iwl5000_gain_computation(struct iwl_priv *priv,
data->delta_gain_code[i] |= (1 << 2); data->delta_gain_code[i] |= (1 << 2);
} }
IWL_DEBUG_CALIB("Delta gains: ANT_B = %d ANT_C = %d\n", IWL_DEBUG_CALIB(priv, "Delta gains: ANT_B = %d ANT_C = %d\n",
data->delta_gain_code[1], data->delta_gain_code[2]); data->delta_gain_code[1], data->delta_gain_code[2]);
if (!data->radio_write) { if (!data->radio_write) {
@ -387,11 +390,11 @@ static void iwl5000_chain_noise_reset(struct iwl_priv *priv)
IWL_ERR(priv, IWL_ERR(priv,
"Could not send REPLY_PHY_CALIBRATION_CMD\n"); "Could not send REPLY_PHY_CALIBRATION_CMD\n");
data->state = IWL_CHAIN_NOISE_ACCUMULATE; data->state = IWL_CHAIN_NOISE_ACCUMULATE;
IWL_DEBUG_CALIB("Run chain_noise_calibrate\n"); IWL_DEBUG_CALIB(priv, "Run chain_noise_calibrate\n");
} }
} }
static void iwl5000_rts_tx_cmd_flag(struct ieee80211_tx_info *info, void iwl5000_rts_tx_cmd_flag(struct ieee80211_tx_info *info,
__le32 *tx_flags) __le32 *tx_flags)
{ {
if ((info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) || if ((info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
@ -518,7 +521,7 @@ static void iwl5000_rx_calib_result(struct iwl_priv *priv,
static void iwl5000_rx_calib_complete(struct iwl_priv *priv, static void iwl5000_rx_calib_complete(struct iwl_priv *priv,
struct iwl_rx_mem_buffer *rxb) struct iwl_rx_mem_buffer *rxb)
{ {
IWL_DEBUG_INFO("Init. calibration is completed, restarting fw.\n"); IWL_DEBUG_INFO(priv, "Init. calibration is completed, restarting fw.\n");
queue_work(priv->workqueue, &priv->restart); queue_work(priv->workqueue, &priv->restart);
} }
@ -586,7 +589,7 @@ static int iwl5000_load_given_ucode(struct iwl_priv *priv,
if (ret) if (ret)
return ret; return ret;
IWL_DEBUG_INFO("INST uCode section being loaded...\n"); IWL_DEBUG_INFO(priv, "INST uCode section being loaded...\n");
ret = wait_event_interruptible_timeout(priv->wait_command_queue, ret = wait_event_interruptible_timeout(priv->wait_command_queue,
priv->ucode_write_complete, 5 * HZ); priv->ucode_write_complete, 5 * HZ);
if (ret == -ERESTARTSYS) { if (ret == -ERESTARTSYS) {
@ -606,7 +609,7 @@ static int iwl5000_load_given_ucode(struct iwl_priv *priv,
if (ret) if (ret)
return ret; return ret;
IWL_DEBUG_INFO("DATA uCode section being loaded...\n"); IWL_DEBUG_INFO(priv, "DATA uCode section being loaded...\n");
ret = wait_event_interruptible_timeout(priv->wait_command_queue, ret = wait_event_interruptible_timeout(priv->wait_command_queue,
priv->ucode_write_complete, 5 * HZ); priv->ucode_write_complete, 5 * HZ);
@ -631,20 +634,20 @@ static int iwl5000_load_ucode(struct iwl_priv *priv)
/* check whether init ucode should be loaded, or rather runtime ucode */ /* check whether init ucode should be loaded, or rather runtime ucode */
if (priv->ucode_init.len && (priv->ucode_type == UCODE_NONE)) { if (priv->ucode_init.len && (priv->ucode_type == UCODE_NONE)) {
IWL_DEBUG_INFO("Init ucode found. Loading init ucode...\n"); IWL_DEBUG_INFO(priv, "Init ucode found. Loading init ucode...\n");
ret = iwl5000_load_given_ucode(priv, ret = iwl5000_load_given_ucode(priv,
&priv->ucode_init, &priv->ucode_init_data); &priv->ucode_init, &priv->ucode_init_data);
if (!ret) { if (!ret) {
IWL_DEBUG_INFO("Init ucode load complete.\n"); IWL_DEBUG_INFO(priv, "Init ucode load complete.\n");
priv->ucode_type = UCODE_INIT; priv->ucode_type = UCODE_INIT;
} }
} else { } else {
IWL_DEBUG_INFO("Init ucode not found, or already loaded. " IWL_DEBUG_INFO(priv, "Init ucode not found, or already loaded. "
"Loading runtime ucode...\n"); "Loading runtime ucode...\n");
ret = iwl5000_load_given_ucode(priv, ret = iwl5000_load_given_ucode(priv,
&priv->ucode_code, &priv->ucode_data); &priv->ucode_code, &priv->ucode_data);
if (!ret) { if (!ret) {
IWL_DEBUG_INFO("Runtime ucode load complete.\n"); IWL_DEBUG_INFO(priv, "Runtime ucode load complete.\n");
priv->ucode_type = UCODE_RT; priv->ucode_type = UCODE_RT;
} }
} }
@ -660,7 +663,7 @@ static void iwl5000_init_alive_start(struct iwl_priv *priv)
if (priv->card_alive_init.is_valid != UCODE_VALID_OK) { if (priv->card_alive_init.is_valid != UCODE_VALID_OK) {
/* We had an error bringing up the hardware, so take it /* We had an error bringing up the hardware, so take it
* all the way back down so we can try again */ * all the way back down so we can try again */
IWL_DEBUG_INFO("Initialize Alive failed.\n"); IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
goto restart; goto restart;
} }
@ -670,7 +673,7 @@ static void iwl5000_init_alive_start(struct iwl_priv *priv)
if (iwl_verify_ucode(priv)) { if (iwl_verify_ucode(priv)) {
/* Runtime instruction load was bad; /* Runtime instruction load was bad;
* take it all the way back down so we can try again */ * take it all the way back down so we can try again */
IWL_DEBUG_INFO("Bad \"initialize\" uCode load.\n"); IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
goto restart; goto restart;
} }
@ -713,7 +716,7 @@ static void iwl5000_tx_queue_set_status(struct iwl_priv *priv,
txq->sched_retry = scd_retry; txq->sched_retry = scd_retry;
IWL_DEBUG_INFO("%s %s Queue %d on AC %d\n", IWL_DEBUG_INFO(priv, "%s %s Queue %d on AC %d\n",
active ? "Activate" : "Deactivate", active ? "Activate" : "Deactivate",
scd_retry ? "BA" : "AC", txq_id, tx_fifo_id); scd_retry ? "BA" : "AC", txq_id, tx_fifo_id);
} }
@ -840,8 +843,18 @@ static int iwl5000_hw_set_hw_params(struct iwl_priv *priv)
priv->hw_params.tfd_size = sizeof(struct iwl_tfd); priv->hw_params.tfd_size = sizeof(struct iwl_tfd);
priv->hw_params.max_stations = IWL5000_STATION_COUNT; priv->hw_params.max_stations = IWL5000_STATION_COUNT;
priv->hw_params.bcast_sta_id = IWL5000_BROADCAST_ID; priv->hw_params.bcast_sta_id = IWL5000_BROADCAST_ID;
priv->hw_params.max_data_size = IWL50_RTC_DATA_SIZE;
priv->hw_params.max_inst_size = IWL50_RTC_INST_SIZE; switch (priv->hw_rev & CSR_HW_REV_TYPE_MSK) {
case CSR_HW_REV_TYPE_6x00:
case CSR_HW_REV_TYPE_6x50:
priv->hw_params.max_data_size = IWL60_RTC_DATA_SIZE;
priv->hw_params.max_inst_size = IWL60_RTC_INST_SIZE;
break;
default:
priv->hw_params.max_data_size = IWL50_RTC_DATA_SIZE;
priv->hw_params.max_inst_size = IWL50_RTC_INST_SIZE;
}
priv->hw_params.max_bsm_size = 0; priv->hw_params.max_bsm_size = 0;
priv->hw_params.fat_channel = BIT(IEEE80211_BAND_2GHZ) | priv->hw_params.fat_channel = BIT(IEEE80211_BAND_2GHZ) |
BIT(IEEE80211_BAND_5GHZ); BIT(IEEE80211_BAND_5GHZ);
@ -849,54 +862,25 @@ static int iwl5000_hw_set_hw_params(struct iwl_priv *priv)
priv->hw_params.sens = &iwl5000_sensitivity; priv->hw_params.sens = &iwl5000_sensitivity;
switch (priv->hw_rev & CSR_HW_REV_TYPE_MSK) { priv->hw_params.tx_chains_num = num_of_ant(priv->cfg->valid_tx_ant);
case CSR_HW_REV_TYPE_5100: priv->hw_params.rx_chains_num = num_of_ant(priv->cfg->valid_rx_ant);
priv->hw_params.tx_chains_num = 1; priv->hw_params.valid_tx_ant = priv->cfg->valid_tx_ant;
priv->hw_params.rx_chains_num = 2; priv->hw_params.valid_rx_ant = priv->cfg->valid_rx_ant;
priv->hw_params.valid_tx_ant = ANT_B;
priv->hw_params.valid_rx_ant = ANT_AB;
break;
case CSR_HW_REV_TYPE_5150:
priv->hw_params.tx_chains_num = 1;
priv->hw_params.rx_chains_num = 2;
priv->hw_params.valid_tx_ant = ANT_A;
priv->hw_params.valid_rx_ant = ANT_AB;
break;
case CSR_HW_REV_TYPE_5300:
case CSR_HW_REV_TYPE_5350:
priv->hw_params.tx_chains_num = 3;
priv->hw_params.rx_chains_num = 3;
priv->hw_params.valid_tx_ant = ANT_ABC;
priv->hw_params.valid_rx_ant = ANT_ABC;
break;
}
switch (priv->hw_rev & CSR_HW_REV_TYPE_MSK) { switch (priv->hw_rev & CSR_HW_REV_TYPE_MSK) {
case CSR_HW_REV_TYPE_5100:
case CSR_HW_REV_TYPE_5300:
case CSR_HW_REV_TYPE_5350:
/* 5X00 and 5350 wants in Celsius */
priv->hw_params.ct_kill_threshold = CT_KILL_THRESHOLD;
break;
case CSR_HW_REV_TYPE_5150: case CSR_HW_REV_TYPE_5150:
/* 5150 wants in Kelvin */ /* 5150 wants in Kelvin */
priv->hw_params.ct_kill_threshold = priv->hw_params.ct_kill_threshold =
iwl5150_get_ct_threshold(priv); iwl5150_get_ct_threshold(priv);
break; break;
default:
/* all others want Celsius */
priv->hw_params.ct_kill_threshold = CT_KILL_THRESHOLD;
break;
} }
/* Set initial calibration set */ /* Set initial calibration set */
switch (priv->hw_rev & CSR_HW_REV_TYPE_MSK) { switch (priv->hw_rev & CSR_HW_REV_TYPE_MSK) {
case CSR_HW_REV_TYPE_5100:
case CSR_HW_REV_TYPE_5300:
case CSR_HW_REV_TYPE_5350:
priv->hw_params.calib_init_cfg =
BIT(IWL_CALIB_XTAL) |
BIT(IWL_CALIB_LO) |
BIT(IWL_CALIB_TX_IQ) |
BIT(IWL_CALIB_TX_IQ_PERD) |
BIT(IWL_CALIB_BASE_BAND);
break;
case CSR_HW_REV_TYPE_5150: case CSR_HW_REV_TYPE_5150:
priv->hw_params.calib_init_cfg = priv->hw_params.calib_init_cfg =
BIT(IWL_CALIB_DC) | BIT(IWL_CALIB_DC) |
@ -905,6 +889,14 @@ static int iwl5000_hw_set_hw_params(struct iwl_priv *priv)
BIT(IWL_CALIB_BASE_BAND); BIT(IWL_CALIB_BASE_BAND);
break; break;
default:
priv->hw_params.calib_init_cfg =
BIT(IWL_CALIB_XTAL) |
BIT(IWL_CALIB_LO) |
BIT(IWL_CALIB_TX_IQ) |
BIT(IWL_CALIB_TX_IQ_PERD) |
BIT(IWL_CALIB_BASE_BAND);
break;
} }
@ -1113,7 +1105,7 @@ static int iwl5000_txq_agg_disable(struct iwl_priv *priv, u16 txq_id,
return 0; return 0;
} }
static u16 iwl5000_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data) u16 iwl5000_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data)
{ {
u16 size = (u16)sizeof(struct iwl_addsta_cmd); u16 size = (u16)sizeof(struct iwl_addsta_cmd);
memcpy(data, cmd, size); memcpy(data, cmd, size);
@ -1151,7 +1143,7 @@ static int iwl5000_tx_status_reply_tx(struct iwl_priv *priv,
u16 seq; u16 seq;
if (agg->wait_for_ba) if (agg->wait_for_ba)
IWL_DEBUG_TX_REPLY("got tx response w/o block-ack\n"); IWL_DEBUG_TX_REPLY(priv, "got tx response w/o block-ack\n");
agg->frame_count = tx_resp->frame_count; agg->frame_count = tx_resp->frame_count;
agg->start_idx = start_idx; agg->start_idx = start_idx;
@ -1165,7 +1157,7 @@ static int iwl5000_tx_status_reply_tx(struct iwl_priv *priv,
idx = start_idx; idx = start_idx;
/* FIXME: code repetition */ /* FIXME: code repetition */
IWL_DEBUG_TX_REPLY("FrameCnt = %d, StartIdx=%d idx=%d\n", IWL_DEBUG_TX_REPLY(priv, "FrameCnt = %d, StartIdx=%d idx=%d\n",
agg->frame_count, agg->start_idx, idx); agg->frame_count, agg->start_idx, idx);
info = IEEE80211_SKB_CB(priv->txq[txq_id].txb[idx].skb[0]); info = IEEE80211_SKB_CB(priv->txq[txq_id].txb[idx].skb[0]);
@ -1177,9 +1169,9 @@ static int iwl5000_tx_status_reply_tx(struct iwl_priv *priv,
/* FIXME: code repetition end */ /* FIXME: code repetition end */
IWL_DEBUG_TX_REPLY("1 Frame 0x%x failure :%d\n", IWL_DEBUG_TX_REPLY(priv, "1 Frame 0x%x failure :%d\n",
status & 0xff, tx_resp->failure_frame); status & 0xff, tx_resp->failure_frame);
IWL_DEBUG_TX_REPLY("Rate Info rate_n_flags=%x\n", rate_n_flags); IWL_DEBUG_TX_REPLY(priv, "Rate Info rate_n_flags=%x\n", rate_n_flags);
agg->wait_for_ba = 0; agg->wait_for_ba = 0;
} else { } else {
@ -1199,7 +1191,7 @@ static int iwl5000_tx_status_reply_tx(struct iwl_priv *priv,
AGG_TX_STATE_ABORT_MSK)) AGG_TX_STATE_ABORT_MSK))
continue; continue;
IWL_DEBUG_TX_REPLY("FrameCnt = %d, txq_id=%d idx=%d\n", IWL_DEBUG_TX_REPLY(priv, "FrameCnt = %d, txq_id=%d idx=%d\n",
agg->frame_count, txq_id, idx); agg->frame_count, txq_id, idx);
hdr = iwl_tx_queue_get_hdr(priv, txq_id, idx); hdr = iwl_tx_queue_get_hdr(priv, txq_id, idx);
@ -1214,7 +1206,7 @@ static int iwl5000_tx_status_reply_tx(struct iwl_priv *priv,
return -1; return -1;
} }
IWL_DEBUG_TX_REPLY("AGG Frame i=%d idx %d seq=%d\n", IWL_DEBUG_TX_REPLY(priv, "AGG Frame i=%d idx %d seq=%d\n",
i, idx, SEQ_TO_SN(sc)); i, idx, SEQ_TO_SN(sc));
sh = idx - start; sh = idx - start;
@ -1232,13 +1224,13 @@ static int iwl5000_tx_status_reply_tx(struct iwl_priv *priv,
sh = 0; sh = 0;
} }
bitmap |= 1ULL << sh; bitmap |= 1ULL << sh;
IWL_DEBUG_TX_REPLY("start=%d bitmap=0x%llx\n", IWL_DEBUG_TX_REPLY(priv, "start=%d bitmap=0x%llx\n",
start, (unsigned long long)bitmap); start, (unsigned long long)bitmap);
} }
agg->bitmap = bitmap; agg->bitmap = bitmap;
agg->start_idx = start; agg->start_idx = start;
IWL_DEBUG_TX_REPLY("Frames %d start_idx=%d bitmap=0x%llx\n", IWL_DEBUG_TX_REPLY(priv, "Frames %d start_idx=%d bitmap=0x%llx\n",
agg->frame_count, agg->start_idx, agg->frame_count, agg->start_idx,
(unsigned long long)agg->bitmap); (unsigned long long)agg->bitmap);
@ -1291,7 +1283,7 @@ static void iwl5000_rx_reply_tx(struct iwl_priv *priv,
if (txq->q.read_ptr != (scd_ssn & 0xff)) { if (txq->q.read_ptr != (scd_ssn & 0xff)) {
index = iwl_queue_dec_wrap(scd_ssn & 0xff, txq->q.n_bd); index = iwl_queue_dec_wrap(scd_ssn & 0xff, txq->q.n_bd);
IWL_DEBUG_TX_REPLY("Retry scheduler reclaim " IWL_DEBUG_TX_REPLY(priv, "Retry scheduler reclaim "
"scd_ssn=%d idx=%d txq=%d swq=%d\n", "scd_ssn=%d idx=%d txq=%d swq=%d\n",
scd_ssn , index, txq_id, txq->swq_id); scd_ssn , index, txq_id, txq->swq_id);
@ -1318,7 +1310,7 @@ static void iwl5000_rx_reply_tx(struct iwl_priv *priv,
le32_to_cpu(tx_resp->rate_n_flags), le32_to_cpu(tx_resp->rate_n_flags),
info); info);
IWL_DEBUG_TX_REPLY("TXQ %d status %s (0x%08x) rate_n_flags " IWL_DEBUG_TX_REPLY(priv, "TXQ %d status %s (0x%08x) rate_n_flags "
"0x%x retries %d\n", "0x%x retries %d\n",
txq_id, txq_id,
iwl_get_tx_fail_reason(status), status, iwl_get_tx_fail_reason(status), status,
@ -1342,7 +1334,7 @@ static void iwl5000_rx_reply_tx(struct iwl_priv *priv,
} }
/* Currently 5000 is the superset of everything */ /* Currently 5000 is the superset of everything */
static u16 iwl5000_get_hcmd_size(u8 cmd_id, u16 len) u16 iwl5000_get_hcmd_size(u8 cmd_id, u16 len)
{ {
return len; return len;
} }
@ -1389,7 +1381,7 @@ static int iwl5000_send_rxon_assoc(struct iwl_priv *priv)
(rxon1->acquisition_data == rxon2->acquisition_data) && (rxon1->acquisition_data == rxon2->acquisition_data) &&
(rxon1->rx_chain == rxon2->rx_chain) && (rxon1->rx_chain == rxon2->rx_chain) &&
(rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) { (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
IWL_DEBUG_INFO("Using current RXON_ASSOC. Not resending.\n"); IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC. Not resending.\n");
return 0; return 0;
} }
@ -1419,12 +1411,19 @@ static int iwl5000_send_rxon_assoc(struct iwl_priv *priv)
static int iwl5000_send_tx_power(struct iwl_priv *priv) static int iwl5000_send_tx_power(struct iwl_priv *priv)
{ {
struct iwl5000_tx_power_dbm_cmd tx_power_cmd; struct iwl5000_tx_power_dbm_cmd tx_power_cmd;
u8 tx_ant_cfg_cmd;
/* half dBm need to multiply */ /* half dBm need to multiply */
tx_power_cmd.global_lmt = (s8)(2 * priv->tx_power_user_lmt); tx_power_cmd.global_lmt = (s8)(2 * priv->tx_power_user_lmt);
tx_power_cmd.flags = IWL50_TX_POWER_NO_CLOSED; tx_power_cmd.flags = IWL50_TX_POWER_NO_CLOSED;
tx_power_cmd.srv_chan_lmt = IWL50_TX_POWER_AUTO; tx_power_cmd.srv_chan_lmt = IWL50_TX_POWER_AUTO;
return iwl_send_cmd_pdu_async(priv, REPLY_TX_POWER_DBM_CMD,
if (IWL_UCODE_API(priv->ucode_ver) == 1)
tx_ant_cfg_cmd = REPLY_TX_POWER_DBM_CMD_V1;
else
tx_ant_cfg_cmd = REPLY_TX_POWER_DBM_CMD;
return iwl_send_cmd_pdu_async(priv, tx_ant_cfg_cmd,
sizeof(tx_power_cmd), &tx_power_cmd, sizeof(tx_power_cmd), &tx_power_cmd,
NULL); NULL);
} }
@ -1436,7 +1435,7 @@ static void iwl5000_temperature(struct iwl_priv *priv)
} }
/* Calc max signal level (dBm) among 3 possible receivers */ /* Calc max signal level (dBm) among 3 possible receivers */
static int iwl5000_calc_rssi(struct iwl_priv *priv, int iwl5000_calc_rssi(struct iwl_priv *priv,
struct iwl_rx_phy_res *rx_resp) struct iwl_rx_phy_res *rx_resp)
{ {
/* data from PHY/DSP regarding signal strength, etc., /* data from PHY/DSP regarding signal strength, etc.,
@ -1465,7 +1464,7 @@ static int iwl5000_calc_rssi(struct iwl_priv *priv,
max_rssi = max_t(u32, rssi_a, rssi_b); max_rssi = max_t(u32, rssi_a, rssi_b);
max_rssi = max_t(u32, max_rssi, rssi_c); max_rssi = max_t(u32, max_rssi, rssi_c);
IWL_DEBUG_STATS("Rssi In A %d B %d C %d Max %d AGC dB %d\n", IWL_DEBUG_STATS(priv, "Rssi In A %d B %d C %d Max %d AGC dB %d\n",
rssi_a, rssi_b, rssi_c, max_rssi, agc); rssi_a, rssi_b, rssi_c, max_rssi, agc);
/* dBm = max_rssi dB - agc dB - constant. /* dBm = max_rssi dB - agc dB - constant.
@ -1473,11 +1472,11 @@ static int iwl5000_calc_rssi(struct iwl_priv *priv,
return max_rssi - agc - IWL49_RSSI_OFFSET; return max_rssi - agc - IWL49_RSSI_OFFSET;
} }
static struct iwl_hcmd_ops iwl5000_hcmd = { struct iwl_hcmd_ops iwl5000_hcmd = {
.rxon_assoc = iwl5000_send_rxon_assoc, .rxon_assoc = iwl5000_send_rxon_assoc,
}; };
static struct iwl_hcmd_utils_ops iwl5000_hcmd_utils = { struct iwl_hcmd_utils_ops iwl5000_hcmd_utils = {
.get_hcmd_size = iwl5000_get_hcmd_size, .get_hcmd_size = iwl5000_get_hcmd_size,
.build_addsta_hcmd = iwl5000_build_addsta_hcmd, .build_addsta_hcmd = iwl5000_build_addsta_hcmd,
.gain_computation = iwl5000_gain_computation, .gain_computation = iwl5000_gain_computation,
@ -1486,7 +1485,7 @@ static struct iwl_hcmd_utils_ops iwl5000_hcmd_utils = {
.calc_rssi = iwl5000_calc_rssi, .calc_rssi = iwl5000_calc_rssi,
}; };
static struct iwl_lib_ops iwl5000_lib = { struct iwl_lib_ops iwl5000_lib = {
.set_hw_params = iwl5000_hw_set_hw_params, .set_hw_params = iwl5000_hw_set_hw_params,
.txq_update_byte_cnt_tbl = iwl5000_txq_update_byte_cnt_tbl, .txq_update_byte_cnt_tbl = iwl5000_txq_update_byte_cnt_tbl,
.txq_inval_byte_cnt_tbl = iwl5000_txq_inval_byte_cnt_tbl, .txq_inval_byte_cnt_tbl = iwl5000_txq_inval_byte_cnt_tbl,
@ -1556,6 +1555,9 @@ struct iwl_cfg iwl5300_agn_cfg = {
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_ABC,
.valid_rx_ant = ANT_ABC,
.need_pll_cfg = true,
}; };
struct iwl_cfg iwl5100_bg_cfg = { struct iwl_cfg iwl5100_bg_cfg = {
@ -1569,6 +1571,9 @@ struct iwl_cfg iwl5100_bg_cfg = {
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_B,
.valid_rx_ant = ANT_AB,
.need_pll_cfg = true,
}; };
struct iwl_cfg iwl5100_abg_cfg = { struct iwl_cfg iwl5100_abg_cfg = {
@ -1582,6 +1587,9 @@ struct iwl_cfg iwl5100_abg_cfg = {
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_B,
.valid_rx_ant = ANT_AB,
.need_pll_cfg = true,
}; };
struct iwl_cfg iwl5100_agn_cfg = { struct iwl_cfg iwl5100_agn_cfg = {
@ -1595,6 +1603,9 @@ struct iwl_cfg iwl5100_agn_cfg = {
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_B,
.valid_rx_ant = ANT_AB,
.need_pll_cfg = true,
}; };
struct iwl_cfg iwl5350_agn_cfg = { struct iwl_cfg iwl5350_agn_cfg = {
@ -1608,6 +1619,9 @@ struct iwl_cfg iwl5350_agn_cfg = {
.eeprom_ver = EEPROM_5050_EEPROM_VERSION, .eeprom_ver = EEPROM_5050_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_ABC,
.valid_rx_ant = ANT_ABC,
.need_pll_cfg = true,
}; };
struct iwl_cfg iwl5150_agn_cfg = { struct iwl_cfg iwl5150_agn_cfg = {
@ -1621,6 +1635,9 @@ struct iwl_cfg iwl5150_agn_cfg = {
.eeprom_ver = EEPROM_5050_EEPROM_VERSION, .eeprom_ver = EEPROM_5050_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5050_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_A,
.valid_rx_ant = ANT_AB,
.need_pll_cfg = true,
}; };
MODULE_FIRMWARE(IWL5000_MODULE_FIRMWARE(IWL5000_UCODE_API_MAX)); MODULE_FIRMWARE(IWL5000_MODULE_FIRMWARE(IWL5000_UCODE_API_MAX));

42
drivers/net/wireless/iwlwifi/iwl-6000.c
View File

@ -46,8 +46,8 @@
#include "iwl-5000-hw.h" #include "iwl-5000-hw.h"
/* Highest firmware API version supported */ /* Highest firmware API version supported */
#define IWL6000_UCODE_API_MAX 1 #define IWL6000_UCODE_API_MAX 2
#define IWL6050_UCODE_API_MAX 1 #define IWL6050_UCODE_API_MAX 2
/* Lowest firmware API version supported */ /* Lowest firmware API version supported */
#define IWL6000_UCODE_API_MIN 1 #define IWL6000_UCODE_API_MIN 1
@ -61,17 +61,33 @@
#define _IWL6050_MODULE_FIRMWARE(api) IWL6050_FW_PRE #api ".ucode" #define _IWL6050_MODULE_FIRMWARE(api) IWL6050_FW_PRE #api ".ucode"
#define IWL6050_MODULE_FIRMWARE(api) _IWL6050_MODULE_FIRMWARE(api) #define IWL6050_MODULE_FIRMWARE(api) _IWL6050_MODULE_FIRMWARE(api)
static struct iwl_hcmd_utils_ops iwl6000_hcmd_utils = {
.get_hcmd_size = iwl5000_get_hcmd_size,
.build_addsta_hcmd = iwl5000_build_addsta_hcmd,
.rts_tx_cmd_flag = iwl5000_rts_tx_cmd_flag,
.calc_rssi = iwl5000_calc_rssi,
};
static struct iwl_ops iwl6000_ops = {
.lib = &iwl5000_lib,
.hcmd = &iwl5000_hcmd,
.utils = &iwl6000_hcmd_utils,
};
struct iwl_cfg iwl6000_2ag_cfg = { struct iwl_cfg iwl6000_2ag_cfg = {
.name = "6000 Series 2x2 AG", .name = "6000 Series 2x2 AG",
.fw_name_pre = IWL6000_FW_PRE, .fw_name_pre = IWL6000_FW_PRE,
.ucode_api_max = IWL6000_UCODE_API_MAX, .ucode_api_max = IWL6000_UCODE_API_MAX,
.ucode_api_min = IWL6000_UCODE_API_MIN, .ucode_api_min = IWL6000_UCODE_API_MIN,
.sku = IWL_SKU_A|IWL_SKU_G, .sku = IWL_SKU_A|IWL_SKU_G,
.ops = &iwl5000_ops, .ops = &iwl6000_ops,
.eeprom_size = IWL_5000_EEPROM_IMG_SIZE, .eeprom_size = IWL_5000_EEPROM_IMG_SIZE,
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_BC,
.valid_rx_ant = ANT_BC,
.need_pll_cfg = false,
}; };
struct iwl_cfg iwl6000_2agn_cfg = { struct iwl_cfg iwl6000_2agn_cfg = {
@ -80,11 +96,14 @@ struct iwl_cfg iwl6000_2agn_cfg = {
.ucode_api_max = IWL6000_UCODE_API_MAX, .ucode_api_max = IWL6000_UCODE_API_MAX,
.ucode_api_min = IWL6000_UCODE_API_MIN, .ucode_api_min = IWL6000_UCODE_API_MIN,
.sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N, .sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N,
.ops = &iwl5000_ops, .ops = &iwl6000_ops,
.eeprom_size = IWL_5000_EEPROM_IMG_SIZE, .eeprom_size = IWL_5000_EEPROM_IMG_SIZE,
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_BC,
.valid_rx_ant = ANT_BC,
.need_pll_cfg = false,
}; };
struct iwl_cfg iwl6050_2agn_cfg = { struct iwl_cfg iwl6050_2agn_cfg = {
@ -93,11 +112,14 @@ struct iwl_cfg iwl6050_2agn_cfg = {
.ucode_api_max = IWL6050_UCODE_API_MAX, .ucode_api_max = IWL6050_UCODE_API_MAX,
.ucode_api_min = IWL6050_UCODE_API_MIN, .ucode_api_min = IWL6050_UCODE_API_MIN,
.sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N, .sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N,
.ops = &iwl5000_ops, .ops = &iwl6000_ops,
.eeprom_size = IWL_5000_EEPROM_IMG_SIZE, .eeprom_size = IWL_5000_EEPROM_IMG_SIZE,
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_BC,
.valid_rx_ant = ANT_BC,
.need_pll_cfg = false,
}; };
struct iwl_cfg iwl6000_3agn_cfg = { struct iwl_cfg iwl6000_3agn_cfg = {
@ -106,11 +128,14 @@ struct iwl_cfg iwl6000_3agn_cfg = {
.ucode_api_max = IWL6000_UCODE_API_MAX, .ucode_api_max = IWL6000_UCODE_API_MAX,
.ucode_api_min = IWL6000_UCODE_API_MIN, .ucode_api_min = IWL6000_UCODE_API_MIN,
.sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N, .sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N,
.ops = &iwl5000_ops, .ops = &iwl6000_ops,
.eeprom_size = IWL_5000_EEPROM_IMG_SIZE, .eeprom_size = IWL_5000_EEPROM_IMG_SIZE,
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_ABC,
.valid_rx_ant = ANT_ABC,
.need_pll_cfg = false,
}; };
struct iwl_cfg iwl6050_3agn_cfg = { struct iwl_cfg iwl6050_3agn_cfg = {
@ -119,11 +144,14 @@ struct iwl_cfg iwl6050_3agn_cfg = {
.ucode_api_max = IWL6050_UCODE_API_MAX, .ucode_api_max = IWL6050_UCODE_API_MAX,
.ucode_api_min = IWL6050_UCODE_API_MIN, .ucode_api_min = IWL6050_UCODE_API_MIN,
.sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N, .sku = IWL_SKU_A|IWL_SKU_G|IWL_SKU_N,
.ops = &iwl5000_ops, .ops = &iwl6000_ops,
.eeprom_size = IWL_5000_EEPROM_IMG_SIZE, .eeprom_size = IWL_5000_EEPROM_IMG_SIZE,
.eeprom_ver = EEPROM_5000_EEPROM_VERSION, .eeprom_ver = EEPROM_5000_EEPROM_VERSION,
.eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION, .eeprom_calib_ver = EEPROM_5000_TX_POWER_VERSION,
.mod_params = &iwl50_mod_params, .mod_params = &iwl50_mod_params,
.valid_tx_ant = ANT_ABC,
.valid_rx_ant = ANT_ABC,
.need_pll_cfg = false,
}; };
MODULE_FIRMWARE(IWL6000_MODULE_FIRMWARE(IWL6000_UCODE_API_MAX)); MODULE_FIRMWARE(IWL6000_MODULE_FIRMWARE(IWL6000_UCODE_API_MAX));

109
drivers/net/wireless/iwlwifi/iwl-agn-hcmd-check.c
View File

@ -1,109 +0,0 @@
/******************************************************************************
*
* GPL LICENSE SUMMARY
*
* Copyright(c) 2008 - 2009 Intel Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
* USA
*
* The full GNU General Public License is included in this distribution
* in the file called LICENSE.GPL.
*
* Contact Information:
* Intel Linux Wireless <ilw@linux.intel.com>
* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
*****************************************************************************/
#include <linux/kernel.h>
#include <net/mac80211.h>
#include "iwl-dev.h"
#include "iwl-debug.h"
#include "iwl-commands.h"
/**
* iwl_check_rxon_cmd - validate RXON structure is valid
*
* NOTE: This is really only useful during development and can eventually
* be #ifdef'd out once the driver is stable and folks aren't actively
* making changes
*/
int iwl_agn_check_rxon_cmd(struct iwl_priv *priv)
{
int error = 0;
int counter = 1;
struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
error |= le32_to_cpu(rxon->flags &
(RXON_FLG_TGJ_NARROW_BAND_MSK |
RXON_FLG_RADAR_DETECT_MSK));
if (error)
IWL_WARN(priv, "check 24G fields %d | %d\n",
counter++, error);
} else {
error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
if (error)
IWL_WARN(priv, "check 52 fields %d | %d\n",
counter++, error);
error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
if (error)
IWL_WARN(priv, "check 52 CCK %d | %d\n",
counter++, error);
}
error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
if (error)
IWL_WARN(priv, "check mac addr %d | %d\n", counter++, error);
/* make sure basic rates 6Mbps and 1Mbps are supported */
error |= (((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0) &&
((rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0));
if (error)
IWL_WARN(priv, "check basic rate %d | %d\n", counter++, error);
error |= (le16_to_cpu(rxon->assoc_id) > 2007);
if (error)
IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);
error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
== (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
if (error)
IWL_WARN(priv, "check CCK and short slot %d | %d\n",
counter++, error);
error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK))
== (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK));
if (error)
IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
counter++, error);
error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
if (error)
IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
counter++, error);
if (error)
IWL_WARN(priv, "Tuning to channel %d\n",
le16_to_cpu(rxon->channel));
if (error) {
IWL_ERR(priv, "Not a valid iwl_rxon_assoc_cmd field values\n");
return -1;
}
return 0;
}

104
drivers/net/wireless/iwlwifi/iwl-agn-rs.c
View File

@ -360,7 +360,7 @@ static void rs_tl_turn_on_agg_for_tid(struct iwl_priv *priv,
struct ieee80211_sta *sta) struct ieee80211_sta *sta)
{ {
if (rs_tl_get_load(lq_data, tid) > IWL_AGG_LOAD_THRESHOLD) { if (rs_tl_get_load(lq_data, tid) > IWL_AGG_LOAD_THRESHOLD) {
IWL_DEBUG_HT("Starting Tx agg: STA: %pM tid: %d\n", IWL_DEBUG_HT(priv, "Starting Tx agg: STA: %pM tid: %d\n",
sta->addr, tid); sta->addr, tid);
ieee80211_start_tx_ba_session(priv->hw, sta->addr, tid); ieee80211_start_tx_ba_session(priv->hw, sta->addr, tid);
} }
@ -693,7 +693,7 @@ static u16 rs_get_adjacent_rate(struct iwl_priv *priv, u8 index, u16 rate_mask,
break; break;
if (rate_mask & (1 << low)) if (rate_mask & (1 << low))
break; break;
IWL_DEBUG_RATE("Skipping masked lower rate: %d\n", low); IWL_DEBUG_RATE(priv, "Skipping masked lower rate: %d\n", low);
} }
high = index; high = index;
@ -703,7 +703,7 @@ static u16 rs_get_adjacent_rate(struct iwl_priv *priv, u8 index, u16 rate_mask,
break; break;
if (rate_mask & (1 << high)) if (rate_mask & (1 << high))
break; break;
IWL_DEBUG_RATE("Skipping masked higher rate: %d\n", high); IWL_DEBUG_RATE(priv, "Skipping masked higher rate: %d\n", high);
} }
return (high << 8) | low; return (high << 8) | low;
@ -790,7 +790,7 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
u8 active_index = 0; u8 active_index = 0;
s32 tpt = 0; s32 tpt = 0;
IWL_DEBUG_RATE_LIMIT("get frame ack response, update rate scale window\n"); IWL_DEBUG_RATE_LIMIT(priv, "get frame ack response, update rate scale window\n");
if (!ieee80211_is_data(hdr->frame_control) || if (!ieee80211_is_data(hdr->frame_control) ||
is_multicast_ether_addr(hdr->addr1)) is_multicast_ether_addr(hdr->addr1))
@ -840,7 +840,7 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
(!!(tx_rate & RATE_MCS_GF_MSK) != !!(info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)) || (!!(tx_rate & RATE_MCS_GF_MSK) != !!(info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)) ||
(hw->wiphy->bands[priv->band]->bitrates[rs_index].bitrate != (hw->wiphy->bands[priv->band]->bitrates[rs_index].bitrate !=
hw->wiphy->bands[info->band]->bitrates[info->status.rates[0].idx].bitrate)) { hw->wiphy->bands[info->band]->bitrates[info->status.rates[0].idx].bitrate)) {
IWL_DEBUG_RATE("initial rate does not match 0x%x\n", tx_rate); IWL_DEBUG_RATE(priv, "initial rate does not match 0x%x\n", tx_rate);
/* the last LQ command could failed so the LQ in ucode not /* the last LQ command could failed so the LQ in ucode not
* the same in driver sync up * the same in driver sync up
*/ */
@ -971,7 +971,7 @@ out:
static void rs_set_stay_in_table(struct iwl_priv *priv, u8 is_legacy, static void rs_set_stay_in_table(struct iwl_priv *priv, u8 is_legacy,
struct iwl_lq_sta *lq_sta) struct iwl_lq_sta *lq_sta)
{ {
IWL_DEBUG_RATE("we are staying in the same table\n"); IWL_DEBUG_RATE(priv, "we are staying in the same table\n");
lq_sta->stay_in_tbl = 1; /* only place this gets set */ lq_sta->stay_in_tbl = 1; /* only place this gets set */
if (is_legacy) { if (is_legacy) {
lq_sta->table_count_limit = IWL_LEGACY_TABLE_COUNT; lq_sta->table_count_limit = IWL_LEGACY_TABLE_COUNT;
@ -1150,7 +1150,7 @@ static int rs_switch_to_mimo2(struct iwl_priv *priv,
if (priv->hw_params.tx_chains_num < 2) if (priv->hw_params.tx_chains_num < 2)
return -1; return -1;
IWL_DEBUG_RATE("LQ: try to switch to MIMO2\n"); IWL_DEBUG_RATE(priv, "LQ: try to switch to MIMO2\n");
tbl->lq_type = LQ_MIMO2; tbl->lq_type = LQ_MIMO2;
tbl->is_dup = lq_sta->is_dup; tbl->is_dup = lq_sta->is_dup;
@ -1179,16 +1179,16 @@ static int rs_switch_to_mimo2(struct iwl_priv *priv,
rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index); rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index);
IWL_DEBUG_RATE("LQ: MIMO2 best rate %d mask %X\n", rate, rate_mask); IWL_DEBUG_RATE(priv, "LQ: MIMO2 best rate %d mask %X\n", rate, rate_mask);
if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) { if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) {
IWL_DEBUG_RATE("Can't switch with index %d rate mask %x\n", IWL_DEBUG_RATE(priv, "Can't switch with index %d rate mask %x\n",
rate, rate_mask); rate, rate_mask);
return -1; return -1;
} }
tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, rate, is_green); tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, rate, is_green);
IWL_DEBUG_RATE("LQ: Switch to new mcs %X index is green %X\n", IWL_DEBUG_RATE(priv, "LQ: Switch to new mcs %X index is green %X\n",
tbl->current_rate, is_green); tbl->current_rate, is_green);
return 0; return 0;
} }
@ -1209,7 +1209,7 @@ static int rs_switch_to_siso(struct iwl_priv *priv,
if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported) if (!conf_is_ht(conf) || !sta->ht_cap.ht_supported)
return -1; return -1;
IWL_DEBUG_RATE("LQ: try to switch to SISO\n"); IWL_DEBUG_RATE(priv, "LQ: try to switch to SISO\n");
tbl->is_dup = lq_sta->is_dup; tbl->is_dup = lq_sta->is_dup;
tbl->lq_type = LQ_SISO; tbl->lq_type = LQ_SISO;
@ -1240,14 +1240,14 @@ static int rs_switch_to_siso(struct iwl_priv *priv,
rs_set_expected_tpt_table(lq_sta, tbl); rs_set_expected_tpt_table(lq_sta, tbl);
rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index); rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index);
IWL_DEBUG_RATE("LQ: get best rate %d mask %X\n", rate, rate_mask); IWL_DEBUG_RATE(priv, "LQ: get best rate %d mask %X\n", rate, rate_mask);
if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) { if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) {
IWL_DEBUG_RATE("can not switch with index %d rate mask %x\n", IWL_DEBUG_RATE(priv, "can not switch with index %d rate mask %x\n",
rate, rate_mask); rate, rate_mask);
return -1; return -1;
} }
tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, rate, is_green); tbl->current_rate = rate_n_flags_from_tbl(priv, tbl, rate, is_green);
IWL_DEBUG_RATE("LQ: Switch to new mcs %X index is green %X\n", IWL_DEBUG_RATE(priv, "LQ: Switch to new mcs %X index is green %X\n",
tbl->current_rate, is_green); tbl->current_rate, is_green);
return 0; return 0;
} }
@ -1276,7 +1276,7 @@ static int rs_move_legacy_other(struct iwl_priv *priv,
switch (tbl->action) { switch (tbl->action) {
case IWL_LEGACY_SWITCH_ANTENNA1: case IWL_LEGACY_SWITCH_ANTENNA1:
case IWL_LEGACY_SWITCH_ANTENNA2: case IWL_LEGACY_SWITCH_ANTENNA2:
IWL_DEBUG_RATE("LQ: Legacy toggle Antenna\n"); IWL_DEBUG_RATE(priv, "LQ: Legacy toggle Antenna\n");
lq_sta->action_counter++; lq_sta->action_counter++;
@ -1300,7 +1300,7 @@ static int rs_move_legacy_other(struct iwl_priv *priv,
} }
break; break;
case IWL_LEGACY_SWITCH_SISO: case IWL_LEGACY_SWITCH_SISO:
IWL_DEBUG_RATE("LQ: Legacy switch to SISO\n"); IWL_DEBUG_RATE(priv, "LQ: Legacy switch to SISO\n");
/* Set up search table to try SISO */ /* Set up search table to try SISO */
memcpy(search_tbl, tbl, sz); memcpy(search_tbl, tbl, sz);
@ -1316,7 +1316,7 @@ static int rs_move_legacy_other(struct iwl_priv *priv,
case IWL_LEGACY_SWITCH_MIMO2_AB: case IWL_LEGACY_SWITCH_MIMO2_AB:
case IWL_LEGACY_SWITCH_MIMO2_AC: case IWL_LEGACY_SWITCH_MIMO2_AC:
case IWL_LEGACY_SWITCH_MIMO2_BC: case IWL_LEGACY_SWITCH_MIMO2_BC:
IWL_DEBUG_RATE("LQ: Legacy switch to MIMO2\n"); IWL_DEBUG_RATE(priv, "LQ: Legacy switch to MIMO2\n");
/* Set up search table to try MIMO */ /* Set up search table to try MIMO */
memcpy(search_tbl, tbl, sz); memcpy(search_tbl, tbl, sz);
@ -1385,7 +1385,7 @@ static int rs_move_siso_to_other(struct iwl_priv *priv,
switch (tbl->action) { switch (tbl->action) {
case IWL_SISO_SWITCH_ANTENNA1: case IWL_SISO_SWITCH_ANTENNA1:
case IWL_SISO_SWITCH_ANTENNA2: case IWL_SISO_SWITCH_ANTENNA2:
IWL_DEBUG_RATE("LQ: SISO toggle Antenna\n"); IWL_DEBUG_RATE(priv, "LQ: SISO toggle Antenna\n");
if ((tbl->action == IWL_SISO_SWITCH_ANTENNA1 && if ((tbl->action == IWL_SISO_SWITCH_ANTENNA1 &&
tx_chains_num <= 1) || tx_chains_num <= 1) ||
@ -1404,7 +1404,7 @@ static int rs_move_siso_to_other(struct iwl_priv *priv,
case IWL_SISO_SWITCH_MIMO2_AB: case IWL_SISO_SWITCH_MIMO2_AB:
case IWL_SISO_SWITCH_MIMO2_AC: case IWL_SISO_SWITCH_MIMO2_AC:
case IWL_SISO_SWITCH_MIMO2_BC: case IWL_SISO_SWITCH_MIMO2_BC:
IWL_DEBUG_RATE("LQ: SISO switch to MIMO2\n"); IWL_DEBUG_RATE(priv, "LQ: SISO switch to MIMO2\n");
memcpy(search_tbl, tbl, sz); memcpy(search_tbl, tbl, sz);
search_tbl->is_SGI = 0; search_tbl->is_SGI = 0;
@ -1433,7 +1433,7 @@ static int rs_move_siso_to_other(struct iwl_priv *priv,
HT_SHORT_GI_40MHZ)) HT_SHORT_GI_40MHZ))
break; break;
IWL_DEBUG_RATE("LQ: SISO toggle SGI/NGI\n"); IWL_DEBUG_RATE(priv, "LQ: SISO toggle SGI/NGI\n");
memcpy(search_tbl, tbl, sz); memcpy(search_tbl, tbl, sz);
if (is_green) { if (is_green) {
@ -1498,7 +1498,7 @@ static int rs_move_mimo_to_other(struct iwl_priv *priv,
switch (tbl->action) { switch (tbl->action) {
case IWL_MIMO2_SWITCH_ANTENNA1: case IWL_MIMO2_SWITCH_ANTENNA1:
case IWL_MIMO2_SWITCH_ANTENNA2: case IWL_MIMO2_SWITCH_ANTENNA2:
IWL_DEBUG_RATE("LQ: MIMO toggle Antennas\n"); IWL_DEBUG_RATE(priv, "LQ: MIMO toggle Antennas\n");
if (tx_chains_num <= 2) if (tx_chains_num <= 2)
break; break;
@ -1514,7 +1514,7 @@ static int rs_move_mimo_to_other(struct iwl_priv *priv,
case IWL_MIMO2_SWITCH_SISO_A: case IWL_MIMO2_SWITCH_SISO_A:
case IWL_MIMO2_SWITCH_SISO_B: case IWL_MIMO2_SWITCH_SISO_B:
case IWL_MIMO2_SWITCH_SISO_C: case IWL_MIMO2_SWITCH_SISO_C:
IWL_DEBUG_RATE("LQ: MIMO2 switch to SISO\n"); IWL_DEBUG_RATE(priv, "LQ: MIMO2 switch to SISO\n");
/* Set up new search table for SISO */ /* Set up new search table for SISO */
memcpy(search_tbl, tbl, sz); memcpy(search_tbl, tbl, sz);
@ -1546,7 +1546,7 @@ static int rs_move_mimo_to_other(struct iwl_priv *priv,
HT_SHORT_GI_40MHZ)) HT_SHORT_GI_40MHZ))
break; break;
IWL_DEBUG_RATE("LQ: MIMO toggle SGI/NGI\n"); IWL_DEBUG_RATE(priv, "LQ: MIMO toggle SGI/NGI\n");
/* Set up new search table for MIMO */ /* Set up new search table for MIMO */
memcpy(search_tbl, tbl, sz); memcpy(search_tbl, tbl, sz);
@ -1629,7 +1629,7 @@ static void rs_stay_in_table(struct iwl_lq_sta *lq_sta)
(lq_sta->total_success > lq_sta->max_success_limit) || (lq_sta->total_success > lq_sta->max_success_limit) ||
((!lq_sta->search_better_tbl) && (lq_sta->flush_timer) ((!lq_sta->search_better_tbl) && (lq_sta->flush_timer)
&& (flush_interval_passed))) { && (flush_interval_passed))) {
IWL_DEBUG_RATE("LQ: stay is expired %d %d %d\n:", IWL_DEBUG_RATE(priv, "LQ: stay is expired %d %d %d\n:",
lq_sta->total_failed, lq_sta->total_failed,
lq_sta->total_success, lq_sta->total_success,
flush_interval_passed); flush_interval_passed);
@ -1652,7 +1652,7 @@ static void rs_stay_in_table(struct iwl_lq_sta *lq_sta)
lq_sta->table_count_limit) { lq_sta->table_count_limit) {
lq_sta->table_count = 0; lq_sta->table_count = 0;
IWL_DEBUG_RATE("LQ: stay in table clear win\n"); IWL_DEBUG_RATE(priv, "LQ: stay in table clear win\n");
for (i = 0; i < IWL_RATE_COUNT; i++) for (i = 0; i < IWL_RATE_COUNT; i++)
rs_rate_scale_clear_window( rs_rate_scale_clear_window(
&(tbl->win[i])); &(tbl->win[i]));
@ -1701,7 +1701,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
s32 sr; s32 sr;
u8 tid = MAX_TID_COUNT; u8 tid = MAX_TID_COUNT;
IWL_DEBUG_RATE("rate scale calculate new rate for skb\n"); IWL_DEBUG_RATE(priv, "rate scale calculate new rate for skb\n");
/* Send management frames and broadcast/multicast data using /* Send management frames and broadcast/multicast data using
* lowest rate. */ * lowest rate. */
@ -1733,13 +1733,13 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
/* current tx rate */ /* current tx rate */
index = lq_sta->last_txrate_idx; index = lq_sta->last_txrate_idx;
IWL_DEBUG_RATE("Rate scale index %d for type %d\n", index, IWL_DEBUG_RATE(priv, "Rate scale index %d for type %d\n", index,
tbl->lq_type); tbl->lq_type);
/* rates available for this association, and for modulation mode */ /* rates available for this association, and for modulation mode */
rate_mask = rs_get_supported_rates(lq_sta, hdr, tbl->lq_type); rate_mask = rs_get_supported_rates(lq_sta, hdr, tbl->lq_type);
IWL_DEBUG_RATE("mask 0x%04X \n", rate_mask); IWL_DEBUG_RATE(priv, "mask 0x%04X \n", rate_mask);
/* mask with station rate restriction */ /* mask with station rate restriction */
if (is_legacy(tbl->lq_type)) { if (is_legacy(tbl->lq_type)) {
@ -1789,7 +1789,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
fail_count = window->counter - window->success_counter; fail_count = window->counter - window->success_counter;
if ((fail_count < IWL_RATE_MIN_FAILURE_TH) && if ((fail_count < IWL_RATE_MIN_FAILURE_TH) &&
(window->success_counter < IWL_RATE_MIN_SUCCESS_TH)) { (window->success_counter < IWL_RATE_MIN_SUCCESS_TH)) {
IWL_DEBUG_RATE("LQ: still below TH. succ=%d total=%d " IWL_DEBUG_RATE(priv, "LQ: still below TH. succ=%d total=%d "
"for index %d\n", "for index %d\n",
window->success_counter, window->counter, index); window->success_counter, window->counter, index);
@ -1817,7 +1817,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
* continuing to use the setup that we've been trying. */ * continuing to use the setup that we've been trying. */
if (window->average_tpt > lq_sta->last_tpt) { if (window->average_tpt > lq_sta->last_tpt) {
IWL_DEBUG_RATE("LQ: SWITCHING TO NEW TABLE " IWL_DEBUG_RATE(priv, "LQ: SWITCHING TO NEW TABLE "
"suc=%d cur-tpt=%d old-tpt=%d\n", "suc=%d cur-tpt=%d old-tpt=%d\n",
window->success_ratio, window->success_ratio,
window->average_tpt, window->average_tpt,
@ -1833,7 +1833,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
/* Else poor success; go back to mode in "active" table */ /* Else poor success; go back to mode in "active" table */
} else { } else {
IWL_DEBUG_RATE("LQ: GOING BACK TO THE OLD TABLE " IWL_DEBUG_RATE(priv, "LQ: GOING BACK TO THE OLD TABLE "
"suc=%d cur-tpt=%d old-tpt=%d\n", "suc=%d cur-tpt=%d old-tpt=%d\n",
window->success_ratio, window->success_ratio,
window->average_tpt, window->average_tpt,
@ -1886,7 +1886,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
/* Too many failures, decrease rate */ /* Too many failures, decrease rate */
if ((sr <= IWL_RATE_DECREASE_TH) || (current_tpt == 0)) { if ((sr <= IWL_RATE_DECREASE_TH) || (current_tpt == 0)) {
IWL_DEBUG_RATE("decrease rate because of low success_ratio\n"); IWL_DEBUG_RATE(priv, "decrease rate because of low success_ratio\n");
scale_action = -1; scale_action = -1;
/* No throughput measured yet for adjacent rates; try increase. */ /* No throughput measured yet for adjacent rates; try increase. */
@ -1917,8 +1917,8 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
sr >= IWL_RATE_INCREASE_TH) { sr >= IWL_RATE_INCREASE_TH) {
scale_action = 1; scale_action = 1;
} else { } else {
IWL_DEBUG_RATE IWL_DEBUG_RATE(priv,
("decrease rate because of high tpt\n"); "decrease rate because of high tpt\n");
scale_action = -1; scale_action = -1;
} }
@ -1926,8 +1926,8 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
} else if (low_tpt != IWL_INVALID_VALUE) { } else if (low_tpt != IWL_INVALID_VALUE) {
/* Lower rate has better throughput */ /* Lower rate has better throughput */
if (low_tpt > current_tpt) { if (low_tpt > current_tpt) {
IWL_DEBUG_RATE IWL_DEBUG_RATE(priv,
("decrease rate because of low tpt\n"); "decrease rate because of low tpt\n");
scale_action = -1; scale_action = -1;
} else if (sr >= IWL_RATE_INCREASE_TH) { } else if (sr >= IWL_RATE_INCREASE_TH) {
scale_action = 1; scale_action = 1;
@ -1964,7 +1964,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
break; break;
} }
IWL_DEBUG_RATE("choose rate scale index %d action %d low %d " IWL_DEBUG_RATE(priv, "choose rate scale index %d action %d low %d "
"high %d type %d\n", "high %d type %d\n",
index, scale_action, low, high, tbl->lq_type); index, scale_action, low, high, tbl->lq_type);
@ -2008,7 +2008,7 @@ lq_update:
/* Use new "search" start rate */ /* Use new "search" start rate */
index = iwl_hwrate_to_plcp_idx(tbl->current_rate); index = iwl_hwrate_to_plcp_idx(tbl->current_rate);
IWL_DEBUG_RATE("Switch current mcs: %X index: %d\n", IWL_DEBUG_RATE(priv, "Switch current mcs: %X index: %d\n",
tbl->current_rate, index); tbl->current_rate, index);
rs_fill_link_cmd(priv, lq_sta, tbl->current_rate); rs_fill_link_cmd(priv, lq_sta, tbl->current_rate);
iwl_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC); iwl_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
@ -2023,7 +2023,7 @@ lq_update:
if (is_legacy(tbl1->lq_type) && !conf_is_ht(conf) && if (is_legacy(tbl1->lq_type) && !conf_is_ht(conf) &&
lq_sta->action_counter >= 1) { lq_sta->action_counter >= 1) {
lq_sta->action_counter = 0; lq_sta->action_counter = 0;
IWL_DEBUG_RATE("LQ: STAY in legacy table\n"); IWL_DEBUG_RATE(priv, "LQ: STAY in legacy table\n");
rs_set_stay_in_table(priv, 1, lq_sta); rs_set_stay_in_table(priv, 1, lq_sta);
} }
@ -2035,7 +2035,7 @@ lq_update:
if ((lq_sta->last_tpt > IWL_AGG_TPT_THREHOLD) && if ((lq_sta->last_tpt > IWL_AGG_TPT_THREHOLD) &&
(lq_sta->tx_agg_tid_en & (1 << tid)) && (lq_sta->tx_agg_tid_en & (1 << tid)) &&
(tid != MAX_TID_COUNT)) { (tid != MAX_TID_COUNT)) {
IWL_DEBUG_RATE("try to aggregate tid %d\n", tid); IWL_DEBUG_RATE(priv, "try to aggregate tid %d\n", tid);
rs_tl_turn_on_agg(priv, tid, lq_sta, sta); rs_tl_turn_on_agg(priv, tid, lq_sta, sta);
} }
lq_sta->action_counter = 0; lq_sta->action_counter = 0;
@ -2131,7 +2131,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
int rate_idx; int rate_idx;
u64 mask_bit = 0; u64 mask_bit = 0;
IWL_DEBUG_RATE_LIMIT("rate scale calculate new rate for skb\n"); IWL_DEBUG_RATE_LIMIT(priv, "rate scale calculate new rate for skb\n");
/* Get max rate if user set max rate */ /* Get max rate if user set max rate */
if (lq_sta) { if (lq_sta) {
@ -2167,7 +2167,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
u8 sta_id = iwl_find_station(priv, hdr->addr1); u8 sta_id = iwl_find_station(priv, hdr->addr1);
if (sta_id == IWL_INVALID_STATION) { if (sta_id == IWL_INVALID_STATION) {
IWL_DEBUG_RATE("LQ: ADD station %pM\n", IWL_DEBUG_RATE(priv, "LQ: ADD station %pM\n",
hdr->addr1); hdr->addr1);
sta_id = iwl_add_station_flags(priv, hdr->addr1, sta_id = iwl_add_station_flags(priv, hdr->addr1,
0, CMD_ASYNC, NULL); 0, CMD_ASYNC, NULL);
@ -2196,7 +2196,7 @@ static void *rs_alloc_sta(void *priv_rate, struct ieee80211_sta *sta,
int i, j; int i, j;
priv = (struct iwl_priv *)priv_rate; priv = (struct iwl_priv *)priv_rate;
IWL_DEBUG_RATE("create station rate scale window\n"); IWL_DEBUG_RATE(priv, "create station rate scale window\n");
lq_sta = kzalloc(sizeof(struct iwl_lq_sta), gfp); lq_sta = kzalloc(sizeof(struct iwl_lq_sta), gfp);
@ -2229,7 +2229,7 @@ static void rs_rate_init(void *priv_r, struct ieee80211_supported_band *sband,
for (i = 0; i < IWL_RATE_COUNT; i++) for (i = 0; i < IWL_RATE_COUNT; i++)
rs_rate_scale_clear_window(&lq_sta->lq_info[j].win[i]); rs_rate_scale_clear_window(&lq_sta->lq_info[j].win[i]);
IWL_DEBUG_RATE("LQ: *** rate scale station global init ***\n"); IWL_DEBUG_RATE(priv, "LQ: *** rate scale station global init ***\n");
/* TODO: what is a good starting rate for STA? About middle? Maybe not /* TODO: what is a good starting rate for STA? About middle? Maybe not
* the lowest or the highest rate.. Could consider using RSSI from * the lowest or the highest rate.. Could consider using RSSI from
* previous packets? Need to have IEEE 802.1X auth succeed immediately * previous packets? Need to have IEEE 802.1X auth succeed immediately
@ -2240,10 +2240,10 @@ static void rs_rate_init(void *priv_r, struct ieee80211_supported_band *sband,
u8 sta_id = iwl_find_station(priv, sta->addr); u8 sta_id = iwl_find_station(priv, sta->addr);
/* for IBSS the call are from tasklet */ /* for IBSS the call are from tasklet */
IWL_DEBUG_RATE("LQ: ADD station %pM\n", sta->addr); IWL_DEBUG_RATE(priv, "LQ: ADD station %pM\n", sta->addr);
if (sta_id == IWL_INVALID_STATION) { if (sta_id == IWL_INVALID_STATION) {
IWL_DEBUG_RATE("LQ: ADD station %pM\n", sta->addr); IWL_DEBUG_RATE(priv, "LQ: ADD station %pM\n", sta->addr);
sta_id = iwl_add_station_flags(priv, sta->addr, sta_id = iwl_add_station_flags(priv, sta->addr,
0, CMD_ASYNC, NULL); 0, CMD_ASYNC, NULL);
} }
@ -2282,7 +2282,7 @@ static void rs_rate_init(void *priv_r, struct ieee80211_supported_band *sband,
lq_sta->active_mimo3_rate &= ~((u16)0x2); lq_sta->active_mimo3_rate &= ~((u16)0x2);
lq_sta->active_mimo3_rate <<= IWL_FIRST_OFDM_RATE; lq_sta->active_mimo3_rate <<= IWL_FIRST_OFDM_RATE;
IWL_DEBUG_RATE("SISO-RATE=%X MIMO2-RATE=%X MIMO3-RATE=%X\n", IWL_DEBUG_RATE(priv, "SISO-RATE=%X MIMO2-RATE=%X MIMO3-RATE=%X\n",
lq_sta->active_siso_rate, lq_sta->active_siso_rate,
lq_sta->active_mimo2_rate, lq_sta->active_mimo2_rate,
lq_sta->active_mimo3_rate); lq_sta->active_mimo3_rate);
@ -2448,9 +2448,9 @@ static void rs_free_sta(void *priv_r, struct ieee80211_sta *sta,
struct iwl_lq_sta *lq_sta = priv_sta; struct iwl_lq_sta *lq_sta = priv_sta;
struct iwl_priv *priv __maybe_unused = priv_r; struct iwl_priv *priv __maybe_unused = priv_r;
IWL_DEBUG_RATE("enter\n"); IWL_DEBUG_RATE(priv, "enter\n");
kfree(lq_sta); kfree(lq_sta);
IWL_DEBUG_RATE("leave\n"); IWL_DEBUG_RATE(priv, "leave\n");
} }
@ -2475,9 +2475,9 @@ static void rs_dbgfs_set_mcs(struct iwl_lq_sta *lq_sta,
else else
*rate_n_flags = 0x820A; *rate_n_flags = 0x820A;
} }
IWL_DEBUG_RATE("Fixed rate ON\n"); IWL_DEBUG_RATE(priv, "Fixed rate ON\n");
} else { } else {
IWL_DEBUG_RATE("Fixed rate OFF\n"); IWL_DEBUG_RATE(priv, "Fixed rate OFF\n");
} }
} }
@ -2506,7 +2506,7 @@ static ssize_t rs_sta_dbgfs_scale_table_write(struct file *file,
lq_sta->active_mimo2_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */ lq_sta->active_mimo2_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
lq_sta->active_mimo3_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */ lq_sta->active_mimo3_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
IWL_DEBUG_RATE("sta_id %d rate 0x%X\n", IWL_DEBUG_RATE(priv, "sta_id %d rate 0x%X\n",
lq_sta->lq.sta_id, lq_sta->dbg_fixed_rate); lq_sta->lq.sta_id, lq_sta->dbg_fixed_rate);
if (lq_sta->dbg_fixed_rate) { if (lq_sta->dbg_fixed_rate) {

644
drivers/net/wireless/iwlwifi/iwl-agn.c
View File

File diff suppressed because it is too large Load Diff

85
drivers/net/wireless/iwlwifi/iwl-calib.c
View File

@ -202,7 +202,7 @@ static int iwl_sens_energy_cck(struct iwl_priv *priv,
val = data->nrg_silence_rssi[i]; val = data->nrg_silence_rssi[i];
silence_ref = max(silence_ref, val); silence_ref = max(silence_ref, val);
} }
IWL_DEBUG_CALIB("silence a %u, b %u, c %u, 20-bcn max %u\n", IWL_DEBUG_CALIB(priv, "silence a %u, b %u, c %u, 20-bcn max %u\n",
silence_rssi_a, silence_rssi_b, silence_rssi_c, silence_rssi_a, silence_rssi_b, silence_rssi_c,
silence_ref); silence_ref);
@ -226,7 +226,7 @@ static int iwl_sens_energy_cck(struct iwl_priv *priv,
max_nrg_cck = (u32) max(max_nrg_cck, (data->nrg_value[i])); max_nrg_cck = (u32) max(max_nrg_cck, (data->nrg_value[i]));
max_nrg_cck += 6; max_nrg_cck += 6;
IWL_DEBUG_CALIB("rx energy a %u, b %u, c %u, 10-bcn max/min %u\n", IWL_DEBUG_CALIB(priv, "rx energy a %u, b %u, c %u, 10-bcn max/min %u\n",
rx_info->beacon_energy_a, rx_info->beacon_energy_b, rx_info->beacon_energy_a, rx_info->beacon_energy_b,
rx_info->beacon_energy_c, max_nrg_cck - 6); rx_info->beacon_energy_c, max_nrg_cck - 6);
@ -236,15 +236,15 @@ static int iwl_sens_energy_cck(struct iwl_priv *priv,
data->num_in_cck_no_fa++; data->num_in_cck_no_fa++;
else else
data->num_in_cck_no_fa = 0; data->num_in_cck_no_fa = 0;
IWL_DEBUG_CALIB("consecutive bcns with few false alarms = %u\n", IWL_DEBUG_CALIB(priv, "consecutive bcns with few false alarms = %u\n",
data->num_in_cck_no_fa); data->num_in_cck_no_fa);
/* If we got too many false alarms this time, reduce sensitivity */ /* If we got too many false alarms this time, reduce sensitivity */
if ((false_alarms > max_false_alarms) && if ((false_alarms > max_false_alarms) &&
(data->auto_corr_cck > AUTO_CORR_MAX_TH_CCK)) { (data->auto_corr_cck > AUTO_CORR_MAX_TH_CCK)) {
IWL_DEBUG_CALIB("norm FA %u > max FA %u\n", IWL_DEBUG_CALIB(priv, "norm FA %u > max FA %u\n",
false_alarms, max_false_alarms); false_alarms, max_false_alarms);
IWL_DEBUG_CALIB("... reducing sensitivity\n"); IWL_DEBUG_CALIB(priv, "... reducing sensitivity\n");
data->nrg_curr_state = IWL_FA_TOO_MANY; data->nrg_curr_state = IWL_FA_TOO_MANY;
/* Store for "fewer than desired" on later beacon */ /* Store for "fewer than desired" on later beacon */
data->nrg_silence_ref = silence_ref; data->nrg_silence_ref = silence_ref;
@ -266,7 +266,7 @@ static int iwl_sens_energy_cck(struct iwl_priv *priv,
data->nrg_auto_corr_silence_diff = (s32)data->nrg_silence_ref - data->nrg_auto_corr_silence_diff = (s32)data->nrg_silence_ref -
(s32)silence_ref; (s32)silence_ref;
IWL_DEBUG_CALIB("norm FA %u < min FA %u, silence diff %d\n", IWL_DEBUG_CALIB(priv, "norm FA %u < min FA %u, silence diff %d\n",
false_alarms, min_false_alarms, false_alarms, min_false_alarms,
data->nrg_auto_corr_silence_diff); data->nrg_auto_corr_silence_diff);
@ -280,17 +280,17 @@ static int iwl_sens_energy_cck(struct iwl_priv *priv,
((data->nrg_auto_corr_silence_diff > NRG_DIFF) || ((data->nrg_auto_corr_silence_diff > NRG_DIFF) ||
(data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA))) { (data->num_in_cck_no_fa > MAX_NUMBER_CCK_NO_FA))) {
IWL_DEBUG_CALIB("... increasing sensitivity\n"); IWL_DEBUG_CALIB(priv, "... increasing sensitivity\n");
/* Increase nrg value to increase sensitivity */ /* Increase nrg value to increase sensitivity */
val = data->nrg_th_cck + NRG_STEP_CCK; val = data->nrg_th_cck + NRG_STEP_CCK;
data->nrg_th_cck = min((u32)ranges->min_nrg_cck, val); data->nrg_th_cck = min((u32)ranges->min_nrg_cck, val);
} else { } else {
IWL_DEBUG_CALIB("... but not changing sensitivity\n"); IWL_DEBUG_CALIB(priv, "... but not changing sensitivity\n");
} }
/* Else we got a healthy number of false alarms, keep status quo */ /* Else we got a healthy number of false alarms, keep status quo */
} else { } else {
IWL_DEBUG_CALIB(" FA in safe zone\n"); IWL_DEBUG_CALIB(priv, " FA in safe zone\n");
data->nrg_curr_state = IWL_FA_GOOD_RANGE; data->nrg_curr_state = IWL_FA_GOOD_RANGE;
/* Store for use in "fewer than desired" with later beacon */ /* Store for use in "fewer than desired" with later beacon */
@ -300,7 +300,7 @@ static int iwl_sens_energy_cck(struct iwl_priv *priv,
* give it some extra margin by reducing sensitivity again * give it some extra margin by reducing sensitivity again
* (but don't go below measured energy of desired Rx) */ * (but don't go below measured energy of desired Rx) */
if (IWL_FA_TOO_MANY == data->nrg_prev_state) { if (IWL_FA_TOO_MANY == data->nrg_prev_state) {
IWL_DEBUG_CALIB("... increasing margin\n"); IWL_DEBUG_CALIB(priv, "... increasing margin\n");
if (data->nrg_th_cck > (max_nrg_cck + NRG_MARGIN)) if (data->nrg_th_cck > (max_nrg_cck + NRG_MARGIN))
data->nrg_th_cck -= NRG_MARGIN; data->nrg_th_cck -= NRG_MARGIN;
else else
@ -314,7 +314,7 @@ static int iwl_sens_energy_cck(struct iwl_priv *priv,
* Lower value is higher energy, so we use max()! * Lower value is higher energy, so we use max()!
*/ */
data->nrg_th_cck = max(max_nrg_cck, data->nrg_th_cck); data->nrg_th_cck = max(max_nrg_cck, data->nrg_th_cck);
IWL_DEBUG_CALIB("new nrg_th_cck %u\n", data->nrg_th_cck); IWL_DEBUG_CALIB(priv, "new nrg_th_cck %u\n", data->nrg_th_cck);
data->nrg_prev_state = data->nrg_curr_state; data->nrg_prev_state = data->nrg_curr_state;
@ -367,7 +367,7 @@ static int iwl_sens_auto_corr_ofdm(struct iwl_priv *priv,
/* If we got too many false alarms this time, reduce sensitivity */ /* If we got too many false alarms this time, reduce sensitivity */
if (false_alarms > max_false_alarms) { if (false_alarms > max_false_alarms) {
IWL_DEBUG_CALIB("norm FA %u > max FA %u)\n", IWL_DEBUG_CALIB(priv, "norm FA %u > max FA %u)\n",
false_alarms, max_false_alarms); false_alarms, max_false_alarms);
val = data->auto_corr_ofdm + AUTO_CORR_STEP_OFDM; val = data->auto_corr_ofdm + AUTO_CORR_STEP_OFDM;
@ -390,7 +390,7 @@ static int iwl_sens_auto_corr_ofdm(struct iwl_priv *priv,
/* Else if we got fewer than desired, increase sensitivity */ /* Else if we got fewer than desired, increase sensitivity */
else if (false_alarms < min_false_alarms) { else if (false_alarms < min_false_alarms) {
IWL_DEBUG_CALIB("norm FA %u < min FA %u\n", IWL_DEBUG_CALIB(priv, "norm FA %u < min FA %u\n",
false_alarms, min_false_alarms); false_alarms, min_false_alarms);
val = data->auto_corr_ofdm - AUTO_CORR_STEP_OFDM; val = data->auto_corr_ofdm - AUTO_CORR_STEP_OFDM;
@ -409,7 +409,7 @@ static int iwl_sens_auto_corr_ofdm(struct iwl_priv *priv,
data->auto_corr_ofdm_mrc_x1 = data->auto_corr_ofdm_mrc_x1 =
max((u32)ranges->auto_corr_min_ofdm_mrc_x1, val); max((u32)ranges->auto_corr_min_ofdm_mrc_x1, val);
} else { } else {
IWL_DEBUG_CALIB("min FA %u < norm FA %u < max FA %u OK\n", IWL_DEBUG_CALIB(priv, "min FA %u < norm FA %u < max FA %u OK\n",
min_false_alarms, false_alarms, max_false_alarms); min_false_alarms, false_alarms, max_false_alarms);
} }
return 0; return 0;
@ -452,18 +452,18 @@ static int iwl_sensitivity_write(struct iwl_priv *priv)
cpu_to_le16((u16)data->nrg_th_ofdm); cpu_to_le16((u16)data->nrg_th_ofdm);
cmd.table[HD_BARKER_CORR_TH_ADD_MIN_INDEX] = cmd.table[HD_BARKER_CORR_TH_ADD_MIN_INDEX] =
__constant_cpu_to_le16(190); cpu_to_le16(190);
cmd.table[HD_BARKER_CORR_TH_ADD_MIN_MRC_INDEX] = cmd.table[HD_BARKER_CORR_TH_ADD_MIN_MRC_INDEX] =
__constant_cpu_to_le16(390); cpu_to_le16(390);
cmd.table[HD_OFDM_ENERGY_TH_IN_INDEX] = cmd.table[HD_OFDM_ENERGY_TH_IN_INDEX] =
__constant_cpu_to_le16(62); cpu_to_le16(62);
IWL_DEBUG_CALIB("ofdm: ac %u mrc %u x1 %u mrc_x1 %u thresh %u\n", IWL_DEBUG_CALIB(priv, "ofdm: ac %u mrc %u x1 %u mrc_x1 %u thresh %u\n",
data->auto_corr_ofdm, data->auto_corr_ofdm_mrc, data->auto_corr_ofdm, data->auto_corr_ofdm_mrc,
data->auto_corr_ofdm_x1, data->auto_corr_ofdm_mrc_x1, data->auto_corr_ofdm_x1, data->auto_corr_ofdm_mrc_x1,
data->nrg_th_ofdm); data->nrg_th_ofdm);
IWL_DEBUG_CALIB("cck: ac %u mrc %u thresh %u\n", IWL_DEBUG_CALIB(priv, "cck: ac %u mrc %u thresh %u\n",
data->auto_corr_cck, data->auto_corr_cck_mrc, data->auto_corr_cck, data->auto_corr_cck_mrc,
data->nrg_th_cck); data->nrg_th_cck);
@ -473,7 +473,7 @@ static int iwl_sensitivity_write(struct iwl_priv *priv)
/* Don't send command to uCode if nothing has changed */ /* Don't send command to uCode if nothing has changed */
if (!memcmp(&cmd.table[0], &(priv->sensitivity_tbl[0]), if (!memcmp(&cmd.table[0], &(priv->sensitivity_tbl[0]),
sizeof(u16)*HD_TABLE_SIZE)) { sizeof(u16)*HD_TABLE_SIZE)) {
IWL_DEBUG_CALIB("No change in SENSITIVITY_CMD\n"); IWL_DEBUG_CALIB(priv, "No change in SENSITIVITY_CMD\n");
return 0; return 0;
} }
@ -498,7 +498,7 @@ void iwl_init_sensitivity(struct iwl_priv *priv)
if (priv->disable_sens_cal) if (priv->disable_sens_cal)
return; return;
IWL_DEBUG_CALIB("Start iwl_init_sensitivity\n"); IWL_DEBUG_CALIB(priv, "Start iwl_init_sensitivity\n");
/* Clear driver's sensitivity algo data */ /* Clear driver's sensitivity algo data */
data = &(priv->sensitivity_data); data = &(priv->sensitivity_data);
@ -536,7 +536,7 @@ void iwl_init_sensitivity(struct iwl_priv *priv)
data->last_fa_cnt_cck = 0; data->last_fa_cnt_cck = 0;
ret |= iwl_sensitivity_write(priv); ret |= iwl_sensitivity_write(priv);
IWL_DEBUG_CALIB("<<return 0x%X\n", ret); IWL_DEBUG_CALIB(priv, "<<return 0x%X\n", ret);
} }
EXPORT_SYMBOL(iwl_init_sensitivity); EXPORT_SYMBOL(iwl_init_sensitivity);
@ -562,13 +562,13 @@ void iwl_sensitivity_calibration(struct iwl_priv *priv,
data = &(priv->sensitivity_data); data = &(priv->sensitivity_data);
if (!iwl_is_associated(priv)) { if (!iwl_is_associated(priv)) {
IWL_DEBUG_CALIB("<< - not associated\n"); IWL_DEBUG_CALIB(priv, "<< - not associated\n");
return; return;
} }
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) { if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
IWL_DEBUG_CALIB("<< invalid data.\n"); IWL_DEBUG_CALIB(priv, "<< invalid data.\n");
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
return; return;
} }
@ -595,10 +595,10 @@ void iwl_sensitivity_calibration(struct iwl_priv *priv,
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
IWL_DEBUG_CALIB("rx_enable_time = %u usecs\n", rx_enable_time); IWL_DEBUG_CALIB(priv, "rx_enable_time = %u usecs\n", rx_enable_time);
if (!rx_enable_time) { if (!rx_enable_time) {
IWL_DEBUG_CALIB("<< RX Enable Time == 0! \n"); IWL_DEBUG_CALIB(priv, "<< RX Enable Time == 0! \n");
return; return;
} }
@ -637,7 +637,7 @@ void iwl_sensitivity_calibration(struct iwl_priv *priv,
norm_fa_ofdm = fa_ofdm + bad_plcp_ofdm; norm_fa_ofdm = fa_ofdm + bad_plcp_ofdm;
norm_fa_cck = fa_cck + bad_plcp_cck; norm_fa_cck = fa_cck + bad_plcp_cck;
IWL_DEBUG_CALIB("cck: fa %u badp %u ofdm: fa %u badp %u\n", fa_cck, IWL_DEBUG_CALIB(priv, "cck: fa %u badp %u ofdm: fa %u badp %u\n", fa_cck,
bad_plcp_cck, fa_ofdm, bad_plcp_ofdm); bad_plcp_cck, fa_ofdm, bad_plcp_ofdm);
iwl_sens_auto_corr_ofdm(priv, norm_fa_ofdm, rx_enable_time); iwl_sens_auto_corr_ofdm(priv, norm_fa_ofdm, rx_enable_time);
@ -690,13 +690,13 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
* then we're done forever. */ * then we're done forever. */
if (data->state != IWL_CHAIN_NOISE_ACCUMULATE) { if (data->state != IWL_CHAIN_NOISE_ACCUMULATE) {
if (data->state == IWL_CHAIN_NOISE_ALIVE) if (data->state == IWL_CHAIN_NOISE_ALIVE)
IWL_DEBUG_CALIB("Wait for noise calib reset\n"); IWL_DEBUG_CALIB(priv, "Wait for noise calib reset\n");
return; return;
} }
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) { if (rx_info->interference_data_flag != INTERFERENCE_DATA_AVAILABLE) {
IWL_DEBUG_CALIB(" << Interference data unavailable\n"); IWL_DEBUG_CALIB(priv, " << Interference data unavailable\n");
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
return; return;
} }
@ -709,7 +709,7 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
/* Make sure we accumulate data for just the associated channel /* Make sure we accumulate data for just the associated channel
* (even if scanning). */ * (even if scanning). */
if ((rxon_chnum != stat_chnum) || (rxon_band24 != stat_band24)) { if ((rxon_chnum != stat_chnum) || (rxon_band24 != stat_band24)) {
IWL_DEBUG_CALIB("Stats not from chan=%d, band24=%d\n", IWL_DEBUG_CALIB(priv, "Stats not from chan=%d, band24=%d\n",
rxon_chnum, rxon_band24); rxon_chnum, rxon_band24);
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
return; return;
@ -739,11 +739,11 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
data->chain_signal_b = (chain_sig_b + data->chain_signal_b); data->chain_signal_b = (chain_sig_b + data->chain_signal_b);
data->chain_signal_c = (chain_sig_c + data->chain_signal_c); data->chain_signal_c = (chain_sig_c + data->chain_signal_c);
IWL_DEBUG_CALIB("chan=%d, band24=%d, beacon=%d\n", IWL_DEBUG_CALIB(priv, "chan=%d, band24=%d, beacon=%d\n",
rxon_chnum, rxon_band24, data->beacon_count); rxon_chnum, rxon_band24, data->beacon_count);
IWL_DEBUG_CALIB("chain_sig: a %d b %d c %d\n", IWL_DEBUG_CALIB(priv, "chain_sig: a %d b %d c %d\n",
chain_sig_a, chain_sig_b, chain_sig_c); chain_sig_a, chain_sig_b, chain_sig_c);
IWL_DEBUG_CALIB("chain_noise: a %d b %d c %d\n", IWL_DEBUG_CALIB(priv, "chain_noise: a %d b %d c %d\n",
chain_noise_a, chain_noise_b, chain_noise_c); chain_noise_a, chain_noise_b, chain_noise_c);
/* If this is the 20th beacon, determine: /* If this is the 20th beacon, determine:
@ -773,9 +773,9 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
active_chains = (1 << max_average_sig_antenna_i); active_chains = (1 << max_average_sig_antenna_i);
} }
IWL_DEBUG_CALIB("average_sig: a %d b %d c %d\n", IWL_DEBUG_CALIB(priv, "average_sig: a %d b %d c %d\n",
average_sig[0], average_sig[1], average_sig[2]); average_sig[0], average_sig[1], average_sig[2]);
IWL_DEBUG_CALIB("max_average_sig = %d, antenna %d\n", IWL_DEBUG_CALIB(priv, "max_average_sig = %d, antenna %d\n",
max_average_sig, max_average_sig_antenna_i); max_average_sig, max_average_sig_antenna_i);
/* Compare signal strengths for all 3 receivers. */ /* Compare signal strengths for all 3 receivers. */
@ -789,7 +789,7 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
data->disconn_array[i] = 1; data->disconn_array[i] = 1;
else else
active_chains |= (1 << i); active_chains |= (1 << i);
IWL_DEBUG_CALIB("i = %d rssiDelta = %d " IWL_DEBUG_CALIB(priv, "i = %d rssiDelta = %d "
"disconn_array[i] = %d\n", "disconn_array[i] = %d\n",
i, rssi_delta, data->disconn_array[i]); i, rssi_delta, data->disconn_array[i]);
} }
@ -813,7 +813,7 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
* disconnected connect it anyway */ * disconnected connect it anyway */
data->disconn_array[i] = 0; data->disconn_array[i] = 0;
active_chains |= ant_msk; active_chains |= ant_msk;
IWL_DEBUG_CALIB("All Tx chains are disconnected W/A - " IWL_DEBUG_CALIB(priv, "All Tx chains are disconnected W/A - "
"declare %d as connected\n", i); "declare %d as connected\n", i);
break; break;
} }
@ -821,7 +821,7 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
/* Save for use within RXON, TX, SCAN commands, etc. */ /* Save for use within RXON, TX, SCAN commands, etc. */
priv->chain_noise_data.active_chains = active_chains; priv->chain_noise_data.active_chains = active_chains;
IWL_DEBUG_CALIB("active_chains (bitwise) = 0x%x\n", IWL_DEBUG_CALIB(priv, "active_chains (bitwise) = 0x%x\n",
active_chains); active_chains);
/* Analyze noise for rx balance */ /* Analyze noise for rx balance */
@ -839,15 +839,16 @@ void iwl_chain_noise_calibration(struct iwl_priv *priv,
} }
} }
IWL_DEBUG_CALIB("average_noise: a %d b %d c %d\n", IWL_DEBUG_CALIB(priv, "average_noise: a %d b %d c %d\n",
average_noise[0], average_noise[1], average_noise[0], average_noise[1],
average_noise[2]); average_noise[2]);
IWL_DEBUG_CALIB("min_average_noise = %d, antenna %d\n", IWL_DEBUG_CALIB(priv, "min_average_noise = %d, antenna %d\n",
min_average_noise, min_average_noise_antenna_i); min_average_noise, min_average_noise_antenna_i);
priv->cfg->ops->utils->gain_computation(priv, average_noise, if (priv->cfg->ops->utils->gain_computation)
min_average_noise_antenna_i, min_average_noise); priv->cfg->ops->utils->gain_computation(priv, average_noise,
min_average_noise_antenna_i, min_average_noise);
/* Some power changes may have been made during the calibration. /* Some power changes may have been made during the calibration.
* Update and commit the RXON * Update and commit the RXON

6
drivers/net/wireless/iwlwifi/iwl-commands.h
View File

@ -144,9 +144,11 @@ enum {
WHO_IS_AWAKE_NOTIFICATION = 0x94, /* not used */ WHO_IS_AWAKE_NOTIFICATION = 0x94, /* not used */
/* Miscellaneous commands */ /* Miscellaneous commands */
REPLY_TX_POWER_DBM_CMD = 0x95,
QUIET_NOTIFICATION = 0x96, /* not used */ QUIET_NOTIFICATION = 0x96, /* not used */
REPLY_TX_PWR_TABLE_CMD = 0x97, REPLY_TX_PWR_TABLE_CMD = 0x97,
REPLY_TX_POWER_DBM_CMD = 0x98, REPLY_TX_POWER_DBM_CMD_V1 = 0x98, /* old version of API */
TX_ANT_CONFIGURATION_CMD = 0x98, /* not used */
MEASURE_ABORT_NOTIFICATION = 0x99, /* not used */ MEASURE_ABORT_NOTIFICATION = 0x99, /* not used */
/* Bluetooth device coexistence config command */ /* Bluetooth device coexistence config command */
@ -2846,7 +2848,7 @@ struct statistics_rx_ht_phy {
__le32 reserved2; __le32 reserved2;
} __attribute__ ((packed)); } __attribute__ ((packed));
#define INTERFERENCE_DATA_AVAILABLE __constant_cpu_to_le32(1) #define INTERFERENCE_DATA_AVAILABLE cpu_to_le32(1)
struct statistics_rx_non_phy { struct statistics_rx_non_phy {
__le32 bogus_cts; /* CTS received when not expecting CTS */ __le32 bogus_cts; /* CTS received when not expecting CTS */

482
drivers/net/wireless/iwlwifi/iwl-core.c
View File

@ -28,6 +28,7 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/etherdevice.h>
#include <net/mac80211.h> #include <net/mac80211.h>
#include "iwl-eeprom.h" #include "iwl-eeprom.h"
@ -322,7 +323,7 @@ void iwl_reset_qos(struct iwl_priv *priv)
priv->qos_data.def_qos_parm.ac[i].reserved1 = 0; priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;
} }
} }
IWL_DEBUG_QOS("set QoS to default \n"); IWL_DEBUG_QOS(priv, "set QoS to default \n");
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
} }
@ -403,6 +404,7 @@ static void iwlcore_init_hw_rates(struct iwl_priv *priv,
} }
} }
/** /**
* iwlcore_init_geos - Initialize mac80211's geo/channel info based from eeprom * iwlcore_init_geos - Initialize mac80211's geo/channel info based from eeprom
*/ */
@ -417,7 +419,7 @@ int iwlcore_init_geos(struct iwl_priv *priv)
if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates || if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) { priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
IWL_DEBUG_INFO("Geography modes already initialized.\n"); IWL_DEBUG_INFO(priv, "Geography modes already initialized.\n");
set_bit(STATUS_GEO_CONFIGURED, &priv->status); set_bit(STATUS_GEO_CONFIGURED, &priv->status);
return 0; return 0;
} }
@ -499,7 +501,7 @@ int iwlcore_init_geos(struct iwl_priv *priv)
/* Save flags for reg domain usage */ /* Save flags for reg domain usage */
geo_ch->orig_flags = geo_ch->flags; geo_ch->orig_flags = geo_ch->flags;
IWL_DEBUG_INFO("Channel %d Freq=%d[%sGHz] %s flag=0x%X\n", IWL_DEBUG_INFO(priv, "Channel %d Freq=%d[%sGHz] %s flag=0x%X\n",
ch->channel, geo_ch->center_freq, ch->channel, geo_ch->center_freq,
is_channel_a_band(ch) ? "5.2" : "2.4", is_channel_a_band(ch) ? "5.2" : "2.4",
geo_ch->flags & IEEE80211_CHAN_DISABLED ? geo_ch->flags & IEEE80211_CHAN_DISABLED ?
@ -586,6 +588,167 @@ u8 iwl_is_fat_tx_allowed(struct iwl_priv *priv,
} }
EXPORT_SYMBOL(iwl_is_fat_tx_allowed); EXPORT_SYMBOL(iwl_is_fat_tx_allowed);
void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
{
struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
if (hw_decrypt)
rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
else
rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
}
EXPORT_SYMBOL(iwl_set_rxon_hwcrypto);
/**
* iwl_check_rxon_cmd - validate RXON structure is valid
*
* NOTE: This is really only useful during development and can eventually
* be #ifdef'd out once the driver is stable and folks aren't actively
* making changes
*/
int iwl_check_rxon_cmd(struct iwl_priv *priv)
{
int error = 0;
int counter = 1;
struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
error |= le32_to_cpu(rxon->flags &
(RXON_FLG_TGJ_NARROW_BAND_MSK |
RXON_FLG_RADAR_DETECT_MSK));
if (error)
IWL_WARN(priv, "check 24G fields %d | %d\n",
counter++, error);
} else {
error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
if (error)
IWL_WARN(priv, "check 52 fields %d | %d\n",
counter++, error);
error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
if (error)
IWL_WARN(priv, "check 52 CCK %d | %d\n",
counter++, error);
}
error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
if (error)
IWL_WARN(priv, "check mac addr %d | %d\n", counter++, error);
/* make sure basic rates 6Mbps and 1Mbps are supported */
error |= (((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0) &&
((rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0));
if (error)
IWL_WARN(priv, "check basic rate %d | %d\n", counter++, error);
error |= (le16_to_cpu(rxon->assoc_id) > 2007);
if (error)
IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);
error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
== (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
if (error)
IWL_WARN(priv, "check CCK and short slot %d | %d\n",
counter++, error);
error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK))
== (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK));
if (error)
IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
counter++, error);
error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
if (error)
IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
counter++, error);
if (error)
IWL_WARN(priv, "Tuning to channel %d\n",
le16_to_cpu(rxon->channel));
if (error) {
IWL_ERR(priv, "Not a valid iwl_rxon_assoc_cmd field values\n");
return -1;
}
return 0;
}
EXPORT_SYMBOL(iwl_check_rxon_cmd);
/**
* iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
* @priv: staging_rxon is compared to active_rxon
*
* If the RXON structure is changing enough to require a new tune,
* or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
* a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
*/
int iwl_full_rxon_required(struct iwl_priv *priv)
{
/* These items are only settable from the full RXON command */
if (!(iwl_is_associated(priv)) ||
compare_ether_addr(priv->staging_rxon.bssid_addr,
priv->active_rxon.bssid_addr) ||
compare_ether_addr(priv->staging_rxon.node_addr,
priv->active_rxon.node_addr) ||
compare_ether_addr(priv->staging_rxon.wlap_bssid_addr,
priv->active_rxon.wlap_bssid_addr) ||
(priv->staging_rxon.dev_type != priv->active_rxon.dev_type) ||
(priv->staging_rxon.channel != priv->active_rxon.channel) ||
(priv->staging_rxon.air_propagation !=
priv->active_rxon.air_propagation) ||
(priv->staging_rxon.ofdm_ht_single_stream_basic_rates !=
priv->active_rxon.ofdm_ht_single_stream_basic_rates) ||
(priv->staging_rxon.ofdm_ht_dual_stream_basic_rates !=
priv->active_rxon.ofdm_ht_dual_stream_basic_rates) ||
(priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
return 1;
/* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
* be updated with the RXON_ASSOC command -- however only some
* flag transitions are allowed using RXON_ASSOC */
/* Check if we are not switching bands */
if ((priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
(priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK))
return 1;
/* Check if we are switching association toggle */
if ((priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
(priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
return 1;
return 0;
}
EXPORT_SYMBOL(iwl_full_rxon_required);
u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv)
{
int i;
int rate_mask;
/* Set rate mask*/
if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
else
rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
/* Find lowest valid rate */
for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
i = iwl_rates[i].next_ieee) {
if (rate_mask & (1 << i))
return iwl_rates[i].plcp;
}
/* No valid rate was found. Assign the lowest one */
if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
return IWL_RATE_1M_PLCP;
else
return IWL_RATE_6M_PLCP;
}
EXPORT_SYMBOL(iwl_rate_get_lowest_plcp);
void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info) void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info)
{ {
struct iwl_rxon_cmd *rxon = &priv->staging_rxon; struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
@ -627,7 +790,7 @@ void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info)
iwl_set_rxon_chain(priv); iwl_set_rxon_chain(priv);
IWL_DEBUG_ASSOC("supported HT rate 0x%X 0x%X 0x%X " IWL_DEBUG_ASSOC(priv, "supported HT rate 0x%X 0x%X 0x%X "
"rxon flags 0x%X operation mode :0x%X " "rxon flags 0x%X operation mode :0x%X "
"extension channel offset 0x%x\n", "extension channel offset 0x%x\n",
ht_info->mcs.rx_mask[0], ht_info->mcs.rx_mask[0],
@ -773,7 +936,7 @@ void iwl_set_rxon_chain(struct iwl_priv *priv)
else else
priv->staging_rxon.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK; priv->staging_rxon.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
IWL_DEBUG_ASSOC("rx_chain=0x%X active=%d idle=%d\n", IWL_DEBUG_ASSOC(priv, "rx_chain=0x%X active=%d idle=%d\n",
priv->staging_rxon.rx_chain, priv->staging_rxon.rx_chain,
active_rx_cnt, idle_rx_cnt); active_rx_cnt, idle_rx_cnt);
@ -798,7 +961,7 @@ int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch)
u16 channel = ieee80211_frequency_to_channel(ch->center_freq); u16 channel = ieee80211_frequency_to_channel(ch->center_freq);
if (!iwl_get_channel_info(priv, band, channel)) { if (!iwl_get_channel_info(priv, band, channel)) {
IWL_DEBUG_INFO("Could not set channel to %d [%d]\n", IWL_DEBUG_INFO(priv, "Could not set channel to %d [%d]\n",
channel, band); channel, band);
return -EINVAL; return -EINVAL;
} }
@ -815,12 +978,283 @@ int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch)
priv->band = band; priv->band = band;
IWL_DEBUG_INFO("Staging channel set to %d [%d]\n", channel, band); IWL_DEBUG_INFO(priv, "Staging channel set to %d [%d]\n", channel, band);
return 0; return 0;
} }
EXPORT_SYMBOL(iwl_set_rxon_channel); EXPORT_SYMBOL(iwl_set_rxon_channel);
void iwl_set_flags_for_band(struct iwl_priv *priv,
enum ieee80211_band band)
{
if (band == IEEE80211_BAND_5GHZ) {
priv->staging_rxon.flags &=
~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
| RXON_FLG_CCK_MSK);
priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
} else {
/* Copied from iwl_post_associate() */
if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
else
priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
priv->staging_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
priv->staging_rxon.flags &= ~RXON_FLG_CCK_MSK;
}
}
EXPORT_SYMBOL(iwl_set_flags_for_band);
/*
* initialize rxon structure with default values from eeprom
*/
void iwl_connection_init_rx_config(struct iwl_priv *priv, int mode)
{
const struct iwl_channel_info *ch_info;
memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
switch (mode) {
case NL80211_IFTYPE_AP:
priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
break;
case NL80211_IFTYPE_STATION:
priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
break;
case NL80211_IFTYPE_ADHOC:
priv->staging_rxon.dev_type = RXON_DEV_TYPE_IBSS;
priv->staging_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
priv->staging_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
RXON_FILTER_ACCEPT_GRP_MSK;
break;
case NL80211_IFTYPE_MONITOR:
priv->staging_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
priv->staging_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
break;
default:
IWL_ERR(priv, "Unsupported interface type %d\n", mode);
break;
}
#if 0
/* TODO: Figure out when short_preamble would be set and cache from
* that */
if (!hw_to_local(priv->hw)->short_preamble)
priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
else
priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
#endif
ch_info = iwl_get_channel_info(priv, priv->band,
le16_to_cpu(priv->active_rxon.channel));
if (!ch_info)
ch_info = &priv->channel_info[0];
/*
* in some case A channels are all non IBSS
* in this case force B/G channel
*/
if ((priv->iw_mode == NL80211_IFTYPE_ADHOC) &&
!(is_channel_ibss(ch_info)))
ch_info = &priv->channel_info[0];
priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
priv->band = ch_info->band;
iwl_set_flags_for_band(priv, priv->band);
priv->staging_rxon.ofdm_basic_rates =
(IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
priv->staging_rxon.cck_basic_rates =
(IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
priv->staging_rxon.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED_MSK |
RXON_FLG_CHANNEL_MODE_PURE_40_MSK);
memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
memcpy(priv->staging_rxon.wlap_bssid_addr, priv->mac_addr, ETH_ALEN);
priv->staging_rxon.ofdm_ht_single_stream_basic_rates = 0xff;
priv->staging_rxon.ofdm_ht_dual_stream_basic_rates = 0xff;
}
EXPORT_SYMBOL(iwl_connection_init_rx_config);
void iwl_set_rate(struct iwl_priv *priv)
{
const struct ieee80211_supported_band *hw = NULL;
struct ieee80211_rate *rate;
int i;
hw = iwl_get_hw_mode(priv, priv->band);
if (!hw) {
IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
return;
}
priv->active_rate = 0;
priv->active_rate_basic = 0;
for (i = 0; i < hw->n_bitrates; i++) {
rate = &(hw->bitrates[i]);
if (rate->hw_value < IWL_RATE_COUNT)
priv->active_rate |= (1 << rate->hw_value);
}
IWL_DEBUG_RATE(priv, "Set active_rate = %0x, active_rate_basic = %0x\n",
priv->active_rate, priv->active_rate_basic);
/*
* If a basic rate is configured, then use it (adding IWL_RATE_1M_MASK)
* otherwise set it to the default of all CCK rates and 6, 12, 24 for
* OFDM
*/
if (priv->active_rate_basic & IWL_CCK_BASIC_RATES_MASK)
priv->staging_rxon.cck_basic_rates =
((priv->active_rate_basic &
IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
else
priv->staging_rxon.cck_basic_rates =
(IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
priv->staging_rxon.ofdm_basic_rates =
((priv->active_rate_basic &
(IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
IWL_FIRST_OFDM_RATE) & 0xFF;
else
priv->staging_rxon.ofdm_basic_rates =
(IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
}
EXPORT_SYMBOL(iwl_set_rate);
void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
{
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
struct iwl_rxon_cmd *rxon = (void *)&priv->active_rxon;
struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
IWL_DEBUG_11H(priv, "CSA notif: channel %d, status %d\n",
le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
rxon->channel = csa->channel;
priv->staging_rxon.channel = csa->channel;
}
EXPORT_SYMBOL(iwl_rx_csa);
#ifdef CONFIG_IWLWIFI_DEBUG
static void iwl_print_rx_config_cmd(struct iwl_priv *priv)
{
struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
IWL_DEBUG_RADIO(priv, "RX CONFIG:\n");
iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
IWL_DEBUG_RADIO(priv, "u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
IWL_DEBUG_RADIO(priv, "u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
IWL_DEBUG_RADIO(priv, "u32 filter_flags: 0x%08x\n",
le32_to_cpu(rxon->filter_flags));
IWL_DEBUG_RADIO(priv, "u8 dev_type: 0x%x\n", rxon->dev_type);
IWL_DEBUG_RADIO(priv, "u8 ofdm_basic_rates: 0x%02x\n",
rxon->ofdm_basic_rates);
IWL_DEBUG_RADIO(priv, "u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
IWL_DEBUG_RADIO(priv, "u8[6] node_addr: %pM\n", rxon->node_addr);
IWL_DEBUG_RADIO(priv, "u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
IWL_DEBUG_RADIO(priv, "u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
#endif
/**
* iwl_irq_handle_error - called for HW or SW error interrupt from card
*/
void iwl_irq_handle_error(struct iwl_priv *priv)
{
/* Set the FW error flag -- cleared on iwl_down */
set_bit(STATUS_FW_ERROR, &priv->status);
/* Cancel currently queued command. */
clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
#ifdef CONFIG_IWLWIFI_DEBUG
if (priv->debug_level & IWL_DL_FW_ERRORS) {
iwl_dump_nic_error_log(priv);
iwl_dump_nic_event_log(priv);
iwl_print_rx_config_cmd(priv);
}
#endif
wake_up_interruptible(&priv->wait_command_queue);
/* Keep the restart process from trying to send host
* commands by clearing the INIT status bit */
clear_bit(STATUS_READY, &priv->status);
if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
IWL_DEBUG(priv, IWL_DL_FW_ERRORS,
"Restarting adapter due to uCode error.\n");
if (iwl_is_associated(priv)) {
memcpy(&priv->recovery_rxon, &priv->active_rxon,
sizeof(priv->recovery_rxon));
priv->error_recovering = 1;
}
if (priv->cfg->mod_params->restart_fw)
queue_work(priv->workqueue, &priv->restart);
}
}
EXPORT_SYMBOL(iwl_irq_handle_error);
void iwl_configure_filter(struct ieee80211_hw *hw,
unsigned int changed_flags,
unsigned int *total_flags,
int mc_count, struct dev_addr_list *mc_list)
{
struct iwl_priv *priv = hw->priv;
__le32 *filter_flags = &priv->staging_rxon.filter_flags;
IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
changed_flags, *total_flags);
if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
if (*total_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))
*filter_flags |= RXON_FILTER_PROMISC_MSK;
else
*filter_flags &= ~RXON_FILTER_PROMISC_MSK;
}
if (changed_flags & FIF_ALLMULTI) {
if (*total_flags & FIF_ALLMULTI)
*filter_flags |= RXON_FILTER_ACCEPT_GRP_MSK;
else
*filter_flags &= ~RXON_FILTER_ACCEPT_GRP_MSK;
}
if (changed_flags & FIF_CONTROL) {
if (*total_flags & FIF_CONTROL)
*filter_flags |= RXON_FILTER_CTL2HOST_MSK;
else
*filter_flags &= ~RXON_FILTER_CTL2HOST_MSK;
}
if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
*filter_flags |= RXON_FILTER_BCON_AWARE_MSK;
else
*filter_flags &= ~RXON_FILTER_BCON_AWARE_MSK;
}
/* We avoid iwl_commit_rxon here to commit the new filter flags
* since mac80211 will call ieee80211_hw_config immediately.
* (mc_list is not supported at this time). Otherwise, we need to
* queue a background iwl_commit_rxon work.
*/
*total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
}
EXPORT_SYMBOL(iwl_configure_filter);
int iwl_setup_mac(struct iwl_priv *priv) int iwl_setup_mac(struct iwl_priv *priv)
{ {
int ret; int ret;
@ -921,8 +1355,8 @@ int iwl_init_drv(struct iwl_priv *priv)
priv->qos_data.qos_cap.val = 0; priv->qos_data.qos_cap.val = 0;
priv->rates_mask = IWL_RATES_MASK; priv->rates_mask = IWL_RATES_MASK;
/* If power management is turned on, default to AC mode */ /* If power management is turned on, default to CAM mode */
priv->power_mode = IWL_POWER_AC; priv->power_mode = IWL_POWER_MODE_CAM;
priv->tx_power_user_lmt = IWL_TX_POWER_TARGET_POWER_MAX; priv->tx_power_user_lmt = IWL_TX_POWER_TARGET_POWER_MAX;
ret = iwl_init_channel_map(priv); ret = iwl_init_channel_map(priv);
@ -995,13 +1429,13 @@ void iwl_disable_interrupts(struct iwl_priv *priv)
* from uCode or flow handler (Rx/Tx DMA) */ * from uCode or flow handler (Rx/Tx DMA) */
iwl_write32(priv, CSR_INT, 0xffffffff); iwl_write32(priv, CSR_INT, 0xffffffff);
iwl_write32(priv, CSR_FH_INT_STATUS, 0xffffffff); iwl_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
IWL_DEBUG_ISR("Disabled interrupts\n"); IWL_DEBUG_ISR(priv, "Disabled interrupts\n");
} }
EXPORT_SYMBOL(iwl_disable_interrupts); EXPORT_SYMBOL(iwl_disable_interrupts);
void iwl_enable_interrupts(struct iwl_priv *priv) void iwl_enable_interrupts(struct iwl_priv *priv)
{ {
IWL_DEBUG_ISR("Enabling interrupts\n"); IWL_DEBUG_ISR(priv, "Enabling interrupts\n");
set_bit(STATUS_INT_ENABLED, &priv->status); set_bit(STATUS_INT_ENABLED, &priv->status);
iwl_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK); iwl_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
} }
@ -1047,7 +1481,7 @@ static int iwlcore_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32
u32 errcnt = 0; u32 errcnt = 0;
u32 i; u32 i;
IWL_DEBUG_INFO("ucode inst image size is %u\n", len); IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
ret = iwl_grab_nic_access(priv); ret = iwl_grab_nic_access(priv);
if (ret) if (ret)
@ -1085,7 +1519,7 @@ static int iwl_verify_inst_full(struct iwl_priv *priv, __le32 *image,
int ret = 0; int ret = 0;
u32 errcnt; u32 errcnt;
IWL_DEBUG_INFO("ucode inst image size is %u\n", len); IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
ret = iwl_grab_nic_access(priv); ret = iwl_grab_nic_access(priv);
if (ret) if (ret)
@ -1114,8 +1548,8 @@ static int iwl_verify_inst_full(struct iwl_priv *priv, __le32 *image,
iwl_release_nic_access(priv); iwl_release_nic_access(priv);
if (!errcnt) if (!errcnt)
IWL_DEBUG_INFO IWL_DEBUG_INFO(priv,
("ucode image in INSTRUCTION memory is good\n"); "ucode image in INSTRUCTION memory is good\n");
return ret; return ret;
} }
@ -1135,7 +1569,7 @@ int iwl_verify_ucode(struct iwl_priv *priv)
len = priv->ucode_boot.len; len = priv->ucode_boot.len;
ret = iwlcore_verify_inst_sparse(priv, image, len); ret = iwlcore_verify_inst_sparse(priv, image, len);
if (!ret) { if (!ret) {
IWL_DEBUG_INFO("Bootstrap uCode is good in inst SRAM\n"); IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
return 0; return 0;
} }
@ -1144,7 +1578,7 @@ int iwl_verify_ucode(struct iwl_priv *priv)
len = priv->ucode_init.len; len = priv->ucode_init.len;
ret = iwlcore_verify_inst_sparse(priv, image, len); ret = iwlcore_verify_inst_sparse(priv, image, len);
if (!ret) { if (!ret) {
IWL_DEBUG_INFO("Initialize uCode is good in inst SRAM\n"); IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
return 0; return 0;
} }
@ -1153,7 +1587,7 @@ int iwl_verify_ucode(struct iwl_priv *priv)
len = priv->ucode_code.len; len = priv->ucode_code.len;
ret = iwlcore_verify_inst_sparse(priv, image, len); ret = iwlcore_verify_inst_sparse(priv, image, len);
if (!ret) { if (!ret) {
IWL_DEBUG_INFO("Runtime uCode is good in inst SRAM\n"); IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
return 0; return 0;
} }
@ -1393,7 +1827,7 @@ void iwl_rf_kill_ct_config(struct iwl_priv *priv)
if (ret) if (ret)
IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n"); IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
else else
IWL_DEBUG_INFO("REPLY_CT_KILL_CONFIG_CMD succeeded, " IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD succeeded, "
"critical temperature is %d\n", "critical temperature is %d\n",
cmd.critical_temperature_R); cmd.critical_temperature_R);
} }
@ -1430,7 +1864,7 @@ void iwl_radio_kill_sw_disable_radio(struct iwl_priv *priv)
if (test_bit(STATUS_RF_KILL_SW, &priv->status)) if (test_bit(STATUS_RF_KILL_SW, &priv->status))
return; return;
IWL_DEBUG_RF_KILL("Manual SW RF KILL set to: RADIO OFF\n"); IWL_DEBUG_RF_KILL(priv, "Manual SW RF KILL set to: RADIO OFF\n");
iwl_scan_cancel(priv); iwl_scan_cancel(priv);
/* FIXME: This is a workaround for AP */ /* FIXME: This is a workaround for AP */
@ -1459,7 +1893,7 @@ int iwl_radio_kill_sw_enable_radio(struct iwl_priv *priv)
if (!test_bit(STATUS_RF_KILL_SW, &priv->status)) if (!test_bit(STATUS_RF_KILL_SW, &priv->status))
return 0; return 0;
IWL_DEBUG_RF_KILL("Manual SW RF KILL set to: RADIO ON\n"); IWL_DEBUG_RF_KILL(priv, "Manual SW RF KILL set to: RADIO ON\n");
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL); iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
@ -1484,7 +1918,7 @@ int iwl_radio_kill_sw_enable_radio(struct iwl_priv *priv)
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
if (test_bit(STATUS_RF_KILL_HW, &priv->status)) { if (test_bit(STATUS_RF_KILL_HW, &priv->status)) {
IWL_DEBUG_RF_KILL("Can not turn radio back on - " IWL_DEBUG_RF_KILL(priv, "Can not turn radio back on - "
"disabled by HW switch\n"); "disabled by HW switch\n");
return 0; return 0;
} }
@ -1519,7 +1953,7 @@ void iwl_bg_rf_kill(struct work_struct *work)
mutex_lock(&priv->mutex); mutex_lock(&priv->mutex);
if (!iwl_is_rfkill(priv)) { if (!iwl_is_rfkill(priv)) {
IWL_DEBUG(IWL_DL_RF_KILL, IWL_DEBUG_RF_KILL(priv,
"HW and/or SW RF Kill no longer active, restarting " "HW and/or SW RF Kill no longer active, restarting "
"device\n"); "device\n");
if (!test_bit(STATUS_EXIT_PENDING, &priv->status) && if (!test_bit(STATUS_EXIT_PENDING, &priv->status) &&
@ -1531,7 +1965,7 @@ void iwl_bg_rf_kill(struct work_struct *work)
ieee80211_stop_queues(priv->hw); ieee80211_stop_queues(priv->hw);
if (!test_bit(STATUS_RF_KILL_HW, &priv->status)) if (!test_bit(STATUS_RF_KILL_HW, &priv->status))
IWL_DEBUG_RF_KILL("Can not turn radio back on - " IWL_DEBUG_RF_KILL(priv, "Can not turn radio back on - "
"disabled by SW switch\n"); "disabled by SW switch\n");
else else
IWL_WARN(priv, "Radio Frequency Kill Switch is On:\n" IWL_WARN(priv, "Radio Frequency Kill Switch is On:\n"

26
drivers/net/wireless/iwlwifi/iwl-core.h
View File

@ -211,6 +211,9 @@ struct iwl_cfg {
u16 eeprom_calib_ver; u16 eeprom_calib_ver;
const struct iwl_ops *ops; const struct iwl_ops *ops;
const struct iwl_mod_params *mod_params; const struct iwl_mod_params *mod_params;
u8 valid_tx_ant;
u8 valid_rx_ant;
bool need_pll_cfg;
}; };
/*************************** /***************************
@ -221,11 +224,25 @@ struct ieee80211_hw *iwl_alloc_all(struct iwl_cfg *cfg,
struct ieee80211_ops *hw_ops); struct ieee80211_ops *hw_ops);
void iwl_hw_detect(struct iwl_priv *priv); void iwl_hw_detect(struct iwl_priv *priv);
void iwl_reset_qos(struct iwl_priv *priv); void iwl_reset_qos(struct iwl_priv *priv);
void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt);
int iwl_check_rxon_cmd(struct iwl_priv *priv);
int iwl_full_rxon_required(struct iwl_priv *priv);
void iwl_set_rxon_chain(struct iwl_priv *priv); void iwl_set_rxon_chain(struct iwl_priv *priv);
int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch); int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch);
void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info); void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info);
u8 iwl_is_fat_tx_allowed(struct iwl_priv *priv, u8 iwl_is_fat_tx_allowed(struct iwl_priv *priv,
struct ieee80211_sta_ht_cap *sta_ht_inf); struct ieee80211_sta_ht_cap *sta_ht_inf);
void iwl_set_flags_for_band(struct iwl_priv *priv, enum ieee80211_band band);
void iwl_connection_init_rx_config(struct iwl_priv *priv, int mode);
int iwl_set_decrypted_flag(struct iwl_priv *priv,
struct ieee80211_hdr *hdr,
u32 decrypt_res,
struct ieee80211_rx_status *stats);
void iwl_irq_handle_error(struct iwl_priv *priv);
void iwl_configure_filter(struct ieee80211_hw *hw,
unsigned int changed_flags,
unsigned int *total_flags,
int mc_count, struct dev_addr_list *mc_list);
int iwl_hw_nic_init(struct iwl_priv *priv); int iwl_hw_nic_init(struct iwl_priv *priv);
int iwl_setup_mac(struct iwl_priv *priv); int iwl_setup_mac(struct iwl_priv *priv);
int iwl_set_hw_params(struct iwl_priv *priv); int iwl_set_hw_params(struct iwl_priv *priv);
@ -253,6 +270,7 @@ void iwl_rx_missed_beacon_notif(struct iwl_priv *priv,
struct iwl_rx_mem_buffer *rxb); struct iwl_rx_mem_buffer *rxb);
void iwl_rx_statistics(struct iwl_priv *priv, void iwl_rx_statistics(struct iwl_priv *priv,
struct iwl_rx_mem_buffer *rxb); struct iwl_rx_mem_buffer *rxb);
void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb);
/* TX helpers */ /* TX helpers */
@ -296,6 +314,10 @@ void iwl_hwrate_to_tx_control(struct iwl_priv *priv, u32 rate_n_flags,
struct ieee80211_tx_info *info); struct ieee80211_tx_info *info);
int iwl_hwrate_to_plcp_idx(u32 rate_n_flags); int iwl_hwrate_to_plcp_idx(u32 rate_n_flags);
u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv);
void iwl_set_rate(struct iwl_priv *priv);
u8 iwl_toggle_tx_ant(struct iwl_priv *priv, u8 ant_idx); u8 iwl_toggle_tx_ant(struct iwl_priv *priv, u8 ant_idx);
static inline u32 iwl_ant_idx_to_flags(u8 ant_idx) static inline u32 iwl_ant_idx_to_flags(u8 ant_idx)
@ -343,8 +365,8 @@ int iwl_send_scan_abort(struct iwl_priv *priv);
* time if it's a quiet channel (nothing responded to our probe, and there's * time if it's a quiet channel (nothing responded to our probe, and there's
* no other traffic). * no other traffic).
* Disable "quiet" feature by setting PLCP_QUIET_THRESH to 0. */ * Disable "quiet" feature by setting PLCP_QUIET_THRESH to 0. */
#define IWL_ACTIVE_QUIET_TIME __constant_cpu_to_le16(10) /* msec */ #define IWL_ACTIVE_QUIET_TIME cpu_to_le16(10) /* msec */
#define IWL_PLCP_QUIET_THRESH __constant_cpu_to_le16(1) /* packets */ #define IWL_PLCP_QUIET_THRESH cpu_to_le16(1) /* packets */
/******************************************************************************* /*******************************************************************************

3
drivers/net/wireless/iwlwifi/iwl-csr.h
View File

@ -211,6 +211,9 @@
#define CSR_HW_REV_TYPE_5350 (0x0000030) #define CSR_HW_REV_TYPE_5350 (0x0000030)
#define CSR_HW_REV_TYPE_5100 (0x0000050) #define CSR_HW_REV_TYPE_5100 (0x0000050)
#define CSR_HW_REV_TYPE_5150 (0x0000040) #define CSR_HW_REV_TYPE_5150 (0x0000040)
#define CSR_HW_REV_TYPE_100 (0x0000060)
#define CSR_HW_REV_TYPE_6x00 (0x0000070)
#define CSR_HW_REV_TYPE_6x50 (0x0000080)
#define CSR_HW_REV_TYPE_NONE (0x00000F0) #define CSR_HW_REV_TYPE_NONE (0x00000F0)
/* EEPROM REG */ /* EEPROM REG */

103
drivers/net/wireless/iwlwifi/iwl-debug.h
View File

@ -37,18 +37,20 @@ struct iwl_priv;
#define IWL_CRIT(p, f, a...) dev_crit(&((p)->pci_dev->dev), f, ## a) #define IWL_CRIT(p, f, a...) dev_crit(&((p)->pci_dev->dev), f, ## a)
#ifdef CONFIG_IWLWIFI_DEBUG #ifdef CONFIG_IWLWIFI_DEBUG
#define IWL_DEBUG(level, fmt, args...) \ #define IWL_DEBUG(__priv, level, fmt, args...) \
do { \ do { \
if (priv->debug_level & (level)) \ if (__priv->debug_level & (level)) \
dev_printk(KERN_ERR, &(priv->hw->wiphy->dev), "%c %s " fmt, \ dev_printk(KERN_ERR, &(__priv->hw->wiphy->dev), \
in_interrupt() ? 'I' : 'U', __func__ , ## args); \ "%c %s " fmt, in_interrupt() ? 'I' : 'U', \
__func__ , ## args); \
} while (0) } while (0)
#define IWL_DEBUG_LIMIT(level, fmt, args...) \ #define IWL_DEBUG_LIMIT(__priv, level, fmt, args...) \
do { \ do { \
if ((priv->debug_level & (level)) && net_ratelimit()) \ if ((__priv->debug_level & (level)) && net_ratelimit()) \
dev_printk(KERN_ERR, &(priv->hw->wiphy->dev), "%c %s " fmt, \ dev_printk(KERN_ERR, &(__priv->hw->wiphy->dev), \
in_interrupt() ? 'I' : 'U', __func__ , ## args); \ "%c %s " fmt, in_interrupt() ? 'I' : 'U', \
__func__ , ## args); \
} while (0) } while (0)
#define iwl_print_hex_dump(priv, level, p, len) \ #define iwl_print_hex_dump(priv, level, p, len) \
@ -88,8 +90,8 @@ void iwl_dbgfs_unregister(struct iwl_priv *priv);
#endif #endif
#else #else
#define IWL_DEBUG(level, fmt, args...) #define IWL_DEBUG(__priv, level, fmt, args...)
#define IWL_DEBUG_LIMIT(level, fmt, args...) #define IWL_DEBUG_LIMIT(__priv, level, fmt, args...)
static inline void iwl_print_hex_dump(struct iwl_priv *priv, int level, static inline void iwl_print_hex_dump(struct iwl_priv *priv, int level,
void *p, u32 len) void *p, u32 len)
{} {}
@ -169,42 +171,45 @@ static inline void iwl_dbgfs_unregister(struct iwl_priv *priv)
#define IWL_DL_TX_REPLY (1 << 30) #define IWL_DL_TX_REPLY (1 << 30)
#define IWL_DL_QOS (1 << 31) #define IWL_DL_QOS (1 << 31)
#define IWL_DEBUG_INFO(f, a...) IWL_DEBUG(IWL_DL_INFO, f, ## a) #define IWL_DEBUG_INFO(p, f, a...) IWL_DEBUG(p, IWL_DL_INFO, f, ## a)
#define IWL_DEBUG_MAC80211(f, a...) IWL_DEBUG(IWL_DL_MAC80211, f, ## a) #define IWL_DEBUG_MAC80211(p, f, a...) IWL_DEBUG(p, IWL_DL_MAC80211, f, ## a)
#define IWL_DEBUG_MACDUMP(f, a...) IWL_DEBUG(IWL_DL_MACDUMP, f, ## a) #define IWL_DEBUG_MACDUMP(p, f, a...) IWL_DEBUG(p, IWL_DL_MACDUMP, f, ## a)
#define IWL_DEBUG_TEMP(f, a...) IWL_DEBUG(IWL_DL_TEMP, f, ## a) #define IWL_DEBUG_TEMP(p, f, a...) IWL_DEBUG(p, IWL_DL_TEMP, f, ## a)
#define IWL_DEBUG_SCAN(f, a...) IWL_DEBUG(IWL_DL_SCAN, f, ## a) #define IWL_DEBUG_SCAN(p, f, a...) IWL_DEBUG(p, IWL_DL_SCAN, f, ## a)
#define IWL_DEBUG_RX(f, a...) IWL_DEBUG(IWL_DL_RX, f, ## a) #define IWL_DEBUG_RX(p, f, a...) IWL_DEBUG(p, IWL_DL_RX, f, ## a)
#define IWL_DEBUG_TX(f, a...) IWL_DEBUG(IWL_DL_TX, f, ## a) #define IWL_DEBUG_TX(p, f, a...) IWL_DEBUG(p, IWL_DL_TX, f, ## a)
#define IWL_DEBUG_ISR(f, a...) IWL_DEBUG(IWL_DL_ISR, f, ## a) #define IWL_DEBUG_ISR(p, f, a...) IWL_DEBUG(p, IWL_DL_ISR, f, ## a)
#define IWL_DEBUG_LED(f, a...) IWL_DEBUG(IWL_DL_LED, f, ## a) #define IWL_DEBUG_LED(p, f, a...) IWL_DEBUG(p, IWL_DL_LED, f, ## a)
#define IWL_DEBUG_WEP(f, a...) IWL_DEBUG(IWL_DL_WEP, f, ## a) #define IWL_DEBUG_WEP(p, f, a...) IWL_DEBUG(p, IWL_DL_WEP, f, ## a)
#define IWL_DEBUG_HC(f, a...) IWL_DEBUG(IWL_DL_HCMD, f, ## a) #define IWL_DEBUG_HC(p, f, a...) IWL_DEBUG(p, IWL_DL_HCMD, f, ## a)
#define IWL_DEBUG_HC_DUMP(f, a...) IWL_DEBUG(IWL_DL_HCMD_DUMP, f, ## a) #define IWL_DEBUG_HC_DUMP(p, f, a...) IWL_DEBUG(p, IWL_DL_HCMD_DUMP, f, ## a)
#define IWL_DEBUG_CALIB(f, a...) IWL_DEBUG(IWL_DL_CALIB, f, ## a) #define IWL_DEBUG_CALIB(p, f, a...) IWL_DEBUG(p, IWL_DL_CALIB, f, ## a)
#define IWL_DEBUG_FW(f, a...) IWL_DEBUG(IWL_DL_FW, f, ## a) #define IWL_DEBUG_FW(p, f, a...) IWL_DEBUG(p, IWL_DL_FW, f, ## a)
#define IWL_DEBUG_RF_KILL(f, a...) IWL_DEBUG(IWL_DL_RF_KILL, f, ## a) #define IWL_DEBUG_RF_KILL(p, f, a...) IWL_DEBUG(p, IWL_DL_RF_KILL, f, ## a)
#define IWL_DEBUG_DROP(f, a...) IWL_DEBUG(IWL_DL_DROP, f, ## a) #define IWL_DEBUG_DROP(p, f, a...) IWL_DEBUG(p, IWL_DL_DROP, f, ## a)
#define IWL_DEBUG_DROP_LIMIT(f, a...) IWL_DEBUG_LIMIT(IWL_DL_DROP, f, ## a) #define IWL_DEBUG_DROP_LIMIT(p, f, a...) \
#define IWL_DEBUG_AP(f, a...) IWL_DEBUG(IWL_DL_AP, f, ## a) IWL_DEBUG_LIMIT(p, IWL_DL_DROP, f, ## a)
#define IWL_DEBUG_TXPOWER(f, a...) IWL_DEBUG(IWL_DL_TXPOWER, f, ## a) #define IWL_DEBUG_AP(p, f, a...) IWL_DEBUG(p, IWL_DL_AP, f, ## a)
#define IWL_DEBUG_IO(f, a...) IWL_DEBUG(IWL_DL_IO, f, ## a) #define IWL_DEBUG_TXPOWER(p, f, a...) IWL_DEBUG(p, IWL_DL_TXPOWER, f, ## a)
#define IWL_DEBUG_RATE(f, a...) IWL_DEBUG(IWL_DL_RATE, f, ## a) #define IWL_DEBUG_IO(p, f, a...) IWL_DEBUG(p, IWL_DL_IO, f, ## a)
#define IWL_DEBUG_RATE_LIMIT(f, a...) IWL_DEBUG_LIMIT(IWL_DL_RATE, f, ## a) #define IWL_DEBUG_RATE(p, f, a...) IWL_DEBUG(p, IWL_DL_RATE, f, ## a)
#define IWL_DEBUG_NOTIF(f, a...) IWL_DEBUG(IWL_DL_NOTIF, f, ## a) #define IWL_DEBUG_RATE_LIMIT(p, f, a...) \
#define IWL_DEBUG_ASSOC(f, a...) \ IWL_DEBUG_LIMIT(p, IWL_DL_RATE, f, ## a)
IWL_DEBUG(IWL_DL_ASSOC | IWL_DL_INFO, f, ## a) #define IWL_DEBUG_NOTIF(p, f, a...) IWL_DEBUG(p, IWL_DL_NOTIF, f, ## a)
#define IWL_DEBUG_ASSOC_LIMIT(f, a...) \ #define IWL_DEBUG_ASSOC(p, f, a...) \
IWL_DEBUG_LIMIT(IWL_DL_ASSOC | IWL_DL_INFO, f, ## a) IWL_DEBUG(p, IWL_DL_ASSOC | IWL_DL_INFO, f, ## a)
#define IWL_DEBUG_HT(f, a...) IWL_DEBUG(IWL_DL_HT, f, ## a) #define IWL_DEBUG_ASSOC_LIMIT(p, f, a...) \
#define IWL_DEBUG_STATS(f, a...) IWL_DEBUG(IWL_DL_STATS, f, ## a) IWL_DEBUG_LIMIT(p, IWL_DL_ASSOC | IWL_DL_INFO, f, ## a)
#define IWL_DEBUG_STATS_LIMIT(f, a...) IWL_DEBUG_LIMIT(IWL_DL_STATS, f, ## a) #define IWL_DEBUG_HT(p, f, a...) IWL_DEBUG(p, IWL_DL_HT, f, ## a)
#define IWL_DEBUG_TX_REPLY(f, a...) IWL_DEBUG(IWL_DL_TX_REPLY, f, ## a) #define IWL_DEBUG_STATS(p, f, a...) IWL_DEBUG(p, IWL_DL_STATS, f, ## a)
#define IWL_DEBUG_TX_REPLY_LIMIT(f, a...) \ #define IWL_DEBUG_STATS_LIMIT(p, f, a...) \
IWL_DEBUG_LIMIT(IWL_DL_TX_REPLY, f, ## a) IWL_DEBUG_LIMIT(p, IWL_DL_STATS, f, ## a)
#define IWL_DEBUG_QOS(f, a...) IWL_DEBUG(IWL_DL_QOS, f, ## a) #define IWL_DEBUG_TX_REPLY(p, f, a...) IWL_DEBUG(p, IWL_DL_TX_REPLY, f, ## a)
#define IWL_DEBUG_RADIO(f, a...) IWL_DEBUG(IWL_DL_RADIO, f, ## a) #define IWL_DEBUG_TX_REPLY_LIMIT(p, f, a...) \
#define IWL_DEBUG_POWER(f, a...) IWL_DEBUG(IWL_DL_POWER, f, ## a) IWL_DEBUG_LIMIT(p, IWL_DL_TX_REPLY, f, ## a)
#define IWL_DEBUG_11H(f, a...) IWL_DEBUG(IWL_DL_11H, f, ## a) #define IWL_DEBUG_QOS(p, f, a...) IWL_DEBUG(p, IWL_DL_QOS, f, ## a)
#define IWL_DEBUG_RADIO(p, f, a...) IWL_DEBUG(p, IWL_DL_RADIO, f, ## a)
#define IWL_DEBUG_POWER(p, f, a...) IWL_DEBUG(p, IWL_DL_POWER, f, ## a)
#define IWL_DEBUG_11H(p, f, a...) IWL_DEBUG(p, IWL_DL_11H, f, ## a)
#endif #endif

19
drivers/net/wireless/iwlwifi/iwl-dev.h
View File

@ -67,6 +67,18 @@ extern struct iwl_cfg iwl100_bgn_cfg;
/* shared structures from iwl-5000.c */ /* shared structures from iwl-5000.c */
extern struct iwl_mod_params iwl50_mod_params; extern struct iwl_mod_params iwl50_mod_params;
extern struct iwl_ops iwl5000_ops; extern struct iwl_ops iwl5000_ops;
extern struct iwl_lib_ops iwl5000_lib;
extern struct iwl_hcmd_ops iwl5000_hcmd;
extern struct iwl_hcmd_utils_ops iwl5000_hcmd_utils;
/* shared functions from iwl-5000.c */
extern u16 iwl5000_get_hcmd_size(u8 cmd_id, u16 len);
extern u16 iwl5000_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd,
u8 *data);
extern void iwl5000_rts_tx_cmd_flag(struct ieee80211_tx_info *info,
__le32 *tx_flags);
extern int iwl5000_calc_rssi(struct iwl_priv *priv,
struct iwl_rx_phy_res *rx_resp);
/* CT-KILL constants */ /* CT-KILL constants */
#define CT_KILL_THRESHOLD 110 /* in Celsius */ #define CT_KILL_THRESHOLD 110 /* in Celsius */
@ -1078,13 +1090,6 @@ struct iwl_priv {
/*For 3945*/ /*For 3945*/
#define IWL_DEFAULT_TX_POWER 0x0F #define IWL_DEFAULT_TX_POWER 0x0F
/* We declare this const so it can only be
* changed via explicit cast within the
* routines that actually update the physical
* hardware */
const struct iwl3945_rxon_cmd active39_rxon;
struct iwl3945_rxon_cmd staging39_rxon;
struct iwl3945_rxon_cmd recovery39_rxon;
struct iwl3945_notif_statistics statistics_39; struct iwl3945_notif_statistics statistics_39;

14
drivers/net/wireless/iwlwifi/iwl-eeprom.c
View File

@ -173,7 +173,7 @@ int iwlcore_eeprom_acquire_semaphore(struct iwl_priv *priv)
CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM, CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM,
EEPROM_SEM_TIMEOUT); EEPROM_SEM_TIMEOUT);
if (ret >= 0) { if (ret >= 0) {
IWL_DEBUG_IO("Acquired semaphore after %d tries.\n", IWL_DEBUG_IO(priv, "Acquired semaphore after %d tries.\n",
count+1); count+1);
return ret; return ret;
} }
@ -390,7 +390,7 @@ static int iwl_set_fat_chan_info(struct iwl_priv *priv,
if (!is_channel_valid(ch_info)) if (!is_channel_valid(ch_info))
return -1; return -1;
IWL_DEBUG_INFO("FAT Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):" IWL_DEBUG_INFO(priv, "FAT Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
" Ad-Hoc %ssupported\n", " Ad-Hoc %ssupported\n",
ch_info->channel, ch_info->channel,
is_channel_a_band(ch_info) ? is_channel_a_band(ch_info) ?
@ -432,11 +432,11 @@ int iwl_init_channel_map(struct iwl_priv *priv)
struct iwl_channel_info *ch_info; struct iwl_channel_info *ch_info;
if (priv->channel_count) { if (priv->channel_count) {
IWL_DEBUG_INFO("Channel map already initialized.\n"); IWL_DEBUG_INFO(priv, "Channel map already initialized.\n");
return 0; return 0;
} }
IWL_DEBUG_INFO("Initializing regulatory info from EEPROM\n"); IWL_DEBUG_INFO(priv, "Initializing regulatory info from EEPROM\n");
priv->channel_count = priv->channel_count =
ARRAY_SIZE(iwl_eeprom_band_1) + ARRAY_SIZE(iwl_eeprom_band_1) +
@ -445,7 +445,7 @@ int iwl_init_channel_map(struct iwl_priv *priv)
ARRAY_SIZE(iwl_eeprom_band_4) + ARRAY_SIZE(iwl_eeprom_band_4) +
ARRAY_SIZE(iwl_eeprom_band_5); ARRAY_SIZE(iwl_eeprom_band_5);
IWL_DEBUG_INFO("Parsing data for %d channels.\n", priv->channel_count); IWL_DEBUG_INFO(priv, "Parsing data for %d channels.\n", priv->channel_count);
priv->channel_info = kzalloc(sizeof(struct iwl_channel_info) * priv->channel_info = kzalloc(sizeof(struct iwl_channel_info) *
priv->channel_count, GFP_KERNEL); priv->channel_count, GFP_KERNEL);
@ -485,7 +485,7 @@ int iwl_init_channel_map(struct iwl_priv *priv)
IEEE80211_CHAN_NO_FAT_BELOW); IEEE80211_CHAN_NO_FAT_BELOW);
if (!(is_channel_valid(ch_info))) { if (!(is_channel_valid(ch_info))) {
IWL_DEBUG_INFO("Ch. %d Flags %x [%sGHz] - " IWL_DEBUG_INFO(priv, "Ch. %d Flags %x [%sGHz] - "
"No traffic\n", "No traffic\n",
ch_info->channel, ch_info->channel,
ch_info->flags, ch_info->flags,
@ -501,7 +501,7 @@ int iwl_init_channel_map(struct iwl_priv *priv)
ch_info->scan_power = eeprom_ch_info[ch].max_power_avg; ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
ch_info->min_power = 0; ch_info->min_power = 0;
IWL_DEBUG_INFO("Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm):" IWL_DEBUG_INFO(priv, "Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm):"
" Ad-Hoc %ssupported\n", " Ad-Hoc %ssupported\n",
ch_info->channel, ch_info->channel,
is_channel_a_band(ch_info) ? is_channel_a_band(ch_info) ?

8
drivers/net/wireless/iwlwifi/iwl-hcmd.c
View File

@ -125,11 +125,11 @@ static int iwl_generic_cmd_callback(struct iwl_priv *priv,
switch (cmd->hdr.cmd) { switch (cmd->hdr.cmd) {
case REPLY_TX_LINK_QUALITY_CMD: case REPLY_TX_LINK_QUALITY_CMD:
case SENSITIVITY_CMD: case SENSITIVITY_CMD:
IWL_DEBUG_HC_DUMP("back from %s (0x%08X)\n", IWL_DEBUG_HC_DUMP(priv, "back from %s (0x%08X)\n",
get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags); get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
break; break;
default: default:
IWL_DEBUG_HC("back from %s (0x%08X)\n", IWL_DEBUG_HC(priv, "back from %s (0x%08X)\n",
get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags); get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags);
} }
#endif #endif
@ -211,13 +211,13 @@ int iwl_send_cmd_sync(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
} }
if (test_bit(STATUS_RF_KILL_HW, &priv->status)) { if (test_bit(STATUS_RF_KILL_HW, &priv->status)) {
IWL_DEBUG_INFO("Command %s aborted: RF KILL Switch\n", IWL_DEBUG_INFO(priv, "Command %s aborted: RF KILL Switch\n",
get_cmd_string(cmd->id)); get_cmd_string(cmd->id));
ret = -ECANCELED; ret = -ECANCELED;
goto fail; goto fail;
} }
if (test_bit(STATUS_FW_ERROR, &priv->status)) { if (test_bit(STATUS_FW_ERROR, &priv->status)) {
IWL_DEBUG_INFO("Command %s failed: FW Error\n", IWL_DEBUG_INFO(priv, "Command %s failed: FW Error\n",
get_cmd_string(cmd->id)); get_cmd_string(cmd->id));
ret = -EIO; ret = -EIO;
goto fail; goto fail;

20
drivers/net/wireless/iwlwifi/iwl-io.h
View File

@ -66,7 +66,7 @@
static inline void __iwl_write32(const char *f, u32 l, struct iwl_priv *priv, static inline void __iwl_write32(const char *f, u32 l, struct iwl_priv *priv,
u32 ofs, u32 val) u32 ofs, u32 val)
{ {
IWL_DEBUG_IO("write32(0x%08X, 0x%08X) - %s %d\n", ofs, val, f, l); IWL_DEBUG_IO(priv, "write32(0x%08X, 0x%08X) - %s %d\n", ofs, val, f, l);
_iwl_write32(priv, ofs, val); _iwl_write32(priv, ofs, val);
} }
#define iwl_write32(priv, ofs, val) \ #define iwl_write32(priv, ofs, val) \
@ -79,7 +79,7 @@ static inline void __iwl_write32(const char *f, u32 l, struct iwl_priv *priv,
#ifdef CONFIG_IWLWIFI_DEBUG #ifdef CONFIG_IWLWIFI_DEBUG
static inline u32 __iwl_read32(char *f, u32 l, struct iwl_priv *priv, u32 ofs) static inline u32 __iwl_read32(char *f, u32 l, struct iwl_priv *priv, u32 ofs)
{ {
IWL_DEBUG_IO("read_direct32(0x%08X) - %s %d\n", ofs, f, l); IWL_DEBUG_IO(priv, "read_direct32(0x%08X) - %s %d\n", ofs, f, l);
return _iwl_read32(priv, ofs); return _iwl_read32(priv, ofs);
} }
#define iwl_read32(priv, ofs) __iwl_read32(__FILE__, __LINE__, priv, ofs) #define iwl_read32(priv, ofs) __iwl_read32(__FILE__, __LINE__, priv, ofs)
@ -108,7 +108,7 @@ static inline int __iwl_poll_bit(const char *f, u32 l,
u32 bits, u32 mask, int timeout) u32 bits, u32 mask, int timeout)
{ {
int ret = _iwl_poll_bit(priv, addr, bits, mask, timeout); int ret = _iwl_poll_bit(priv, addr, bits, mask, timeout);
IWL_DEBUG_IO("poll_bit(0x%08X, 0x%08X, 0x%08X) - %s- %s %d\n", IWL_DEBUG_IO(priv, "poll_bit(0x%08X, 0x%08X, 0x%08X) - %s- %s %d\n",
addr, bits, mask, addr, bits, mask,
unlikely(ret == -ETIMEDOUT) ? "timeout" : "", f, l); unlikely(ret == -ETIMEDOUT) ? "timeout" : "", f, l);
return ret; return ret;
@ -128,7 +128,7 @@ static inline void __iwl_set_bit(const char *f, u32 l,
struct iwl_priv *priv, u32 reg, u32 mask) struct iwl_priv *priv, u32 reg, u32 mask)
{ {
u32 val = _iwl_read32(priv, reg) | mask; u32 val = _iwl_read32(priv, reg) | mask;
IWL_DEBUG_IO("set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val); IWL_DEBUG_IO(priv, "set_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
_iwl_write32(priv, reg, val); _iwl_write32(priv, reg, val);
} }
#define iwl_set_bit(p, r, m) __iwl_set_bit(__FILE__, __LINE__, p, r, m) #define iwl_set_bit(p, r, m) __iwl_set_bit(__FILE__, __LINE__, p, r, m)
@ -145,7 +145,7 @@ static inline void __iwl_clear_bit(const char *f, u32 l,
struct iwl_priv *priv, u32 reg, u32 mask) struct iwl_priv *priv, u32 reg, u32 mask)
{ {
u32 val = _iwl_read32(priv, reg) & ~mask; u32 val = _iwl_read32(priv, reg) & ~mask;
IWL_DEBUG_IO("clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val); IWL_DEBUG_IO(priv, "clear_bit(0x%08X, 0x%08X) = 0x%08X\n", reg, mask, val);
_iwl_write32(priv, reg, val); _iwl_write32(priv, reg, val);
} }
#define iwl_clear_bit(p, r, m) __iwl_clear_bit(__FILE__, __LINE__, p, r, m) #define iwl_clear_bit(p, r, m) __iwl_clear_bit(__FILE__, __LINE__, p, r, m)
@ -184,7 +184,7 @@ static inline int __iwl_grab_nic_access(const char *f, u32 l,
if (atomic_read(&priv->restrict_refcnt)) if (atomic_read(&priv->restrict_refcnt))
IWL_ERR(priv, "Grabbing access while already held %s %d.\n", f, l); IWL_ERR(priv, "Grabbing access while already held %s %d.\n", f, l);
IWL_DEBUG_IO("grabbing nic access - %s %d\n", f, l); IWL_DEBUG_IO(priv, "grabbing nic access - %s %d\n", f, l);
return _iwl_grab_nic_access(priv); return _iwl_grab_nic_access(priv);
} }
#define iwl_grab_nic_access(priv) \ #define iwl_grab_nic_access(priv) \
@ -209,7 +209,7 @@ static inline void __iwl_release_nic_access(const char *f, u32 l,
if (atomic_read(&priv->restrict_refcnt) <= 0) if (atomic_read(&priv->restrict_refcnt) <= 0)
IWL_ERR(priv, "Release unheld nic access at line %s %d.\n", f, l); IWL_ERR(priv, "Release unheld nic access at line %s %d.\n", f, l);
IWL_DEBUG_IO("releasing nic access - %s %d\n", f, l); IWL_DEBUG_IO(priv, "releasing nic access - %s %d\n", f, l);
_iwl_release_nic_access(priv); _iwl_release_nic_access(priv);
} }
#define iwl_release_nic_access(priv) \ #define iwl_release_nic_access(priv) \
@ -230,7 +230,7 @@ static inline u32 __iwl_read_direct32(const char *f, u32 l,
u32 value = _iwl_read_direct32(priv, reg); u32 value = _iwl_read_direct32(priv, reg);
if (!atomic_read(&priv->restrict_refcnt)) if (!atomic_read(&priv->restrict_refcnt))
IWL_ERR(priv, "Nic access not held from %s %d\n", f, l); IWL_ERR(priv, "Nic access not held from %s %d\n", f, l);
IWL_DEBUG_IO("read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value, IWL_DEBUG_IO(priv, "read_direct32(0x%4X) = 0x%08x - %s %d \n", reg, value,
f, l); f, l);
return value; return value;
} }
@ -284,10 +284,10 @@ static inline int __iwl_poll_direct_bit(const char *f, u32 l,
int ret = _iwl_poll_direct_bit(priv, addr, mask, timeout); int ret = _iwl_poll_direct_bit(priv, addr, mask, timeout);
if (unlikely(ret == -ETIMEDOUT)) if (unlikely(ret == -ETIMEDOUT))
IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) - " IWL_DEBUG_IO(priv, "poll_direct_bit(0x%08X, 0x%08X) - "
"timedout - %s %d\n", addr, mask, f, l); "timedout - %s %d\n", addr, mask, f, l);
else else
IWL_DEBUG_IO("poll_direct_bit(0x%08X, 0x%08X) = 0x%08X " IWL_DEBUG_IO(priv, "poll_direct_bit(0x%08X, 0x%08X) = 0x%08X "
"- %s %d\n", addr, mask, ret, f, l); "- %s %d\n", addr, mask, ret, f, l);
return ret; return ret;
} }

22
drivers/net/wireless/iwlwifi/iwl-led.c
View File

@ -123,7 +123,7 @@ static int iwl4965_led_pattern(struct iwl_priv *priv, int led_id,
/* Set led register off */ /* Set led register off */
static int iwl4965_led_on_reg(struct iwl_priv *priv, int led_id) static int iwl4965_led_on_reg(struct iwl_priv *priv, int led_id)
{ {
IWL_DEBUG_LED("led on %d\n", led_id); IWL_DEBUG_LED(priv, "led on %d\n", led_id);
iwl_write32(priv, CSR_LED_REG, CSR_LED_REG_TRUN_ON); iwl_write32(priv, CSR_LED_REG, CSR_LED_REG_TRUN_ON);
return 0; return 0;
} }
@ -150,7 +150,7 @@ int iwl4965_led_off(struct iwl_priv *priv, int led_id)
.off = 0, .off = 0,
.interval = IWL_DEF_LED_INTRVL .interval = IWL_DEF_LED_INTRVL
}; };
IWL_DEBUG_LED("led off %d\n", led_id); IWL_DEBUG_LED(priv, "led off %d\n", led_id);
return iwl_send_led_cmd(priv, &led_cmd); return iwl_send_led_cmd(priv, &led_cmd);
} }
#endif #endif
@ -159,7 +159,7 @@ int iwl4965_led_off(struct iwl_priv *priv, int led_id)
/* Set led register off */ /* Set led register off */
static int iwl4965_led_off_reg(struct iwl_priv *priv, int led_id) static int iwl4965_led_off_reg(struct iwl_priv *priv, int led_id)
{ {
IWL_DEBUG_LED("LED Reg off\n"); IWL_DEBUG_LED(priv, "LED Reg off\n");
iwl_write32(priv, CSR_LED_REG, CSR_LED_REG_TRUN_OFF); iwl_write32(priv, CSR_LED_REG, CSR_LED_REG_TRUN_OFF);
return 0; return 0;
} }
@ -169,7 +169,7 @@ static int iwl4965_led_off_reg(struct iwl_priv *priv, int led_id)
*/ */
static int iwl_led_associate(struct iwl_priv *priv, int led_id) static int iwl_led_associate(struct iwl_priv *priv, int led_id)
{ {
IWL_DEBUG_LED("Associated\n"); IWL_DEBUG_LED(priv, "Associated\n");
priv->allow_blinking = 1; priv->allow_blinking = 1;
return iwl4965_led_on_reg(priv, led_id); return iwl4965_led_on_reg(priv, led_id);
} }
@ -213,7 +213,7 @@ static void iwl_led_brightness_set(struct led_classdev *led_cdev,
return; return;
IWL_DEBUG_LED("Led type = %s brightness = %d\n", IWL_DEBUG_LED(priv, "Led type = %s brightness = %d\n",
led_type_str[led->type], brightness); led_type_str[led->type], brightness);
switch (brightness) { switch (brightness) {
case LED_FULL: case LED_FULL:
@ -280,7 +280,7 @@ static int iwl_get_blink_rate(struct iwl_priv *priv)
if (tpt < 0) /* wraparound */ if (tpt < 0) /* wraparound */
tpt = -tpt; tpt = -tpt;
IWL_DEBUG_LED("tpt %lld current_tpt %llu\n", IWL_DEBUG_LED(priv, "tpt %lld current_tpt %llu\n",
(long long)tpt, (long long)tpt,
(unsigned long long)current_tpt); (unsigned long long)current_tpt);
priv->led_tpt = current_tpt; priv->led_tpt = current_tpt;
@ -292,7 +292,7 @@ static int iwl_get_blink_rate(struct iwl_priv *priv)
if (tpt > (blink_tbl[i].tpt * IWL_1MB_RATE)) if (tpt > (blink_tbl[i].tpt * IWL_1MB_RATE))
break; break;
IWL_DEBUG_LED("LED BLINK IDX=%d\n", i); IWL_DEBUG_LED(priv, "LED BLINK IDX=%d\n", i);
return i; return i;
} }
@ -352,7 +352,7 @@ int iwl_leds_register(struct iwl_priv *priv)
trigger = ieee80211_get_radio_led_name(priv->hw); trigger = ieee80211_get_radio_led_name(priv->hw);
snprintf(priv->led[IWL_LED_TRG_RADIO].name, snprintf(priv->led[IWL_LED_TRG_RADIO].name,
sizeof(priv->led[IWL_LED_TRG_RADIO].name), "iwl-%s:radio", sizeof(priv->led[IWL_LED_TRG_RADIO].name), "iwl-%s::radio",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
priv->led[IWL_LED_TRG_RADIO].led_on = iwl4965_led_on_reg; priv->led[IWL_LED_TRG_RADIO].led_on = iwl4965_led_on_reg;
@ -366,7 +366,7 @@ int iwl_leds_register(struct iwl_priv *priv)
trigger = ieee80211_get_assoc_led_name(priv->hw); trigger = ieee80211_get_assoc_led_name(priv->hw);
snprintf(priv->led[IWL_LED_TRG_ASSOC].name, snprintf(priv->led[IWL_LED_TRG_ASSOC].name,
sizeof(priv->led[IWL_LED_TRG_ASSOC].name), "iwl-%s:assoc", sizeof(priv->led[IWL_LED_TRG_ASSOC].name), "iwl-%s::assoc",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_ASSOC], ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_ASSOC],
@ -382,7 +382,7 @@ int iwl_leds_register(struct iwl_priv *priv)
trigger = ieee80211_get_rx_led_name(priv->hw); trigger = ieee80211_get_rx_led_name(priv->hw);
snprintf(priv->led[IWL_LED_TRG_RX].name, snprintf(priv->led[IWL_LED_TRG_RX].name,
sizeof(priv->led[IWL_LED_TRG_RX].name), "iwl-%s:RX", sizeof(priv->led[IWL_LED_TRG_RX].name), "iwl-%s::RX",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_RX], ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_RX],
@ -397,7 +397,7 @@ int iwl_leds_register(struct iwl_priv *priv)
trigger = ieee80211_get_tx_led_name(priv->hw); trigger = ieee80211_get_tx_led_name(priv->hw);
snprintf(priv->led[IWL_LED_TRG_TX].name, snprintf(priv->led[IWL_LED_TRG_TX].name,
sizeof(priv->led[IWL_LED_TRG_TX].name), "iwl-%s:TX", sizeof(priv->led[IWL_LED_TRG_TX].name), "iwl-%s::TX",
wiphy_name(priv->hw->wiphy)); wiphy_name(priv->hw->wiphy));
ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_TX], ret = iwl_leds_register_led(priv, &priv->led[IWL_LED_TRG_TX],

2
drivers/net/wireless/iwlwifi/iwl-led.h
View File

@ -35,7 +35,7 @@ struct iwl_priv;
#define IWL_LED_SOLID 11 #define IWL_LED_SOLID 11
#define IWL_LED_NAME_LEN 31 #define IWL_LED_NAME_LEN 31
#define IWL_DEF_LED_INTRVL __constant_cpu_to_le32(1000) #define IWL_DEF_LED_INTRVL cpu_to_le32(1000)
#define IWL_LED_ACTIVITY (0<<1) #define IWL_LED_ACTIVITY (0<<1)
#define IWL_LED_LINK (1<<1) #define IWL_LED_LINK (1<<1)

35
drivers/net/wireless/iwlwifi/iwl-power.c
View File

@ -102,6 +102,7 @@ static struct iwl_power_vec_entry range_2[IWL_POWER_MAX] = {
{{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 0xFF)}, 0} {{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 0xFF)}, 0}
}; };
/* set card power command */ /* set card power command */
static int iwl_set_power(struct iwl_priv *priv, void *cmd) static int iwl_set_power(struct iwl_priv *priv, void *cmd)
{ {
@ -126,13 +127,6 @@ static u16 iwl_get_auto_power_mode(struct iwl_priv *priv)
else else
mode = IWL_POWER_ON_AC_DISASSOC; mode = IWL_POWER_ON_AC_DISASSOC;
break; break;
/* FIXME: remove battery and ac from here */
case IWL_POWER_BATTERY:
mode = IWL_POWER_INDEX_3;
break;
case IWL_POWER_AC:
mode = IWL_POWER_MODE_CAM;
break;
default: default:
mode = priv->power_data.user_power_setting; mode = priv->power_data.user_power_setting;
break; break;
@ -149,7 +143,7 @@ static void iwl_power_init_handle(struct iwl_priv *priv)
int i; int i;
u16 pci_pm; u16 pci_pm;
IWL_DEBUG_POWER("Initialize power \n"); IWL_DEBUG_POWER(priv, "Initialize power \n");
pow_data = &priv->power_data; pow_data = &priv->power_data;
@ -161,7 +155,7 @@ static void iwl_power_init_handle(struct iwl_priv *priv)
pci_read_config_word(priv->pci_dev, PCI_CFG_LINK_CTRL, &pci_pm); pci_read_config_word(priv->pci_dev, PCI_CFG_LINK_CTRL, &pci_pm);
IWL_DEBUG_POWER("adjust power command flags\n"); IWL_DEBUG_POWER(priv, "adjust power command flags\n");
for (i = 0; i < IWL_POWER_MAX; i++) { for (i = 0; i < IWL_POWER_MAX; i++) {
cmd = &pow_data->pwr_range_0[i].cmd; cmd = &pow_data->pwr_range_0[i].cmd;
@ -185,7 +179,7 @@ static int iwl_update_power_cmd(struct iwl_priv *priv,
bool skip; bool skip;
if (mode > IWL_POWER_INDEX_5) { if (mode > IWL_POWER_INDEX_5) {
IWL_DEBUG_POWER("Error invalid power mode \n"); IWL_DEBUG_POWER(priv, "Error invalid power mode \n");
return -EINVAL; return -EINVAL;
} }
@ -225,10 +219,10 @@ static int iwl_update_power_cmd(struct iwl_priv *priv,
if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep) if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep)
cmd->sleep_interval[i] = cpu_to_le32(max_sleep); cmd->sleep_interval[i] = cpu_to_le32(max_sleep);
IWL_DEBUG_POWER("Flags value = 0x%08X\n", cmd->flags); IWL_DEBUG_POWER(priv, "Flags value = 0x%08X\n", cmd->flags);
IWL_DEBUG_POWER("Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout)); IWL_DEBUG_POWER(priv, "Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
IWL_DEBUG_POWER("Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout)); IWL_DEBUG_POWER(priv, "Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
IWL_DEBUG_POWER("Sleep interval vector = { %d , %d , %d , %d , %d }\n", IWL_DEBUG_POWER(priv, "Sleep interval vector = { %d , %d , %d , %d , %d }\n",
le32_to_cpu(cmd->sleep_interval[0]), le32_to_cpu(cmd->sleep_interval[0]),
le32_to_cpu(cmd->sleep_interval[1]), le32_to_cpu(cmd->sleep_interval[1]),
le32_to_cpu(cmd->sleep_interval[2]), le32_to_cpu(cmd->sleep_interval[2]),
@ -302,7 +296,7 @@ int iwl_power_update_mode(struct iwl_priv *priv, bool force)
if (priv->cfg->ops->lib->update_chain_flags && update_chains) if (priv->cfg->ops->lib->update_chain_flags && update_chains)
priv->cfg->ops->lib->update_chain_flags(priv); priv->cfg->ops->lib->update_chain_flags(priv);
else else
IWL_DEBUG_POWER("Cannot update the power, chain noise " IWL_DEBUG_POWER(priv, "Cannot update the power, chain noise "
"calibration running: %d\n", "calibration running: %d\n",
priv->chain_noise_data.state); priv->chain_noise_data.state);
if (!ret) if (!ret)
@ -357,7 +351,7 @@ EXPORT_SYMBOL(iwl_power_enable_management);
/* set user_power_setting */ /* set user_power_setting */
int iwl_power_set_user_mode(struct iwl_priv *priv, u16 mode) int iwl_power_set_user_mode(struct iwl_priv *priv, u16 mode)
{ {
if (mode > IWL_POWER_LIMIT) if (mode > IWL_POWER_MAX)
return -EINVAL; return -EINVAL;
priv->power_data.user_power_setting = mode; priv->power_data.user_power_setting = mode;
@ -371,11 +365,10 @@ EXPORT_SYMBOL(iwl_power_set_user_mode);
*/ */
int iwl_power_set_system_mode(struct iwl_priv *priv, u16 mode) int iwl_power_set_system_mode(struct iwl_priv *priv, u16 mode)
{ {
if (mode > IWL_POWER_LIMIT) if (mode < IWL_POWER_SYS_MAX)
priv->power_data.system_power_setting = mode;
else
return -EINVAL; return -EINVAL;
priv->power_data.system_power_setting = mode;
return iwl_power_update_mode(priv, 0); return iwl_power_update_mode(priv, 0);
} }
EXPORT_SYMBOL(iwl_power_set_system_mode); EXPORT_SYMBOL(iwl_power_set_system_mode);
@ -423,7 +416,7 @@ static void iwl_bg_set_power_save(struct work_struct *work)
{ {
struct iwl_priv *priv = container_of(work, struct iwl_priv *priv = container_of(work,
struct iwl_priv, set_power_save.work); struct iwl_priv, set_power_save.work);
IWL_DEBUG(IWL_DL_STATE, "update power\n"); IWL_DEBUG_POWER(priv, "update power\n");
if (test_bit(STATUS_EXIT_PENDING, &priv->status)) if (test_bit(STATUS_EXIT_PENDING, &priv->status))
return; return;

28
drivers/net/wireless/iwlwifi/iwl-power.h
View File

@ -42,38 +42,26 @@ enum {
IWL_POWER_INDEX_5, IWL_POWER_INDEX_5,
IWL_POWER_AUTO, IWL_POWER_AUTO,
IWL_POWER_MAX = IWL_POWER_AUTO, IWL_POWER_MAX = IWL_POWER_AUTO,
IWL39_POWER_AC = IWL_POWER_AUTO, /* 0x06 */
IWL_POWER_AC,
IWL39_POWER_BATTERY = IWL_POWER_AC, /* 0x07 */
IWL39_POWER_LIMIT = IWL_POWER_AC,
IWL_POWER_BATTERY,
}; };
enum { enum {
IWL_POWER_SYS_AUTO, IWL_POWER_SYS_AUTO,
IWL_POWER_SYS_AC, IWL_POWER_SYS_AC,
IWL_POWER_SYS_BATTERY, IWL_POWER_SYS_BATTERY,
IWL_POWER_SYS_MAX,
}; };
#define IWL_POWER_LIMIT 0x08
#define IWL_POWER_MASK 0x0F
#define IWL_POWER_ENABLED 0x10
#define IWL_POWER_RANGE_0 (0)
#define IWL_POWER_RANGE_1 (1)
#define IWL_POWER_LEVEL(x) ((x) & IWL_POWER_MASK)
/* Power management (not Tx power) structures */ /* Power management (not Tx power) structures */
#define NOSLP __constant_cpu_to_le16(0), 0, 0 #define NOSLP cpu_to_le16(0), 0, 0
#define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK, 0, 0 #define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK, 0, 0
#define SLP_TOUT(T) __constant_cpu_to_le32((T) * MSEC_TO_USEC) #define SLP_TOUT(T) cpu_to_le32((T) * MSEC_TO_USEC)
#define SLP_VEC(X0, X1, X2, X3, X4) {__constant_cpu_to_le32(X0), \ #define SLP_VEC(X0, X1, X2, X3, X4) {cpu_to_le32(X0), \
__constant_cpu_to_le32(X1), \ cpu_to_le32(X1), \
__constant_cpu_to_le32(X2), \ cpu_to_le32(X2), \
__constant_cpu_to_le32(X3), \ cpu_to_le32(X3), \
__constant_cpu_to_le32(X4)} cpu_to_le32(X4)}
struct iwl_power_vec_entry { struct iwl_power_vec_entry {
struct iwl_powertable_cmd cmd; struct iwl_powertable_cmd cmd;
u8 no_dtim; u8 no_dtim;

8
drivers/net/wireless/iwlwifi/iwl-rfkill.c
View File

@ -47,7 +47,7 @@ static int iwl_rfkill_soft_rf_kill(void *data, enum rfkill_state state)
if (test_bit(STATUS_EXIT_PENDING, &priv->status)) if (test_bit(STATUS_EXIT_PENDING, &priv->status))
return 0; return 0;
IWL_DEBUG_RF_KILL("we received soft RFKILL set to state %d\n", state); IWL_DEBUG_RF_KILL(priv, "we received soft RFKILL set to state %d\n", state);
mutex_lock(&priv->mutex); mutex_lock(&priv->mutex);
switch (state) { switch (state) {
@ -79,7 +79,7 @@ int iwl_rfkill_init(struct iwl_priv *priv)
BUG_ON(device == NULL); BUG_ON(device == NULL);
IWL_DEBUG_RF_KILL("Initializing RFKILL.\n"); IWL_DEBUG_RF_KILL(priv, "Initializing RFKILL.\n");
priv->rfkill = rfkill_allocate(device, RFKILL_TYPE_WLAN); priv->rfkill = rfkill_allocate(device, RFKILL_TYPE_WLAN);
if (!priv->rfkill) { if (!priv->rfkill) {
IWL_ERR(priv, "Unable to allocate RFKILL device.\n"); IWL_ERR(priv, "Unable to allocate RFKILL device.\n");
@ -102,7 +102,7 @@ int iwl_rfkill_init(struct iwl_priv *priv)
goto free_rfkill; goto free_rfkill;
} }
IWL_DEBUG_RF_KILL("RFKILL initialization complete.\n"); IWL_DEBUG_RF_KILL(priv, "RFKILL initialization complete.\n");
return ret; return ret;
free_rfkill: free_rfkill:
@ -111,7 +111,7 @@ free_rfkill:
priv->rfkill = NULL; priv->rfkill = NULL;
error: error:
IWL_DEBUG_RF_KILL("RFKILL initialization complete.\n"); IWL_DEBUG_RF_KILL(priv, "RFKILL initialization complete.\n");
return ret; return ret;
} }
EXPORT_SYMBOL(iwl_rfkill_init); EXPORT_SYMBOL(iwl_rfkill_init);

37
drivers/net/wireless/iwlwifi/iwl-rx.c
View File

@ -494,7 +494,7 @@ void iwl_rx_missed_beacon_notif(struct iwl_priv *priv,
missed_beacon = &pkt->u.missed_beacon; missed_beacon = &pkt->u.missed_beacon;
if (le32_to_cpu(missed_beacon->consequtive_missed_beacons) > 5) { if (le32_to_cpu(missed_beacon->consequtive_missed_beacons) > 5) {
IWL_DEBUG_CALIB("missed bcn cnsq %d totl %d rcd %d expctd %d\n", IWL_DEBUG_CALIB(priv, "missed bcn cnsq %d totl %d rcd %d expctd %d\n",
le32_to_cpu(missed_beacon->consequtive_missed_beacons), le32_to_cpu(missed_beacon->consequtive_missed_beacons),
le32_to_cpu(missed_beacon->total_missed_becons), le32_to_cpu(missed_beacon->total_missed_becons),
le32_to_cpu(missed_beacon->num_recvd_beacons), le32_to_cpu(missed_beacon->num_recvd_beacons),
@ -541,7 +541,7 @@ static void iwl_rx_calc_noise(struct iwl_priv *priv)
else else
priv->last_rx_noise = IWL_NOISE_MEAS_NOT_AVAILABLE; priv->last_rx_noise = IWL_NOISE_MEAS_NOT_AVAILABLE;
IWL_DEBUG_CALIB("inband silence a %u, b %u, c %u, dBm %d\n", IWL_DEBUG_CALIB(priv, "inband silence a %u, b %u, c %u, dBm %d\n",
bcn_silence_a, bcn_silence_b, bcn_silence_c, bcn_silence_a, bcn_silence_b, bcn_silence_c,
priv->last_rx_noise); priv->last_rx_noise);
} }
@ -554,7 +554,7 @@ void iwl_rx_statistics(struct iwl_priv *priv,
int change; int change;
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data; struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
IWL_DEBUG_RX("Statistics notification received (%d vs %d).\n", IWL_DEBUG_RX(priv, "Statistics notification received (%d vs %d).\n",
(int)sizeof(priv->statistics), pkt->len); (int)sizeof(priv->statistics), pkt->len);
change = ((priv->statistics.general.temperature != change = ((priv->statistics.general.temperature !=
@ -741,13 +741,13 @@ static void iwl_dbg_report_frame(struct iwl_priv *priv,
* MAC addresses show just the last byte (for brevity), * MAC addresses show just the last byte (for brevity),
* but you can hack it to show more, if you'd like to. */ * but you can hack it to show more, if you'd like to. */
if (dataframe) if (dataframe)
IWL_DEBUG_RX("%s: mhd=0x%04x, dst=0x%02x, " IWL_DEBUG_RX(priv, "%s: mhd=0x%04x, dst=0x%02x, "
"len=%u, rssi=%d, chnl=%d, rate=%u, \n", "len=%u, rssi=%d, chnl=%d, rate=%u, \n",
title, le16_to_cpu(fc), header->addr1[5], title, le16_to_cpu(fc), header->addr1[5],
length, rssi, channel, bitrate); length, rssi, channel, bitrate);
else { else {
/* src/dst addresses assume managed mode */ /* src/dst addresses assume managed mode */
IWL_DEBUG_RX("%s: 0x%04x, dst=0x%02x, src=0x%02x, " IWL_DEBUG_RX(priv, "%s: 0x%04x, dst=0x%02x, src=0x%02x, "
"len=%u, rssi=%d, tim=%lu usec, " "len=%u, rssi=%d, tim=%lu usec, "
"phy=0x%02x, chnl=%d\n", "phy=0x%02x, chnl=%d\n",
title, le16_to_cpu(fc), header->addr1[5], title, le16_to_cpu(fc), header->addr1[5],
@ -772,10 +772,10 @@ static void iwl_update_rx_stats(struct iwl_priv *priv, u16 fc, u16 len)
/* /*
* returns non-zero if packet should be dropped * returns non-zero if packet should be dropped
*/ */
static int iwl_set_decrypted_flag(struct iwl_priv *priv, int iwl_set_decrypted_flag(struct iwl_priv *priv,
struct ieee80211_hdr *hdr, struct ieee80211_hdr *hdr,
u32 decrypt_res, u32 decrypt_res,
struct ieee80211_rx_status *stats) struct ieee80211_rx_status *stats)
{ {
u16 fc = le16_to_cpu(hdr->frame_control); u16 fc = le16_to_cpu(hdr->frame_control);
@ -785,7 +785,7 @@ static int iwl_set_decrypted_flag(struct iwl_priv *priv,
if (!(fc & IEEE80211_FCTL_PROTECTED)) if (!(fc & IEEE80211_FCTL_PROTECTED))
return 0; return 0;
IWL_DEBUG_RX("decrypt_res:0x%x\n", decrypt_res); IWL_DEBUG_RX(priv, "decrypt_res:0x%x\n", decrypt_res);
switch (decrypt_res & RX_RES_STATUS_SEC_TYPE_MSK) { switch (decrypt_res & RX_RES_STATUS_SEC_TYPE_MSK) {
case RX_RES_STATUS_SEC_TYPE_TKIP: case RX_RES_STATUS_SEC_TYPE_TKIP:
/* The uCode has got a bad phase 1 Key, pushes the packet. /* The uCode has got a bad phase 1 Key, pushes the packet.
@ -799,13 +799,13 @@ static int iwl_set_decrypted_flag(struct iwl_priv *priv,
RX_RES_STATUS_BAD_ICV_MIC) { RX_RES_STATUS_BAD_ICV_MIC) {
/* bad ICV, the packet is destroyed since the /* bad ICV, the packet is destroyed since the
* decryption is inplace, drop it */ * decryption is inplace, drop it */
IWL_DEBUG_RX("Packet destroyed\n"); IWL_DEBUG_RX(priv, "Packet destroyed\n");
return -1; return -1;
} }
case RX_RES_STATUS_SEC_TYPE_CCMP: case RX_RES_STATUS_SEC_TYPE_CCMP:
if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) == if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
RX_RES_STATUS_DECRYPT_OK) { RX_RES_STATUS_DECRYPT_OK) {
IWL_DEBUG_RX("hw decrypt successfully!!!\n"); IWL_DEBUG_RX(priv, "hw decrypt successfully!!!\n");
stats->flag |= RX_FLAG_DECRYPTED; stats->flag |= RX_FLAG_DECRYPTED;
} }
break; break;
@ -815,6 +815,7 @@ static int iwl_set_decrypted_flag(struct iwl_priv *priv,
} }
return 0; return 0;
} }
EXPORT_SYMBOL(iwl_set_decrypted_flag);
static u32 iwl_translate_rx_status(struct iwl_priv *priv, u32 decrypt_in) static u32 iwl_translate_rx_status(struct iwl_priv *priv, u32 decrypt_in)
{ {
@ -869,7 +870,7 @@ static u32 iwl_translate_rx_status(struct iwl_priv *priv, u32 decrypt_in)
break; break;
}; };
IWL_DEBUG_RX("decrypt_in:0x%x decrypt_out = 0x%x\n", IWL_DEBUG_RX(priv, "decrypt_in:0x%x decrypt_out = 0x%x\n",
decrypt_in, decrypt_out); decrypt_in, decrypt_out);
return decrypt_out; return decrypt_out;
@ -933,8 +934,8 @@ static void iwl_pass_packet_to_mac80211(struct iwl_priv *priv,
/* We only process data packets if the interface is open */ /* We only process data packets if the interface is open */
if (unlikely(!priv->is_open)) { if (unlikely(!priv->is_open)) {
IWL_DEBUG_DROP_LIMIT IWL_DEBUG_DROP_LIMIT(priv,
("Dropping packet while interface is not open.\n"); "Dropping packet while interface is not open.\n");
return; return;
} }
@ -1006,7 +1007,7 @@ void iwl_rx_reply_rx(struct iwl_priv *priv,
/*rx_status.flag |= RX_FLAG_TSFT;*/ /*rx_status.flag |= RX_FLAG_TSFT;*/
if ((unlikely(rx_start->cfg_phy_cnt > 20))) { if ((unlikely(rx_start->cfg_phy_cnt > 20))) {
IWL_DEBUG_DROP("dsp size out of range [0,20]: %d/n", IWL_DEBUG_DROP(priv, "dsp size out of range [0,20]: %d/n",
rx_start->cfg_phy_cnt); rx_start->cfg_phy_cnt);
return; return;
} }
@ -1044,7 +1045,7 @@ void iwl_rx_reply_rx(struct iwl_priv *priv,
if (!(*rx_end & RX_RES_STATUS_NO_CRC32_ERROR) || if (!(*rx_end & RX_RES_STATUS_NO_CRC32_ERROR) ||
!(*rx_end & RX_RES_STATUS_NO_RXE_OVERFLOW)) { !(*rx_end & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
IWL_DEBUG_RX("Bad CRC or FIFO: 0x%08X.\n", IWL_DEBUG_RX(priv, "Bad CRC or FIFO: 0x%08X.\n",
le32_to_cpu(*rx_end)); le32_to_cpu(*rx_end));
return; return;
} }
@ -1077,7 +1078,7 @@ void iwl_rx_reply_rx(struct iwl_priv *priv,
if (unlikely(priv->debug_level & IWL_DL_RX)) if (unlikely(priv->debug_level & IWL_DL_RX))
iwl_dbg_report_frame(priv, rx_start, len, header, 1); iwl_dbg_report_frame(priv, rx_start, len, header, 1);
#endif #endif
IWL_DEBUG_STATS_LIMIT("Rssi %d, noise %d, qual %d, TSF %llu\n", IWL_DEBUG_STATS_LIMIT(priv, "Rssi %d, noise %d, qual %d, TSF %llu\n",
rx_status.signal, rx_status.noise, rx_status.signal, rx_status.signal, rx_status.noise, rx_status.signal,
(unsigned long long)rx_status.mactime); (unsigned long long)rx_status.mactime);

62
drivers/net/wireless/iwlwifi/iwl-scan.c
View File

@ -70,12 +70,12 @@ int iwl_scan_cancel(struct iwl_priv *priv)
if (test_bit(STATUS_SCANNING, &priv->status)) { if (test_bit(STATUS_SCANNING, &priv->status)) {
if (!test_bit(STATUS_SCAN_ABORTING, &priv->status)) { if (!test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
IWL_DEBUG_SCAN("Queuing scan abort.\n"); IWL_DEBUG_SCAN(priv, "Queuing scan abort.\n");
set_bit(STATUS_SCAN_ABORTING, &priv->status); set_bit(STATUS_SCAN_ABORTING, &priv->status);
queue_work(priv->workqueue, &priv->abort_scan); queue_work(priv->workqueue, &priv->abort_scan);
} else } else
IWL_DEBUG_SCAN("Scan abort already in progress.\n"); IWL_DEBUG_SCAN(priv, "Scan abort already in progress.\n");
return test_bit(STATUS_SCANNING, &priv->status); return test_bit(STATUS_SCANNING, &priv->status);
} }
@ -140,7 +140,7 @@ int iwl_send_scan_abort(struct iwl_priv *priv)
* can occur if we send the scan abort before we * can occur if we send the scan abort before we
* the microcode has notified us that a scan is * the microcode has notified us that a scan is
* completed. */ * completed. */
IWL_DEBUG_INFO("SCAN_ABORT returned %d.\n", res->u.status); IWL_DEBUG_INFO(priv, "SCAN_ABORT returned %d.\n", res->u.status);
clear_bit(STATUS_SCAN_ABORTING, &priv->status); clear_bit(STATUS_SCAN_ABORTING, &priv->status);
clear_bit(STATUS_SCAN_HW, &priv->status); clear_bit(STATUS_SCAN_HW, &priv->status);
} }
@ -161,7 +161,7 @@ static void iwl_rx_reply_scan(struct iwl_priv *priv,
struct iwl_scanreq_notification *notif = struct iwl_scanreq_notification *notif =
(struct iwl_scanreq_notification *)pkt->u.raw; (struct iwl_scanreq_notification *)pkt->u.raw;
IWL_DEBUG_RX("Scan request status = 0x%x\n", notif->status); IWL_DEBUG_RX(priv, "Scan request status = 0x%x\n", notif->status);
#endif #endif
} }
@ -173,7 +173,7 @@ static void iwl_rx_scan_start_notif(struct iwl_priv *priv,
struct iwl_scanstart_notification *notif = struct iwl_scanstart_notification *notif =
(struct iwl_scanstart_notification *)pkt->u.raw; (struct iwl_scanstart_notification *)pkt->u.raw;
priv->scan_start_tsf = le32_to_cpu(notif->tsf_low); priv->scan_start_tsf = le32_to_cpu(notif->tsf_low);
IWL_DEBUG_SCAN("Scan start: " IWL_DEBUG_SCAN(priv, "Scan start: "
"%d [802.11%s] " "%d [802.11%s] "
"(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n", "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
notif->channel, notif->channel,
@ -192,7 +192,7 @@ static void iwl_rx_scan_results_notif(struct iwl_priv *priv,
struct iwl_scanresults_notification *notif = struct iwl_scanresults_notification *notif =
(struct iwl_scanresults_notification *)pkt->u.raw; (struct iwl_scanresults_notification *)pkt->u.raw;
IWL_DEBUG_SCAN("Scan ch.res: " IWL_DEBUG_SCAN(priv, "Scan ch.res: "
"%d [802.11%s] " "%d [802.11%s] "
"(TSF: 0x%08X:%08X) - %d " "(TSF: 0x%08X:%08X) - %d "
"elapsed=%lu usec (%dms since last)\n", "elapsed=%lu usec (%dms since last)\n",
@ -218,7 +218,7 @@ static void iwl_rx_scan_complete_notif(struct iwl_priv *priv,
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data; struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
struct iwl_scancomplete_notification *scan_notif = (void *)pkt->u.raw; struct iwl_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
IWL_DEBUG_SCAN("Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n", IWL_DEBUG_SCAN(priv, "Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
scan_notif->scanned_channels, scan_notif->scanned_channels,
scan_notif->tsf_low, scan_notif->tsf_low,
scan_notif->tsf_high, scan_notif->status); scan_notif->tsf_high, scan_notif->status);
@ -230,7 +230,7 @@ static void iwl_rx_scan_complete_notif(struct iwl_priv *priv,
/* The scan completion notification came in, so kill that timer... */ /* The scan completion notification came in, so kill that timer... */
cancel_delayed_work(&priv->scan_check); cancel_delayed_work(&priv->scan_check);
IWL_DEBUG_INFO("Scan pass on %sGHz took %dms\n", IWL_DEBUG_INFO(priv, "Scan pass on %sGHz took %dms\n",
(priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ? (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
"2.4" : "5.2", "2.4" : "5.2",
jiffies_to_msecs(elapsed_jiffies jiffies_to_msecs(elapsed_jiffies
@ -248,7 +248,7 @@ static void iwl_rx_scan_complete_notif(struct iwl_priv *priv,
* then we reset the scan state machine and terminate, * then we reset the scan state machine and terminate,
* re-queuing another scan if one has been requested */ * re-queuing another scan if one has been requested */
if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) { if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
IWL_DEBUG_INFO("Aborted scan completed.\n"); IWL_DEBUG_INFO(priv, "Aborted scan completed.\n");
clear_bit(STATUS_SCAN_ABORTING, &priv->status); clear_bit(STATUS_SCAN_ABORTING, &priv->status);
} else { } else {
/* If there are more bands on this scan pass reschedule */ /* If there are more bands on this scan pass reschedule */
@ -258,11 +258,11 @@ static void iwl_rx_scan_complete_notif(struct iwl_priv *priv,
priv->last_scan_jiffies = jiffies; priv->last_scan_jiffies = jiffies;
priv->next_scan_jiffies = 0; priv->next_scan_jiffies = 0;
IWL_DEBUG_INFO("Setting scan to off\n"); IWL_DEBUG_INFO(priv, "Setting scan to off\n");
clear_bit(STATUS_SCANNING, &priv->status); clear_bit(STATUS_SCANNING, &priv->status);
IWL_DEBUG_INFO("Scan took %dms\n", IWL_DEBUG_INFO(priv, "Scan took %dms\n",
jiffies_to_msecs(elapsed_jiffies(priv->scan_start, jiffies))); jiffies_to_msecs(elapsed_jiffies(priv->scan_start, jiffies)));
queue_work(priv->workqueue, &priv->scan_completed); queue_work(priv->workqueue, &priv->scan_completed);
@ -355,7 +355,7 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
ch_info = iwl_get_channel_info(priv, band, channel); ch_info = iwl_get_channel_info(priv, band, channel);
if (!is_channel_valid(ch_info)) { if (!is_channel_valid(ch_info)) {
IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n", IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
channel); channel);
continue; continue;
} }
@ -384,7 +384,7 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
else else
scan_ch->tx_gain = ((1 << 5) | (5 << 3)); scan_ch->tx_gain = ((1 << 5) | (5 << 3));
IWL_DEBUG_SCAN("Scanning ch=%d prob=0x%X [%s %d]\n", IWL_DEBUG_SCAN(priv, "Scanning ch=%d prob=0x%X [%s %d]\n",
channel, le32_to_cpu(scan_ch->type), channel, le32_to_cpu(scan_ch->type),
(scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ? (scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ?
"ACTIVE" : "PASSIVE", "ACTIVE" : "PASSIVE",
@ -395,7 +395,7 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
added++; added++;
} }
IWL_DEBUG_SCAN("total channels to scan %d \n", added); IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
return added; return added;
} }
@ -411,21 +411,21 @@ void iwl_init_scan_params(struct iwl_priv *priv)
int iwl_scan_initiate(struct iwl_priv *priv) int iwl_scan_initiate(struct iwl_priv *priv)
{ {
if (!iwl_is_ready_rf(priv)) { if (!iwl_is_ready_rf(priv)) {
IWL_DEBUG_SCAN("Aborting scan due to not ready.\n"); IWL_DEBUG_SCAN(priv, "Aborting scan due to not ready.\n");
return -EIO; return -EIO;
} }
if (test_bit(STATUS_SCANNING, &priv->status)) { if (test_bit(STATUS_SCANNING, &priv->status)) {
IWL_DEBUG_SCAN("Scan already in progress.\n"); IWL_DEBUG_SCAN(priv, "Scan already in progress.\n");
return -EAGAIN; return -EAGAIN;
} }
if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) { if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
IWL_DEBUG_SCAN("Scan request while abort pending\n"); IWL_DEBUG_SCAN(priv, "Scan request while abort pending\n");
return -EAGAIN; return -EAGAIN;
} }
IWL_DEBUG_INFO("Starting scan...\n"); IWL_DEBUG_INFO(priv, "Starting scan...\n");
if (priv->cfg->sku & IWL_SKU_G) if (priv->cfg->sku & IWL_SKU_G)
priv->scan_bands |= BIT(IEEE80211_BAND_2GHZ); priv->scan_bands |= BIT(IEEE80211_BAND_2GHZ);
if (priv->cfg->sku & IWL_SKU_A) if (priv->cfg->sku & IWL_SKU_A)
@ -453,7 +453,7 @@ void iwl_bg_scan_check(struct work_struct *data)
mutex_lock(&priv->mutex); mutex_lock(&priv->mutex);
if (test_bit(STATUS_SCANNING, &priv->status) || if (test_bit(STATUS_SCANNING, &priv->status) ||
test_bit(STATUS_SCAN_ABORTING, &priv->status)) { test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
IWL_DEBUG(IWL_DL_SCAN, "Scan completion watchdog resetting " IWL_DEBUG_SCAN(priv, "Scan completion watchdog resetting "
"adapter (%dms)\n", "adapter (%dms)\n",
jiffies_to_msecs(IWL_SCAN_CHECK_WATCHDOG)); jiffies_to_msecs(IWL_SCAN_CHECK_WATCHDOG));
@ -657,34 +657,34 @@ static void iwl_bg_request_scan(struct work_struct *data)
/* This should never be called or scheduled if there is currently /* This should never be called or scheduled if there is currently
* a scan active in the hardware. */ * a scan active in the hardware. */
if (test_bit(STATUS_SCAN_HW, &priv->status)) { if (test_bit(STATUS_SCAN_HW, &priv->status)) {
IWL_DEBUG_INFO("Multiple concurrent scan requests in parallel. " IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests in parallel. "
"Ignoring second request.\n"); "Ignoring second request.\n");
ret = -EIO; ret = -EIO;
goto done; goto done;
} }
if (test_bit(STATUS_EXIT_PENDING, &priv->status)) { if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
IWL_DEBUG_SCAN("Aborting scan due to device shutdown\n"); IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
goto done; goto done;
} }
if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) { if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
IWL_DEBUG_HC("Scan request while abort pending. Queuing.\n"); IWL_DEBUG_HC(priv, "Scan request while abort pending. Queuing.\n");
goto done; goto done;
} }
if (iwl_is_rfkill(priv)) { if (iwl_is_rfkill(priv)) {
IWL_DEBUG_HC("Aborting scan due to RF Kill activation\n"); IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
goto done; goto done;
} }
if (!test_bit(STATUS_READY, &priv->status)) { if (!test_bit(STATUS_READY, &priv->status)) {
IWL_DEBUG_HC("Scan request while uninitialized. Queuing.\n"); IWL_DEBUG_HC(priv, "Scan request while uninitialized. Queuing.\n");
goto done; goto done;
} }
if (!priv->scan_bands) { if (!priv->scan_bands) {
IWL_DEBUG_HC("Aborting scan due to no requested bands\n"); IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
goto done; goto done;
} }
@ -709,7 +709,7 @@ static void iwl_bg_request_scan(struct work_struct *data)
u32 scan_suspend_time = 100; u32 scan_suspend_time = 100;
unsigned long flags; unsigned long flags;
IWL_DEBUG_INFO("Scanning while associated...\n"); IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
interval = priv->beacon_int; interval = priv->beacon_int;
@ -724,13 +724,13 @@ static void iwl_bg_request_scan(struct work_struct *data)
scan_suspend_time = (extra | scan_suspend_time = (extra |
((suspend_time % interval) * 1024)); ((suspend_time % interval) * 1024));
scan->suspend_time = cpu_to_le32(scan_suspend_time); scan->suspend_time = cpu_to_le32(scan_suspend_time);
IWL_DEBUG_SCAN("suspend_time 0x%X beacon interval %d\n", IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
scan_suspend_time, interval); scan_suspend_time, interval);
} }
/* We should add the ability for user to lock to PASSIVE ONLY */ /* We should add the ability for user to lock to PASSIVE ONLY */
if (priv->one_direct_scan) { if (priv->one_direct_scan) {
IWL_DEBUG_SCAN("Start direct scan for '%s'\n", IWL_DEBUG_SCAN(priv, "Start direct scan for '%s'\n",
print_ssid(ssid, priv->direct_ssid, print_ssid(ssid, priv->direct_ssid,
priv->direct_ssid_len)); priv->direct_ssid_len));
scan->direct_scan[0].id = WLAN_EID_SSID; scan->direct_scan[0].id = WLAN_EID_SSID;
@ -739,7 +739,7 @@ static void iwl_bg_request_scan(struct work_struct *data)
priv->direct_ssid, priv->direct_ssid_len); priv->direct_ssid, priv->direct_ssid_len);
n_probes++; n_probes++;
} else { } else {
IWL_DEBUG_SCAN("Start indirect scan.\n"); IWL_DEBUG_SCAN(priv, "Start indirect scan.\n");
} }
scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK; scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
@ -801,7 +801,7 @@ static void iwl_bg_request_scan(struct work_struct *data)
(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]); (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
if (scan->channel_count == 0) { if (scan->channel_count == 0) {
IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count); IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
goto done; goto done;
} }
@ -855,7 +855,7 @@ void iwl_bg_scan_completed(struct work_struct *work)
struct iwl_priv *priv = struct iwl_priv *priv =
container_of(work, struct iwl_priv, scan_completed); container_of(work, struct iwl_priv, scan_completed);
IWL_DEBUG_SCAN("SCAN complete scan\n"); IWL_DEBUG_SCAN(priv, "SCAN complete scan\n");
if (test_bit(STATUS_EXIT_PENDING, &priv->status)) if (test_bit(STATUS_EXIT_PENDING, &priv->status))
return; return;

8
drivers/net/wireless/iwlwifi/iwl-spectrum.c
View File

@ -154,9 +154,9 @@ static int iwl_get_measurement(struct iwl_priv *priv,
switch (spectrum_resp_status) { switch (spectrum_resp_status) {
case 0: /* Command will be handled */ case 0: /* Command will be handled */
if (res->u.spectrum.id != 0xff) { if (res->u.spectrum.id != 0xff) {
IWL_DEBUG_INFO IWL_DEBUG_INFO(priv,
("Replaced existing measurement: %d\n", "Replaced existing measurement: %d\n",
res->u.spectrum.id); res->u.spectrum.id);
priv->measurement_status &= ~MEASUREMENT_READY; priv->measurement_status &= ~MEASUREMENT_READY;
} }
priv->measurement_status |= MEASUREMENT_ACTIVE; priv->measurement_status |= MEASUREMENT_ACTIVE;
@ -181,7 +181,7 @@ static void iwl_rx_spectrum_measure_notif(struct iwl_priv *priv,
struct iwl_spectrum_notification *report = &(pkt->u.spectrum_notif); struct iwl_spectrum_notification *report = &(pkt->u.spectrum_notif);
if (!report->state) { if (!report->state) {
IWL_DEBUG(IWL_DL_11H, IWL_DEBUG_11H(priv,
"Spectrum Measure Notification: Start\n"); "Spectrum Measure Notification: Start\n");
return; return;
} }

36
drivers/net/wireless/iwlwifi/iwl-sta.c
View File

@ -60,7 +60,7 @@ u8 iwl_find_station(struct iwl_priv *priv, const u8 *addr)
goto out; goto out;
} }
IWL_DEBUG_ASSOC_LIMIT("can not find STA %pM total %d\n", IWL_DEBUG_ASSOC_LIMIT(priv, "can not find STA %pM total %d\n",
addr, priv->num_stations); addr, priv->num_stations);
out: out:
@ -92,7 +92,7 @@ static void iwl_sta_ucode_activate(struct iwl_priv *priv, u8 sta_id)
sta_id); sta_id);
priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE; priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE;
IWL_DEBUG_ASSOC("Added STA to Ucode: %pM\n", IWL_DEBUG_ASSOC(priv, "Added STA to Ucode: %pM\n",
priv->stations[sta_id].sta.sta.addr); priv->stations[sta_id].sta.sta.addr);
spin_unlock_irqrestore(&priv->sta_lock, flags); spin_unlock_irqrestore(&priv->sta_lock, flags);
@ -123,7 +123,7 @@ static int iwl_add_sta_callback(struct iwl_priv *priv,
iwl_sta_ucode_activate(priv, sta_id); iwl_sta_ucode_activate(priv, sta_id);
/* fall through */ /* fall through */
default: default:
IWL_DEBUG_HC("Received REPLY_ADD_STA:(0x%08X)\n", IWL_DEBUG_HC(priv, "Received REPLY_ADD_STA:(0x%08X)\n",
res->u.add_sta.status); res->u.add_sta.status);
break; break;
} }
@ -166,7 +166,7 @@ int iwl_send_add_sta(struct iwl_priv *priv,
switch (res->u.add_sta.status) { switch (res->u.add_sta.status) {
case ADD_STA_SUCCESS_MSK: case ADD_STA_SUCCESS_MSK:
iwl_sta_ucode_activate(priv, sta->sta.sta_id); iwl_sta_ucode_activate(priv, sta->sta.sta_id);
IWL_DEBUG_INFO("REPLY_ADD_STA PASSED\n"); IWL_DEBUG_INFO(priv, "REPLY_ADD_STA PASSED\n");
break; break;
default: default:
ret = -EIO; ret = -EIO;
@ -272,7 +272,7 @@ u8 iwl_add_station_flags(struct iwl_priv *priv, const u8 *addr, int is_ap,
station = &priv->stations[sta_id]; station = &priv->stations[sta_id];
station->used = IWL_STA_DRIVER_ACTIVE; station->used = IWL_STA_DRIVER_ACTIVE;
IWL_DEBUG_ASSOC("Add STA to driver ID %d: %pM\n", IWL_DEBUG_ASSOC(priv, "Add STA to driver ID %d: %pM\n",
sta_id, addr); sta_id, addr);
priv->num_stations++; priv->num_stations++;
@ -304,7 +304,7 @@ static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, const char *addr)
BUG_ON(sta_id == IWL_INVALID_STATION); BUG_ON(sta_id == IWL_INVALID_STATION);
IWL_DEBUG_ASSOC("Removed STA from Ucode: %pM\n", addr); IWL_DEBUG_ASSOC(priv, "Removed STA from Ucode: %pM\n", addr);
spin_lock_irqsave(&priv->sta_lock, flags); spin_lock_irqsave(&priv->sta_lock, flags);
@ -390,7 +390,7 @@ static int iwl_send_remove_station(struct iwl_priv *priv, const u8 *addr,
switch (res->u.rem_sta.status) { switch (res->u.rem_sta.status) {
case REM_STA_SUCCESS_MSK: case REM_STA_SUCCESS_MSK:
iwl_sta_ucode_deactivate(priv, addr); iwl_sta_ucode_deactivate(priv, addr);
IWL_DEBUG_ASSOC("REPLY_REMOVE_STA PASSED\n"); IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n");
break; break;
default: default:
ret = -EIO; ret = -EIO;
@ -432,7 +432,7 @@ int iwl_remove_station(struct iwl_priv *priv, const u8 *addr, int is_ap)
if (unlikely(sta_id == IWL_INVALID_STATION)) if (unlikely(sta_id == IWL_INVALID_STATION))
goto out; goto out;
IWL_DEBUG_ASSOC("Removing STA from driver:%d %pM\n", IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d %pM\n",
sta_id, addr); sta_id, addr);
if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) { if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
@ -560,7 +560,7 @@ int iwl_remove_default_wep_key(struct iwl_priv *priv,
priv->default_wep_key--; priv->default_wep_key--;
memset(&priv->wep_keys[keyconf->keyidx], 0, sizeof(priv->wep_keys[0])); memset(&priv->wep_keys[keyconf->keyidx], 0, sizeof(priv->wep_keys[0]));
ret = iwl_send_static_wepkey_cmd(priv, 1); ret = iwl_send_static_wepkey_cmd(priv, 1);
IWL_DEBUG_WEP("Remove default WEP key: idx=%d ret=%d\n", IWL_DEBUG_WEP(priv, "Remove default WEP key: idx=%d ret=%d\n",
keyconf->keyidx, ret); keyconf->keyidx, ret);
spin_unlock_irqrestore(&priv->sta_lock, flags); spin_unlock_irqrestore(&priv->sta_lock, flags);
@ -576,7 +576,7 @@ int iwl_set_default_wep_key(struct iwl_priv *priv,
if (keyconf->keylen != WEP_KEY_LEN_128 && if (keyconf->keylen != WEP_KEY_LEN_128 &&
keyconf->keylen != WEP_KEY_LEN_64) { keyconf->keylen != WEP_KEY_LEN_64) {
IWL_DEBUG_WEP("Bad WEP key length %d\n", keyconf->keylen); IWL_DEBUG_WEP(priv, "Bad WEP key length %d\n", keyconf->keylen);
return -EINVAL; return -EINVAL;
} }
@ -596,7 +596,7 @@ int iwl_set_default_wep_key(struct iwl_priv *priv,
keyconf->keylen); keyconf->keylen);
ret = iwl_send_static_wepkey_cmd(priv, 0); ret = iwl_send_static_wepkey_cmd(priv, 0);
IWL_DEBUG_WEP("Set default WEP key: len=%d idx=%d ret=%d\n", IWL_DEBUG_WEP(priv, "Set default WEP key: len=%d idx=%d ret=%d\n",
keyconf->keylen, keyconf->keyidx, ret); keyconf->keylen, keyconf->keyidx, ret);
spin_unlock_irqrestore(&priv->sta_lock, flags); spin_unlock_irqrestore(&priv->sta_lock, flags);
@ -752,7 +752,7 @@ void iwl_update_tkip_key(struct iwl_priv *priv,
sta_id = iwl_find_station(priv, addr); sta_id = iwl_find_station(priv, addr);
if (sta_id == IWL_INVALID_STATION) { if (sta_id == IWL_INVALID_STATION) {
IWL_DEBUG_MAC80211("leave - %pM not in station map.\n", IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
addr); addr);
return; return;
} }
@ -804,7 +804,7 @@ int iwl_remove_dynamic_key(struct iwl_priv *priv,
key_flags = le16_to_cpu(priv->stations[sta_id].sta.key.key_flags); key_flags = le16_to_cpu(priv->stations[sta_id].sta.key.key_flags);
keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3; keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;
IWL_DEBUG_WEP("Remove dynamic key: idx=%d sta=%d\n", IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
keyconf->keyidx, sta_id); keyconf->keyidx, sta_id);
if (keyconf->keyidx != keyidx) { if (keyconf->keyidx != keyidx) {
@ -868,7 +868,7 @@ int iwl_set_dynamic_key(struct iwl_priv *priv,
ret = -EINVAL; ret = -EINVAL;
} }
IWL_DEBUG_WEP("Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n", IWL_DEBUG_WEP(priv, "Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n",
keyconf->alg, keyconf->keylen, keyconf->keyidx, keyconf->alg, keyconf->keylen, keyconf->keyidx,
sta_id, ret); sta_id, ret);
@ -881,13 +881,13 @@ static void iwl_dump_lq_cmd(struct iwl_priv *priv,
struct iwl_link_quality_cmd *lq) struct iwl_link_quality_cmd *lq)
{ {
int i; int i;
IWL_DEBUG_RATE("lq station id 0x%x\n", lq->sta_id); IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id);
IWL_DEBUG_RATE("lq ant 0x%X 0x%X\n", IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n",
lq->general_params.single_stream_ant_msk, lq->general_params.single_stream_ant_msk,
lq->general_params.dual_stream_ant_msk); lq->general_params.dual_stream_ant_msk);
for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
IWL_DEBUG_RATE("lq index %d 0x%X\n", IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n",
i, lq->rs_table[i].rate_n_flags); i, lq->rs_table[i].rate_n_flags);
} }
#else #else
@ -1064,7 +1064,7 @@ int iwl_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
if (sta_id != IWL_INVALID_STATION) if (sta_id != IWL_INVALID_STATION)
return sta_id; return sta_id;
IWL_DEBUG_DROP("Station %pM not in station map. " IWL_DEBUG_DROP(priv, "Station %pM not in station map. "
"Defaulting to broadcast...\n", "Defaulting to broadcast...\n",
hdr->addr1); hdr->addr1);
iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr)); iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));

54
drivers/net/wireless/iwlwifi/iwl-tx.c
View File

@ -96,7 +96,7 @@ int iwl_txq_update_write_ptr(struct iwl_priv *priv, struct iwl_tx_queue *txq)
reg = iwl_read32(priv, CSR_UCODE_DRV_GP1); reg = iwl_read32(priv, CSR_UCODE_DRV_GP1);
if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) { if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
IWL_DEBUG_INFO("Requesting wakeup, GP1 = 0x%x\n", reg); IWL_DEBUG_INFO(priv, "Requesting wakeup, GP1 = 0x%x\n", reg);
iwl_set_bit(priv, CSR_GP_CNTRL, iwl_set_bit(priv, CSR_GP_CNTRL,
CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ); CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
return ret; return ret;
@ -638,14 +638,14 @@ static void iwl_tx_cmd_build_hwcrypto(struct iwl_priv *priv,
memcpy(tx_cmd->key, keyconf->key, keyconf->keylen); memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
if (info->flags & IEEE80211_TX_CTL_AMPDU) if (info->flags & IEEE80211_TX_CTL_AMPDU)
tx_cmd->tx_flags |= TX_CMD_FLG_AGG_CCMP_MSK; tx_cmd->tx_flags |= TX_CMD_FLG_AGG_CCMP_MSK;
IWL_DEBUG_TX("tx_cmd with AES hwcrypto\n"); IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
break; break;
case ALG_TKIP: case ALG_TKIP:
tx_cmd->sec_ctl = TX_CMD_SEC_TKIP; tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
ieee80211_get_tkip_key(keyconf, skb_frag, ieee80211_get_tkip_key(keyconf, skb_frag,
IEEE80211_TKIP_P2_KEY, tx_cmd->key); IEEE80211_TKIP_P2_KEY, tx_cmd->key);
IWL_DEBUG_TX("tx_cmd with tkip hwcrypto\n"); IWL_DEBUG_TX(priv, "tx_cmd with tkip hwcrypto\n");
break; break;
case ALG_WEP: case ALG_WEP:
@ -657,7 +657,7 @@ static void iwl_tx_cmd_build_hwcrypto(struct iwl_priv *priv,
memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen); memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
IWL_DEBUG_TX("Configuring packet for WEP encryption " IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
"with key %d\n", keyconf->keyidx); "with key %d\n", keyconf->keyidx);
break; break;
@ -703,7 +703,7 @@ int iwl_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
if (iwl_is_rfkill(priv)) { if (iwl_is_rfkill(priv)) {
IWL_DEBUG_DROP("Dropping - RF KILL\n"); IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
goto drop_unlock; goto drop_unlock;
} }
@ -717,11 +717,11 @@ int iwl_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
#ifdef CONFIG_IWLWIFI_DEBUG #ifdef CONFIG_IWLWIFI_DEBUG
if (ieee80211_is_auth(fc)) if (ieee80211_is_auth(fc))
IWL_DEBUG_TX("Sending AUTH frame\n"); IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
else if (ieee80211_is_assoc_req(fc)) else if (ieee80211_is_assoc_req(fc))
IWL_DEBUG_TX("Sending ASSOC frame\n"); IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
else if (ieee80211_is_reassoc_req(fc)) else if (ieee80211_is_reassoc_req(fc))
IWL_DEBUG_TX("Sending REASSOC frame\n"); IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
#endif #endif
/* drop all data frame if we are not associated */ /* drop all data frame if we are not associated */
@ -731,7 +731,7 @@ int iwl_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
(!iwl_is_associated(priv) || (!iwl_is_associated(priv) ||
((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id) || ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id) ||
!priv->assoc_station_added)) { !priv->assoc_station_added)) {
IWL_DEBUG_DROP("Dropping - !iwl_is_associated\n"); IWL_DEBUG_DROP(priv, "Dropping - !iwl_is_associated\n");
goto drop_unlock; goto drop_unlock;
} }
@ -742,12 +742,12 @@ int iwl_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
/* Find (or create) index into station table for destination station */ /* Find (or create) index into station table for destination station */
sta_id = iwl_get_sta_id(priv, hdr); sta_id = iwl_get_sta_id(priv, hdr);
if (sta_id == IWL_INVALID_STATION) { if (sta_id == IWL_INVALID_STATION) {
IWL_DEBUG_DROP("Dropping - INVALID STATION: %pM\n", IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
hdr->addr1); hdr->addr1);
goto drop; goto drop;
} }
IWL_DEBUG_TX("station Id %d\n", sta_id); IWL_DEBUG_TX(priv, "station Id %d\n", sta_id);
swq_id = skb_get_queue_mapping(skb); swq_id = skb_get_queue_mapping(skb);
txq_id = swq_id; txq_id = swq_id;
@ -757,7 +757,7 @@ int iwl_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
seq_number = priv->stations[sta_id].tid[tid].seq_number; seq_number = priv->stations[sta_id].tid[tid].seq_number;
seq_number &= IEEE80211_SCTL_SEQ; seq_number &= IEEE80211_SCTL_SEQ;
hdr->seq_ctrl = hdr->seq_ctrl & hdr->seq_ctrl = hdr->seq_ctrl &
__constant_cpu_to_le16(IEEE80211_SCTL_FRAG); cpu_to_le16(IEEE80211_SCTL_FRAG);
hdr->seq_ctrl |= cpu_to_le16(seq_number); hdr->seq_ctrl |= cpu_to_le16(seq_number);
seq_number += 0x10; seq_number += 0x10;
/* aggregation is on for this <sta,tid> */ /* aggregation is on for this <sta,tid> */
@ -938,7 +938,7 @@ int iwl_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
!(cmd->meta.flags & CMD_SIZE_HUGE)); !(cmd->meta.flags & CMD_SIZE_HUGE));
if (iwl_is_rfkill(priv)) { if (iwl_is_rfkill(priv)) {
IWL_DEBUG_INFO("Not sending command - RF KILL"); IWL_DEBUG_INFO(priv, "Not sending command - RF KILL");
return -EIO; return -EIO;
} }
@ -981,7 +981,7 @@ int iwl_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
switch (out_cmd->hdr.cmd) { switch (out_cmd->hdr.cmd) {
case REPLY_TX_LINK_QUALITY_CMD: case REPLY_TX_LINK_QUALITY_CMD:
case SENSITIVITY_CMD: case SENSITIVITY_CMD:
IWL_DEBUG_HC_DUMP("Sending command %s (#%x), seq: 0x%04X, " IWL_DEBUG_HC_DUMP(priv, "Sending command %s (#%x), seq: 0x%04X, "
"%d bytes at %d[%d]:%d\n", "%d bytes at %d[%d]:%d\n",
get_cmd_string(out_cmd->hdr.cmd), get_cmd_string(out_cmd->hdr.cmd),
out_cmd->hdr.cmd, out_cmd->hdr.cmd,
@ -989,7 +989,7 @@ int iwl_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
q->write_ptr, idx, IWL_CMD_QUEUE_NUM); q->write_ptr, idx, IWL_CMD_QUEUE_NUM);
break; break;
default: default:
IWL_DEBUG_HC("Sending command %s (#%x), seq: 0x%04X, " IWL_DEBUG_HC(priv, "Sending command %s (#%x), seq: 0x%04X, "
"%d bytes at %d[%d]:%d\n", "%d bytes at %d[%d]:%d\n",
get_cmd_string(out_cmd->hdr.cmd), get_cmd_string(out_cmd->hdr.cmd),
out_cmd->hdr.cmd, out_cmd->hdr.cmd,
@ -1194,7 +1194,7 @@ int iwl_tx_agg_start(struct iwl_priv *priv, const u8 *ra, u16 tid, u16 *ssn)
tid_data->agg.state = IWL_AGG_ON; tid_data->agg.state = IWL_AGG_ON;
ieee80211_start_tx_ba_cb_irqsafe(priv->hw, ra, tid); ieee80211_start_tx_ba_cb_irqsafe(priv->hw, ra, tid);
} else { } else {
IWL_DEBUG_HT("HW queue is NOT empty: %d packets in HW queue\n", IWL_DEBUG_HT(priv, "HW queue is NOT empty: %d packets in HW queue\n",
tid_data->tfds_in_queue); tid_data->tfds_in_queue);
tid_data->agg.state = IWL_EMPTYING_HW_QUEUE_ADDBA; tid_data->agg.state = IWL_EMPTYING_HW_QUEUE_ADDBA;
} }
@ -1235,13 +1235,13 @@ int iwl_tx_agg_stop(struct iwl_priv *priv , const u8 *ra, u16 tid)
/* The queue is not empty */ /* The queue is not empty */
if (write_ptr != read_ptr) { if (write_ptr != read_ptr) {
IWL_DEBUG_HT("Stopping a non empty AGG HW QUEUE\n"); IWL_DEBUG_HT(priv, "Stopping a non empty AGG HW QUEUE\n");
priv->stations[sta_id].tid[tid].agg.state = priv->stations[sta_id].tid[tid].agg.state =
IWL_EMPTYING_HW_QUEUE_DELBA; IWL_EMPTYING_HW_QUEUE_DELBA;
return 0; return 0;
} }
IWL_DEBUG_HT("HW queue is empty\n"); IWL_DEBUG_HT(priv, "HW queue is empty\n");
priv->stations[sta_id].tid[tid].agg.state = IWL_AGG_OFF; priv->stations[sta_id].tid[tid].agg.state = IWL_AGG_OFF;
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
@ -1272,7 +1272,7 @@ int iwl_txq_check_empty(struct iwl_priv *priv, int sta_id, u8 tid, int txq_id)
(q->read_ptr == q->write_ptr)) { (q->read_ptr == q->write_ptr)) {
u16 ssn = SEQ_TO_SN(tid_data->seq_number); u16 ssn = SEQ_TO_SN(tid_data->seq_number);
int tx_fifo = default_tid_to_tx_fifo[tid]; int tx_fifo = default_tid_to_tx_fifo[tid];
IWL_DEBUG_HT("HW queue empty: continue DELBA flow\n"); IWL_DEBUG_HT(priv, "HW queue empty: continue DELBA flow\n");
priv->cfg->ops->lib->txq_agg_disable(priv, txq_id, priv->cfg->ops->lib->txq_agg_disable(priv, txq_id,
ssn, tx_fifo); ssn, tx_fifo);
tid_data->agg.state = IWL_AGG_OFF; tid_data->agg.state = IWL_AGG_OFF;
@ -1282,7 +1282,7 @@ int iwl_txq_check_empty(struct iwl_priv *priv, int sta_id, u8 tid, int txq_id)
case IWL_EMPTYING_HW_QUEUE_ADDBA: case IWL_EMPTYING_HW_QUEUE_ADDBA:
/* We are reclaiming the last packet of the queue */ /* We are reclaiming the last packet of the queue */
if (tid_data->tfds_in_queue == 0) { if (tid_data->tfds_in_queue == 0) {
IWL_DEBUG_HT("HW queue empty: continue ADDBA flow\n"); IWL_DEBUG_HT(priv, "HW queue empty: continue ADDBA flow\n");
tid_data->agg.state = IWL_AGG_ON; tid_data->agg.state = IWL_AGG_ON;
ieee80211_start_tx_ba_cb_irqsafe(priv->hw, addr, tid); ieee80211_start_tx_ba_cb_irqsafe(priv->hw, addr, tid);
} }
@ -1317,7 +1317,7 @@ static int iwl_tx_status_reply_compressed_ba(struct iwl_priv *priv,
/* Mark that the expected block-ack response arrived */ /* Mark that the expected block-ack response arrived */
agg->wait_for_ba = 0; agg->wait_for_ba = 0;
IWL_DEBUG_TX_REPLY("BA %d %d\n", agg->start_idx, ba_resp->seq_ctl); IWL_DEBUG_TX_REPLY(priv, "BA %d %d\n", agg->start_idx, ba_resp->seq_ctl);
/* Calculate shift to align block-ack bits with our Tx window bits */ /* Calculate shift to align block-ack bits with our Tx window bits */
sh = agg->start_idx - SEQ_TO_INDEX(seq_ctl >> 4); sh = agg->start_idx - SEQ_TO_INDEX(seq_ctl >> 4);
@ -1328,7 +1328,7 @@ static int iwl_tx_status_reply_compressed_ba(struct iwl_priv *priv,
bitmap = le64_to_cpu(ba_resp->bitmap) >> sh; bitmap = le64_to_cpu(ba_resp->bitmap) >> sh;
if (agg->frame_count > (64 - sh)) { if (agg->frame_count > (64 - sh)) {
IWL_DEBUG_TX_REPLY("more frames than bitmap size"); IWL_DEBUG_TX_REPLY(priv, "more frames than bitmap size");
return -1; return -1;
} }
@ -1341,7 +1341,7 @@ static int iwl_tx_status_reply_compressed_ba(struct iwl_priv *priv,
for (i = 0; i < agg->frame_count ; i++) { for (i = 0; i < agg->frame_count ; i++) {
ack = bitmap & (1ULL << i); ack = bitmap & (1ULL << i);
successes += !!ack; successes += !!ack;
IWL_DEBUG_TX_REPLY("%s ON i=%d idx=%d raw=%d\n", IWL_DEBUG_TX_REPLY(priv, "%s ON i=%d idx=%d raw=%d\n",
ack ? "ACK" : "NACK", i, (agg->start_idx + i) & 0xff, ack ? "ACK" : "NACK", i, (agg->start_idx + i) & 0xff,
agg->start_idx + i); agg->start_idx + i);
} }
@ -1354,7 +1354,7 @@ static int iwl_tx_status_reply_compressed_ba(struct iwl_priv *priv,
info->status.ampdu_ack_len = agg->frame_count; info->status.ampdu_ack_len = agg->frame_count;
iwl_hwrate_to_tx_control(priv, agg->rate_n_flags, info); iwl_hwrate_to_tx_control(priv, agg->rate_n_flags, info);
IWL_DEBUG_TX_REPLY("Bitmap %llx\n", (unsigned long long)bitmap); IWL_DEBUG_TX_REPLY(priv, "Bitmap %llx\n", (unsigned long long)bitmap);
return 0; return 0;
} }
@ -1399,19 +1399,19 @@ void iwl_rx_reply_compressed_ba(struct iwl_priv *priv,
/* TODO: Need to get this copy more safely - now good for debug */ /* TODO: Need to get this copy more safely - now good for debug */
IWL_DEBUG_TX_REPLY("REPLY_COMPRESSED_BA [%d] Received from %pM, " IWL_DEBUG_TX_REPLY(priv, "REPLY_COMPRESSED_BA [%d] Received from %pM, "
"sta_id = %d\n", "sta_id = %d\n",
agg->wait_for_ba, agg->wait_for_ba,
(u8 *) &ba_resp->sta_addr_lo32, (u8 *) &ba_resp->sta_addr_lo32,
ba_resp->sta_id); ba_resp->sta_id);
IWL_DEBUG_TX_REPLY("TID = %d, SeqCtl = %d, bitmap = 0x%llx, scd_flow = " IWL_DEBUG_TX_REPLY(priv, "TID = %d, SeqCtl = %d, bitmap = 0x%llx, scd_flow = "
"%d, scd_ssn = %d\n", "%d, scd_ssn = %d\n",
ba_resp->tid, ba_resp->tid,
ba_resp->seq_ctl, ba_resp->seq_ctl,
(unsigned long long)le64_to_cpu(ba_resp->bitmap), (unsigned long long)le64_to_cpu(ba_resp->bitmap),
ba_resp->scd_flow, ba_resp->scd_flow,
ba_resp->scd_ssn); ba_resp->scd_ssn);
IWL_DEBUG_TX_REPLY("DAT start_idx = %d, bitmap = 0x%llx \n", IWL_DEBUG_TX_REPLY(priv, "DAT start_idx = %d, bitmap = 0x%llx \n",
agg->start_idx, agg->start_idx,
(unsigned long long)agg->bitmap); (unsigned long long)agg->bitmap);

1392
drivers/net/wireless/iwlwifi/iwl3945-base.c
View File

File diff suppressed because it is too large Load Diff

15
drivers/net/wireless/libertas/if_spi.c
View File

@ -42,6 +42,7 @@ struct if_spi_packet {
struct if_spi_card { struct if_spi_card {
struct spi_device *spi; struct spi_device *spi;
struct lbs_private *priv; struct lbs_private *priv;
struct libertas_spi_platform_data *pdata;
char helper_fw_name[FIRMWARE_NAME_MAX]; char helper_fw_name[FIRMWARE_NAME_MAX];
char main_fw_name[FIRMWARE_NAME_MAX]; char main_fw_name[FIRMWARE_NAME_MAX];
@ -1022,6 +1023,17 @@ static int __devinit if_spi_probe(struct spi_device *spi)
lbs_deb_enter(LBS_DEB_SPI); lbs_deb_enter(LBS_DEB_SPI);
if (!pdata) {
err = -EINVAL;
goto out;
}
if (pdata->setup) {
err = pdata->setup(spi);
if (err)
goto out;
}
/* Allocate card structure to represent this specific device */ /* Allocate card structure to represent this specific device */
card = kzalloc(sizeof(struct if_spi_card), GFP_KERNEL); card = kzalloc(sizeof(struct if_spi_card), GFP_KERNEL);
if (!card) { if (!card) {
@ -1029,6 +1041,7 @@ static int __devinit if_spi_probe(struct spi_device *spi)
goto out; goto out;
} }
spi_set_drvdata(spi, card); spi_set_drvdata(spi, card);
card->pdata = pdata;
card->spi = spi; card->spi = spi;
card->gpio_cs = pdata->gpio_cs; card->gpio_cs = pdata->gpio_cs;
card->prev_xfer_time = jiffies; card->prev_xfer_time = jiffies;
@ -1158,6 +1171,8 @@ static int __devexit libertas_spi_remove(struct spi_device *spi)
if_spi_terminate_spi_thread(card); if_spi_terminate_spi_thread(card);
lbs_remove_card(priv); /* will call free_netdev */ lbs_remove_card(priv); /* will call free_netdev */
gpio_free(card->gpio_cs); gpio_free(card->gpio_cs);
if (card->pdata->teardown)
card->pdata->teardown(spi);
free_if_spi_card(card); free_if_spi_card(card);
lbs_deb_leave(LBS_DEB_SPI); lbs_deb_leave(LBS_DEB_SPI);
return 0; return 0;

2
drivers/net/wireless/libertas/scan.c
View File

@ -692,7 +692,7 @@ static int lbs_process_bss(struct bss_descriptor *bss,
bss->wpa_ie_len); bss->wpa_ie_len);
} else if (pos[1] >= MARVELL_MESH_IE_LENGTH && } else if (pos[1] >= MARVELL_MESH_IE_LENGTH &&
pos[2] == 0x00 && pos[3] == 0x50 && pos[2] == 0x00 && pos[3] == 0x50 &&
pos[4] == 0x43 && pos[4] == 0x04) { pos[4] == 0x43 && pos[5] == 0x04) {
lbs_deb_scan("got mesh IE\n"); lbs_deb_scan("got mesh IE\n");
bss->mesh = 1; bss->mesh = 1;
} else { } else {

35
drivers/net/wireless/orinoco/airport.c
View File

@ -4,9 +4,9 @@
* card. * card.
* *
* Copyright notice & release notes in file orinoco.c * Copyright notice & release notes in file orinoco.c
* *
* Note specific to airport stub: * Note specific to airport stub:
* *
* 0.05 : first version of the new split driver * 0.05 : first version of the new split driver
* 0.06 : fix possible hang on powerup, add sleep support * 0.06 : fix possible hang on powerup, add sleep support
*/ */
@ -60,7 +60,8 @@ airport_suspend(struct macio_dev *mdev, pm_message_t state)
orinoco_unlock(priv, &flags); orinoco_unlock(priv, &flags);
disable_irq(dev->irq); disable_irq(dev->irq);
pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 0); pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE,
macio_get_of_node(mdev), 0, 0);
return 0; return 0;
} }
@ -75,7 +76,8 @@ airport_resume(struct macio_dev *mdev)
printk(KERN_DEBUG "%s: Airport waking up\n", dev->name); printk(KERN_DEBUG "%s: Airport waking up\n", dev->name);
pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 1); pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE,
macio_get_of_node(mdev), 0, 1);
msleep(200); msleep(200);
enable_irq(dev->irq); enable_irq(dev->irq);
@ -93,7 +95,7 @@ airport_resume(struct macio_dev *mdev)
priv->hw_unavailable--; priv->hw_unavailable--;
if (priv->open && (! priv->hw_unavailable)) { if (priv->open && (!priv->hw_unavailable)) {
err = __orinoco_up(dev); err = __orinoco_up(dev);
if (err) if (err)
printk(KERN_ERR "%s: Error %d restarting card on PBOOK_WAKE\n", printk(KERN_ERR "%s: Error %d restarting card on PBOOK_WAKE\n",
@ -127,7 +129,8 @@ airport_detach(struct macio_dev *mdev)
macio_release_resource(mdev, 0); macio_release_resource(mdev, 0);
pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 0); pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE,
macio_get_of_node(mdev), 0, 0);
ssleep(1); ssleep(1);
macio_set_drvdata(mdev, NULL); macio_set_drvdata(mdev, NULL);
@ -153,9 +156,11 @@ static int airport_hard_reset(struct orinoco_private *priv)
* off. */ * off. */
disable_irq(dev->irq); disable_irq(dev->irq);
pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(card->mdev), 0, 0); pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE,
macio_get_of_node(card->mdev), 0, 0);
ssleep(1); ssleep(1);
pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(card->mdev), 0, 1); pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE,
macio_get_of_node(card->mdev), 0, 1);
ssleep(1); ssleep(1);
enable_irq(dev->irq); enable_irq(dev->irq);
@ -182,7 +187,7 @@ airport_attach(struct macio_dev *mdev, const struct of_device_id *match)
/* Allocate space for private device-specific data */ /* Allocate space for private device-specific data */
dev = alloc_orinocodev(sizeof(*card), &mdev->ofdev.dev, dev = alloc_orinocodev(sizeof(*card), &mdev->ofdev.dev,
airport_hard_reset, NULL); airport_hard_reset, NULL);
if (! dev) { if (!dev) {
printk(KERN_ERR PFX "Cannot allocate network device\n"); printk(KERN_ERR PFX "Cannot allocate network device\n");
return -ENODEV; return -ENODEV;
} }
@ -214,9 +219,10 @@ airport_attach(struct macio_dev *mdev, const struct of_device_id *match)
} }
hermes_struct_init(hw, card->vaddr, HERMES_16BIT_REGSPACING); hermes_struct_init(hw, card->vaddr, HERMES_16BIT_REGSPACING);
/* Power up card */ /* Power up card */
pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 1); pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE,
macio_get_of_node(mdev), 0, 1);
ssleep(1); ssleep(1);
/* Reset it before we get the interrupt */ /* Reset it before we get the interrupt */
@ -248,7 +254,7 @@ MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
MODULE_DESCRIPTION("Driver for the Apple Airport wireless card."); MODULE_DESCRIPTION("Driver for the Apple Airport wireless card.");
MODULE_LICENSE("Dual MPL/GPL"); MODULE_LICENSE("Dual MPL/GPL");
static struct of_device_id airport_match[] = static struct of_device_id airport_match[] =
{ {
{ {
.name = "radio", .name = "radio",
@ -256,10 +262,9 @@ static struct of_device_id airport_match[] =
{}, {},
}; };
MODULE_DEVICE_TABLE (of, airport_match); MODULE_DEVICE_TABLE(of, airport_match);
static struct macio_driver airport_driver = static struct macio_driver airport_driver = {
{
.name = DRIVER_NAME, .name = DRIVER_NAME,
.match_table = airport_match, .match_table = airport_match,
.probe = airport_attach, .probe = airport_attach,

102
drivers/net/wireless/orinoco/hermes.c
View File

@ -15,7 +15,7 @@
* *
* Copyright (C) 2000, David Gibson, Linuxcare Australia. * Copyright (C) 2000, David Gibson, Linuxcare Australia.
* (C) Copyright David Gibson, IBM Corp. 2001-2003. * (C) Copyright David Gibson, IBM Corp. 2001-2003.
* *
* The contents of this file are subject to the Mozilla Public License * The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in * Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License * compliance with the License. You may obtain a copy of the License
@ -45,7 +45,8 @@
#include "hermes.h" #include "hermes.h"
MODULE_DESCRIPTION("Low-level driver helper for Lucent Hermes chipset and Prism II HFA384x wireless MAC controller"); MODULE_DESCRIPTION("Low-level driver helper for Lucent Hermes chipset"
" and Prism II HFA384x wireless MAC controller");
MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>" MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>"
" & David Gibson <hermes@gibson.dropbear.id.au>"); " & David Gibson <hermes@gibson.dropbear.id.au>");
MODULE_LICENSE("Dual MPL/GPL"); MODULE_LICENSE("Dual MPL/GPL");
@ -61,13 +62,13 @@ MODULE_LICENSE("Dual MPL/GPL");
*/ */
#define DMSG(stuff...) do {printk(KERN_DEBUG "hermes @ %p: " , hw->iobase); \ #define DMSG(stuff...) do {printk(KERN_DEBUG "hermes @ %p: " , hw->iobase); \
printk(stuff);} while (0) printk(stuff); } while (0)
#undef HERMES_DEBUG #undef HERMES_DEBUG
#ifdef HERMES_DEBUG #ifdef HERMES_DEBUG
#include <stdarg.h> #include <stdarg.h>
#define DEBUG(lvl, stuff...) if ( (lvl) <= HERMES_DEBUG) DMSG(stuff) #define DEBUG(lvl, stuff...) if ((lvl) <= HERMES_DEBUG) DMSG(stuff)
#else /* ! HERMES_DEBUG */ #else /* ! HERMES_DEBUG */
@ -95,20 +96,19 @@ static int hermes_issue_cmd(hermes_t *hw, u16 cmd, u16 param0,
/* First wait for the command register to unbusy */ /* First wait for the command register to unbusy */
reg = hermes_read_regn(hw, CMD); reg = hermes_read_regn(hw, CMD);
while ( (reg & HERMES_CMD_BUSY) && k ) { while ((reg & HERMES_CMD_BUSY) && k) {
k--; k--;
udelay(1); udelay(1);
reg = hermes_read_regn(hw, CMD); reg = hermes_read_regn(hw, CMD);
} }
if (reg & HERMES_CMD_BUSY) { if (reg & HERMES_CMD_BUSY)
return -EBUSY; return -EBUSY;
}
hermes_write_regn(hw, PARAM2, param2); hermes_write_regn(hw, PARAM2, param2);
hermes_write_regn(hw, PARAM1, param1); hermes_write_regn(hw, PARAM1, param1);
hermes_write_regn(hw, PARAM0, param0); hermes_write_regn(hw, PARAM0, param0);
hermes_write_regn(hw, CMD, cmd); hermes_write_regn(hw, CMD, cmd);
return 0; return 0;
} }
@ -191,23 +191,23 @@ int hermes_init(hermes_t *hw)
hermes_write_regn(hw, EVACK, 0xffff); hermes_write_regn(hw, EVACK, 0xffff);
/* Normally it's a "can't happen" for the command register to /* Normally it's a "can't happen" for the command register to
be busy when we go to issue a command because we are be busy when we go to issue a command because we are
serializing all commands. However we want to have some serializing all commands. However we want to have some
chance of resetting the card even if it gets into a stupid chance of resetting the card even if it gets into a stupid
state, so we actually wait to see if the command register state, so we actually wait to see if the command register
will unbusy itself here. */ will unbusy itself here. */
k = CMD_BUSY_TIMEOUT; k = CMD_BUSY_TIMEOUT;
reg = hermes_read_regn(hw, CMD); reg = hermes_read_regn(hw, CMD);
while (k && (reg & HERMES_CMD_BUSY)) { while (k && (reg & HERMES_CMD_BUSY)) {
if (reg == 0xffff) /* Special case - the card has probably been removed, if (reg == 0xffff) /* Special case - the card has probably been
so don't wait for the timeout */ removed, so don't wait for the timeout */
return -ENODEV; return -ENODEV;
k--; k--;
udelay(1); udelay(1);
reg = hermes_read_regn(hw, CMD); reg = hermes_read_regn(hw, CMD);
} }
/* No need to explicitly handle the timeout - if we've timed /* No need to explicitly handle the timeout - if we've timed
out hermes_issue_cmd() will probably return -EBUSY below */ out hermes_issue_cmd() will probably return -EBUSY below */
@ -228,7 +228,10 @@ EXPORT_SYMBOL(hermes_init);
/* Issue a command to the chip, and (busy!) wait for it to /* Issue a command to the chip, and (busy!) wait for it to
* complete. * complete.
* *
* Returns: < 0 on internal error, 0 on success, > 0 on error returned by the firmware * Returns:
* < 0 on internal error
* 0 on success
* > 0 on error returned by the firmware
* *
* Callable from any context, but locking is your problem. */ * Callable from any context, but locking is your problem. */
int hermes_docmd_wait(hermes_t *hw, u16 cmd, u16 parm0, int hermes_docmd_wait(hermes_t *hw, u16 cmd, u16 parm0,
@ -241,13 +244,13 @@ int hermes_docmd_wait(hermes_t *hw, u16 cmd, u16 parm0,
err = hermes_issue_cmd(hw, cmd, parm0, 0, 0); err = hermes_issue_cmd(hw, cmd, parm0, 0, 0);
if (err) { if (err) {
if (! hermes_present(hw)) { if (!hermes_present(hw)) {
if (net_ratelimit()) if (net_ratelimit())
printk(KERN_WARNING "hermes @ %p: " printk(KERN_WARNING "hermes @ %p: "
"Card removed while issuing command " "Card removed while issuing command "
"0x%04x.\n", hw->iobase, cmd); "0x%04x.\n", hw->iobase, cmd);
err = -ENODEV; err = -ENODEV;
} else } else
if (net_ratelimit()) if (net_ratelimit())
printk(KERN_ERR "hermes @ %p: " printk(KERN_ERR "hermes @ %p: "
"Error %d issuing command 0x%04x.\n", "Error %d issuing command 0x%04x.\n",
@ -257,21 +260,21 @@ int hermes_docmd_wait(hermes_t *hw, u16 cmd, u16 parm0,
reg = hermes_read_regn(hw, EVSTAT); reg = hermes_read_regn(hw, EVSTAT);
k = CMD_COMPL_TIMEOUT; k = CMD_COMPL_TIMEOUT;
while ( (! (reg & HERMES_EV_CMD)) && k) { while ((!(reg & HERMES_EV_CMD)) && k) {
k--; k--;
udelay(10); udelay(10);
reg = hermes_read_regn(hw, EVSTAT); reg = hermes_read_regn(hw, EVSTAT);
} }
if (! hermes_present(hw)) { if (!hermes_present(hw)) {
printk(KERN_WARNING "hermes @ %p: Card removed " printk(KERN_WARNING "hermes @ %p: Card removed "
"while waiting for command 0x%04x completion.\n", "while waiting for command 0x%04x completion.\n",
hw->iobase, cmd); hw->iobase, cmd);
err = -ENODEV; err = -ENODEV;
goto out; goto out;
} }
if (! (reg & HERMES_EV_CMD)) { if (!(reg & HERMES_EV_CMD)) {
printk(KERN_ERR "hermes @ %p: Timeout waiting for " printk(KERN_ERR "hermes @ %p: Timeout waiting for "
"command 0x%04x completion.\n", hw->iobase, cmd); "command 0x%04x completion.\n", hw->iobase, cmd);
err = -ETIMEDOUT; err = -ETIMEDOUT;
@ -301,31 +304,30 @@ int hermes_allocate(hermes_t *hw, u16 size, u16 *fid)
int err = 0; int err = 0;
int k; int k;
u16 reg; u16 reg;
if ( (size < HERMES_ALLOC_LEN_MIN) || (size > HERMES_ALLOC_LEN_MAX) ) if ((size < HERMES_ALLOC_LEN_MIN) || (size > HERMES_ALLOC_LEN_MAX))
return -EINVAL; return -EINVAL;
err = hermes_docmd_wait(hw, HERMES_CMD_ALLOC, size, NULL); err = hermes_docmd_wait(hw, HERMES_CMD_ALLOC, size, NULL);
if (err) { if (err)
return err; return err;
}
reg = hermes_read_regn(hw, EVSTAT); reg = hermes_read_regn(hw, EVSTAT);
k = ALLOC_COMPL_TIMEOUT; k = ALLOC_COMPL_TIMEOUT;
while ( (! (reg & HERMES_EV_ALLOC)) && k) { while ((!(reg & HERMES_EV_ALLOC)) && k) {
k--; k--;
udelay(10); udelay(10);
reg = hermes_read_regn(hw, EVSTAT); reg = hermes_read_regn(hw, EVSTAT);
} }
if (! hermes_present(hw)) { if (!hermes_present(hw)) {
printk(KERN_WARNING "hermes @ %p: " printk(KERN_WARNING "hermes @ %p: "
"Card removed waiting for frame allocation.\n", "Card removed waiting for frame allocation.\n",
hw->iobase); hw->iobase);
return -ENODEV; return -ENODEV;
} }
if (! (reg & HERMES_EV_ALLOC)) { if (!(reg & HERMES_EV_ALLOC)) {
printk(KERN_ERR "hermes @ %p: " printk(KERN_ERR "hermes @ %p: "
"Timeout waiting for frame allocation\n", "Timeout waiting for frame allocation\n",
hw->iobase); hw->iobase);
@ -334,14 +336,17 @@ int hermes_allocate(hermes_t *hw, u16 size, u16 *fid)
*fid = hermes_read_regn(hw, ALLOCFID); *fid = hermes_read_regn(hw, ALLOCFID);
hermes_write_regn(hw, EVACK, HERMES_EV_ALLOC); hermes_write_regn(hw, EVACK, HERMES_EV_ALLOC);
return 0; return 0;
} }
EXPORT_SYMBOL(hermes_allocate); EXPORT_SYMBOL(hermes_allocate);
/* Set up a BAP to read a particular chunk of data from card's internal buffer. /* Set up a BAP to read a particular chunk of data from card's internal buffer.
* *
* Returns: < 0 on internal failure (errno), 0 on success, >0 on error * Returns:
* < 0 on internal failure (errno)
* 0 on success
* > 0 on error
* from firmware * from firmware
* *
* Callable from any context */ * Callable from any context */
@ -353,7 +358,7 @@ static int hermes_bap_seek(hermes_t *hw, int bap, u16 id, u16 offset)
u16 reg; u16 reg;
/* Paranoia.. */ /* Paranoia.. */
if ( (offset > HERMES_BAP_OFFSET_MAX) || (offset % 2) ) if ((offset > HERMES_BAP_OFFSET_MAX) || (offset % 2))
return -EINVAL; return -EINVAL;
k = HERMES_BAP_BUSY_TIMEOUT; k = HERMES_BAP_BUSY_TIMEOUT;
@ -374,7 +379,7 @@ static int hermes_bap_seek(hermes_t *hw, int bap, u16 id, u16 offset)
/* Wait for the BAP to be ready */ /* Wait for the BAP to be ready */
k = HERMES_BAP_BUSY_TIMEOUT; k = HERMES_BAP_BUSY_TIMEOUT;
reg = hermes_read_reg(hw, oreg); reg = hermes_read_reg(hw, oreg);
while ( (reg & (HERMES_OFFSET_BUSY | HERMES_OFFSET_ERR)) && k) { while ((reg & (HERMES_OFFSET_BUSY | HERMES_OFFSET_ERR)) && k) {
k--; k--;
udelay(1); udelay(1);
reg = hermes_read_reg(hw, oreg); reg = hermes_read_reg(hw, oreg);
@ -386,9 +391,8 @@ static int hermes_bap_seek(hermes_t *hw, int bap, u16 id, u16 offset)
(reg & HERMES_OFFSET_BUSY) ? "timeout" : "error", (reg & HERMES_OFFSET_BUSY) ? "timeout" : "error",
reg, id, offset); reg, id, offset);
if (reg & HERMES_OFFSET_BUSY) { if (reg & HERMES_OFFSET_BUSY)
return -ETIMEDOUT; return -ETIMEDOUT;
}
return -EIO; /* error or wrong offset */ return -EIO; /* error or wrong offset */
} }
@ -400,7 +404,10 @@ static int hermes_bap_seek(hermes_t *hw, int bap, u16 id, u16 offset)
* BAP. Synchronization/serialization is the caller's problem. len * BAP. Synchronization/serialization is the caller's problem. len
* must be even. * must be even.
* *
* Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware * Returns:
* < 0 on internal failure (errno)
* 0 on success
* > 0 on error from firmware
*/ */
int hermes_bap_pread(hermes_t *hw, int bap, void *buf, int len, int hermes_bap_pread(hermes_t *hw, int bap, void *buf, int len,
u16 id, u16 offset) u16 id, u16 offset)
@ -408,7 +415,7 @@ int hermes_bap_pread(hermes_t *hw, int bap, void *buf, int len,
int dreg = bap ? HERMES_DATA1 : HERMES_DATA0; int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
int err = 0; int err = 0;
if ( (len < 0) || (len % 2) ) if ((len < 0) || (len % 2))
return -EINVAL; return -EINVAL;
err = hermes_bap_seek(hw, bap, id, offset); err = hermes_bap_seek(hw, bap, id, offset);
@ -426,7 +433,10 @@ EXPORT_SYMBOL(hermes_bap_pread);
/* Write a block of data to the chip's buffer, via the /* Write a block of data to the chip's buffer, via the
* BAP. Synchronization/serialization is the caller's problem. * BAP. Synchronization/serialization is the caller's problem.
* *
* Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware * Returns:
* < 0 on internal failure (errno)
* 0 on success
* > 0 on error from firmware
*/ */
int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, int len, int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, int len,
u16 id, u16 offset) u16 id, u16 offset)
@ -440,11 +450,11 @@ int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, int len,
err = hermes_bap_seek(hw, bap, id, offset); err = hermes_bap_seek(hw, bap, id, offset);
if (err) if (err)
goto out; goto out;
/* Actually do the transfer */ /* Actually do the transfer */
hermes_write_bytes(hw, dreg, buf, len); hermes_write_bytes(hw, dreg, buf, len);
out: out:
return err; return err;
} }
EXPORT_SYMBOL(hermes_bap_pwrite); EXPORT_SYMBOL(hermes_bap_pwrite);
@ -465,7 +475,7 @@ int hermes_read_ltv(hermes_t *hw, int bap, u16 rid, unsigned bufsize,
u16 rlength, rtype; u16 rlength, rtype;
unsigned nwords; unsigned nwords;
if ( (bufsize < 0) || (bufsize % 2) ) if ((bufsize < 0) || (bufsize % 2))
return -EINVAL; return -EINVAL;
err = hermes_docmd_wait(hw, HERMES_CMD_ACCESS, rid, NULL); err = hermes_docmd_wait(hw, HERMES_CMD_ACCESS, rid, NULL);
@ -478,7 +488,7 @@ int hermes_read_ltv(hermes_t *hw, int bap, u16 rid, unsigned bufsize,
rlength = hermes_read_reg(hw, dreg); rlength = hermes_read_reg(hw, dreg);
if (! rlength) if (!rlength)
return -ENODATA; return -ENODATA;
rtype = hermes_read_reg(hw, dreg); rtype = hermes_read_reg(hw, dreg);
@ -503,7 +513,7 @@ int hermes_read_ltv(hermes_t *hw, int bap, u16 rid, unsigned bufsize,
} }
EXPORT_SYMBOL(hermes_read_ltv); EXPORT_SYMBOL(hermes_read_ltv);
int hermes_write_ltv(hermes_t *hw, int bap, u16 rid, int hermes_write_ltv(hermes_t *hw, int bap, u16 rid,
u16 length, const void *value) u16 length, const void *value)
{ {
int dreg = bap ? HERMES_DATA1 : HERMES_DATA0; int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;

35
drivers/net/wireless/orinoco/hermes.h
View File

@ -15,7 +15,8 @@
* Copyright (C) 2000, David Gibson, Linuxcare Australia. * Copyright (C) 2000, David Gibson, Linuxcare Australia.
* (C) Copyright David Gibson, IBM Corp. 2001-2003. * (C) Copyright David Gibson, IBM Corp. 2001-2003.
* *
* Portions taken from hfa384x.h, Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved. * Portions taken from hfa384x.h.
* Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
* *
* This file distributed under the GPL, version 2. * This file distributed under the GPL, version 2.
*/ */
@ -31,7 +32,7 @@
*/ */
#include <linux/if_ether.h> #include <linux/if_ether.h>
#include <asm/io.h> #include <linux/io.h>
/* /*
* Limits and constants * Limits and constants
@ -203,7 +204,7 @@ struct hermes_tx_descriptor {
__le32 sw_support; __le32 sw_support;
u8 retry_count; u8 retry_count;
u8 tx_rate; u8 tx_rate;
__le16 tx_control; __le16 tx_control;
} __attribute__ ((packed)); } __attribute__ ((packed));
#define HERMES_TXSTAT_RETRYERR (0x0001) #define HERMES_TXSTAT_RETRYERR (0x0001)
@ -298,7 +299,7 @@ struct symbol_scan_apinfo {
/* bits: 0-ess, 1-ibss, 4-privacy [wep] */ /* bits: 0-ess, 1-ibss, 4-privacy [wep] */
__le16 essid_len; /* ESSID length */ __le16 essid_len; /* ESSID length */
u8 essid[32]; /* ESSID of the network */ u8 essid[32]; /* ESSID of the network */
__le16 rates[5]; /* Bit rate supported */ __le16 rates[5]; /* Bit rate supported */
__le16 basic_rates; /* Basic rates bitmask */ __le16 basic_rates; /* Basic rates bitmask */
u8 unknown2[6]; /* Always FF:FF:FF:FF:00:00 */ u8 unknown2[6]; /* Always FF:FF:FF:FF:00:00 */
u8 unknown3[8]; /* Always 0, appeared in f/w 3.91-68 */ u8 unknown3[8]; /* Always 0, appeared in f/w 3.91-68 */
@ -344,14 +345,14 @@ struct agere_ext_scan_info {
u8 data[316]; u8 data[316];
} __attribute__ ((packed)); } __attribute__ ((packed));
#define HERMES_LINKSTATUS_NOT_CONNECTED (0x0000) #define HERMES_LINKSTATUS_NOT_CONNECTED (0x0000)
#define HERMES_LINKSTATUS_CONNECTED (0x0001) #define HERMES_LINKSTATUS_CONNECTED (0x0001)
#define HERMES_LINKSTATUS_DISCONNECTED (0x0002) #define HERMES_LINKSTATUS_DISCONNECTED (0x0002)
#define HERMES_LINKSTATUS_AP_CHANGE (0x0003) #define HERMES_LINKSTATUS_AP_CHANGE (0x0003)
#define HERMES_LINKSTATUS_AP_OUT_OF_RANGE (0x0004) #define HERMES_LINKSTATUS_AP_OUT_OF_RANGE (0x0004)
#define HERMES_LINKSTATUS_AP_IN_RANGE (0x0005) #define HERMES_LINKSTATUS_AP_IN_RANGE (0x0005)
#define HERMES_LINKSTATUS_ASSOC_FAILED (0x0006) #define HERMES_LINKSTATUS_ASSOC_FAILED (0x0006)
struct hermes_linkstatus { struct hermes_linkstatus {
__le16 linkstatus; /* Link status */ __le16 linkstatus; /* Link status */
} __attribute__ ((packed)); } __attribute__ ((packed));
@ -384,11 +385,12 @@ typedef struct hermes {
/* Register access convenience macros */ /* Register access convenience macros */
#define hermes_read_reg(hw, off) \ #define hermes_read_reg(hw, off) \
(ioread16((hw)->iobase + ( (off) << (hw)->reg_spacing ))) (ioread16((hw)->iobase + ((off) << (hw)->reg_spacing)))
#define hermes_write_reg(hw, off, val) \ #define hermes_write_reg(hw, off, val) \
(iowrite16((val), (hw)->iobase + ((off) << (hw)->reg_spacing))) (iowrite16((val), (hw)->iobase + ((off) << (hw)->reg_spacing)))
#define hermes_read_regn(hw, name) hermes_read_reg((hw), HERMES_##name) #define hermes_read_regn(hw, name) hermes_read_reg((hw), HERMES_##name)
#define hermes_write_regn(hw, name, val) hermes_write_reg((hw), HERMES_##name, (val)) #define hermes_write_regn(hw, name, val) \
hermes_write_reg((hw), HERMES_##name, (val))
/* Function prototypes */ /* Function prototypes */
void hermes_struct_init(hermes_t *hw, void __iomem *address, int reg_spacing); void hermes_struct_init(hermes_t *hw, void __iomem *address, int reg_spacing);
@ -430,7 +432,7 @@ static inline int hermes_enable_port(hermes_t *hw, int port)
static inline int hermes_disable_port(hermes_t *hw, int port) static inline int hermes_disable_port(hermes_t *hw, int port)
{ {
return hermes_docmd_wait(hw, HERMES_CMD_DISABLE | (port << 8), return hermes_docmd_wait(hw, HERMES_CMD_DISABLE | (port << 8),
0, NULL); 0, NULL);
} }
@ -441,11 +443,12 @@ static inline int hermes_inquire(hermes_t *hw, u16 rid)
return hermes_docmd_wait(hw, HERMES_CMD_INQUIRE, rid, NULL); return hermes_docmd_wait(hw, HERMES_CMD_INQUIRE, rid, NULL);
} }
#define HERMES_BYTES_TO_RECLEN(n) ( (((n)+1)/2) + 1 ) #define HERMES_BYTES_TO_RECLEN(n) ((((n)+1)/2) + 1)
#define HERMES_RECLEN_TO_BYTES(n) ( ((n)-1) * 2 ) #define HERMES_RECLEN_TO_BYTES(n) (((n)-1) * 2)
/* Note that for the next two, the count is in 16-bit words, not bytes */ /* Note that for the next two, the count is in 16-bit words, not bytes */
static inline void hermes_read_words(struct hermes *hw, int off, void *buf, unsigned count) static inline void hermes_read_words(struct hermes *hw, int off,
void *buf, unsigned count)
{ {
off = off << hw->reg_spacing; off = off << hw->reg_spacing;
ioread16_rep(hw->iobase + off, buf, count); ioread16_rep(hw->iobase + off, buf, count);
@ -460,7 +463,8 @@ static inline void hermes_write_bytes(struct hermes *hw, int off,
iowrite8(buf[count - 1], hw->iobase + off); iowrite8(buf[count - 1], hw->iobase + off);
} }
static inline void hermes_clear_words(struct hermes *hw, int off, unsigned count) static inline void hermes_clear_words(struct hermes *hw, int off,
unsigned count)
{ {
unsigned i; unsigned i;
@ -471,9 +475,10 @@ static inline void hermes_clear_words(struct hermes *hw, int off, unsigned count
} }
#define HERMES_READ_RECORD(hw, bap, rid, buf) \ #define HERMES_READ_RECORD(hw, bap, rid, buf) \
(hermes_read_ltv((hw),(bap),(rid), sizeof(*buf), NULL, (buf))) (hermes_read_ltv((hw), (bap), (rid), sizeof(*buf), NULL, (buf)))
#define HERMES_WRITE_RECORD(hw, bap, rid, buf) \ #define HERMES_WRITE_RECORD(hw, bap, rid, buf) \
(hermes_write_ltv((hw),(bap),(rid),HERMES_BYTES_TO_RECLEN(sizeof(*buf)),(buf))) (hermes_write_ltv((hw), (bap), (rid), \
HERMES_BYTES_TO_RECLEN(sizeof(*buf)), (buf)))
static inline int hermes_read_wordrec(hermes_t *hw, int bap, u16 rid, u16 *word) static inline int hermes_read_wordrec(hermes_t *hw, int bap, u16 rid, u16 *word)
{ {

4
drivers/net/wireless/orinoco/hermes_dld.c
View File

@ -573,9 +573,9 @@ static const struct { \
__le16 id; \ __le16 id; \
u8 val[length]; \ u8 val[length]; \
} __attribute__ ((packed)) default_pdr_data_##pid = { \ } __attribute__ ((packed)) default_pdr_data_##pid = { \
__constant_cpu_to_le16((sizeof(default_pdr_data_##pid)/ \ cpu_to_le16((sizeof(default_pdr_data_##pid)/ \
sizeof(__le16)) - 1), \ sizeof(__le16)) - 1), \
__constant_cpu_to_le16(pid), \ cpu_to_le16(pid), \
data \ data \
} }

2
drivers/net/wireless/orinoco/orinoco.c
View File

@ -1333,7 +1333,7 @@ static void orinoco_rx_monitor(struct net_device *dev, u16 rxfid,
skb->dev = dev; skb->dev = dev;
skb->ip_summed = CHECKSUM_NONE; skb->ip_summed = CHECKSUM_NONE;
skb->pkt_type = PACKET_OTHERHOST; skb->pkt_type = PACKET_OTHERHOST;
skb->protocol = __constant_htons(ETH_P_802_2); skb->protocol = cpu_to_be16(ETH_P_802_2);
stats->rx_packets++; stats->rx_packets++;
stats->rx_bytes += skb->len; stats->rx_bytes += skb->len;

17
drivers/net/wireless/orinoco/orinoco.h
View File

@ -1,5 +1,5 @@
/* orinoco.h /* orinoco.h
* *
* Common definitions to all pieces of the various orinoco * Common definitions to all pieces of the various orinoco
* drivers * drivers
*/ */
@ -18,9 +18,9 @@
#include "hermes.h" #include "hermes.h"
/* To enable debug messages */ /* To enable debug messages */
//#define ORINOCO_DEBUG 3 /*#define ORINOCO_DEBUG 3*/
#define WIRELESS_SPY // enable iwspy support #define WIRELESS_SPY /* enable iwspy support */
#define MAX_SCAN_LEN 4096 #define MAX_SCAN_LEN 4096
@ -121,7 +121,7 @@ struct orinoco_private {
u16 encode_alg, wep_restrict, tx_key; u16 encode_alg, wep_restrict, tx_key;
struct orinoco_key keys[ORINOCO_MAX_KEYS]; struct orinoco_key keys[ORINOCO_MAX_KEYS];
int bitratemode; int bitratemode;
char nick[IW_ESSID_MAX_SIZE+1]; char nick[IW_ESSID_MAX_SIZE+1];
char desired_essid[IW_ESSID_MAX_SIZE+1]; char desired_essid[IW_ESSID_MAX_SIZE+1];
char desired_bssid[ETH_ALEN]; char desired_bssid[ETH_ALEN];
int bssid_fixed; int bssid_fixed;
@ -131,7 +131,7 @@ struct orinoco_private {
u16 pm_on, pm_mcast, pm_period, pm_timeout; u16 pm_on, pm_mcast, pm_period, pm_timeout;
u16 preamble; u16 preamble;
#ifdef WIRELESS_SPY #ifdef WIRELESS_SPY
struct iw_spy_data spy_data; /* iwspy support */ struct iw_spy_data spy_data; /* iwspy support */
struct iw_public_data wireless_data; struct iw_public_data wireless_data;
#endif #endif
@ -168,7 +168,10 @@ struct orinoco_private {
#ifdef ORINOCO_DEBUG #ifdef ORINOCO_DEBUG
extern int orinoco_debug; extern int orinoco_debug;
#define DEBUG(n, args...) do { if (orinoco_debug>(n)) printk(KERN_DEBUG args); } while(0) #define DEBUG(n, args...) do { \
if (orinoco_debug > (n)) \
printk(KERN_DEBUG args); \
} while (0)
#else #else
#define DEBUG(n, args...) do { } while (0) #define DEBUG(n, args...) do { } while (0)
#endif /* ORINOCO_DEBUG */ #endif /* ORINOCO_DEBUG */
@ -185,7 +188,7 @@ extern void free_orinocodev(struct net_device *dev);
extern int __orinoco_up(struct net_device *dev); extern int __orinoco_up(struct net_device *dev);
extern int __orinoco_down(struct net_device *dev); extern int __orinoco_down(struct net_device *dev);
extern int orinoco_reinit_firmware(struct net_device *dev); extern int orinoco_reinit_firmware(struct net_device *dev);
extern irqreturn_t orinoco_interrupt(int irq, void * dev_id); extern irqreturn_t orinoco_interrupt(int irq, void *dev_id);
/********************************************************************/ /********************************************************************/
/* Locking and synchronization functions */ /* Locking and synchronization functions */

31
drivers/net/wireless/orinoco/orinoco_cs.c
View File

@ -6,7 +6,7 @@
* It should also be usable on various Prism II based cards such as the * It should also be usable on various Prism II based cards such as the
* Linksys, D-Link and Farallon Skyline. It should also work on Symbol * Linksys, D-Link and Farallon Skyline. It should also work on Symbol
* cards such as the 3Com AirConnect and Ericsson WLAN. * cards such as the 3Com AirConnect and Ericsson WLAN.
* *
* Copyright notice & release notes in file orinoco.c * Copyright notice & release notes in file orinoco.c
*/ */
@ -30,7 +30,8 @@
/********************************************************************/ /********************************************************************/
MODULE_AUTHOR("David Gibson <hermes@gibson.dropbear.id.au>"); MODULE_AUTHOR("David Gibson <hermes@gibson.dropbear.id.au>");
MODULE_DESCRIPTION("Driver for PCMCIA Lucent Orinoco, Prism II based and similar wireless cards"); MODULE_DESCRIPTION("Driver for PCMCIA Lucent Orinoco,"
" Prism II based and similar wireless cards");
MODULE_LICENSE("Dual MPL/GPL"); MODULE_LICENSE("Dual MPL/GPL");
/* Module parameters */ /* Module parameters */
@ -53,8 +54,8 @@ struct orinoco_pccard {
/* Used to handle hard reset */ /* Used to handle hard reset */
/* yuck, we need this hack to work around the insanity of the /* yuck, we need this hack to work around the insanity of the
* PCMCIA layer */ * PCMCIA layer */
unsigned long hard_reset_in_progress; unsigned long hard_reset_in_progress;
}; };
@ -98,7 +99,7 @@ orinoco_cs_hard_reset(struct orinoco_private *priv)
* This creates an "instance" of the driver, allocating local data * This creates an "instance" of the driver, allocating local data
* structures for one device. The device is registered with Card * structures for one device. The device is registered with Card
* Services. * Services.
* *
* The dev_link structure is initialized, but we don't actually * The dev_link structure is initialized, but we don't actually
* configure the card at this point -- we wait until we receive a card * configure the card at this point -- we wait until we receive a card
* insertion event. */ * insertion event. */
@ -111,7 +112,7 @@ orinoco_cs_probe(struct pcmcia_device *link)
dev = alloc_orinocodev(sizeof(*card), &handle_to_dev(link), dev = alloc_orinocodev(sizeof(*card), &handle_to_dev(link),
orinoco_cs_hard_reset, NULL); orinoco_cs_hard_reset, NULL);
if (! dev) if (!dev)
return -ENOMEM; return -ENOMEM;
priv = netdev_priv(dev); priv = netdev_priv(dev);
card = priv->card; card = priv->card;
@ -124,7 +125,7 @@ orinoco_cs_probe(struct pcmcia_device *link)
link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT; link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
link->irq.IRQInfo1 = IRQ_LEVEL_ID; link->irq.IRQInfo1 = IRQ_LEVEL_ID;
link->irq.Handler = orinoco_interrupt; link->irq.Handler = orinoco_interrupt;
link->irq.Instance = dev; link->irq.Instance = dev;
/* General socket configuration defaults can go here. In this /* General socket configuration defaults can go here. In this
* client, we assume very little, and rely on the CIS for * client, we assume very little, and rely on the CIS for
@ -162,8 +163,10 @@ static void orinoco_cs_detach(struct pcmcia_device *link)
*/ */
#define CS_CHECK(fn, ret) do { \ #define CS_CHECK(fn, ret) do { \
last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; \ last_fn = (fn); \
} while (0) if ((last_ret = (ret)) != 0) \
goto cs_failed; \
} while (0)
static int orinoco_cs_config_check(struct pcmcia_device *p_dev, static int orinoco_cs_config_check(struct pcmcia_device *p_dev,
cistpl_cftable_entry_t *cfg, cistpl_cftable_entry_t *cfg,
@ -307,8 +310,8 @@ orinoco_cs_config(struct pcmcia_device *link)
* initialized and arranged in a linked list at link->dev_node. */ * initialized and arranged in a linked list at link->dev_node. */
strcpy(card->node.dev_name, dev->name); strcpy(card->node.dev_name, dev->name);
link->dev_node = &card->node; /* link->dev_node being non-NULL is also link->dev_node = &card->node; /* link->dev_node being non-NULL is also
used to indicate that the * used to indicate that the
net_device has been registered */ * net_device has been registered */
/* Finally, report what we've done */ /* Finally, report what we've done */
printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io " printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io "
@ -359,7 +362,7 @@ static int orinoco_cs_suspend(struct pcmcia_device *link)
/* This is probably racy, but I can't think of /* This is probably racy, but I can't think of
a better way, short of rewriting the PCMCIA a better way, short of rewriting the PCMCIA
layer to not suck :-( */ layer to not suck :-( */
if (! test_bit(0, &card->hard_reset_in_progress)) { if (!test_bit(0, &card->hard_reset_in_progress)) {
spin_lock_irqsave(&priv->lock, flags); spin_lock_irqsave(&priv->lock, flags);
err = __orinoco_down(dev); err = __orinoco_down(dev);
@ -384,7 +387,7 @@ static int orinoco_cs_resume(struct pcmcia_device *link)
int err = 0; int err = 0;
unsigned long flags; unsigned long flags;
if (! test_bit(0, &card->hard_reset_in_progress)) { if (!test_bit(0, &card->hard_reset_in_progress)) {
err = orinoco_reinit_firmware(dev); err = orinoco_reinit_firmware(dev);
if (err) { if (err) {
printk(KERN_ERR "%s: Error %d re-initializing firmware\n", printk(KERN_ERR "%s: Error %d re-initializing firmware\n",
@ -397,7 +400,7 @@ static int orinoco_cs_resume(struct pcmcia_device *link)
netif_device_attach(dev); netif_device_attach(dev);
priv->hw_unavailable--; priv->hw_unavailable--;
if (priv->open && ! priv->hw_unavailable) { if (priv->open && !priv->hw_unavailable) {
err = __orinoco_up(dev); err = __orinoco_up(dev);
if (err) if (err)
printk(KERN_ERR "%s: Error %d restarting card\n", printk(KERN_ERR "%s: Error %d restarting card\n",

7
drivers/net/wireless/orinoco/orinoco_nortel.c
View File

@ -9,12 +9,12 @@
* *
* Some of this code is borrowed from orinoco_plx.c * Some of this code is borrowed from orinoco_plx.c
* Copyright (C) 2001 Daniel Barlow * Copyright (C) 2001 Daniel Barlow
* Some of this code is borrowed from orinoco_pci.c * Some of this code is borrowed from orinoco_pci.c
* Copyright (C) 2001 Jean Tourrilhes * Copyright (C) 2001 Jean Tourrilhes
* Some of this code is "inspired" by linux-wlan-ng-0.1.10, but nothing * Some of this code is "inspired" by linux-wlan-ng-0.1.10, but nothing
* has been copied from it. linux-wlan-ng-0.1.10 is originally : * has been copied from it. linux-wlan-ng-0.1.10 is originally :
* Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved. * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
* *
* The contents of this file are subject to the Mozilla Public License * The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in * Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License * compliance with the License. You may obtain a copy of the License
@ -103,9 +103,8 @@ static int orinoco_nortel_hw_init(struct orinoco_pci_card *card)
iowrite16(0x8, card->bridge_io + 2); iowrite16(0x8, card->bridge_io + 2);
for (i = 0; i < 30; i++) { for (i = 0; i < 30; i++) {
mdelay(30); mdelay(30);
if (ioread16(card->bridge_io) & 0x10) { if (ioread16(card->bridge_io) & 0x10)
break; break;
}
} }
if (i == 30) { if (i == 30) {
printk(KERN_ERR PFX "brg1 timed out\n"); printk(KERN_ERR PFX "brg1 timed out\n");

5
drivers/net/wireless/orinoco/orinoco_pci.c
View File

@ -1,5 +1,5 @@
/* orinoco_pci.c /* orinoco_pci.c
* *
* Driver for Prism 2.5/3 devices that have a direct PCI interface * Driver for Prism 2.5/3 devices that have a direct PCI interface
* (i.e. these are not PCMCIA cards in a PCMCIA-to-PCI bridge). * (i.e. these are not PCMCIA cards in a PCMCIA-to-PCI bridge).
* The card contains only one PCI region, which contains all the usual * The card contains only one PCI region, which contains all the usual
@ -237,7 +237,8 @@ static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
" (Pavel Roskin <proski@gnu.org>," " (Pavel Roskin <proski@gnu.org>,"
" David Gibson <hermes@gibson.dropbear.id.au> &" " David Gibson <hermes@gibson.dropbear.id.au> &"
" Jean Tourrilhes <jt@hpl.hp.com>)"; " Jean Tourrilhes <jt@hpl.hp.com>)";
MODULE_AUTHOR("Pavel Roskin <proski@gnu.org> & David Gibson <hermes@gibson.dropbear.id.au>"); MODULE_AUTHOR("Pavel Roskin <proski@gnu.org> &"
" David Gibson <hermes@gibson.dropbear.id.au>");
MODULE_DESCRIPTION("Driver for wireless LAN cards using direct PCI interface"); MODULE_DESCRIPTION("Driver for wireless LAN cards using direct PCI interface");
MODULE_LICENSE("Dual MPL/GPL"); MODULE_LICENSE("Dual MPL/GPL");

10
drivers/net/wireless/orinoco/orinoco_pci.h
View File

@ -1,5 +1,5 @@
/* orinoco_pci.h /* orinoco_pci.h
* *
* Common code for all Orinoco drivers for PCI devices, including * Common code for all Orinoco drivers for PCI devices, including
* both native PCI and PCMCIA-to-PCI bridges. * both native PCI and PCMCIA-to-PCI bridges.
* *
@ -37,11 +37,11 @@ static int orinoco_pci_suspend(struct pci_dev *pdev, pm_message_t state)
if (err) if (err)
printk(KERN_WARNING "%s: error %d bringing interface down " printk(KERN_WARNING "%s: error %d bringing interface down "
"for suspend\n", dev->name, err); "for suspend\n", dev->name, err);
netif_device_detach(dev); netif_device_detach(dev);
priv->hw_unavailable++; priv->hw_unavailable++;
orinoco_unlock(priv, &flags); orinoco_unlock(priv, &flags);
free_irq(pdev->irq, dev); free_irq(pdev->irq, dev);
@ -90,13 +90,13 @@ static int orinoco_pci_resume(struct pci_dev *pdev)
priv->hw_unavailable--; priv->hw_unavailable--;
if (priv->open && (! priv->hw_unavailable)) { if (priv->open && (!priv->hw_unavailable)) {
err = __orinoco_up(dev); err = __orinoco_up(dev);
if (err) if (err)
printk(KERN_ERR "%s: Error %d restarting card on resume\n", printk(KERN_ERR "%s: Error %d restarting card on resume\n",
dev->name, err); dev->name, err);
} }
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
return 0; return 0;

3
drivers/net/wireless/orinoco/orinoco_plx.c
View File

@ -146,9 +146,8 @@ static int orinoco_plx_hw_init(struct orinoco_pci_card *card)
}; };
printk(KERN_DEBUG PFX "CIS: "); printk(KERN_DEBUG PFX "CIS: ");
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++)
printk("%02X:", ioread8(card->attr_io + (i << 1))); printk("%02X:", ioread8(card->attr_io + (i << 1)));
}
printk("\n"); printk("\n");
/* Verify whether a supported PC card is present */ /* Verify whether a supported PC card is present */

2
drivers/net/wireless/orinoco/orinoco_tmd.c
View File

@ -1,7 +1,7 @@
/* orinoco_tmd.c /* orinoco_tmd.c
* *
* Driver for Prism II devices which would usually be driven by orinoco_cs, * Driver for Prism II devices which would usually be driven by orinoco_cs,
* but are connected to the PCI bus by a TMD7160. * but are connected to the PCI bus by a TMD7160.
* *
* Copyright (C) 2003 Joerg Dorchain <joerg AT dorchain.net> * Copyright (C) 2003 Joerg Dorchain <joerg AT dorchain.net>
* based heavily upon orinoco_plx.c Copyright (C) 2001 Daniel Barlow * based heavily upon orinoco_plx.c Copyright (C) 2001 Daniel Barlow

15
drivers/net/wireless/orinoco/spectrum_cs.c
View File

@ -133,7 +133,7 @@ spectrum_reset(struct pcmcia_device *link, int idle)
udelay(1000); udelay(1000);
return 0; return 0;
cs_failed: cs_failed:
cs_error(link, last_fn, last_ret); cs_error(link, last_fn, last_ret);
return -ENODEV; return -ENODEV;
} }
@ -171,7 +171,7 @@ spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle)
* This creates an "instance" of the driver, allocating local data * This creates an "instance" of the driver, allocating local data
* structures for one device. The device is registered with Card * structures for one device. The device is registered with Card
* Services. * Services.
* *
* The dev_link structure is initialized, but we don't actually * The dev_link structure is initialized, but we don't actually
* configure the card at this point -- we wait until we receive a card * configure the card at this point -- we wait until we receive a card
* insertion event. */ * insertion event. */
@ -185,7 +185,7 @@ spectrum_cs_probe(struct pcmcia_device *link)
dev = alloc_orinocodev(sizeof(*card), &handle_to_dev(link), dev = alloc_orinocodev(sizeof(*card), &handle_to_dev(link),
spectrum_cs_hard_reset, spectrum_cs_hard_reset,
spectrum_cs_stop_firmware); spectrum_cs_stop_firmware);
if (! dev) if (!dev)
return -ENOMEM; return -ENOMEM;
priv = netdev_priv(dev); priv = netdev_priv(dev);
card = priv->card; card = priv->card;
@ -198,7 +198,7 @@ spectrum_cs_probe(struct pcmcia_device *link)
link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT; link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
link->irq.IRQInfo1 = IRQ_LEVEL_ID; link->irq.IRQInfo1 = IRQ_LEVEL_ID;
link->irq.Handler = orinoco_interrupt; link->irq.Handler = orinoco_interrupt;
link->irq.Instance = dev; link->irq.Instance = dev;
/* General socket configuration defaults can go here. In this /* General socket configuration defaults can go here. In this
* client, we assume very little, and rely on the CIS for * client, we assume very little, and rely on the CIS for
@ -367,9 +367,8 @@ spectrum_cs_config(struct pcmcia_device *link)
card->node.major = card->node.minor = 0; card->node.major = card->node.minor = 0;
/* Reset card */ /* Reset card */
if (spectrum_cs_hard_reset(priv) != 0) { if (spectrum_cs_hard_reset(priv) != 0)
goto failed; goto failed;
}
SET_NETDEV_DEV(dev, &handle_to_dev(link)); SET_NETDEV_DEV(dev, &handle_to_dev(link));
/* Tell the stack we exist */ /* Tell the stack we exist */
@ -382,8 +381,8 @@ spectrum_cs_config(struct pcmcia_device *link)
* initialized and arranged in a linked list at link->dev_node. */ * initialized and arranged in a linked list at link->dev_node. */
strcpy(card->node.dev_name, dev->name); strcpy(card->node.dev_name, dev->name);
link->dev_node = &card->node; /* link->dev_node being non-NULL is also link->dev_node = &card->node; /* link->dev_node being non-NULL is also
used to indicate that the * used to indicate that the
net_device has been registered */ * net_device has been registered */
/* Finally, report what we've done */ /* Finally, report what we've done */
printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io " printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io "

32
drivers/net/wireless/rt2x00/rt2400pci.c
View File

@ -934,21 +934,10 @@ static int rt2400pci_enable_radio(struct rt2x00_dev *rt2x00dev)
static void rt2400pci_disable_radio(struct rt2x00_dev *rt2x00dev) static void rt2400pci_disable_radio(struct rt2x00_dev *rt2x00dev)
{ {
u32 reg; /*
* Disable power
*/
rt2x00pci_register_write(rt2x00dev, PWRCSR0, 0); rt2x00pci_register_write(rt2x00dev, PWRCSR0, 0);
/*
* Disable synchronisation.
*/
rt2x00pci_register_write(rt2x00dev, CSR14, 0);
/*
* Cancel RX and TX.
*/
rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
} }
static int rt2400pci_set_state(struct rt2x00_dev *rt2x00dev, static int rt2400pci_set_state(struct rt2x00_dev *rt2x00dev,
@ -1145,6 +1134,20 @@ static void rt2400pci_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg); rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
} }
static void rt2400pci_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid qid)
{
u32 reg;
if (qid == QID_BEACON) {
rt2x00pci_register_write(rt2x00dev, CSR14, 0);
} else {
rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
}
}
/* /*
* RX control handlers * RX control handlers
*/ */
@ -1606,6 +1609,7 @@ static const struct rt2x00lib_ops rt2400pci_rt2x00_ops = {
.write_tx_data = rt2x00pci_write_tx_data, .write_tx_data = rt2x00pci_write_tx_data,
.write_beacon = rt2400pci_write_beacon, .write_beacon = rt2400pci_write_beacon,
.kick_tx_queue = rt2400pci_kick_tx_queue, .kick_tx_queue = rt2400pci_kick_tx_queue,
.kill_tx_queue = rt2400pci_kill_tx_queue,
.fill_rxdone = rt2400pci_fill_rxdone, .fill_rxdone = rt2400pci_fill_rxdone,
.config_filter = rt2400pci_config_filter, .config_filter = rt2400pci_config_filter,
.config_intf = rt2400pci_config_intf, .config_intf = rt2400pci_config_intf,

32
drivers/net/wireless/rt2x00/rt2500pci.c
View File

@ -1093,21 +1093,10 @@ static int rt2500pci_enable_radio(struct rt2x00_dev *rt2x00dev)
static void rt2500pci_disable_radio(struct rt2x00_dev *rt2x00dev) static void rt2500pci_disable_radio(struct rt2x00_dev *rt2x00dev)
{ {
u32 reg; /*
* Disable power
*/
rt2x00pci_register_write(rt2x00dev, PWRCSR0, 0); rt2x00pci_register_write(rt2x00dev, PWRCSR0, 0);
/*
* Disable synchronisation.
*/
rt2x00pci_register_write(rt2x00dev, CSR14, 0);
/*
* Cancel RX and TX.
*/
rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
} }
static int rt2500pci_set_state(struct rt2x00_dev *rt2x00dev, static int rt2500pci_set_state(struct rt2x00_dev *rt2x00dev,
@ -1303,6 +1292,20 @@ static void rt2500pci_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg); rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
} }
static void rt2500pci_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid qid)
{
u32 reg;
if (qid == QID_BEACON) {
rt2x00pci_register_write(rt2x00dev, CSR14, 0);
} else {
rt2x00pci_register_read(rt2x00dev, TXCSR0, &reg);
rt2x00_set_field32(&reg, TXCSR0_ABORT, 1);
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
}
}
/* /*
* RX control handlers * RX control handlers
*/ */
@ -1905,6 +1908,7 @@ static const struct rt2x00lib_ops rt2500pci_rt2x00_ops = {
.write_tx_data = rt2x00pci_write_tx_data, .write_tx_data = rt2x00pci_write_tx_data,
.write_beacon = rt2500pci_write_beacon, .write_beacon = rt2500pci_write_beacon,
.kick_tx_queue = rt2500pci_kick_tx_queue, .kick_tx_queue = rt2500pci_kick_tx_queue,
.kill_tx_queue = rt2500pci_kill_tx_queue,
.fill_rxdone = rt2500pci_fill_rxdone, .fill_rxdone = rt2500pci_fill_rxdone,
.config_filter = rt2500pci_config_filter, .config_filter = rt2500pci_config_filter,
.config_intf = rt2500pci_config_intf, .config_intf = rt2500pci_config_intf,

1
drivers/net/wireless/rt2x00/rt2500usb.c
View File

@ -1935,6 +1935,7 @@ static const struct rt2x00lib_ops rt2500usb_rt2x00_ops = {
.write_beacon = rt2500usb_write_beacon, .write_beacon = rt2500usb_write_beacon,
.get_tx_data_len = rt2500usb_get_tx_data_len, .get_tx_data_len = rt2500usb_get_tx_data_len,
.kick_tx_queue = rt2500usb_kick_tx_queue, .kick_tx_queue = rt2500usb_kick_tx_queue,
.kill_tx_queue = rt2x00usb_kill_tx_queue,
.fill_rxdone = rt2500usb_fill_rxdone, .fill_rxdone = rt2500usb_fill_rxdone,
.config_shared_key = rt2500usb_config_key, .config_shared_key = rt2500usb_config_key,
.config_pairwise_key = rt2500usb_config_key, .config_pairwise_key = rt2500usb_config_key,

9
drivers/net/wireless/rt2x00/rt2x00.h
View File

@ -468,9 +468,10 @@ struct rt2x00lib_ops {
*/ */
int (*probe_hw) (struct rt2x00_dev *rt2x00dev); int (*probe_hw) (struct rt2x00_dev *rt2x00dev);
char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev); char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev);
u16 (*get_firmware_crc) (const void *data, const size_t len); int (*check_firmware) (struct rt2x00_dev *rt2x00dev,
int (*load_firmware) (struct rt2x00_dev *rt2x00dev, const void *data, const u8 *data, const size_t len);
const size_t len); int (*load_firmware) (struct rt2x00_dev *rt2x00dev,
const u8 *data, const size_t len);
/* /*
* Device initialization/deinitialization handlers. * Device initialization/deinitialization handlers.
@ -508,6 +509,8 @@ struct rt2x00lib_ops {
int (*get_tx_data_len) (struct queue_entry *entry); int (*get_tx_data_len) (struct queue_entry *entry);
void (*kick_tx_queue) (struct rt2x00_dev *rt2x00dev, void (*kick_tx_queue) (struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid queue); const enum data_queue_qid queue);
void (*kill_tx_queue) (struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid queue);
/* /*
* RX control handlers * RX control handlers

7
drivers/net/wireless/rt2x00/rt2x00dev.c
View File

@ -83,9 +83,10 @@ void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
return; return;
/* /*
* Stop the TX queues. * Stop the TX queues in mac80211.
*/ */
ieee80211_stop_queues(rt2x00dev->hw); ieee80211_stop_queues(rt2x00dev->hw);
rt2x00queue_stop_queues(rt2x00dev);
/* /*
* Disable RX. * Disable RX.
@ -157,7 +158,7 @@ static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
return; return;
if (delayed_flags & DELAYED_UPDATE_BEACON) if (delayed_flags & DELAYED_UPDATE_BEACON)
rt2x00queue_update_beacon(rt2x00dev, vif); rt2x00queue_update_beacon(rt2x00dev, vif, true);
if (delayed_flags & DELAYED_CONFIG_ERP) if (delayed_flags & DELAYED_CONFIG_ERP)
rt2x00lib_config_erp(rt2x00dev, intf, &conf); rt2x00lib_config_erp(rt2x00dev, intf, &conf);
@ -215,7 +216,7 @@ void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
rt2x00lib_beacondone_iter, rt2x00lib_beacondone_iter,
rt2x00dev); rt2x00dev);
schedule_work(&rt2x00dev->intf_work); queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
} }
EXPORT_SYMBOL_GPL(rt2x00lib_beacondone); EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);

27
drivers/net/wireless/rt2x00/rt2x00firmware.c
View File

@ -35,7 +35,6 @@ static int rt2x00lib_request_firmware(struct rt2x00_dev *rt2x00dev)
const struct firmware *fw; const struct firmware *fw;
char *fw_name; char *fw_name;
int retval; int retval;
u16 crc;
/* /*
* Read correct firmware from harddisk. * Read correct firmware from harddisk.
@ -61,16 +60,26 @@ static int rt2x00lib_request_firmware(struct rt2x00_dev *rt2x00dev)
return -ENOENT; return -ENOENT;
} }
crc = rt2x00dev->ops->lib->get_firmware_crc(fw->data, fw->size);
if (crc != (fw->data[fw->size - 2] << 8 | fw->data[fw->size - 1])) {
ERROR(rt2x00dev, "Firmware checksum error.\n");
retval = -ENOENT;
goto exit;
}
INFO(rt2x00dev, "Firmware detected - version: %d.%d.\n", INFO(rt2x00dev, "Firmware detected - version: %d.%d.\n",
fw->data[fw->size - 4], fw->data[fw->size - 3]); fw->data[fw->size - 4], fw->data[fw->size - 3]);
retval = rt2x00dev->ops->lib->check_firmware(rt2x00dev, fw->data, fw->size);
switch (retval) {
case FW_OK:
break;
case FW_BAD_CRC:
ERROR(rt2x00dev, "Firmware checksum error.\n");
goto exit;
case FW_BAD_LENGTH:
ERROR(rt2x00dev,
"Invalid firmware file length (len=%zu)\n", fw->size);
goto exit;
case FW_BAD_VERSION:
ERROR(rt2x00dev,
"Current firmware does not support detected chipset.\n");
goto exit;
};
rt2x00dev->fw = fw; rt2x00dev->fw = fw;
return 0; return 0;
@ -78,7 +87,7 @@ static int rt2x00lib_request_firmware(struct rt2x00_dev *rt2x00dev)
exit: exit:
release_firmware(fw); release_firmware(fw);
return retval; return -ENOENT;
} }
int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev) int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev)

6
drivers/net/wireless/rt2x00/rt2x00leds.c
View File

@ -134,7 +134,7 @@ void rt2x00leds_register(struct rt2x00_dev *rt2x00dev)
rt2x00dev->ops->name, wiphy_name(rt2x00dev->hw->wiphy)); rt2x00dev->ops->name, wiphy_name(rt2x00dev->hw->wiphy));
if (rt2x00dev->led_radio.flags & LED_INITIALIZED) { if (rt2x00dev->led_radio.flags & LED_INITIALIZED) {
snprintf(name, sizeof(name), "%s:radio", dev_name); snprintf(name, sizeof(name), "%s::radio", dev_name);
retval = rt2x00leds_register_led(rt2x00dev, retval = rt2x00leds_register_led(rt2x00dev,
&rt2x00dev->led_radio, &rt2x00dev->led_radio,
@ -144,7 +144,7 @@ void rt2x00leds_register(struct rt2x00_dev *rt2x00dev)
} }
if (rt2x00dev->led_assoc.flags & LED_INITIALIZED) { if (rt2x00dev->led_assoc.flags & LED_INITIALIZED) {
snprintf(name, sizeof(name), "%s:assoc", dev_name); snprintf(name, sizeof(name), "%s::assoc", dev_name);
retval = rt2x00leds_register_led(rt2x00dev, retval = rt2x00leds_register_led(rt2x00dev,
&rt2x00dev->led_assoc, &rt2x00dev->led_assoc,
@ -154,7 +154,7 @@ void rt2x00leds_register(struct rt2x00_dev *rt2x00dev)
} }
if (rt2x00dev->led_qual.flags & LED_INITIALIZED) { if (rt2x00dev->led_qual.flags & LED_INITIALIZED) {
snprintf(name, sizeof(name), "%s:quality", dev_name); snprintf(name, sizeof(name), "%s::quality", dev_name);
retval = rt2x00leds_register_led(rt2x00dev, retval = rt2x00leds_register_led(rt2x00dev,
&rt2x00dev->led_qual, &rt2x00dev->led_qual,

13
drivers/net/wireless/rt2x00/rt2x00lib.h
View File

@ -123,9 +123,11 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb);
* rt2x00queue_update_beacon - Send new beacon from mac80211 to hardware * rt2x00queue_update_beacon - Send new beacon from mac80211 to hardware
* @rt2x00dev: Pointer to &struct rt2x00_dev. * @rt2x00dev: Pointer to &struct rt2x00_dev.
* @vif: Interface for which the beacon should be updated. * @vif: Interface for which the beacon should be updated.
* @enable_beacon: Enable beaconing
*/ */
int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev, int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev,
struct ieee80211_vif *vif); struct ieee80211_vif *vif,
const bool enable_beacon);
/** /**
* rt2x00queue_index_inc - Index incrementation function * rt2x00queue_index_inc - Index incrementation function
@ -138,6 +140,15 @@ int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev,
*/ */
void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index); void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index);
/**
* rt2x00queue_stop_queues - Halt all data queues
* @rt2x00dev: Pointer to &struct rt2x00_dev.
*
* This function will loop through all available queues to stop
* any pending outgoing frames.
*/
void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev);
/** /**
* rt2x00queue_init_queues - Initialize all data queues * rt2x00queue_init_queues - Initialize all data queues
* @rt2x00dev: Pointer to &struct rt2x00_dev. * @rt2x00dev: Pointer to &struct rt2x00_dev.

6
drivers/net/wireless/rt2x00/rt2x00mac.c
View File

@ -431,8 +431,10 @@ int rt2x00mac_config_interface(struct ieee80211_hw *hw,
/* /*
* Update the beacon. * Update the beacon.
*/ */
if (conf->changed & IEEE80211_IFCC_BEACON) if (conf->changed & (IEEE80211_IFCC_BEACON |
status = rt2x00queue_update_beacon(rt2x00dev, vif); IEEE80211_IFCC_BEACON_ENABLED))
status = rt2x00queue_update_beacon(rt2x00dev, vif,
conf->enable_beacon);
return status; return status;
} }

19
drivers/net/wireless/rt2x00/rt2x00queue.c
View File

@ -443,7 +443,8 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb)
} }
int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev, int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev,
struct ieee80211_vif *vif) struct ieee80211_vif *vif,
const bool enable_beacon)
{ {
struct rt2x00_intf *intf = vif_to_intf(vif); struct rt2x00_intf *intf = vif_to_intf(vif);
struct skb_frame_desc *skbdesc; struct skb_frame_desc *skbdesc;
@ -453,6 +454,11 @@ int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev,
if (unlikely(!intf->beacon)) if (unlikely(!intf->beacon))
return -ENOBUFS; return -ENOBUFS;
if (!enable_beacon) {
rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev, QID_BEACON);
return 0;
}
intf->beacon->skb = ieee80211_beacon_get(rt2x00dev->hw, vif); intf->beacon->skb = ieee80211_beacon_get(rt2x00dev->hw, vif);
if (!intf->beacon->skb) if (!intf->beacon->skb)
return -ENOMEM; return -ENOMEM;
@ -501,6 +507,9 @@ struct data_queue *rt2x00queue_get_queue(struct rt2x00_dev *rt2x00dev,
{ {
int atim = test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags); int atim = test_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);
if (queue == QID_RX)
return rt2x00dev->rx;
if (queue < rt2x00dev->ops->tx_queues && rt2x00dev->tx) if (queue < rt2x00dev->ops->tx_queues && rt2x00dev->tx)
return &rt2x00dev->tx[queue]; return &rt2x00dev->tx[queue];
@ -577,6 +586,14 @@ static void rt2x00queue_reset(struct data_queue *queue)
spin_unlock_irqrestore(&queue->lock, irqflags); spin_unlock_irqrestore(&queue->lock, irqflags);
} }
void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev)
{
struct data_queue *queue;
txall_queue_for_each(rt2x00dev, queue)
rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev, queue->qid);
}
void rt2x00queue_init_queues(struct rt2x00_dev *rt2x00dev) void rt2x00queue_init_queues(struct rt2x00_dev *rt2x00dev)
{ {
struct data_queue *queue; struct data_queue *queue;

10
drivers/net/wireless/rt2x00/rt2x00reg.h
View File

@ -134,6 +134,16 @@ enum rate_modulation {
RATE_MODE_HT_GREENFIELD = 3, RATE_MODE_HT_GREENFIELD = 3,
}; };
/*
* Firmware validation error codes
*/
enum firmware_errors {
FW_OK,
FW_BAD_CRC,
FW_BAD_LENGTH,
FW_BAD_VERSION,
};
/* /*
* Register handlers. * Register handlers.
* We store the position of a register field inside a field structure, * We store the position of a register field inside a field structure,

62
drivers/net/wireless/rt2x00/rt2x00usb.c
View File

@ -296,6 +296,41 @@ void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
} }
EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue); EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue);
void rt2x00usb_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid qid)
{
struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
struct queue_entry_priv_usb *entry_priv;
struct queue_entry_priv_usb_bcn *bcn_priv;
unsigned int i;
bool kill_guard;
/*
* When killing the beacon queue, we must also kill
* the beacon guard byte.
*/
kill_guard =
(qid == QID_BEACON) &&
(test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags));
/*
* Cancel all entries.
*/
for (i = 0; i < queue->limit; i++) {
entry_priv = queue->entries[i].priv_data;
usb_kill_urb(entry_priv->urb);
/*
* Kill guardian urb (if required by driver).
*/
if (kill_guard) {
bcn_priv = queue->entries[i].priv_data;
usb_kill_urb(bcn_priv->guardian_urb);
}
}
}
EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue);
/* /*
* RX data handlers. * RX data handlers.
*/ */
@ -338,35 +373,14 @@ static void rt2x00usb_interrupt_rxdone(struct urb *urb)
*/ */
void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev) void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
{ {
struct queue_entry_priv_usb *entry_priv;
struct queue_entry_priv_usb_bcn *bcn_priv;
struct data_queue *queue;
unsigned int i;
rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0, rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
REGISTER_TIMEOUT); REGISTER_TIMEOUT);
/* /*
* Cancel all queues. * The USB version of kill_tx_queue also works
* on the RX queue.
*/ */
queue_for_each(rt2x00dev, queue) { rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev, QID_RX);
for (i = 0; i < queue->limit; i++) {
entry_priv = queue->entries[i].priv_data;
usb_kill_urb(entry_priv->urb);
}
}
/*
* Kill guardian urb (if required by driver).
*/
if (!test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
return;
for (i = 0; i < rt2x00dev->bcn->limit; i++) {
bcn_priv = rt2x00dev->bcn->entries[i].priv_data;
if (bcn_priv->guardian_urb)
usb_kill_urb(bcn_priv->guardian_urb);
}
} }
EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio); EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);

11
drivers/net/wireless/rt2x00/rt2x00usb.h
View File

@ -419,6 +419,17 @@ struct queue_entry_priv_usb_bcn {
void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev, void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid qid); const enum data_queue_qid qid);
/**
* rt2x00usb_kill_tx_queue - Kill data queue
* @rt2x00dev: Pointer to &struct rt2x00_dev
* @qid: Data queue to kill
*
* This will walk through all entries of the queue and kill all
* previously kicked frames before they can be send.
*/
void rt2x00usb_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid qid);
/* /*
* Device initialization handlers. * Device initialization handlers.
*/ */

68
drivers/net/wireless/rt2x00/rt61pci.c
View File

@ -1176,34 +1176,41 @@ static char *rt61pci_get_firmware_name(struct rt2x00_dev *rt2x00dev)
return fw_name; return fw_name;
} }
static u16 rt61pci_get_firmware_crc(const void *data, const size_t len) static int rt61pci_check_firmware(struct rt2x00_dev *rt2x00dev,
const u8 *data, const size_t len)
{ {
u16 fw_crc;
u16 crc; u16 crc;
/* /*
* Use the crc itu-t algorithm. * Only support 8kb firmware files.
*/
if (len != 8192)
return FW_BAD_LENGTH;
/*
* The last 2 bytes in the firmware array are the crc checksum itself, * The last 2 bytes in the firmware array are the crc checksum itself,
* this means that we should never pass those 2 bytes to the crc * this means that we should never pass those 2 bytes to the crc
* algorithm. * algorithm.
*/ */
fw_crc = (data[len - 2] << 8 | data[len - 1]);
/*
* Use the crc itu-t algorithm.
*/
crc = crc_itu_t(0, data, len - 2); crc = crc_itu_t(0, data, len - 2);
crc = crc_itu_t_byte(crc, 0); crc = crc_itu_t_byte(crc, 0);
crc = crc_itu_t_byte(crc, 0); crc = crc_itu_t_byte(crc, 0);
return crc; return (fw_crc == crc) ? FW_OK : FW_BAD_CRC;
} }
static int rt61pci_load_firmware(struct rt2x00_dev *rt2x00dev, const void *data, static int rt61pci_load_firmware(struct rt2x00_dev *rt2x00dev,
const size_t len) const u8 *data, const size_t len)
{ {
int i; int i;
u32 reg; u32 reg;
if (len != 8192) {
ERROR(rt2x00dev, "Invalid firmware file length (len=%zu)\n", len);
return -ENOENT;
}
/* /*
* Wait for stable hardware. * Wait for stable hardware.
*/ */
@ -1696,24 +1703,10 @@ static int rt61pci_enable_radio(struct rt2x00_dev *rt2x00dev)
static void rt61pci_disable_radio(struct rt2x00_dev *rt2x00dev) static void rt61pci_disable_radio(struct rt2x00_dev *rt2x00dev)
{ {
u32 reg; /*
* Disable power
*/
rt2x00pci_register_write(rt2x00dev, MAC_CSR10, 0x00001818); rt2x00pci_register_write(rt2x00dev, MAC_CSR10, 0x00001818);
/*
* Disable synchronisation.
*/
rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, 0);
/*
* Cancel RX and TX.
*/
rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC0, 1);
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC1, 1);
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC2, 1);
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC3, 1);
rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
} }
static int rt61pci_set_state(struct rt2x00_dev *rt2x00dev, enum dev_state state) static int rt61pci_set_state(struct rt2x00_dev *rt2x00dev, enum dev_state state)
@ -1936,6 +1929,24 @@ static void rt61pci_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg); rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
} }
static void rt61pci_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
const enum data_queue_qid qid)
{
u32 reg;
if (qid == QID_BEACON) {
rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, 0);
return;
}
rt2x00pci_register_read(rt2x00dev, TX_CNTL_CSR, &reg);
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC0, (qid == QID_AC_BE));
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC1, (qid == QID_AC_BK));
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC2, (qid == QID_AC_VI));
rt2x00_set_field32(&reg, TX_CNTL_CSR_ABORT_TX_AC3, (qid == QID_AC_VO));
rt2x00pci_register_write(rt2x00dev, TX_CNTL_CSR, reg);
}
/* /*
* RX control handlers * RX control handlers
*/ */
@ -2746,7 +2757,7 @@ static const struct rt2x00lib_ops rt61pci_rt2x00_ops = {
.irq_handler = rt61pci_interrupt, .irq_handler = rt61pci_interrupt,
.probe_hw = rt61pci_probe_hw, .probe_hw = rt61pci_probe_hw,
.get_firmware_name = rt61pci_get_firmware_name, .get_firmware_name = rt61pci_get_firmware_name,
.get_firmware_crc = rt61pci_get_firmware_crc, .check_firmware = rt61pci_check_firmware,
.load_firmware = rt61pci_load_firmware, .load_firmware = rt61pci_load_firmware,
.initialize = rt2x00pci_initialize, .initialize = rt2x00pci_initialize,
.uninitialize = rt2x00pci_uninitialize, .uninitialize = rt2x00pci_uninitialize,
@ -2761,6 +2772,7 @@ static const struct rt2x00lib_ops rt61pci_rt2x00_ops = {
.write_tx_data = rt2x00pci_write_tx_data, .write_tx_data = rt2x00pci_write_tx_data,
.write_beacon = rt61pci_write_beacon, .write_beacon = rt61pci_write_beacon,
.kick_tx_queue = rt61pci_kick_tx_queue, .kick_tx_queue = rt61pci_kick_tx_queue,
.kill_tx_queue = rt61pci_kill_tx_queue,
.fill_rxdone = rt61pci_fill_rxdone, .fill_rxdone = rt61pci_fill_rxdone,
.config_shared_key = rt61pci_config_shared_key, .config_shared_key = rt61pci_config_shared_key,
.config_pairwise_key = rt61pci_config_pairwise_key, .config_pairwise_key = rt61pci_config_pairwise_key,

31
drivers/net/wireless/rt2x00/rt73usb.c
View File

@ -1061,35 +1061,42 @@ static char *rt73usb_get_firmware_name(struct rt2x00_dev *rt2x00dev)
return FIRMWARE_RT2571; return FIRMWARE_RT2571;
} }
static u16 rt73usb_get_firmware_crc(const void *data, const size_t len) static int rt73usb_check_firmware(struct rt2x00_dev *rt2x00dev,
const u8 *data, const size_t len)
{ {
u16 fw_crc;
u16 crc; u16 crc;
/* /*
* Use the crc itu-t algorithm. * Only support 2kb firmware files.
*/
if (len != 2048)
return FW_BAD_LENGTH;
/*
* The last 2 bytes in the firmware array are the crc checksum itself, * The last 2 bytes in the firmware array are the crc checksum itself,
* this means that we should never pass those 2 bytes to the crc * this means that we should never pass those 2 bytes to the crc
* algorithm. * algorithm.
*/ */
fw_crc = (data[len - 2] << 8 | data[len - 1]);
/*
* Use the crc itu-t algorithm.
*/
crc = crc_itu_t(0, data, len - 2); crc = crc_itu_t(0, data, len - 2);
crc = crc_itu_t_byte(crc, 0); crc = crc_itu_t_byte(crc, 0);
crc = crc_itu_t_byte(crc, 0); crc = crc_itu_t_byte(crc, 0);
return crc; return (fw_crc == crc) ? FW_OK : FW_BAD_CRC;
} }
static int rt73usb_load_firmware(struct rt2x00_dev *rt2x00dev, const void *data, static int rt73usb_load_firmware(struct rt2x00_dev *rt2x00dev,
const size_t len) const u8 *data, const size_t len)
{ {
unsigned int i; unsigned int i;
int status; int status;
u32 reg; u32 reg;
if (len != 2048) {
ERROR(rt2x00dev, "Invalid firmware file length (len=%zu)\n", len);
return -ENOENT;
}
/* /*
* Wait for stable hardware. * Wait for stable hardware.
*/ */
@ -2278,7 +2285,7 @@ static const struct ieee80211_ops rt73usb_mac80211_ops = {
static const struct rt2x00lib_ops rt73usb_rt2x00_ops = { static const struct rt2x00lib_ops rt73usb_rt2x00_ops = {
.probe_hw = rt73usb_probe_hw, .probe_hw = rt73usb_probe_hw,
.get_firmware_name = rt73usb_get_firmware_name, .get_firmware_name = rt73usb_get_firmware_name,
.get_firmware_crc = rt73usb_get_firmware_crc, .check_firmware = rt73usb_check_firmware,
.load_firmware = rt73usb_load_firmware, .load_firmware = rt73usb_load_firmware,
.initialize = rt2x00usb_initialize, .initialize = rt2x00usb_initialize,
.uninitialize = rt2x00usb_uninitialize, .uninitialize = rt2x00usb_uninitialize,
@ -2293,6 +2300,7 @@ static const struct rt2x00lib_ops rt73usb_rt2x00_ops = {
.write_beacon = rt73usb_write_beacon, .write_beacon = rt73usb_write_beacon,
.get_tx_data_len = rt73usb_get_tx_data_len, .get_tx_data_len = rt73usb_get_tx_data_len,
.kick_tx_queue = rt73usb_kick_tx_queue, .kick_tx_queue = rt73usb_kick_tx_queue,
.kill_tx_queue = rt2x00usb_kill_tx_queue,
.fill_rxdone = rt73usb_fill_rxdone, .fill_rxdone = rt73usb_fill_rxdone,
.config_shared_key = rt73usb_config_shared_key, .config_shared_key = rt73usb_config_shared_key,
.config_pairwise_key = rt73usb_config_pairwise_key, .config_pairwise_key = rt73usb_config_pairwise_key,
@ -2360,6 +2368,7 @@ static struct usb_device_id rt73usb_device_table[] = {
/* Billionton */ /* Billionton */
{ USB_DEVICE(0x1631, 0xc019), USB_DEVICE_DATA(&rt73usb_ops) }, { USB_DEVICE(0x1631, 0xc019), USB_DEVICE_DATA(&rt73usb_ops) },
/* Buffalo */ /* Buffalo */
{ USB_DEVICE(0x0411, 0x00d8), USB_DEVICE_DATA(&rt73usb_ops) },
{ USB_DEVICE(0x0411, 0x00f4), USB_DEVICE_DATA(&rt73usb_ops) }, { USB_DEVICE(0x0411, 0x00f4), USB_DEVICE_DATA(&rt73usb_ops) },
/* CNet */ /* CNet */
{ USB_DEVICE(0x1371, 0x9022), USB_DEVICE_DATA(&rt73usb_ops) }, { USB_DEVICE(0x1371, 0x9022), USB_DEVICE_DATA(&rt73usb_ops) },

2
drivers/net/wireless/zd1211rw/zd_mac.c
View File

@ -967,7 +967,7 @@ struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf)
hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &mac->band; hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &mac->band;
hw->flags = IEEE80211_HW_RX_INCLUDES_FCS | hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
IEEE80211_HW_SIGNAL_DB; IEEE80211_HW_SIGNAL_UNSPEC;
hw->wiphy->interface_modes = hw->wiphy->interface_modes =
BIT(NL80211_IFTYPE_MESH_POINT) | BIT(NL80211_IFTYPE_MESH_POINT) |

1
drivers/ssb/Makefile
View File

@ -9,6 +9,7 @@ ssb-$(CONFIG_SSB_PCMCIAHOST) += pcmcia.o
# built-in drivers # built-in drivers
ssb-y += driver_chipcommon.o ssb-y += driver_chipcommon.o
ssb-y += driver_chipcommon_pmu.o
ssb-$(CONFIG_SSB_DRIVER_MIPS) += driver_mipscore.o ssb-$(CONFIG_SSB_DRIVER_MIPS) += driver_mipscore.o
ssb-$(CONFIG_SSB_DRIVER_EXTIF) += driver_extif.o ssb-$(CONFIG_SSB_DRIVER_EXTIF) += driver_extif.o
ssb-$(CONFIG_SSB_DRIVER_PCICORE) += driver_pcicore.o ssb-$(CONFIG_SSB_DRIVER_PCICORE) += driver_pcicore.o

14
drivers/ssb/driver_chipcommon.c
View File

@ -26,19 +26,6 @@ enum ssb_clksrc {
}; };
static inline u32 chipco_read32(struct ssb_chipcommon *cc,
u16 offset)
{
return ssb_read32(cc->dev, offset);
}
static inline void chipco_write32(struct ssb_chipcommon *cc,
u16 offset,
u32 value)
{
ssb_write32(cc->dev, offset, value);
}
static inline u32 chipco_write32_masked(struct ssb_chipcommon *cc, u16 offset, static inline u32 chipco_write32_masked(struct ssb_chipcommon *cc, u16 offset,
u32 mask, u32 value) u32 mask, u32 value)
{ {
@ -246,6 +233,7 @@ void ssb_chipcommon_init(struct ssb_chipcommon *cc)
{ {
if (!cc->dev) if (!cc->dev)
return; /* We don't have a ChipCommon */ return; /* We don't have a ChipCommon */
ssb_pmu_init(cc);
chipco_powercontrol_init(cc); chipco_powercontrol_init(cc);
ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST);
calc_fast_powerup_delay(cc); calc_fast_powerup_delay(cc);

508
drivers/ssb/driver_chipcommon_pmu.c Normal file
View File

@ -0,0 +1,508 @@
/*
* Sonics Silicon Backplane
* Broadcom ChipCommon Power Management Unit driver
*
* Copyright 2009, Michael Buesch <mb@bu3sch.de>
* Copyright 2007, Broadcom Corporation
*
* Licensed under the GNU/GPL. See COPYING for details.
*/
#include <linux/ssb/ssb.h>
#include <linux/ssb/ssb_regs.h>
#include <linux/ssb/ssb_driver_chipcommon.h>
#include <linux/delay.h>
#include "ssb_private.h"
static u32 ssb_chipco_pll_read(struct ssb_chipcommon *cc, u32 offset)
{
chipco_write32(cc, SSB_CHIPCO_PLLCTL_ADDR, offset);
return chipco_read32(cc, SSB_CHIPCO_PLLCTL_DATA);
}
static void ssb_chipco_pll_write(struct ssb_chipcommon *cc,
u32 offset, u32 value)
{
chipco_write32(cc, SSB_CHIPCO_PLLCTL_ADDR, offset);
chipco_write32(cc, SSB_CHIPCO_PLLCTL_DATA, value);
}
struct pmu0_plltab_entry {
u16 freq; /* Crystal frequency in kHz.*/
u8 xf; /* Crystal frequency value for PMU control */
u8 wb_int;
u32 wb_frac;
};
static const struct pmu0_plltab_entry pmu0_plltab[] = {
{ .freq = 12000, .xf = 1, .wb_int = 73, .wb_frac = 349525, },
{ .freq = 13000, .xf = 2, .wb_int = 67, .wb_frac = 725937, },
{ .freq = 14400, .xf = 3, .wb_int = 61, .wb_frac = 116508, },
{ .freq = 15360, .xf = 4, .wb_int = 57, .wb_frac = 305834, },
{ .freq = 16200, .xf = 5, .wb_int = 54, .wb_frac = 336579, },
{ .freq = 16800, .xf = 6, .wb_int = 52, .wb_frac = 399457, },
{ .freq = 19200, .xf = 7, .wb_int = 45, .wb_frac = 873813, },
{ .freq = 19800, .xf = 8, .wb_int = 44, .wb_frac = 466033, },
{ .freq = 20000, .xf = 9, .wb_int = 44, .wb_frac = 0, },
{ .freq = 25000, .xf = 10, .wb_int = 70, .wb_frac = 419430, },
{ .freq = 26000, .xf = 11, .wb_int = 67, .wb_frac = 725937, },
{ .freq = 30000, .xf = 12, .wb_int = 58, .wb_frac = 699050, },
{ .freq = 38400, .xf = 13, .wb_int = 45, .wb_frac = 873813, },
{ .freq = 40000, .xf = 14, .wb_int = 45, .wb_frac = 0, },
};
#define SSB_PMU0_DEFAULT_XTALFREQ 20000
static const struct pmu0_plltab_entry * pmu0_plltab_find_entry(u32 crystalfreq)
{
const struct pmu0_plltab_entry *e;
unsigned int i;
for (i = 0; i < ARRAY_SIZE(pmu0_plltab); i++) {
e = &pmu0_plltab[i];
if (e->freq == crystalfreq)
return e;
}
return NULL;
}
/* Tune the PLL to the crystal speed. crystalfreq is in kHz. */
static void ssb_pmu0_pllinit_r0(struct ssb_chipcommon *cc,
u32 crystalfreq)
{
struct ssb_bus *bus = cc->dev->bus;
const struct pmu0_plltab_entry *e = NULL;
u32 pmuctl, tmp, pllctl;
unsigned int i;
if ((bus->chip_id == 0x5354) && !crystalfreq) {
/* The 5354 crystal freq is 25MHz */
crystalfreq = 25000;
}
if (crystalfreq)
e = pmu0_plltab_find_entry(crystalfreq);
if (!e)
e = pmu0_plltab_find_entry(SSB_PMU0_DEFAULT_XTALFREQ);
BUG_ON(!e);
crystalfreq = e->freq;
cc->pmu.crystalfreq = e->freq;
/* Check if the PLL already is programmed to this frequency. */
pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL);
if (((pmuctl & SSB_CHIPCO_PMU_CTL_XTALFREQ) >> SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) == e->xf) {
/* We're already there... */
return;
}
ssb_printk(KERN_INFO PFX "Programming PLL to %u.%03u MHz\n",
(crystalfreq / 1000), (crystalfreq % 1000));
/* First turn the PLL off. */
switch (bus->chip_id) {
case 0x4328:
chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK,
~(1 << SSB_PMURES_4328_BB_PLL_PU));
chipco_mask32(cc, SSB_CHIPCO_PMU_MAXRES_MSK,
~(1 << SSB_PMURES_4328_BB_PLL_PU));
break;
case 0x5354:
chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK,
~(1 << SSB_PMURES_5354_BB_PLL_PU));
chipco_mask32(cc, SSB_CHIPCO_PMU_MAXRES_MSK,
~(1 << SSB_PMURES_5354_BB_PLL_PU));
break;
default:
SSB_WARN_ON(1);
}
for (i = 1500; i; i--) {
tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST);
if (!(tmp & SSB_CHIPCO_CLKCTLST_HAVEHT))
break;
udelay(10);
}
tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST);
if (tmp & SSB_CHIPCO_CLKCTLST_HAVEHT)
ssb_printk(KERN_EMERG PFX "Failed to turn the PLL off!\n");
/* Set PDIV in PLL control 0. */
pllctl = ssb_chipco_pll_read(cc, SSB_PMU0_PLLCTL0);
if (crystalfreq >= SSB_PMU0_PLLCTL0_PDIV_FREQ)
pllctl |= SSB_PMU0_PLLCTL0_PDIV_MSK;
else
pllctl &= ~SSB_PMU0_PLLCTL0_PDIV_MSK;
ssb_chipco_pll_write(cc, SSB_PMU0_PLLCTL0, pllctl);
/* Set WILD in PLL control 1. */
pllctl = ssb_chipco_pll_read(cc, SSB_PMU0_PLLCTL1);
pllctl &= ~SSB_PMU0_PLLCTL1_STOPMOD;
pllctl &= ~(SSB_PMU0_PLLCTL1_WILD_IMSK | SSB_PMU0_PLLCTL1_WILD_FMSK);
pllctl |= ((u32)e->wb_int << SSB_PMU0_PLLCTL1_WILD_IMSK_SHIFT) & SSB_PMU0_PLLCTL1_WILD_IMSK;
pllctl |= ((u32)e->wb_frac << SSB_PMU0_PLLCTL1_WILD_FMSK_SHIFT) & SSB_PMU0_PLLCTL1_WILD_FMSK;
if (e->wb_frac == 0)
pllctl |= SSB_PMU0_PLLCTL1_STOPMOD;
ssb_chipco_pll_write(cc, SSB_PMU0_PLLCTL1, pllctl);
/* Set WILD in PLL control 2. */
pllctl = ssb_chipco_pll_read(cc, SSB_PMU0_PLLCTL2);
pllctl &= ~SSB_PMU0_PLLCTL2_WILD_IMSKHI;
pllctl |= (((u32)e->wb_int >> 4) << SSB_PMU0_PLLCTL2_WILD_IMSKHI_SHIFT) & SSB_PMU0_PLLCTL2_WILD_IMSKHI;
ssb_chipco_pll_write(cc, SSB_PMU0_PLLCTL2, pllctl);
/* Set the crystalfrequency and the divisor. */
pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL);
pmuctl &= ~SSB_CHIPCO_PMU_CTL_ILP_DIV;
pmuctl |= (((crystalfreq + 127) / 128 - 1) << SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT)
& SSB_CHIPCO_PMU_CTL_ILP_DIV;
pmuctl &= ~SSB_CHIPCO_PMU_CTL_XTALFREQ;
pmuctl |= ((u32)e->xf << SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) & SSB_CHIPCO_PMU_CTL_XTALFREQ;
chipco_write32(cc, SSB_CHIPCO_PMU_CTL, pmuctl);
}
struct pmu1_plltab_entry {
u16 freq; /* Crystal frequency in kHz.*/
u8 xf; /* Crystal frequency value for PMU control */
u8 ndiv_int;
u32 ndiv_frac;
u8 p1div;
u8 p2div;
};
static const struct pmu1_plltab_entry pmu1_plltab[] = {
{ .freq = 12000, .xf = 1, .p1div = 3, .p2div = 22, .ndiv_int = 0x9, .ndiv_frac = 0xFFFFEF, },
{ .freq = 13000, .xf = 2, .p1div = 1, .p2div = 6, .ndiv_int = 0xb, .ndiv_frac = 0x483483, },
{ .freq = 14400, .xf = 3, .p1div = 1, .p2div = 10, .ndiv_int = 0xa, .ndiv_frac = 0x1C71C7, },
{ .freq = 15360, .xf = 4, .p1div = 1, .p2div = 5, .ndiv_int = 0xb, .ndiv_frac = 0x755555, },
{ .freq = 16200, .xf = 5, .p1div = 1, .p2div = 10, .ndiv_int = 0x5, .ndiv_frac = 0x6E9E06, },
{ .freq = 16800, .xf = 6, .p1div = 1, .p2div = 10, .ndiv_int = 0x5, .ndiv_frac = 0x3CF3CF, },
{ .freq = 19200, .xf = 7, .p1div = 1, .p2div = 9, .ndiv_int = 0x5, .ndiv_frac = 0x17B425, },
{ .freq = 19800, .xf = 8, .p1div = 1, .p2div = 11, .ndiv_int = 0x4, .ndiv_frac = 0xA57EB, },
{ .freq = 20000, .xf = 9, .p1div = 1, .p2div = 11, .ndiv_int = 0x4, .ndiv_frac = 0, },
{ .freq = 24000, .xf = 10, .p1div = 3, .p2div = 11, .ndiv_int = 0xa, .ndiv_frac = 0, },
{ .freq = 25000, .xf = 11, .p1div = 5, .p2div = 16, .ndiv_int = 0xb, .ndiv_frac = 0, },
{ .freq = 26000, .xf = 12, .p1div = 1, .p2div = 2, .ndiv_int = 0x10, .ndiv_frac = 0xEC4EC4, },
{ .freq = 30000, .xf = 13, .p1div = 3, .p2div = 8, .ndiv_int = 0xb, .ndiv_frac = 0, },
{ .freq = 38400, .xf = 14, .p1div = 1, .p2div = 5, .ndiv_int = 0x4, .ndiv_frac = 0x955555, },
{ .freq = 40000, .xf = 15, .p1div = 1, .p2div = 2, .ndiv_int = 0xb, .ndiv_frac = 0, },
};
#define SSB_PMU1_DEFAULT_XTALFREQ 15360
static const struct pmu1_plltab_entry * pmu1_plltab_find_entry(u32 crystalfreq)
{
const struct pmu1_plltab_entry *e;
unsigned int i;
for (i = 0; i < ARRAY_SIZE(pmu1_plltab); i++) {
e = &pmu1_plltab[i];
if (e->freq == crystalfreq)
return e;
}
return NULL;
}
/* Tune the PLL to the crystal speed. crystalfreq is in kHz. */
static void ssb_pmu1_pllinit_r0(struct ssb_chipcommon *cc,
u32 crystalfreq)
{
struct ssb_bus *bus = cc->dev->bus;
const struct pmu1_plltab_entry *e = NULL;
u32 buffer_strength = 0;
u32 tmp, pllctl, pmuctl;
unsigned int i;
if (bus->chip_id == 0x4312) {
/* We do not touch the BCM4312 PLL and assume
* the default crystal settings work out-of-the-box. */
cc->pmu.crystalfreq = 20000;
return;
}
if (crystalfreq)
e = pmu1_plltab_find_entry(crystalfreq);
if (!e)
e = pmu1_plltab_find_entry(SSB_PMU1_DEFAULT_XTALFREQ);
BUG_ON(!e);
crystalfreq = e->freq;
cc->pmu.crystalfreq = e->freq;
/* Check if the PLL already is programmed to this frequency. */
pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL);
if (((pmuctl & SSB_CHIPCO_PMU_CTL_XTALFREQ) >> SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) == e->xf) {
/* We're already there... */
return;
}
ssb_printk(KERN_INFO PFX "Programming PLL to %u.%03u MHz\n",
(crystalfreq / 1000), (crystalfreq % 1000));
/* First turn the PLL off. */
switch (bus->chip_id) {
case 0x4325:
chipco_mask32(cc, SSB_CHIPCO_PMU_MINRES_MSK,
~((1 << SSB_PMURES_4325_BBPLL_PWRSW_PU) |
(1 << SSB_PMURES_4325_HT_AVAIL)));
chipco_mask32(cc, SSB_CHIPCO_PMU_MAXRES_MSK,
~((1 << SSB_PMURES_4325_BBPLL_PWRSW_PU) |
(1 << SSB_PMURES_4325_HT_AVAIL)));
/* Adjust the BBPLL to 2 on all channels later. */
buffer_strength = 0x222222;
break;
default:
SSB_WARN_ON(1);
}
for (i = 1500; i; i--) {
tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST);
if (!(tmp & SSB_CHIPCO_CLKCTLST_HAVEHT))
break;
udelay(10);
}
tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST);
if (tmp & SSB_CHIPCO_CLKCTLST_HAVEHT)
ssb_printk(KERN_EMERG PFX "Failed to turn the PLL off!\n");
/* Set p1div and p2div. */
pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL0);
pllctl &= ~(SSB_PMU1_PLLCTL0_P1DIV | SSB_PMU1_PLLCTL0_P2DIV);
pllctl |= ((u32)e->p1div << SSB_PMU1_PLLCTL0_P1DIV_SHIFT) & SSB_PMU1_PLLCTL0_P1DIV;
pllctl |= ((u32)e->p2div << SSB_PMU1_PLLCTL0_P2DIV_SHIFT) & SSB_PMU1_PLLCTL0_P2DIV;
ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL0, pllctl);
/* Set ndiv int and ndiv mode */
pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL2);
pllctl &= ~(SSB_PMU1_PLLCTL2_NDIVINT | SSB_PMU1_PLLCTL2_NDIVMODE);
pllctl |= ((u32)e->ndiv_int << SSB_PMU1_PLLCTL2_NDIVINT_SHIFT) & SSB_PMU1_PLLCTL2_NDIVINT;
pllctl |= (1 << SSB_PMU1_PLLCTL2_NDIVMODE_SHIFT) & SSB_PMU1_PLLCTL2_NDIVMODE;
ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL2, pllctl);
/* Set ndiv frac */
pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL3);
pllctl &= ~SSB_PMU1_PLLCTL3_NDIVFRAC;
pllctl |= ((u32)e->ndiv_frac << SSB_PMU1_PLLCTL3_NDIVFRAC_SHIFT) & SSB_PMU1_PLLCTL3_NDIVFRAC;
ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL3, pllctl);
/* Change the drive strength, if required. */
if (buffer_strength) {
pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL5);
pllctl &= ~SSB_PMU1_PLLCTL5_CLKDRV;
pllctl |= (buffer_strength << SSB_PMU1_PLLCTL5_CLKDRV_SHIFT) & SSB_PMU1_PLLCTL5_CLKDRV;
ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL5, pllctl);
}
/* Tune the crystalfreq and the divisor. */
pmuctl = chipco_read32(cc, SSB_CHIPCO_PMU_CTL);
pmuctl &= ~(SSB_CHIPCO_PMU_CTL_ILP_DIV | SSB_CHIPCO_PMU_CTL_XTALFREQ);
pmuctl |= ((((u32)e->freq + 127) / 128 - 1) << SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT)
& SSB_CHIPCO_PMU_CTL_ILP_DIV;
pmuctl |= ((u32)e->xf << SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT) & SSB_CHIPCO_PMU_CTL_XTALFREQ;
chipco_write32(cc, SSB_CHIPCO_PMU_CTL, pmuctl);
}
static void ssb_pmu_pll_init(struct ssb_chipcommon *cc)
{
struct ssb_bus *bus = cc->dev->bus;
u32 crystalfreq = 0; /* in kHz. 0 = keep default freq. */
if (bus->bustype == SSB_BUSTYPE_SSB) {
/* TODO: The user may override the crystal frequency. */
}
switch (bus->chip_id) {
case 0x4312:
case 0x4325:
ssb_pmu1_pllinit_r0(cc, crystalfreq);
break;
case 0x4328:
case 0x5354:
ssb_pmu0_pllinit_r0(cc, crystalfreq);
break;
default:
ssb_printk(KERN_ERR PFX
"ERROR: PLL init unknown for device %04X\n",
bus->chip_id);
}
}
struct pmu_res_updown_tab_entry {
u8 resource; /* The resource number */
u16 updown; /* The updown value */
};
enum pmu_res_depend_tab_task {
PMU_RES_DEP_SET = 1,
PMU_RES_DEP_ADD,
PMU_RES_DEP_REMOVE,
};
struct pmu_res_depend_tab_entry {
u8 resource; /* The resource number */
u8 task; /* SET | ADD | REMOVE */
u32 depend; /* The depend mask */
};
static const struct pmu_res_updown_tab_entry pmu_res_updown_tab_4328a0[] = {
{ .resource = SSB_PMURES_4328_EXT_SWITCHER_PWM, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_BB_SWITCHER_PWM, .updown = 0x1F01, },
{ .resource = SSB_PMURES_4328_BB_SWITCHER_BURST, .updown = 0x010F, },
{ .resource = SSB_PMURES_4328_BB_EXT_SWITCHER_BURST, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_ILP_REQUEST, .updown = 0x0202, },
{ .resource = SSB_PMURES_4328_RADIO_SWITCHER_PWM, .updown = 0x0F01, },
{ .resource = SSB_PMURES_4328_RADIO_SWITCHER_BURST, .updown = 0x0F01, },
{ .resource = SSB_PMURES_4328_ROM_SWITCH, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_PA_REF_LDO, .updown = 0x0F01, },
{ .resource = SSB_PMURES_4328_RADIO_LDO, .updown = 0x0F01, },
{ .resource = SSB_PMURES_4328_AFE_LDO, .updown = 0x0F01, },
{ .resource = SSB_PMURES_4328_PLL_LDO, .updown = 0x0F01, },
{ .resource = SSB_PMURES_4328_BG_FILTBYP, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_TX_FILTBYP, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_RX_FILTBYP, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_XTAL_PU, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_XTAL_EN, .updown = 0xA001, },
{ .resource = SSB_PMURES_4328_BB_PLL_FILTBYP, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_RF_PLL_FILTBYP, .updown = 0x0101, },
{ .resource = SSB_PMURES_4328_BB_PLL_PU, .updown = 0x0701, },
};
static const struct pmu_res_depend_tab_entry pmu_res_depend_tab_4328a0[] = {
{
/* Adjust ILP Request to avoid forcing EXT/BB into burst mode. */
.resource = SSB_PMURES_4328_ILP_REQUEST,
.task = PMU_RES_DEP_SET,
.depend = ((1 << SSB_PMURES_4328_EXT_SWITCHER_PWM) |
(1 << SSB_PMURES_4328_BB_SWITCHER_PWM)),
},
};
static const struct pmu_res_updown_tab_entry pmu_res_updown_tab_4325a0[] = {
{ .resource = SSB_PMURES_4325_XTAL_PU, .updown = 0x1501, },
};
static const struct pmu_res_depend_tab_entry pmu_res_depend_tab_4325a0[] = {
{
/* Adjust HT-Available dependencies. */
.resource = SSB_PMURES_4325_HT_AVAIL,
.task = PMU_RES_DEP_ADD,
.depend = ((1 << SSB_PMURES_4325_RX_PWRSW_PU) |
(1 << SSB_PMURES_4325_TX_PWRSW_PU) |
(1 << SSB_PMURES_4325_LOGEN_PWRSW_PU) |
(1 << SSB_PMURES_4325_AFE_PWRSW_PU)),
},
};
static void ssb_pmu_resources_init(struct ssb_chipcommon *cc)
{
struct ssb_bus *bus = cc->dev->bus;
u32 min_msk = 0, max_msk = 0;
unsigned int i;
const struct pmu_res_updown_tab_entry *updown_tab = NULL;
unsigned int updown_tab_size;
const struct pmu_res_depend_tab_entry *depend_tab = NULL;
unsigned int depend_tab_size;
switch (bus->chip_id) {
case 0x4312:
/* We keep the default settings:
* min_msk = 0xCBB
* max_msk = 0x7FFFF
*/
break;
case 0x4325:
/* Power OTP down later. */
min_msk = (1 << SSB_PMURES_4325_CBUCK_BURST) |
(1 << SSB_PMURES_4325_LNLDO2_PU);
if (chipco_read32(cc, SSB_CHIPCO_CHIPSTAT) &
SSB_CHIPCO_CHST_4325_PMUTOP_2B)
min_msk |= (1 << SSB_PMURES_4325_CLDO_CBUCK_BURST);
/* The PLL may turn on, if it decides so. */
max_msk = 0xFFFFF;
updown_tab = pmu_res_updown_tab_4325a0;
updown_tab_size = ARRAY_SIZE(pmu_res_updown_tab_4325a0);
depend_tab = pmu_res_depend_tab_4325a0;
depend_tab_size = ARRAY_SIZE(pmu_res_depend_tab_4325a0);
break;
case 0x4328:
min_msk = (1 << SSB_PMURES_4328_EXT_SWITCHER_PWM) |
(1 << SSB_PMURES_4328_BB_SWITCHER_PWM) |
(1 << SSB_PMURES_4328_XTAL_EN);
/* The PLL may turn on, if it decides so. */
max_msk = 0xFFFFF;
updown_tab = pmu_res_updown_tab_4328a0;
updown_tab_size = ARRAY_SIZE(pmu_res_updown_tab_4328a0);
depend_tab = pmu_res_depend_tab_4328a0;
depend_tab_size = ARRAY_SIZE(pmu_res_depend_tab_4328a0);
break;
case 0x5354:
/* The PLL may turn on, if it decides so. */
max_msk = 0xFFFFF;
break;
default:
ssb_printk(KERN_ERR PFX
"ERROR: PMU resource config unknown for device %04X\n",
bus->chip_id);
}
if (updown_tab) {
for (i = 0; i < updown_tab_size; i++) {
chipco_write32(cc, SSB_CHIPCO_PMU_RES_TABSEL,
updown_tab[i].resource);
chipco_write32(cc, SSB_CHIPCO_PMU_RES_UPDNTM,
updown_tab[i].updown);
}
}
if (depend_tab) {
for (i = 0; i < depend_tab_size; i++) {
chipco_write32(cc, SSB_CHIPCO_PMU_RES_TABSEL,
depend_tab[i].resource);
switch (depend_tab[i].task) {
case PMU_RES_DEP_SET:
chipco_write32(cc, SSB_CHIPCO_PMU_RES_DEPMSK,
depend_tab[i].depend);
break;
case PMU_RES_DEP_ADD:
chipco_set32(cc, SSB_CHIPCO_PMU_RES_DEPMSK,
depend_tab[i].depend);
break;
case PMU_RES_DEP_REMOVE:
chipco_mask32(cc, SSB_CHIPCO_PMU_RES_DEPMSK,
~(depend_tab[i].depend));
break;
default:
SSB_WARN_ON(1);
}
}
}
/* Set the resource masks. */
if (min_msk)
chipco_write32(cc, SSB_CHIPCO_PMU_MINRES_MSK, min_msk);
if (max_msk)
chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk);
}
void ssb_pmu_init(struct ssb_chipcommon *cc)
{
struct ssb_bus *bus = cc->dev->bus;
u32 pmucap;
if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU))
return;
pmucap = chipco_read32(cc, SSB_CHIPCO_PMU_CAP);
cc->pmu.rev = (pmucap & SSB_CHIPCO_PMU_CAP_REVISION);
ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n",
cc->pmu.rev, pmucap);
if (cc->pmu.rev >= 1) {
if ((bus->chip_id == 0x4325) && (bus->chip_rev < 2)) {
chipco_mask32(cc, SSB_CHIPCO_PMU_CTL,
~SSB_CHIPCO_PMU_CTL_NOILPONW);
} else {
chipco_set32(cc, SSB_CHIPCO_PMU_CTL,
SSB_CHIPCO_PMU_CTL_NOILPONW);
}
}
ssb_pmu_pll_init(cc);
ssb_pmu_resources_init(cc);
}

4
include/linux/nl80211.h
View File

@ -113,6 +113,8 @@
* @NL80211_CMD_SET_BSS: Set BSS attributes for BSS identified by * @NL80211_CMD_SET_BSS: Set BSS attributes for BSS identified by
* %NL80211_ATTR_IFINDEX. * %NL80211_ATTR_IFINDEX.
* *
* @NL80211_CMD_GET_REG: ask the wireless core to send us its currently set
* regulatory domain.
* @NL80211_CMD_SET_REG: Set current regulatory domain. CRDA sends this command * @NL80211_CMD_SET_REG: Set current regulatory domain. CRDA sends this command
* after being queried by the kernel. CRDA replies by sending a regulatory * after being queried by the kernel. CRDA replies by sending a regulatory
* domain structure which consists of %NL80211_ATTR_REG_ALPHA set to our * domain structure which consists of %NL80211_ATTR_REG_ALPHA set to our
@ -188,6 +190,8 @@ enum nl80211_commands {
NL80211_CMD_SET_MGMT_EXTRA_IE, NL80211_CMD_SET_MGMT_EXTRA_IE,
NL80211_CMD_GET_REG,
/* add new commands above here */ /* add new commands above here */
/* used to define NL80211_CMD_MAX below */ /* used to define NL80211_CMD_MAX below */

7
include/linux/spi/libertas_spi.h
View File

@ -10,6 +10,9 @@
*/ */
#ifndef _LIBERTAS_SPI_H_ #ifndef _LIBERTAS_SPI_H_
#define _LIBERTAS_SPI_H_ #define _LIBERTAS_SPI_H_
struct spi_device;
struct libertas_spi_platform_data { struct libertas_spi_platform_data {
/* There are two ways to read data from the WLAN module's SPI /* There are two ways to read data from the WLAN module's SPI
* interface. Setting 0 or 1 here controls which one is used. * interface. Setting 0 or 1 here controls which one is used.
@ -21,5 +24,9 @@ struct libertas_spi_platform_data {
/* GPIO number to use as chip select */ /* GPIO number to use as chip select */
u16 gpio_cs; u16 gpio_cs;
/* Board specific setup/teardown */
int (*setup)(struct spi_device *spi);
int (*teardown)(struct spi_device *spi);
}; };
#endif #endif

224
include/linux/ssb/ssb_driver_chipcommon.h
View File

@ -181,6 +181,16 @@
#define SSB_CHIPCO_PROG_WAITCNT 0x0124 #define SSB_CHIPCO_PROG_WAITCNT 0x0124
#define SSB_CHIPCO_FLASH_CFG 0x0128 #define SSB_CHIPCO_FLASH_CFG 0x0128
#define SSB_CHIPCO_FLASH_WAITCNT 0x012C #define SSB_CHIPCO_FLASH_WAITCNT 0x012C
#define SSB_CHIPCO_CLKCTLST 0x01E0 /* Clock control and status (rev >= 20) */
#define SSB_CHIPCO_CLKCTLST_FORCEALP 0x00000001 /* Force ALP request */
#define SSB_CHIPCO_CLKCTLST_FORCEHT 0x00000002 /* Force HT request */
#define SSB_CHIPCO_CLKCTLST_FORCEILP 0x00000004 /* Force ILP request */
#define SSB_CHIPCO_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */
#define SSB_CHIPCO_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */
#define SSB_CHIPCO_CLKCTLST_HWCROFF 0x00000020 /* Force HW clock request off */
#define SSB_CHIPCO_CLKCTLST_HAVEHT 0x00010000 /* HT available */
#define SSB_CHIPCO_CLKCTLST_HAVEALP 0x00020000 /* APL available */
#define SSB_CHIPCO_HW_WORKAROUND 0x01E4 /* Hardware workaround (rev >= 20) */
#define SSB_CHIPCO_UART0_DATA 0x0300 #define SSB_CHIPCO_UART0_DATA 0x0300
#define SSB_CHIPCO_UART0_IMR 0x0304 #define SSB_CHIPCO_UART0_IMR 0x0304
#define SSB_CHIPCO_UART0_FCR 0x0308 #define SSB_CHIPCO_UART0_FCR 0x0308
@ -197,6 +207,196 @@
#define SSB_CHIPCO_UART1_LSR 0x0414 #define SSB_CHIPCO_UART1_LSR 0x0414
#define SSB_CHIPCO_UART1_MSR 0x0418 #define SSB_CHIPCO_UART1_MSR 0x0418
#define SSB_CHIPCO_UART1_SCRATCH 0x041C #define SSB_CHIPCO_UART1_SCRATCH 0x041C
/* PMU registers (rev >= 20) */
#define SSB_CHIPCO_PMU_CTL 0x0600 /* PMU control */
#define SSB_CHIPCO_PMU_CTL_ILP_DIV 0xFFFF0000 /* ILP div mask */
#define SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT 16
#define SSB_CHIPCO_PMU_CTL_NOILPONW 0x00000200 /* No ILP on wait */
#define SSB_CHIPCO_PMU_CTL_HTREQEN 0x00000100 /* HT req enable */
#define SSB_CHIPCO_PMU_CTL_ALPREQEN 0x00000080 /* ALP req enable */
#define SSB_CHIPCO_PMU_CTL_XTALFREQ 0x0000007C /* Crystal freq */
#define SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT 2
#define SSB_CHIPCO_PMU_CTL_ILPDIVEN 0x00000002 /* ILP div enable */
#define SSB_CHIPCO_PMU_CTL_LPOSEL 0x00000001 /* LPO sel */
#define SSB_CHIPCO_PMU_CAP 0x0604 /* PMU capabilities */
#define SSB_CHIPCO_PMU_CAP_REVISION 0x000000FF /* Revision mask */
#define SSB_CHIPCO_PMU_STAT 0x0608 /* PMU status */
#define SSB_CHIPCO_PMU_STAT_INTPEND 0x00000040 /* Interrupt pending */
#define SSB_CHIPCO_PMU_STAT_SBCLKST 0x00000030 /* Backplane clock status? */
#define SSB_CHIPCO_PMU_STAT_HAVEALP 0x00000008 /* ALP available */
#define SSB_CHIPCO_PMU_STAT_HAVEHT 0x00000004 /* HT available */
#define SSB_CHIPCO_PMU_STAT_RESINIT 0x00000003 /* Res init */
#define SSB_CHIPCO_PMU_RES_STAT 0x060C /* PMU res status */
#define SSB_CHIPCO_PMU_RES_PEND 0x0610 /* PMU res pending */
#define SSB_CHIPCO_PMU_TIMER 0x0614 /* PMU timer */
#define SSB_CHIPCO_PMU_MINRES_MSK 0x0618 /* PMU min res mask */
#define SSB_CHIPCO_PMU_MAXRES_MSK 0x061C /* PMU max res mask */
#define SSB_CHIPCO_PMU_RES_TABSEL 0x0620 /* PMU res table sel */
#define SSB_CHIPCO_PMU_RES_DEPMSK 0x0624 /* PMU res dep mask */
#define SSB_CHIPCO_PMU_RES_UPDNTM 0x0628 /* PMU res updown timer */
#define SSB_CHIPCO_PMU_RES_TIMER 0x062C /* PMU res timer */
#define SSB_CHIPCO_PMU_CLKSTRETCH 0x0630 /* PMU clockstretch */
#define SSB_CHIPCO_PMU_WATCHDOG 0x0634 /* PMU watchdog */
#define SSB_CHIPCO_PMU_RES_REQTS 0x0640 /* PMU res req timer sel */
#define SSB_CHIPCO_PMU_RES_REQT 0x0644 /* PMU res req timer */
#define SSB_CHIPCO_PMU_RES_REQM 0x0648 /* PMU res req mask */
#define SSB_CHIPCO_CHIPCTL_ADDR 0x0650
#define SSB_CHIPCO_CHIPCTL_DATA 0x0654
#define SSB_CHIPCO_REGCTL_ADDR 0x0658
#define SSB_CHIPCO_REGCTL_DATA 0x065C
#define SSB_CHIPCO_PLLCTL_ADDR 0x0660
#define SSB_CHIPCO_PLLCTL_DATA 0x0664
/** PMU PLL registers */
/* PMU rev 0 PLL registers */
#define SSB_PMU0_PLLCTL0 0
#define SSB_PMU0_PLLCTL0_PDIV_MSK 0x00000001
#define SSB_PMU0_PLLCTL0_PDIV_FREQ 25000 /* kHz */
#define SSB_PMU0_PLLCTL1 1
#define SSB_PMU0_PLLCTL1_WILD_IMSK 0xF0000000 /* Wild int mask (low nibble) */
#define SSB_PMU0_PLLCTL1_WILD_IMSK_SHIFT 28
#define SSB_PMU0_PLLCTL1_WILD_FMSK 0x0FFFFF00 /* Wild frac mask */
#define SSB_PMU0_PLLCTL1_WILD_FMSK_SHIFT 8
#define SSB_PMU0_PLLCTL1_STOPMOD 0x00000040 /* Stop mod */
#define SSB_PMU0_PLLCTL2 2
#define SSB_PMU0_PLLCTL2_WILD_IMSKHI 0x0000000F /* Wild int mask (high nibble) */
#define SSB_PMU0_PLLCTL2_WILD_IMSKHI_SHIFT 0
/* PMU rev 1 PLL registers */
#define SSB_PMU1_PLLCTL0 0
#define SSB_PMU1_PLLCTL0_P1DIV 0x00F00000 /* P1 div */
#define SSB_PMU1_PLLCTL0_P1DIV_SHIFT 20
#define SSB_PMU1_PLLCTL0_P2DIV 0x0F000000 /* P2 div */
#define SSB_PMU1_PLLCTL0_P2DIV_SHIFT 24
#define SSB_PMU1_PLLCTL1 1
#define SSB_PMU1_PLLCTL1_M1DIV 0x000000FF /* M1 div */
#define SSB_PMU1_PLLCTL1_M1DIV_SHIFT 0
#define SSB_PMU1_PLLCTL1_M2DIV 0x0000FF00 /* M2 div */
#define SSB_PMU1_PLLCTL1_M2DIV_SHIFT 8
#define SSB_PMU1_PLLCTL1_M3DIV 0x00FF0000 /* M3 div */
#define SSB_PMU1_PLLCTL1_M3DIV_SHIFT 16
#define SSB_PMU1_PLLCTL1_M4DIV 0xFF000000 /* M4 div */
#define SSB_PMU1_PLLCTL1_M4DIV_SHIFT 24
#define SSB_PMU1_PLLCTL2 2
#define SSB_PMU1_PLLCTL2_M5DIV 0x000000FF /* M5 div */
#define SSB_PMU1_PLLCTL2_M5DIV_SHIFT 0
#define SSB_PMU1_PLLCTL2_M6DIV 0x0000FF00 /* M6 div */
#define SSB_PMU1_PLLCTL2_M6DIV_SHIFT 8
#define SSB_PMU1_PLLCTL2_NDIVMODE 0x000E0000 /* NDIV mode */
#define SSB_PMU1_PLLCTL2_NDIVMODE_SHIFT 17
#define SSB_PMU1_PLLCTL2_NDIVINT 0x1FF00000 /* NDIV int */
#define SSB_PMU1_PLLCTL2_NDIVINT_SHIFT 20
#define SSB_PMU1_PLLCTL3 3
#define SSB_PMU1_PLLCTL3_NDIVFRAC 0x00FFFFFF /* NDIV frac */
#define SSB_PMU1_PLLCTL3_NDIVFRAC_SHIFT 0
#define SSB_PMU1_PLLCTL4 4
#define SSB_PMU1_PLLCTL5 5
#define SSB_PMU1_PLLCTL5_CLKDRV 0xFFFFFF00 /* clk drv */
#define SSB_PMU1_PLLCTL5_CLKDRV_SHIFT 8
/* BCM4312 PLL resource numbers. */
#define SSB_PMURES_4312_SWITCHER_BURST 0
#define SSB_PMURES_4312_SWITCHER_PWM 1
#define SSB_PMURES_4312_PA_REF_LDO 2
#define SSB_PMURES_4312_CORE_LDO_BURST 3
#define SSB_PMURES_4312_CORE_LDO_PWM 4
#define SSB_PMURES_4312_RADIO_LDO 5
#define SSB_PMURES_4312_ILP_REQUEST 6
#define SSB_PMURES_4312_BG_FILTBYP 7
#define SSB_PMURES_4312_TX_FILTBYP 8
#define SSB_PMURES_4312_RX_FILTBYP 9
#define SSB_PMURES_4312_XTAL_PU 10
#define SSB_PMURES_4312_ALP_AVAIL 11
#define SSB_PMURES_4312_BB_PLL_FILTBYP 12
#define SSB_PMURES_4312_RF_PLL_FILTBYP 13
#define SSB_PMURES_4312_HT_AVAIL 14
/* BCM4325 PLL resource numbers. */
#define SSB_PMURES_4325_BUCK_BOOST_BURST 0
#define SSB_PMURES_4325_CBUCK_BURST 1
#define SSB_PMURES_4325_CBUCK_PWM 2
#define SSB_PMURES_4325_CLDO_CBUCK_BURST 3
#define SSB_PMURES_4325_CLDO_CBUCK_PWM 4
#define SSB_PMURES_4325_BUCK_BOOST_PWM 5
#define SSB_PMURES_4325_ILP_REQUEST 6
#define SSB_PMURES_4325_ABUCK_BURST 7
#define SSB_PMURES_4325_ABUCK_PWM 8
#define SSB_PMURES_4325_LNLDO1_PU 9
#define SSB_PMURES_4325_LNLDO2_PU 10
#define SSB_PMURES_4325_LNLDO3_PU 11
#define SSB_PMURES_4325_LNLDO4_PU 12
#define SSB_PMURES_4325_XTAL_PU 13
#define SSB_PMURES_4325_ALP_AVAIL 14
#define SSB_PMURES_4325_RX_PWRSW_PU 15
#define SSB_PMURES_4325_TX_PWRSW_PU 16
#define SSB_PMURES_4325_RFPLL_PWRSW_PU 17
#define SSB_PMURES_4325_LOGEN_PWRSW_PU 18
#define SSB_PMURES_4325_AFE_PWRSW_PU 19
#define SSB_PMURES_4325_BBPLL_PWRSW_PU 20
#define SSB_PMURES_4325_HT_AVAIL 21
/* BCM4328 PLL resource numbers. */
#define SSB_PMURES_4328_EXT_SWITCHER_PWM 0
#define SSB_PMURES_4328_BB_SWITCHER_PWM 1
#define SSB_PMURES_4328_BB_SWITCHER_BURST 2
#define SSB_PMURES_4328_BB_EXT_SWITCHER_BURST 3
#define SSB_PMURES_4328_ILP_REQUEST 4
#define SSB_PMURES_4328_RADIO_SWITCHER_PWM 5
#define SSB_PMURES_4328_RADIO_SWITCHER_BURST 6
#define SSB_PMURES_4328_ROM_SWITCH 7
#define SSB_PMURES_4328_PA_REF_LDO 8
#define SSB_PMURES_4328_RADIO_LDO 9
#define SSB_PMURES_4328_AFE_LDO 10
#define SSB_PMURES_4328_PLL_LDO 11
#define SSB_PMURES_4328_BG_FILTBYP 12
#define SSB_PMURES_4328_TX_FILTBYP 13
#define SSB_PMURES_4328_RX_FILTBYP 14
#define SSB_PMURES_4328_XTAL_PU 15
#define SSB_PMURES_4328_XTAL_EN 16
#define SSB_PMURES_4328_BB_PLL_FILTBYP 17
#define SSB_PMURES_4328_RF_PLL_FILTBYP 18
#define SSB_PMURES_4328_BB_PLL_PU 19
/* BCM5354 PLL resource numbers. */
#define SSB_PMURES_5354_EXT_SWITCHER_PWM 0
#define SSB_PMURES_5354_BB_SWITCHER_PWM 1
#define SSB_PMURES_5354_BB_SWITCHER_BURST 2
#define SSB_PMURES_5354_BB_EXT_SWITCHER_BURST 3
#define SSB_PMURES_5354_ILP_REQUEST 4
#define SSB_PMURES_5354_RADIO_SWITCHER_PWM 5
#define SSB_PMURES_5354_RADIO_SWITCHER_BURST 6
#define SSB_PMURES_5354_ROM_SWITCH 7
#define SSB_PMURES_5354_PA_REF_LDO 8
#define SSB_PMURES_5354_RADIO_LDO 9
#define SSB_PMURES_5354_AFE_LDO 10
#define SSB_PMURES_5354_PLL_LDO 11
#define SSB_PMURES_5354_BG_FILTBYP 12
#define SSB_PMURES_5354_TX_FILTBYP 13
#define SSB_PMURES_5354_RX_FILTBYP 14
#define SSB_PMURES_5354_XTAL_PU 15
#define SSB_PMURES_5354_XTAL_EN 16
#define SSB_PMURES_5354_BB_PLL_FILTBYP 17
#define SSB_PMURES_5354_RF_PLL_FILTBYP 18
#define SSB_PMURES_5354_BB_PLL_PU 19
/** Chip specific Chip-Status register contents. */
#define SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL 0x00000003
#define SSB_CHIPCO_CHST_4325_DEFCIS_SEL 0 /* OTP is powered up, use def. CIS, no SPROM */
#define SSB_CHIPCO_CHST_4325_SPROM_SEL 1 /* OTP is powered up, SPROM is present */
#define SSB_CHIPCO_CHST_4325_OTP_SEL 2 /* OTP is powered up, no SPROM */
#define SSB_CHIPCO_CHST_4325_OTP_PWRDN 3 /* OTP is powered down, SPROM is present */
#define SSB_CHIPCO_CHST_4325_SDIO_USB_MODE 0x00000004
#define SSB_CHIPCO_CHST_4325_SDIO_USB_MODE_SHIFT 2
#define SSB_CHIPCO_CHST_4325_RCAL_VALID 0x00000008
#define SSB_CHIPCO_CHST_4325_RCAL_VALID_SHIFT 3
#define SSB_CHIPCO_CHST_4325_RCAL_VALUE 0x000001F0
#define SSB_CHIPCO_CHST_4325_RCAL_VALUE_SHIFT 4
#define SSB_CHIPCO_CHST_4325_PMUTOP_2B 0x00000200 /* 1 for 2b, 0 for to 2a */
@ -353,11 +553,20 @@
struct ssb_device; struct ssb_device;
struct ssb_serial_port; struct ssb_serial_port;
/* Data for the PMU, if available.
* Check availability with ((struct ssb_chipcommon)->capabilities & SSB_CHIPCO_CAP_PMU)
*/
struct ssb_chipcommon_pmu {
u8 rev; /* PMU revision */
u32 crystalfreq; /* The active crystal frequency (in kHz) */
};
struct ssb_chipcommon { struct ssb_chipcommon {
struct ssb_device *dev; struct ssb_device *dev;
u32 capabilities; u32 capabilities;
/* Fast Powerup Delay constant */ /* Fast Powerup Delay constant */
u16 fast_pwrup_delay; u16 fast_pwrup_delay;
struct ssb_chipcommon_pmu pmu;
}; };
static inline bool ssb_chipco_available(struct ssb_chipcommon *cc) static inline bool ssb_chipco_available(struct ssb_chipcommon *cc)
@ -365,6 +574,17 @@ static inline bool ssb_chipco_available(struct ssb_chipcommon *cc)
return (cc->dev != NULL); return (cc->dev != NULL);
} }
/* Register access */
#define chipco_read32(cc, offset) ssb_read32((cc)->dev, offset)
#define chipco_write32(cc, offset, val) ssb_write32((cc)->dev, offset, val)
#define chipco_mask32(cc, offset, mask) \
chipco_write32(cc, offset, chipco_read32(cc, offset) & (mask))
#define chipco_set32(cc, offset, set) \
chipco_write32(cc, offset, chipco_read32(cc, offset) | (set))
#define chipco_maskset32(cc, offset, mask, set) \
chipco_write32(cc, offset, (chipco_read32(cc, offset) & (mask)) | (set))
extern void ssb_chipcommon_init(struct ssb_chipcommon *cc); extern void ssb_chipcommon_init(struct ssb_chipcommon *cc);
extern void ssb_chipco_suspend(struct ssb_chipcommon *cc); extern void ssb_chipco_suspend(struct ssb_chipcommon *cc);
@ -406,4 +626,8 @@ extern int ssb_chipco_serial_init(struct ssb_chipcommon *cc,
struct ssb_serial_port *ports); struct ssb_serial_port *ports);
#endif /* CONFIG_SSB_SERIAL */ #endif /* CONFIG_SSB_SERIAL */
/* PMU support */
extern void ssb_pmu_init(struct ssb_chipcommon *cc);
#endif /* LINUX_SSB_CHIPCO_H_ */ #endif /* LINUX_SSB_CHIPCO_H_ */

22
include/net/mac80211.h
View File

@ -860,11 +860,6 @@ enum ieee80211_tkip_key_type {
* expect values between 0 and @max_signal. * expect values between 0 and @max_signal.
* If possible please provide dB or dBm instead. * If possible please provide dB or dBm instead.
* *
* @IEEE80211_HW_SIGNAL_DB:
* Hardware gives signal values in dB, decibel difference from an
* arbitrary, fixed reference. We expect values between 0 and @max_signal.
* If possible please provide dBm instead.
*
* @IEEE80211_HW_SIGNAL_DBM: * @IEEE80211_HW_SIGNAL_DBM:
* Hardware gives signal values in dBm, decibel difference from * Hardware gives signal values in dBm, decibel difference from
* one milliwatt. This is the preferred method since it is standardized * one milliwatt. This is the preferred method since it is standardized
@ -900,15 +895,14 @@ enum ieee80211_hw_flags {
IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE = 1<<3, IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE = 1<<3,
IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE = 1<<4, IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE = 1<<4,
IEEE80211_HW_SIGNAL_UNSPEC = 1<<5, IEEE80211_HW_SIGNAL_UNSPEC = 1<<5,
IEEE80211_HW_SIGNAL_DB = 1<<6, IEEE80211_HW_SIGNAL_DBM = 1<<6,
IEEE80211_HW_SIGNAL_DBM = 1<<7, IEEE80211_HW_NOISE_DBM = 1<<7,
IEEE80211_HW_NOISE_DBM = 1<<8, IEEE80211_HW_SPECTRUM_MGMT = 1<<8,
IEEE80211_HW_SPECTRUM_MGMT = 1<<9, IEEE80211_HW_AMPDU_AGGREGATION = 1<<9,
IEEE80211_HW_AMPDU_AGGREGATION = 1<<10, IEEE80211_HW_SUPPORTS_PS = 1<<10,
IEEE80211_HW_SUPPORTS_PS = 1<<11, IEEE80211_HW_PS_NULLFUNC_STACK = 1<<11,
IEEE80211_HW_PS_NULLFUNC_STACK = 1<<12, IEEE80211_HW_SUPPORTS_DYNAMIC_PS = 1<<12,
IEEE80211_HW_SUPPORTS_DYNAMIC_PS = 1<<13, IEEE80211_HW_MFP_CAPABLE = 1<<13,
IEEE80211_HW_MFP_CAPABLE = 1<<14,
}; };
/** /**

47
net/mac80211/iface.c
View File

@ -591,19 +591,6 @@ static void ieee80211_set_multicast_list(struct net_device *dev)
dev_mc_sync(local->mdev, dev); dev_mc_sync(local->mdev, dev);
} }
static void ieee80211_if_setup(struct net_device *dev)
{
ether_setup(dev);
dev->hard_start_xmit = ieee80211_subif_start_xmit;
dev->wireless_handlers = &ieee80211_iw_handler_def;
dev->set_multicast_list = ieee80211_set_multicast_list;
dev->change_mtu = ieee80211_change_mtu;
dev->open = ieee80211_open;
dev->stop = ieee80211_stop;
dev->destructor = free_netdev;
/* we will validate the address ourselves in ->open */
dev->validate_addr = NULL;
}
/* /*
* Called when the netdev is removed or, by the code below, before * Called when the netdev is removed or, by the code below, before
* the interface type changes. * the interface type changes.
@ -671,6 +658,34 @@ static void ieee80211_teardown_sdata(struct net_device *dev)
WARN_ON(flushed); WARN_ON(flushed);
} }
static const struct net_device_ops ieee80211_dataif_ops = {
.ndo_open = ieee80211_open,
.ndo_stop = ieee80211_stop,
.ndo_uninit = ieee80211_teardown_sdata,
.ndo_start_xmit = ieee80211_subif_start_xmit,
.ndo_set_multicast_list = ieee80211_set_multicast_list,
.ndo_change_mtu = ieee80211_change_mtu,
.ndo_set_mac_address = eth_mac_addr,
};
static const struct net_device_ops ieee80211_monitorif_ops = {
.ndo_open = ieee80211_open,
.ndo_stop = ieee80211_stop,
.ndo_uninit = ieee80211_teardown_sdata,
.ndo_start_xmit = ieee80211_monitor_start_xmit,
.ndo_set_multicast_list = ieee80211_set_multicast_list,
.ndo_change_mtu = ieee80211_change_mtu,
.ndo_set_mac_address = eth_mac_addr,
};
static void ieee80211_if_setup(struct net_device *dev)
{
ether_setup(dev);
dev->netdev_ops = &ieee80211_dataif_ops;
dev->wireless_handlers = &ieee80211_iw_handler_def;
dev->destructor = free_netdev;
}
/* /*
* Helper function to initialise an interface to a specific type. * Helper function to initialise an interface to a specific type.
*/ */
@ -682,7 +697,7 @@ static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
/* and set some type-dependent values */ /* and set some type-dependent values */
sdata->vif.type = type; sdata->vif.type = type;
sdata->dev->hard_start_xmit = ieee80211_subif_start_xmit; sdata->dev->netdev_ops = &ieee80211_dataif_ops;
sdata->wdev.iftype = type; sdata->wdev.iftype = type;
/* only monitor differs */ /* only monitor differs */
@ -703,7 +718,7 @@ static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
break; break;
case NL80211_IFTYPE_MONITOR: case NL80211_IFTYPE_MONITOR:
sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP; sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
sdata->dev->hard_start_xmit = ieee80211_monitor_start_xmit; sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
sdata->u.mntr_flags = MONITOR_FLAG_CONTROL | sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
MONITOR_FLAG_OTHER_BSS; MONITOR_FLAG_OTHER_BSS;
break; break;
@ -809,8 +824,6 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
if (ret) if (ret)
goto fail; goto fail;
ndev->uninit = ieee80211_teardown_sdata;
if (ieee80211_vif_is_mesh(&sdata->vif) && if (ieee80211_vif_is_mesh(&sdata->vif) &&
params && params->mesh_id_len) params && params->mesh_id_len)
ieee80211_sdata_set_mesh_id(sdata, ieee80211_sdata_set_mesh_id(sdata,

29
net/mac80211/main.c
View File

@ -791,6 +791,23 @@ struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
} }
EXPORT_SYMBOL(ieee80211_alloc_hw); EXPORT_SYMBOL(ieee80211_alloc_hw);
static const struct net_device_ops ieee80211_master_ops = {
.ndo_start_xmit = ieee80211_master_start_xmit,
.ndo_open = ieee80211_master_open,
.ndo_stop = ieee80211_master_stop,
.ndo_set_multicast_list = ieee80211_master_set_multicast_list,
.ndo_select_queue = ieee80211_select_queue,
};
static void ieee80211_master_setup(struct net_device *mdev)
{
mdev->type = ARPHRD_IEEE80211;
mdev->netdev_ops = &ieee80211_master_ops;
mdev->header_ops = &ieee80211_header_ops;
mdev->tx_queue_len = 1000;
mdev->addr_len = ETH_ALEN;
}
int ieee80211_register_hw(struct ieee80211_hw *hw) int ieee80211_register_hw(struct ieee80211_hw *hw)
{ {
struct ieee80211_local *local = hw_to_local(hw); struct ieee80211_local *local = hw_to_local(hw);
@ -840,7 +857,7 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
hw->ampdu_queues = 0; hw->ampdu_queues = 0;
mdev = alloc_netdev_mq(sizeof(struct ieee80211_master_priv), mdev = alloc_netdev_mq(sizeof(struct ieee80211_master_priv),
"wmaster%d", ether_setup, "wmaster%d", ieee80211_master_setup,
ieee80211_num_queues(hw)); ieee80211_num_queues(hw));
if (!mdev) if (!mdev)
goto fail_mdev_alloc; goto fail_mdev_alloc;
@ -851,13 +868,6 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
ieee80211_rx_bss_list_init(local); ieee80211_rx_bss_list_init(local);
mdev->hard_start_xmit = ieee80211_master_start_xmit;
mdev->open = ieee80211_master_open;
mdev->stop = ieee80211_master_stop;
mdev->type = ARPHRD_IEEE80211;
mdev->header_ops = &ieee80211_header_ops;
mdev->set_multicast_list = ieee80211_master_set_multicast_list;
local->hw.workqueue = local->hw.workqueue =
create_singlethread_workqueue(wiphy_name(local->hw.wiphy)); create_singlethread_workqueue(wiphy_name(local->hw.wiphy));
if (!local->hw.workqueue) { if (!local->hw.workqueue) {
@ -884,7 +894,6 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
local->hw.conf.listen_interval = local->hw.max_listen_interval; local->hw.conf.listen_interval = local->hw.max_listen_interval;
local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC | local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC |
IEEE80211_HW_SIGNAL_DB |
IEEE80211_HW_SIGNAL_DBM) ? IEEE80211_HW_SIGNAL_DBM) ?
IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID; IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID;
local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ? local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ?
@ -924,8 +933,6 @@ int ieee80211_register_hw(struct ieee80211_hw *hw)
goto fail_wep; goto fail_wep;
} }
local->mdev->select_queue = ieee80211_select_queue;
/* add one default STA interface if supported */ /* add one default STA interface if supported */
if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) { if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) {
result = ieee80211_if_add(local, "wlan%d", NULL, result = ieee80211_if_add(local, "wlan%d", NULL,

48
net/mac80211/mlme.c
View File

@ -1042,6 +1042,7 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
struct ieee80211_local *local = sdata->local; struct ieee80211_local *local = sdata->local;
struct sta_info *sta; struct sta_info *sta;
int disassoc; int disassoc;
bool remove_bss = false;
/* TODO: start monitoring current AP signal quality and number of /* TODO: start monitoring current AP signal quality and number of
* missed beacons. Scan other channels every now and then and search * missed beacons. Scan other channels every now and then and search
@ -1067,6 +1068,7 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
"range\n", "range\n",
sdata->dev->name, ifsta->bssid); sdata->dev->name, ifsta->bssid);
disassoc = 1; disassoc = 1;
remove_bss = true;
} else } else
ieee80211_send_probe_req(sdata, ifsta->bssid, ieee80211_send_probe_req(sdata, ifsta->bssid,
ifsta->ssid, ifsta->ssid,
@ -1086,12 +1088,24 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
rcu_read_unlock(); rcu_read_unlock();
if (disassoc) if (disassoc) {
ieee80211_set_disassoc(sdata, ifsta, true, true, ieee80211_set_disassoc(sdata, ifsta, true, true,
WLAN_REASON_PREV_AUTH_NOT_VALID); WLAN_REASON_PREV_AUTH_NOT_VALID);
else if (remove_bss) {
struct ieee80211_bss *bss;
bss = ieee80211_rx_bss_get(local, ifsta->bssid,
local->hw.conf.channel->center_freq,
ifsta->ssid, ifsta->ssid_len);
if (bss) {
atomic_dec(&bss->users);
ieee80211_rx_bss_put(local, bss);
}
}
} else {
mod_timer(&ifsta->timer, jiffies + mod_timer(&ifsta->timer, jiffies +
IEEE80211_MONITORING_INTERVAL); IEEE80211_MONITORING_INTERVAL);
}
} }
@ -1503,13 +1517,22 @@ static int ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
struct ieee80211_bss *bss) struct ieee80211_bss *bss)
{ {
struct ieee80211_local *local = sdata->local; struct ieee80211_local *local = sdata->local;
int res, rates, i, j; int res = 0, rates, i, j;
struct sk_buff *skb; struct sk_buff *skb;
struct ieee80211_mgmt *mgmt; struct ieee80211_mgmt *mgmt;
u8 *pos; u8 *pos;
struct ieee80211_supported_band *sband; struct ieee80211_supported_band *sband;
union iwreq_data wrqu; union iwreq_data wrqu;
if (local->ops->reset_tsf) {
/* Reset own TSF to allow time synchronization work. */
local->ops->reset_tsf(local_to_hw(local));
}
if ((ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) &&
memcmp(ifsta->bssid, bss->bssid, ETH_ALEN) == 0)
return res;
skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400 + skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400 +
sdata->u.sta.ie_proberesp_len); sdata->u.sta.ie_proberesp_len);
if (!skb) { if (!skb) {
@ -1520,13 +1543,11 @@ static int ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
/* Remove possible STA entries from other IBSS networks. */ if (!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET)) {
sta_info_flush_delayed(sdata); /* Remove possible STA entries from other IBSS networks. */
sta_info_flush_delayed(sdata);
if (local->ops->reset_tsf) {
/* Reset own TSF to allow time synchronization work. */
local->ops->reset_tsf(local_to_hw(local));
} }
memcpy(ifsta->bssid, bss->bssid, ETH_ALEN); memcpy(ifsta->bssid, bss->bssid, ETH_ALEN);
res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID); res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID);
if (res) if (res)
@ -2415,8 +2436,10 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
ifsta->ssid_len); ifsta->ssid_len);
ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE; ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE;
set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request); set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request);
} else } else {
ifsta->assoc_scan_tries = 0;
ifsta->state = IEEE80211_STA_MLME_DISABLED; ifsta->state = IEEE80211_STA_MLME_DISABLED;
}
} }
return -1; return -1;
} }
@ -2720,9 +2743,8 @@ void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
if (sdata && sdata->vif.type == NL80211_IFTYPE_ADHOC) { if (sdata && sdata->vif.type == NL80211_IFTYPE_ADHOC) {
ifsta = &sdata->u.sta; ifsta = &sdata->u.sta;
if (!(ifsta->flags & IEEE80211_STA_BSSID_SET) || if ((!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET)) ||
(!(ifsta->state == IEEE80211_STA_MLME_IBSS_JOINED) && !ieee80211_sta_active_ibss(sdata))
!ieee80211_sta_active_ibss(sdata)))
ieee80211_sta_find_ibss(sdata, ifsta); ieee80211_sta_find_ibss(sdata, ifsta);
} }

19
net/mac80211/rx.c
View File

@ -86,8 +86,7 @@ ieee80211_rx_radiotap_len(struct ieee80211_local *local,
if (status->flag & RX_FLAG_TSFT) if (status->flag & RX_FLAG_TSFT)
len += 8; len += 8;
if (local->hw.flags & IEEE80211_HW_SIGNAL_DB || if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
len += 1; len += 1;
if (local->hw.flags & IEEE80211_HW_NOISE_DBM) if (local->hw.flags & IEEE80211_HW_NOISE_DBM)
len += 1; len += 1;
@ -199,14 +198,6 @@ ieee80211_add_rx_radiotap_header(struct ieee80211_local *local,
*pos = status->antenna; *pos = status->antenna;
pos++; pos++;
/* IEEE80211_RADIOTAP_DB_ANTSIGNAL */
if (local->hw.flags & IEEE80211_HW_SIGNAL_DB) {
*pos = status->signal;
rthdr->it_present |=
cpu_to_le32(1 << IEEE80211_RADIOTAP_DB_ANTSIGNAL);
pos++;
}
/* IEEE80211_RADIOTAP_DB_ANTNOISE is not used */ /* IEEE80211_RADIOTAP_DB_ANTNOISE is not used */
/* IEEE80211_RADIOTAP_RX_FLAGS */ /* IEEE80211_RADIOTAP_RX_FLAGS */
@ -1225,12 +1216,12 @@ ieee80211_data_to_8023(struct ieee80211_rx_data *rx)
switch (hdr->frame_control & switch (hdr->frame_control &
cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) { cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) {
case __constant_cpu_to_le16(IEEE80211_FCTL_TODS): case cpu_to_le16(IEEE80211_FCTL_TODS):
if (unlikely(sdata->vif.type != NL80211_IFTYPE_AP && if (unlikely(sdata->vif.type != NL80211_IFTYPE_AP &&
sdata->vif.type != NL80211_IFTYPE_AP_VLAN)) sdata->vif.type != NL80211_IFTYPE_AP_VLAN))
return -1; return -1;
break; break;
case __constant_cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS): case cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS):
if (unlikely(sdata->vif.type != NL80211_IFTYPE_WDS && if (unlikely(sdata->vif.type != NL80211_IFTYPE_WDS &&
sdata->vif.type != NL80211_IFTYPE_MESH_POINT)) sdata->vif.type != NL80211_IFTYPE_MESH_POINT))
return -1; return -1;
@ -1244,13 +1235,13 @@ ieee80211_data_to_8023(struct ieee80211_rx_data *rx)
} }
} }
break; break;
case __constant_cpu_to_le16(IEEE80211_FCTL_FROMDS): case cpu_to_le16(IEEE80211_FCTL_FROMDS):
if (sdata->vif.type != NL80211_IFTYPE_STATION || if (sdata->vif.type != NL80211_IFTYPE_STATION ||
(is_multicast_ether_addr(dst) && (is_multicast_ether_addr(dst) &&
!compare_ether_addr(src, dev->dev_addr))) !compare_ether_addr(src, dev->dev_addr)))
return -1; return -1;
break; break;
case __constant_cpu_to_le16(0): case cpu_to_le16(0):
if (sdata->vif.type != NL80211_IFTYPE_ADHOC) if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
return -1; return -1;
break; break;

21
net/mac80211/tx.c
View File

@ -1433,10 +1433,31 @@ int ieee80211_monitor_start_xmit(struct sk_buff *skb,
struct net_device *dev) struct net_device *dev)
{ {
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_channel *chan = local->hw.conf.channel;
struct ieee80211_radiotap_header *prthdr = struct ieee80211_radiotap_header *prthdr =
(struct ieee80211_radiotap_header *)skb->data; (struct ieee80211_radiotap_header *)skb->data;
u16 len_rthdr; u16 len_rthdr;
/*
* Frame injection is not allowed if beaconing is not allowed
* or if we need radar detection. Beaconing is usually not allowed when
* the mode or operation (Adhoc, AP, Mesh) does not support DFS.
* Passive scan is also used in world regulatory domains where
* your country is not known and as such it should be treated as
* NO TX unless the channel is explicitly allowed in which case
* your current regulatory domain would not have the passive scan
* flag.
*
* Since AP mode uses monitor interfaces to inject/TX management
* frames we can make AP mode the exception to this rule once it
* supports radar detection as its implementation can deal with
* radar detection by itself. We can do that later by adding a
* monitor flag interfaces used for AP support.
*/
if ((chan->flags & (IEEE80211_CHAN_NO_IBSS | IEEE80211_CHAN_RADAR |
IEEE80211_CHAN_PASSIVE_SCAN)))
goto fail;
/* check for not even having the fixed radiotap header part */ /* check for not even having the fixed radiotap header part */
if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header))) if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
goto fail; /* too short to be possibly valid */ goto fail; /* too short to be possibly valid */

3
net/mac80211/wext.c
View File

@ -173,8 +173,7 @@ static int ieee80211_ioctl_giwrange(struct net_device *dev,
range->num_encoding_sizes = 2; range->num_encoding_sizes = 2;
range->max_encoding_tokens = NUM_DEFAULT_KEYS; range->max_encoding_tokens = NUM_DEFAULT_KEYS;
if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC || if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
local->hw.flags & IEEE80211_HW_SIGNAL_DB)
range->max_qual.level = local->hw.max_signal; range->max_qual.level = local->hw.max_signal;
else if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) else if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
range->max_qual.level = -110; range->max_qual.level = -110;

81
net/wireless/nl80211.c
View File

@ -2093,6 +2093,81 @@ static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
#undef FILL_IN_MESH_PARAM_IF_SET #undef FILL_IN_MESH_PARAM_IF_SET
static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
{
struct sk_buff *msg;
void *hdr = NULL;
struct nlattr *nl_reg_rules;
unsigned int i;
int err = -EINVAL;
mutex_lock(&cfg80211_drv_mutex);
if (!cfg80211_regdomain)
goto out;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg) {
err = -ENOBUFS;
goto out;
}
hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
NL80211_CMD_GET_REG);
if (!hdr)
goto nla_put_failure;
NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2,
cfg80211_regdomain->alpha2);
nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
if (!nl_reg_rules)
goto nla_put_failure;
for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
struct nlattr *nl_reg_rule;
const struct ieee80211_reg_rule *reg_rule;
const struct ieee80211_freq_range *freq_range;
const struct ieee80211_power_rule *power_rule;
reg_rule = &cfg80211_regdomain->reg_rules[i];
freq_range = &reg_rule->freq_range;
power_rule = &reg_rule->power_rule;
nl_reg_rule = nla_nest_start(msg, i);
if (!nl_reg_rule)
goto nla_put_failure;
NLA_PUT_U32(msg, NL80211_ATTR_REG_RULE_FLAGS,
reg_rule->flags);
NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_START,
freq_range->start_freq_khz);
NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_END,
freq_range->end_freq_khz);
NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
freq_range->max_bandwidth_khz);
NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
power_rule->max_antenna_gain);
NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
power_rule->max_eirp);
nla_nest_end(msg, nl_reg_rule);
}
nla_nest_end(msg, nl_reg_rules);
genlmsg_end(msg, hdr);
err = genlmsg_unicast(msg, info->snd_pid);
goto out;
nla_put_failure:
genlmsg_cancel(msg, hdr);
err = -EMSGSIZE;
out:
mutex_unlock(&cfg80211_drv_mutex);
return err;
}
static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info) static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
{ {
struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1]; struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
@ -2332,6 +2407,12 @@ static struct genl_ops nl80211_ops[] = {
.policy = nl80211_policy, .policy = nl80211_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{
.cmd = NL80211_CMD_GET_REG,
.doit = nl80211_get_reg,
.policy = nl80211_policy,
/* can be retrieved by unprivileged users */
},
{ {
.cmd = NL80211_CMD_SET_REG, .cmd = NL80211_CMD_SET_REG,
.doit = nl80211_set_reg, .doit = nl80211_set_reg,

2
net/wireless/reg.c
View File

@ -57,7 +57,7 @@ static u32 supported_bandwidths[] = {
/* Central wireless core regulatory domains, we only need two, /* Central wireless core regulatory domains, we only need two,
* the current one and a world regulatory domain in case we have no * the current one and a world regulatory domain in case we have no
* information to give us an alpha2 */ * information to give us an alpha2 */
static const struct ieee80211_regdomain *cfg80211_regdomain; const struct ieee80211_regdomain *cfg80211_regdomain;
/* We use this as a place for the rd structure built from the /* We use this as a place for the rd structure built from the
* last parsed country IE to rest until CRDA gets back to us with * last parsed country IE to rest until CRDA gets back to us with

Some files were not shown because too many files have changed in this diff Show More