2 * Copyright (c) 2008, Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 /* Implementation of the main "ATH" layer. */
22 static int ath_outdoor
; /* enable outdoor use */
24 static const u8 ath_bcast_mac
[ETH_ALEN
] =
25 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
27 static u32 ath_chainmask_sel_up_rssi_thres
=
28 ATH_CHAINMASK_SEL_UP_RSSI_THRES
;
29 static u32 ath_chainmask_sel_down_rssi_thres
=
30 ATH_CHAINMASK_SEL_DOWN_RSSI_THRES
;
31 static u32 ath_chainmask_sel_period
=
32 ATH_CHAINMASK_SEL_TIMEOUT
;
34 /* return bus cachesize in 4B word units */
36 static void bus_read_cachesize(struct ath_softc
*sc
, int *csz
)
40 pci_read_config_byte(sc
->pdev
, PCI_CACHE_LINE_SIZE
, (u8
*)&u8tmp
);
44 * This check was put in to avoid "unplesant" consequences if
45 * the bootrom has not fully initialized all PCI devices.
46 * Sometimes the cache line size register is not set
50 *csz
= DEFAULT_CACHELINE
>> 2; /* Use the default size */
54 * Set current operating mode
56 * This function initializes and fills the rate table in the ATH object based
57 * on the operating mode. The blink rates are also set up here, although
58 * they have been superceeded by the ath_led module.
61 static void ath_setcurmode(struct ath_softc
*sc
, enum wireless_mode mode
)
63 const struct ath9k_rate_table
*rt
;
66 memset(sc
->sc_rixmap
, 0xff, sizeof(sc
->sc_rixmap
));
67 rt
= sc
->sc_rates
[mode
];
70 for (i
= 0; i
< rt
->rateCount
; i
++)
71 sc
->sc_rixmap
[rt
->info
[i
].rateCode
] = (u8
) i
;
73 memzero(sc
->sc_hwmap
, sizeof(sc
->sc_hwmap
));
74 for (i
= 0; i
< 256; i
++) {
75 u8 ix
= rt
->rateCodeToIndex
[i
];
80 sc
->sc_hwmap
[i
].ieeerate
=
81 rt
->info
[ix
].dot11Rate
& IEEE80211_RATE_VAL
;
82 sc
->sc_hwmap
[i
].rateKbps
= rt
->info
[ix
].rateKbps
;
84 if (rt
->info
[ix
].shortPreamble
||
85 rt
->info
[ix
].phy
== PHY_OFDM
) {
86 /* XXX: Handle this */
89 /* NB: this uses the last entry if the rate isn't found */
90 /* XXX beware of overlow */
93 sc
->sc_curmode
= mode
;
95 * All protection frames are transmited at 2Mb/s for
96 * 11g, otherwise at 1Mb/s.
97 * XXX select protection rate index from rate table.
99 sc
->sc_protrix
= (mode
== WIRELESS_MODE_11g
? 1 : 0);
100 /* rate index used to send mgt frames */
101 sc
->sc_minrateix
= 0;
107 * Based on the wireless mode passed in, the rate table in the ATH object
108 * is set to the mode specific rate table. This also calls the callback
109 * function to set the rate in the protocol layer object.
112 static int ath_rate_setup(struct ath_softc
*sc
, enum wireless_mode mode
)
114 struct ath_hal
*ah
= sc
->sc_ah
;
115 const struct ath9k_rate_table
*rt
;
118 case WIRELESS_MODE_11a
:
120 ath9k_hw_getratetable(ah
, ATH9K_MODE_SEL_11A
);
122 case WIRELESS_MODE_11b
:
124 ath9k_hw_getratetable(ah
, ATH9K_MODE_SEL_11B
);
126 case WIRELESS_MODE_11g
:
128 ath9k_hw_getratetable(ah
, ATH9K_MODE_SEL_11G
);
130 case WIRELESS_MODE_11NA_HT20
:
132 ath9k_hw_getratetable(ah
, ATH9K_MODE_SEL_11NA_HT20
);
134 case WIRELESS_MODE_11NG_HT20
:
136 ath9k_hw_getratetable(ah
, ATH9K_MODE_SEL_11NG_HT20
);
138 case WIRELESS_MODE_11NA_HT40PLUS
:
140 ath9k_hw_getratetable(ah
, ATH9K_MODE_SEL_11NA_HT40PLUS
);
142 case WIRELESS_MODE_11NA_HT40MINUS
:
144 ath9k_hw_getratetable(ah
,
145 ATH9K_MODE_SEL_11NA_HT40MINUS
);
147 case WIRELESS_MODE_11NG_HT40PLUS
:
149 ath9k_hw_getratetable(ah
, ATH9K_MODE_SEL_11NG_HT40PLUS
);
151 case WIRELESS_MODE_11NG_HT40MINUS
:
153 ath9k_hw_getratetable(ah
,
154 ATH9K_MODE_SEL_11NG_HT40MINUS
);
157 DPRINTF(sc
, ATH_DBG_FATAL
, "%s: invalid mode %u\n",
161 rt
= sc
->sc_rates
[mode
];
165 /* setup rate set in 802.11 protocol layer */
166 ath_setup_rate(sc
, mode
, NORMAL_RATE
, rt
);
172 * Set up channel list
174 static int ath_setup_channels(struct ath_softc
*sc
)
176 struct ath_hal
*ah
= sc
->sc_ah
;
177 int nchan
, i
, a
= 0, b
= 0;
178 u8 regclassids
[ATH_REGCLASSIDS_MAX
];
180 struct ieee80211_supported_band
*band_2ghz
;
181 struct ieee80211_supported_band
*band_5ghz
;
182 struct ieee80211_channel
*chan_2ghz
;
183 struct ieee80211_channel
*chan_5ghz
;
184 struct ath9k_channel
*c
;
186 /* Fill in ah->ah_channels */
187 if (!ath9k_regd_init_channels(ah
,
197 u32 rd
= ah
->ah_currentRD
;
199 DPRINTF(sc
, ATH_DBG_FATAL
,
200 "%s: unable to collect channel list; "
201 "regdomain likely %u country code %u\n",
202 __func__
, rd
, CTRY_DEFAULT
);
206 band_2ghz
= &sc
->sbands
[IEEE80211_BAND_2GHZ
];
207 band_5ghz
= &sc
->sbands
[IEEE80211_BAND_5GHZ
];
208 chan_2ghz
= sc
->channels
[IEEE80211_BAND_2GHZ
];
209 chan_5ghz
= sc
->channels
[IEEE80211_BAND_5GHZ
];
211 for (i
= 0; i
< nchan
; i
++) {
212 c
= &ah
->ah_channels
[i
];
213 if (IS_CHAN_2GHZ(c
)) {
214 chan_2ghz
[a
].band
= IEEE80211_BAND_2GHZ
;
215 chan_2ghz
[a
].center_freq
= c
->channel
;
216 chan_2ghz
[a
].max_power
= c
->maxTxPower
;
218 if (c
->privFlags
& CHANNEL_DISALLOW_ADHOC
)
219 chan_2ghz
[a
].flags
|=
220 IEEE80211_CHAN_NO_IBSS
;
221 if (c
->channelFlags
& CHANNEL_PASSIVE
)
222 chan_2ghz
[a
].flags
|=
223 IEEE80211_CHAN_PASSIVE_SCAN
;
225 band_2ghz
->n_channels
= ++a
;
227 DPRINTF(sc
, ATH_DBG_CONFIG
,
228 "%s: 2MHz channel: %d, "
229 "channelFlags: 0x%x\n",
233 } else if (IS_CHAN_5GHZ(c
)) {
234 chan_5ghz
[b
].band
= IEEE80211_BAND_5GHZ
;
235 chan_5ghz
[b
].center_freq
= c
->channel
;
236 chan_5ghz
[b
].max_power
= c
->maxTxPower
;
238 if (c
->privFlags
& CHANNEL_DISALLOW_ADHOC
)
239 chan_5ghz
[b
].flags
|=
240 IEEE80211_CHAN_NO_IBSS
;
241 if (c
->channelFlags
& CHANNEL_PASSIVE
)
242 chan_5ghz
[b
].flags
|=
243 IEEE80211_CHAN_PASSIVE_SCAN
;
245 band_5ghz
->n_channels
= ++b
;
247 DPRINTF(sc
, ATH_DBG_CONFIG
,
248 "%s: 5MHz channel: %d, "
249 "channelFlags: 0x%x\n",
260 * Determine mode from channel flags
262 * This routine will provide the enumerated WIRELESSS_MODE value based
263 * on the settings of the channel flags. If ho valid set of flags
264 * exist, the lowest mode (11b) is selected.
267 static enum wireless_mode
ath_chan2mode(struct ath9k_channel
*chan
)
269 if (chan
->chanmode
== CHANNEL_A
)
270 return WIRELESS_MODE_11a
;
271 else if (chan
->chanmode
== CHANNEL_G
)
272 return WIRELESS_MODE_11g
;
273 else if (chan
->chanmode
== CHANNEL_B
)
274 return WIRELESS_MODE_11b
;
275 else if (chan
->chanmode
== CHANNEL_A_HT20
)
276 return WIRELESS_MODE_11NA_HT20
;
277 else if (chan
->chanmode
== CHANNEL_G_HT20
)
278 return WIRELESS_MODE_11NG_HT20
;
279 else if (chan
->chanmode
== CHANNEL_A_HT40PLUS
)
280 return WIRELESS_MODE_11NA_HT40PLUS
;
281 else if (chan
->chanmode
== CHANNEL_A_HT40MINUS
)
282 return WIRELESS_MODE_11NA_HT40MINUS
;
283 else if (chan
->chanmode
== CHANNEL_G_HT40PLUS
)
284 return WIRELESS_MODE_11NG_HT40PLUS
;
285 else if (chan
->chanmode
== CHANNEL_G_HT40MINUS
)
286 return WIRELESS_MODE_11NG_HT40MINUS
;
288 /* NB: should not get here */
289 return WIRELESS_MODE_11b
;
295 * Performs the actions to change the channel in the hardware, and set up
296 * the current operating mode for the new channel.
299 static void ath_chan_change(struct ath_softc
*sc
, struct ath9k_channel
*chan
)
301 enum wireless_mode mode
;
303 mode
= ath_chan2mode(chan
);
305 ath_rate_setup(sc
, mode
);
306 ath_setcurmode(sc
, mode
);
310 * Stop the device, grabbing the top-level lock to protect
311 * against concurrent entry through ath_init (which can happen
312 * if another thread does a system call and the thread doing the
313 * stop is preempted).
316 static int ath_stop(struct ath_softc
*sc
)
318 struct ath_hal
*ah
= sc
->sc_ah
;
320 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: invalid %u\n",
321 __func__
, sc
->sc_invalid
);
324 * Shutdown the hardware and driver:
325 * stop output from above
326 * reset 802.11 state machine
327 * (sends station deassoc/deauth frames)
330 * clear transmit machinery
331 * clear receive machinery
333 * reclaim beacon resources
335 * Note that some of this work is not possible if the
336 * hardware is gone (invalid).
340 ath9k_hw_set_interrupts(ah
, 0);
341 ath_draintxq(sc
, false);
342 if (!sc
->sc_invalid
) {
344 ath9k_hw_phy_disable(ah
);
346 sc
->sc_rxlink
= NULL
;
354 * This function is called when starting a channel scan. It will perform
355 * power save wakeup processing, set the filter for the scan, and get the
356 * chip ready to send broadcast packets out during the scan.
359 void ath_scan_start(struct ath_softc
*sc
)
361 struct ath_hal
*ah
= sc
->sc_ah
;
363 u32 now
= (u32
) jiffies_to_msecs(get_timestamp());
366 rfilt
= ath_calcrxfilter(sc
);
367 ath9k_hw_setrxfilter(ah
, rfilt
);
368 ath9k_hw_write_associd(ah
, ath_bcast_mac
, 0);
370 /* Restore previous power management state. */
372 DPRINTF(sc
, ATH_DBG_CONFIG
, "%d.%03d | %s: RX filter 0x%x aid 0\n",
373 now
/ 1000, now
% 1000, __func__
, rfilt
);
379 * This routine is called by the upper layer when the scan is completed. This
380 * will set the filters back to normal operating mode, set the BSSID to the
381 * correct value, and restore the power save state.
384 void ath_scan_end(struct ath_softc
*sc
)
386 struct ath_hal
*ah
= sc
->sc_ah
;
388 u32 now
= (u32
) jiffies_to_msecs(get_timestamp());
391 /* Request for a full reset due to rx packet filter changes */
392 sc
->sc_full_reset
= 1;
393 rfilt
= ath_calcrxfilter(sc
);
394 ath9k_hw_setrxfilter(ah
, rfilt
);
395 ath9k_hw_write_associd(ah
, sc
->sc_curbssid
, sc
->sc_curaid
);
397 DPRINTF(sc
, ATH_DBG_CONFIG
, "%d.%03d | %s: RX filter 0x%x aid 0x%x\n",
398 now
/ 1000, now
% 1000, __func__
, rfilt
, sc
->sc_curaid
);
402 * Set the current channel
404 * Set/change channels. If the channel is really being changed, it's done
405 * by reseting the chip. To accomplish this we must first cleanup any pending
406 * DMA, then restart stuff after a la ath_init.
408 int ath_set_channel(struct ath_softc
*sc
, struct ath9k_channel
*hchan
)
410 struct ath_hal
*ah
= sc
->sc_ah
;
411 bool fastcc
= true, stopped
;
412 enum ath9k_ht_macmode ht_macmode
;
414 if (sc
->sc_invalid
) /* if the device is invalid or removed */
417 DPRINTF(sc
, ATH_DBG_CONFIG
,
418 "%s: %u (%u MHz) -> %u (%u MHz), cflags:%x\n",
420 ath9k_hw_mhz2ieee(ah
, sc
->sc_curchan
.channel
,
421 sc
->sc_curchan
.channelFlags
),
422 sc
->sc_curchan
.channel
,
423 ath9k_hw_mhz2ieee(ah
, hchan
->channel
, hchan
->channelFlags
),
424 hchan
->channel
, hchan
->channelFlags
);
426 ht_macmode
= ath_cwm_macmode(sc
);
428 if (hchan
->channel
!= sc
->sc_curchan
.channel
||
429 hchan
->channelFlags
!= sc
->sc_curchan
.channelFlags
||
430 sc
->sc_update_chainmask
|| sc
->sc_full_reset
) {
433 * This is only performed if the channel settings have
436 * To switch channels clear any pending DMA operations;
437 * wait long enough for the RX fifo to drain, reset the
438 * hardware at the new frequency, and then re-enable
439 * the relevant bits of the h/w.
441 ath9k_hw_set_interrupts(ah
, 0); /* disable interrupts */
442 ath_draintxq(sc
, false); /* clear pending tx frames */
443 stopped
= ath_stoprecv(sc
); /* turn off frame recv */
445 /* XXX: do not flush receive queue here. We don't want
446 * to flush data frames already in queue because of
447 * changing channel. */
449 if (!stopped
|| sc
->sc_full_reset
)
452 spin_lock_bh(&sc
->sc_resetlock
);
453 if (!ath9k_hw_reset(ah
, sc
->sc_opmode
, hchan
,
454 ht_macmode
, sc
->sc_tx_chainmask
,
456 sc
->sc_ht_extprotspacing
,
458 DPRINTF(sc
, ATH_DBG_FATAL
,
459 "%s: unable to reset channel %u (%uMhz) "
460 "flags 0x%x hal status %u\n", __func__
,
461 ath9k_hw_mhz2ieee(ah
, hchan
->channel
,
462 hchan
->channelFlags
),
463 hchan
->channel
, hchan
->channelFlags
, status
);
464 spin_unlock_bh(&sc
->sc_resetlock
);
467 spin_unlock_bh(&sc
->sc_resetlock
);
469 sc
->sc_curchan
= *hchan
;
470 sc
->sc_update_chainmask
= 0;
471 sc
->sc_full_reset
= 0;
473 /* Re-enable rx framework */
474 if (ath_startrecv(sc
) != 0) {
475 DPRINTF(sc
, ATH_DBG_FATAL
,
476 "%s: unable to restart recv logic\n", __func__
);
480 * Change channels and update the h/w rate map
481 * if we're switching; e.g. 11a to 11b/g.
483 ath_chan_change(sc
, hchan
);
484 ath_update_txpow(sc
); /* update tx power state */
486 * Re-enable interrupts.
488 ath9k_hw_set_interrupts(ah
, sc
->sc_imask
);
493 /**********************/
494 /* Chainmask Handling */
495 /**********************/
497 static void ath_chainmask_sel_timertimeout(unsigned long data
)
499 struct ath_chainmask_sel
*cm
= (struct ath_chainmask_sel
*)data
;
500 cm
->switch_allowed
= 1;
503 /* Start chainmask select timer */
504 static void ath_chainmask_sel_timerstart(struct ath_chainmask_sel
*cm
)
506 cm
->switch_allowed
= 0;
507 mod_timer(&cm
->timer
, ath_chainmask_sel_period
);
510 /* Stop chainmask select timer */
511 static void ath_chainmask_sel_timerstop(struct ath_chainmask_sel
*cm
)
513 cm
->switch_allowed
= 0;
514 del_timer_sync(&cm
->timer
);
517 static void ath_chainmask_sel_init(struct ath_softc
*sc
, struct ath_node
*an
)
519 struct ath_chainmask_sel
*cm
= &an
->an_chainmask_sel
;
521 memzero(cm
, sizeof(struct ath_chainmask_sel
));
523 cm
->cur_tx_mask
= sc
->sc_tx_chainmask
;
524 cm
->cur_rx_mask
= sc
->sc_rx_chainmask
;
525 cm
->tx_avgrssi
= ATH_RSSI_DUMMY_MARKER
;
526 setup_timer(&cm
->timer
,
527 ath_chainmask_sel_timertimeout
, (unsigned long) cm
);
530 int ath_chainmask_sel_logic(struct ath_softc
*sc
, struct ath_node
*an
)
532 struct ath_chainmask_sel
*cm
= &an
->an_chainmask_sel
;
535 * Disable auto-swtiching in one of the following if conditions.
536 * sc_chainmask_auto_sel is used for internal global auto-switching
537 * enabled/disabled setting
539 if (sc
->sc_ah
->ah_caps
.halTxChainMask
!= ATH_CHAINMASK_SEL_3X3
) {
540 cm
->cur_tx_mask
= sc
->sc_tx_chainmask
;
541 return cm
->cur_tx_mask
;
544 if (cm
->tx_avgrssi
== ATH_RSSI_DUMMY_MARKER
)
545 return cm
->cur_tx_mask
;
547 if (cm
->switch_allowed
) {
548 /* Switch down from tx 3 to tx 2. */
549 if (cm
->cur_tx_mask
== ATH_CHAINMASK_SEL_3X3
&&
550 ATH_RSSI_OUT(cm
->tx_avgrssi
) >=
551 ath_chainmask_sel_down_rssi_thres
) {
552 cm
->cur_tx_mask
= sc
->sc_tx_chainmask
;
554 /* Don't let another switch happen until
555 * this timer expires */
556 ath_chainmask_sel_timerstart(cm
);
558 /* Switch up from tx 2 to 3. */
559 else if (cm
->cur_tx_mask
== sc
->sc_tx_chainmask
&&
560 ATH_RSSI_OUT(cm
->tx_avgrssi
) <=
561 ath_chainmask_sel_up_rssi_thres
) {
562 cm
->cur_tx_mask
= ATH_CHAINMASK_SEL_3X3
;
564 /* Don't let another switch happen
565 * until this timer expires */
566 ath_chainmask_sel_timerstart(cm
);
570 return cm
->cur_tx_mask
;
574 * Update tx/rx chainmask. For legacy association,
575 * hard code chainmask to 1x1, for 11n association, use
576 * the chainmask configuration.
579 void ath_update_chainmask(struct ath_softc
*sc
, int is_ht
)
581 sc
->sc_update_chainmask
= 1;
583 sc
->sc_tx_chainmask
= sc
->sc_ah
->ah_caps
.halTxChainMask
;
584 sc
->sc_rx_chainmask
= sc
->sc_ah
->ah_caps
.halRxChainMask
;
586 sc
->sc_tx_chainmask
= 1;
587 sc
->sc_rx_chainmask
= 1;
590 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: tx chmask: %d, rx chmask: %d\n",
591 __func__
, sc
->sc_tx_chainmask
, sc
->sc_rx_chainmask
);
601 * This routine brings the VAP out of the down state into a "listen" state
602 * where it waits for association requests. This is used in AP and AdHoc
606 int ath_vap_listen(struct ath_softc
*sc
, int if_id
)
608 struct ath_hal
*ah
= sc
->sc_ah
;
611 DECLARE_MAC_BUF(mac
);
613 avp
= sc
->sc_vaps
[if_id
];
615 DPRINTF(sc
, ATH_DBG_FATAL
, "%s: invalid interface id %u\n",
620 #ifdef CONFIG_SLOW_ANT_DIV
621 ath_slow_ant_div_stop(&sc
->sc_antdiv
);
624 /* update ratectrl about the new state */
625 ath_rate_newstate(sc
, avp
);
627 rfilt
= ath_calcrxfilter(sc
);
628 ath9k_hw_setrxfilter(ah
, rfilt
);
630 if (sc
->sc_opmode
== ATH9K_M_STA
|| sc
->sc_opmode
== ATH9K_M_IBSS
) {
631 memcpy(sc
->sc_curbssid
, ath_bcast_mac
, ETH_ALEN
);
632 ath9k_hw_write_associd(ah
, sc
->sc_curbssid
, sc
->sc_curaid
);
636 DPRINTF(sc
, ATH_DBG_CONFIG
,
637 "%s: RX filter 0x%x bssid %s aid 0x%x\n",
638 __func__
, rfilt
, print_mac(mac
,
639 sc
->sc_curbssid
), sc
->sc_curaid
);
643 * Disable BMISS interrupt when we're not associated
645 ath9k_hw_set_interrupts(ah
,
646 sc
->sc_imask
& ~(ATH9K_INT_SWBA
| ATH9K_INT_BMISS
));
647 sc
->sc_imask
&= ~(ATH9K_INT_SWBA
| ATH9K_INT_BMISS
);
648 /* need to reconfigure the beacons when it moves to RUN */
654 int ath_vap_attach(struct ath_softc
*sc
,
656 struct ieee80211_vif
*if_data
,
657 enum ath9k_opmode opmode
)
661 if (if_id
>= ATH_BCBUF
|| sc
->sc_vaps
[if_id
] != NULL
) {
662 DPRINTF(sc
, ATH_DBG_FATAL
,
663 "%s: Invalid interface id = %u\n", __func__
, if_id
);
670 case ATH9K_M_MONITOR
:
673 /* XXX not right, beacon buffer is allocated on RUN trans */
674 if (list_empty(&sc
->sc_bbuf
))
682 avp
= kmalloc(sizeof(struct ath_vap
), GFP_KERNEL
);
686 memzero(avp
, sizeof(struct ath_vap
));
687 avp
->av_if_data
= if_data
;
688 /* Set the VAP opmode */
689 avp
->av_opmode
= opmode
;
691 INIT_LIST_HEAD(&avp
->av_mcastq
.axq_q
);
692 INIT_LIST_HEAD(&avp
->av_mcastq
.axq_acq
);
693 spin_lock_init(&avp
->av_mcastq
.axq_lock
);
695 ath9k_hw_set_tsfadjust(sc
->sc_ah
, 1);
697 sc
->sc_vaps
[if_id
] = avp
;
699 /* Set the device opmode */
700 sc
->sc_opmode
= opmode
;
702 /* default VAP configuration */
703 avp
->av_config
.av_fixed_rateset
= IEEE80211_FIXED_RATE_NONE
;
704 avp
->av_config
.av_fixed_retryset
= 0x03030303;
709 int ath_vap_detach(struct ath_softc
*sc
, int if_id
)
711 struct ath_hal
*ah
= sc
->sc_ah
;
714 avp
= sc
->sc_vaps
[if_id
];
716 DPRINTF(sc
, ATH_DBG_FATAL
, "%s: invalid interface id %u\n",
722 * Quiesce the hardware while we remove the vap. In
723 * particular we need to reclaim all references to the
724 * vap state by any frames pending on the tx queues.
726 * XXX can we do this w/o affecting other vap's?
728 ath9k_hw_set_interrupts(ah
, 0); /* disable interrupts */
729 ath_draintxq(sc
, false); /* stop xmit side */
730 ath_stoprecv(sc
); /* stop recv side */
731 ath_flushrecv(sc
); /* flush recv queue */
733 /* Reclaim any pending mcast bufs on the vap. */
734 ath_tx_draintxq(sc
, &avp
->av_mcastq
, false);
737 sc
->sc_vaps
[if_id
] = NULL
;
743 int ath_vap_config(struct ath_softc
*sc
,
744 int if_id
, struct ath_vap_config
*if_config
)
748 if (if_id
>= ATH_BCBUF
) {
749 DPRINTF(sc
, ATH_DBG_FATAL
,
750 "%s: Invalid interface id = %u\n", __func__
, if_id
);
754 avp
= sc
->sc_vaps
[if_id
];
758 memcpy(&avp
->av_config
, if_config
, sizeof(avp
->av_config
));
767 int ath_open(struct ath_softc
*sc
, struct ath9k_channel
*initial_chan
)
769 struct ath_hal
*ah
= sc
->sc_ah
;
772 enum ath9k_ht_macmode ht_macmode
= ath_cwm_macmode(sc
);
774 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: mode %d\n", __func__
, sc
->sc_opmode
);
777 * Stop anything previously setup. This is safe
778 * whether this is the first time through or not.
782 /* Initialize chanmask selection */
783 sc
->sc_tx_chainmask
= ah
->ah_caps
.halTxChainMask
;
784 sc
->sc_rx_chainmask
= ah
->ah_caps
.halRxChainMask
;
786 /* Reset SERDES registers */
787 ath9k_hw_configpcipowersave(ah
, 0);
790 * The basic interface to setting the hardware in a good
791 * state is ``reset''. On return the hardware is known to
792 * be powered up and with interrupts disabled. This must
793 * be followed by initialization of the appropriate bits
794 * and then setup of the interrupt mask.
796 sc
->sc_curchan
= *initial_chan
;
798 spin_lock_bh(&sc
->sc_resetlock
);
799 if (!ath9k_hw_reset(ah
, sc
->sc_opmode
, &sc
->sc_curchan
, ht_macmode
,
800 sc
->sc_tx_chainmask
, sc
->sc_rx_chainmask
,
801 sc
->sc_ht_extprotspacing
, false, &status
)) {
802 DPRINTF(sc
, ATH_DBG_FATAL
,
803 "%s: unable to reset hardware; hal status %u "
804 "(freq %u flags 0x%x)\n", __func__
, status
,
805 sc
->sc_curchan
.channel
, sc
->sc_curchan
.channelFlags
);
807 spin_unlock_bh(&sc
->sc_resetlock
);
810 spin_unlock_bh(&sc
->sc_resetlock
);
812 * This is needed only to setup initial state
813 * but it's best done after a reset.
815 ath_update_txpow(sc
);
818 * Setup the hardware after reset:
819 * The receive engine is set going.
820 * Frame transmit is handled entirely
821 * in the frame output path; there's nothing to do
822 * here except setup the interrupt mask.
824 if (ath_startrecv(sc
) != 0) {
825 DPRINTF(sc
, ATH_DBG_FATAL
,
826 "%s: unable to start recv logic\n", __func__
);
830 /* Setup our intr mask. */
831 sc
->sc_imask
= ATH9K_INT_RX
| ATH9K_INT_TX
832 | ATH9K_INT_RXEOL
| ATH9K_INT_RXORN
833 | ATH9K_INT_FATAL
| ATH9K_INT_GLOBAL
;
835 if (ah
->ah_caps
.halGTTSupport
)
836 sc
->sc_imask
|= ATH9K_INT_GTT
;
838 if (ah
->ah_caps
.halHTSupport
)
839 sc
->sc_imask
|= ATH9K_INT_CST
;
842 * Enable MIB interrupts when there are hardware phy counters.
843 * Note we only do this (at the moment) for station mode.
845 if (ath9k_hw_phycounters(ah
) &&
846 ((sc
->sc_opmode
== ATH9K_M_STA
) || (sc
->sc_opmode
== ATH9K_M_IBSS
)))
847 sc
->sc_imask
|= ATH9K_INT_MIB
;
849 * Some hardware processes the TIM IE and fires an
850 * interrupt when the TIM bit is set. For hardware
851 * that does, if not overridden by configuration,
852 * enable the TIM interrupt when operating as station.
854 if (ah
->ah_caps
.halEnhancedPmSupport
&& sc
->sc_opmode
== ATH9K_M_STA
&&
855 !sc
->sc_config
.swBeaconProcess
)
856 sc
->sc_imask
|= ATH9K_INT_TIM
;
858 * Don't enable interrupts here as we've not yet built our
859 * vap and node data structures, which will be needed as soon
860 * as we start receiving.
862 ath_chan_change(sc
, initial_chan
);
864 /* XXX: we must make sure h/w is ready and clear invalid flag
865 * before turning on interrupt. */
872 * Reset the hardware w/o losing operational state. This is
873 * basically a more efficient way of doing ath_stop, ath_init,
874 * followed by state transitions to the current 802.11
875 * operational state. Used to recover from errors rx overrun
876 * and to reset the hardware when rf gain settings must be reset.
879 static int ath_reset_start(struct ath_softc
*sc
, u32 flag
)
881 struct ath_hal
*ah
= sc
->sc_ah
;
883 ath9k_hw_set_interrupts(ah
, 0); /* disable interrupts */
884 ath_draintxq(sc
, flag
& RESET_RETRY_TXQ
); /* stop xmit side */
885 ath_stoprecv(sc
); /* stop recv side */
886 ath_flushrecv(sc
); /* flush recv queue */
891 static int ath_reset_end(struct ath_softc
*sc
, u32 flag
)
893 struct ath_hal
*ah
= sc
->sc_ah
;
895 if (ath_startrecv(sc
) != 0) /* restart recv */
896 DPRINTF(sc
, ATH_DBG_FATAL
,
897 "%s: unable to start recv logic\n", __func__
);
900 * We may be doing a reset in response to a request
901 * that changes the channel so update any state that
902 * might change as a result.
904 ath_chan_change(sc
, &sc
->sc_curchan
);
906 ath_update_txpow(sc
); /* update tx power state */
909 ath_beacon_config(sc
, ATH_IF_ID_ANY
); /* restart beacons */
910 ath9k_hw_set_interrupts(ah
, sc
->sc_imask
);
912 /* Restart the txq */
913 if (flag
& RESET_RETRY_TXQ
) {
915 for (i
= 0; i
< ATH9K_NUM_TX_QUEUES
; i
++) {
916 if (ATH_TXQ_SETUP(sc
, i
)) {
917 spin_lock_bh(&sc
->sc_txq
[i
].axq_lock
);
918 ath_txq_schedule(sc
, &sc
->sc_txq
[i
]);
919 spin_unlock_bh(&sc
->sc_txq
[i
].axq_lock
);
926 int ath_reset(struct ath_softc
*sc
)
928 struct ath_hal
*ah
= sc
->sc_ah
;
931 enum ath9k_ht_macmode ht_macmode
= ath_cwm_macmode(sc
);
933 /* NB: indicate channel change so we do a full reset */
934 spin_lock_bh(&sc
->sc_resetlock
);
935 if (!ath9k_hw_reset(ah
, sc
->sc_opmode
, &sc
->sc_curchan
,
937 sc
->sc_tx_chainmask
, sc
->sc_rx_chainmask
,
938 sc
->sc_ht_extprotspacing
, false, &status
)) {
939 DPRINTF(sc
, ATH_DBG_FATAL
,
940 "%s: unable to reset hardware; hal status %u\n",
944 spin_unlock_bh(&sc
->sc_resetlock
);
949 int ath_suspend(struct ath_softc
*sc
)
951 struct ath_hal
*ah
= sc
->sc_ah
;
953 /* No I/O if device has been surprise removed */
957 /* Shut off the interrupt before setting sc->sc_invalid to '1' */
958 ath9k_hw_set_interrupts(ah
, 0);
960 /* XXX: we must make sure h/w will not generate any interrupt
961 * before setting the invalid flag. */
964 /* disable HAL and put h/w to sleep */
965 ath9k_hw_disable(sc
->sc_ah
);
967 ath9k_hw_configpcipowersave(sc
->sc_ah
, 1);
972 /* Interrupt handler. Most of the actual processing is deferred.
973 * It's the caller's responsibility to ensure the chip is awake. */
975 irqreturn_t
ath_isr(int irq
, void *dev
)
977 struct ath_softc
*sc
= dev
;
978 struct ath_hal
*ah
= sc
->sc_ah
;
979 enum ath9k_int status
;
983 if (sc
->sc_invalid
) {
985 * The hardware is not ready/present, don't
986 * touch anything. Note this can happen early
987 * on if the IRQ is shared.
991 if (!ath9k_hw_intrpend(ah
)) { /* shared irq, not for us */
996 * Figure out the reason(s) for the interrupt. Note
997 * that the hal returns a pseudo-ISR that may include
998 * bits we haven't explicitly enabled so we mask the
999 * value to insure we only process bits we requested.
1001 ath9k_hw_getisr(ah
, &status
); /* NB: clears ISR too */
1003 status
&= sc
->sc_imask
; /* discard unasked-for bits */
1006 * If there are no status bits set, then this interrupt was not
1007 * for me (should have been caught above).
1013 sc
->sc_intrstatus
= status
;
1015 if (status
& ATH9K_INT_FATAL
) {
1016 /* need a chip reset */
1018 } else if (status
& ATH9K_INT_RXORN
) {
1019 /* need a chip reset */
1022 if (status
& ATH9K_INT_SWBA
) {
1023 /* schedule a tasklet for beacon handling */
1024 tasklet_schedule(&sc
->bcon_tasklet
);
1026 if (status
& ATH9K_INT_RXEOL
) {
1028 * NB: the hardware should re-read the link when
1029 * RXE bit is written, but it doesn't work
1030 * at least on older hardware revs.
1035 if (status
& ATH9K_INT_TXURN
)
1036 /* bump tx trigger level */
1037 ath9k_hw_updatetxtriglevel(ah
, true);
1038 /* XXX: optimize this */
1039 if (status
& ATH9K_INT_RX
)
1041 if (status
& ATH9K_INT_TX
)
1043 if (status
& ATH9K_INT_BMISS
)
1045 /* carrier sense timeout */
1046 if (status
& ATH9K_INT_CST
)
1048 if (status
& ATH9K_INT_MIB
) {
1050 * Disable interrupts until we service the MIB
1051 * interrupt; otherwise it will continue to
1054 ath9k_hw_set_interrupts(ah
, 0);
1056 * Let the hal handle the event. We assume
1057 * it will clear whatever condition caused
1060 ath9k_hw_procmibevent(ah
, &sc
->sc_halstats
);
1061 ath9k_hw_set_interrupts(ah
, sc
->sc_imask
);
1063 if (status
& ATH9K_INT_TIM_TIMER
) {
1064 if (!ah
->ah_caps
.halAutoSleepSupport
) {
1065 /* Clear RxAbort bit so that we can
1067 ath9k_hw_setrxabort(ah
, 0);
1075 /* turn off every interrupt except SWBA */
1076 ath9k_hw_set_interrupts(ah
, (sc
->sc_imask
& ATH9K_INT_SWBA
));
1077 tasklet_schedule(&sc
->intr_tq
);
1083 /* Deferred interrupt processing */
1085 static void ath9k_tasklet(unsigned long data
)
1087 struct ath_softc
*sc
= (struct ath_softc
*)data
;
1088 u32 status
= sc
->sc_intrstatus
;
1090 if (status
& ATH9K_INT_FATAL
) {
1091 /* need a chip reset */
1092 ath_internal_reset(sc
);
1097 (ATH9K_INT_RX
| ATH9K_INT_RXEOL
| ATH9K_INT_RXORN
)) {
1098 /* XXX: fill me in */
1100 if (status & ATH9K_INT_RXORN) {
1102 if (status & ATH9K_INT_RXEOL) {
1105 spin_lock_bh(&sc
->sc_rxflushlock
);
1106 ath_rx_tasklet(sc
, 0);
1107 spin_unlock_bh(&sc
->sc_rxflushlock
);
1109 /* XXX: optimize this */
1110 if (status
& ATH9K_INT_TX
)
1112 /* XXX: fill me in */
1114 if (status & ATH9K_INT_BMISS) {
1116 if (status & (ATH9K_INT_TIM | ATH9K_INT_DTIMSYNC)) {
1117 if (status & ATH9K_INT_TIM) {
1119 if (status & ATH9K_INT_DTIMSYNC) {
1125 /* re-enable hardware interrupt */
1126 ath9k_hw_set_interrupts(sc
->sc_ah
, sc
->sc_imask
);
1129 int ath_init(u16 devid
, struct ath_softc
*sc
)
1131 struct ath_hal
*ah
= NULL
;
1137 /* XXX: hardware will not be ready until ath_open() being called */
1140 sc
->sc_debug
= DBG_DEFAULT
;
1141 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: devid 0x%x\n", __func__
, devid
);
1143 /* Initialize tasklet */
1144 tasklet_init(&sc
->intr_tq
, ath9k_tasklet
, (unsigned long)sc
);
1145 tasklet_init(&sc
->bcon_tasklet
, ath9k_beacon_tasklet
,
1149 * Cache line size is used to size and align various
1150 * structures used to communicate with the hardware.
1152 bus_read_cachesize(sc
, &csz
);
1153 /* XXX assert csz is non-zero */
1154 sc
->sc_cachelsz
= csz
<< 2; /* convert to bytes */
1156 spin_lock_init(&sc
->sc_resetlock
);
1158 ah
= ath9k_hw_attach(devid
, sc
, sc
->mem
, &status
);
1160 DPRINTF(sc
, ATH_DBG_FATAL
,
1161 "%s: unable to attach hardware; HAL status %u\n",
1168 /* Get the chipset-specific aggr limit. */
1169 sc
->sc_rtsaggrlimit
= ah
->ah_caps
.halRtsAggrLimit
;
1171 /* Get the hardware key cache size. */
1172 sc
->sc_keymax
= ah
->ah_caps
.halKeyCacheSize
;
1173 if (sc
->sc_keymax
> ATH_KEYMAX
) {
1174 DPRINTF(sc
, ATH_DBG_KEYCACHE
,
1175 "%s: Warning, using only %u entries in %u key cache\n",
1176 __func__
, ATH_KEYMAX
, sc
->sc_keymax
);
1177 sc
->sc_keymax
= ATH_KEYMAX
;
1181 * Reset the key cache since some parts do not
1182 * reset the contents on initial power up.
1184 for (i
= 0; i
< sc
->sc_keymax
; i
++)
1185 ath9k_hw_keyreset(ah
, (u16
) i
);
1187 * Mark key cache slots associated with global keys
1188 * as in use. If we knew TKIP was not to be used we
1189 * could leave the +32, +64, and +32+64 slots free.
1190 * XXX only for splitmic.
1192 for (i
= 0; i
< IEEE80211_WEP_NKID
; i
++) {
1193 set_bit(i
, sc
->sc_keymap
);
1194 set_bit(i
+ 32, sc
->sc_keymap
);
1195 set_bit(i
+ 64, sc
->sc_keymap
);
1196 set_bit(i
+ 32 + 64, sc
->sc_keymap
);
1199 * Collect the channel list using the default country
1200 * code and including outdoor channels. The 802.11 layer
1201 * is resposible for filtering this list based on settings
1202 * like the phy mode.
1204 rd
= ah
->ah_currentRD
;
1206 error
= ath_setup_channels(sc
);
1210 /* default to STA mode */
1211 sc
->sc_opmode
= ATH9K_M_MONITOR
;
1213 /* Setup rate tables for all potential media types. */
1214 /* 11g encompasses b,g */
1216 ath_rate_setup(sc
, WIRELESS_MODE_11a
);
1217 ath_rate_setup(sc
, WIRELESS_MODE_11g
);
1219 /* NB: setup here so ath_rate_update is happy */
1220 ath_setcurmode(sc
, WIRELESS_MODE_11a
);
1223 * Allocate hardware transmit queues: one queue for
1224 * beacon frames and one data queue for each QoS
1225 * priority. Note that the hal handles reseting
1226 * these queues at the needed time.
1228 sc
->sc_bhalq
= ath_beaconq_setup(ah
);
1229 if (sc
->sc_bhalq
== -1) {
1230 DPRINTF(sc
, ATH_DBG_FATAL
,
1231 "%s: unable to setup a beacon xmit queue\n", __func__
);
1235 sc
->sc_cabq
= ath_txq_setup(sc
, ATH9K_TX_QUEUE_CAB
, 0);
1236 if (sc
->sc_cabq
== NULL
) {
1237 DPRINTF(sc
, ATH_DBG_FATAL
,
1238 "%s: unable to setup CAB xmit queue\n", __func__
);
1243 sc
->sc_config
.cabqReadytime
= ATH_CABQ_READY_TIME
;
1244 ath_cabq_update(sc
);
1246 for (i
= 0; i
< ARRAY_SIZE(sc
->sc_haltype2q
); i
++)
1247 sc
->sc_haltype2q
[i
] = -1;
1249 /* Setup data queues */
1250 /* NB: ensure BK queue is the lowest priority h/w queue */
1251 if (!ath_tx_setup(sc
, ATH9K_WME_AC_BK
)) {
1252 DPRINTF(sc
, ATH_DBG_FATAL
,
1253 "%s: unable to setup xmit queue for BK traffic\n",
1259 if (!ath_tx_setup(sc
, ATH9K_WME_AC_BE
)) {
1260 DPRINTF(sc
, ATH_DBG_FATAL
,
1261 "%s: unable to setup xmit queue for BE traffic\n",
1266 if (!ath_tx_setup(sc
, ATH9K_WME_AC_VI
)) {
1267 DPRINTF(sc
, ATH_DBG_FATAL
,
1268 "%s: unable to setup xmit queue for VI traffic\n",
1273 if (!ath_tx_setup(sc
, ATH9K_WME_AC_VO
)) {
1274 DPRINTF(sc
, ATH_DBG_FATAL
,
1275 "%s: unable to setup xmit queue for VO traffic\n",
1281 sc
->sc_rc
= ath_rate_attach(ah
);
1282 if (sc
->sc_rc
== NULL
) {
1287 if (ath9k_hw_getcapability(ah
, HAL_CAP_CIPHER
,
1288 ATH9K_CIPHER_TKIP
, NULL
)) {
1290 * Whether we should enable h/w TKIP MIC.
1291 * XXX: if we don't support WME TKIP MIC, then we wouldn't
1292 * report WMM capable, so it's always safe to turn on
1293 * TKIP MIC in this case.
1295 ath9k_hw_setcapability(sc
->sc_ah
, HAL_CAP_TKIP_MIC
, 0, 1, NULL
);
1299 * Check whether the separate key cache entries
1300 * are required to handle both tx+rx MIC keys.
1301 * With split mic keys the number of stations is limited
1302 * to 27 otherwise 59.
1304 if (ath9k_hw_getcapability(ah
, HAL_CAP_CIPHER
,
1305 ATH9K_CIPHER_TKIP
, NULL
)
1306 && ath9k_hw_getcapability(ah
, HAL_CAP_CIPHER
,
1307 ATH9K_CIPHER_MIC
, NULL
)
1308 && ath9k_hw_getcapability(ah
, HAL_CAP_TKIP_SPLIT
,
1310 sc
->sc_splitmic
= 1;
1312 /* turn on mcast key search if possible */
1313 if (!ath9k_hw_getcapability(ah
, HAL_CAP_MCAST_KEYSRCH
, 0, NULL
))
1314 (void)ath9k_hw_setcapability(ah
, HAL_CAP_MCAST_KEYSRCH
, 1,
1317 sc
->sc_config
.txpowlimit
= ATH_TXPOWER_MAX
;
1318 sc
->sc_config
.txpowlimit_override
= 0;
1320 /* 11n Capabilities */
1321 if (ah
->ah_caps
.halHTSupport
) {
1326 sc
->sc_tx_chainmask
= ah
->ah_caps
.halTxChainMask
;
1327 sc
->sc_rx_chainmask
= ah
->ah_caps
.halRxChainMask
;
1329 /* Configuration for rx chain detection */
1330 sc
->sc_rxchaindetect_ref
= 0;
1331 sc
->sc_rxchaindetect_thresh5GHz
= 35;
1332 sc
->sc_rxchaindetect_thresh2GHz
= 35;
1333 sc
->sc_rxchaindetect_delta5GHz
= 30;
1334 sc
->sc_rxchaindetect_delta2GHz
= 30;
1336 ath9k_hw_setcapability(ah
, HAL_CAP_DIVERSITY
, 1, true, NULL
);
1337 sc
->sc_defant
= ath9k_hw_getdefantenna(ah
);
1339 ath9k_hw_getmac(ah
, sc
->sc_myaddr
);
1340 if (ah
->ah_caps
.halBssIdMaskSupport
) {
1341 ath9k_hw_getbssidmask(ah
, sc
->sc_bssidmask
);
1342 ATH_SET_VAP_BSSID_MASK(sc
->sc_bssidmask
);
1343 ath9k_hw_setbssidmask(ah
, sc
->sc_bssidmask
);
1345 sc
->sc_slottime
= ATH9K_SLOT_TIME_9
; /* default to short slot time */
1347 /* initialize beacon slots */
1348 for (i
= 0; i
< ARRAY_SIZE(sc
->sc_bslot
); i
++)
1349 sc
->sc_bslot
[i
] = ATH_IF_ID_ANY
;
1351 /* save MISC configurations */
1352 sc
->sc_config
.swBeaconProcess
= 1;
1354 #ifdef CONFIG_SLOW_ANT_DIV
1355 /* range is 40 - 255, we use something in the middle */
1356 ath_slow_ant_div_init(&sc
->sc_antdiv
, sc
, 0x127);
1361 /* cleanup tx queues */
1362 for (i
= 0; i
< ATH9K_NUM_TX_QUEUES
; i
++)
1363 if (ATH_TXQ_SETUP(sc
, i
))
1364 ath_tx_cleanupq(sc
, &sc
->sc_txq
[i
]);
1367 ath9k_hw_detach(ah
);
1371 void ath_deinit(struct ath_softc
*sc
)
1373 struct ath_hal
*ah
= sc
->sc_ah
;
1376 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s\n", __func__
);
1379 if (!sc
->sc_invalid
)
1380 ath9k_hw_setpower(sc
->sc_ah
, ATH9K_PM_AWAKE
);
1381 ath_rate_detach(sc
->sc_rc
);
1382 /* cleanup tx queues */
1383 for (i
= 0; i
< ATH9K_NUM_TX_QUEUES
; i
++)
1384 if (ATH_TXQ_SETUP(sc
, i
))
1385 ath_tx_cleanupq(sc
, &sc
->sc_txq
[i
]);
1386 ath9k_hw_detach(ah
);
1389 /*******************/
1390 /* Node Management */
1391 /*******************/
1393 struct ath_node
*ath_node_attach(struct ath_softc
*sc
, u8
*addr
, int if_id
)
1395 struct ath_vap
*avp
;
1396 struct ath_node
*an
;
1397 DECLARE_MAC_BUF(mac
);
1399 avp
= sc
->sc_vaps
[if_id
];
1400 ASSERT(avp
!= NULL
);
1402 /* mac80211 sta_notify callback is from an IRQ context, so no sleep */
1403 an
= kmalloc(sizeof(struct ath_node
), GFP_ATOMIC
);
1406 memzero(an
, sizeof(*an
));
1409 memcpy(an
->an_addr
, addr
, ETH_ALEN
);
1410 atomic_set(&an
->an_refcnt
, 1);
1412 /* set up per-node tx/rx state */
1413 ath_tx_node_init(sc
, an
);
1414 ath_rx_node_init(sc
, an
);
1416 ath_chainmask_sel_init(sc
, an
);
1417 ath_chainmask_sel_timerstart(&an
->an_chainmask_sel
);
1418 list_add(&an
->list
, &sc
->node_list
);
1423 void ath_node_detach(struct ath_softc
*sc
, struct ath_node
*an
, bool bh_flag
)
1425 unsigned long flags
;
1427 DECLARE_MAC_BUF(mac
);
1429 ath_chainmask_sel_timerstop(&an
->an_chainmask_sel
);
1430 an
->an_flags
|= ATH_NODE_CLEAN
;
1431 ath_tx_node_cleanup(sc
, an
, bh_flag
);
1432 ath_rx_node_cleanup(sc
, an
);
1434 ath_tx_node_free(sc
, an
);
1435 ath_rx_node_free(sc
, an
);
1437 spin_lock_irqsave(&sc
->node_lock
, flags
);
1439 list_del(&an
->list
);
1441 spin_unlock_irqrestore(&sc
->node_lock
, flags
);
1446 /* Finds a node and increases the refcnt if found */
1448 struct ath_node
*ath_node_get(struct ath_softc
*sc
, u8
*addr
)
1450 struct ath_node
*an
= NULL
, *an_found
= NULL
;
1452 if (list_empty(&sc
->node_list
)) /* FIXME */
1454 list_for_each_entry(an
, &sc
->node_list
, list
) {
1455 if (!compare_ether_addr(an
->an_addr
, addr
)) {
1456 atomic_inc(&an
->an_refcnt
);
1465 /* Decrements the refcnt and if it drops to zero, detach the node */
1467 void ath_node_put(struct ath_softc
*sc
, struct ath_node
*an
, bool bh_flag
)
1469 if (atomic_dec_and_test(&an
->an_refcnt
))
1470 ath_node_detach(sc
, an
, bh_flag
);
1473 /* Finds a node, doesn't increment refcnt. Caller must hold sc->node_lock */
1474 struct ath_node
*ath_node_find(struct ath_softc
*sc
, u8
*addr
)
1476 struct ath_node
*an
= NULL
, *an_found
= NULL
;
1478 if (list_empty(&sc
->node_list
))
1481 list_for_each_entry(an
, &sc
->node_list
, list
)
1482 if (!compare_ether_addr(an
->an_addr
, addr
)) {
1493 * Setup driver-specific state for a newly associated node. This routine
1494 * really only applies if compression or XR are enabled, there is no code
1495 * covering any other cases.
1498 void ath_newassoc(struct ath_softc
*sc
,
1499 struct ath_node
*an
, int isnew
, int isuapsd
)
1503 /* if station reassociates, tear down the aggregation state. */
1505 for (tidno
= 0; tidno
< WME_NUM_TID
; tidno
++) {
1507 ath_tx_aggr_teardown(sc
, an
, tidno
);
1509 ath_rx_aggr_teardown(sc
, an
, tidno
);
1519 void ath_key_reset(struct ath_softc
*sc
, u16 keyix
, int freeslot
)
1521 ath9k_hw_keyreset(sc
->sc_ah
, keyix
);
1523 clear_bit(keyix
, sc
->sc_keymap
);
1526 int ath_keyset(struct ath_softc
*sc
,
1528 struct ath9k_keyval
*hk
,
1529 const u8 mac
[ETH_ALEN
])
1533 status
= ath9k_hw_set_keycache_entry(sc
->sc_ah
,
1534 keyix
, hk
, mac
, false);
1536 return status
!= false;
1539 /***********************/
1540 /* TX Power/Regulatory */
1541 /***********************/
1544 * Set Transmit power in HAL
1546 * This routine makes the actual HAL calls to set the new transmit power
1550 void ath_update_txpow(struct ath_softc
*sc
)
1552 struct ath_hal
*ah
= sc
->sc_ah
;
1555 if (sc
->sc_curtxpow
!= sc
->sc_config
.txpowlimit
) {
1556 ath9k_hw_set_txpowerlimit(ah
, sc
->sc_config
.txpowlimit
);
1557 /* read back in case value is clamped */
1558 ath9k_hw_getcapability(ah
, HAL_CAP_TXPOW
, 1, &txpow
);
1559 sc
->sc_curtxpow
= txpow
;
1563 /* Return the current country and domain information */
1564 void ath_get_currentCountry(struct ath_softc
*sc
,
1565 struct ath9k_country_entry
*ctry
)
1567 ath9k_regd_get_current_country(sc
->sc_ah
, ctry
);
1569 /* If HAL not specific yet, since it is band dependent,
1570 * use the one we passed in. */
1571 if (ctry
->countryCode
== CTRY_DEFAULT
) {
1574 } else if (ctry
->iso
[0] && ctry
->iso
[1]) {
1575 if (!ctry
->iso
[2]) {
1584 /**************************/
1585 /* Slow Antenna Diversity */
1586 /**************************/
1588 void ath_slow_ant_div_init(struct ath_antdiv
*antdiv
,
1589 struct ath_softc
*sc
,
1594 /* antdivf_rssitrig can range from 40 - 0xff */
1595 trig
= (rssitrig
> 0xff) ? 0xff : rssitrig
;
1596 trig
= (rssitrig
< 40) ? 40 : rssitrig
;
1598 antdiv
->antdiv_sc
= sc
;
1599 antdiv
->antdivf_rssitrig
= trig
;
1602 void ath_slow_ant_div_start(struct ath_antdiv
*antdiv
,
1606 antdiv
->antdiv_num_antcfg
=
1607 num_antcfg
< ATH_ANT_DIV_MAX_CFG
?
1608 num_antcfg
: ATH_ANT_DIV_MAX_CFG
;
1609 antdiv
->antdiv_state
= ATH_ANT_DIV_IDLE
;
1610 antdiv
->antdiv_curcfg
= 0;
1611 antdiv
->antdiv_bestcfg
= 0;
1612 antdiv
->antdiv_laststatetsf
= 0;
1614 memcpy(antdiv
->antdiv_bssid
, bssid
, sizeof(antdiv
->antdiv_bssid
));
1616 antdiv
->antdiv_start
= 1;
1619 void ath_slow_ant_div_stop(struct ath_antdiv
*antdiv
)
1621 antdiv
->antdiv_start
= 0;
1624 static int32_t ath_find_max_val(int32_t *val
,
1625 u8 num_val
, u8
*max_index
)
1627 u32 MaxVal
= *val
++;
1631 while (++cur_index
< num_val
) {
1632 if (*val
> MaxVal
) {
1634 *max_index
= cur_index
;
1643 void ath_slow_ant_div(struct ath_antdiv
*antdiv
,
1644 struct ieee80211_hdr
*hdr
,
1645 struct ath_rx_status
*rx_stats
)
1647 struct ath_softc
*sc
= antdiv
->antdiv_sc
;
1648 struct ath_hal
*ah
= sc
->sc_ah
;
1650 u8 bestcfg
, curcfg
= antdiv
->antdiv_curcfg
;
1651 __le16 fc
= hdr
->frame_control
;
1653 if (antdiv
->antdiv_start
&& ieee80211_is_beacon(fc
)
1654 && !compare_ether_addr(hdr
->addr3
, antdiv
->antdiv_bssid
)) {
1655 antdiv
->antdiv_lastbrssi
[curcfg
] = rx_stats
->rs_rssi
;
1656 antdiv
->antdiv_lastbtsf
[curcfg
] = ath9k_hw_gettsf64(sc
->sc_ah
);
1657 curtsf
= antdiv
->antdiv_lastbtsf
[curcfg
];
1662 switch (antdiv
->antdiv_state
) {
1663 case ATH_ANT_DIV_IDLE
:
1664 if ((antdiv
->antdiv_lastbrssi
[curcfg
] <
1665 antdiv
->antdivf_rssitrig
)
1666 && ((curtsf
- antdiv
->antdiv_laststatetsf
) >
1667 ATH_ANT_DIV_MIN_IDLE_US
)) {
1670 if (curcfg
== antdiv
->antdiv_num_antcfg
)
1673 if (!ath9k_hw_select_antconfig(ah
, curcfg
)) {
1674 antdiv
->antdiv_bestcfg
= antdiv
->antdiv_curcfg
;
1675 antdiv
->antdiv_curcfg
= curcfg
;
1676 antdiv
->antdiv_laststatetsf
= curtsf
;
1677 antdiv
->antdiv_state
= ATH_ANT_DIV_SCAN
;
1682 case ATH_ANT_DIV_SCAN
:
1683 if ((curtsf
- antdiv
->antdiv_laststatetsf
) <
1684 ATH_ANT_DIV_MIN_SCAN_US
)
1688 if (curcfg
== antdiv
->antdiv_num_antcfg
)
1691 if (curcfg
== antdiv
->antdiv_bestcfg
) {
1692 ath_find_max_val(antdiv
->antdiv_lastbrssi
,
1693 antdiv
->antdiv_num_antcfg
, &bestcfg
);
1694 if (!ath9k_hw_select_antconfig(ah
, bestcfg
)) {
1695 antdiv
->antdiv_bestcfg
= bestcfg
;
1696 antdiv
->antdiv_curcfg
= bestcfg
;
1697 antdiv
->antdiv_laststatetsf
= curtsf
;
1698 antdiv
->antdiv_state
= ATH_ANT_DIV_IDLE
;
1701 if (!ath9k_hw_select_antconfig(ah
, curcfg
)) {
1702 antdiv
->antdiv_curcfg
= curcfg
;
1703 antdiv
->antdiv_laststatetsf
= curtsf
;
1704 antdiv
->antdiv_state
= ATH_ANT_DIV_SCAN
;
1712 /***********************/
1713 /* Descriptor Handling */
1714 /***********************/
1717 * Set up DMA descriptors
1719 * This function will allocate both the DMA descriptor structure, and the
1720 * buffers it contains. These are used to contain the descriptors used
1724 int ath_descdma_setup(struct ath_softc
*sc
,
1725 struct ath_descdma
*dd
,
1726 struct list_head
*head
,
1731 #define DS2PHYS(_dd, _ds) \
1732 ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
1733 #define ATH_DESC_4KB_BOUND_CHECK(_daddr) ((((_daddr) & 0xFFF) > 0xF7F) ? 1 : 0)
1734 #define ATH_DESC_4KB_BOUND_NUM_SKIPPED(_len) ((_len) / 4096)
1736 struct ath_desc
*ds
;
1738 int i
, bsize
, error
;
1740 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: %s DMA: %u buffers %u desc/buf\n",
1741 __func__
, name
, nbuf
, ndesc
);
1743 /* ath_desc must be a multiple of DWORDs */
1744 if ((sizeof(struct ath_desc
) % 4) != 0) {
1745 DPRINTF(sc
, ATH_DBG_FATAL
, "%s: ath_desc not DWORD aligned\n",
1747 ASSERT((sizeof(struct ath_desc
) % 4) == 0);
1753 dd
->dd_desc_len
= sizeof(struct ath_desc
) * nbuf
* ndesc
;
1756 * Need additional DMA memory because we can't use
1757 * descriptors that cross the 4K page boundary. Assume
1758 * one skipped descriptor per 4K page.
1760 if (!(sc
->sc_ah
->ah_caps
.hal4kbSplitTransSupport
)) {
1762 ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd
->dd_desc_len
);
1765 while (ndesc_skipped
) {
1766 dma_len
= ndesc_skipped
* sizeof(struct ath_desc
);
1767 dd
->dd_desc_len
+= dma_len
;
1769 ndesc_skipped
= ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len
);
1773 /* allocate descriptors */
1774 dd
->dd_desc
= pci_alloc_consistent(sc
->pdev
,
1776 &dd
->dd_desc_paddr
);
1777 if (dd
->dd_desc
== NULL
) {
1782 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: %s DMA map: %p (%u) -> %llx (%u)\n",
1783 __func__
, dd
->dd_name
, ds
, (u32
) dd
->dd_desc_len
,
1784 ito64(dd
->dd_desc_paddr
), /*XXX*/(u32
) dd
->dd_desc_len
);
1786 /* allocate buffers */
1787 bsize
= sizeof(struct ath_buf
) * nbuf
;
1788 bf
= kmalloc(bsize
, GFP_KERNEL
);
1796 INIT_LIST_HEAD(head
);
1797 for (i
= 0; i
< nbuf
; i
++, bf
++, ds
+= ndesc
) {
1799 bf
->bf_daddr
= DS2PHYS(dd
, ds
);
1801 if (!(sc
->sc_ah
->ah_caps
.hal4kbSplitTransSupport
)) {
1803 * Skip descriptor addresses which can cause 4KB
1804 * boundary crossing (addr + length) with a 32 dword
1807 while (ATH_DESC_4KB_BOUND_CHECK(bf
->bf_daddr
)) {
1808 ASSERT((caddr_t
) bf
->bf_desc
<
1809 ((caddr_t
) dd
->dd_desc
+
1814 bf
->bf_daddr
= DS2PHYS(dd
, ds
);
1817 list_add_tail(&bf
->list
, head
);
1821 pci_free_consistent(sc
->pdev
,
1822 dd
->dd_desc_len
, dd
->dd_desc
, dd
->dd_desc_paddr
);
1824 memzero(dd
, sizeof(*dd
));
1826 #undef ATH_DESC_4KB_BOUND_CHECK
1827 #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED
1832 * Cleanup DMA descriptors
1834 * This function will free the DMA block that was allocated for the descriptor
1835 * pool. Since this was allocated as one "chunk", it is freed in the same
1839 void ath_descdma_cleanup(struct ath_softc
*sc
,
1840 struct ath_descdma
*dd
,
1841 struct list_head
*head
)
1843 /* Free memory associated with descriptors */
1844 pci_free_consistent(sc
->pdev
,
1845 dd
->dd_desc_len
, dd
->dd_desc
, dd
->dd_desc_paddr
);
1847 INIT_LIST_HEAD(head
);
1848 kfree(dd
->dd_bufptr
);
1849 memzero(dd
, sizeof(*dd
));
1856 void ath_internal_reset(struct ath_softc
*sc
)
1858 ath_reset_start(sc
, 0);
1860 ath_reset_end(sc
, 0);
1863 int ath_get_hal_qnum(u16 queue
, struct ath_softc
*sc
)
1869 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_VO
];
1872 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_VI
];
1875 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_BE
];
1878 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_BK
];
1881 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_BE
];
1888 int ath_get_mac80211_qnum(u32 queue
, struct ath_softc
*sc
)
1893 case ATH9K_WME_AC_VO
:
1896 case ATH9K_WME_AC_VI
:
1899 case ATH9K_WME_AC_BE
:
1902 case ATH9K_WME_AC_BK
:
1915 * Expand time stamp to TSF
1917 * Extend 15-bit time stamp from rx descriptor to
1918 * a full 64-bit TSF using the current h/w TSF.
1921 u64
ath_extend_tsf(struct ath_softc
*sc
, u32 rstamp
)
1925 tsf
= ath9k_hw_gettsf64(sc
->sc_ah
);
1926 if ((tsf
& 0x7fff) < rstamp
)
1928 return (tsf
& ~0x7fff) | rstamp
;
1932 * Set Default Antenna
1934 * Call into the HAL to set the default antenna to use. Not really valid for
1938 void ath_setdefantenna(void *context
, u32 antenna
)
1940 struct ath_softc
*sc
= (struct ath_softc
*)context
;
1941 struct ath_hal
*ah
= sc
->sc_ah
;
1943 /* XXX block beacon interrupts */
1944 ath9k_hw_setantenna(ah
, antenna
);
1945 sc
->sc_defant
= antenna
;
1946 sc
->sc_rxotherant
= 0;
1952 * This will wake up the chip if required, and set the slot time for the
1953 * frame (maximum transmit time). Slot time is assumed to be already set
1954 * in the ATH object member sc_slottime
1957 void ath_setslottime(struct ath_softc
*sc
)
1959 ath9k_hw_setslottime(sc
->sc_ah
, sc
->sc_slottime
);
1960 sc
->sc_updateslot
= OK
;