Please note: This project is no longer active. The website is kept online for historic purposes only.
If you´re looking for a Linux driver for your Atheros WLAN device, you should continue here .

Ticket #900: ath-mib-irq-status-debug.diff

File ath-mib-irq-status-debug.diff, 60.0 kB (added by anonymous, 13 years ago)
  • madwifi-ng/ath/if_ath.c

    old new  
    167167static u_int32_t ath_get_icvlen(struct ieee80211_key *); 
    168168static u_int32_t ath_get_ivlen(struct ieee80211_key *); 
    169169static void ath_setup_comp(struct ieee80211_node *, int); 
    170 static void ath_comp_set(struct ieee80211vap *, struct ieee80211_node *, int);  
     170static void ath_comp_set(struct ieee80211vap *, struct ieee80211_node *, int); 
    171171#endif 
    172172static int ath_tx_setup(struct ath_softc *, int, int); 
    173173static int ath_wme_update(struct ieee80211com *); 
     
    242242static void ath_check_dfs_clear(unsigned long); 
    243243static const char *ath_get_hal_status_desc(HAL_STATUS status); 
    244244static int ath_rcv_dev_event(struct notifier_block *, unsigned long, void *); 
    245          
     245 
    246246static int ath_calinterval = ATH_SHORT_CALINTERVAL;             /* 
    247247                                                                 * calibrate every 30 secs in steady state 
    248248                                                                 * but check every second at first. 
     
    504504 
    505505        if (rfkill != -1) { 
    506506                printk(KERN_INFO "ath_pci: switching rfkill capability %s\n", 
    507                         rfkill ? "on" : "off");         
     507                        rfkill ? "on" : "off"); 
    508508                ath_hal_setrfsilent(ah, rfkill); 
    509509        } 
    510510 
     
    700700        ic->ic_phytype = IEEE80211_T_OFDM; 
    701701        ic->ic_opmode = IEEE80211_M_STA; 
    702702        sc->sc_opmode = HAL_M_STA; 
    703         /*  
    704          * Set the Atheros Advanced Capabilities from station config before  
    705          * starting 802.11 state machine.  Currently, set only fast-frames  
     703        /* 
     704         * Set the Atheros Advanced Capabilities from station config before 
     705         * starting 802.11 state machine.  Currently, set only fast-frames 
    706706         * capability. 
    707707         */ 
    708708        ic->ic_ath_cap = 0; 
     
    713713        ic->ic_ath_cap |= (ath_hal_burstsupported(ah) ? IEEE80211_ATHC_BURST : 0); 
    714714 
    715715#ifdef ATH_SUPERG_COMP 
    716         ic->ic_ath_cap |= (ath_hal_compressionsupported(ah) ? IEEE80211_ATHC_COMP : 0);  
     716        ic->ic_ath_cap |= (ath_hal_compressionsupported(ah) ? IEEE80211_ATHC_COMP : 0); 
    717717#endif 
    718718 
    719719#ifdef ATH_SUPERG_DYNTURBO 
     
    761761                        if (ath_hal_wmetkipmic(ah)) 
    762762                                ic->ic_caps |= IEEE80211_C_WME_TKIPMIC; 
    763763                } 
    764   
     764 
    765765                if (ath_hal_tkipsplit(ah)) 
    766766                        sc->sc_splitmic = 1; 
    767767        } 
     
    783783         * Default 11.h to start enabled. 
    784784         */ 
    785785        ic->ic_flags |= IEEE80211_F_DOTH; 
    786          
     786 
    787787        /* 
    788788         * Check for misc other capabilities. 
    789789         */ 
     
    891891                        autocreatemode = -1; 
    892892                } 
    893893        } 
    894          
     894 
    895895        if (autocreatemode != -1) { 
    896896                rtnl_lock(); 
    897897                error = ieee80211_create_vap(ic, "ath%d", dev, 
     
    994994                if (flags & IEEE80211_NO_STABEACONS) { 
    995995                        sc->sc_nostabeacons = 1; 
    996996                        ic_opmode = IEEE80211_M_HOSTAP; /* Run with chip in AP mode */ 
    997                 } else  
     997                } else 
    998998                        ic_opmode = opmode; 
    999999                break; 
    10001000        case IEEE80211_M_IBSS: 
     
    10401040                /* XXX msg */ 
    10411041                return NULL; 
    10421042        } 
    1043          
     1043 
    10441044        avp = dev->priv; 
    10451045        ieee80211_vap_setup(ic, dev, name, unit, opmode, flags); 
    10461046        /* override with driver methods */ 
     
    10681068            sc->sc_nvaps != 0 && opmode != IEEE80211_M_WDS && sc->sc_hasbmask) { 
    10691069                struct ieee80211vap *v; 
    10701070                int id_mask, id; 
    1071                  
     1071 
    10721072                /* 
    10731073                 * Hardware supports the bssid mask and a unique 
    10741074                 * bssid was requested.  Assign a new mac address 
    10751075                 * and expand our bssid mask to cover the active 
    10761076                 * virtual ap's with distinct addresses. 
    10771077                 */ 
    1078                  
     1078 
    10791079                /* do a full search to mark all the allocated vaps */ 
    10801080                id_mask = 0; 
    10811081                TAILQ_FOREACH(v, &ic->ic_vaps, iv_next) 
    10821082                        id_mask |= (1 << ATH_GET_VAP_ID(v->iv_myaddr)); 
    1083                  
     1083 
    10841084                for (id = 0; id < ATH_BCBUF; id++) { 
    10851085                        /* get the first available slot */ 
    10861086                        if ((id_mask & (1 << id)) == 0) { 
     
    11431143                ieee80211_media_change, ieee80211_media_status); 
    11441144 
    11451145        ic->ic_opmode = ic_opmode; 
    1146          
     1146 
    11471147        if (opmode != IEEE80211_M_WDS) 
    11481148                sc->sc_nvaps++; 
    1149                  
     1149 
    11501150        if (opmode == IEEE80211_M_STA) 
    11511151                sc->sc_nstavaps++; 
    11521152        else if (opmode == IEEE80211_M_MONITOR) 
     
    12381238        if (decrease) 
    12391239                sc->sc_nvaps--; 
    12401240 
    1241 #ifdef ATH_SUPERG_XR  
     1241#ifdef ATH_SUPERG_XR 
    12421242        /* 
    12431243         * if its an XR vap ,free the memory allocated explicitly. 
    12441244         * since the XR vap is not registered , OS can not free the memory. 
     
    13361336                        break; 
    13371337                } 
    13381338                if (bf->bf_status & ATH_BUFSTATUS_DONE) { 
    1339                         /*  
     1339                        /* 
    13401340                         * already processed this buffer (shouldn't occur if 
    13411341                         * we change code to always process descriptors in 
    13421342                         * rx intr handler - as opposed to sometimes processing 
     
    13551355                 *          of ath_hal_rxprocdesc we require for trigger search. 
    13561356                 */ 
    13571357 
    1358                 /*  
     1358                /* 
    13591359                 * NB: descriptor memory doesn't need to be sync'd 
    1360                  *     due to the way it was allocated.  
     1360                 *     due to the way it was allocated. 
    13611361                 */ 
    13621362 
    13631363                /* 
     
    13831383                        continue; 
    13841384 
    13851385                /* prepare wireless header for examination */ 
    1386                 bus_dma_sync_single(sc->sc_bdev, bf->bf_skbaddr,  
    1387                                                         sizeof(struct ieee80211_qosframe),  
     1386                bus_dma_sync_single(sc->sc_bdev, bf->bf_skbaddr, 
     1387                                                        sizeof(struct ieee80211_qosframe), 
    13881388                                                        BUS_DMA_FROMDEVICE); 
    13891389                qwh = (struct ieee80211_qosframe *) skb->data; 
    13901390 
    13911391                /* find the node. it MUST be in the keycache. */ 
    13921392                if (ds->ds_rxstat.rs_keyix == HAL_RXKEYIX_INVALID || 
    13931393                    (ni = sc->sc_keyixmap[ds->ds_rxstat.rs_keyix]) == NULL) { 
    1394                         /*  
     1394                        /* 
    13951395                         * XXX: this can occur if WEP mode is used for non-atheros clients 
    13961396                         *      (since we do not know which of the 4 WEP keys will be used 
    13971397                         *      at association time, so cannot setup a key-cache entry. 
     
    14081408#endif 
    14091409                        continue; 
    14101410                } 
    1411                  
     1411 
    14121412                if (!(ni->ni_flags & IEEE80211_NODE_UAPSD)) 
    14131413                        continue; 
    1414                  
     1414 
    14151415                /* 
    14161416                 * Must deal with change of state here, since otherwise there would 
    14171417                 * be a race (on two quick frames from STA) between this code and the 
     
    14361436                                ic->ic_uapsdmaxtriggers++; 
    14371437                                WME_UAPSD_NODE_TRIGSEQINIT(ni); 
    14381438                                DPRINTF(sc, ATH_DEBUG_UAPSD, 
    1439                                         "%s: Node (%s) became U-APSD triggerable (%d)\n",  
     1439                                        "%s: Node (%s) became U-APSD triggerable (%d)\n", 
    14401440                                        __func__, ether_sprintf(qwh->i_addr2), 
    14411441                                        ic->ic_uapsdmaxtriggers); 
    14421442                        } else { 
    14431443                                ni->ni_flags &= ~IEEE80211_NODE_UAPSD_TRIG; 
    14441444                                ic->ic_uapsdmaxtriggers--; 
    14451445                                DPRINTF(sc, ATH_DEBUG_UAPSD, 
    1446                                         "%s: Node (%s) no longer U-APSD triggerable (%d)\n",  
     1446                                        "%s: Node (%s) no longer U-APSD triggerable (%d)\n", 
    14471447                                        __func__, ether_sprintf(qwh->i_addr2), 
    14481448                                        ic->ic_uapsdmaxtriggers); 
    1449                                 /*  
    1450                                  * XXX: rapidly thrashing sta could get  
     1449                                /* 
     1450                                 * XXX: rapidly thrashing sta could get 
    14511451                                 * out-of-order frames due this flush placing 
    14521452                                 * frames on backlogged regular AC queue and 
    14531453                                 * re-entry to PS having fresh arrivals onto 
     
    14561456                                 */ 
    14571457                                ath_uapsd_flush(ni); 
    14581458                        } 
    1459                          
     1459 
    14601460                        continue; 
    14611461                } 
    14621462 
    14631463                if (ic->ic_uapsdmaxtriggers == 0) 
    14641464                        continue; 
    1465                  
     1465 
    14661466                /* make sure the frame is QoS data/null */ 
    1467                 /* NB: with current sub-type definitions, the  
    1468                  * IEEE80211_FC0_SUBTYPE_QOS check, below, covers the  
     1467                /* NB: with current sub-type definitions, the 
     1468                 * IEEE80211_FC0_SUBTYPE_QOS check, below, covers the 
    14691469                 * qos null case too. 
    14701470                 */ 
    14711471                if (((qwh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) || 
    14721472                     !(qwh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS)) 
    14731473                        continue; 
    1474                  
     1474 
    14751475                /* 
    14761476                 * To be a trigger: 
    14771477                 *   - node is in triggerable state 
     
    14811481                ac = TID_TO_WME_AC(tid); 
    14821482                if (!WME_UAPSD_AC_CAN_TRIGGER(ac, ni)) 
    14831483                        continue; 
    1484                  
    1485                 DPRINTF(sc, ATH_DEBUG_UAPSD,  
     1484 
     1485                DPRINTF(sc, ATH_DEBUG_UAPSD, 
    14861486                        "%s: U-APSD trigger detected for node (%s) on AC %d\n", 
    14871487                        __func__, ether_sprintf(ni->ni_macaddr), ac); 
    14881488                if (ni->ni_flags & IEEE80211_NODE_UAPSD_SP) { 
     
    15181518                        DPRINTF(sc, ATH_DEBUG_UAPSD, 
    15191519                                "%s: Queue empty, generating QoS NULL to send\n", 
    15201520                                __func__); 
    1521                         /*  
     1521                        /* 
    15221522                         * Empty queue, so need to send qos null on this ac. Make a 
    15231523                         * call that will dump a qos null onto the node's queue, then 
    15241524                         * we can proceed as normal. 
     
    15301530                        struct ath_buf *last_buf = STAILQ_LAST(&an->an_uapsd_q, ath_buf, bf_list); 
    15311531                        struct ath_desc *last_desc = last_buf->bf_desc; 
    15321532                        struct ieee80211_qosframe *qwhl = (struct ieee80211_qosframe *)last_buf->bf_skb->data; 
    1533                         /*  
     1533                        /* 
    15341534                         * NB: flip the bit to cause intr on the EOSP desc, 
    15351535                         * which is the last one 
    15361536                         */ 
     
    15411541                                /* simulate lost EOSP */ 
    15421542                                qwhl->i_addr1[0] |= 0x40; 
    15431543                        } 
    1544                          
     1544 
    15451545                        /* more data bit only for EOSP frame */ 
    15461546                        if (an->an_uapsd_overflowqdepth) 
    15471547                                qwhl->i_fc[1] |= IEEE80211_FC1_MORE_DATA; 
     
    15521552 
    15531553                        bus_dma_sync_single(sc->sc_bdev, last_buf->bf_skbaddr, 
    15541554                                sizeof(*qwhl), BUS_DMA_TODEVICE); 
    1555                          
     1555 
    15561556                        if (uapsd_xmit_q->axq_link) { 
    15571557#ifdef AH_NEED_DESC_SWAP 
    15581558                                *uapsd_xmit_q->axq_link = cpu_to_le32(STAILQ_FIRST(&an->an_uapsd_q)->bf_daddr); 
     
    15631563                        /* below leaves an_uapsd_q NULL */ 
    15641564                        STAILQ_CONCAT(&uapsd_xmit_q->axq_q, &an->an_uapsd_q); 
    15651565                        uapsd_xmit_q->axq_link = &last_desc->ds_link; 
    1566                         ath_hal_puttxbuf(sc->sc_ah,  
    1567                                 uapsd_xmit_q->axq_qnum,  
     1566                        ath_hal_puttxbuf(sc->sc_ah, 
     1567                                uapsd_xmit_q->axq_qnum, 
    15681568                                (STAILQ_FIRST(&uapsd_xmit_q->axq_q))->bf_daddr); 
    15691569                        ath_hal_txstart(sc->sc_ah, uapsd_xmit_q->axq_qnum); 
    15701570                } 
     
    15861586        struct net_device *dev = dev_id; 
    15871587        struct ath_softc *sc = dev->priv; 
    15881588        struct ath_hal *ah = sc->sc_ah; 
    1589         HAL_INT status
    1590         int needmark
     1589        HAL_INT status, saved
     1590        int needmark, i
    15911591 
    15921592        if (sc->sc_invalid) { 
    15931593                /* 
     
    16061606                return IRQ_HANDLED; 
    16071607        } 
    16081608        needmark = 0; 
    1609         /* 
    1610          * Figure out the reason(s) for the interrupt.  Note 
    1611          * that the hal returns a pseudo-ISR that may include 
    1612          * bits we haven't explicitly enabled so we mask the 
    1613          * value to ensure we only process bits we requested. 
    1614          */ 
    1615         ath_hal_getisr(ah, &status);            /* NB: clears ISR too */ 
    1616         DPRINTF(sc, ATH_DEBUG_INTR, "%s: status 0x%x\n", __func__, status); 
    1617         status &= sc->sc_imask;                 /* discard unasked for bits */ 
    1618         if (status & HAL_INT_FATAL) { 
    1619                 sc->sc_stats.ast_hardware++; 
    1620                 ath_hal_intrset(ah, 0);         /* disable intr's until reset */ 
    1621                 ATH_SCHEDULE_TQUEUE(&sc->sc_fataltq, &needmark); 
    1622         } else if (status & HAL_INT_RXORN) { 
    1623                 sc->sc_stats.ast_rxorn++; 
    1624                 ath_hal_intrset(ah, 0);         /* disable intr's until reset */ 
    1625                 ATH_SCHEDULE_TQUEUE(&sc->sc_rxorntq, &needmark); 
    1626         } else { 
    1627                 if (status & HAL_INT_SWBA) { 
    1628                         /* 
    1629                          * Software beacon alert--time to send a beacon. 
    1630                          * Handle beacon transmission directly; deferring 
    1631                          * this is too slow to meet timing constraints 
    1632                          * under load. 
    1633                          */ 
    1634                         ath_beacon_send(sc, &needmark); 
    1635                 } 
    1636                 if (status & HAL_INT_RXEOL) { 
    1637                         /* 
    1638                          * NB: the hardware should re-read the link when 
    1639                          *     RXE bit is written, but it doesn't work at 
    1640                          *     least on older hardware revs. 
    1641                          */ 
    1642                         sc->sc_stats.ast_rxeol++; 
    1643                 } 
    1644                 if (status & HAL_INT_TXURN) { 
    1645                         sc->sc_stats.ast_txurn++; 
    1646                         /* bump tx trigger level */ 
    1647                         ath_hal_updatetxtriglevel(ah, AH_TRUE); 
    1648                 } 
    1649                 if (status & HAL_INT_RX) { 
    1650                         ath_uapsd_processtriggers(sc); 
    1651                         ATH_SCHEDULE_TQUEUE(&sc->sc_rxtq, &needmark); 
     1609 
     1610        for(i=0; i < 5; i++) { 
     1611                /* 
     1612                 * Figure out the reason(s) for the interrupt.  Note 
     1613                 * that the hal returns a pseudo-ISR that may include 
     1614                 * bits we haven't explicitly enabled so we mask the 
     1615                 * value to ensure we only process bits we requested. 
     1616                 */ 
     1617                ath_hal_getisr(ah, &status);            /* NB: clears ISR too */ 
     1618                saved = status; 
     1619                status &= sc->sc_imask;                 /* discard unasked for bits */ 
     1620 
     1621                if ((i > 0) && (status == 0)) { 
     1622                        break; 
    16521623                } 
    1653                 if (status & HAL_INT_TX) { 
     1624 
     1625                DPRINTF(sc, ATH_DEBUG_INTR, "%s: status 0x%x\n", __func__, status); 
     1626                if (status & HAL_INT_FATAL) { 
     1627                        sc->sc_stats.ast_hardware++; 
     1628                        ath_hal_intrset(ah, 0);         /* disable intr's until reset */ 
     1629                        ATH_SCHEDULE_TQUEUE(&sc->sc_fataltq, &needmark); 
     1630                } else if (status & HAL_INT_RXORN) { 
     1631                        sc->sc_stats.ast_rxorn++; 
     1632                        ath_hal_intrset(ah, 0);         /* disable intr's until reset */ 
     1633                        ATH_SCHEDULE_TQUEUE(&sc->sc_rxorntq, &needmark); 
     1634                } else { 
     1635                        if (status & HAL_INT_SWBA) { 
     1636                                /* 
     1637                                 * Software beacon alert--time to send a beacon. 
     1638                                 * Handle beacon transmission directly; deferring 
     1639                                 * this is too slow to meet timing constraints 
     1640                                 * under load. 
     1641                                 */ 
     1642                                ath_beacon_send(sc, &needmark); 
     1643                        } 
     1644                        if (status & HAL_INT_RXEOL) { 
     1645                                /* 
     1646                                 * NB: the hardware should re-read the link when 
     1647                                 *     RXE bit is written, but it doesn't work at 
     1648                                 *     least on older hardware revs. 
     1649                                 */ 
     1650                                sc->sc_stats.ast_rxeol++; 
     1651                        } 
     1652                        if (status & HAL_INT_TXURN) { 
     1653                                sc->sc_stats.ast_txurn++; 
     1654                                /* bump tx trigger level */ 
     1655                                ath_hal_updatetxtriglevel(ah, AH_TRUE); 
     1656                        } 
     1657                        if (status & HAL_INT_RX) { 
     1658                                ath_uapsd_processtriggers(sc); 
     1659                                ATH_SCHEDULE_TQUEUE(&sc->sc_rxtq, &needmark); 
     1660                        } 
     1661                        if (status & HAL_INT_TX) { 
    16541662#ifdef ATH_SUPERG_DYNTURBO 
    1655                         /* 
    1656                          * Check if the beacon queue caused the interrupt  
    1657                         * when a dynamic turbo switch 
    1658                          * is pending so we can initiate the change.  
    1659                         * XXX must wait for all vap's beacons 
    1660                         */ 
     1663                               /* 
     1664                                * Check if the beacon queue caused the interrupt 
     1665                                * when a dynamic turbo switch 
     1666                                * is pending so we can initiate the change. 
     1667                                * XXX must wait for all vap's beacons 
     1668                                */ 
    16611669 
    1662                         if (sc->sc_dturbo_switch) { 
    1663                                 u_int32_t txqs = (1 << sc->sc_bhalq); 
    1664                                 ath_hal_gettxintrtxqs(ah, &txqs); 
    1665                                 if(txqs & (1 << sc->sc_bhalq)) { 
    1666                                         sc->sc_dturbo_switch = 0; 
    1667                                         /* 
    1668                                         * Hack: defer switch for 10ms to permit slow 
    1669                                         * clients time to track us.  This especially 
    1670                                         * noticeable with Windows clients. 
    1671                                         */ 
    1672                                         mod_timer(&sc->sc_dturbo_switch_mode, 
     1670                               if (sc->sc_dturbo_switch) { 
     1671                                       u_int32_t txqs = (1 << sc->sc_bhalq); 
     1672                                       ath_hal_gettxintrtxqs(ah, &txqs); 
     1673                                       if(txqs & (1 << sc->sc_bhalq)) { 
     1674                                               sc->sc_dturbo_switch = 0; 
     1675                                               /* 
     1676                                                * Hack: defer switch for 10ms to permit slow 
     1677                                                * clients time to track us.  This especially 
     1678                                                * noticeable with Windows clients. 
     1679                                                */ 
     1680                                               mod_timer(&sc->sc_dturbo_switch_mode, 
    16731681                                                          jiffies + msecs_to_jiffies(10)); 
     1682                                        } 
    16741683                                } 
    1675                         }  
    16761684#endif 
    1677                         ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, &needmark); 
    1678                 } 
    1679                 if (status & HAL_INT_BMISS) { 
    1680                         sc->sc_stats.ast_bmiss++; 
    1681                         ATH_SCHEDULE_TQUEUE(&sc->sc_bmisstq, &needmark); 
    1682                 } 
    1683                 if (status & HAL_INT_MIB) { 
    1684                         sc->sc_stats.ast_mib++; 
    1685                         /* 
    1686                          * Disable interrupts until we service the MIB 
    1687                          * interrupt; otherwise it will continue to fire. 
    1688                          */ 
    1689                         ath_hal_intrset(ah, 0); 
    1690                         /* 
    1691                          * Let the hal handle the event.  We assume it will 
    1692                          * clear whatever condition caused the interrupt. 
    1693                          */ 
    1694                         ath_hal_mibevent(ah, &sc->sc_halstats); 
    1695                         ath_hal_intrset(ah, sc->sc_imask); 
     1685                                ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, &needmark); 
     1686                        } 
     1687                        if (status & HAL_INT_BMISS) { 
     1688                                sc->sc_stats.ast_bmiss++; 
     1689                                ATH_SCHEDULE_TQUEUE(&sc->sc_bmisstq, &needmark); 
     1690                        } 
     1691                        if (status & HAL_INT_MIB) { 
     1692                                int i; 
     1693                                HAL_INT mibstatus; 
     1694 
     1695                                sc->sc_stats.ast_mib++; 
     1696                                /* 
     1697                                 * Let the hal handle the event.  We assume it will 
     1698                                 * clear whatever condition caused the interrupt. 
     1699                                 */ 
     1700 
     1701                                for(i=0; i < 3; i++) { 
     1702                                        /* 
     1703                                         * Disable interrupts until we service the MIB 
     1704                                         * interrupt; otherwise it will continue to fire. 
     1705                                         */ 
     1706                                        ath_hal_intrset(ah, 0); 
     1707 
     1708                                        ath_hal_mibevent(ah, &sc->sc_halstats); 
     1709                                        ath_hal_intrset(ah, sc->sc_imask); 
     1710 
     1711                                        ath_hal_getisr(ah, &mibstatus); 
     1712 
     1713                                        if (!(mibstatus & HAL_INT_MIB)) 
     1714                                                break; 
     1715                                } 
     1716 
     1717                                if (i > 0) { 
     1718                                        printk("ath_intr(): MIB retry count: %d, status: 0x%0X, mibstatus: 0x%0X\n", 
     1719                                               i, status, mibstatus); 
     1720                                } 
     1721 
     1722                                if (mibstatus & HAL_INT_MIB) { 
     1723                                        printk("ath_intr(): mibstatus: 0x%0X, HAL_INT_MIB is not cleared.\n", 
     1724                                               mibstatus); 
     1725                                        sc->sc_stats.ast_hardware++; 
     1726                                        ath_hal_intrset(ah, 0);         /* disable intr's until reset */ 
     1727                                        ATH_SCHEDULE_TQUEUE(&sc->sc_fataltq, &needmark); 
     1728                                } 
     1729                        } 
    16961730                } 
    16971731        } 
     1732 
     1733        if ((i == 5) && (status != 0)) { 
     1734                printk("count: %d, saved: %0X, masked: %0X\n", i, saved, status); 
     1735        } 
     1736 
    16981737        if (needmark) 
    16991738                mark_bh(IMMEDIATE_BH); 
    17001739        return IRQ_HANDLED; 
     
    17421781static void 
    17431782ath_dfs_test_return(unsigned long data) 
    17441783{ 
    1745         struct ath_softc *sc = (struct ath_softc *)data;  
     1784        struct ath_softc *sc = (struct ath_softc *)data; 
    17461785        struct ieee80211com *ic = &sc->sc_ic; 
    17471786 
    17481787        sc->sc_dfstest = 0; 
     
    18391878                else 
    18401879                        ath_hal_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 1, NULL); 
    18411880        } 
    1842                  
     1881 
    18431882        /* 
    18441883         * Flush the skb's allocated for receive in case the rx 
    18451884         * buffer size changes.  This could be optimized but for 
     
    19211960        return error; 
    19221961} 
    19231962 
    1924 /* Caller must lock ATH_LOCK  
     1963/* Caller must lock ATH_LOCK 
    19251964 * 
    19261965 * Context: softIRQ 
    1927  */  
     1966 */ 
    19281967static int 
    19291968ath_stop_locked(struct net_device *dev) 
    19301969{ 
     
    19772016        } 
    19782017        if (sc->sc_softled) 
    19792018                ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon); 
    1980          
     2019 
    19812020        return 0; 
    19822021} 
    19832022 
     
    20182057        return error; 
    20192058} 
    20202059 
    2021 static int  
     2060static int 
    20222061ar_device(int devid) 
    20232062{ 
    20242063        switch (devid) { 
     
    20572096        case AR_SUBVENDOR_ID_NOG: 
    20582097        case AR_SUBVENDOR_ID_NEW_A: 
    20592098                return 5213; 
    2060         default:  
     2099        default: 
    20612100                return 0; /* unknown */ 
    20622101        } 
    20632102} 
    20642103 
    20652104 
    2066 static int  
    2067 ath_set_ack_bitrate(struct ath_softc *sc, int high)  
     2105static int 
     2106ath_set_ack_bitrate(struct ath_softc *sc, int high) 
    20682107{ 
    20692108        struct ath_hal *ah = sc->sc_ah; 
    20702109        if (ar_device(sc->devid) == 5212 || ar_device(sc->devid) == 5213) { 
     
    21682207} 
    21692208 
    21702209/* 
    2171  * Insert a buffer on a txq  
    2172  *  
     2210 * Insert a buffer on a txq 
     2211 * 
    21732212 */ 
    21742213static __inline void 
    2175 ath_tx_txqaddbuf(struct ath_softc *sc, struct ieee80211_node *ni,  
    2176         struct ath_txq *txq, struct ath_buf *bf,  
     2214ath_tx_txqaddbuf(struct ath_softc *sc, struct ieee80211_node *ni, 
     2215        struct ath_txq *txq, struct ath_buf *bf, 
    21772216        struct ath_desc *lastds, int framelen) 
    21782217{ 
    21792218        struct ath_hal *ah = sc->sc_ah; 
     
    22332272        sc->sc_devstats.tx_bytes += framelen; 
    22342273} 
    22352274 
    2236 static int  
     2275static int 
    22372276dot11_to_ratecode(struct ath_softc *sc, const HAL_RATE_TABLE *rt, int dot11) 
    22382277{ 
    22392278        int index = sc->sc_rixmap[dot11 & IEEE80211_RATE_VAL]; 
    22402279        if (index >= 0 && index < rt->rateCount) 
    22412280                return rt->info[index].rateCode; 
    2242          
     2281 
    22432282        return rt->info[sc->sc_minrateix].rateCode; 
    22442283} 
    22452284 
    22462285 
    2247 static int  
    2248 ath_tx_startraw(struct net_device *dev, struct ath_buf *bf, struct sk_buff *skb)  
     2286static int 
     2287ath_tx_startraw(struct net_device *dev, struct ath_buf *bf, struct sk_buff *skb) 
    22492288{ 
    22502289        struct ath_softc *sc = dev->priv; 
    22512290        struct ath_hal *ah = sc->sc_ah; 
     
    22612300        u_int8_t antenna, txrate; 
    22622301        struct ath_txq *txq=NULL; 
    22632302        struct ath_desc *ds=NULL; 
    2264         struct ieee80211_frame *wh;  
    2265          
     2303        struct ieee80211_frame *wh; 
     2304 
    22662305        wh = (struct ieee80211_frame *) skb->data; 
    22672306        try0 = ph->try0; 
    22682307        rt = sc->sc_currates; 
     
    22702309        power = ph->power > 60 ? 60 : ph->power; 
    22712310        hdrlen = ieee80211_anyhdrsize(wh); 
    22722311        pktlen = skb->len + IEEE80211_CRC_LEN; 
    2273          
     2312 
    22742313        keyix = HAL_TXKEYIX_INVALID; 
    22752314        flags = HAL_TXDESC_INTREQ | HAL_TXDESC_CLRDMASK; /* XXX needed for crypto errs */ 
    2276          
     2315 
    22772316        bf->bf_skbaddr = bus_map_single(sc->sc_bdev, 
    22782317                                        skb->data, pktlen, BUS_DMA_TODEVICE); 
    22792318        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: skb %p [data %p len %u] skbaddr %llx\n", 
    22802319                __func__, skb, skb->data, skb->len, ito64(bf->bf_skbaddr)); 
    2281          
    2282          
     2320 
     2321 
    22832322        bf->bf_skb = skb; 
    22842323        bf->bf_node = NULL; 
    2285          
     2324 
    22862325#ifdef ATH_SUPERG_FF 
    22872326        bf->bf_numdesc = 1; 
    22882327#endif 
    2289          
     2328 
    22902329        /* setup descriptors */ 
    22912330        ds = bf->bf_desc; 
    22922331        rt = sc->sc_currates; 
    22932332        KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode)); 
    2294          
    2295          
     2333 
     2334 
    22962335        if (IEEE80211_IS_MULTICAST(wh->i_addr1)) { 
    22972336                flags |= HAL_TXDESC_NOACK;      /* no ack on broad/multicast */ 
    22982337                sc->sc_stats.ast_tx_noack++; 
     
    23002339        } 
    23012340        atype = HAL_PKT_TYPE_NORMAL;            /* default */ 
    23022341        txq = sc->sc_ac2q[skb->priority & 0x3]; 
    2303          
    2304          
     2342 
     2343 
    23052344        flags |= HAL_TXDESC_INTREQ; 
    23062345        antenna = sc->sc_txantenna; 
    2307          
     2346 
    23082347        /* XXX check return value? */ 
    23092348        ath_hal_setuptxdesc(ah, ds 
    23102349                            , pktlen    /* packet length */ 
     
    23272366                        , dot11_to_ratecode(sc, rt, ph->rate1), ph->try1 /* series 1 */ 
    23282367                        , dot11_to_ratecode(sc, rt, ph->rate2), ph->try2 /* series 2 */ 
    23292368                        , dot11_to_ratecode(sc, rt, ph->rate3), ph->try3 /* series 3 */ 
    2330                         );      
     2369                        ); 
    23312370        } 
    23322371        bf->bf_flags = flags;                   /* record for post-processing */ 
    23332372 
    23342373        ds->ds_link = 0; 
    23352374        ds->ds_data = bf->bf_skbaddr; 
    2336          
     2375 
    23372376        ath_hal_filltxdesc(ah, ds 
    23382377                           , skb->len   /* segment length */ 
    23392378                           , AH_TRUE    /* first segment */ 
    23402379                           , AH_TRUE    /* last segment */ 
    23412380                           , ds         /* first descriptor */ 
    23422381                           ); 
    2343          
    2344         /* NB: The desc swap function becomes void,  
     2382 
     2383        /* NB: The desc swap function becomes void, 
    23452384         * if descriptor swapping is not enabled 
    23462385         */ 
    23472386        ath_desc_swap(ds); 
    2348          
     2387 
    23492388        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: Q%d: %08x %08x %08x %08x %08x %08x\n", 
    23502389                __func__, M_FLAG_GET(skb, M_UAPSD) ? 0 : txq->axq_qnum, ds->ds_link, ds->ds_data, 
    23512390                ds->ds_ctl0, ds->ds_ctl1, ds->ds_hw[0], ds->ds_hw[1]); 
    2352                  
     2391 
    23532392        ath_tx_txqaddbuf(sc, NULL, txq, bf, ds, pktlen); 
    23542393        return 0; 
    23552394} 
     
    26592698                int bfcnt; 
    26602699 
    26612700                /* 
    2662                 **  Allocate 1 ath_buf for each frame given 1 was  
     2701                **  Allocate 1 ath_buf for each frame given 1 was 
    26632702                **  already alloc'd 
    26642703                */ 
    26652704                ATH_TXBUF_LOCK(sc); 
     
    26702709                        } 
    26712710                        else 
    26722711                                break; 
    2673                          
     2712 
    26742713                        ieee80211_ref_node(ni); 
    26752714                } 
    26762715 
     
    27302769                STAILQ_FOREACH_SAFE(tbf, &bf_head, bf_list, tempbf) { 
    27312770                        tbf->bf_skb = NULL; 
    27322771                        tbf->bf_node = NULL; 
    2733                          
    2734                         if (ni != NULL)  
     2772 
     2773                        if (ni != NULL) 
    27352774                                ieee80211_free_node(ni); 
    27362775 
    27372776                        STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list); 
     
    32733312            sc->sc_opmode == HAL_M_IBSS ||      /* NB: AHDEMO too */ 
    32743313            (sc->sc_nostabeacons) || sc->sc_scanning) 
    32753314                rfilt |= HAL_RX_FILTER_BEACON; 
    3276         if (sc->sc_nmonvaps > 0)  
    3277                 rfilt |= (HAL_RX_FILTER_CONTROL | HAL_RX_FILTER_BEACON |  
     3315        if (sc->sc_nmonvaps > 0) 
     3316                rfilt |= (HAL_RX_FILTER_CONTROL | HAL_RX_FILTER_BEACON | 
    32783317                          HAL_RX_FILTER_PROBEREQ | HAL_RX_FILTER_PROM); 
    32793318        return rfilt; 
    32803319#undef RX_FILTER_PRESERVE 
     
    34253464                sc->sc_dturbo_turbo_tmax = 120 * 1024 / ic->ic_lintval; 
    34263465                sc->sc_dturbo_turbo_tmin = 5 * 1024 / ic->ic_lintval; 
    34273466                /* convert the thresholds from BW/sec to BW/beacon period */ 
    3428                 sc->sc_dturbo_bw_base    = ATH_TURBO_DN_THRESH/(1024/ic->ic_lintval);   
    3429                 sc->sc_dturbo_bw_turbo   = ATH_TURBO_UP_THRESH/(1024/ic->ic_lintval);  
     3467                sc->sc_dturbo_bw_base    = ATH_TURBO_DN_THRESH/(1024/ic->ic_lintval); 
     3468                sc->sc_dturbo_bw_turbo   = ATH_TURBO_UP_THRESH/(1024/ic->ic_lintval); 
    34303469                /* time in hold state in number of beacon */ 
    34313470                sc->sc_dturbo_hold_max   = (ATH_TURBO_PERIOD_HOLD * 1024)/ic->ic_lintval; 
    34323471        } else { 
     
    34493488 
    34503489        /* TBD: Age out CHANNEL_INTERFERENCE */ 
    34513490        if (sc->sc_ignore_ar) { 
    3452                 /*  
     3491                /* 
    34533492                 * Ignore AR for this beacon; a dynamic turbo 
    34543493                 * switch just happened and the information 
    34553494                 * is invalid.  Notify AR support of the channel 
     
    34673506        sc->sc_dturbo_bytes = sc->sc_devstats.tx_bytes 
    34683507                            + sc->sc_devstats.rx_bytes; 
    34693508        if (ic->ic_ath_cap & IEEE80211_ATHC_BOOST) { 
    3470                 /*  
     3509                /* 
    34713510                * before switching to base mode, 
    3472                 * make sure that the conditions( low rssi, low bw) to switch mode  
     3511                * make sure that the conditions( low rssi, low bw) to switch mode 
    34733512                * hold for some time and time in turbo exceeds minimum turbo time. 
    34743513                */ 
    3475   
    3476                 if (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmin &&  
     3514 
     3515                if (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmin && 
    34773516                   sc->sc_dturbo_hold ==0 && 
    34783517                   (bss_traffic < sc->sc_dturbo_bw_base || !sc->sc_rate_recn_state)) { 
    34793518                        sc->sc_dturbo_hold = 1; 
     
    34923531                 * 
    34933532                 * Transition to base occurs when one of the following 
    34943533                 * is true: 
    3495                  *    1. its a DTIM beacon.  
     3534                 *    1. its a DTIM beacon. 
    34963535                 *    2. Maximum time in BOOST has elapsed (120 secs). 
    34973536                 *    3. Channel is marked with interference 
    3498                  *    4. Average BSS traffic falls below 4Mbps  
    3499                  *    5. RSSI cannot support at least 18 Mbps rate  
     3537                 *    4. Average BSS traffic falls below 4Mbps 
     3538                 *    5. RSSI cannot support at least 18 Mbps rate 
    35003539                 * XXX do bw checks at true beacon interval? 
    35013540                 */ 
    3502                 if (dtim &&  
     3541                if (dtim && 
    35033542                        (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmax || 
    3504                          ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) &&  
     3543                         ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) && 
    35053544                          (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) && 
    3506                           IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) ||  
     3545                          IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) || 
    35073546                         !sc->sc_dturbo_hold_count)) { 
    35083547                        DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Leaving turbo\n", 
    35093548                                        sc->sc_dev->name); 
     
    35193558                 * Transition to Turbo (i.e. BOOST) when all of the 
    35203559                 * following are true: 
    35213560                 * 
    3522                  * 1. its a DTIM beacon.  
     3561                 * 1. its a DTIM beacon. 
    35233562                 * 2. Dwell time at base has exceeded minimum (70 secs) 
    35243563                 * 3. Only DT-capable stations are associated 
    35253564                 * 4. Channel is marked interference-free. 
    3526                  * 5. BSS data traffic averages at least 6Mbps  
    3527                  * 6. RSSI is good enough to support 36Mbps  
     3565                 * 5. BSS data traffic averages at least 6Mbps 
     3566                 * 6. RSSI is good enough to support 36Mbps 
    35283567                 * XXX do bw+rssi checks at true beacon interval? 
    35293568                 */ 
    3530                 if (dtim &&  
     3569                if (dtim && 
    35313570                        (sc->sc_dturbo_tcount >= sc->sc_dturbo_base_tmin && 
    35323571                         (ic->ic_dt_sta_assoc != 0 && 
    35333572                          ic->ic_sta_assoc == ic->ic_dt_sta_assoc) && 
    3534                          ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) == 0 ||  
     3573                         ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) == 0 || 
    35353574                          (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) == 0) && 
    3536                          bss_traffic >= sc->sc_dturbo_bw_turbo &&  
     3575                         bss_traffic >= sc->sc_dturbo_bw_turbo && 
    35373576                         sc->sc_rate_recn_state)) { 
    35383577                        DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Entering turbo\n", 
    35393578                                        sc->sc_dev->name); 
     
    35483587} 
    35493588 
    35503589 
    3551 static int  
     3590static int 
    35523591ath_check_beacon_done(struct ath_softc *sc) 
    35533592{ 
    35543593        struct ieee80211vap *vap=NULL; 
     
    35633602         * check if the last beacon went out with the mode change flag set. 
    35643603         */ 
    35653604        for (slot = 0; slot < ATH_BCBUF; slot++) { 
    3566                 if(sc->sc_bslot[slot]) {  
     3605                if(sc->sc_bslot[slot]) { 
    35673606                        vap = sc->sc_bslot[slot]; 
    35683607                        break; 
    35693608                } 
     
    35993638                ic->ic_ath_cap & IEEE80211_ATHC_BOOST ? "turbo" : "base"); 
    36003639 
    36013640        if (!ath_check_beacon_done(sc)) { 
    3602                 /*  
     3641                /* 
    36033642                 * beacon did not go out. reschedule tasklet. 
    36043643                 */ 
    36053644                mod_timer(&sc->sc_dturbo_switch_mode, jiffies + msecs_to_jiffies(2)); 
     
    38733912                , ds                    /* first descriptor */ 
    38743913        ); 
    38753914 
    3876         /* NB: The desc swap function becomes void,  
     3915        /* NB: The desc swap function becomes void, 
    38773916         * if descriptor swapping is not enabled 
    38783917         */ 
    38793918        ath_desc_swap(ds); 
     
    39183957        ni = bf->bf_node; 
    39193958 
    39203959#ifdef ATH_SUPERG_DYNTURBO 
    3921         /*  
     3960        /* 
    39223961         * If we are using dynamic turbo, update the 
    39233962         * capability info and arrange for a mode change 
    39243963         * if needed. 
     
    39483987 
    39493988        /* 
    39503989         * if the CABQ traffic from previous DTIM is pending and the current 
    3951          * beacon is also a DTIM.  
    3952          *  1) if there is only one vap let the cab traffic continue.  
     3990         * beacon is also a DTIM. 
     3991         *  1) if there is only one vap let the cab traffic continue. 
    39533992         *  2) if there are more than one vap and we are using staggered 
    39543993         *     beacons, then drain the cabq by dropping all the frames in 
    39553994         *     the cabq so that the current vaps cab traffic can be scheduled. 
     
    39784017                struct ath_txq *cabq = sc->sc_cabq; 
    39794018                struct ath_buf *bfmcast; 
    39804019                /* 
    3981                  * Move everything from the vap's mcast queue  
     4020                 * Move everything from the vap's mcast queue 
    39824021                 * to the hardware cab queue. 
    39834022                 * XXX MORE_DATA bit? 
    39844023                 */ 
     
    41734212        struct net_device *dev = (struct net_device *)data; 
    41744213        struct ath_softc *sc = dev->priv; 
    41754214        /* 
    4176          * XXX:if the bmisscount is cleared while the  
     4215         * XXX:if the bmisscount is cleared while the 
    41774216         *     tasklet execution is pending, the following 
    4178          *     check will be true , in which case return  
     4217         *     check will be true , in which case return 
    41794218         *     without resetting the driver. 
    41804219         */ 
    4181         if (sc->sc_bmisscount <= BSTUCK_THRESH)  
     4220        if (sc->sc_bmisscount <= BSTUCK_THRESH) 
    41824221                return; 
    41834222        printk("%s: stuck beacon; resetting (bmiss count %u)\n", 
    41844223                dev->name, sc->sc_bmisscount); 
     
    43174356                 * For multi-bss ap support beacons are either staggered 
    43184357                 * evenly over N slots or burst together.  For the former 
    43194358                 * arrange for the SWBA to be delivered for each slot. 
    4320                  * Slots that are not occupied will generate nothing.  
     4359                 * Slots that are not occupied will generate nothing. 
    43214360                 */ 
    43224361                /* NB: the beacon interval is kept internally in TU's */ 
    43234362                intval = ic->ic_lintval & HAL_BEACON_PERIOD; 
     
    44164455                if (bs.bs_sleepduration > bs.bs_dtimperiod) 
    44174456                        bs.bs_sleepduration = roundup(bs.bs_sleepduration, bs.bs_dtimperiod); 
    44184457 
    4419                 DPRINTF(sc, ATH_DEBUG_BEACON,  
     4458                DPRINTF(sc, ATH_DEBUG_BEACON, 
    44204459                        "%s: tsf %llu tsf:tu %u intval %u nexttbtt %u dtim %u nextdtim %u bmiss %u sleep %u cfp:period %u maxdur %u next %u timoffset %u\n" 
    44214460                        , __func__ 
    44224461                        , (long long) tsf, tsftu 
     
    44624501                        ath_beaconq_config(sc); 
    44634502                } 
    44644503#ifdef ATH_SUPERG_DYNTURBO 
    4465                 ath_beacon_dturbo_config(vap, intval &  
     4504                ath_beacon_dturbo_config(vap, intval & 
    44664505                                ~(HAL_BEACON_RESET_TSF | HAL_BEACON_ENA)); 
    44674506#endif 
    44684507                ath_hal_beaconinit(ah, nexttbtt, intval); 
     
    46584697        struct ath_softc *sc = ni->ni_ic->ic_dev->priv; 
    46594698        struct ath_node *an = ATH_NODE(ni); 
    46604699        struct ath_buf *bf; 
    4661          
     4700 
    46624701        /* 
    46634702         * U-APSD cleanup 
    46644703         */ 
     
    47504789ath_node_move_data(const struct ieee80211_node *ni) 
    47514790{ 
    47524791#ifdef NOT_YET 
    4753         struct ath_txq *txq = NULL;  
     4792        struct ath_txq *txq = NULL; 
    47544793        struct ieee80211com *ic = ni->ni_ic; 
    47554794        struct ath_softc *sc = ic->ic_dev->priv; 
    47564795        struct ath_buf *bf, *prev, *bf_tmp, *bf_tmp1; 
     
    47614800        int index; 
    47624801 
    47634802        if (ni->ni_vap->iv_flags & IEEE80211_F_XR) { 
    4764                 struct ath_txq tmp_q;  
     4803                struct ath_txq tmp_q; 
    47654804                memset(&tmp_q, 0, sizeof(tmp_q)); 
    47664805                STAILQ_INIT(&tmp_q.axq_q); 
    47674806                /* 
     
    47734812                 * in to the tmp_q. 
    47744813                 */ 
    47754814                index = WME_AC_VO; 
    4776                 while (index >= WME_AC_BE && txq != sc->sc_ac2q[index]) {  
    4777                         txq = sc->sc_ac2q[index];  
     4815                while (index >= WME_AC_BE && txq != sc->sc_ac2q[index]) { 
     4816                        txq = sc->sc_ac2q[index]; 
    47784817                        ATH_TXQ_LOCK(txq); 
    47794818                        ath_hal_stoptxdma(ah, txq->axq_qnum); 
    47804819                        bf = prev = STAILQ_FIRST(&txq->axq_q); 
     
    47904829#endif 
    47914830                                status = ath_hal_txprocdesc(ah, ds); 
    47924831                                if (status == HAL_EINPROGRESS) 
    4793                                         break;  
     4832                                        break; 
    47944833                                prev = bf; 
    47954834                                bf = STAILQ_NEXT(bf,bf_list); 
    47964835                        } 
    4797                         /*  
     4836                        /* 
    47984837                         * save the pointer to the last buf thats 
    47994838                         * done . 
    48004839                         */ 
    48014840                        if (prev == bf) 
    4802                                 bf_tmp = NULL;   
     4841                                bf_tmp = NULL; 
    48034842                        else 
    48044843                                bf_tmp=prev; 
    48054844                        while (bf) { 
     
    48494888                                                ds = prev->bf_desc;     /* NB: last decriptor */ 
    48504889#endif 
    48514890                                                status = ath_hal_txprocdesc(ah, ds); 
    4852                                                 if (status == HAL_EINPROGRESS)  
     4891                                                if (status == HAL_EINPROGRESS) 
    48534892                                                        txq->axq_link = &ds->ds_link; 
    48544893                                                else 
    4855                                                         txq->axq_link = NULL;   
     4894                                                        txq->axq_link = NULL; 
    48564895                                        } 
    4857                                 }  
     4896                                } 
    48584897                        } else 
    48594898                                txq->axq_link = NULL; 
    48604899 
    48614900                        ATH_TXQ_UNLOCK(txq); 
    48624901                        /* 
    4863                          * restart the DMA from the first  
     4902                         * restart the DMA from the first 
    48644903                         * buffer that was not DMAd. 
    48654904                         */ 
    48664905                        if (bf_tmp) 
    48674906                                bf = STAILQ_NEXT(bf_tmp, bf_list); 
    48684907                        else 
    48694908                                bf = STAILQ_FIRST(&txq->axq_q); 
    4870                         if (bf) {       
     4909                        if (bf) { 
    48714910                                ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr); 
    48724911                                ath_hal_txstart(ah, txq->axq_qnum); 
    48734912                        } 
    48744913                } 
    4875                 /*  
    4876                  * queue them on to the XR txqueue.  
     4914                /* 
     4915                 * queue them on to the XR txqueue. 
    48774916                 * can not directly put them on to the XR txq. since the 
    48784917                 * skb data size may be greater than the XR fragmentation 
    48794918                 * threshold size. 
     
    48944933                } 
    48954934                printk("moved %d buffers from NORMAL to XR\n", index); 
    48964935        } else { 
    4897                 struct ath_txq wme_tmp_qs[WME_AC_VO+1];  
    4898                 struct ath_txq *wmeq = NULL, *prevq;  
     4936                struct ath_txq wme_tmp_qs[WME_AC_VO+1]; 
     4937                struct ath_txq *wmeq = NULL, *prevq; 
    48994938                struct ieee80211_frame *wh; 
    49004939                struct ath_desc *ds = NULL; 
    49014940                int count = 0; 
     
    49074946                memset(&wme_tmp_qs, 0, sizeof(wme_tmp_qs)); 
    49084947                for (index = 0; index <= WME_AC_VO; index++) 
    49094948                        STAILQ_INIT(&wme_tmp_qs[index].axq_q); 
    4910                 txq = sc->sc_xrtxq;  
     4949                txq = sc->sc_xrtxq; 
    49114950                ATH_TXQ_LOCK(txq); 
    49124951                ath_hal_stoptxdma(ah, txq->axq_qnum); 
    49134952                bf = prev = STAILQ_FIRST(&txq->axq_q); 
     
    49274966                        prev= bf; 
    49284967                        bf = STAILQ_NEXT(bf,bf_list); 
    49294968                } 
    4930                 /*  
     4969                /* 
    49314970                 * save the pointer to the last buf thats 
    49324971                 * done . 
    49334972                 */ 
    49344973                if (prev == bf) 
    4935                         bf_tmp1 = NULL;   
     4974                        bf_tmp1 = NULL; 
    49364975                else 
    49374976                        bf_tmp1 = prev; 
    49384977                /* 
     
    49604999                                        wmeq = &wme_tmp_qs[WME_AC_BE]; 
    49615000                                STAILQ_INSERT_TAIL(&wmeq->axq_q, bf_tmp, bf_list); 
    49625001                                ds = bf_tmp->bf_desc; 
    4963                                 /*  
     5002                                /* 
    49645003                                 * link the descriptors . 
    49655004                                 */ 
    49665005                                if (wmeq->axq_link != NULL) { 
     
    49755014                                                        (caddr_t)bf_tmp->bf_daddr, bf_tmp->bf_desc); 
    49765015                                } 
    49775016                                wmeq->axq_link = &ds->ds_link; 
    4978                                 /*  
    4979                                  * update the rate information   
     5017                                /* 
     5018                                 * update the rate information 
    49805019                                 */ 
    49815020                        } else { 
    49825021                                prev = bf; 
     
    49975036                                        ds = prev->bf_desc;     /* NB: last decriptor */ 
    49985037#endif 
    49995038                                        status = ath_hal_txprocdesc(ah, ds); 
    5000                                         if (status == HAL_EINPROGRESS)  
     5039                                        if (status == HAL_EINPROGRESS) 
    50015040                                                txq->axq_link = &ds->ds_link; 
    50025041                                        else 
    50035042                                                txq->axq_link = NULL; 
    5004                                 }  
    5005                         }  
     5043                                } 
     5044                        } 
    50065045                } else { 
    50075046                        /* 
    50085047                         * if the list is empty reset the pointer. 
     
    50115050                } 
    50125051                ATH_TXQ_UNLOCK(txq); 
    50135052                /* 
    5014                  * restart the DMA from the first  
     5053                 * restart the DMA from the first 
    50155054                 * buffer that was not DMAd. 
    50165055                 */ 
    50175056                if (bf_tmp1) 
    50185057                        bf = STAILQ_NEXT(bf_tmp1,bf_list); 
    50195058                else 
    50205059                        bf = STAILQ_FIRST(&txq->axq_q); 
    5021                 if (bf) {       
     5060                if (bf) { 
    50225061                        ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr); 
    50235062                        ath_hal_txstart(ah, txq->axq_qnum); 
    50245063                } 
    50255064 
    5026                 /*  
     5065                /* 
    50275066                 * move (concant) the lists from the temp sw queues in to 
    50285067                 * wme queues. 
    50295068                 */ 
    50305069                index = WME_AC_VO; 
    50315070                txq = NULL; 
    5032                 while (index >= WME_AC_BE ) {  
     5071                while (index >= WME_AC_BE ) { 
    50335072                        prevq = txq; 
    50345073                        txq = sc->sc_ac2q[index]; 
    50355074                        if (txq != prevq) { 
    50365075                                ATH_TXQ_LOCK(txq); 
    50375076                                ath_hal_stoptxdma(ah, txq->axq_qnum); 
    50385077                        } 
    5039                          
     5078 
    50405079                        wmeq = &wme_tmp_qs[index]; 
    50415080                        bf = STAILQ_FIRST(&wmeq->axq_q); 
    50425081                        if (bf) { 
     
    50475086#else 
    50485087                                        *(txq->axq_link) = bf->bf_daddr; 
    50495088#endif 
    5050                                 }  
     5089                                } 
    50515090                        } 
    50525091                        if (index == WME_AC_BE || txq != prevq) { 
    5053                                 /*  
     5092                                /* 
    50545093                                 * find the first buffer to be DMAd. 
    50555094                                 */ 
    50565095                                bf = STAILQ_FIRST(&txq->axq_q); 
     
    50625101#endif 
    50635102                                        status = ath_hal_txprocdesc(ah, ds); 
    50645103                                        if (status == HAL_EINPROGRESS) 
    5065                                                 break;  
     5104                                                break; 
    50665105                                        bf = STAILQ_NEXT(bf,bf_list); 
    50675106                                } 
    50685107                                if (bf) { 
     
    51065145        if (skb == NULL) { 
    51075146                if (sc->sc_nmonvaps > 0) { 
    51085147                        u_int off; 
    5109                         int extra = A_MAX(sizeof(struct ath_rx_radiotap_header),  
     5148                        int extra = A_MAX(sizeof(struct ath_rx_radiotap_header), 
    51105149                                          A_MAX(sizeof(wlan_ng_prism2_header), ATHDESC_HEADER_SIZE)); 
    5111                                                  
     5150 
    51125151                        /* 
    51135152                         * Allocate buffer for monitor mode with space for the 
    51145153                         * wlan-ng style physical layer header at the start. 
     
    52305269{ 
    52315270        struct ath_softc *sc = dev->priv; 
    52325271        struct ieee80211com *ic = &sc->sc_ic; 
    5233         int extra = A_MAX(sizeof(struct ath_tx_radiotap_header),  
     5272        int extra = A_MAX(sizeof(struct ath_tx_radiotap_header), 
    52345273                          A_MAX(sizeof(wlan_ng_prism2_header), ATHDESC_HEADER_SIZE)); 
    5235         /*                                                                       
    5236          * release the owner of this skb since we're basically                   
    5237          * recycling it                                                          
     5274        /* 
     5275         * release the owner of this skb since we're basically 
     5276         * recycling it 
    52385277         */ 
    52395278        if (atomic_read(&skb->users) != 1) { 
    52405279                struct sk_buff *skb2 = skb; 
     
    53745413                 * interrupt handler to support U-APSD trigger search. 
    53755414                 * This must also be done even when U-APSD is not active to support 
    53765415                 * other error handling that requires immediate attention. 
    5377                  * We check bf_status to find out if the bf's descriptors have  
     5416                 * We check bf_status to find out if the bf's descriptors have 
    53785417                 * been processed by the HAL. 
    53795418                 */ 
    53805419                if (!(bf->bf_status & ATH_BUFSTATUS_DONE)) 
    53815420                        break; 
    5382                  
     5421 
    53835422                ds = bf->bf_desc; 
    53845423                if (ds->ds_link == bf->bf_daddr) { 
    53855424                        /* NB: never process the self-linked entry at the end */ 
     
    55685607                         * No key index or no entry, do a lookup and 
    55695608                         * add the node to the mapping table if possible. 
    55705609                         */ 
    5571                         ni = ieee80211_find_rxnode(ic,  
     5610                        ni = ieee80211_find_rxnode(ic, 
    55725611                                (const struct ieee80211_frame_min *) skb->data); 
    55735612                        if (ni != NULL) { 
    55745613                                struct ath_node *an = ATH_NODE(ni); 
     
    55875626                                if (keyix != IEEE80211_KEYIX_NONE && 
    55885627                                    sc->sc_keyixmap[keyix] == NULL) 
    55895628                                        sc->sc_keyixmap[keyix] = ieee80211_ref_node(ni); 
    5590                                 ieee80211_free_node(ni);  
     5629                                ieee80211_free_node(ni); 
    55915630                        } else 
    55925631                                type = ieee80211_input_all(ic, skb, 
    55935632                                        ds->ds_rxstat.rs_rssi, 
     
    56385677 
    56395678#ifdef ATH_SUPERG_XR 
    56405679 
    5641 static void  
     5680static void 
    56425681ath_grppoll_period_update(struct ath_softc *sc) 
    56435682{ 
    56445683        struct ieee80211com *ic = &sc->sc_ic; 
     
    56535692         * if no stations are in XR mode. 
    56545693         * use default poll interval. 
    56555694         */ 
    5656         if (xrsta == 0) {  
     5695        if (xrsta == 0) { 
    56575696                if (sc->sc_xrpollint != XR_DEFAULT_POLL_INTERVAL) { 
    56585697                        sc->sc_xrpollint = XR_DEFAULT_POLL_INTERVAL; 
    56595698                        ath_grppoll_txq_update(sc,XR_DEFAULT_POLL_INTERVAL); 
     
    56665705         * if all the stations are in XR mode. 
    56675706         * use minimum poll interval. 
    56685707         */ 
    5669         if (allsta == xrsta) {  
     5708        if (allsta == xrsta) { 
    56705709                if (sc->sc_xrpollint != XR_MIN_POLL_INTERVAL) { 
    56715710                        sc->sc_xrpollint = XR_MIN_POLL_INTERVAL; 
    56725711                        ath_grppoll_txq_update(sc,XR_MIN_POLL_INTERVAL); 
     
    56765715 
    56775716        normalsta = allsta-xrsta; 
    56785717        /* 
    5679          * if stations are in both XR and normal mode.  
     5718         * if stations are in both XR and normal mode. 
    56805719         * use some fudge factor. 
    56815720         */ 
    56825721        interval = XR_DEFAULT_POLL_INTERVAL - 
    56835722          ((XR_DEFAULT_POLL_INTERVAL - XR_MIN_POLL_INTERVAL) * xrsta)/(normalsta * XR_GRPPOLL_PERIOD_FACTOR); 
    56845723        if (interval < XR_MIN_POLL_INTERVAL) 
    56855724                interval = XR_MIN_POLL_INTERVAL; 
    5686          
     5725 
    56875726        if (sc->sc_xrpollint != interval) { 
    56885727                sc->sc_xrpollint = interval; 
    56895728                ath_grppoll_txq_update(sc,interval); 
     
    56995738/* 
    57005739 * update grppoll period. 
    57015740 */ 
    5702 static void  
     5741static void 
    57035742ath_grppoll_txq_update(struct ath_softc *sc, int period) 
    57045743{ 
    57055744        struct ath_hal *ah = sc->sc_ah; 
     
    57075746        struct ath_txq *txq = &sc->sc_grpplq; 
    57085747 
    57095748        if (sc->sc_grpplq.axq_qnum == -1) 
    5710                 return;  
     5749                return; 
    57115750 
    57125751        memset(&qi, 0, sizeof(qi)); 
    57135752        qi.tqi_subtype = 0; 
     
    57245763/* 
    57255764 * Setup grppoll  h/w transmit queue. 
    57265765 */ 
    5727 static void  
     5766static void 
    57285767ath_grppoll_txq_setup(struct ath_softc *sc, int qtype, int period) 
    57295768{ 
    57305769#define N(a)    ((int)(sizeof(a)/sizeof(a[0]))) 
     
    58195858                == IEEE80211_F_SHPREAMBLE) 
    58205859 
    58215860        if (sc->sc_xrgrppoll) 
    5822                 return;  
     5861                return; 
    58235862 
    58245863        memset(&rates, 0, sizeof(rates)); 
    58255864        pos = 0; 
     
    58555894 
    58565895                        flags = HAL_TXDESC_NOACK; 
    58575896                        rate = rt->info[rtindex].rateCode; 
    5858                         /*  
     5897                        /* 
    58595898                         * except for the last one every thing else is a CF poll. 
    58605899                         * last one is  the CF End frame. 
    58615900                         */ 
     
    58705909                                pktlen = skb->len + IEEE80211_CRC_LEN; 
    58715910                                /* 
    58725911                                 * the very first group poll ctsduration  should be enough to allow 
    5873                                  * an auth frame from station. This is to pass the wifi testing (as  
     5912                                 * an auth frame from station. This is to pass the wifi testing (as 
    58745913                                 * some stations in testing do not honor CF_END and rely on CTS duration) 
    58755914                                 */ 
    58765915                                if (i == 0 && amode == HAL_ANTENNA_FIXED_A) { 
    58775916                                        ctsduration = ath_hal_computetxtime(ah, rt, 
    58785917                                                        pktlen, rtindex, 
    58795918                                                        AH_FALSE) /*cf-poll time */ 
    5880                                                 + (XR_AIFS + (XR_CWMIN_CWMAX * XR_SLOT_DELAY))   
     5919                                                + (XR_AIFS + (XR_CWMIN_CWMAX * XR_SLOT_DELAY)) 
    58815920                                                + ath_hal_computetxtime(ah, rt, 
    58825921                                                        2 * (sizeof(struct ieee80211_frame_min) + 6), 
    58835922                                                        IEEE80211_XR_DEFAULT_RATE_INDEX, 
     
    58855924                                                + ath_hal_computetxtime(ah, rt, 
    58865925                                                        IEEE80211_ACK_LEN, 
    58875926                                                        IEEE80211_XR_DEFAULT_RATE_INDEX, 
    5888                                                         AH_FALSE); /*ack frame time */  
     5927                                                        AH_FALSE); /*ack frame time */ 
    58895928                                } else { 
    58905929                                        ctsduration = ath_hal_computetxtime(ah, rt, 
    58915930                                                        pktlen, rtindex, 
    58925931                                                        AH_FALSE) /*cf-poll time */ 
    5893                                                 + (XR_AIFS + (XR_CWMIN_CWMAX * XR_SLOT_DELAY))   
     5932                                                + (XR_AIFS + (XR_CWMIN_CWMAX * XR_SLOT_DELAY)) 
    58945933                                                + ath_hal_computetxtime(ah,rt, 
    58955934                                                        XR_FRAGMENTATION_THRESHOLD , 
    58965935                                                        IEEE80211_XR_DEFAULT_RATE_INDEX, 
     
    58985937                                                + ath_hal_computetxtime(ah,rt, 
    58995938                                                        IEEE80211_ACK_LEN, 
    59005939                                                        IEEE80211_XR_DEFAULT_RATE_INDEX, 
    5901                                                         AH_FALSE); /*ack frame time */  
     5940                                                        AH_FALSE); /*ack frame time */ 
    59025941                                } 
    59035942                                if ((vap->iv_flags & IEEE80211_F_PRIVACY) && keyix == 0) { 
    59045943                                        struct ieee80211_key *k; 
     
    59075946                                                keyix = k->wk_keyix; 
    59085947                                } 
    59095948                        } 
    5910                         ATH_TXBUF_LOCK_IRQ(sc);                                         
     5949                        ATH_TXBUF_LOCK_IRQ(sc); 
    59115950                        bf = STAILQ_FIRST(&sc->sc_grppollbuf); 
    59125951                        if (bf != NULL) 
    59135952                                STAILQ_REMOVE_HEAD(&sc->sc_grppollbuf, bf_list); 
     
    59165955                                return; 
    59175956                        } 
    59185957                        /* XXX use a counter and leave at least one for mgmt frames */ 
    5919                         if (STAILQ_EMPTY(&sc->sc_grppollbuf)) {                                 
     5958                        if (STAILQ_EMPTY(&sc->sc_grppollbuf)) { 
    59205959                                DPRINTF(sc, ATH_DEBUG_XMIT, "%s: No more TxBufs left\n", __func__); 
    59215960                                return; 
    5922                         }                                       
     5961                        } 
    59235962                        ATH_TXBUF_UNLOCK_IRQ(sc); 
    59245963                        bf->bf_skbaddr = bus_map_single(sc->sc_bdev, 
    59255964                                skb->data, skb->len, BUS_DMA_TODEVICE); 
     
    59355974                                type = HAL_PKT_TYPE_GRP_POLL; 
    59365975                        } 
    59375976                        if (i == 0 && amode == HAL_ANTENNA_FIXED_A ) { 
    5938                                 flags |= HAL_TXDESC_CLRDMASK;   
     5977                                flags |= HAL_TXDESC_CLRDMASK; 
    59395978                                head = bf; 
    59405979                        } 
    59415980                        ath_hal_setuptxdesc(ah, ds 
     
    59465985                                , rate, 0               /* series 0 rate/tries */ 
    59475986                                , keyix /* HAL_TXKEYIX_INVALID */               /* use key index */ 
    59485987                                , amode                 /* antenna mode */ 
    5949                                 , flags                                 
     5988                                , flags 
    59505989                                , ctsrate               /* rts/cts rate */ 
    59515990                                , ctsduration           /* rts/cts duration */ 
    59525991                                , 0                     /* comp icv len */ 
     
    59595998                                , AH_TRUE               /* last segment */ 
    59605999                                , ds                    /* first descriptor */ 
    59616000                                ); 
    5962                         /* NB: The desc swap function becomes void,  
     6001                        /* NB: The desc swap function becomes void, 
    59636002                        * if descriptor swapping is not enabled 
    59646003                        */ 
    59656004                        ath_desc_swap(ds); 
     
    59986037        struct ath_hal *ah = sc->sc_ah; 
    59996038        struct ath_txq *txq = &sc->sc_grpplq; 
    60006039        struct ath_buf *bf; 
    6001          
    6002          
     6040 
     6041 
    60036042        if (!sc->sc_xrgrppoll) 
    6004                 return;  
     6043                return; 
    60056044        ath_hal_stoptxdma(ah, txq->axq_qnum); 
    60066045 
    60076046        /* move the grppool bufs back to the grppollbuf */ 
     
    60656104 
    60666105#ifdef ATH_SUPERG_COMP 
    60676106        /* allocate compression scratch buffer for data queues */ 
    6068         if (((qtype == HAL_TX_QUEUE_DATA)|| (qtype == HAL_TX_QUEUE_UAPSD))  
     6107        if (((qtype == HAL_TX_QUEUE_DATA)|| (qtype == HAL_TX_QUEUE_UAPSD)) 
    60696108            && ath_hal_compressionsupported(ah)) { 
    6070                 compbufsz = roundup(HAL_COMP_BUF_MAX_SIZE,  
     6109                compbufsz = roundup(HAL_COMP_BUF_MAX_SIZE, 
    60716110                        HAL_COMP_BUF_ALIGN_SIZE) + HAL_COMP_BUF_ALIGN_SIZE; 
    60726111                compbuf = (char *)bus_alloc_consistent(sc->sc_bdev, 
    60736112                        compbufsz, &compbufp); 
    60746113                if (compbuf == NULL) 
    6075                         sc->sc_ic.ic_ath_cap &= ~IEEE80211_ATHC_COMP;   
     6114                        sc->sc_ic.ic_ath_cap &= ~IEEE80211_ATHC_COMP; 
    60766115                else 
    60776116                        qi.tqi_compBuf = (u_int32_t)compbufp; 
    6078         }  
     6117        } 
    60796118#endif 
    60806119        /* 
    60816120         * Enable interrupts only for EOL and DESC conditions. 
     
    62236262/* 
    62246263 * Callback from 802.11 layer to flush a node's U-APSD queues 
    62256264 */ 
    6226 static void     
     6265static void 
    62276266ath_uapsd_flush(struct ieee80211_node *ni) 
    62286267{ 
    62296268        struct ath_node *an = ATH_NODE(ni); 
     
    63166355        if (cip->ic_cipher == IEEE80211_CIPHER_AES_CCM || 
    63176356                cip->ic_cipher == IEEE80211_CIPHER_AES_OCB) 
    63186357                ivlen += EXT_IV_FIELD_SIZE; 
    6319          
     6358 
    63206359        return ivlen; 
    63216360} 
    63226361#endif 
     
    63716410                STAILQ_INSERT_TAIL(&an->an_uapsd_q, bf, bf_list); 
    63726411                an->an_uapsd_qdepth++; 
    63736412                DPRINTF(sc, ATH_DEBUG_UAPSD, 
    6374                                 "%s: added AC %d frame to delivery Q, new depth = %d\n",  
     6413                                "%s: added AC %d frame to delivery Q, new depth = %d\n", 
    63756414                                __func__, bf->bf_skb->priority, an->an_uapsd_qdepth); 
    63766415                return; 
    63776416        } 
    6378          
     6417 
    63796418        /* check if need to make room on overflow queue */ 
    63806419        if (an->an_uapsd_overflowqdepth == an->an_node.ni_uapsd_maxsp) { 
    6381                 /*  
     6420                /* 
    63826421                 *  pop oldest from delivery queue and cleanup 
    6383                  */  
     6422                 */ 
    63846423                lastbuf = STAILQ_FIRST(&an->an_uapsd_q); 
    63856424                STAILQ_REMOVE_HEAD(&an->an_uapsd_q, bf_list); 
    63866425                dev_kfree_skb(lastbuf->bf_skb); 
     
    63906429                ATH_TXBUF_LOCK_IRQ(sc); 
    63916430                STAILQ_INSERT_TAIL(&sc->sc_txbuf, lastbuf, bf_list); 
    63926431                ATH_TXBUF_UNLOCK_IRQ(sc); 
    6393                  
     6432 
    63946433                /* 
    63956434                 *  move oldest from overflow to delivery 
    63966435                 */ 
     
    64486487        isprot = wh->i_fc[1] & IEEE80211_FC1_PROT; 
    64496488        ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); 
    64506489        hdrlen = ieee80211_anyhdrsize(wh); 
    6451         istxfrag = (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) ||  
    6452                 (((le16toh(*(u_int16_t *) &wh->i_seq[0]) >>  
     6490        istxfrag = (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) || 
     6491                (((le16toh(*(u_int16_t *) &wh->i_seq[0]) >> 
    64536492                IEEE80211_SEQ_FRAG_SHIFT) & IEEE80211_SEQ_FRAG_MASK) > 0); 
    64546493 
    64556494        pktlen = skb->len; 
     
    65606599        /* setup descriptors */ 
    65616600        ds = bf->bf_desc; 
    65626601#ifdef ATH_SUPERG_XR 
    6563         if(vap->iv_flags & IEEE80211_F_XR )  
     6602        if(vap->iv_flags & IEEE80211_F_XR ) 
    65646603                rt = sc->sc_xr_rates; 
    65656604        else 
    65666605                rt = sc->sc_currates; 
     
    66266665                break; 
    66276666        case IEEE80211_FC0_TYPE_DATA: 
    66286667                atype = HAL_PKT_TYPE_NORMAL;            /* default */ 
    6629                  
     6668 
    66306669                if (ismcast) { 
    66316670                        rix = ath_tx_findindex(rt, vap->iv_mcast_rate); 
    66326671                        txrate = rt->info[rix].rateCode; 
    66336672                        if (shortPreamble) 
    66346673                                txrate |= rt->info[rix].shortPreamble; 
    6635                         /*  
     6674                        /* 
    66366675                         * ATH_TXMAXTRY disables Multi-rate retries, which 
    66376676                         * isn't applicable to mcast packets and overrides 
    66386677                         * the desired transmission rate for mcast traffic. 
     
    66776716                return -EIO; 
    66786717        } 
    66796718 
    6680 #ifdef ATH_SUPERG_XR  
     6719#ifdef ATH_SUPERG_XR 
    66816720        if (vap->iv_flags & IEEE80211_F_XR ) { 
    66826721                txq = sc->sc_xrtxq; 
    66836722                if (!txq) 
     
    67056744                flags |= HAL_TXDESC_NOACK;      /* no ack on broad/multicast */ 
    67066745                sc->sc_stats.ast_tx_noack++; 
    67076746                try0 = ATH_TXMAXTRY;    /* turn off multi-rate retry for multicast traffic */ 
    6708          } else if (pktlen > vap->iv_rtsthreshold) {  
     6747         } else if (pktlen > vap->iv_rtsthreshold) { 
    67096748#ifdef ATH_SUPERG_FF 
    67106749                /* we could refine to only check that the frame of interest 
    67116750                 * is a FF, but this seems inconsistent. 
     
    67366775 
    67376776                if (istxfrag) 
    67386777                        /* 
    6739                         **  if Tx fragment, it would be desirable to  
     6778                        **  if Tx fragment, it would be desirable to 
    67406779                        **  use highest CCK rate for RTS/CTS. 
    67416780                        **  However, stations farther away may detect it 
    6742                         **  at a lower CCK rate. Therefore, use the  
     6781                        **  at a lower CCK rate. Therefore, use the 
    67436782                        **  configured protect rate, which is 2 Mbps 
    67446783                        **  for 11G. 
    67456784                        */ 
     
    67736812                        ** The last fragment uses the ACK duration only. 
    67746813                        ** Add time for next fragment. 
    67756814                        */ 
    6776                         dur += ath_hal_computetxtime(ah, rt, nextfraglen,  
     6815                        dur += ath_hal_computetxtime(ah, rt, nextfraglen, 
    67776816                                rix, shortPreamble); 
    67786817                } 
    67796818 
     
    68326871                 * Must disable multi-rate retry when using RTS/CTS. 
    68336872                 */ 
    68346873                try0 = ATH_TXMAXTRY; 
    6835         } else  
     6874        } else 
    68366875                ctsrate = 0; 
    68376876 
    68386877        if (IFF_DUMPPKTS(sc, ATH_DEBUG_XMIT)) 
     
    68626901        } 
    68636902 
    68646903#ifdef ATH_SUPERG_COMP 
    6865         if (ATH_NODE(ni)->an_decomp_index != INVALID_DECOMP_INDEX &&  
     6904        if (ATH_NODE(ni)->an_decomp_index != INVALID_DECOMP_INDEX && 
    68666905            !ismcast && 
    68676906            ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_DATA) && 
    68686907            ((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) != IEEE80211_FC0_SUBTYPE_NODATA)) { 
     
    68706909                        comp = ATH_COMP_PROC_COMP_OPTIMAL; 
    68716910                else 
    68726911                        comp = ATH_COMP_PROC_NO_COMP_ADD_CCS; 
    6873         }  
     6912        } 
    68746913#endif 
    68756914 
    68766915        /* 
     
    69276966                           , ds         /* first descriptor */ 
    69286967                ); 
    69296968 
    6930         /* NB: The desc swap function becomes void,  
     6969        /* NB: The desc swap function becomes void, 
    69316970         * if descriptor swapping is not enabled 
    69326971         */ 
    69336972        ath_desc_swap(ds); 
     
    69516990                        , ds                    /* first descriptor */ 
    69526991                ); 
    69536992 
    6954                 /* NB: The desc swap function becomes void,  
     6993                /* NB: The desc swap function becomes void, 
    69556994                 * if descriptor swapping is not enabled 
    69566995                 */ 
    69576996                ath_desc_swap(ds); 
     
    69717010                                , ds0                   /* first descriptor */ 
    69727011                        ); 
    69737012 
    6974                         /* NB: The desc swap function becomes void,  
     7013                        /* NB: The desc swap function becomes void, 
    69757014                         * if descriptor swapping is not enabled 
    69767015                         */ 
    69777016                        ath_desc_swap(ds); 
     
    69877026        if (M_FLAG_GET(skb, M_UAPSD)) { 
    69887027                /* must lock against interrupt-time processing (i.e., not just tasklet) */ 
    69897028                ATH_NODE_UAPSD_LOCK_IRQ(an); 
    6990                 DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: Qing U-APSD data frame for node %s \n",  
     7029                DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: Qing U-APSD data frame for node %s \n", 
    69917030                        __func__, ether_sprintf(an->an_node.ni_macaddr)); 
    69927031                ath_tx_uapsdqueue(sc, an, bf); 
    69937032                if (IEEE80211_NODE_UAPSD_USETIM(ni) && (an->an_uapsd_qdepth == 1)) 
     
    69967035 
    69977036                return 0; 
    69987037        } 
    6999          
    7000          
     7038 
     7039 
    70017040        IEEE80211_DPRINTF(vap, IEEE80211_MSG_NODE, "%s: %p<%s> refcnt %d\n", 
    70027041                __func__, vap->iv_bss, ether_sprintf(vap->iv_bss->ni_macaddr), 
    70037042                ieee80211_node_refcnt(vap->iv_bss)); 
     
    71367175                         *     this is a DEAUTH message that was sent and the 
    71377176                         *     node was timed out due to inactivity. 
    71387177                         */ 
    7139                          ieee80211_free_node(ni);  
     7178                         ieee80211_free_node(ni); 
    71407179                } 
    71417180 
    7142                 bus_unmap_single(sc->sc_bdev, bf->bf_skbaddr,  
     7181                bus_unmap_single(sc->sc_bdev, bf->bf_skbaddr, 
    71437182                                 bf->bf_skb->len, BUS_DMA_TODEVICE); 
    71447183                if (ni && uapsdq) { 
    71457184                        /* detect EOSP for this node */ 
     
    71477186                        an = ATH_NODE(ni); 
    71487187                        KASSERT(ni != NULL, ("Processing U-APSD txq for ath_buf with no node!\n")); 
    71497188                        if (qwh->i_qos[0] & IEEE80211_QOS_EOSP) { 
    7150                                 DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: EOSP detected for node (%s) on desc %p\n",  
     7189                                DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: EOSP detected for node (%s) on desc %p\n", 
    71517190                                        __func__, ether_sprintf(ni->ni_macaddr), ds); 
    71527191                                ATH_NODE_UAPSD_LOCK_IRQ(an); 
    71537192                                ni->ni_flags &= ~IEEE80211_NODE_UAPSD_SP; 
     
    73187357        } 
    73197358} 
    73207359 
    7321 /*  
     7360/* 
    73227361 * Context: softIRQ and hwIRQ 
    73237362 */ 
    73247363static void 
     
    75637602                hchan.channel); 
    75647603        /* check if it is turbo mode switch */ 
    75657604        if (hchan.channel == sc->sc_curchan.channel && 
    7566            (hchan.channelFlags & IEEE80211_CHAN_TURBO) != (sc->sc_curchan.channelFlags & IEEE80211_CHAN_TURBO))  
     7605           (hchan.channelFlags & IEEE80211_CHAN_TURBO) != (sc->sc_curchan.channelFlags & IEEE80211_CHAN_TURBO)) 
    75677606                tswitch = 1; 
    75687607        if (hchan.channel != sc->sc_curchan.channel || 
    75697608            hchan.channelFlags != sc->sc_curchan.channelFlags) { 
     
    75787617                ath_hal_intrset(ah, 0); /* disable interrupts */ 
    75797618                ath_draintxq(sc);       /* clear pending tx frames */ 
    75807619                ath_stoprecv(sc);       /* turn off frame recv */ 
    7581                  
     7620 
    75827621                /* Set coverage class */ 
    75837622                if (sc->sc_scanning || !IEEE80211_IS_CHAN_A(chan)) 
    75847623                        ath_hal_setcoverageclass(sc->sc_ah, 0, 0); 
     
    75977636 
    75987637                if (sc->sc_softled) 
    75997638                        ath_hal_gpioCfgOutput(ah, sc->sc_ledpin); 
    7600                  
     7639 
    76017640                sc->sc_curchan = hchan; 
    76027641                ath_update_txpow(sc);           /* update tx power state */ 
    76037642 
     
    76177656                ath_chan_change(sc, chan); 
    76187657                if (ic->ic_opmode == IEEE80211_M_HOSTAP) { 
    76197658                        if (sc->sc_curchan.privFlags & CHANNEL_DFS) { 
    7620                                 if (!(sc->sc_curchan.privFlags & CHANNEL_DFS_CLEAR)) {  
     7659                                if (!(sc->sc_curchan.privFlags & CHANNEL_DFS_CLEAR)) { 
    76217660                                        dev->watchdog_timeo = 120 * HZ; /* set the timeout to normal */ 
    7622                                         netif_stop_queue(dev);                  
     7661                                        netif_stop_queue(dev); 
    76237662                                        if (sc->sc_dfswait) 
    76247663                                                del_timer_sync(&sc->sc_dfswaittimer); 
    76257664                                        DPRINTF(sc, ATH_DEBUG_STATE, "%s: %s: start dfs wait period\n", 
    76267665                                                __func__, dev->name); 
    76277666                                        sc->sc_dfswait = 1; 
    76287667                                        sc->sc_dfswaittimer.function = ath_check_dfs_clear; 
    7629                                         sc->sc_dfswaittimer.expires =  
     7668                                        sc->sc_dfswaittimer.expires = 
    76307669                                                jiffies + (ATH_DFS_WAIT_POLL_PERIOD * HZ); 
    76317670                                        sc->sc_dfswaittimer.data = (unsigned long)sc; 
    76327671                                        add_timer(&sc->sc_dfswaittimer); 
     
    76397678                 * re configure beacons when it is a turbo mode switch. 
    76407679                 * HW seems to turn off beacons during turbo mode switch. 
    76417680                 */ 
    7642                 if (sc->sc_beacons && tswitch)  
    7643                         ath_beacon_config(sc, NULL);    
     7681                if (sc->sc_beacons && tswitch) 
     7682                        ath_beacon_config(sc, NULL); 
    76447683 
    76457684                /* 
    76467685                 * Re-enable interrupts. 
     
    76947733                if (nchans > 0) { 
    76957734                        u_int32_t i, j; 
    76967735                        struct ieee80211_channel *ichan; 
    7697                          
     7736 
    76987737                        for (i = 0; i < nchans; i++) { 
    76997738                                for (j = 0; j < ic->ic_nchans; j++) { 
    77007739                                        ichan = &ic->ic_channels[j]; 
     
    77767815} 
    77777816 
    77787817static void 
    7779 ath_set_coverageclass(struct ieee80211com *ic)  
     7818ath_set_coverageclass(struct ieee80211com *ic) 
    77807819{ 
    77817820        struct ath_softc *sc = ic->ic_dev->priv; 
    77827821 
    77837822        ath_hal_setcoverageclass(sc->sc_ah, ic->ic_coverageclass, 0); 
    7784          
     7823 
    77857824        return; 
    77867825} 
    77877826 
     
    79197958                        error = ath_beacon_alloc(sc, ni); 
    79207959                        if (error < 0) 
    79217960                                goto bad; 
    7922                         /*  
     7961                        /* 
    79237962                         * if the turbo flags have changed, then beacon and turbo 
    79247963                         * need to be reconfigured. 
    79257964                         */ 
    7926                         if ((sc->sc_dturbo && !(vap->iv_ath_cap & IEEE80211_ATHC_TURBOP)) ||  
    7927                                 (!sc->sc_dturbo && (vap->iv_ath_cap & IEEE80211_ATHC_TURBOP)))  
     7965                        if ((sc->sc_dturbo && !(vap->iv_ath_cap & IEEE80211_ATHC_TURBOP)) || 
     7966                                (!sc->sc_dturbo && (vap->iv_ath_cap & IEEE80211_ATHC_TURBOP))) 
    79287967                                sc->sc_beacons = 0; 
    7929                         /*  
    7930                          * if it is the first AP VAP moving to RUN state then beacon  
     7968                        /* 
     7969                         * if it is the first AP VAP moving to RUN state then beacon 
    79317970                         * needs to be reconfigured. 
    79327971                         */ 
    79337972                        TAILQ_FOREACH(tmpvap, &ic->ic_vaps, iv_next) { 
     
    79357974                                        tmpvap->iv_opmode == IEEE80211_M_HOSTAP) 
    79367975                                        break; 
    79377976                        } 
    7938                         if (!tmpvap)  
     7977                        if (!tmpvap) 
    79397978                                sc->sc_beacons = 0; 
    79407979                        break; 
    79417980                case IEEE80211_M_STA: 
     
    79628001                                wds_ni->ni_rates = vap->iv_bss->ni_rates; 
    79638002                                /* Depending on the sequence of bring-ing up devices 
    79648003                                 * it's possible the rates of the root bss isn't 
    7965                                  * filled yet.  
     8004                                 * filled yet. 
    79668005                                 */ 
    7967                                 if (vap->iv_ic->ic_newassoc != NULL &&  
     8006                                if (vap->iv_ic->ic_newassoc != NULL && 
    79688007                                    wds_ni->ni_rates.rs_nrates != 0) { 
    79698008                                        /* Fill in the rates based on our own rates 
    79708009                                         * we rely on the rate selection mechanism 
     
    79938032                sc->sc_halstats.ns_avgbrssi = ATH_RSSI_DUMMY_MARKER; 
    79948033                sc->sc_halstats.ns_avgrssi = ATH_RSSI_DUMMY_MARKER; 
    79958034                sc->sc_halstats.ns_avgtxrssi = ATH_RSSI_DUMMY_MARKER; 
    7996                 /*  
    7997                  * if it is a DFS channel and has not been checked for radar  
     8035                /* 
     8036                 * if it is a DFS channel and has not been checked for radar 
    79988037                 * do not let the 80211 state machine to go to RUN state. 
    79998038                 * 
    80008039                 */ 
     
    80028041                        /* push the vap to RUN state once DFS is cleared */ 
    80038042                        DPRINTF(sc, ATH_DEBUG_STATE, "%s: %s: vap  -> DFS_WAIT\n", 
    80048043                                __func__, dev->name); 
    8005                         avp->av_dfswait_run = 1;  
     8044                        avp->av_dfswait_run = 1; 
    80068045                        return 0; 
    80078046                } 
    80088047        } else { 
     
    80168055                } 
    80178056                /* 
    80188057                 *  XXXX 
    8019                  * if it is SCAN state , disable Beacons.  
     8058                 * if it is SCAN state , disable Beacons. 
    80208059                 */ 
    80218060                if (nstate == IEEE80211_S_SCAN) { 
    80228061                        ath_hal_intrset(ah,sc->sc_imask &~ (HAL_INT_SWBA | HAL_INT_BMISS)); 
    80238062                        sc->sc_imask &= ~(HAL_INT_SWBA | HAL_INT_BMISS); 
    80248063                        /* need to reconfigure the beacons when it moves to RUN */ 
    8025                         sc->sc_beacons = 0;  
     8064                        sc->sc_beacons = 0; 
    80268065                } 
    8027                 avp->av_dfswait_run = 0; /* reset the dfs wait flag */  
     8066                avp->av_dfswait_run = 0; /* reset the dfs wait flag */ 
    80288067        } 
    80298068done: 
    80308069        /* 
     
    80578096/* 
    80588097 * periodically checks for the hal to set 
    80598098 * CHANNEL_DFS_CLEAR flag on current channel. 
    8060  * if the flag is set and a vap is waiting for it ,push  
     8099 * if the flag is set and a vap is waiting for it ,push 
    80618100 * transition the vap to RUN state. 
    80628101 * 
    80638102 * Context: Timer (softIRQ) 
    80648103 */ 
    8065 static void  
    8066 ath_check_dfs_clear(unsigned long data )  
     8104static void 
     8105ath_check_dfs_clear(unsigned long data ) 
    80678106{ 
    8068         struct ath_softc *sc = (struct ath_softc *)data;  
     8107        struct ath_softc *sc = (struct ath_softc *)data; 
    80698108        struct ieee80211com *ic = &sc->sc_ic; 
    80708109        struct net_device *dev = sc->sc_dev; 
    80718110        struct ieee80211vap *vap ; 
     
    80778116        ath_hal_radar_wait(sc->sc_ah, &hchan); 
    80788117 
    80798118        if (hchan.privFlags & CHANNEL_INTERFERENCE) 
    8080                 return;  
     8119                return; 
    80818120 
    80828121        if ((hchan.privFlags & CHANNEL_DFS_CLEAR) || 
    8083             (!(hchan.privFlags & CHANNEL_DFS))) {  
     8122            (!(hchan.privFlags & CHANNEL_DFS))) { 
    80848123                sc->sc_curchan.privFlags |= CHANNEL_DFS_CLEAR; 
    80858124                sc->sc_dfswait = 0; 
    80868125                TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { 
     
    81588197                if ((ni->ni_wpa_ie != NULL) && 
    81598198                    (ni->ni_rsn.rsn_ucastcipher == IEEE80211_CIPHER_TKIP) && 
    81608199                    sc->sc_splitmic) { 
    8161                         if ((ni->ni_ucastkey.wk_flags & IEEE80211_KEY_XR)  
     8200                        if ((ni->ni_ucastkey.wk_flags & IEEE80211_KEY_XR) 
    81628201                                                        == IEEE80211_KEY_XR) 
    81638202                                keyindex = ni->ni_ucastkey.wk_keyix + 32; 
    81648203                        else 
     
    82148253                ath_setup_comp(ni, 1); 
    82158254#endif 
    82168255        } 
    8217          
     8256 
    82188257        return; 
    82198258} 
    82208259 
     
    82418280                ("got invalid vap def key index 0x%x", vap->iv_def_txkey)); 
    82428281 
    82438282        /* Allocate a key slot first */ 
    8244         if (!ieee80211_crypto_newkey(vap,  
    8245                 IEEE80211_CIPHER_WEP,  
    8246                 IEEE80211_KEY_XMIT|IEEE80211_KEY_RECV,  
     8283        if (!ieee80211_crypto_newkey(vap, 
     8284                IEEE80211_CIPHER_WEP, 
     8285                IEEE80211_KEY_XMIT|IEEE80211_KEY_RECV, 
    82478286                &ni->ni_ucastkey)) 
    82488287                goto error; 
    82498288 
     
    82538292        /* Do we need seperate rx key? */ 
    82548293        if (ni->ni_ath_defkeyindex != vap->iv_def_txkey) { 
    82558294                ni->ni_ucastkey.wk_keyix = IEEE80211_KEYIX_NONE; 
    8256                 if (!ieee80211_crypto_newkey(vap,  
    8257                         IEEE80211_CIPHER_WEP,  
     8295                if (!ieee80211_crypto_newkey(vap, 
     8296                        IEEE80211_CIPHER_WEP, 
    82588297                        IEEE80211_KEY_XMIT|IEEE80211_KEY_RECV, 
    82598298                        &ni->ni_ucastkey)) { 
    82608299                        ni->ni_ucastkey.wk_keyix = txkeyidx; 
     
    82838322        ni_key->wk_keylen = xmit_key->wk_keylen; 
    82848323        for (i = 0; i < IEEE80211_TID_SIZE; i++) 
    82858324                ni_key->wk_keyrsc[i] = xmit_key->wk_keyrsc[i]; 
    8286         ni_key->wk_keytsc = 0;  
     8325        ni_key->wk_keytsc = 0; 
    82878326        memset(ni_key->wk_key, 0, sizeof(ni_key->wk_key)); 
    82888327        memcpy(ni_key->wk_key, xmit_key->wk_key, xmit_key->wk_keylen); 
    8289         ieee80211_crypto_setkey(vap, &ni->ni_ucastkey,  
     8328        ieee80211_crypto_setkey(vap, &ni->ni_ucastkey, 
    82908329                (rxkeyidx == txkeyidx) ? ni->ni_macaddr:null_macaddr, ni); 
    82918330 
    82928331        if (rxkeyidx != txkeyidx) { 
     
    82978336                ni_key->wk_keylen = rcv_key->wk_keylen; 
    82988337                for(i = 0; i < IEEE80211_TID_SIZE; i++) 
    82998338                        ni_key->wk_keyrsc[i] = rcv_key->wk_keyrsc[i]; 
    8300                 ni_key->wk_keytsc = 0;  
    8301                 ni_key->wk_cipher = rcv_key->wk_cipher;  
    8302                 ni_key->wk_private = rcv_key->wk_private;  
     8339                ni_key->wk_keytsc = 0; 
     8340                ni_key->wk_cipher = rcv_key->wk_cipher; 
     8341                ni_key->wk_private = rcv_key->wk_private; 
    83038342                memset(ni_key->wk_key, 0, sizeof(ni_key->wk_key)); 
    83048343                memcpy(ni_key->wk_key, rcv_key->wk_key, rcv_key->wk_keylen); 
    83058344                ieee80211_crypto_setkey(vap, &tmpkey, ni->ni_macaddr, ni); 
     
    85128551        (void)ath_hal_getmaxtxpow(ah, &maxtxpowlimit); 
    85138552        ic->ic_txpowlimit = maxtxpowlimit; 
    85148553        ath_hal_settxpowlimit(ah, txpowlimit); 
    8515          
     8554 
    85168555        /* 
    85178556         * Make sure the VAP's change is within limits, clamp it otherwise 
    85188557         */ 
     
    85208559                clamped_txpow = ic->ic_txpowlimit; 
    85218560        else 
    85228561                clamped_txpow = ic->ic_newtxpowlimit; 
    8523          
     8562 
    85248563        /* 
    85258564         * Search for the VAP that needs a txpow change, if any 
    85268565         */ 
     
    85358574                ieee80211_iterate_nodes(&vap->iv_ic->ic_sta, set_node_txpower, &clamped_txpow); 
    85368575#endif 
    85378576        } 
    8538          
     8577 
    85398578        ic->ic_newtxpowlimit = sc->sc_curtxpow = clamped_txpow; 
    85408579 
    85418580#ifdef ATH_CAP_TPC 
     
    85468585                ath_hal_settxpowlimit(ah, ic->ic_newtxpowlimit); 
    85478586#endif 
    85488587} 
    8549   
     8588 
    85508589 
    85518590#ifdef ATH_SUPERG_XR 
    85528591static int 
     
    88108849 
    88118850        /* if the 4msec limit is set on the channel, take it in to account */ 
    88128851        if (sc->sc_curchan.privFlags & CHANNEL_4MS_LIMIT) 
    8813                 txoplimit = MIN(txoplimit, US_PER_4MS);  
     8852                txoplimit = MIN(txoplimit, US_PER_4MS); 
    88148853 
    88158854        if (txoplimit != 0 && athff_approx_txtime(sc, an, skb) > txoplimit) { 
    88168855                DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF, 
     
    90279066                        error = ath_ioctl_ethtool(sc, cmd, ifr->ifr_data); 
    90289067                break; 
    90299068        case SIOC80211IFCREATE: 
    9030                 error = ieee80211_ioctl_create_vap(ic, ifr, dev);  
     9069                error = ieee80211_ioctl_create_vap(ic, ifr, dev); 
    90319070                break; 
    90329071        default: 
    90339072                error = -EINVAL; 
     
    91819220                                break; 
    91829221                        } 
    91839222#ifdef ATH_SUPERG_XR 
    9184                         case ATH_XR_POLL_PERIOD:  
     9223                        case ATH_XR_POLL_PERIOD: 
    91859224                                if (val > XR_MAX_POLL_INTERVAL) 
    91869225                                        val = XR_MAX_POLL_INTERVAL; 
    91879226                                else if (val < XR_MIN_POLL_INTERVAL) 
     
    91899228                                sc->sc_xrpollint = val; 
    91909229                                break; 
    91919230 
    9192                         case ATH_XR_POLL_COUNT:  
     9231                        case ATH_XR_POLL_COUNT: 
    91939232                                if (val > XR_MAX_POLL_COUNT) 
    91949233                                        val = XR_MAX_POLL_COUNT; 
    91959234                                else if (val < XR_MIN_POLL_COUNT) 
     
    92509289                        val = ath_hal_gettkipmic(ah); 
    92519290                        break; 
    92529291#ifdef ATH_SUPERG_XR 
    9253                 case ATH_XR_POLL_PERIOD:  
     9292                case ATH_XR_POLL_PERIOD: 
    92549293                        val=sc->sc_xrpollint; 
    92559294                        break; 
    9256                 case ATH_XR_POLL_COUNT:  
     9295                case ATH_XR_POLL_COUNT: 
    92579296                        val=sc->sc_xrpollcount; 
    92589297                        break; 
    92599298#endif 
     
    93719410{ 
    93729411        int i, space; 
    93739412        char *dev_name = NULL; 
    9374          
     9413 
    93759414        space = 5 * sizeof(struct ctl_table) + sizeof(ath_sysctl_template); 
    93769415        sc->sc_sysctls = kmalloc(space, GFP_KERNEL); 
    93779416        if (sc->sc_sysctls == NULL) { 
    93789417                printk("%s: no memory for sysctl table!\n", __func__); 
    93799418                return; 
    93809419        } 
    9381          
    9382         /*  
     9420 
     9421        /* 
    93839422         * We want to reserve space for the name of the device seperate 
    93849423         * to the net_device structure, because when the name is changed 
    93859424         * it is changed in the net_device structure and the message given 
     
    95839622} 
    95849623#endif /* CONFIG_SYSCTL */ 
    95859624 
    9586 static const char*  
     9625static const char* 
    95879626ath_get_hal_status_desc(HAL_STATUS status) 
    95889627{ 
    95899628        if (status > 0 && status < sizeof(hal_status_desc)/sizeof(char *))