source: branches/8.09/package/madwifi/patches/421-channel_handling.patch @ 17279

Last change on this file since 17279 was 17279, checked in by nbd, 7 years ago

merge madwifi and wprobe into 8.09

File size: 41.8 KB
  • ath/if_ath.c

    a b static int ath_key_set(struct ieee80211v 
    148148static void ath_key_update_begin(struct ieee80211vap *); 
    149149static void ath_key_update_end(struct ieee80211vap *); 
    150150static void ath_mode_init(struct net_device *); 
    151 static void ath_setslottime(struct ath_softc *); 
    152151static void ath_updateslot(struct net_device *); 
    153152static int ath_beaconq_setup(struct ath_softc *); 
    154153static int ath_beacon_alloc(struct ath_softc *, struct ieee80211_node *); 
    static void ath_setup_stationkey(struct  
    240239static void ath_setup_stationwepkey(struct ieee80211_node *); 
    241240static void ath_setup_keycacheslot(struct ath_softc *, struct ieee80211_node *); 
    242241static void ath_newassoc(struct ieee80211_node *, int); 
    243 static int ath_getchannels(struct net_device *, u_int, HAL_BOOL, HAL_BOOL); 
     242static int ath_getchannels(struct net_device *); 
    244243static void ath_led_event(struct ath_softc *, int); 
    245244static void ath_update_txpow(struct ath_softc *); 
    246245 
    static int ath_change_mtu(struct net_dev 
    265264static int ath_ioctl(struct net_device *, struct ifreq *, int); 
    266265 
    267266static int ath_rate_setup(struct net_device *, u_int); 
    268 static void ath_setup_subrates(struct net_device *); 
    269267#ifdef ATH_SUPERG_XR 
    270268static int ath_xr_rate_setup(struct net_device *); 
    271269static void ath_grppoll_txq_setup(struct ath_softc *, int, int); 
    static void ath_fetch_idle_time(struct a 
    387385 
    388386/* calibrate every 30 secs in steady state but check every second at first. */ 
    389387static int ath_calinterval = ATH_SHORT_CALINTERVAL; 
    390 static int ath_countrycode = CTRY_DEFAULT;      /* country code */ 
    391 static int ath_outdoor = AH_FALSE;              /* enable outdoor use */ 
    392388static int ath_xchanmode = AH_TRUE;             /* enable extended channels */ 
    393389static int ath_maxvaps = ATH_MAXVAPS_DEFAULT;   /* set default maximum vaps */ 
    394390static int bstuck_thresh = BSTUCK_THRESH;       /* Stuck beacon count required for reset */ 
    static char *autocreate = NULL; 
    396392static char *ratectl = DEF_RATE_CTL; 
    397393static int rfkill = 0; 
    398394static int tpc = 1; 
    399 static int countrycode = -1; 
    400395static int maxvaps = -1; 
    401 static int outdoor = -1; 
    402396static int xchanmode = -1; 
    403397#include "ath_wprobe.c" 
    404398static int beacon_cal = 1; 
    static struct notifier_block ath_event_b 
    437431 
    438432#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,52)) 
    439433MODULE_PARM(beacon_cal, "i"); 
    440 MODULE_PARM(countrycode, "i"); 
    441434MODULE_PARM(maxvaps, "i"); 
    442 MODULE_PARM(outdoor, "i"); 
    443435MODULE_PARM(xchanmode, "i"); 
    444436MODULE_PARM(rfkill, "i"); 
    445437#ifdef ATH_CAP_TPC 
    MODULE_PARM(ratectl, "s"); 
    451443#else 
    452444#include <linux/moduleparam.h> 
    453445module_param(beacon_cal, int, 0600); 
    454 module_param(countrycode, int, 0600); 
    455446module_param(maxvaps, int, 0600); 
    456 module_param(outdoor, int, 0600); 
    457447module_param(xchanmode, int, 0600); 
    458448module_param(rfkill, int, 0600); 
    459449#ifdef ATH_CAP_TPC 
    module_param(bstuck_thresh, int, 0600); 
    463453module_param(autocreate, charp, 0600); 
    464454module_param(ratectl, charp, 0600); 
    465455#endif 
    466 MODULE_PARM_DESC(countrycode, "Override default country code"); 
    467456MODULE_PARM_DESC(maxvaps, "Maximum VAPs"); 
    468 MODULE_PARM_DESC(outdoor, "Enable/disable outdoor use"); 
    469457MODULE_PARM_DESC(xchanmode, "Enable/disable extended channel mode"); 
    470458MODULE_PARM_DESC(rfkill, "Enable/disable RFKILL capability"); 
    471459#ifdef ATH_CAP_TPC 
    MODULE_PARM_DESC(ieee80211_debug, "Load- 
    531519                                (bssid)[0] |= (((id) << 2) | 0x02);     \ 
    532520                } while (0) 
    533521 
     522static inline int ath_chan2mode(struct ieee80211_channel *c) 
     523{ 
     524        if (IEEE80211_IS_CHAN_HALF(c)) 
     525                return ATH_MODE_HALF; 
     526        else if (IEEE80211_IS_CHAN_QUARTER(c)) 
     527                return ATH_MODE_QUARTER; 
     528        else 
     529                return ieee80211_chan2mode(c); 
     530} 
     531 
     532static inline int rate_hal2ieee(int dot11Rate, int f) 
     533{ 
     534        int flag = dot11Rate & ~(IEEE80211_RATE_VAL); 
     535        dot11Rate &= IEEE80211_RATE_VAL; 
     536 
     537        if (f == 4) { /* Quarter */ 
     538                if (dot11Rate == 4) 
     539                        return 18 | flag; 
     540        } 
     541        return (dot11Rate * f) | flag; 
     542} 
     543 
     544static inline int rate_factor(int mode) 
     545{ 
     546        int f; 
     547 
     548        /* 
     549         * NB: Fix up rates. HAL returns half or quarter dot11Rates, 
     550         * while the stack deals with full rates only 
     551         */ 
     552        switch(mode) { 
     553                case ATH_MODE_HALF: 
     554                        f = 2; 
     555                        break; 
     556                case ATH_MODE_QUARTER: 
     557                        f = 4; 
     558                        break; 
     559                default: 
     560                        f = 1; 
     561                        break; 
     562        } 
     563        return f; 
     564} 
     565 
    534566/* Initialize ath_softc structure */ 
    535567 
    536568int 
    ath_attach(u_int16_t devid, struct net_d 
    647679        for (i = 0; i < sc->sc_keymax; i++) 
    648680                ath_hal_keyreset(ah, i); 
    649681 
    650         /* 
    651          * Collect the channel list using the default country 
    652          * code and including outdoor channels.  The 802.11 layer 
    653          * is responsible for filtering this list based on settings 
    654          * like the phy mode. 
    655          */ 
    656         if (countrycode != -1) 
    657                 ath_countrycode = countrycode; 
    658682        if (maxvaps != -1) { 
    659683                ath_maxvaps = maxvaps; 
    660684                if (ath_maxvaps < ATH_MAXVAPS_MIN) 
    ath_attach(u_int16_t devid, struct net_d 
    662686                else if (ath_maxvaps > ATH_MAXVAPS_MAX) 
    663687                        ath_maxvaps = ATH_MAXVAPS_MAX; 
    664688        } 
    665         if (outdoor != -1) 
    666                 ath_outdoor = outdoor; 
    667689        if (xchanmode != -1) 
    668690                ath_xchanmode = xchanmode; 
    669         error = ath_getchannels(dev, ath_countrycode, 
    670                         ath_outdoor, ath_xchanmode); 
     691        error = ath_getchannels(dev); 
    671692        if (error != 0) 
    672693                goto bad; 
    673694 
    674         ic->ic_country_code = ath_countrycode; 
    675         ic->ic_country_outdoor = ath_outdoor; 
     695        ic->ic_country_code = CTRY_DEFAULT; 
     696        ic->ic_country_outdoor = 0; 
    676697 
    677698        IPRINTF(sc, "Switching rfkill capability %s\n", 
    678699                rfkill ? "on" : "off"); 
    ath_attach(u_int16_t devid, struct net_d 
    686707        ath_rate_setup(dev, IEEE80211_MODE_11G); 
    687708        ath_rate_setup(dev, IEEE80211_MODE_TURBO_A); 
    688709        ath_rate_setup(dev, IEEE80211_MODE_TURBO_G); 
    689  
    690         /* Setup for half/quarter rates */ 
    691         ath_setup_subrates(dev); 
     710        ath_rate_setup(dev, ATH_MODE_HALF); 
     711        ath_rate_setup(dev, ATH_MODE_QUARTER); 
    692712 
    693713        /* NB: setup here so ath_rate_update is happy */ 
    694714        ath_setcurmode(sc, IEEE80211_MODE_11A); 
    ath_attach(u_int16_t devid, struct net_d 
    908928                        IEEE80211_ATHC_COMP : 0); 
    909929#endif 
    910930 
    911 #ifdef ATH_SUPERG_DYNTURBO 
    912         ic->ic_ath_cap |= (ath_hal_turboagsupported(ah, ath_countrycode) ?  
    913                         (IEEE80211_ATHC_TURBOP | IEEE80211_ATHC_AR) : 0); 
    914 #endif 
    915931#ifdef ATH_SUPERG_XR 
    916932        ic->ic_ath_cap |= (ath_hal_xrsupported(ah) ? IEEE80211_ATHC_XR : 0); 
    917933#endif 
    ath_mode_init(struct net_device *dev) 
    44704486 * Set the slot time based on the current setting. 
    44714487 */ 
    44724488static void 
    4473 ath_setslottime(struct ath_softc *sc) 
     4489ath_settiming(struct ath_softc *sc) 
    44744490{ 
    4475         struct ieee80211com *ic = &sc->sc_ic; 
    44764491        struct ath_hal *ah = sc->sc_ah; 
     4492        u_int offset = getTimingOffset(sc); 
    44774493 
    4478         if (sc->sc_slottimeconf > 0) /* manual override */ 
    4479                 ath_hal_setslottime(ah, sc->sc_slottimeconf); 
    4480         else if (ic->ic_flags & IEEE80211_F_SHSLOT) 
    4481                 ath_hal_setslottime(ah, HAL_SLOT_TIME_9); 
    4482         else 
    4483                 ath_hal_setslottime(ah, HAL_SLOT_TIME_20); 
     4494        if (sc->sc_slottimeconf > 0) 
     4495                ath_hal_setslottime(ah, offset + sc->sc_slottimeconf); 
     4496        if (sc->sc_acktimeconf > 0) 
     4497                ath_hal_setacktimeout(ah, 2 * offset + sc->sc_acktimeconf); 
     4498        if (sc->sc_ctstimeconf > 0) 
     4499                ath_hal_setctstimeout(ah, 2 * offset + sc->sc_ctstimeconf); 
    44844500        sc->sc_updateslot = OK; 
    44854501} 
    44864502 
    ath_updateslot(struct net_device *dev) 
    45024518        if (ic->ic_opmode == IEEE80211_M_HOSTAP) 
    45034519                sc->sc_updateslot = UPDATE; 
    45044520        else if (dev->flags & IFF_RUNNING) 
    4505                 ath_setslottime(sc); 
     4521                ath_settiming(sc); 
    45064522} 
    45074523 
    45084524#ifdef ATH_SUPERG_DYNTURBO 
    ath_beacon_send(struct ath_softc *sc, in 
    53465362                sc->sc_updateslot = COMMIT;     /* commit next beacon */ 
    53475363                sc->sc_slotupdate = slot; 
    53485364        } else if ((sc->sc_updateslot == COMMIT) && (sc->sc_slotupdate == slot)) 
    5349                 ath_setslottime(sc);            /* commit change to hardware */ 
     5365                ath_settiming(sc);              /* commit change to hardware */ 
    53505366 
    53515367        if (bfaddr != 0) { 
    53525368                /* 
    ath_get_ivlen(struct ieee80211_key *k) 
    77997815 * Get transmit rate index using rate in Kbps 
    78007816 */ 
    78017817static __inline int 
    7802 ath_tx_findindex(const HAL_RATE_TABLE *rt, int rate) 
     7818ath_tx_findindex(struct ath_softc *sc, const HAL_RATE_TABLE *rt, int rate) 
    78037819{ 
    78047820        unsigned int i, ndx = 0; 
     7821        int f; 
    78057822 
     7823        f = rate_factor(sc->sc_curmode); 
    78067824        for (i = 0; i < rt->rateCount; i++) { 
    7807                 if (rt->info[i].rateKbps == rate) { 
     7825                if ((rt->info[i].rateKbps * f) == rate) { 
    78087826                        ndx = i; 
    78097827                        break; 
    78107828                } 
    ath_tx_start(struct net_device *dev, str 
    80978115                atype = HAL_PKT_TYPE_NORMAL;            /* default */ 
    80988116 
    80998117                if (ismcast) { 
    8100                         rix = ath_tx_findindex(rt, vap->iv_mcast_rate); 
     8118                        rix = ath_tx_findindex(sc, rt, vap->iv_mcast_rate); 
    81018119                        txrate = rt->info[rix].rateCode; 
    81028120                        if (shortPreamble) 
    81038121                                txrate |= rt->info[rix].shortPreamble; 
    ath_chan_change(struct ath_softc *sc, st 
    90649082        struct net_device *dev = sc->sc_dev; 
    90659083        enum ieee80211_phymode mode; 
    90669084 
    9067         mode = ieee80211_chan2mode(chan); 
     9085        mode = ath_chan2mode(chan); 
    90689086 
    90699087        ath_rate_setup(dev, mode); 
    90709088        ath_setcurmode(sc, mode); 
    ath_newassoc(struct ieee80211_node *ni,  
    1012110139} 
    1012210140 
    1012310141static int 
    10124 ath_getchannels(struct net_device *dev, u_int cc, 
    10125         HAL_BOOL outdoor, HAL_BOOL xchanmode) 
     10142ath_getchannels(struct net_device *dev) 
    1012610143{ 
    1012710144        struct ath_softc *sc = dev->priv; 
    1012810145        struct ieee80211com *ic = &sc->sc_ic; 
    ath_getchannels(struct net_device *dev,  
    1013610153                EPRINTF(sc, "Insufficient memory for channel table!\n"); 
    1013710154                return -ENOMEM; 
    1013810155        } 
     10156 
     10157restart: 
    1013910158        if (!ath_hal_init_channels(ah, chans, IEEE80211_CHAN_MAX, &nchan, 
    1014010159            ic->ic_regclassids, IEEE80211_REGCLASSIDS_MAX, &ic->ic_nregclass, 
    10141             cc, HAL_MODE_ALL, outdoor, xchanmode)) { 
     10160            ic->ic_country_code, HAL_MODE_ALL, ic->ic_country_outdoor, ath_xchanmode)) { 
    1014210161                u_int32_t rd; 
    1014310162 
    1014410163                ath_hal_getregdomain(ah, &rd); 
    1014510164                EPRINTF(sc, "Unable to collect channel list from HAL; " 
    10146                         "regdomain likely %u country code %u\n", rd, cc); 
     10165                        "regdomain likely %u country code %u\n", rd, ic->ic_country_code); 
     10166                if ((ic->ic_country_code != CTRY_DEFAULT) || 
     10167                        (ic->ic_country_outdoor != 0)) { 
     10168                        EPRINTF(sc, "Reverting to defaults\n"); 
     10169                        ic->ic_country_code = CTRY_DEFAULT; 
     10170                        ic->ic_country_outdoor = 0; 
     10171                        goto restart; 
     10172                } 
    1014710173                kfree(chans); 
    1014810174                return -EINVAL; 
    1014910175        } 
     10176#ifdef ATH_SUPERG_DYNTURBO 
     10177        ic->ic_ath_cap &= ~(IEEE80211_ATHC_TURBOP | IEEE80211_ATHC_AR); 
     10178        ic->ic_ath_cap |= (ath_hal_turboagsupported(ah, ic->ic_country_code) ? 
     10179                        (IEEE80211_ATHC_TURBOP | IEEE80211_ATHC_AR) : 0); 
     10180#endif 
    1015010181        /* 
    1015110182         * Convert HAL channels to ieee80211 ones. 
    1015210183         */ 
    ath_xr_rate_setup(struct net_device *dev 
    1039210423        struct ieee80211com *ic = &sc->sc_ic; 
    1039310424        const HAL_RATE_TABLE *rt; 
    1039410425        struct ieee80211_rateset *rs; 
    10395         unsigned int i, maxrates; 
     10426        unsigned int i, j, maxrates; 
    1039610427        sc->sc_xr_rates = ath_hal_getratetable(ah, HAL_MODE_XR); 
    1039710428        rt = sc->sc_xr_rates; 
    1039810429        if (rt == NULL) 
    ath_xr_rate_setup(struct net_device *dev 
    1040510436        } else 
    1040610437                maxrates = rt->rateCount; 
    1040710438        rs = &ic->ic_sup_xr_rates; 
    10408         for (i = 0; i < maxrates; i++) 
    10409                 rs->rs_rates[i] = rt->info[i].dot11Rate; 
    10410         rs->rs_nrates = maxrates; 
     10439        for (j = 0, i = 0; i < maxrates; i++) { 
     10440                if (!rt->info[i].valid) 
     10441                        continue; 
     10442                rs->rs_rates[j++] = rt->info[i].dot11Rate; 
     10443        } 
     10444        rs->rs_nrates = j; 
    1041110445        return 1; 
    1041210446} 
    1041310447#endif 
    1041410448 
    10415 /* Setup half/quarter rate table support */ 
    10416 static void 
    10417 ath_setup_subrates(struct net_device *dev) 
    10418 { 
    10419         struct ath_softc *sc = dev->priv; 
    10420         struct ath_hal *ah = sc->sc_ah; 
    10421         struct ieee80211com *ic = &sc->sc_ic; 
    10422         const HAL_RATE_TABLE *rt; 
    10423         struct ieee80211_rateset *rs; 
    10424         unsigned int i, maxrates; 
    10425  
    10426         sc->sc_half_rates = ath_hal_getratetable(ah, HAL_MODE_11A_HALF_RATE); 
    10427         rt = sc->sc_half_rates; 
    10428         if (rt != NULL) { 
    10429                 if (rt->rateCount > IEEE80211_RATE_MAXSIZE) { 
    10430                         DPRINTF(sc, ATH_DEBUG_ANY, 
    10431                                 "The rate table is too small (%u > %u)\n", 
    10432                                rt->rateCount, IEEE80211_RATE_MAXSIZE); 
    10433                         maxrates = IEEE80211_RATE_MAXSIZE; 
    10434                 } else 
    10435                         maxrates = rt->rateCount; 
    10436                 rs = &ic->ic_sup_half_rates; 
    10437                 for (i = 0; i < maxrates; i++) 
    10438                         rs->rs_rates[i] = rt->info[i].dot11Rate; 
    10439                 rs->rs_nrates = maxrates; 
    10440         } 
    10441  
    10442         sc->sc_quarter_rates = ath_hal_getratetable(ah, HAL_MODE_11A_QUARTER_RATE); 
    10443         rt = sc->sc_quarter_rates; 
    10444         if (rt != NULL) { 
    10445                 if (rt->rateCount > IEEE80211_RATE_MAXSIZE) { 
    10446                         DPRINTF(sc, ATH_DEBUG_ANY, 
    10447                                 "The rate table is too small (%u > %u)\n", 
    10448                                rt->rateCount, IEEE80211_RATE_MAXSIZE); 
    10449                         maxrates = IEEE80211_RATE_MAXSIZE; 
    10450                 } else 
    10451                         maxrates = rt->rateCount; 
    10452                 rs = &ic->ic_sup_quarter_rates; 
    10453                 for (i = 0; i < maxrates; i++) 
    10454                         rs->rs_rates[i] = rt->info[i].dot11Rate; 
    10455                 rs->rs_nrates = maxrates; 
    10456         } 
    10457 } 
    10458  
    1045910449static int 
    1046010450ath_rate_setup(struct net_device *dev, u_int mode) 
    1046110451{ 
    ath_rate_setup(struct net_device *dev, u 
    1046410454        struct ieee80211com *ic = &sc->sc_ic; 
    1046510455        const HAL_RATE_TABLE *rt; 
    1046610456        struct ieee80211_rateset *rs; 
    10467         unsigned int i, maxrates; 
     10457        unsigned int i, j, maxrates, f; 
    1046810458 
    1046910459        switch (mode) { 
    1047010460        case IEEE80211_MODE_11A: 
    ath_rate_setup(struct net_device *dev, u 
    1048210472        case IEEE80211_MODE_TURBO_G: 
    1048310473                sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_108G); 
    1048410474                break; 
     10475        case ATH_MODE_HALF: 
     10476                sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_11A_HALF_RATE); 
     10477                break; 
     10478        case ATH_MODE_QUARTER: 
     10479                sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_11A_QUARTER_RATE); 
     10480                break; 
    1048510481        default: 
    1048610482                DPRINTF(sc, ATH_DEBUG_ANY, "Invalid mode %u\n", mode); 
    1048710483                return 0; 
    ath_rate_setup(struct net_device *dev, u 
    1049610492                maxrates = IEEE80211_RATE_MAXSIZE; 
    1049710493        } else 
    1049810494                maxrates = rt->rateCount; 
     10495 
     10496        /* NB: quarter/half rate channels hijack the 11A rateset */ 
     10497        if (mode >= IEEE80211_MODE_MAX) 
     10498                return 1; 
     10499 
    1049910500        rs = &ic->ic_sup_rates[mode]; 
    1050010501        for (i = 0; i < maxrates; i++) 
    1050110502                rs->rs_rates[i] = rt->info[i].dot11Rate; 
    1050210503        rs->rs_nrates = maxrates; 
     10504 
    1050310505        return 1; 
    1050410506} 
    1050510507 
    ath_setcurmode(struct ath_softc *sc, enu 
    1052810530                {   0, 500, 130 }, 
    1052910531        }; 
    1053010532        const HAL_RATE_TABLE *rt; 
    10531         unsigned int i, j; 
     10533        unsigned int i, j, f; 
    1053210534 
     10535        /* 
     10536         * NB: Fix up rixmap. HAL returns half or quarter dot11Rates, 
     10537         * while the stack deals with full rates only 
     10538         */ 
     10539        f = rate_factor(mode); 
    1053310540        memset(sc->sc_rixmap, 0xff, sizeof(sc->sc_rixmap)); 
    1053410541        rt = sc->sc_rates[mode]; 
    1053510542        KASSERT(rt != NULL, ("no h/w rate set for phy mode %u", mode)); 
    1053610543        for (i = 0; i < rt->rateCount; i++) 
    10537                 sc->sc_rixmap[rt->info[i].dot11Rate & IEEE80211_RATE_VAL] = i; 
     10544                sc->sc_rixmap[rate_hal2ieee(rt->info[i].dot11Rate, f) & IEEE80211_RATE_VAL] = i; 
    1053810545        memset(sc->sc_hwmap, 0, sizeof(sc->sc_hwmap)); 
    1053910546        for (i = 0; i < 32; i++) { 
    1054010547                u_int8_t ix = rt->rateCodeToIndex[i]; 
    ath_setcurmode(struct ath_softc *sc, enu 
    1054410551                        continue; 
    1054510552                } 
    1054610553                sc->sc_hwmap[i].ieeerate = 
    10547                         rt->info[ix].dot11Rate & IEEE80211_RATE_VAL; 
     10554                        rate_hal2ieee(rt->info[ix].dot11Rate, f) & IEEE80211_RATE_VAL; 
    1054810555                if (rt->info[ix].shortPreamble || 
    1054910556                    rt->info[ix].phy == IEEE80211_T_OFDM) 
    1055010557                        sc->sc_hwmap[i].flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 
    enum { 
    1094510952        ATH_MAXVAPS             = 26, 
    1094610953        ATH_INTMIT                      = 27, 
    1094710954        ATH_NOISE_IMMUNITY      = 28, 
    10948         ATH_OFDM_WEAK_DET       = 29 
     10955        ATH_OFDM_WEAK_DET       = 29, 
     10956        ATH_CHANBW              = 30, 
     10957        ATH_OUTDOOR             = 31, 
    1094910958}; 
    1095010959 
     10960/* 
     10961 * perform the channel related sysctl, reload the channel list 
     10962 * and try to stay on the current frequency 
     10963 */ 
     10964static int ath_sysctl_setchanparam(struct ath_softc *sc, unsigned long ctl, u_int val) 
     10965{ 
     10966        struct ieee80211com *ic = &sc->sc_ic; 
     10967        struct ath_hal *ah = sc->sc_ah; 
     10968        struct ieee80211_channel *c = NULL; 
     10969        struct ieee80211vap *vap; 
     10970        u_int16_t freq = 0; 
     10971        struct ifreq ifr; 
     10972 
     10973        if (ic->ic_curchan != IEEE80211_CHAN_ANYC) 
     10974                freq = ic->ic_curchan->ic_freq; 
     10975 
     10976        switch(ctl) { 
     10977        case ATH_COUNTRYCODE: 
     10978                ic->ic_country_code = val; 
     10979                break; 
     10980        case ATH_OUTDOOR: 
     10981                ic->ic_country_outdoor = val; 
     10982                break; 
     10983        case ATH_CHANBW: 
     10984                switch(val) { 
     10985                case 0: 
     10986                case 5: 
     10987                case 10: 
     10988                case 20: 
     10989                case 40: 
     10990                        if (ath_hal_setcapability(ah, HAL_CAP_CHANBW, 1, val, NULL) == AH_TRUE) { 
     10991                                sc->sc_chanbw = val; 
     10992                                break; 
     10993                        } 
     10994                default: 
     10995                        return -EINVAL; 
     10996                } 
     10997                break; 
     10998        } 
     10999 
     11000        if (ic->ic_curchan != IEEE80211_CHAN_ANYC) 
     11001                freq = ic->ic_curchan->ic_freq; 
     11002 
     11003        /* clear out any old state */ 
     11004        TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { 
     11005                vap->iv_des_mode = IEEE80211_MODE_AUTO; 
     11006                vap->iv_des_chan = IEEE80211_CHAN_ANYC; 
     11007        } 
     11008        ieee80211_scan_flush(ic); 
     11009 
     11010        IEEE80211_LOCK_IRQ(ic); 
     11011        ath_getchannels(sc->sc_dev); 
     11012        ieee80211_update_channels(ic, 0); 
     11013        if (freq) 
     11014                c = ieee80211_find_channel(ic, freq, IEEE80211_MODE_AUTO); 
     11015        if (!c) 
     11016                c = &ic->ic_channels[0]; 
     11017        ic->ic_curchan = c; 
     11018        ic->ic_bsschan = c; 
     11019        ic->ic_curmode = IEEE80211_MODE_AUTO; 
     11020        IEEE80211_UNLOCK_IRQ(ic); 
     11021 
     11022        if (!(sc->sc_dev->flags & IFF_RUNNING)) { 
     11023                ic->ic_bsschan = IEEE80211_CHAN_ANYC; 
     11024                return 0; 
     11025        } 
     11026 
     11027#ifndef ifr_media 
     11028#define    ifr_media       ifr_ifru.ifru_ivalue 
     11029#endif 
     11030        memset(&ifr, 0, sizeof(ifr)); 
     11031        ifr.ifr_media = ic->ic_media.ifm_cur->ifm_media & ~IFM_MMASK; 
     11032        ifr.ifr_media |= IFM_MAKEMODE(IEEE80211_MODE_AUTO); 
     11033        ifmedia_ioctl(ic->ic_dev, &ifr, &ic->ic_media, SIOCSIFMEDIA); 
     11034 
     11035        /* apply the channel to the hw */ 
     11036        ath_set_channel(ic); 
     11037 
     11038        TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { 
     11039                struct net_device *dev = vap->iv_dev; 
     11040 
     11041                /* reactivate all active vaps */ 
     11042                vap->iv_state = IEEE80211_S_SCAN; 
     11043                if ((vap->iv_opmode == IEEE80211_M_HOSTAP) || 
     11044                        (vap->iv_opmode == IEEE80211_M_MONITOR) || 
     11045                        (vap->iv_opmode == IEEE80211_M_WDS)) 
     11046                        ieee80211_new_state(vap, IEEE80211_S_RUN, 0); 
     11047                else 
     11048                        ieee80211_new_state(vap, IEEE80211_S_INIT, -1); 
     11049        } 
     11050 
     11051        return 0; 
     11052} 
     11053 
     11054 
    1095111055static int 
    1095211056ath_sysctl_set_intmit(struct ath_softc *sc, long ctl, u_int val) 
    1095311057{ 
    static int 
    1102611130ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl, write, filp, buffer, lenp, ppos) 
    1102711131{ 
    1102811132        struct ath_softc *sc = ctl->extra1; 
     11133        struct ieee80211com *ic = &sc->sc_ic; 
    1102911134        struct ath_hal *ah = sc->sc_ah; 
    1103011135        u_int val; 
    1103111136        u_int tab_3_val[3]; 
    ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl 
    1104911154                                lenp, ppos); 
    1105011155                if (ret == 0) { 
    1105111156                        switch ((long)ctl->extra2) { 
     11157                        case ATH_REGDOMAIN: 
     11158                                ath_hal_setregdomain(ah, val); 
     11159                                break; 
     11160                        case ATH_OUTDOOR: 
     11161                        case ATH_COUNTRYCODE: 
     11162                        case ATH_CHANBW: 
     11163                                ret = ath_sysctl_setchanparam(sc, (long) ctl->extra2, val); 
     11164                                break; 
    1105211165                        case ATH_SLOTTIME: 
    11053                                 if (val > 0) { 
    11054                                         if (!ath_hal_setslottime(ah, val)) 
    11055                                                 ret = -EINVAL; 
    11056                                         else 
    11057                                                 sc->sc_slottimeconf = val; 
    11058                                 } else { 
    11059                                         /* disable manual override */ 
     11166                                if (val > 0) 
     11167                                        sc->sc_slottimeconf = val; 
     11168                                else 
    1106011169                                        sc->sc_slottimeconf = 0; 
    11061                                         ath_setslottime(sc); 
    11062                                 } 
     11170                                ath_settiming(sc); 
    1106311171                                break; 
    1106411172                        case ATH_ACKTIMEOUT: 
    11065                                 if (!ath_hal_setacktimeout(ah, val)) 
    11066                                         ret = -EINVAL; 
     11173                                if (val > 0) 
     11174                                        sc->sc_acktimeconf = val; 
     11175                                else 
     11176                                        sc->sc_acktimeconf = 0; 
     11177                                ath_settiming(sc); 
    1106711178                                break; 
    1106811179                        case ATH_CTSTIMEOUT: 
    11069                                 if (!ath_hal_setctstimeout(ah, val)) 
    11070                                         ret = -EINVAL; 
     11180                                if (val > 0) 
     11181                                        sc->sc_ctstimeconf = val; 
     11182                                else 
     11183                                        sc->sc_ctstimeconf = 0; 
     11184                                ath_settiming(sc); 
    1107111185                                break; 
    1107211186                        case ATH_SOFTLED: 
    1107311187                                if (val != sc->sc_softled) { 
    ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl 
    1122011334                } 
    1122111335        } else { 
    1122211336                switch ((long)ctl->extra2) { 
     11337                case ATH_CHANBW: 
     11338                        val = sc->sc_chanbw ?: 20; 
     11339                        break; 
    1122311340                case ATH_SLOTTIME: 
    1122411341                        val = ath_hal_getslottime(ah); 
    1122511342                        break; 
    ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl 
    1123811355                case ATH_COUNTRYCODE: 
    1123911356                        ath_hal_getcountrycode(ah, &val); 
    1124011357                        break; 
     11358                case ATH_OUTDOOR: 
     11359                        val = ic->ic_country_outdoor; 
     11360                        break; 
    1124111361                case ATH_MAXVAPS: 
    1124211362                        val = ath_maxvaps; 
    1124311363                        break; 
    static const ctl_table ath_sysctl_templa 
    1135111471        }, 
    1135211472        { .ctl_name     = CTL_AUTO, 
    1135311473          .procname     = "countrycode", 
    11354           .mode         = 0444, 
     11474          .mode         = 0644, 
    1135511475          .proc_handler = ath_sysctl_halparam, 
    1135611476          .extra2       = (void *)ATH_COUNTRYCODE, 
    1135711477        }, 
    1135811478        { .ctl_name     = CTL_AUTO, 
     11479          .procname     = "outdoor", 
     11480          .mode         = 0644, 
     11481          .proc_handler = ath_sysctl_halparam, 
     11482          .extra2       = (void *)ATH_OUTDOOR, 
     11483        }, 
     11484        { .ctl_name     = CTL_AUTO, 
    1135911485          .procname     = "maxvaps", 
    1136011486          .mode         = 0444, 
    1136111487          .proc_handler = ath_sysctl_halparam, 
    static const ctl_table ath_sysctl_templa 
    1136311489        }, 
    1136411490        { .ctl_name     = CTL_AUTO, 
    1136511491          .procname     = "regdomain", 
    11366           .mode         = 0444, 
     11492          .mode         = 0644, 
    1136711493          .proc_handler = ath_sysctl_halparam, 
    1136811494          .extra2       = (void *)ATH_REGDOMAIN, 
    1136911495        }, 
    static const ctl_table ath_sysctl_templa 
    1142611552          .extra2       = (void *)ATH_ACKRATE, 
    1142711553        }, 
    1142811554        { .ctl_name     = CTL_AUTO, 
     11555          .procname     = "channelbw", 
     11556          .mode         = 0644, 
     11557          .proc_handler = ath_sysctl_halparam, 
     11558          .extra2       = (void *)ATH_CHANBW, 
     11559        }, 
     11560        { .ctl_name     = CTL_AUTO, 
    1142911561          .procname     = "rp", 
    1143011562          .mode         = 0200, 
    1143111563          .proc_handler = ath_sysctl_halparam, 
    static ctl_table ath_static_sysctls[] =  
    1166611798        }, 
    1166711799#endif 
    1166811800        { .ctl_name     = CTL_AUTO, 
    11669           .procname     = "countrycode", 
    11670           .mode         = 0444, 
    11671           .data         = &ath_countrycode, 
    11672           .maxlen       = sizeof(ath_countrycode), 
    11673           .proc_handler = proc_dointvec 
    11674         }, 
    11675         { .ctl_name     = CTL_AUTO, 
    1167611801          .procname     = "maxvaps", 
    1167711802          .mode         = 0444, 
    1167811803          .data         = &ath_maxvaps, 
    static ctl_table ath_static_sysctls[] =  
    1168011805          .proc_handler = proc_dointvec 
    1168111806        }, 
    1168211807        { .ctl_name     = CTL_AUTO, 
    11683           .procname     = "outdoor", 
    11684           .mode         = 0444, 
    11685           .data         = &ath_outdoor, 
    11686           .maxlen       = sizeof(ath_outdoor), 
    11687           .proc_handler = proc_dointvec 
    11688         }, 
    11689         { .ctl_name     = CTL_AUTO, 
    1169011808          .procname     = "xchanmode", 
    1169111809          .mode         = 0444, 
    1169211810          .data         = &ath_xchanmode, 
  • ath/if_athvar.h

    a b struct ath_softc { 
    688688        int8_t sc_ofdm_weak_det; /* OFDM weak frames detection, -1 == auto */ 
    689689 
    690690        /* rate tables */ 
    691         const HAL_RATE_TABLE *sc_rates[IEEE80211_MODE_MAX]; 
     691#define ATH_MODE_HALF           (IEEE80211_MODE_MAX) 
     692#define ATH_MODE_QUARTER        (IEEE80211_MODE_MAX + 1) 
     693        const HAL_RATE_TABLE *sc_rates[IEEE80211_MODE_MAX + 2]; 
    692694        const HAL_RATE_TABLE *sc_currates;      /* current rate table */ 
    693695        const HAL_RATE_TABLE *sc_xr_rates;      /* XR rate table */ 
    694         const HAL_RATE_TABLE *sc_half_rates;    /* half rate table */ 
    695         const HAL_RATE_TABLE *sc_quarter_rates; /* quarter rate table */ 
    696696        HAL_OPMODE sc_opmode;                   /* current hal operating mode */ 
    697697        enum ieee80211_phymode sc_curmode;      /* current phy mode */ 
    698698        u_int sc_poweroffset;                   /* hardware power offset */ 
    699699        u_int16_t sc_curtxpow;                  /* current tx power limit */ 
    700700        u_int16_t sc_curaid;                    /* current association id */ 
    701701        HAL_CHANNEL sc_curchan;                 /* current h/w channel */ 
     702        u_int8_t sc_chanbw;                             /* channel bandwidth */ 
    702703        u_int8_t sc_curbssid[IEEE80211_ADDR_LEN]; 
    703704        u_int8_t        sc_rixmap[256];                 /* IEEE to h/w rate table ix */ 
    704705        struct { 
    struct ath_softc { 
    809810        u_int32_t sc_dturbo_bw_turbo;           /* bandwidth threshold */ 
    810811#endif 
    811812        u_int sc_slottimeconf;                  /* manual override for slottime */ 
     813        u_int sc_acktimeconf;                   /* manual override for acktime */ 
     814        u_int sc_ctstimeconf;                   /* manual override for ctstime */ 
    812815 
    813816        struct timer_list sc_dfs_excl_timer;    /* mark expiration timer task */ 
    814817        struct timer_list sc_dfs_cac_timer;     /* dfs wait timer */ 
    struct ath_softc { 
    827830        int sc_rp_num; 
    828831        int sc_rp_min; 
    829832        HAL_BOOL (*sc_rp_analyse)(struct ath_softc *sc); 
     833        struct ATH_TQ_STRUCT sc_refresh_tq; 
    830834        struct ATH_TQ_STRUCT sc_rp_tq; 
    831835         
    832836        int sc_rp_ignored;                      /* if set, we ignored all  
    int ar_device(int devid); 
    942946          DEV_NAME(_v->iv_ic->ic_dev)) 
    943947 
    944948void ath_radar_detected(struct ath_softc *sc, const char* message); 
     949static inline u_int getTimingOffset(struct ath_softc *sc) 
     950{ 
     951        struct ieee80211com *ic = &sc->sc_ic; 
     952        u_int usec = 9; 
     953        if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan)) { 
     954                usec = 20; 
     955                if (ic->ic_flags & IEEE80211_F_SHSLOT) 
     956                        usec = 9; 
     957        } else if (IEEE80211_IS_CHAN_A(ic->ic_curchan)) 
     958                usec = 9; 
     959 
     960        if (IEEE80211_IS_CHAN_TURBO(ic->ic_curchan)) 
     961                usec = 6; 
     962 
     963        if (IEEE80211_IS_CHAN_HALF(ic->ic_curchan)) 
     964                usec = 13; 
     965        else if (IEEE80211_IS_CHAN_QUARTER(ic->ic_curchan)) 
     966                usec = 21; 
     967        return usec; 
     968} 
     969 
     970static inline void ath_get_timings(struct ath_softc *sc, u_int *t_slot, u_int *t_sifs, u_int *t_difs) 
     971{ 
     972        struct ieee80211_channel *c = sc->sc_ic.ic_curchan; 
     973 
     974        *t_slot = getTimingOffset(sc) + sc->sc_slottimeconf; 
     975 
     976        if (IEEE80211_IS_CHAN_HALF(c)) { 
     977                *t_sifs = 32; 
     978                *t_difs = 56; 
     979        } else if (IEEE80211_IS_CHAN_QUARTER(c)) { 
     980                *t_sifs = 64; 
     981                *t_difs = 112; 
     982        } else if (IEEE80211_IS_CHAN_TURBO(c)) { 
     983                *t_sifs = 8; 
     984                *t_difs = 28; 
     985        } else { 
     986                *t_sifs = 16; 
     987                *t_difs = 28; 
     988        } 
     989} 
     990 
    945991 
    946992struct ath_hw_detect { 
    947993        const char *vendor_name; 
  • tools/athctrl.c

    a b CMD(athctrl)(int argc, char *argv[]) 
    118118        } 
    119119 
    120120        if (distance >= 0) { 
    121                 int slottime = 9 + (distance / 300) + ((distance % 300) ? 1 : 0); 
     121                int slottime = (distance / 300) + ((distance % 300) ? 1 : 0); 
    122122                int acktimeout = slottime * 2 + 3; 
    123123                int ctstimeout = slottime * 2 + 3; 
    124124 
  • net80211/ieee80211.c

    a b static const struct country_code_to_str 
    243243        {CTRY_ZIMBABWE,             "ZW"} 
    244244}; 
    245245 
    246 int 
    247 ieee80211_ifattach(struct ieee80211com *ic) 
     246void ieee80211_update_channels(struct ieee80211com *ic, int init) 
    248247{ 
    249         struct net_device *dev = ic->ic_dev; 
    250248        struct ieee80211_channel *c; 
     249        struct ieee80211vap *vap; 
    251250        struct ifmediareq imr; 
     251        int ext = 0; 
    252252        int i; 
    253253 
    254         _MOD_INC_USE(THIS_MODULE, return -ENODEV); 
    255  
    256         /* 
    257          * Pick an initial operating mode until we have a vap 
    258          * created to lock it down correctly.  This is only 
    259          * drivers have something defined for configuring the 
    260          * hardware at startup. 
    261          */ 
    262         ic->ic_opmode = IEEE80211_M_STA;        /* everyone supports this */ 
    263  
    264         /* 
    265          * Fill in 802.11 available channel set, mark 
    266          * all available channels as active, and pick 
    267          * a default channel if not already specified. 
    268          */ 
    269         KASSERT(0 < ic->ic_nchans && ic->ic_nchans < IEEE80211_CHAN_MAX, 
    270                 ("invalid number of channels specified: %u", ic->ic_nchans)); 
    271254        memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail)); 
    272         ic->ic_modecaps |= 1 << IEEE80211_MODE_AUTO; 
    273255        ic->ic_max_txpower = IEEE80211_TXPOWER_MIN; 
     256        ic->ic_modecaps = 1 << IEEE80211_MODE_AUTO; 
    274257 
    275258        for (i = 0; i < ic->ic_nchans; i++) { 
    276259                c = &ic->ic_channels[i]; 
    ieee80211_ifattach(struct ieee80211com * 
    298281                        ic->ic_modecaps |= 1 << IEEE80211_MODE_TURBO_A; 
    299282                if (IEEE80211_IS_CHAN_108G(c)) 
    300283                        ic->ic_modecaps |= 1 << IEEE80211_MODE_TURBO_G; 
     284                if (IEEE80211_IS_CHAN_HALF(c) || IEEE80211_IS_CHAN_QUARTER(c)) 
     285                        ext = 1; 
    301286        } 
    302287        /* Initialize candidate channels to all available */ 
    303288        memcpy(ic->ic_chan_active, ic->ic_chan_avail, 
    ieee80211_ifattach(struct ieee80211com * 
    311296         * When 11g is supported, force the rate set to 
    312297         * include basic rates suitable for a mixed b/g bss. 
    313298         */ 
    314         if (ic->ic_modecaps & (1 << IEEE80211_MODE_11G)) 
     299        if ((ic->ic_modecaps & (1 << IEEE80211_MODE_11G)) && !ext) 
    315300                ieee80211_set11gbasicrates( 
    316301                        &ic->ic_sup_rates[IEEE80211_MODE_11G], 
    317302                        IEEE80211_MODE_11G); 
    318303 
     304        if (init) 
     305                return; 
     306 
     307        ieee80211_media_setup(ic, &ic->ic_media, ic->ic_caps, NULL, NULL); 
     308        ieee80211com_media_status(ic->ic_dev, &imr); 
     309        ifmedia_set(&ic->ic_media, imr.ifm_active); 
     310 
     311        TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { 
     312                struct ieee80211vap *avp; 
     313                TAILQ_FOREACH(avp, &vap->iv_wdslinks, iv_wdsnext) { 
     314                        (void) ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps, NULL, NULL); 
     315                        ieee80211_media_status(vap->iv_dev, &imr); 
     316                        ifmedia_set(&vap->iv_media, imr.ifm_active); 
     317                } 
     318                (void) ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps, NULL, NULL); 
     319                ieee80211_media_status(vap->iv_dev, &imr); 
     320                ifmedia_set(&vap->iv_media, imr.ifm_active); 
     321        } 
     322} 
     323EXPORT_SYMBOL(ieee80211_update_channels); 
     324 
     325int 
     326ieee80211_ifattach(struct ieee80211com *ic) 
     327{ 
     328        struct net_device *dev = ic->ic_dev; 
     329        struct ieee80211_channel *c; 
     330        struct ifmediareq imr; 
     331 
     332        _MOD_INC_USE(THIS_MODULE, return -ENODEV); 
     333 
     334        /* 
     335         * Pick an initial operating mode until we have a vap 
     336         * created to lock it down correctly.  This is only 
     337         * drivers have something defined for configuring the 
     338         * hardware at startup. 
     339         */ 
     340        ic->ic_opmode = IEEE80211_M_STA;        /* everyone supports this */ 
     341 
     342        /* 
     343         * Fill in 802.11 available channel set, mark 
     344         * all available channels as active, and pick 
     345         * a default channel if not already specified. 
     346         */ 
     347        KASSERT(0 < ic->ic_nchans && ic->ic_nchans < IEEE80211_CHAN_MAX, 
     348                ("invalid number of channels specified: %u", ic->ic_nchans)); 
     349        ieee80211_update_channels(ic, 1); 
     350 
    319351        /* Setup initial channel settings */ 
    320352        ic->ic_bsschan = IEEE80211_CHAN_ANYC; 
    321353        /* Arbitrarily pick the first channel */ 
    ieee80211_ifattach(struct ieee80211com * 
    327359        /* Enable WME by default, if we're capable. */ 
    328360        if (ic->ic_caps & IEEE80211_C_WME) 
    329361                ic->ic_flags |= IEEE80211_F_WME; 
     362 
    330363        (void) ieee80211_setmode(ic, ic->ic_curmode); 
    331364 
    332365        /* Store default beacon interval, as nec. */ 
    ieee80211_media_setup(struct ieee80211co 
    763796        struct ieee80211_rateset allrates; 
    764797 
    765798        /* Fill in media characteristics. */ 
    766         ifmedia_init(media, 0, media_change, media_stat); 
     799        if (media_change || media_stat) 
     800                ifmedia_init(media, 0, media_change, media_stat); 
    767801        maxrate = 0; 
    768802        memset(&allrates, 0, sizeof(allrates)); 
    769803 
    ieee80211_media_setup(struct ieee80211co 
    793827                        ADD(media, IFM_AUTO, mopt | IFM_IEEE80211_WDS); 
    794828                if (mode == IEEE80211_MODE_AUTO) 
    795829                        continue; 
    796                 rs = &ic->ic_sup_rates[mode]; 
     830                rs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)]; 
    797831 
    798832                for (i = 0; i < rs->rs_nrates; i++) { 
    799833                        rate = rs->rs_rates[i]; 
    ieee80211_announce(struct ieee80211com * 
    12071241                if ((ic->ic_modecaps & (1 << mode)) == 0) 
    12081242                        continue; 
    12091243                if_printf(dev, "%s rates: ", ieee80211_phymode_name[mode]); 
    1210                 rs = &ic->ic_sup_rates[mode]; 
     1244                rs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)]; 
    12111245                for (i = 0; i < rs->rs_nrates; i++) { 
    12121246                        rate = rs->rs_rates[i]; 
    12131247                        mword = ieee80211_rate2media(ic, rate, mode); 
    ieee80211com_media_change(struct net_dev 
    14171451                         * now so drivers have a consistent state. 
    14181452                         */ 
    14191453                        KASSERT(vap->iv_bss != NULL, ("no bss node")); 
    1420                         vap->iv_bss->ni_rates = ic->ic_sup_rates[newphymode]; 
     1454                        vap->iv_bss->ni_rates = ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, newphymode)]; 
    14211455                } 
    14221456                error = -ENETRESET; 
    14231457        } 
    findrate(struct ieee80211com *ic, enum i 
    14351469{ 
    14361470#define IEEERATE(_ic,_m,_i) \ 
    14371471        ((_ic)->ic_sup_rates[_m].rs_rates[_i] & IEEE80211_RATE_VAL) 
    1438         int i, nrates = ic->ic_sup_rates[mode].rs_nrates; 
     1472        int i, nrates = ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)].rs_nrates; 
    14391473        for (i = 0; i < nrates; i++) 
    14401474                if (IEEERATE(ic, mode, i) == rate) 
    14411475                        return i; 
    ieee80211_build_countryie(struct ieee802 
    18771911                        if (ieee80211_chan2mode(c) != curmode_noturbo) 
    18781912                                continue; 
    18791913 
    1880                         /* Skip half/quarter rate channels */ 
    1881                         if (IEEE80211_IS_CHAN_HALF(c) || 
    1882                             IEEE80211_IS_CHAN_QUARTER(c)) 
    1883                                 continue; 
    1884  
    18851914                        if (*cur_runlen == 0) { 
    18861915                                (*cur_runlen)++; 
    18871916                                *cur_pow = c->ic_maxregpower; 
    void 
    19151944ieee80211_build_sc_ie(struct ieee80211com *ic) 
    19161945{ 
    19171946        struct ieee80211_ie_sc *ie = &ic->ic_sc_ie; 
    1918         int i, j; 
     1947        int i, j, k; 
    19191948        struct ieee80211_channel *c; 
    19201949        u_int8_t prevchan; 
    19211950 
  • net80211/ieee80211_var.h

    a b struct ieee80211com { 
    336336        u_int8_t ic_nopened;                    /* VAPs been opened */ 
    337337        struct ieee80211_rateset ic_sup_rates[IEEE80211_MODE_MAX]; 
    338338        struct ieee80211_rateset ic_sup_xr_rates; 
    339         struct ieee80211_rateset ic_sup_half_rates; 
    340         struct ieee80211_rateset ic_sup_quarter_rates; 
    341339        u_int16_t ic_modecaps;                  /* set of mode capabilities */ 
    342340        u_int16_t ic_curmode;                   /* current mode */ 
    343341        u_int16_t ic_lintval;                   /* beacon interval */ 
    MALLOC_DECLARE(M_80211_VAP); 
    715713 
    716714int ieee80211_ifattach(struct ieee80211com *); 
    717715void ieee80211_ifdetach(struct ieee80211com *); 
     716void ieee80211_update_channels(struct ieee80211com *ic, int); 
    718717int ieee80211_vap_setup(struct ieee80211com *, struct net_device *, 
    719718        const char *, int, int, struct ieee80211vap *); 
    720719int ieee80211_vap_attach(struct ieee80211vap *, ifm_change_cb_t, ifm_stat_cb_t); 
    ieee80211_anyhdrspace(struct ieee80211co 
    794793        return size; 
    795794} 
    796795 
     796static __inline int 
     797ieee80211_chan2ratemode(struct ieee80211_channel *c, int mode) 
     798{ 
     799        if (mode == -1) 
     800                mode = ieee80211_chan2mode(c); 
     801 
     802        /* 
     803         * Use 11a rateset for half/quarter to restrict things 
     804         * to pure OFDM 
     805         */ 
     806        if (IEEE80211_IS_CHAN_HALF(c) || 
     807                IEEE80211_IS_CHAN_QUARTER(c)) 
     808                return IEEE80211_MODE_11A; 
     809 
     810        return mode; 
     811} 
     812 
    797813/* Macros to print MAC address used in 802.11 headers */ 
    798814 
    799815#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x" 
  • net80211/ieee80211_node.c

    a b ieee80211_node_set_chan(struct ieee80211 
    287287                ni->ni_rates = ic->ic_sup_xr_rates; 
    288288        else 
    289289#endif 
    290         ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2mode(chan)]; 
     290        ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2ratemode(chan, -1)]; 
    291291} 
    292292 
    293293static __inline void 
    ieee80211_create_ibss(struct ieee80211va 
    387387        ic->ic_bsschan = chan; 
    388388        ieee80211_node_set_chan(ic, ni); 
    389389        ic->ic_curmode = ieee80211_chan2mode(chan); 
     390        ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2ratemode(chan, -1)]; 
     391 
    390392        spin_lock_irqsave(&channel_lock, flags); 
    391393        ieee80211_scan_set_bss_channel(ic, ic->ic_bsschan); 
    392394        spin_unlock_irqrestore(&channel_lock, flags); 
    ieee80211_create_ibss(struct ieee80211va 
    394396        /* Update country ie information */ 
    395397        ieee80211_build_countryie(ic); 
    396398 
    397         if (IEEE80211_IS_CHAN_HALF(chan)) { 
    398                 ni->ni_rates = ic->ic_sup_half_rates; 
    399         } else if (IEEE80211_IS_CHAN_QUARTER(chan)) { 
    400                 ni->ni_rates = ic->ic_sup_quarter_rates; 
    401         } 
    402  
    403         if ((vap->iv_flags & IEEE80211_F_PUREG) && 
    404                 IEEE80211_IS_CHAN_ANYG(chan)) { 
     399        if ((ieee80211_chan2ratemode(chan, -1) != IEEE80211_MODE_11A) && 
     400                IEEE80211_IS_CHAN_ANYG(chan) && (vap->iv_flags & IEEE80211_F_PUREG)) { 
    405401                ieee80211_setpuregbasicrates(&ni->ni_rates); 
    406402        } 
    407403 
  • net80211/ieee80211_scan_sta.c

    a b check_rate(struct ieee80211vap *vap, con 
    490490 
    491491        okrate = badrate = fixedrate = 0; 
    492492 
    493         if (IEEE80211_IS_CHAN_HALF(se->se_chan)) 
    494                 srs = &ic->ic_sup_half_rates; 
    495         else if (IEEE80211_IS_CHAN_QUARTER(se->se_chan)) 
    496                 srs = &ic->ic_sup_quarter_rates; 
    497         else 
    498                 srs = &ic->ic_sup_rates[ieee80211_chan2mode(se->se_chan)]; 
     493        srs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, -1)]; 
    499494        nrs = se->se_rates[1]; 
    500495        rs = se->se_rates + 2; 
    501496        fixedrate = IEEE80211_FIXED_RATE_NONE; 
  • net80211/ieee80211_output.c

    a b ieee80211_send_probereq(struct ieee80211 
    16761676 
    16771677        frm = ieee80211_add_ssid(frm, ssid, ssidlen); 
    16781678        mode = ieee80211_chan2mode(ic->ic_curchan); 
    1679         frm = ieee80211_add_rates(frm, &ic->ic_sup_rates[mode]); 
    1680         frm = ieee80211_add_xrates(frm, &ic->ic_sup_rates[mode]); 
     1679        frm = ieee80211_add_rates(frm, &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)]); 
     1680        frm = ieee80211_add_xrates(frm, &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)]); 
    16811681 
    16821682        if (optie != NULL) { 
    16831683                memcpy(frm, optie, optielen); 
  • net80211/ieee80211_proto.c

    a b ieee80211_fix_rate(struct ieee80211_node 
    404404 
    405405        error = 0; 
    406406        okrate = badrate = fixedrate = 0; 
    407         srs = &ic->ic_sup_rates[ieee80211_chan2mode(ni->ni_chan)]; 
     407        srs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, -1)]; 
    408408        nrs = &ni->ni_rates; 
    409409        fixedrate = IEEE80211_FIXED_RATE_NONE; 
    410410        for (i = 0; i < nrs->rs_nrates;) { 
    ieee80211_new_state(struct ieee80211vap  
    14011401        IEEE80211_VAPS_UNLOCK_IRQ(ic); 
    14021402        return rc; 
    14031403} 
     1404EXPORT_SYMBOL(ieee80211_new_state); 
    14041405 
    14051406static int 
    14061407__ieee80211_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 
  • ath_rate/minstrel/minstrel.c

    a b calc_usecs_unicast_packet(struct ath_sof 
    195195                        return 0; 
    196196                } 
    197197 
    198                 /* XXX: Getting MAC/PHY level timings should be fixed for turbo 
    199                  * rates, and there is probably a way to get this from the 
    200                  * HAL... */ 
    201                 switch (rt->info[rix].phy) { 
    202                 case IEEE80211_T_OFDM: 
    203 #if 0 
    204                         t_slot = 9; 
    205                         t_sifs = 16; 
    206                         t_difs = 28; 
    207                         /* fall through */ 
    208 #endif 
    209                 case IEEE80211_T_TURBO: 
    210                         t_slot = 9; 
    211                         t_sifs = 8; 
    212                         t_difs = 28; 
    213                         break; 
    214                 case IEEE80211_T_DS: 
    215                         /* Fall through to default */ 
    216                 default: 
    217                         /* pg. 205 ieee.802.11.pdf */ 
    218                         t_slot = 20; 
    219                         t_difs = 50; 
    220                         t_sifs = 10; 
    221                 } 
    222  
     198                ath_get_timings(sc, &t_slot, &t_sifs, &t_difs); 
    223199                if ((ic->ic_flags & IEEE80211_F_USEPROT) && 
    224200                (rt->info[rix].phy == IEEE80211_T_OFDM)) { 
    225201                        if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 
  • ath_rate/sample/sample.c

    a b calc_usecs_unicast_packet(struct ath_sof 
    172172         * rates, and there is probably a way to get this from the 
    173173         * hal... 
    174174         */ 
    175         switch (rt->info[rix].phy) { 
    176         case IEEE80211_T_OFDM: 
    177                 t_slot = 9; 
    178                 t_sifs = 16; 
    179                 t_difs = 28; 
    180                 /* fall through */ 
    181         case IEEE80211_T_TURBO: 
    182                 t_slot = 9; 
    183                 t_sifs = 8; 
    184                 t_difs = 28; 
    185                 break; 
    186         case IEEE80211_T_DS: 
    187                 /* fall through to default */ 
    188         default: 
    189                 /* pg 205 ieee.802.11.pdf */ 
    190                 t_slot = 20; 
    191                 t_difs = 50; 
    192                 t_sifs = 10; 
    193         } 
    194  
     175        ath_get_timings(sc, &t_slot, &t_sifs, &t_difs); 
    195176        rts = cts = 0; 
    196177 
    197178        if ((ic->ic_flags & IEEE80211_F_USEPROT) && 
  • net80211/ieee80211_wireless.c

    a b ieee80211_ioctl_setmode(struct net_devic 
    21332133 
    21342134                vap->iv_des_mode = mode; 
    21352135                if (IS_UP_AUTO(vap)) 
    2136                         ieee80211_new_state(vap, IEEE80211_S_SCAN, 0); 
     2136                        ieee80211_init(vap->iv_dev, 0); 
    21372137 
    21382138                retv = 0; 
    21392139        } 
    ieee80211_ioctl_getchanlist(struct net_d 
    40814081        return 0; 
    40824082} 
    40834083 
     4084static int alreadyListed(struct ieee80211req_chaninfo *chans, u_int16_t mhz) 
     4085{ 
     4086        int i; 
     4087        for (i = 0; i < chans->ic_nchans; i++) { 
     4088                if (chans->ic_chans[i].ic_freq == mhz) 
     4089                        return 1; 
     4090        } 
     4091        return 0; 
     4092} 
     4093 
    40844094static int 
    40854095ieee80211_ioctl_getchaninfo(struct net_device *dev, 
    4086         struct iw_request_info *info, void *w, char *extra) 
     4096                            struct iw_request_info *info, void *w, char *extra) 
    40874097{ 
    40884098        struct ieee80211vap *vap = dev->priv; 
    40894099        struct ieee80211com *ic = vap->iv_ic; 
    4090         struct ieee80211req_chaninfo chans; 
     4100        struct ieee80211req_chaninfo *chans = 
     4101            (struct ieee80211req_chaninfo *)extra; 
     4102 
    40914103        u_int8_t reported[IEEE80211_CHAN_BYTES];        /* XXX stack usage? */ 
    40924104        int i; 
    40934105 
    4094         memset(&chans, 0, sizeof(chans)); 
    4095         memset(&reported, 0, sizeof(reported)); 
     4106        memset(chans, 0, sizeof(*chans)); 
     4107        memset(reported, 0, sizeof(reported)); 
    40964108        for (i = 0; i < ic->ic_nchans; i++) { 
    40974109                const struct ieee80211_channel *c = &ic->ic_channels[i]; 
    40984110                const struct ieee80211_channel *c1 = c; 
    40994111 
    4100                 if (isclr(reported, c->ic_ieee)) { 
     4112                if (!alreadyListed(chans, c->ic_freq)) { 
    41014113                        setbit(reported, c->ic_ieee); 
    41024114 
    4103                         /* pick turbo channel over non-turbo channel, and 
    4104                          * 11g channel over 11b channel */ 
    41054115                        if (IEEE80211_IS_CHAN_A(c)) 
    4106                                 c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_TURBO_A); 
     4116                                c1 = findchannel(ic, c->ic_freq, 
     4117                                                 IEEE80211_MODE_TURBO_A); 
    41074118                        if (IEEE80211_IS_CHAN_ANYG(c)) 
    4108                                 c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_TURBO_G); 
     4119                                c1 = findchannel(ic, c->ic_freq, 
     4120                                                 IEEE80211_MODE_TURBO_G); 
    41094121                        else if (IEEE80211_IS_CHAN_B(c)) { 
    4110                                 c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_TURBO_G); 
     4122                                c1 = findchannel(ic, c->ic_freq, 
     4123                                                 IEEE80211_MODE_TURBO_G); 
    41114124                                if (!c1) 
    4112                                         c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_11G); 
     4125                                        c1 = findchannel(ic, c->ic_freq, 
     4126                                                         IEEE80211_MODE_11G); 
    41134127                        } 
    41144128 
    41154129                        if (c1) 
    41164130                                c = c1; 
    4117                         /* Copy the entire structure, whereas it used to just copy a few fields */ 
    4118                         memcpy(&chans.ic_chans[chans.ic_nchans], c, sizeof(struct ieee80211_channel)); 
    4119                         if (++chans.ic_nchans >= IEEE80211_CHAN_MAX) 
     4131                        chans->ic_chans[chans->ic_nchans].ic_ieee = c->ic_ieee; 
     4132                        chans->ic_chans[chans->ic_nchans].ic_freq = c->ic_freq; 
     4133                        chans->ic_chans[chans->ic_nchans].ic_flags = c->ic_flags; 
     4134                        if (++chans->ic_nchans >= IEEE80211_CHAN_MAX) 
    41204135                                break; 
    41214136                } 
    41224137        } 
    4123         memcpy(extra, &chans, sizeof(struct ieee80211req_chaninfo)); 
    41244138        return 0; 
    41254139} 
    41264140 
  • net80211/ieee80211_scan_ap.c

    a b pick_channel(struct ieee80211_scan_state 
    512512        int ss_last = ss->ss_last; 
    513513        struct ieee80211_channel *best; 
    514514        struct ap_state *as = ss->ss_priv; 
    515         struct channel chans[ss_last]; /* actually ss_last-1 is required */ 
     515        struct channel *chans; /* actually ss_last-1 is required */ 
    516516        struct channel *c = NULL; 
    517517        struct pc_params params = { vap, ss, flags }; 
    518518        int benefit = 0; 
    519519        int sta_assoc = 0; 
    520520 
     521        chans = (struct channel *)kmalloc(ss_last*sizeof(struct channel),GFP_ATOMIC); 
    521522        for (i = 0; i < ss_last; i++) { 
    522523                chans[i].chan = ss->ss_chans[i]; 
    523524                chans[i].orig = i; 
    pick_channel(struct ieee80211_scan_state 
    571572                                "%s: best: channel %u rssi %d\n", 
    572573                                __func__, i, as->as_maxrssi[i]); 
    573574        } 
     575        kfree(chans); 
    574576        return best; 
    575577} 
    576578 
    ap_end(struct ieee80211_scan_state *ss,  
    609611                res = 1; /* Do NOT restart scan */ 
    610612        } else { 
    611613                struct ieee80211_scan_entry se; 
     614                int i; 
    612615                /* XXX: notify all VAPs? */ 
    613616                /* if this is a dynamic turbo frequency , start with normal  
    614617                 * mode first */ 
    ap_end(struct ieee80211_scan_state *ss,  
    623626                                return 0; 
    624627                        } 
    625628                } 
     629                for (i = (bestchan - &ic->ic_channels[0])/sizeof(*bestchan) + 1; i < ic->ic_nchans; i++) { 
     630                        if ((ic->ic_channels[i].ic_freq == bestchan->ic_freq) && 
     631                                IEEE80211_IS_CHAN_ANYG(&ic->ic_channels[i])) 
     632                                bestchan = &ic->ic_channels[i]; 
     633                } 
    626634                memset(&se, 0, sizeof(se)); 
    627635                se.se_chan = bestchan; 
    628636 
  • tools/wlanconfig.c

    a b list_channels(const char *ifname, int al 
    737737        if (get80211priv(ifname, IEEE80211_IOCTL_GETCHANINFO, &chans, sizeof(chans)) < 0) 
    738738                errx(1, "unable to get channel information"); 
    739739        if (!allchans) { 
    740                 uint8_t active[32]; 
     740                uint8_t active[IEEE80211_CHAN_BYTES]; 
    741741 
    742742                if (get80211priv(ifname, IEEE80211_IOCTL_GETCHANLIST, &active, sizeof(active)) < 0) 
    743743                        errx(1, "unable to get active channel list"); 
  • net80211/ieee80211_scan.c

    a b ieee80211_scan_assoc_fail(struct ieee802 
    10441044                ss->ss_ops->scan_assoc_fail(ss, mac, reason); 
    10451045        } 
    10461046} 
     1047EXPORT_SYMBOL(ieee80211_scan_flush); 
    10471048 
    10481049/* 
    10491050 * Iterate over the contents of the scan cache. 
  • ath/if_ath_hal_wrappers.h

    a b static inline HAL_BOOL ath_hal_getregdom 
    111111        return (ath_hal_getcapability(ah, HAL_CAP_REG_DMN, 0, destination) == HAL_OK); 
    112112} 
    113113 
     114static inline HAL_BOOL ath_hal_setregdomain(struct ath_hal *ah, u_int32_t v) 
     115{ 
     116        return (ath_hal_setcapability(ah, HAL_CAP_REG_DMN, 0, v, NULL)); 
     117} 
     118 
    114119static inline HAL_BOOL ath_hal_gettkipmic(struct ath_hal *ah) 
    115120{ 
    116121        return (ath_hal_getcapability(ah, HAL_CAP_TKIP_MIC, 1, NULL) == HAL_OK); 
Note: See TracBrowser for help on using the repository browser.