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 u32 ath_chainmask_sel_up_rssi_thres
=
25 ATH_CHAINMASK_SEL_UP_RSSI_THRES
;
26 static u32 ath_chainmask_sel_down_rssi_thres
=
27 ATH_CHAINMASK_SEL_DOWN_RSSI_THRES
;
28 static u32 ath_chainmask_sel_period
=
29 ATH_CHAINMASK_SEL_TIMEOUT
;
31 /* return bus cachesize in 4B word units */
33 static void bus_read_cachesize(struct ath_softc
*sc
, int *csz
)
37 pci_read_config_byte(sc
->pdev
, PCI_CACHE_LINE_SIZE
, (u8
*)&u8tmp
);
41 * This check was put in to avoid "unplesant" consequences if
42 * the bootrom has not fully initialized all PCI devices.
43 * Sometimes the cache line size register is not set
47 *csz
= DEFAULT_CACHELINE
>> 2; /* Use the default size */
51 * Set current operating mode
53 * This function initializes and fills the rate table in the ATH object based
54 * on the operating mode. The blink rates are also set up here, although
55 * they have been superceeded by the ath_led module.
58 static void ath_setcurmode(struct ath_softc
*sc
, enum wireless_mode mode
)
60 const struct ath9k_rate_table
*rt
;
63 memset(sc
->sc_rixmap
, 0xff, sizeof(sc
->sc_rixmap
));
64 rt
= ath9k_hw_getratetable(sc
->sc_ah
, mode
);
67 for (i
= 0; i
< rt
->rateCount
; i
++)
68 sc
->sc_rixmap
[rt
->info
[i
].rateCode
] = (u8
) i
;
70 memzero(sc
->sc_hwmap
, sizeof(sc
->sc_hwmap
));
71 for (i
= 0; i
< 256; i
++) {
72 u8 ix
= rt
->rateCodeToIndex
[i
];
77 sc
->sc_hwmap
[i
].ieeerate
=
78 rt
->info
[ix
].dot11Rate
& IEEE80211_RATE_VAL
;
79 sc
->sc_hwmap
[i
].rateKbps
= rt
->info
[ix
].rateKbps
;
81 if (rt
->info
[ix
].shortPreamble
||
82 rt
->info
[ix
].phy
== PHY_OFDM
) {
83 /* XXX: Handle this */
86 /* NB: this uses the last entry if the rate isn't found */
87 /* XXX beware of overlow */
90 sc
->sc_curmode
= mode
;
92 * All protection frames are transmited at 2Mb/s for
93 * 11g, otherwise at 1Mb/s.
94 * XXX select protection rate index from rate table.
96 sc
->sc_protrix
= (mode
== ATH9K_MODE_11G
? 1 : 0);
100 * Set up rate table (legacy rates)
102 static void ath_setup_rates(struct ath_softc
*sc
, enum ieee80211_band band
)
104 struct ath_hal
*ah
= sc
->sc_ah
;
105 const struct ath9k_rate_table
*rt
= NULL
;
106 struct ieee80211_supported_band
*sband
;
107 struct ieee80211_rate
*rate
;
111 case IEEE80211_BAND_2GHZ
:
112 rt
= ath9k_hw_getratetable(ah
, ATH9K_MODE_11G
);
114 case IEEE80211_BAND_5GHZ
:
115 rt
= ath9k_hw_getratetable(ah
, ATH9K_MODE_11A
);
124 sband
= &sc
->sbands
[band
];
125 rate
= sc
->rates
[band
];
127 if (rt
->rateCount
> ATH_RATE_MAX
)
128 maxrates
= ATH_RATE_MAX
;
130 maxrates
= rt
->rateCount
;
132 for (i
= 0; i
< maxrates
; i
++) {
133 rate
[i
].bitrate
= rt
->info
[i
].rateKbps
/ 100;
134 rate
[i
].hw_value
= rt
->info
[i
].rateCode
;
136 DPRINTF(sc
, ATH_DBG_CONFIG
,
137 "%s: Rate: %2dMbps, ratecode: %2d\n",
139 rate
[i
].bitrate
/ 10,
145 * Set up channel list
147 static int ath_setup_channels(struct ath_softc
*sc
)
149 struct ath_hal
*ah
= sc
->sc_ah
;
150 int nchan
, i
, a
= 0, b
= 0;
151 u8 regclassids
[ATH_REGCLASSIDS_MAX
];
153 struct ieee80211_supported_band
*band_2ghz
;
154 struct ieee80211_supported_band
*band_5ghz
;
155 struct ieee80211_channel
*chan_2ghz
;
156 struct ieee80211_channel
*chan_5ghz
;
157 struct ath9k_channel
*c
;
159 /* Fill in ah->ah_channels */
160 if (!ath9k_regd_init_channels(ah
,
169 u32 rd
= ah
->ah_currentRD
;
171 DPRINTF(sc
, ATH_DBG_FATAL
,
172 "%s: unable to collect channel list; "
173 "regdomain likely %u country code %u\n",
174 __func__
, rd
, CTRY_DEFAULT
);
178 band_2ghz
= &sc
->sbands
[IEEE80211_BAND_2GHZ
];
179 band_5ghz
= &sc
->sbands
[IEEE80211_BAND_5GHZ
];
180 chan_2ghz
= sc
->channels
[IEEE80211_BAND_2GHZ
];
181 chan_5ghz
= sc
->channels
[IEEE80211_BAND_5GHZ
];
183 for (i
= 0; i
< nchan
; i
++) {
184 c
= &ah
->ah_channels
[i
];
185 if (IS_CHAN_2GHZ(c
)) {
186 chan_2ghz
[a
].band
= IEEE80211_BAND_2GHZ
;
187 chan_2ghz
[a
].center_freq
= c
->channel
;
188 chan_2ghz
[a
].max_power
= c
->maxTxPower
;
190 if (c
->privFlags
& CHANNEL_DISALLOW_ADHOC
)
191 chan_2ghz
[a
].flags
|=
192 IEEE80211_CHAN_NO_IBSS
;
193 if (c
->channelFlags
& CHANNEL_PASSIVE
)
194 chan_2ghz
[a
].flags
|=
195 IEEE80211_CHAN_PASSIVE_SCAN
;
197 band_2ghz
->n_channels
= ++a
;
199 DPRINTF(sc
, ATH_DBG_CONFIG
,
200 "%s: 2MHz channel: %d, "
201 "channelFlags: 0x%x\n",
205 } else if (IS_CHAN_5GHZ(c
)) {
206 chan_5ghz
[b
].band
= IEEE80211_BAND_5GHZ
;
207 chan_5ghz
[b
].center_freq
= c
->channel
;
208 chan_5ghz
[b
].max_power
= c
->maxTxPower
;
210 if (c
->privFlags
& CHANNEL_DISALLOW_ADHOC
)
211 chan_5ghz
[b
].flags
|=
212 IEEE80211_CHAN_NO_IBSS
;
213 if (c
->channelFlags
& CHANNEL_PASSIVE
)
214 chan_5ghz
[b
].flags
|=
215 IEEE80211_CHAN_PASSIVE_SCAN
;
217 band_5ghz
->n_channels
= ++b
;
219 DPRINTF(sc
, ATH_DBG_CONFIG
,
220 "%s: 5MHz channel: %d, "
221 "channelFlags: 0x%x\n",
232 * Determine mode from channel flags
234 * This routine will provide the enumerated WIRELESSS_MODE value based
235 * on the settings of the channel flags. If ho valid set of flags
236 * exist, the lowest mode (11b) is selected.
239 static enum wireless_mode
ath_chan2mode(struct ath9k_channel
*chan
)
241 if (chan
->chanmode
== CHANNEL_A
)
242 return ATH9K_MODE_11A
;
243 else if (chan
->chanmode
== CHANNEL_G
)
244 return ATH9K_MODE_11G
;
245 else if (chan
->chanmode
== CHANNEL_B
)
246 return ATH9K_MODE_11B
;
247 else if (chan
->chanmode
== CHANNEL_A_HT20
)
248 return ATH9K_MODE_11NA_HT20
;
249 else if (chan
->chanmode
== CHANNEL_G_HT20
)
250 return ATH9K_MODE_11NG_HT20
;
251 else if (chan
->chanmode
== CHANNEL_A_HT40PLUS
)
252 return ATH9K_MODE_11NA_HT40PLUS
;
253 else if (chan
->chanmode
== CHANNEL_A_HT40MINUS
)
254 return ATH9K_MODE_11NA_HT40MINUS
;
255 else if (chan
->chanmode
== CHANNEL_G_HT40PLUS
)
256 return ATH9K_MODE_11NG_HT40PLUS
;
257 else if (chan
->chanmode
== CHANNEL_G_HT40MINUS
)
258 return ATH9K_MODE_11NG_HT40MINUS
;
260 /* NB: should not get here */
261 return ATH9K_MODE_11B
;
265 * Stop the device, grabbing the top-level lock to protect
266 * against concurrent entry through ath_init (which can happen
267 * if another thread does a system call and the thread doing the
268 * stop is preempted).
271 static int ath_stop(struct ath_softc
*sc
)
273 struct ath_hal
*ah
= sc
->sc_ah
;
275 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: invalid %ld\n",
276 __func__
, sc
->sc_flags
& SC_OP_INVALID
);
279 * Shutdown the hardware and driver:
280 * stop output from above
281 * reset 802.11 state machine
282 * (sends station deassoc/deauth frames)
285 * clear transmit machinery
286 * clear receive machinery
288 * reclaim beacon resources
290 * Note that some of this work is not possible if the
291 * hardware is gone (invalid).
294 if (!(sc
->sc_flags
& SC_OP_INVALID
))
295 ath9k_hw_set_interrupts(ah
, 0);
296 ath_draintxq(sc
, false);
297 if (!(sc
->sc_flags
& SC_OP_INVALID
)) {
299 ath9k_hw_phy_disable(ah
);
301 sc
->sc_rxlink
= NULL
;
307 * Set the current channel
309 * Set/change channels. If the channel is really being changed, it's done
310 * by reseting the chip. To accomplish this we must first cleanup any pending
311 * DMA, then restart stuff after a la ath_init.
313 int ath_set_channel(struct ath_softc
*sc
, struct ath9k_channel
*hchan
)
315 struct ath_hal
*ah
= sc
->sc_ah
;
316 bool fastcc
= true, stopped
;
317 enum ath9k_ht_macmode ht_macmode
;
319 if (sc
->sc_flags
& SC_OP_INVALID
) /* the device is invalid or removed */
322 DPRINTF(sc
, ATH_DBG_CONFIG
,
323 "%s: %u (%u MHz) -> %u (%u MHz), cflags:%x\n",
325 ath9k_hw_mhz2ieee(ah
, sc
->sc_ah
->ah_curchan
->channel
,
326 sc
->sc_ah
->ah_curchan
->channelFlags
),
327 sc
->sc_ah
->ah_curchan
->channel
,
328 ath9k_hw_mhz2ieee(ah
, hchan
->channel
, hchan
->channelFlags
),
329 hchan
->channel
, hchan
->channelFlags
);
331 ht_macmode
= ath_cwm_macmode(sc
);
333 if (hchan
->channel
!= sc
->sc_ah
->ah_curchan
->channel
||
334 hchan
->channelFlags
!= sc
->sc_ah
->ah_curchan
->channelFlags
||
335 (sc
->sc_flags
& SC_OP_CHAINMASK_UPDATE
) ||
336 (sc
->sc_flags
& SC_OP_FULL_RESET
)) {
339 * This is only performed if the channel settings have
342 * To switch channels clear any pending DMA operations;
343 * wait long enough for the RX fifo to drain, reset the
344 * hardware at the new frequency, and then re-enable
345 * the relevant bits of the h/w.
347 ath9k_hw_set_interrupts(ah
, 0); /* disable interrupts */
348 ath_draintxq(sc
, false); /* clear pending tx frames */
349 stopped
= ath_stoprecv(sc
); /* turn off frame recv */
351 /* XXX: do not flush receive queue here. We don't want
352 * to flush data frames already in queue because of
353 * changing channel. */
355 if (!stopped
|| (sc
->sc_flags
& SC_OP_FULL_RESET
))
358 spin_lock_bh(&sc
->sc_resetlock
);
359 if (!ath9k_hw_reset(ah
, hchan
,
360 ht_macmode
, sc
->sc_tx_chainmask
,
362 sc
->sc_ht_extprotspacing
,
364 DPRINTF(sc
, ATH_DBG_FATAL
,
365 "%s: unable to reset channel %u (%uMhz) "
366 "flags 0x%x hal status %u\n", __func__
,
367 ath9k_hw_mhz2ieee(ah
, hchan
->channel
,
368 hchan
->channelFlags
),
369 hchan
->channel
, hchan
->channelFlags
, status
);
370 spin_unlock_bh(&sc
->sc_resetlock
);
373 spin_unlock_bh(&sc
->sc_resetlock
);
375 sc
->sc_flags
&= ~SC_OP_CHAINMASK_UPDATE
;
376 sc
->sc_flags
&= ~SC_OP_FULL_RESET
;
378 /* Re-enable rx framework */
379 if (ath_startrecv(sc
) != 0) {
380 DPRINTF(sc
, ATH_DBG_FATAL
,
381 "%s: unable to restart recv logic\n", __func__
);
385 * Change channels and update the h/w rate map
386 * if we're switching; e.g. 11a to 11b/g.
388 ath_setcurmode(sc
, ath_chan2mode(hchan
));
390 ath_update_txpow(sc
); /* update tx power state */
392 * Re-enable interrupts.
394 ath9k_hw_set_interrupts(ah
, sc
->sc_imask
);
399 /**********************/
400 /* Chainmask Handling */
401 /**********************/
403 static void ath_chainmask_sel_timertimeout(unsigned long data
)
405 struct ath_chainmask_sel
*cm
= (struct ath_chainmask_sel
*)data
;
406 cm
->switch_allowed
= 1;
409 /* Start chainmask select timer */
410 static void ath_chainmask_sel_timerstart(struct ath_chainmask_sel
*cm
)
412 cm
->switch_allowed
= 0;
413 mod_timer(&cm
->timer
, ath_chainmask_sel_period
);
416 /* Stop chainmask select timer */
417 static void ath_chainmask_sel_timerstop(struct ath_chainmask_sel
*cm
)
419 cm
->switch_allowed
= 0;
420 del_timer_sync(&cm
->timer
);
423 static void ath_chainmask_sel_init(struct ath_softc
*sc
, struct ath_node
*an
)
425 struct ath_chainmask_sel
*cm
= &an
->an_chainmask_sel
;
427 memzero(cm
, sizeof(struct ath_chainmask_sel
));
429 cm
->cur_tx_mask
= sc
->sc_tx_chainmask
;
430 cm
->cur_rx_mask
= sc
->sc_rx_chainmask
;
431 cm
->tx_avgrssi
= ATH_RSSI_DUMMY_MARKER
;
432 setup_timer(&cm
->timer
,
433 ath_chainmask_sel_timertimeout
, (unsigned long) cm
);
436 int ath_chainmask_sel_logic(struct ath_softc
*sc
, struct ath_node
*an
)
438 struct ath_chainmask_sel
*cm
= &an
->an_chainmask_sel
;
441 * Disable auto-swtiching in one of the following if conditions.
442 * sc_chainmask_auto_sel is used for internal global auto-switching
443 * enabled/disabled setting
445 if (sc
->sc_ah
->ah_caps
.tx_chainmask
!= ATH_CHAINMASK_SEL_3X3
) {
446 cm
->cur_tx_mask
= sc
->sc_tx_chainmask
;
447 return cm
->cur_tx_mask
;
450 if (cm
->tx_avgrssi
== ATH_RSSI_DUMMY_MARKER
)
451 return cm
->cur_tx_mask
;
453 if (cm
->switch_allowed
) {
454 /* Switch down from tx 3 to tx 2. */
455 if (cm
->cur_tx_mask
== ATH_CHAINMASK_SEL_3X3
&&
456 ATH_RSSI_OUT(cm
->tx_avgrssi
) >=
457 ath_chainmask_sel_down_rssi_thres
) {
458 cm
->cur_tx_mask
= sc
->sc_tx_chainmask
;
460 /* Don't let another switch happen until
461 * this timer expires */
462 ath_chainmask_sel_timerstart(cm
);
464 /* Switch up from tx 2 to 3. */
465 else if (cm
->cur_tx_mask
== sc
->sc_tx_chainmask
&&
466 ATH_RSSI_OUT(cm
->tx_avgrssi
) <=
467 ath_chainmask_sel_up_rssi_thres
) {
468 cm
->cur_tx_mask
= ATH_CHAINMASK_SEL_3X3
;
470 /* Don't let another switch happen
471 * until this timer expires */
472 ath_chainmask_sel_timerstart(cm
);
476 return cm
->cur_tx_mask
;
480 * Update tx/rx chainmask. For legacy association,
481 * hard code chainmask to 1x1, for 11n association, use
482 * the chainmask configuration.
485 void ath_update_chainmask(struct ath_softc
*sc
, int is_ht
)
487 sc
->sc_flags
|= SC_OP_CHAINMASK_UPDATE
;
489 sc
->sc_tx_chainmask
= sc
->sc_ah
->ah_caps
.tx_chainmask
;
490 sc
->sc_rx_chainmask
= sc
->sc_ah
->ah_caps
.rx_chainmask
;
492 sc
->sc_tx_chainmask
= 1;
493 sc
->sc_rx_chainmask
= 1;
496 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: tx chmask: %d, rx chmask: %d\n",
497 __func__
, sc
->sc_tx_chainmask
, sc
->sc_rx_chainmask
);
507 * This routine brings the VAP out of the down state into a "listen" state
508 * where it waits for association requests. This is used in AP and AdHoc
512 int ath_vap_listen(struct ath_softc
*sc
, int if_id
)
514 struct ath_hal
*ah
= sc
->sc_ah
;
517 DECLARE_MAC_BUF(mac
);
519 avp
= sc
->sc_vaps
[if_id
];
521 DPRINTF(sc
, ATH_DBG_FATAL
, "%s: invalid interface id %u\n",
526 #ifdef CONFIG_SLOW_ANT_DIV
527 ath_slow_ant_div_stop(&sc
->sc_antdiv
);
530 /* update ratectrl about the new state */
531 ath_rate_newstate(sc
, avp
);
533 rfilt
= ath_calcrxfilter(sc
);
534 ath9k_hw_setrxfilter(ah
, rfilt
);
536 if (sc
->sc_ah
->ah_opmode
== ATH9K_M_STA
||
537 sc
->sc_ah
->ah_opmode
== ATH9K_M_IBSS
) {
538 memcpy(sc
->sc_curbssid
, ath_bcast_mac
, ETH_ALEN
);
539 ath9k_hw_write_associd(ah
, sc
->sc_curbssid
, sc
->sc_curaid
);
543 DPRINTF(sc
, ATH_DBG_CONFIG
,
544 "%s: RX filter 0x%x bssid %s aid 0x%x\n",
545 __func__
, rfilt
, print_mac(mac
,
546 sc
->sc_curbssid
), sc
->sc_curaid
);
550 * Disable BMISS interrupt when we're not associated
552 ath9k_hw_set_interrupts(ah
,
553 sc
->sc_imask
& ~(ATH9K_INT_SWBA
| ATH9K_INT_BMISS
));
554 sc
->sc_imask
&= ~(ATH9K_INT_SWBA
| ATH9K_INT_BMISS
);
555 /* need to reconfigure the beacons when it moves to RUN */
556 sc
->sc_flags
&= ~SC_OP_BEACONS
;
561 int ath_vap_attach(struct ath_softc
*sc
,
563 struct ieee80211_vif
*if_data
,
564 enum ath9k_opmode opmode
)
568 if (if_id
>= ATH_BCBUF
|| sc
->sc_vaps
[if_id
] != NULL
) {
569 DPRINTF(sc
, ATH_DBG_FATAL
,
570 "%s: Invalid interface id = %u\n", __func__
, if_id
);
577 case ATH9K_M_MONITOR
:
580 /* XXX not right, beacon buffer is allocated on RUN trans */
581 if (list_empty(&sc
->sc_bbuf
))
589 avp
= kmalloc(sizeof(struct ath_vap
), GFP_KERNEL
);
593 memzero(avp
, sizeof(struct ath_vap
));
594 avp
->av_if_data
= if_data
;
595 /* Set the VAP opmode */
596 avp
->av_opmode
= opmode
;
598 INIT_LIST_HEAD(&avp
->av_mcastq
.axq_q
);
599 INIT_LIST_HEAD(&avp
->av_mcastq
.axq_acq
);
600 spin_lock_init(&avp
->av_mcastq
.axq_lock
);
602 ath9k_hw_set_tsfadjust(sc
->sc_ah
, 1);
604 sc
->sc_vaps
[if_id
] = avp
;
606 /* Set the device opmode */
607 sc
->sc_ah
->ah_opmode
= opmode
;
609 /* default VAP configuration */
610 avp
->av_config
.av_fixed_rateset
= IEEE80211_FIXED_RATE_NONE
;
611 avp
->av_config
.av_fixed_retryset
= 0x03030303;
616 int ath_vap_detach(struct ath_softc
*sc
, int if_id
)
618 struct ath_hal
*ah
= sc
->sc_ah
;
621 avp
= sc
->sc_vaps
[if_id
];
623 DPRINTF(sc
, ATH_DBG_FATAL
, "%s: invalid interface id %u\n",
629 * Quiesce the hardware while we remove the vap. In
630 * particular we need to reclaim all references to the
631 * vap state by any frames pending on the tx queues.
633 * XXX can we do this w/o affecting other vap's?
635 ath9k_hw_set_interrupts(ah
, 0); /* disable interrupts */
636 ath_draintxq(sc
, false); /* stop xmit side */
637 ath_stoprecv(sc
); /* stop recv side */
638 ath_flushrecv(sc
); /* flush recv queue */
640 /* Reclaim any pending mcast bufs on the vap. */
641 ath_tx_draintxq(sc
, &avp
->av_mcastq
, false);
644 sc
->sc_vaps
[if_id
] = NULL
;
650 int ath_vap_config(struct ath_softc
*sc
,
651 int if_id
, struct ath_vap_config
*if_config
)
655 if (if_id
>= ATH_BCBUF
) {
656 DPRINTF(sc
, ATH_DBG_FATAL
,
657 "%s: Invalid interface id = %u\n", __func__
, if_id
);
661 avp
= sc
->sc_vaps
[if_id
];
665 memcpy(&avp
->av_config
, if_config
, sizeof(avp
->av_config
));
674 int ath_open(struct ath_softc
*sc
, struct ath9k_channel
*initial_chan
)
676 struct ath_hal
*ah
= sc
->sc_ah
;
679 enum ath9k_ht_macmode ht_macmode
= ath_cwm_macmode(sc
);
681 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: mode %d\n",
682 __func__
, sc
->sc_ah
->ah_opmode
);
685 * Stop anything previously setup. This is safe
686 * whether this is the first time through or not.
690 /* Initialize chanmask selection */
691 sc
->sc_tx_chainmask
= ah
->ah_caps
.tx_chainmask
;
692 sc
->sc_rx_chainmask
= ah
->ah_caps
.rx_chainmask
;
694 /* Reset SERDES registers */
695 ath9k_hw_configpcipowersave(ah
, 0);
698 * The basic interface to setting the hardware in a good
699 * state is ``reset''. On return the hardware is known to
700 * be powered up and with interrupts disabled. This must
701 * be followed by initialization of the appropriate bits
702 * and then setup of the interrupt mask.
705 spin_lock_bh(&sc
->sc_resetlock
);
706 if (!ath9k_hw_reset(ah
, initial_chan
, ht_macmode
,
707 sc
->sc_tx_chainmask
, sc
->sc_rx_chainmask
,
708 sc
->sc_ht_extprotspacing
, false, &status
)) {
709 DPRINTF(sc
, ATH_DBG_FATAL
,
710 "%s: unable to reset hardware; hal status %u "
711 "(freq %u flags 0x%x)\n", __func__
, status
,
712 initial_chan
->channel
, initial_chan
->channelFlags
);
714 spin_unlock_bh(&sc
->sc_resetlock
);
717 spin_unlock_bh(&sc
->sc_resetlock
);
719 * This is needed only to setup initial state
720 * but it's best done after a reset.
722 ath_update_txpow(sc
);
725 * Setup the hardware after reset:
726 * The receive engine is set going.
727 * Frame transmit is handled entirely
728 * in the frame output path; there's nothing to do
729 * here except setup the interrupt mask.
731 if (ath_startrecv(sc
) != 0) {
732 DPRINTF(sc
, ATH_DBG_FATAL
,
733 "%s: unable to start recv logic\n", __func__
);
737 /* Setup our intr mask. */
738 sc
->sc_imask
= ATH9K_INT_RX
| ATH9K_INT_TX
739 | ATH9K_INT_RXEOL
| ATH9K_INT_RXORN
740 | ATH9K_INT_FATAL
| ATH9K_INT_GLOBAL
;
742 if (ah
->ah_caps
.hw_caps
& ATH9K_HW_CAP_GTT
)
743 sc
->sc_imask
|= ATH9K_INT_GTT
;
745 if (ah
->ah_caps
.hw_caps
& ATH9K_HW_CAP_HT
)
746 sc
->sc_imask
|= ATH9K_INT_CST
;
749 * Enable MIB interrupts when there are hardware phy counters.
750 * Note we only do this (at the moment) for station mode.
752 if (ath9k_hw_phycounters(ah
) &&
753 ((sc
->sc_ah
->ah_opmode
== ATH9K_M_STA
) ||
754 (sc
->sc_ah
->ah_opmode
== ATH9K_M_IBSS
)))
755 sc
->sc_imask
|= ATH9K_INT_MIB
;
757 * Some hardware processes the TIM IE and fires an
758 * interrupt when the TIM bit is set. For hardware
759 * that does, if not overridden by configuration,
760 * enable the TIM interrupt when operating as station.
762 if ((ah
->ah_caps
.hw_caps
& ATH9K_HW_CAP_ENHANCEDPM
) &&
763 (sc
->sc_ah
->ah_opmode
== ATH9K_M_STA
) &&
764 !sc
->sc_config
.swBeaconProcess
)
765 sc
->sc_imask
|= ATH9K_INT_TIM
;
767 * Don't enable interrupts here as we've not yet built our
768 * vap and node data structures, which will be needed as soon
769 * as we start receiving.
771 ath_setcurmode(sc
, ath_chan2mode(initial_chan
));
773 /* XXX: we must make sure h/w is ready and clear invalid flag
774 * before turning on interrupt. */
775 sc
->sc_flags
&= ~SC_OP_INVALID
;
780 int ath_reset(struct ath_softc
*sc
, bool retry_tx
)
782 struct ath_hal
*ah
= sc
->sc_ah
;
785 enum ath9k_ht_macmode ht_macmode
= ath_cwm_macmode(sc
);
787 ath9k_hw_set_interrupts(ah
, 0); /* disable interrupts */
788 ath_draintxq(sc
, retry_tx
); /* stop xmit */
789 ath_stoprecv(sc
); /* stop recv */
790 ath_flushrecv(sc
); /* flush recv queue */
793 spin_lock_bh(&sc
->sc_resetlock
);
794 if (!ath9k_hw_reset(ah
, sc
->sc_ah
->ah_curchan
,
796 sc
->sc_tx_chainmask
, sc
->sc_rx_chainmask
,
797 sc
->sc_ht_extprotspacing
, false, &status
)) {
798 DPRINTF(sc
, ATH_DBG_FATAL
,
799 "%s: unable to reset hardware; hal status %u\n",
803 spin_unlock_bh(&sc
->sc_resetlock
);
805 if (ath_startrecv(sc
) != 0) /* restart recv */
806 DPRINTF(sc
, ATH_DBG_FATAL
,
807 "%s: unable to start recv logic\n", __func__
);
810 * We may be doing a reset in response to a request
811 * that changes the channel so update any state that
812 * might change as a result.
814 ath_setcurmode(sc
, ath_chan2mode(sc
->sc_ah
->ah_curchan
));
816 ath_update_txpow(sc
);
818 if (sc
->sc_flags
& SC_OP_BEACONS
)
819 ath_beacon_config(sc
, ATH_IF_ID_ANY
); /* restart beacons */
821 ath9k_hw_set_interrupts(ah
, sc
->sc_imask
);
823 /* Restart the txq */
826 for (i
= 0; i
< ATH9K_NUM_TX_QUEUES
; i
++) {
827 if (ATH_TXQ_SETUP(sc
, i
)) {
828 spin_lock_bh(&sc
->sc_txq
[i
].axq_lock
);
829 ath_txq_schedule(sc
, &sc
->sc_txq
[i
]);
830 spin_unlock_bh(&sc
->sc_txq
[i
].axq_lock
);
838 int ath_suspend(struct ath_softc
*sc
)
840 struct ath_hal
*ah
= sc
->sc_ah
;
842 /* No I/O if device has been surprise removed */
843 if (sc
->sc_flags
& SC_OP_INVALID
)
846 /* Shut off the interrupt before setting sc->sc_invalid to '1' */
847 ath9k_hw_set_interrupts(ah
, 0);
849 /* XXX: we must make sure h/w will not generate any interrupt
850 * before setting the invalid flag. */
851 sc
->sc_flags
|= SC_OP_INVALID
;
853 /* disable HAL and put h/w to sleep */
854 ath9k_hw_disable(sc
->sc_ah
);
856 ath9k_hw_configpcipowersave(sc
->sc_ah
, 1);
861 /* Interrupt handler. Most of the actual processing is deferred.
862 * It's the caller's responsibility to ensure the chip is awake. */
864 irqreturn_t
ath_isr(int irq
, void *dev
)
866 struct ath_softc
*sc
= dev
;
867 struct ath_hal
*ah
= sc
->sc_ah
;
868 enum ath9k_int status
;
872 if (sc
->sc_flags
& SC_OP_INVALID
) {
874 * The hardware is not ready/present, don't
875 * touch anything. Note this can happen early
876 * on if the IRQ is shared.
880 if (!ath9k_hw_intrpend(ah
)) { /* shared irq, not for us */
885 * Figure out the reason(s) for the interrupt. Note
886 * that the hal returns a pseudo-ISR that may include
887 * bits we haven't explicitly enabled so we mask the
888 * value to insure we only process bits we requested.
890 ath9k_hw_getisr(ah
, &status
); /* NB: clears ISR too */
892 status
&= sc
->sc_imask
; /* discard unasked-for bits */
895 * If there are no status bits set, then this interrupt was not
896 * for me (should have been caught above).
902 sc
->sc_intrstatus
= status
;
904 if (status
& ATH9K_INT_FATAL
) {
905 /* need a chip reset */
907 } else if (status
& ATH9K_INT_RXORN
) {
908 /* need a chip reset */
911 if (status
& ATH9K_INT_SWBA
) {
912 /* schedule a tasklet for beacon handling */
913 tasklet_schedule(&sc
->bcon_tasklet
);
915 if (status
& ATH9K_INT_RXEOL
) {
917 * NB: the hardware should re-read the link when
918 * RXE bit is written, but it doesn't work
919 * at least on older hardware revs.
924 if (status
& ATH9K_INT_TXURN
)
925 /* bump tx trigger level */
926 ath9k_hw_updatetxtriglevel(ah
, true);
927 /* XXX: optimize this */
928 if (status
& ATH9K_INT_RX
)
930 if (status
& ATH9K_INT_TX
)
932 if (status
& ATH9K_INT_BMISS
)
934 /* carrier sense timeout */
935 if (status
& ATH9K_INT_CST
)
937 if (status
& ATH9K_INT_MIB
) {
939 * Disable interrupts until we service the MIB
940 * interrupt; otherwise it will continue to
943 ath9k_hw_set_interrupts(ah
, 0);
945 * Let the hal handle the event. We assume
946 * it will clear whatever condition caused
949 ath9k_hw_procmibevent(ah
, &sc
->sc_halstats
);
950 ath9k_hw_set_interrupts(ah
, sc
->sc_imask
);
952 if (status
& ATH9K_INT_TIM_TIMER
) {
953 if (!(ah
->ah_caps
.hw_caps
&
954 ATH9K_HW_CAP_AUTOSLEEP
)) {
955 /* Clear RxAbort bit so that we can
957 ath9k_hw_setrxabort(ah
, 0);
965 /* turn off every interrupt except SWBA */
966 ath9k_hw_set_interrupts(ah
, (sc
->sc_imask
& ATH9K_INT_SWBA
));
967 tasklet_schedule(&sc
->intr_tq
);
973 /* Deferred interrupt processing */
975 static void ath9k_tasklet(unsigned long data
)
977 struct ath_softc
*sc
= (struct ath_softc
*)data
;
978 u32 status
= sc
->sc_intrstatus
;
980 if (status
& ATH9K_INT_FATAL
) {
981 /* need a chip reset */
982 ath_reset(sc
, false);
987 (ATH9K_INT_RX
| ATH9K_INT_RXEOL
| ATH9K_INT_RXORN
)) {
988 /* XXX: fill me in */
990 if (status & ATH9K_INT_RXORN) {
992 if (status & ATH9K_INT_RXEOL) {
995 spin_lock_bh(&sc
->sc_rxflushlock
);
996 ath_rx_tasklet(sc
, 0);
997 spin_unlock_bh(&sc
->sc_rxflushlock
);
999 /* XXX: optimize this */
1000 if (status
& ATH9K_INT_TX
)
1002 /* XXX: fill me in */
1004 if (status & ATH9K_INT_BMISS) {
1006 if (status & (ATH9K_INT_TIM | ATH9K_INT_DTIMSYNC)) {
1007 if (status & ATH9K_INT_TIM) {
1009 if (status & ATH9K_INT_DTIMSYNC) {
1015 /* re-enable hardware interrupt */
1016 ath9k_hw_set_interrupts(sc
->sc_ah
, sc
->sc_imask
);
1019 int ath_init(u16 devid
, struct ath_softc
*sc
)
1021 struct ath_hal
*ah
= NULL
;
1027 /* XXX: hardware will not be ready until ath_open() being called */
1028 sc
->sc_flags
|= SC_OP_INVALID
;
1030 sc
->sc_debug
= DBG_DEFAULT
;
1031 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: devid 0x%x\n", __func__
, devid
);
1033 /* Initialize tasklet */
1034 tasklet_init(&sc
->intr_tq
, ath9k_tasklet
, (unsigned long)sc
);
1035 tasklet_init(&sc
->bcon_tasklet
, ath9k_beacon_tasklet
,
1039 * Cache line size is used to size and align various
1040 * structures used to communicate with the hardware.
1042 bus_read_cachesize(sc
, &csz
);
1043 /* XXX assert csz is non-zero */
1044 sc
->sc_cachelsz
= csz
<< 2; /* convert to bytes */
1046 spin_lock_init(&sc
->sc_resetlock
);
1048 ah
= ath9k_hw_attach(devid
, sc
, sc
->mem
, &status
);
1050 DPRINTF(sc
, ATH_DBG_FATAL
,
1051 "%s: unable to attach hardware; HAL status %u\n",
1058 /* Get the chipset-specific aggr limit. */
1059 sc
->sc_rtsaggrlimit
= ah
->ah_caps
.rts_aggr_limit
;
1061 /* Get the hardware key cache size. */
1062 sc
->sc_keymax
= ah
->ah_caps
.keycache_size
;
1063 if (sc
->sc_keymax
> ATH_KEYMAX
) {
1064 DPRINTF(sc
, ATH_DBG_KEYCACHE
,
1065 "%s: Warning, using only %u entries in %u key cache\n",
1066 __func__
, ATH_KEYMAX
, sc
->sc_keymax
);
1067 sc
->sc_keymax
= ATH_KEYMAX
;
1071 * Reset the key cache since some parts do not
1072 * reset the contents on initial power up.
1074 for (i
= 0; i
< sc
->sc_keymax
; i
++)
1075 ath9k_hw_keyreset(ah
, (u16
) i
);
1077 * Mark key cache slots associated with global keys
1078 * as in use. If we knew TKIP was not to be used we
1079 * could leave the +32, +64, and +32+64 slots free.
1080 * XXX only for splitmic.
1082 for (i
= 0; i
< IEEE80211_WEP_NKID
; i
++) {
1083 set_bit(i
, sc
->sc_keymap
);
1084 set_bit(i
+ 32, sc
->sc_keymap
);
1085 set_bit(i
+ 64, sc
->sc_keymap
);
1086 set_bit(i
+ 32 + 64, sc
->sc_keymap
);
1089 * Collect the channel list using the default country
1090 * code and including outdoor channels. The 802.11 layer
1091 * is resposible for filtering this list based on settings
1092 * like the phy mode.
1094 rd
= ah
->ah_currentRD
;
1096 error
= ath_setup_channels(sc
);
1100 /* default to STA mode */
1101 sc
->sc_ah
->ah_opmode
= ATH9K_M_MONITOR
;
1103 /* Setup rate tables */
1105 ath_setup_rates(sc
, IEEE80211_BAND_2GHZ
);
1106 ath_setup_rates(sc
, IEEE80211_BAND_5GHZ
);
1108 /* NB: setup here so ath_rate_update is happy */
1109 ath_setcurmode(sc
, ATH9K_MODE_11A
);
1112 * Allocate hardware transmit queues: one queue for
1113 * beacon frames and one data queue for each QoS
1114 * priority. Note that the hal handles reseting
1115 * these queues at the needed time.
1117 sc
->sc_bhalq
= ath_beaconq_setup(ah
);
1118 if (sc
->sc_bhalq
== -1) {
1119 DPRINTF(sc
, ATH_DBG_FATAL
,
1120 "%s: unable to setup a beacon xmit queue\n", __func__
);
1124 sc
->sc_cabq
= ath_txq_setup(sc
, ATH9K_TX_QUEUE_CAB
, 0);
1125 if (sc
->sc_cabq
== NULL
) {
1126 DPRINTF(sc
, ATH_DBG_FATAL
,
1127 "%s: unable to setup CAB xmit queue\n", __func__
);
1132 sc
->sc_config
.cabqReadytime
= ATH_CABQ_READY_TIME
;
1133 ath_cabq_update(sc
);
1135 for (i
= 0; i
< ARRAY_SIZE(sc
->sc_haltype2q
); i
++)
1136 sc
->sc_haltype2q
[i
] = -1;
1138 /* Setup data queues */
1139 /* NB: ensure BK queue is the lowest priority h/w queue */
1140 if (!ath_tx_setup(sc
, ATH9K_WME_AC_BK
)) {
1141 DPRINTF(sc
, ATH_DBG_FATAL
,
1142 "%s: unable to setup xmit queue for BK traffic\n",
1148 if (!ath_tx_setup(sc
, ATH9K_WME_AC_BE
)) {
1149 DPRINTF(sc
, ATH_DBG_FATAL
,
1150 "%s: unable to setup xmit queue for BE traffic\n",
1155 if (!ath_tx_setup(sc
, ATH9K_WME_AC_VI
)) {
1156 DPRINTF(sc
, ATH_DBG_FATAL
,
1157 "%s: unable to setup xmit queue for VI traffic\n",
1162 if (!ath_tx_setup(sc
, ATH9K_WME_AC_VO
)) {
1163 DPRINTF(sc
, ATH_DBG_FATAL
,
1164 "%s: unable to setup xmit queue for VO traffic\n",
1170 sc
->sc_rc
= ath_rate_attach(ah
);
1171 if (sc
->sc_rc
== NULL
) {
1176 if (ath9k_hw_getcapability(ah
, ATH9K_CAP_CIPHER
,
1177 ATH9K_CIPHER_TKIP
, NULL
)) {
1179 * Whether we should enable h/w TKIP MIC.
1180 * XXX: if we don't support WME TKIP MIC, then we wouldn't
1181 * report WMM capable, so it's always safe to turn on
1182 * TKIP MIC in this case.
1184 ath9k_hw_setcapability(sc
->sc_ah
, ATH9K_CAP_TKIP_MIC
,
1189 * Check whether the separate key cache entries
1190 * are required to handle both tx+rx MIC keys.
1191 * With split mic keys the number of stations is limited
1192 * to 27 otherwise 59.
1194 if (ath9k_hw_getcapability(ah
, ATH9K_CAP_CIPHER
,
1195 ATH9K_CIPHER_TKIP
, NULL
)
1196 && ath9k_hw_getcapability(ah
, ATH9K_CAP_CIPHER
,
1197 ATH9K_CIPHER_MIC
, NULL
)
1198 && ath9k_hw_getcapability(ah
, ATH9K_CAP_TKIP_SPLIT
,
1200 sc
->sc_splitmic
= 1;
1202 /* turn on mcast key search if possible */
1203 if (!ath9k_hw_getcapability(ah
, ATH9K_CAP_MCAST_KEYSRCH
, 0, NULL
))
1204 (void)ath9k_hw_setcapability(ah
, ATH9K_CAP_MCAST_KEYSRCH
, 1,
1207 sc
->sc_config
.txpowlimit
= ATH_TXPOWER_MAX
;
1208 sc
->sc_config
.txpowlimit_override
= 0;
1210 /* 11n Capabilities */
1211 if (ah
->ah_caps
.hw_caps
& ATH9K_HW_CAP_HT
) {
1212 sc
->sc_flags
|= SC_OP_TXAGGR
;
1213 sc
->sc_flags
|= SC_OP_RXAGGR
;
1216 sc
->sc_tx_chainmask
= ah
->ah_caps
.tx_chainmask
;
1217 sc
->sc_rx_chainmask
= ah
->ah_caps
.rx_chainmask
;
1219 /* Configuration for rx chain detection */
1220 sc
->sc_rxchaindetect_ref
= 0;
1221 sc
->sc_rxchaindetect_thresh5GHz
= 35;
1222 sc
->sc_rxchaindetect_thresh2GHz
= 35;
1223 sc
->sc_rxchaindetect_delta5GHz
= 30;
1224 sc
->sc_rxchaindetect_delta2GHz
= 30;
1226 ath9k_hw_setcapability(ah
, ATH9K_CAP_DIVERSITY
, 1, true, NULL
);
1227 sc
->sc_defant
= ath9k_hw_getdefantenna(ah
);
1229 ath9k_hw_getmac(ah
, sc
->sc_myaddr
);
1230 if (ah
->ah_caps
.hw_caps
& ATH9K_HW_CAP_BSSIDMASK
) {
1231 ath9k_hw_getbssidmask(ah
, sc
->sc_bssidmask
);
1232 ATH_SET_VAP_BSSID_MASK(sc
->sc_bssidmask
);
1233 ath9k_hw_setbssidmask(ah
, sc
->sc_bssidmask
);
1235 sc
->sc_slottime
= ATH9K_SLOT_TIME_9
; /* default to short slot time */
1237 /* initialize beacon slots */
1238 for (i
= 0; i
< ARRAY_SIZE(sc
->sc_bslot
); i
++)
1239 sc
->sc_bslot
[i
] = ATH_IF_ID_ANY
;
1241 /* save MISC configurations */
1242 sc
->sc_config
.swBeaconProcess
= 1;
1244 #ifdef CONFIG_SLOW_ANT_DIV
1245 /* range is 40 - 255, we use something in the middle */
1246 ath_slow_ant_div_init(&sc
->sc_antdiv
, sc
, 0x127);
1251 /* cleanup tx queues */
1252 for (i
= 0; i
< ATH9K_NUM_TX_QUEUES
; i
++)
1253 if (ATH_TXQ_SETUP(sc
, i
))
1254 ath_tx_cleanupq(sc
, &sc
->sc_txq
[i
]);
1257 ath9k_hw_detach(ah
);
1261 void ath_deinit(struct ath_softc
*sc
)
1263 struct ath_hal
*ah
= sc
->sc_ah
;
1266 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s\n", __func__
);
1269 if (!(sc
->sc_flags
& SC_OP_INVALID
))
1270 ath9k_hw_setpower(sc
->sc_ah
, ATH9K_PM_AWAKE
);
1271 ath_rate_detach(sc
->sc_rc
);
1272 /* cleanup tx queues */
1273 for (i
= 0; i
< ATH9K_NUM_TX_QUEUES
; i
++)
1274 if (ATH_TXQ_SETUP(sc
, i
))
1275 ath_tx_cleanupq(sc
, &sc
->sc_txq
[i
]);
1276 ath9k_hw_detach(ah
);
1279 /*******************/
1280 /* Node Management */
1281 /*******************/
1283 struct ath_node
*ath_node_attach(struct ath_softc
*sc
, u8
*addr
, int if_id
)
1285 struct ath_vap
*avp
;
1286 struct ath_node
*an
;
1287 DECLARE_MAC_BUF(mac
);
1289 avp
= sc
->sc_vaps
[if_id
];
1290 ASSERT(avp
!= NULL
);
1292 /* mac80211 sta_notify callback is from an IRQ context, so no sleep */
1293 an
= kmalloc(sizeof(struct ath_node
), GFP_ATOMIC
);
1296 memzero(an
, sizeof(*an
));
1299 memcpy(an
->an_addr
, addr
, ETH_ALEN
);
1300 atomic_set(&an
->an_refcnt
, 1);
1302 /* set up per-node tx/rx state */
1303 ath_tx_node_init(sc
, an
);
1304 ath_rx_node_init(sc
, an
);
1306 ath_chainmask_sel_init(sc
, an
);
1307 ath_chainmask_sel_timerstart(&an
->an_chainmask_sel
);
1308 list_add(&an
->list
, &sc
->node_list
);
1313 void ath_node_detach(struct ath_softc
*sc
, struct ath_node
*an
, bool bh_flag
)
1315 unsigned long flags
;
1317 DECLARE_MAC_BUF(mac
);
1319 ath_chainmask_sel_timerstop(&an
->an_chainmask_sel
);
1320 an
->an_flags
|= ATH_NODE_CLEAN
;
1321 ath_tx_node_cleanup(sc
, an
, bh_flag
);
1322 ath_rx_node_cleanup(sc
, an
);
1324 ath_tx_node_free(sc
, an
);
1325 ath_rx_node_free(sc
, an
);
1327 spin_lock_irqsave(&sc
->node_lock
, flags
);
1329 list_del(&an
->list
);
1331 spin_unlock_irqrestore(&sc
->node_lock
, flags
);
1336 /* Finds a node and increases the refcnt if found */
1338 struct ath_node
*ath_node_get(struct ath_softc
*sc
, u8
*addr
)
1340 struct ath_node
*an
= NULL
, *an_found
= NULL
;
1342 if (list_empty(&sc
->node_list
)) /* FIXME */
1344 list_for_each_entry(an
, &sc
->node_list
, list
) {
1345 if (!compare_ether_addr(an
->an_addr
, addr
)) {
1346 atomic_inc(&an
->an_refcnt
);
1355 /* Decrements the refcnt and if it drops to zero, detach the node */
1357 void ath_node_put(struct ath_softc
*sc
, struct ath_node
*an
, bool bh_flag
)
1359 if (atomic_dec_and_test(&an
->an_refcnt
))
1360 ath_node_detach(sc
, an
, bh_flag
);
1363 /* Finds a node, doesn't increment refcnt. Caller must hold sc->node_lock */
1364 struct ath_node
*ath_node_find(struct ath_softc
*sc
, u8
*addr
)
1366 struct ath_node
*an
= NULL
, *an_found
= NULL
;
1368 if (list_empty(&sc
->node_list
))
1371 list_for_each_entry(an
, &sc
->node_list
, list
)
1372 if (!compare_ether_addr(an
->an_addr
, addr
)) {
1383 * Setup driver-specific state for a newly associated node. This routine
1384 * really only applies if compression or XR are enabled, there is no code
1385 * covering any other cases.
1388 void ath_newassoc(struct ath_softc
*sc
,
1389 struct ath_node
*an
, int isnew
, int isuapsd
)
1393 /* if station reassociates, tear down the aggregation state. */
1395 for (tidno
= 0; tidno
< WME_NUM_TID
; tidno
++) {
1396 if (sc
->sc_flags
& SC_OP_TXAGGR
)
1397 ath_tx_aggr_teardown(sc
, an
, tidno
);
1398 if (sc
->sc_flags
& SC_OP_RXAGGR
)
1399 ath_rx_aggr_teardown(sc
, an
, tidno
);
1409 void ath_key_reset(struct ath_softc
*sc
, u16 keyix
, int freeslot
)
1411 ath9k_hw_keyreset(sc
->sc_ah
, keyix
);
1413 clear_bit(keyix
, sc
->sc_keymap
);
1416 int ath_keyset(struct ath_softc
*sc
,
1418 struct ath9k_keyval
*hk
,
1419 const u8 mac
[ETH_ALEN
])
1423 status
= ath9k_hw_set_keycache_entry(sc
->sc_ah
,
1424 keyix
, hk
, mac
, false);
1426 return status
!= false;
1429 /***********************/
1430 /* TX Power/Regulatory */
1431 /***********************/
1434 * Set Transmit power in HAL
1436 * This routine makes the actual HAL calls to set the new transmit power
1440 void ath_update_txpow(struct ath_softc
*sc
)
1442 struct ath_hal
*ah
= sc
->sc_ah
;
1445 if (sc
->sc_curtxpow
!= sc
->sc_config
.txpowlimit
) {
1446 ath9k_hw_set_txpowerlimit(ah
, sc
->sc_config
.txpowlimit
);
1447 /* read back in case value is clamped */
1448 ath9k_hw_getcapability(ah
, ATH9K_CAP_TXPOW
, 1, &txpow
);
1449 sc
->sc_curtxpow
= txpow
;
1453 /* Return the current country and domain information */
1454 void ath_get_currentCountry(struct ath_softc
*sc
,
1455 struct ath9k_country_entry
*ctry
)
1457 ath9k_regd_get_current_country(sc
->sc_ah
, ctry
);
1459 /* If HAL not specific yet, since it is band dependent,
1460 * use the one we passed in. */
1461 if (ctry
->countryCode
== CTRY_DEFAULT
) {
1464 } else if (ctry
->iso
[0] && ctry
->iso
[1]) {
1465 if (!ctry
->iso
[2]) {
1474 /**************************/
1475 /* Slow Antenna Diversity */
1476 /**************************/
1478 void ath_slow_ant_div_init(struct ath_antdiv
*antdiv
,
1479 struct ath_softc
*sc
,
1484 /* antdivf_rssitrig can range from 40 - 0xff */
1485 trig
= (rssitrig
> 0xff) ? 0xff : rssitrig
;
1486 trig
= (rssitrig
< 40) ? 40 : rssitrig
;
1488 antdiv
->antdiv_sc
= sc
;
1489 antdiv
->antdivf_rssitrig
= trig
;
1492 void ath_slow_ant_div_start(struct ath_antdiv
*antdiv
,
1496 antdiv
->antdiv_num_antcfg
=
1497 num_antcfg
< ATH_ANT_DIV_MAX_CFG
?
1498 num_antcfg
: ATH_ANT_DIV_MAX_CFG
;
1499 antdiv
->antdiv_state
= ATH_ANT_DIV_IDLE
;
1500 antdiv
->antdiv_curcfg
= 0;
1501 antdiv
->antdiv_bestcfg
= 0;
1502 antdiv
->antdiv_laststatetsf
= 0;
1504 memcpy(antdiv
->antdiv_bssid
, bssid
, sizeof(antdiv
->antdiv_bssid
));
1506 antdiv
->antdiv_start
= 1;
1509 void ath_slow_ant_div_stop(struct ath_antdiv
*antdiv
)
1511 antdiv
->antdiv_start
= 0;
1514 static int32_t ath_find_max_val(int32_t *val
,
1515 u8 num_val
, u8
*max_index
)
1517 u32 MaxVal
= *val
++;
1521 while (++cur_index
< num_val
) {
1522 if (*val
> MaxVal
) {
1524 *max_index
= cur_index
;
1533 void ath_slow_ant_div(struct ath_antdiv
*antdiv
,
1534 struct ieee80211_hdr
*hdr
,
1535 struct ath_rx_status
*rx_stats
)
1537 struct ath_softc
*sc
= antdiv
->antdiv_sc
;
1538 struct ath_hal
*ah
= sc
->sc_ah
;
1540 u8 bestcfg
, curcfg
= antdiv
->antdiv_curcfg
;
1541 __le16 fc
= hdr
->frame_control
;
1543 if (antdiv
->antdiv_start
&& ieee80211_is_beacon(fc
)
1544 && !compare_ether_addr(hdr
->addr3
, antdiv
->antdiv_bssid
)) {
1545 antdiv
->antdiv_lastbrssi
[curcfg
] = rx_stats
->rs_rssi
;
1546 antdiv
->antdiv_lastbtsf
[curcfg
] = ath9k_hw_gettsf64(sc
->sc_ah
);
1547 curtsf
= antdiv
->antdiv_lastbtsf
[curcfg
];
1552 switch (antdiv
->antdiv_state
) {
1553 case ATH_ANT_DIV_IDLE
:
1554 if ((antdiv
->antdiv_lastbrssi
[curcfg
] <
1555 antdiv
->antdivf_rssitrig
)
1556 && ((curtsf
- antdiv
->antdiv_laststatetsf
) >
1557 ATH_ANT_DIV_MIN_IDLE_US
)) {
1560 if (curcfg
== antdiv
->antdiv_num_antcfg
)
1563 if (!ath9k_hw_select_antconfig(ah
, curcfg
)) {
1564 antdiv
->antdiv_bestcfg
= antdiv
->antdiv_curcfg
;
1565 antdiv
->antdiv_curcfg
= curcfg
;
1566 antdiv
->antdiv_laststatetsf
= curtsf
;
1567 antdiv
->antdiv_state
= ATH_ANT_DIV_SCAN
;
1572 case ATH_ANT_DIV_SCAN
:
1573 if ((curtsf
- antdiv
->antdiv_laststatetsf
) <
1574 ATH_ANT_DIV_MIN_SCAN_US
)
1578 if (curcfg
== antdiv
->antdiv_num_antcfg
)
1581 if (curcfg
== antdiv
->antdiv_bestcfg
) {
1582 ath_find_max_val(antdiv
->antdiv_lastbrssi
,
1583 antdiv
->antdiv_num_antcfg
, &bestcfg
);
1584 if (!ath9k_hw_select_antconfig(ah
, bestcfg
)) {
1585 antdiv
->antdiv_bestcfg
= bestcfg
;
1586 antdiv
->antdiv_curcfg
= bestcfg
;
1587 antdiv
->antdiv_laststatetsf
= curtsf
;
1588 antdiv
->antdiv_state
= ATH_ANT_DIV_IDLE
;
1591 if (!ath9k_hw_select_antconfig(ah
, curcfg
)) {
1592 antdiv
->antdiv_curcfg
= curcfg
;
1593 antdiv
->antdiv_laststatetsf
= curtsf
;
1594 antdiv
->antdiv_state
= ATH_ANT_DIV_SCAN
;
1602 /***********************/
1603 /* Descriptor Handling */
1604 /***********************/
1607 * Set up DMA descriptors
1609 * This function will allocate both the DMA descriptor structure, and the
1610 * buffers it contains. These are used to contain the descriptors used
1614 int ath_descdma_setup(struct ath_softc
*sc
,
1615 struct ath_descdma
*dd
,
1616 struct list_head
*head
,
1621 #define DS2PHYS(_dd, _ds) \
1622 ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
1623 #define ATH_DESC_4KB_BOUND_CHECK(_daddr) ((((_daddr) & 0xFFF) > 0xF7F) ? 1 : 0)
1624 #define ATH_DESC_4KB_BOUND_NUM_SKIPPED(_len) ((_len) / 4096)
1626 struct ath_desc
*ds
;
1628 int i
, bsize
, error
;
1630 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: %s DMA: %u buffers %u desc/buf\n",
1631 __func__
, name
, nbuf
, ndesc
);
1633 /* ath_desc must be a multiple of DWORDs */
1634 if ((sizeof(struct ath_desc
) % 4) != 0) {
1635 DPRINTF(sc
, ATH_DBG_FATAL
, "%s: ath_desc not DWORD aligned\n",
1637 ASSERT((sizeof(struct ath_desc
) % 4) == 0);
1643 dd
->dd_desc_len
= sizeof(struct ath_desc
) * nbuf
* ndesc
;
1646 * Need additional DMA memory because we can't use
1647 * descriptors that cross the 4K page boundary. Assume
1648 * one skipped descriptor per 4K page.
1650 if (!(sc
->sc_ah
->ah_caps
.hw_caps
& ATH9K_HW_CAP_4KB_SPLITTRANS
)) {
1652 ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd
->dd_desc_len
);
1655 while (ndesc_skipped
) {
1656 dma_len
= ndesc_skipped
* sizeof(struct ath_desc
);
1657 dd
->dd_desc_len
+= dma_len
;
1659 ndesc_skipped
= ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len
);
1663 /* allocate descriptors */
1664 dd
->dd_desc
= pci_alloc_consistent(sc
->pdev
,
1666 &dd
->dd_desc_paddr
);
1667 if (dd
->dd_desc
== NULL
) {
1672 DPRINTF(sc
, ATH_DBG_CONFIG
, "%s: %s DMA map: %p (%u) -> %llx (%u)\n",
1673 __func__
, dd
->dd_name
, ds
, (u32
) dd
->dd_desc_len
,
1674 ito64(dd
->dd_desc_paddr
), /*XXX*/(u32
) dd
->dd_desc_len
);
1676 /* allocate buffers */
1677 bsize
= sizeof(struct ath_buf
) * nbuf
;
1678 bf
= kmalloc(bsize
, GFP_KERNEL
);
1686 INIT_LIST_HEAD(head
);
1687 for (i
= 0; i
< nbuf
; i
++, bf
++, ds
+= ndesc
) {
1689 bf
->bf_daddr
= DS2PHYS(dd
, ds
);
1691 if (!(sc
->sc_ah
->ah_caps
.hw_caps
&
1692 ATH9K_HW_CAP_4KB_SPLITTRANS
)) {
1694 * Skip descriptor addresses which can cause 4KB
1695 * boundary crossing (addr + length) with a 32 dword
1698 while (ATH_DESC_4KB_BOUND_CHECK(bf
->bf_daddr
)) {
1699 ASSERT((caddr_t
) bf
->bf_desc
<
1700 ((caddr_t
) dd
->dd_desc
+
1705 bf
->bf_daddr
= DS2PHYS(dd
, ds
);
1708 list_add_tail(&bf
->list
, head
);
1712 pci_free_consistent(sc
->pdev
,
1713 dd
->dd_desc_len
, dd
->dd_desc
, dd
->dd_desc_paddr
);
1715 memzero(dd
, sizeof(*dd
));
1717 #undef ATH_DESC_4KB_BOUND_CHECK
1718 #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED
1723 * Cleanup DMA descriptors
1725 * This function will free the DMA block that was allocated for the descriptor
1726 * pool. Since this was allocated as one "chunk", it is freed in the same
1730 void ath_descdma_cleanup(struct ath_softc
*sc
,
1731 struct ath_descdma
*dd
,
1732 struct list_head
*head
)
1734 /* Free memory associated with descriptors */
1735 pci_free_consistent(sc
->pdev
,
1736 dd
->dd_desc_len
, dd
->dd_desc
, dd
->dd_desc_paddr
);
1738 INIT_LIST_HEAD(head
);
1739 kfree(dd
->dd_bufptr
);
1740 memzero(dd
, sizeof(*dd
));
1747 int ath_get_hal_qnum(u16 queue
, struct ath_softc
*sc
)
1753 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_VO
];
1756 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_VI
];
1759 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_BE
];
1762 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_BK
];
1765 qnum
= sc
->sc_haltype2q
[ATH9K_WME_AC_BE
];
1772 int ath_get_mac80211_qnum(u32 queue
, struct ath_softc
*sc
)
1777 case ATH9K_WME_AC_VO
:
1780 case ATH9K_WME_AC_VI
:
1783 case ATH9K_WME_AC_BE
:
1786 case ATH9K_WME_AC_BK
:
1799 * Expand time stamp to TSF
1801 * Extend 15-bit time stamp from rx descriptor to
1802 * a full 64-bit TSF using the current h/w TSF.
1805 u64
ath_extend_tsf(struct ath_softc
*sc
, u32 rstamp
)
1809 tsf
= ath9k_hw_gettsf64(sc
->sc_ah
);
1810 if ((tsf
& 0x7fff) < rstamp
)
1812 return (tsf
& ~0x7fff) | rstamp
;
1816 * Set Default Antenna
1818 * Call into the HAL to set the default antenna to use. Not really valid for
1822 void ath_setdefantenna(void *context
, u32 antenna
)
1824 struct ath_softc
*sc
= (struct ath_softc
*)context
;
1825 struct ath_hal
*ah
= sc
->sc_ah
;
1827 /* XXX block beacon interrupts */
1828 ath9k_hw_setantenna(ah
, antenna
);
1829 sc
->sc_defant
= antenna
;
1830 sc
->sc_rxotherant
= 0;
1836 * This will wake up the chip if required, and set the slot time for the
1837 * frame (maximum transmit time). Slot time is assumed to be already set
1838 * in the ATH object member sc_slottime
1841 void ath_setslottime(struct ath_softc
*sc
)
1843 ath9k_hw_setslottime(sc
->sc_ah
, sc
->sc_slottime
);
1844 sc
->sc_updateslot
= OK
;