/home/tai/chorist/xian-1.2/src/ksi.c

Go to the documentation of this file.
00001 
00023 /************************************************************************************************//*
00024  * The Kernel Space XIAN API provides functions to access to the madwifi metrics.
00025  * @file ksi.c
00026  * @authors THALES Communications
00027 ****************************************************************************************************/
00028 
00029 #include <linux/module.h>   // Needed by all modules
00030 //#include <linux/kernel.h>   // Needed for KERN_ALERT
00031 #include <linux/init.h>     // Needed for the macros
00032 #include <linux/netdevice.h> // Needed to get net_dev structures
00033 
00034 #include "include/ksi.h"
00035 #include "include/errors.h"
00036 
00037 /***************************************************************************************************/
00044 int _is_dev_available (char * dev_name)
00045 {
00046   struct net_device * dev;
00047   int boolean;
00048   if ((dev_name) && (strlen(dev_name)))
00049     {
00050       dev = dev_get_by_name (dev_name);
00051       boolean = (dev != NULL);
00052       dev_put(dev);
00053       return boolean;
00054     }
00055   return -1;
00056 }
00057 
00058 /***************************************************************************************************/
00065 int is_dev_available (char * dev_name)
00066 {
00067   switch (_is_dev_available (dev_name))
00068     {
00069     case  0: printk ("Interface not found\n");
00070       return 0;
00071       break;
00072     case  1: return 1;
00073       break;
00074     default: printk ("Interface name not specified!!!\n");
00075       return -1;
00076     }
00077 }
00078 
00079 /***************************************************************************************************
00080  ***************************************************************************************************
00081  *  METRICS OFFERED BY struct ieee80211_nodestats
00082  *  - rx data frame
00083  *  - rx management frames
00084  *  - rx control frames
00085  *  - rx unicast frames
00086  *  - rx multi/broadcast frames
00087  *  - rx data count (bytes)
00088  *  - rx beacon frames
00089  *  - rx probe response frames
00090  *  - rx discard 'cuz dup
00091  *  - rx w/ wep but privacy off
00092  *  - rx wep processing failed
00093  *  - rx demic failed
00094  *  - rx decapsulation failed
00095  *  - rx defragmentation failed
00096  *  - rx disassociation
00097  *  - rx deauthentication
00098  *  - rx decrypt failed on crc
00099  *  - rx on unauthorized port
00100  *  - rx unecrypted w/ privacy
00101  *   
00102  *  - tx data frames
00103  *  - tx management frames
00104  *  - tx unicast frames
00105  *  - tx multi/broadcast frames
00106  *  - tx data count (bytes)
00107  *  - tx probe request frames
00108  *  - tx discard 'cuz no tag
00109  *  - tx discard 'cuz bad tag
00110  *  - ps discard 'cuz of age
00111  *  
00112  *  => MIB-related state
00113  *
00114  *  - [re]associations
00115  *  - [re]association failures
00116  *  - [re]authentications
00117  *  - [re]authentication failures
00118  *  - deauthentications
00119  *  - last deauth reason
00120  *  - disassociations
00121  *  - last disassociation reason
00122  ***************************************************************************************************
00123  ***************************************************************************************************/
00124 
00125 #define GET_NODE_NS(return_type, metric_name)                           \
00126   return_type                                                           \
00127   get_node_##metric_name(u_int8_t * macadd, char * dev_name, unsigned int * code_err) \
00128   {                                                                     \
00129     u_int32_t metric = 0;                                               \
00130     int node_found = 0;                                                 \
00131     struct net_device * dev;                                            \
00132     if (macadd)                                                         \
00133       {                                                                 \
00134         if ((dev_name) && (strlen(dev_name)))                           \
00135           {                                                             \
00136             dev = dev_get_by_name(dev_name);                            \
00137             if (dev)                                                    \
00138               {                                                         \
00139                 struct ath_softc *sc = dev->priv;                       \
00140                 struct ieee80211com *ic = &sc->sc_ic;                   \
00141                 struct ieee80211_node_table *nt = &ic->ic_sta;          \
00142                 struct ieee80211_node *ni;                              \
00143                 ATH_LOCK(sc);                                           \
00144                 IEEE80211_NODE_LOCK(nt);                                \
00145                 TAILQ_FOREACH(ni, &nt->nt_node, ni_list)                \
00146                   {                                                     \
00147                     printk("%s", ni->ni_macaddr);\
00148                     if (IEEE80211_ADDR_EQ(macadd, ni->ni_macaddr))      \
00149                       {                                                 \
00150                         node_found=1;                                   \
00151                         metric=ni->ni_stats.ns_##metric_name;                   \
00152                         break;                                          \
00153                       }                                                 \
00154                   }                                                     \
00155                 IEEE80211_NODE_UNLOCK(nt);                              \
00156                 ATH_UNLOCK(sc);                                         \
00157                 if (node_found==0)                                      \
00158                   {                                                     \
00159                     (*code_err) = NEIGHBOR_NOT_FOUND;                   \
00160                     dev_put(dev);                                       \
00161                     return 0;                                           \
00162                   }                                                     \
00163                 dev_put(dev);                                           \
00164                 return metric;                                          \
00165               }                                                         \
00166             (*code_err) = DEV_NOT_FOUND;                                \
00167             printk ("Device interface not found\n");                    \
00168             return 0;                                                   \
00169           }                                                             \
00170         (*code_err) = DEV_NAME_NOT_DEFINED;                             \
00171         printk("Device interface name not specified !!!\n");            \
00172         return 0;                                                       \
00173       }                                                                 \
00174     (*code_err) = MAC_ADDR_NOT_DEFINED;                                 \
00175     return 0;                                                           \
00176   }                                                                     \
00177   XIAN_EXPORT_SYMBOL(get_node_##metric_name)
00178 //end of macro GET_NODE_NS(_type)
00179 
00180 /******************************************************************************************************/
00186 //get_node_rx_data
00187 GET_NODE_NS(u_int32_t, rx_data);
00188 
00189 /*******************************************************************************************************/
00195 //get_node_rx_mgmt
00196 GET_NODE_NS(u_int32_t, rx_mgmt);
00197 
00198 /*********************************************************************************************************/
00204 //get_node_rx_ctrl
00205 GET_NODE_NS(u_int32_t, rx_ctrl);
00206 
00207 /***********************************************************************************************************/
00213 //get_node_rx_ucast
00214 GET_NODE_NS(u_int32_t, rx_ucast);
00215 
00216 /*********************************************************************************************************************/
00222 //get_node_rx_mcast
00223 GET_NODE_NS(u_int32_t, rx_mcast);
00224 
00225 /******************************************************************************************************************/
00231 //get_node_rx_bytes
00232 GET_NODE_NS(u_int64_t, rx_bytes);
00233 
00234 /************************************************************************************************************/
00240 //get_node_rx_beacons
00241 GET_NODE_NS(u_int64_t, rx_beacons);
00242 
00243 /******************************************************************************************************************/
00249 //get_node_rx_proberesp
00250 GET_NODE_NS(u_int32_t, rx_proberesp);
00251 
00252 /*************************************************************************************************************/
00258 //get_node_rx_dup
00259 GET_NODE_NS(u_int32_t, rx_dup);
00260 
00261 /******************************************************************************************************************/
00267 //get_node_rx_noprivacy
00268 GET_NODE_NS(u_int32_t, rx_noprivacy);
00269 
00270 /******************************************************************************************************************/
00276 //get_node_rx_wepfail
00277 GET_NODE_NS(u_int32_t, rx_wepfail);
00278 
00279 /*************************************************************************************************************/
00285 //get_node_rx_dmicfail
00286 GET_NODE_NS(u_int32_t, rx_demicfail);
00287 
00288 /******************************************************************************************************************/
00294 //get_node_rx_decap
00295 GET_NODE_NS(u_int32_t, rx_decap);
00296 
00297 /******************************************************************************************************************/
00303 //get_node_rx_defrag
00304 GET_NODE_NS(u_int32_t, rx_defrag);
00305 
00306 /****************************************************************************************************************/
00312 //get_node_rx_disassoc
00313 GET_NODE_NS(u_int32_t, rx_disassoc);
00314 
00315 /****************************************************************************************************************/
00321 //get_node_rx_deauth
00322 GET_NODE_NS(u_int32_t, rx_deauth);
00323 
00324 /******************************************************************************************************************/
00330 //get_node_rx_decryptcrc
00331 GET_NODE_NS(u_int32_t, rx_decryptcrc);
00332 
00333 /**********************************************************************************************************************/
00339 //get_node_rx_unauth
00340 GET_NODE_NS(u_int32_t, rx_unauth);
00341 
00342 /********************************************************************************************************************/
00348 //get_node_rx_unencrypted
00349 GET_NODE_NS(u_int32_t, rx_unencrypted);
00350 
00351 /*****************************************************************************************************************/
00357 //get_node_tx_data
00358 GET_NODE_NS(u_int32_t, tx_data);
00359 
00360 /***************************************************************************************************************/
00366 //get_node_tx_mgmt
00367 GET_NODE_NS(u_int32_t, tx_mgmt);
00368 
00369 /*************************************************************************************************************/
00377 //get_node_tx_ucast
00378 GET_NODE_NS(u_int32_t, tx_ucast);
00379 
00380 /******************************************************************************************************************/
00388 //get_node_tx_mcast
00389 GET_NODE_NS(u_int32_t, tx_mcast);
00390 
00391 /*************************************************************************************************************/
00399 //get_node_tx_bytes
00400 GET_NODE_NS(u_int64_t, tx_bytes);
00401 
00402 /****************************************************************************************************************/
00410 //get_node_tx_probereq
00411 GET_NODE_NS(u_int32_t, tx_probereq);
00412 
00413 /****************************************************************************************************************/
00421 //get_node_tx_novlantag
00422 GET_NODE_NS(u_int32_t, tx_novlantag);
00423 
00424 /****************************************************************************************************************/
00432 //get_node_tx_vlanmismatch
00433 GET_NODE_NS(u_int32_t, tx_vlanmismatch);
00434 
00435 /*****************************************************************************************************************/
00443 //get_node_ps_discard
00444 GET_NODE_NS(u_int32_t, ps_discard);
00445 
00446 /******************************************************************************************************************************/
00454 //get_node_tx_assoc
00455 GET_NODE_NS(u_int32_t, tx_assoc);
00456 
00457 /************************************************************************************************************************************/
00465 //get_node_tx_assoc_fail
00466 GET_NODE_NS(u_int32_t, tx_assoc_fail);
00467 
00468 /*********************************************************************************************************************************/
00476 //get_node_tx_auth
00477 GET_NODE_NS(u_int32_t, tx_auth);
00478 
00479 /**************************************************************************************************************************************/
00487 //get_node_tx_auth_fail
00488 GET_NODE_NS(u_int32_t, tx_auth_fail);
00489 
00490 /**************************************************************************************************************************************/
00498 //get_node_tx_deauth
00499 GET_NODE_NS(u_int32_t, tx_deauth);
00500 
00501 /**************************************************************************************************************************************/
00509 //get_node_tx_deauth_code
00510 GET_NODE_NS(u_int32_t, tx_deauth_code);
00511 
00512 /**************************************************************************************************************************************/
00520 //get_node_tx_disassoc
00521 GET_NODE_NS(u_int32_t, tx_disassoc);
00522 
00523 /*************************************************************************************************************************************/
00531 //get_node_tx_disassoc_code
00532 GET_NODE_NS(u_int32_t, tx_disassoc_code);
00533 
00534 
00535 /****************************************************************************************************************
00536  ****************************************************************************************************************
00537  *  METRICS OFFERED BY struct ieee80211_node
00538  *  - negotiated rate or transmission rate
00539  *  - rssi
00540  *  - transmit power metric
00541  ****************************************************************************************************************
00542  ***************************************************************************************************************/
00543 
00544 
00545 /*************************************************************************************************************/
00553 u_int8_t
00554 get_node_txpower(u_int8_t * macadd,
00555                  char * dev_name,
00556                  unsigned int * code_err)
00557 {
00558   u_int8_t metric = 0;
00559   int node_found = 0;
00560   struct net_device * dev;
00561 
00562   if (macadd)
00563     {
00564       if ((dev_name) && (strlen(dev_name)))
00565         {
00566           dev = dev_get_by_name(dev_name);
00567           if (dev)
00568             {
00569               struct ath_softc *sc = dev->priv;
00570               struct ieee80211com *ic = &sc->sc_ic;
00571               struct ieee80211_node_table *nt = &ic->ic_sta;
00572               struct ieee80211_node *ni;
00573               ATH_LOCK(sc);
00574               IEEE80211_NODE_LOCK(nt);
00575               TAILQ_FOREACH(ni, &nt->nt_node, ni_list)
00576                 {
00577                   if (IEEE80211_ADDR_EQ(macadd, ni->ni_macaddr))
00578                     {
00579                       node_found=1;
00580                       metric=ni->ni_txpower;
00581                       break;
00582                     }
00583                 }
00584               IEEE80211_NODE_UNLOCK(nt);
00585               ATH_UNLOCK(sc);
00586               if (node_found==0)
00587                 { 
00588                    (*code_err) = NEIGHBOR_NOT_FOUND; 
00589                    dev_put(dev);
00590                    return 0;     
00591                 }  
00592               dev_put(dev);
00593               return metric;
00594             }
00595           (*code_err) = DEV_NOT_FOUND;
00596           printk ("Device interface not found\n");
00597           return 0;
00598         }
00599       (*code_err) = DEV_NAME_NOT_DEFINED; 
00600       printk("Device interface name not specified !!!\n");
00601       return 0;
00602     }
00603   (*code_err) = MAC_ADDR_NOT_DEFINED; 
00604   return 0; 
00605 }
00606 XIAN_EXPORT_SYMBOL(get_node_txpower);
00607 
00608 
00609 /*************************************************************************************************************/
00617 u_int8_t
00618 get_node_negotiated_rate(u_int8_t * macadd,
00619                          char * dev_name,
00620                          unsigned int * code_err)
00621 {
00622   u_int8_t metric = 0;
00623   int node_found = 0;
00624   struct net_device * dev;
00625 
00626   if (macadd)
00627     {
00628       if ((dev_name) && (strlen(dev_name)))
00629         {
00630           dev = dev_get_by_name(dev_name);        
00631           if (dev)
00632             {
00633               struct ath_softc *sc = dev->priv;
00634               struct ieee80211com *ic = &sc->sc_ic;
00635               struct ieee80211_node_table *nt = &ic->ic_sta;
00636               struct ieee80211_node *ni;
00637               ATH_LOCK(sc);
00638               IEEE80211_NODE_LOCK(nt);
00639               TAILQ_FOREACH(ni, &nt->nt_node, ni_list)
00640                 {
00641                   if (IEEE80211_ADDR_EQ(macadd, ni->ni_macaddr))
00642                     {
00643                       node_found=1;
00644                       metric=(ni->ni_rates.rs_rates[ni->ni_txrate] & 0x7f / 2);
00645                       break;
00646                     }
00647                 }
00648               IEEE80211_NODE_UNLOCK(nt);
00649               ATH_UNLOCK(sc);
00650               if (node_found==0)
00651                 { 
00652                    (*code_err) = NEIGHBOR_NOT_FOUND; 
00653                    dev_put(dev);
00654                    return 0;     
00655                 }  
00656               dev_put(dev);
00657               return metric;
00658             }
00659           (*code_err) = DEV_NOT_FOUND;
00660           printk ("Device interface not found\n");
00661           return 0;
00662         }
00663       (*code_err) = DEV_NAME_NOT_DEFINED; 
00664       printk("Device interface name not specified !!!\n");
00665       return 0;
00666     }
00667   (*code_err) = MAC_ADDR_NOT_DEFINED; 
00668   return 0; 
00669 }
00670 XIAN_EXPORT_SYMBOL(get_node_negotiated_rate);
00671 
00672 
00673 /*************************************************************************************************************/
00681 u_int8_t
00682 get_node_rssi(u_int8_t * macadd,
00683               char * dev_name,
00684               unsigned int * code_err)
00685 {
00686   u_int8_t metric = 0;
00687   int node_found = 0;
00688   struct net_device * dev;
00689   if (macadd)
00690     {
00691       if ((dev_name) && (strlen(dev_name)))
00692         {
00693           dev = dev_get_by_name(dev_name);
00694           if (dev)
00695             {
00696               struct ath_softc *sc = dev->priv;
00697               struct ieee80211com *ic = &sc->sc_ic;
00698               struct ieee80211_node_table *nt = &ic->ic_sta;
00699               struct ieee80211_node *ni;
00700               ATH_LOCK(sc);
00701               IEEE80211_NODE_LOCK(nt);
00702               TAILQ_FOREACH(ni, &nt->nt_node, ni_list)
00703                 {
00704                   if (IEEE80211_ADDR_EQ(macadd, ni->ni_macaddr))
00705                     {
00706                       node_found=1;
00707                       metric=ni->ni_rssi;
00708                       break;
00709                     }
00710                 }
00711               IEEE80211_NODE_UNLOCK(nt);
00712               ATH_UNLOCK(sc);
00713               if (node_found==0)
00714                 { 
00715                    (*code_err) = NEIGHBOR_NOT_FOUND; 
00716                    dev_put(dev);
00717                    return 0;     
00718                 }
00719               dev_put(dev);
00720               return metric;
00721             }
00722           (*code_err) = DEV_NOT_FOUND;
00723           printk ("Device interface not found\n");
00724           return 0;
00725         }
00726       (*code_err) = DEV_NAME_NOT_DEFINED; 
00727       printk("Device interface name not specified !!!\n");
00728       return 0;
00729     }
00730   (*code_err) = MAC_ADDR_NOT_DEFINED; 
00731   return 0; 
00732 }
00733 XIAN_EXPORT_SYMBOL(get_node_rssi);
00734 
00735 
00736 /****************************************************************************************************************
00737  ****************************************************************************************************************
00738  *  METRICS OFFERED BY struct onoe_node
00739  *  - tx !ok pkt (error count of tx frame with no ack)
00740  *  - tx ok pkt count
00741  *  - tx retry count
00742  ****************************************************************************************************************
00743  ***************************************************************************************************************/
00744 
00745 /*************************************************************************************************************/
00754 u_int
00755 get_node_on_tx_err(u_int8_t * macadd,
00756                    char * dev_name,
00757                    unsigned int * code_err)
00758 {
00759   u_int metric = 0;
00760   int node_found = 0;
00761   struct net_device * dev;
00762   
00763   if (macadd)
00764     {
00765       if ((dev_name) && (strlen(dev_name)))
00766         {
00767           dev = dev_get_by_name(dev_name);
00768           if (dev)
00769             {
00770               struct ath_softc *sc = dev->priv;
00771               struct ieee80211com *ic = &sc->sc_ic;
00772               struct ieee80211_node_table *nt = &ic->ic_sta;
00773               struct ieee80211_node *ni;
00774               struct ath_node *an;
00775               struct onoe_node * on;
00776 
00777               ATH_LOCK(sc);
00778               IEEE80211_NODE_LOCK(nt);
00779               TAILQ_FOREACH(ni, &nt->nt_node, ni_list)
00780                 {
00781                   if (IEEE80211_ADDR_EQ(macadd, ni->ni_macaddr))
00782                     {
00783                       node_found = 1;
00784                       an = ATH_NODE(ni);
00785                       on = ATH_NODE_ONOE(an);
00786                       metric = on->on_tx_err;
00787                       /*
00788                       printk("\n\n>>>> ONOE STATS : \n\n");
00789                       printk("on_tx_ok = %u\n", on->on_tx_ok);
00790                       printk("on_tx_err = %u\n", on->on_tx_err);
00791                       printk("on_tx_retr = %u\n", on->on_tx_retr);
00792                       printk("on_tx_upper = %d\n", on->on_tx_upper);
00793                       printk("on_tx_rix0 = %u\n", on->on_tx_rix0);
00794                       printk("on_tx_try0 = %u\n", on->on_tx_try0);
00795                       printk("on_tx_rate0 = %u\n", on->on_tx_rate0);
00796                       printk("on_tx_rate1 = %u\n", on->on_tx_rate1);
00797                       printk("on_tx_rate2 = %u\n", on->on_tx_rate2);
00798                       printk("on_tx_rate3 = %u\n", on->on_tx_rate3);
00799                       printk("on_tx_rate0sp = %u\n", on->on_tx_rate0sp);
00800                       printk("on_tx_rate1sp = %u\n", on->on_tx_rate1sp);
00801                       printk("on_tx_rate2sp = %u\n", on->on_tx_rate2sp);
00802                       printk("on_tx_rate3sp = %u\n", on->on_tx_rate3sp);
00803                       */                                    
00804                       break;
00805                     }
00806                 }
00807               IEEE80211_NODE_UNLOCK(nt);
00808               ATH_UNLOCK(sc);
00809               if (node_found==0)
00810                 { 
00811                    (*code_err) = NEIGHBOR_NOT_FOUND; 
00812                    dev_put(dev);
00813                    return 0;     
00814                 }  
00815               dev_put(dev);
00816               return metric;
00817             }
00818           (*code_err) = DEV_NOT_FOUND;
00819           printk ("Device interface not found\n");
00820           return 0;
00821         }
00822       (*code_err) = DEV_NAME_NOT_DEFINED; 
00823       printk("Device interface name not specified !!!\n");
00824       return 0;
00825     }
00826   (*code_err) = MAC_ADDR_NOT_DEFINED; 
00827   return 0;  
00828 }
00829 XIAN_EXPORT_SYMBOL(get_node_on_tx_err);
00830 
00831 
00832 /*************************************************************************************************************/
00841 u_int
00842 get_node_on_tx_ok(u_int8_t * macadd,
00843                   char * dev_name,
00844                   unsigned int * code_err)
00845 {
00846   u_int metric = 0;
00847   int node_found = 0;
00848   struct net_device * dev;
00849   
00850   if (macadd)
00851     {
00852       if ((dev_name) && (strlen(dev_name)))
00853         {
00854           dev = dev_get_by_name(dev_name);
00855           if (dev)
00856             {
00857               struct ath_softc *sc = dev->priv;
00858               struct ieee80211com *ic = &sc->sc_ic;
00859               struct ieee80211_node_table *nt = &ic->ic_sta;
00860               struct ieee80211_node *ni;
00861               struct ath_node *an;
00862               struct onoe_node * on;
00863 
00864               ATH_LOCK(sc);
00865               IEEE80211_NODE_LOCK(nt);
00866               TAILQ_FOREACH(ni, &nt->nt_node, ni_list)
00867                 {
00868                   if (IEEE80211_ADDR_EQ(macadd, ni->ni_macaddr))
00869                     {
00870                       node_found = 1;
00871                       an = ATH_NODE(ni);
00872                       on = ATH_NODE_ONOE(an);
00873                       metric = on->on_tx_ok;
00874                       /*
00875                       printk("\n\n>>>> ONOE STATS : \n\n");
00876                       printk("on_tx_ok = %u\n", on->on_tx_ok);
00877                       printk("on_tx_err = %u\n", on->on_tx_err);
00878                       printk("on_tx_retr = %u\n", on->on_tx_retr);
00879                       printk("on_tx_upper = %d\n", on->on_tx_upper);
00880                       printk("on_tx_rix0 = %u\n", on->on_tx_rix0);
00881                       printk("on_tx_try0 = %u\n", on->on_tx_try0);
00882                       printk("on_tx_rate0 = %u\n", on->on_tx_rate0);
00883                       printk("on_tx_rate1 = %u\n", on->on_tx_rate1);
00884                       printk("on_tx_rate2 = %u\n", on->on_tx_rate2);
00885                       printk("on_tx_rate3 = %u\n", on->on_tx_rate3);
00886                       printk("on_tx_rate0sp = %u\n", on->on_tx_rate0sp);
00887                       printk("on_tx_rate1sp = %u\n", on->on_tx_rate1sp);
00888                       printk("on_tx_rate2sp = %u\n", on->on_tx_rate2sp);
00889                       printk("on_tx_rate3sp = %u\n", on->on_tx_rate3sp);
00890                       */                                    
00891                       break;
00892                     }
00893                 }
00894               IEEE80211_NODE_UNLOCK(nt);
00895               ATH_UNLOCK(sc);
00896               if (node_found==0)
00897                 { 
00898                    (*code_err) = NEIGHBOR_NOT_FOUND; 
00899                    dev_put(dev);
00900                    return 0;     
00901                 }  
00902               dev_put(dev);
00903               return metric;
00904             }
00905           (*code_err) = DEV_NOT_FOUND;
00906           printk ("Device interface not found\n");
00907           return 0;
00908         }
00909       (*code_err) = DEV_NAME_NOT_DEFINED; 
00910       printk("Device interface name not specified !!!\n");
00911       return 0;
00912     }
00913   (*code_err) = MAC_ADDR_NOT_DEFINED; 
00914   return 0;  
00915 }
00916 XIAN_EXPORT_SYMBOL(get_node_on_tx_ok);
00917 
00918 
00919 /*************************************************************************************************************/
00928 u_int
00929 get_node_on_tx_retr(u_int8_t * macadd,
00930                     char * dev_name,
00931                     unsigned int * code_err)
00932 {
00933   u_int metric = 0;
00934   int node_found = 0;
00935   struct net_device * dev;
00936   
00937   if (macadd)
00938     {
00939       if ((dev_name) && (strlen(dev_name)))
00940         {
00941           dev = dev_get_by_name(dev_name);
00942           if (dev)
00943             {
00944               struct ath_softc *sc = dev->priv;
00945               struct ieee80211com *ic = &sc->sc_ic;
00946               struct ieee80211_node_table *nt = &ic->ic_sta;
00947               struct ieee80211_node *ni;
00948               struct ath_node *an;
00949               struct onoe_node * on;
00950 
00951               ATH_LOCK(sc);
00952               IEEE80211_NODE_LOCK(nt);
00953               TAILQ_FOREACH(ni, &nt->nt_node, ni_list)
00954                 {
00955                   if (IEEE80211_ADDR_EQ(macadd, ni->ni_macaddr))
00956                     {
00957                       node_found = 1;
00958                       an = ATH_NODE(ni);
00959                       on = ATH_NODE_ONOE(an);
00960                       metric = on->on_tx_retr;
00961                       /*
00962                       printk("\n\n>>>> ONOE STATS : \n\n");
00963                       printk("on_tx_ok = %u\n", on->on_tx_ok);
00964                       printk("on_tx_err = %u\n", on->on_tx_err);
00965                       printk("on_tx_retr = %u\n", on->on_tx_retr);
00966                       printk("on_tx_upper = %d\n", on->on_tx_upper);
00967                       printk("on_tx_rix0 = %u\n", on->on_tx_rix0);
00968                       printk("on_tx_try0 = %u\n", on->on_tx_try0);
00969                       printk("on_tx_rate0 = %u\n", on->on_tx_rate0);
00970                       printk("on_tx_rate1 = %u\n", on->on_tx_rate1);
00971                       printk("on_tx_rate2 = %u\n", on->on_tx_rate2);
00972                       printk("on_tx_rate3 = %u\n", on->on_tx_rate3);
00973                       printk("on_tx_rate0sp = %u\n", on->on_tx_rate0sp);
00974                       printk("on_tx_rate1sp = %u\n", on->on_tx_rate1sp);
00975                       printk("on_tx_rate2sp = %u\n", on->on_tx_rate2sp);
00976                       printk("on_tx_rate3sp = %u\n", on->on_tx_rate3sp);
00977                       */                                    
00978                       break;
00979                     }
00980                 }
00981               IEEE80211_NODE_UNLOCK(nt);
00982               ATH_UNLOCK(sc);
00983               if (node_found==0)
00984                 { 
00985                    (*code_err) = NEIGHBOR_NOT_FOUND; 
00986                    dev_put(dev);
00987                    return 0;     
00988                 }  
00989               dev_put(dev);
00990               return metric;
00991             }
00992           (*code_err) = DEV_NOT_FOUND;
00993           printk ("Device interface not found\n");
00994           return 0;
00995         }
00996       (*code_err) = DEV_NAME_NOT_DEFINED; 
00997       printk("Device interface name not specified !!!\n");
00998       return 0;
00999     }
01000   (*code_err) = MAC_ADDR_NOT_DEFINED; 
01001   return 0;  
01002 }
01003 XIAN_EXPORT_SYMBOL(get_node_on_tx_retr);
01004 
01005 
01006 /****************************************************************************************************************
01007  ****************************************************************************************************************
01008  *  METRICS OFFERED BY ath_stats
01009  *
01010  *  Number of :
01011  *  - device reset by watchdog 
01012  *  - fatal hardware error interrupts 
01013  *  - beacon miss interrupts 
01014  *  - beacon stuck interrupts 
01015  *  - rx overrun interrupts 
01016  *  - rx eol interrupts 
01017  *  - tx underrun interrupts
01018  *  - mib interrupts 
01019  *  - interrupts coalesced
01020  *  - packet sent on the interface 
01021  *  - management frames transmitted
01022  *  - frames discarded prior to assoc
01023  *  - frames discarded 'cuz device gone
01024  *  - output stopped 'cuz no buffer
01025  *  - tx encapsulation failed 
01026  *  - tx failed 'cuz no node
01027  *  - tx failed 'cuz no tx buffer (data)
01028  *  - tx failed 'cuz no tx buffer (mgmt)
01029  *  - tx linearized to cluster
01030  *  - tx discarded empty frame
01031  *  - tx failed for dma resrcs
01032  *  - tx failed 'cuz too many retries
01033 
01034  *  - tx failed 'cuz FIFO underrun
01035  *  - tx failed 'cuz xmit filtered 
01036  *  - tx on-chip retries (short) 
01037  *  - tx on-chip retries (long)
01038  *  - tx failed 'cuz bogus xmit rate
01039  *  - tx frames with no ack marked
01040  *  - tx frames with rts enabled 
01041  *  - tx frames with cts enabled 
01042  *  - tx frames with short preamble
01043  *  - tx frames with alternate rate
01044  *  - tx frames with protection
01045  *  - tx frames with cts and bursting
01046  *  - tx frames with cts extension
01047  *  - rx setup failed 'cuz no skb
01048  *  - rx setup failed for dma resrcs
01049  *  - rx failed 'cuz of desc overrun
01050  *  - rx failed 'cuz of bad CRC
01051  *  - rx failed 'cuz of FIFO overrun
01052  *  - rx failed 'cuz decryption 
01053  *  - rx failed 'cuz MIC failure 
01054  *  - rx failed 'cuz of PHY err
01055  *  - rx discarded 'cuz frame too short
01056  *  - rx discarded 'cuz frame too large 
01057  *  - packet recv on the interface
01058  *  - management frames received 
01059  *  - rx discarded 'cuz ctl frame
01060  *  - tx rssi of last ack 
01061  *  - rx rssi from histogram
01062  *  - beacons transmitted 
01063  *  - beacon setup failed 'cuz no skb
01064  *  - periodic calibration calls 
01065  *  - periodic calibration failed
01066  *  - periodic calibration rfgain reset
01067  *  - rate control checks 
01068  *  - rate control raised xmit rate
01069  *  - rate control dropped xmit rate
01070  *  - rx/default antenna switches 
01071  *  - tx antenna switches
01072  *   
01073  ****************************************************************************************************************
01074  ***************************************************************************************************************/
01075 
01076 /*************************************************************************************************************/
01083 u_int32_t
01084 get_ast_watchdog(char * dev_name,
01085                  unsigned int * code_err)
01086 {
01087   u_int32_t metric = 0;
01088   struct net_device * dev;
01089 
01090   if ((dev_name) && (strlen(dev_name)))
01091     {
01092       dev = dev_get_by_name(dev_name);  
01093       if (dev)
01094         {
01095           struct ath_softc *sc = dev->priv;
01096           struct ath_stats *sc_stats = &sc->sc_stats;     
01097           ATH_LOCK(sc);
01098           metric = sc_stats->ast_watchdog;
01099           ATH_UNLOCK(sc);
01100           dev_put(dev);
01101           return metric;
01102         }
01103       (*code_err) = DEV_NOT_FOUND;
01104       printk ("Device interface not found\n");
01105       return 0;
01106     }
01107   (*code_err) = DEV_NAME_NOT_DEFINED; 
01108   printk("Device interface name not specified !!!\n");
01109   return 0;
01110 }
01111 XIAN_EXPORT_SYMBOL(get_ast_watchdog);
01112 
01113 
01114 /*************************************************************************************************************/
01121 u_int32_t
01122 get_ast_hardware(char * dev_name,
01123                  unsigned int * code_err)
01124 {
01125   u_int32_t metric = 0;
01126   struct net_device * dev;
01127   
01128   if ((dev_name) && (strlen(dev_name)))
01129     {
01130       dev = dev_get_by_name(dev_name);    
01131       if (dev)
01132         {
01133           struct ath_softc *sc = dev->priv;
01134           struct ath_stats *sc_stats = &sc->sc_stats;     
01135           ATH_LOCK(sc);
01136           metric = sc_stats->ast_hardware;
01137           ATH_UNLOCK(sc);
01138           dev_put(dev);
01139           return metric;
01140         }
01141       (*code_err) = DEV_NOT_FOUND;
01142       printk ("Device interface not found\n");
01143       return 0;
01144     }
01145   (*code_err) = DEV_NAME_NOT_DEFINED; 
01146   printk("Device interface name not specified !!!\n");
01147   return 0;
01148 }
01149 XIAN_EXPORT_SYMBOL(get_ast_hardware);
01150 
01151 
01152 /*************************************************************************************************************/
01159 u_int32_t
01160 get_ast_bmiss(char * dev_name,
01161                  unsigned int * code_err)
01162 {
01163   u_int32_t metric = 0;
01164   struct net_device * dev;
01165 
01166   if ((dev_name) && (strlen(dev_name)))
01167     {
01168       dev = dev_get_by_name(dev_name);  
01169       if (dev)
01170         {
01171           struct ath_softc *sc = dev->priv;
01172           struct ath_stats *sc_stats = &sc->sc_stats;     
01173           ATH_LOCK(sc);
01174           metric = sc_stats->ast_bmiss;
01175           ATH_UNLOCK(sc);
01176           dev_put(dev);
01177           return metric;
01178         }
01179       (*code_err) = DEV_NOT_FOUND;
01180       printk ("Device interface not found\n");
01181       return 0;
01182     }
01183   (*code_err) = DEV_NAME_NOT_DEFINED; 
01184   printk("Device interface name not specified !!!\n");
01185   return 0;
01186 }
01187 XIAN_EXPORT_SYMBOL(get_ast_bmiss);
01188 
01189 
01190 /*************************************************************************************************************/
01197 u_int32_t
01198 get_ast_bstuck(char * dev_name,
01199                unsigned int * code_err)
01200 {
01201   u_int32_t metric = 0;
01202   struct net_device * dev;
01203 
01204   if ((dev_name) && (strlen(dev_name)))
01205     {
01206       dev = dev_get_by_name(dev_name);  
01207       if (dev)
01208         {
01209           struct ath_softc *sc = dev->priv;
01210 #ifdef MADWIFI_NG
01211           ATH_LOCK(sc);
01212           metric = sc->sc_bmisscount;
01213 #else
01214           struct ath_stats *sc_stats = &sc->sc_stats;
01215           ATH_LOCK(sc);
01216           metric = sc_stats->ast_bstuck;
01217 #endif
01218           ATH_UNLOCK(sc);
01219           dev_put(dev);
01220           return metric;
01221         }
01222       (*code_err) = DEV_NOT_FOUND;
01223       printk ("Device interface not found\n");
01224       return 0;
01225     }
01226   (*code_err) = DEV_NAME_NOT_DEFINED; 
01227   printk("Device interface name not specified !!!\n");
01228   return 0;
01229 }
01230 XIAN_EXPORT_SYMBOL(get_ast_bstuck);
01231 
01232 
01233 /*************************************************************************************************************/
01240 u_int32_t
01241 get_ast_rxorn(char * dev_name,
01242               unsigned int * code_err)
01243 {
01244   u_int32_t metric = 0;
01245   struct net_device * dev;
01246 
01247   if ((dev_name) && (strlen(dev_name)))
01248     {
01249       dev = dev_get_by_name(dev_name);  
01250       if (dev)
01251         {
01252           struct ath_softc *sc = dev->priv;
01253           struct ath_stats *sc_stats = &sc->sc_stats;     
01254           ATH_LOCK(sc);
01255           metric = sc_stats->ast_rxorn;
01256           ATH_UNLOCK(sc);
01257           dev_put(dev);
01258           return metric;
01259         }
01260       (*code_err) = DEV_NOT_FOUND;
01261       printk ("Device interface not found\n");
01262       return 0;
01263     }
01264   (*code_err) = DEV_NAME_NOT_DEFINED; 
01265   printk("Device interface name not specified !!!\n");
01266   return 0;
01267 }
01268 XIAN_EXPORT_SYMBOL(get_ast_rxorn);
01269 
01270 
01271 /*************************************************************************************************************/
01278 u_int32_t
01279 get_ast_rxeol(char * dev_name,
01280               unsigned int * code_err)
01281 {
01282   u_int32_t metric = 0;
01283   struct net_device * dev;
01284 
01285   if ((dev_name) && (strlen(dev_name)))
01286     {
01287       dev = dev_get_by_name(dev_name);  
01288       if (dev)
01289         {
01290           struct ath_softc *sc = dev->priv;
01291           struct ath_stats *sc_stats = &sc->sc_stats;     
01292           ATH_LOCK(sc);
01293           metric = sc_stats->ast_rxeol;
01294           ATH_UNLOCK(sc);
01295           dev_put(dev);
01296           return metric;
01297         }
01298       (*code_err) = DEV_NOT_FOUND;
01299       printk ("Device interface not found\n");
01300       return 0;
01301     }
01302   (*code_err) = DEV_NAME_NOT_DEFINED; 
01303   printk("Device interface name not specified !!!\n");
01304   return 0;
01305 }
01306 XIAN_EXPORT_SYMBOL(get_ast_rxeol);
01307 
01308 
01309 /*************************************************************************************************************/
01316 u_int32_t
01317 get_ast_txurn(char * dev_name,
01318               unsigned int * code_err)
01319 {
01320   u_int32_t metric = 0;
01321   struct net_device * dev;
01322 
01323   if ((dev_name) && (strlen(dev_name)))
01324     {
01325       dev = dev_get_by_name(dev_name);  
01326       if (dev)
01327         {
01328           struct ath_softc *sc = dev->priv;
01329           struct ath_stats *sc_stats = &sc->sc_stats;     
01330           ATH_LOCK(sc);
01331           metric = sc_stats->ast_txurn;
01332           ATH_UNLOCK(sc);
01333           dev_put(dev);
01334           return metric;
01335         }
01336       (*code_err) = DEV_NOT_FOUND;
01337       printk ("Device interface not found\n");
01338       return 0;
01339     }
01340   (*code_err) = DEV_NAME_NOT_DEFINED; 
01341   printk("Device interface name not specified !!!\n");
01342   return 0;
01343 }
01344 XIAN_EXPORT_SYMBOL(get_ast_txurn);
01345 
01346 
01347 /*************************************************************************************************************/
01354 u_int32_t
01355 get_ast_mib(char * dev_name,
01356             unsigned int * code_err)
01357 {
01358   u_int32_t metric = 0;
01359   struct net_device * dev;
01360 
01361   if ((dev_name) && (strlen(dev_name)))
01362     {
01363       dev = dev_get_by_name(dev_name);  
01364       if (dev)
01365         {
01366           struct ath_softc *sc = dev->priv;
01367           struct ath_stats *sc_stats = &sc->sc_stats;     
01368           ATH_LOCK(sc);
01369           metric = sc_stats->ast_mib;
01370           ATH_UNLOCK(sc);
01371           dev_put(dev);
01372           return metric;
01373         }
01374       (*code_err) = DEV_NOT_FOUND;
01375       printk ("Device interface not found\n");
01376       return 0;
01377     }
01378   (*code_err) = DEV_NAME_NOT_DEFINED; 
01379   printk("Device interface name not specified !!!\n");
01380   return 0;
01381 }
01382 XIAN_EXPORT_SYMBOL(get_ast_mib);
01383 
01384 
01385 /*************************************************************************************************************/
01392 u_int32_t
01393 get_ast_intrcoal(char * dev_name,
01394                  unsigned int * code_err)
01395 {
01396   u_int32_t metric = 0;
01397   struct net_device * dev;
01398 
01399   if ((dev_name) && (strlen(dev_name)))
01400     {
01401       dev = dev_get_by_name(dev_name);  
01402       if (dev)
01403         {
01404 #ifndef MADWIFI_NG
01405           struct ath_softc *sc = dev->priv;
01406           struct ath_stats *sc_stats = &sc->sc_stats;     
01407           ATH_LOCK(sc);
01408           metric = sc_stats->ast_intrcoal;
01409           ATH_UNLOCK(sc);
01410 #else
01411           metric = 0;
01412           printk("undefined metric ast_intrcoal\n");
01413 #endif
01414           dev_put(dev);
01415           return metric;
01416         }
01417       (*code_err) = DEV_NOT_FOUND;
01418       printk ("Device interface not found\n");
01419       return 0;
01420     }
01421   (*code_err) = DEV_NAME_NOT_DEFINED; 
01422   printk("Device interface name not specified !!!\n");
01423   return 0;
01424 }
01425 XIAN_EXPORT_SYMBOL(get_ast_intrcoal);
01426 
01427 
01428 /*************************************************************************************************************/
01435 u_int32_t
01436 get_ast_tx_packets(char * dev_name,
01437                  unsigned int * code_err)
01438 {
01439   u_int32_t metric = 0;
01440   struct net_device * dev;
01441 
01442   if ((dev_name) && (strlen(dev_name)))
01443     {
01444       dev = dev_get_by_name(dev_name);  
01445       if (dev)
01446         {
01447           struct ath_softc *sc = dev->priv;
01448           struct ath_stats *sc_stats = &sc->sc_stats;     
01449           ATH_LOCK(sc);
01450           metric = sc_stats->ast_tx_packets;
01451           ATH_UNLOCK(sc);
01452           dev_put(dev);
01453           return metric;
01454         }
01455       (*code_err) = DEV_NOT_FOUND;
01456       printk ("Device interface not found\n");
01457       return 0;
01458     }
01459   (*code_err) = DEV_NAME_NOT_DEFINED; 
01460   printk("Device interface name not specified !!!\n");
01461   return 0;
01462 }
01463 XIAN_EXPORT_SYMBOL(get_ast_tx_packets);
01464 
01465 
01466 /*************************************************************************************************************/
01473 u_int32_t
01474 get_ast_tx_mgmt(char * dev_name,
01475                 unsigned int * code_err)
01476 {
01477   u_int32_t metric = 0;
01478   struct net_device * dev;
01479 
01480   if ((dev_name) && (strlen(dev_name)))
01481     {
01482       dev = dev_get_by_name(dev_name);  
01483       if (dev)
01484         {
01485           struct ath_softc *sc = dev->priv;
01486           struct ath_stats *sc_stats = &sc->sc_stats;     
01487           ATH_LOCK(sc);
01488           metric = sc_stats->ast_tx_mgmt;
01489           ATH_UNLOCK(sc);
01490           dev_put(dev);
01491           return metric;
01492         }
01493       (*code_err) = DEV_NOT_FOUND;
01494       printk ("Device interface not found\n");
01495       return 0;
01496     }
01497   (*code_err) = DEV_NAME_NOT_DEFINED; 
01498   printk("Device interface name not specified !!!\n");
01499   return 0;
01500 }
01501 XIAN_EXPORT_SYMBOL(get_ast_tx_mgmt);
01502 
01503 
01504 /*************************************************************************************************************/
01511 u_int32_t
01512 get_ast_tx_discard(char * dev_name,
01513                    unsigned int * code_err)
01514 {
01515   u_int32_t metric = 0;
01516   struct net_device * dev;
01517 
01518   if ((dev_name) && (strlen(dev_name)))
01519     {
01520       dev = dev_get_by_name(dev_name);  
01521       if (dev)
01522         {
01523           struct ath_softc *sc = dev->priv;
01524           struct ath_stats *sc_stats = &sc->sc_stats;     
01525           ATH_LOCK(sc);
01526           metric = sc_stats->ast_tx_discard;
01527           ATH_UNLOCK(sc);
01528           dev_put(dev);
01529           return metric;
01530         }
01531       (*code_err) = DEV_NOT_FOUND;
01532       printk ("Device interface not found\n");
01533       return 0;
01534     }
01535   (*code_err) = DEV_NAME_NOT_DEFINED; 
01536   printk("Device interface name not specified !!!\n");
01537   return 0;
01538 }
01539 XIAN_EXPORT_SYMBOL(get_ast_tx_discard);
01540 
01541 
01542 /*************************************************************************************************************/
01549 u_int32_t
01550 get_ast_tx_invalid(char * dev_name,
01551                    unsigned int * code_err)
01552 {
01553   u_int32_t metric = 0;
01554   struct net_device * dev;
01555 
01556   if ((dev_name) && (strlen(dev_name)))
01557     {
01558       dev = dev_get_by_name(dev_name);  
01559       if (dev)
01560         {
01561           struct ath_softc *sc = dev->priv;
01562           struct ath_stats *sc_stats = &sc->sc_stats;     
01563           ATH_LOCK(sc);
01564           metric = sc_stats->ast_tx_invalid;
01565           ATH_UNLOCK(sc);
01566           dev_put(dev);
01567           return metric;
01568         }
01569       (*code_err) = DEV_NOT_FOUND;
01570       printk ("Device interface not found\n");
01571       return 0;
01572     }
01573   (*code_err) = DEV_NAME_NOT_DEFINED; 
01574   printk("Device interface name not specified !!!\n");
01575   return 0;
01576 }
01577 XIAN_EXPORT_SYMBOL(get_ast_tx_invalid);
01578 
01579 
01580 /*************************************************************************************************************/
01587 u_int32_t
01588 get_ast_tx_qstop(char * dev_name,
01589                  unsigned int * code_err)
01590 {
01591   u_int32_t metric = 0;
01592   struct net_device * dev;
01593 
01594   if ((dev_name) && (strlen(dev_name)))
01595     {
01596       dev = dev_get_by_name(dev_name);  
01597       if (dev)
01598         {
01599           struct ath_softc *sc = dev->priv;
01600           struct ath_stats *sc_stats = &sc->sc_stats;     
01601           ATH_LOCK(sc);
01602           metric = sc_stats->ast_tx_qstop;
01603           ATH_UNLOCK(sc);
01604           dev_put(dev);
01605           return metric;
01606         }
01607       (*code_err) = DEV_NOT_FOUND;
01608       printk ("Device interface not found\n");
01609       return 0;
01610     }
01611   (*code_err) = DEV_NAME_NOT_DEFINED; 
01612   printk("Device interface name not specified !!!\n");
01613   return 0;
01614 }
01615 XIAN_EXPORT_SYMBOL(get_ast_tx_qstop);
01616 
01617 
01618 /*************************************************************************************************************/
01625 u_int32_t
01626 get_ast_tx_encap(char * dev_name,
01627                  unsigned int * code_err)
01628 {
01629   u_int32_t metric = 0;
01630   struct net_device * dev;
01631 
01632   if ((dev_name) && (strlen(dev_name)))
01633     {
01634       dev = dev_get_by_name(dev_name);  
01635       if (dev)
01636         {
01637           struct ath_softc *sc = dev->priv;
01638           struct ath_stats *sc_stats = &sc->sc_stats;     
01639           ATH_LOCK(sc);
01640           metric = sc_stats->ast_tx_encap;
01641           ATH_UNLOCK(sc);
01642           dev_put(dev);
01643           return metric;
01644         }
01645       (*code_err) = DEV_NOT_FOUND;
01646       printk ("Device interface not found\n");
01647       return 0;
01648     }
01649   (*code_err) = DEV_NAME_NOT_DEFINED; 
01650   printk("Device interface name not specified !!!\n");
01651   return 0;
01652 }
01653 XIAN_EXPORT_SYMBOL(get_ast_tx_encap);
01654 
01655 
01656 /*************************************************************************************************************/
01663 u_int32_t
01664 get_ast_tx_nonode(char * dev_name,
01665                   unsigned int * code_err)
01666 {
01667   u_int32_t metric = 0;
01668   struct net_device * dev;
01669 
01670   if ((dev_name) && (strlen(dev_name)))
01671     {
01672       dev = dev_get_by_name(dev_name);  
01673       if (dev)
01674         {
01675           struct ath_softc *sc = dev->priv;
01676           struct ath_stats *sc_stats = &sc->sc_stats;     
01677           ATH_LOCK(sc);
01678           metric = sc_stats->ast_tx_nonode;
01679           ATH_UNLOCK(sc);
01680           dev_put(dev);
01681           return metric;
01682         }
01683       (*code_err) = DEV_NOT_FOUND;
01684       printk ("Device interface not found\n");
01685       return 0;
01686     }
01687   (*code_err) = DEV_NAME_NOT_DEFINED; 
01688   printk("Device interface name not specified !!!\n");
01689   return 0;
01690 }
01691 XIAN_EXPORT_SYMBOL(get_ast_tx_nonode);
01692 
01693 
01694 /*************************************************************************************************************/
01701 u_int32_t
01702 get_ast_tx_nobuf(char * dev_name,
01703               unsigned int * code_err)
01704 {
01705   u_int32_t metric = 0;
01706   struct net_device * dev;
01707 
01708   if ((dev_name) && (strlen(dev_name)))
01709     {
01710       dev = dev_get_by_name(dev_name);  
01711       if (dev)
01712         {
01713           struct ath_softc *sc = dev->priv;
01714           struct ath_stats *sc_stats = &sc->sc_stats;     
01715           ATH_LOCK(sc);
01716           metric = sc_stats->ast_tx_nobuf;
01717           ATH_UNLOCK(sc);
01718           dev_put(dev);
01719           return metric;
01720         }
01721       (*code_err) = DEV_NOT_FOUND;
01722       printk ("Device interface not found\n");
01723       return 0;
01724     }
01725   (*code_err) = DEV_NAME_NOT_DEFINED; 
01726   printk("Device interface name not specified !!!\n");
01727   return 0;
01728 }
01729 XIAN_EXPORT_SYMBOL(get_ast_tx_nobuf);
01730 
01731 
01732 /*************************************************************************************************************/
01739 u_int32_t
01740 get_ast_tx_nobufmgt(char * dev_name,
01741                     unsigned int * code_err)
01742 {
01743   u_int32_t metric = 0;
01744   struct net_device * dev;
01745 
01746   if ((dev_name) && (strlen(dev_name)))
01747     {
01748       dev = dev_get_by_name(dev_name);  
01749       if (dev)
01750         {
01751           struct ath_softc *sc = dev->priv;
01752           struct ath_stats *sc_stats = &sc->sc_stats;     
01753           ATH_LOCK(sc);
01754           metric = sc_stats->ast_tx_nobufmgt;
01755           ATH_UNLOCK(sc);
01756           dev_put(dev);
01757           return metric;
01758         }
01759       (*code_err) = DEV_NOT_FOUND;
01760       printk ("Device interface not found\n");
01761       return 0;
01762     }
01763   (*code_err) = DEV_NAME_NOT_DEFINED; 
01764   printk("Device interface name not specified !!!\n");
01765   return 0;
01766 }
01767 XIAN_EXPORT_SYMBOL(get_ast_tx_nobufmgt);
01768 
01769 
01770 /*************************************************************************************************************/
01777 u_int32_t
01778 get_ast_tx_linear(char * dev_name,
01779                   unsigned int * code_err)
01780 {
01781   u_int32_t metric = 0;
01782   struct net_device * dev;
01783 
01784   if ((dev_name) && (strlen(dev_name)))
01785     {
01786       dev = dev_get_by_name(dev_name);  
01787       if (dev)
01788         {
01789 #ifdef MADWIFI_NG
01790           metric = 0;
01791           printk("undefined metric ast_tx_linear\n");
01792 #else
01793           struct ath_softc *sc = dev->priv;
01794           struct ath_stats *sc_stats = &sc->sc_stats;     
01795           ATH_LOCK(sc);
01796           metric = sc_stats->ast_tx_linear;
01797           ATH_UNLOCK(sc);
01798 #endif
01799           dev_put(dev);
01800           return metric;
01801         }
01802       (*code_err) = DEV_NOT_FOUND;
01803       printk ("Device interface not found\n");
01804       return 0;
01805     }
01806   (*code_err) = DEV_NAME_NOT_DEFINED; 
01807   printk("Device interface name not specified !!!\n");
01808   return 0;
01809 }
01810 XIAN_EXPORT_SYMBOL(get_ast_tx_linear);
01811 
01812 
01813 /*************************************************************************************************************/
01820 u_int32_t
01821 get_ast_tx_nodata(char * dev_name,
01822                   unsigned int * code_err)
01823 {
01824   u_int32_t metric = 0;
01825   struct net_device * dev;
01826 
01827   if ((dev_name) && (strlen(dev_name)))
01828     {
01829       dev = dev_get_by_name(dev_name);  
01830       if (dev)
01831         {
01832 #ifdef MADWIFI_NG
01833           metric = 0;
01834           printk("undefined metric ast_tx_nodata\n");
01835 #else
01836           struct ath_softc *sc = dev->priv;
01837           struct ath_stats *sc_stats = &sc->sc_stats;     
01838           ATH_LOCK(sc);
01839           metric = sc_stats->ast_tx_nodata;
01840           ATH_UNLOCK(sc);
01841 #endif
01842           dev_put(dev);
01843           return metric;
01844         }
01845       (*code_err) = DEV_NOT_FOUND;
01846       printk ("Device interface not found\n");
01847       return 0;
01848     }
01849   (*code_err) = DEV_NAME_NOT_DEFINED; 
01850   printk("Device interface name not specified !!!\n");
01851   return 0;
01852 }
01853 XIAN_EXPORT_SYMBOL(get_ast_tx_nodata);
01854 
01855 
01856 /*************************************************************************************************************/
01863 u_int32_t
01864 get_ast_tx_busdma(char * dev_name,
01865                   unsigned int * code_err)
01866 {
01867   u_int32_t metric = 0;
01868   struct net_device * dev;
01869 
01870   if ((dev_name) && (strlen(dev_name)))
01871     {
01872       dev = dev_get_by_name(dev_name);  
01873       if (dev)
01874         {
01875 #ifdef MADWIFI_NG
01876           metric = 0;
01877           printk("undefined metric ast_tx_busdma\n");
01878 #else
01879           struct ath_softc *sc = dev->priv;
01880           struct ath_stats *sc_stats = &sc->sc_stats;
01881           ATH_LOCK(sc);
01882           metric = sc_stats->ast_tx_busdma;
01883           ATH_UNLOCK(sc);
01884 #endif
01885           dev_put(dev);
01886           return metric;
01887         }
01888       (*code_err) = DEV_NOT_FOUND;
01889       printk ("Device interface not found\n");
01890       return 0;
01891     }
01892   (*code_err) = DEV_NAME_NOT_DEFINED; 
01893   printk("Device interface name not specified !!!\n");
01894   return 0;
01895 }
01896 XIAN_EXPORT_SYMBOL(get_ast_tx_busdma);
01897 
01898 
01899 /*************************************************************************************************************/
01906 u_int32_t
01907 get_ast_tx_xretries(char * dev_name,
01908                     unsigned int * code_err)
01909 {
01910   u_int32_t metric = 0;
01911   struct net_device * dev;
01912 
01913   if ((dev_name) && (strlen(dev_name)))
01914     {
01915       dev = dev_get_by_name(dev_name);  
01916       if (dev)
01917         {
01918           struct ath_softc *sc = dev->priv;
01919           struct ath_stats *sc_stats = &sc->sc_stats;     
01920           ATH_LOCK(sc);
01921           metric = sc_stats->ast_tx_xretries;
01922           ATH_UNLOCK(sc);
01923           dev_put(dev);
01924           return metric;
01925         }
01926       (*code_err) = DEV_NOT_FOUND;
01927       printk ("Device interface not found\n");
01928       return 0;
01929     }
01930   (*code_err) = DEV_NAME_NOT_DEFINED; 
01931   printk("Device interface name not specified !!!\n");
01932   return 0;
01933 }
01934 XIAN_EXPORT_SYMBOL(get_ast_tx_xretries);
01935 
01936 
01937 /*************************************************************************************************************/
01944 u_int32_t
01945 get_ast_tx_fifoerr(char * dev_name,
01946                    unsigned int * code_err)
01947 {
01948   u_int32_t metric = 0;
01949   struct net_device * dev;
01950 
01951   if ((dev_name) && (strlen(dev_name)))
01952     {
01953       dev = dev_get_by_name(dev_name);  
01954       if (dev)
01955         {
01956           struct ath_softc *sc = dev->priv;
01957           struct ath_stats *sc_stats = &sc->sc_stats;     
01958           ATH_LOCK(sc);
01959           metric = sc_stats->ast_tx_fifoerr;
01960           ATH_UNLOCK(sc);
01961           dev_put(dev);
01962           return metric;
01963         }
01964       (*code_err) = DEV_NOT_FOUND;
01965       printk ("Device interface not found\n");
01966       return 0;
01967     }
01968   (*code_err) = DEV_NAME_NOT_DEFINED; 
01969   printk("Device interface name not specified !!!\n");
01970   return 0;
01971 }
01972 XIAN_EXPORT_SYMBOL(get_ast_tx_fifoerr);
01973 
01974 
01975 /*************************************************************************************************************/
01982 u_int32_t
01983 get_ast_tx_filtered(char * dev_name,
01984                     unsigned int * code_err)
01985 {
01986   u_int32_t metric = 0;
01987   struct net_device * dev;
01988 
01989   if ((dev_name) && (strlen(dev_name)))
01990     {
01991       dev = dev_get_by_name(dev_name);  
01992       if (dev)
01993         {
01994           struct ath_softc *sc = dev->priv;
01995           struct ath_stats *sc_stats = &sc->sc_stats;     
01996           ATH_LOCK(sc);
01997           metric = sc_stats->ast_tx_filtered;
01998           ATH_UNLOCK(sc);
01999           dev_put(dev);
02000           return metric;
02001         }
02002       (*code_err) = DEV_NOT_FOUND;
02003       printk ("Device interface not found\n");
02004       return 0;
02005     }
02006   (*code_err) = DEV_NAME_NOT_DEFINED; 
02007   printk("Device interface name not specified !!!\n");
02008   return 0;
02009 }
02010 XIAN_EXPORT_SYMBOL(get_ast_tx_filtered);
02011 
02012 
02013 /*************************************************************************************************************/
02020 u_int32_t
02021 get_ast_tx_shortretry(char * dev_name,
02022                       unsigned int * code_err)
02023 {
02024   u_int32_t metric = 0;
02025   struct net_device * dev;
02026 
02027   if ((dev_name) && (strlen(dev_name)))
02028     {
02029       dev = dev_get_by_name(dev_name);  
02030       if (dev)
02031         {
02032           struct ath_softc *sc = dev->priv;
02033           struct ath_stats *sc_stats = &sc->sc_stats;     
02034           ATH_LOCK(sc);
02035           metric = sc_stats->ast_tx_shortretry;
02036           ATH_UNLOCK(sc);
02037           dev_put(dev);
02038           return metric;
02039         }
02040       (*code_err) = DEV_NOT_FOUND;
02041       printk ("Device interface not found\n");
02042       return 0;
02043     }
02044   (*code_err) = DEV_NAME_NOT_DEFINED; 
02045   printk("Device interface name not specified !!!\n");
02046   return 0;
02047 }
02048 XIAN_EXPORT_SYMBOL(get_ast_tx_shortretry);
02049 
02050 
02051 /*************************************************************************************************************/
02058 u_int32_t
02059 get_ast_tx_longretry(char * dev_name,
02060                      unsigned int * code_err)
02061 {
02062   u_int32_t metric = 0;
02063   struct net_device * dev;
02064 
02065   if ((dev_name) && (strlen(dev_name)))
02066     {
02067       dev = dev_get_by_name(dev_name);  
02068       if (dev)
02069         {
02070           struct ath_softc *sc = dev->priv;
02071           struct ath_stats *sc_stats = &sc->sc_stats;     
02072           ATH_LOCK(sc);
02073           metric = sc_stats->ast_tx_longretry;
02074           ATH_UNLOCK(sc);
02075           dev_put(dev);
02076           return metric;
02077         }
02078       (*code_err) = DEV_NOT_FOUND;
02079       printk ("Device interface not found\n");
02080       return 0;
02081     }
02082   (*code_err) = DEV_NAME_NOT_DEFINED; 
02083   printk("Device interface name not specified !!!\n");
02084   return 0;
02085 }
02086 XIAN_EXPORT_SYMBOL(get_ast_tx_longretry);
02087 
02088 
02089 /*************************************************************************************************************/
02096 u_int32_t
02097 get_ast_tx_badrate(char * dev_name,
02098                    unsigned int * code_err)
02099 {
02100   u_int32_t metric = 0;
02101   struct net_device * dev;
02102 
02103   if ((dev_name) && (strlen(dev_name)))
02104     {
02105       dev = dev_get_by_name(dev_name);  
02106       if (dev)
02107         {
02108           struct ath_softc *sc = dev->priv;
02109           struct ath_stats *sc_stats = &sc->sc_stats;     
02110           ATH_LOCK(sc);
02111           metric = sc_stats->ast_tx_badrate;
02112           ATH_UNLOCK(sc);
02113           dev_put(dev);
02114           return metric;
02115         }
02116       (*code_err) = DEV_NOT_FOUND;
02117       printk ("Device interface not found\n");
02118       return 0;
02119     }
02120   (*code_err) = DEV_NAME_NOT_DEFINED; 
02121   printk("Device interface name not specified !!!\n");
02122   return 0;
02123 }
02124 XIAN_EXPORT_SYMBOL(get_ast_tx_badrate);
02125 
02126 
02127 /*************************************************************************************************************/
02134 u_int32_t
02135 get_ast_tx_noack(char * dev_name,
02136                  unsigned int * code_err)
02137 {
02138   u_int32_t metric = 0;
02139   struct net_device * dev;
02140 
02141   if ((dev_name) && (strlen(dev_name)))
02142     {
02143       dev = dev_get_by_name(dev_name);  
02144       if (dev)
02145         {
02146           struct ath_softc *sc = dev->priv;
02147           struct ath_stats *sc_stats = &sc->sc_stats;     
02148           ATH_LOCK(sc);
02149           metric = sc_stats->ast_tx_noack;
02150           ATH_UNLOCK(sc);
02151           dev_put(dev);
02152           return metric;
02153         }
02154       (*code_err) = DEV_NOT_FOUND;
02155       printk ("Device interface not found\n");
02156       return 0;
02157     }
02158   (*code_err) = DEV_NAME_NOT_DEFINED; 
02159   printk("Device interface name not specified !!!\n");
02160   return 0;
02161 }
02162 XIAN_EXPORT_SYMBOL(get_ast_tx_noack);
02163 
02164 
02165 /*************************************************************************************************************/
02172 u_int32_t
02173 get_ast_tx_rts(char * dev_name,
02174                unsigned int * code_err)
02175 {
02176   u_int32_t metric = 0;
02177   struct net_device * dev;
02178 
02179   if ((dev_name) && (strlen(dev_name)))
02180     {
02181       dev = dev_get_by_name(dev_name);  
02182       if (dev)
02183         {
02184           struct ath_softc *sc = dev->priv;
02185           struct ath_stats *sc_stats = &sc->sc_stats;     
02186           ATH_LOCK(sc);
02187           metric = sc_stats->ast_tx_rts;
02188           ATH_UNLOCK(sc);
02189           dev_put(dev);
02190           return metric;
02191         }
02192       (*code_err) = DEV_NOT_FOUND;
02193       printk ("Device interface not found\n");
02194       return 0;
02195     }
02196   (*code_err) = DEV_NAME_NOT_DEFINED; 
02197   printk("Device interface name not specified !!!\n");
02198   return 0;
02199 }
02200 XIAN_EXPORT_SYMBOL(get_ast_tx_rts);
02201 
02202 
02203 /*************************************************************************************************************/
02210 u_int32_t
02211 get_ast_tx_cts(char * dev_name,
02212                unsigned int * code_err)
02213 {
02214   u_int32_t metric = 0;
02215   struct net_device * dev;
02216 
02217   if ((dev_name) && (strlen(dev_name)))
02218     {
02219       dev = dev_get_by_name(dev_name);  
02220       if (dev)
02221         {
02222           struct ath_softc *sc = dev->priv;
02223           struct ath_stats *sc_stats = &sc->sc_stats;     
02224           ATH_LOCK(sc);
02225           metric = sc_stats->ast_tx_cts;
02226           ATH_UNLOCK(sc);
02227           dev_put(dev);
02228           return metric;
02229         }
02230       (*code_err) = DEV_NOT_FOUND;
02231       printk ("Device interface not found\n");
02232       return 0;
02233     }
02234   (*code_err) = DEV_NAME_NOT_DEFINED; 
02235   printk("Device interface name not specified !!!\n");
02236   return 0;
02237 }
02238 XIAN_EXPORT_SYMBOL(get_ast_tx_cts);
02239 
02240 
02241 /*************************************************************************************************************/
02248 u_int32_t
02249 get_ast_tx_shortpre(char * dev_name,
02250                     unsigned int * code_err)
02251 {
02252   u_int32_t metric = 0;
02253   struct net_device * dev;
02254 
02255   if ((dev_name) && (strlen(dev_name)))
02256     {
02257       dev = dev_get_by_name(dev_name);  
02258       if (dev)
02259         {
02260           struct ath_softc *sc = dev->priv;
02261           struct ath_stats *sc_stats = &sc->sc_stats;     
02262           ATH_LOCK(sc);
02263           metric = sc_stats->ast_tx_shortpre;
02264           ATH_UNLOCK(sc);
02265           dev_put(dev);
02266           return metric;
02267         }
02268       (*code_err) = DEV_NOT_FOUND;
02269       printk ("Device interface not found\n");
02270       return 0;
02271     }
02272   (*code_err) = DEV_NAME_NOT_DEFINED; 
02273   printk("Device interface name not specified !!!\n");
02274   return 0;
02275 }
02276 XIAN_EXPORT_SYMBOL(get_ast_tx_shortpre);
02277 
02278 
02279 /*************************************************************************************************************/
02286 u_int32_t
02287 get_ast_tx_altrate(char * dev_name,
02288                    unsigned int * code_err)
02289 {
02290   u_int32_t metric = 0;
02291   struct net_device * dev;
02292 
02293   if ((dev_name) && (strlen(dev_name)))
02294     {
02295       dev = dev_get_by_name(dev_name);  
02296       if (dev)
02297         {
02298           struct ath_softc *sc = dev->priv;
02299           struct ath_stats *sc_stats = &sc->sc_stats;     
02300           ATH_LOCK(sc);
02301           metric = sc_stats->ast_tx_altrate;
02302           ATH_UNLOCK(sc);
02303           dev_put(dev);
02304           return metric;
02305         }
02306       (*code_err) = DEV_NOT_FOUND;
02307       printk ("Device interface not found\n");
02308       return 0;
02309     }
02310   (*code_err) = DEV_NAME_NOT_DEFINED; 
02311   printk("Device interface name not specified !!!\n");
02312   return 0;
02313 }
02314 XIAN_EXPORT_SYMBOL(get_ast_tx_altrate);
02315 
02316 
02317 /*************************************************************************************************************/
02324 u_int32_t
02325 get_ast_tx_protect(char * dev_name,
02326                    unsigned int * code_err)
02327 {
02328   u_int32_t metric = 0;
02329   struct net_device * dev;
02330 
02331   if ((dev_name) && (strlen(dev_name)))
02332     {
02333       dev = dev_get_by_name(dev_name);  
02334       if (dev)
02335         {
02336           struct ath_softc *sc = dev->priv;
02337           struct ath_stats *sc_stats = &sc->sc_stats;     
02338           ATH_LOCK(sc);
02339           metric = sc_stats->ast_tx_protect;
02340           ATH_UNLOCK(sc);
02341           dev_put(dev);
02342           return metric;
02343         }
02344       (*code_err) = DEV_NOT_FOUND;
02345       printk ("Device interface not found\n");
02346       return 0;
02347     }
02348   (*code_err) = DEV_NAME_NOT_DEFINED; 
02349   printk("Device interface name not specified !!!\n");
02350   return 0;
02351 }
02352 XIAN_EXPORT_SYMBOL(get_ast_tx_protect);
02353 
02354 
02355 /*************************************************************************************************************/
02362 u_int32_t
02363 get_ast_tx_ctsburst(char * dev_name,
02364                     unsigned int * code_err)
02365 {
02366   u_int32_t metric = 0;
02367   struct net_device * dev;
02368 
02369   if ((dev_name) && (strlen(dev_name)))
02370     {
02371       dev = dev_get_by_name(dev_name);  
02372       if (dev)
02373         {
02374 #ifdef MADWIFI_NG
02375           metric = 0;
02376           printk("undefined metric ast_tx_ctsburst\n");
02377 #else
02378           struct ath_softc *sc = dev->priv;
02379           struct ath_stats *sc_stats = &sc->sc_stats;     
02380           ATH_LOCK(sc);
02381           metric = sc_stats->ast_tx_ctsburst;
02382           ATH_UNLOCK(sc);
02383 #endif
02384           dev_put(dev);
02385           return metric;
02386         }
02387       (*code_err) = DEV_NOT_FOUND;
02388       printk ("Device interface not found\n");
02389       return 0;
02390     }
02391   (*code_err) = DEV_NAME_NOT_DEFINED; 
02392   printk("Device interface name not specified !!!\n");
02393   return 0;
02394 }
02395 XIAN_EXPORT_SYMBOL(get_ast_tx_ctsburst);
02396 
02397 
02398 /*************************************************************************************************************/
02405 u_int32_t
02406 get_ast_tx_ctsext(char * dev_name,
02407                   unsigned int * code_err)
02408 {
02409   u_int32_t metric = 0;
02410   struct net_device * dev;
02411 
02412   if ((dev_name) && (strlen(dev_name)))
02413     {
02414       dev = dev_get_by_name(dev_name);  
02415       if (dev)
02416         {
02417 #ifdef MADWIFI_NG
02418           metric = 0;
02419           printk("undefined metric ast_tx_ctsext\n");
02420 #else
02421           struct ath_softc *sc = dev->priv;
02422           struct ath_stats *sc_stats = &sc->sc_stats;     
02423           ATH_LOCK(sc);
02424           metric = sc_stats->ast_tx_ctsext;
02425           ATH_UNLOCK(sc);
02426 #endif
02427           dev_put(dev);
02428           return metric;
02429         }
02430       (*code_err) = DEV_NOT_FOUND;
02431       printk ("Device interface not found\n");
02432       return 0;
02433     }
02434   (*code_err) = DEV_NAME_NOT_DEFINED; 
02435   printk("Device interface name not specified !!!\n");
02436   return 0;
02437 }
02438 XIAN_EXPORT_SYMBOL(get_ast_tx_ctsext);
02439 
02440 
02441 /*************************************************************************************************************/
02448 u_int32_t
02449 get_ast_rx_nobuf(char * dev_name,
02450                  unsigned int * code_err)
02451 {
02452   u_int32_t metric = 0;
02453   struct net_device * dev;
02454 
02455   if ((dev_name) && (strlen(dev_name)))
02456     {
02457       dev = dev_get_by_name(dev_name);  
02458       if (dev)
02459         {
02460           struct ath_softc *sc = dev->priv;
02461           struct ath_stats *sc_stats = &sc->sc_stats;     
02462           ATH_LOCK(sc);
02463           metric = sc_stats->ast_rx_nobuf;
02464           ATH_UNLOCK(sc);
02465           dev_put(dev);
02466           return metric;
02467         }
02468       (*code_err) = DEV_NOT_FOUND;
02469       printk ("Device interface not found\n");
02470       return 0;
02471     }
02472   (*code_err) = DEV_NAME_NOT_DEFINED; 
02473   printk("Device interface name not specified !!!\n");
02474   return 0;
02475 }
02476 XIAN_EXPORT_SYMBOL(get_ast_rx_nobuf);
02477 
02478 
02479 /*************************************************************************************************************/
02486 u_int32_t
02487 get_ast_rx_busdma(char * dev_name,
02488                    unsigned int * code_err)
02489 {
02490   u_int32_t metric = 0;
02491   struct net_device * dev;
02492 
02493   if ((dev_name) && (strlen(dev_name)))
02494     {
02495       dev = dev_get_by_name(dev_name);  
02496       if (dev)
02497         {
02498 #ifdef MADWIFI_NG
02499           metric = 0;
02500           printk("undefined metric ast_rx_busdma\n");
02501 #else
02502           struct ath_softc *sc = dev->priv;
02503           struct ath_stats *sc_stats = &sc->sc_stats;     
02504           ATH_LOCK(sc);
02505           metric = sc_stats->ast_rx_busdma;
02506           ATH_UNLOCK(sc);
02507 #endif
02508           dev_put(dev);
02509           return metric;
02510         }
02511       (*code_err) = DEV_NOT_FOUND;
02512       printk ("Device interface not found\n");
02513       return 0;
02514     }
02515   (*code_err) = DEV_NAME_NOT_DEFINED; 
02516   printk("Device interface name not specified !!!\n");
02517   return 0;
02518 }
02519 XIAN_EXPORT_SYMBOL(get_ast_rx_busdma);
02520 
02521 
02522 /*************************************************************************************************************/
02529 u_int32_t
02530 get_ast_rx_orn(char * dev_name,
02531                unsigned int * code_err)
02532 {
02533   u_int32_t metric = 0;
02534   struct net_device * dev;
02535 
02536   if ((dev_name) && (strlen(dev_name)))
02537     {
02538       dev = dev_get_by_name(dev_name);  
02539       if (dev)
02540         {
02541           struct ath_softc *sc = dev->priv;
02542           struct ath_stats *sc_stats = &sc->sc_stats;     
02543           ATH_LOCK(sc);
02544           metric = sc_stats->ast_rx_orn;
02545           ATH_UNLOCK(sc);
02546           dev_put(dev);
02547           return metric;
02548         }
02549       (*code_err) = DEV_NOT_FOUND;
02550       printk ("Device interface not found\n");
02551       return 0;
02552     }
02553   (*code_err) = DEV_NAME_NOT_DEFINED; 
02554   printk("Device interface name not specified !!!\n");
02555   return 0;
02556 }
02557 XIAN_EXPORT_SYMBOL(get_ast_rx_orn);
02558 
02559 
02560 /*************************************************************************************************************/
02567 u_int32_t
02568 get_ast_rx_crcerr(char * dev_name,
02569                   unsigned int * code_err)
02570 {
02571   u_int32_t metric = 0;
02572   struct net_device * dev;
02573 
02574   if ((dev_name) && (strlen(dev_name)))
02575     {
02576       dev = dev_get_by_name(dev_name);  
02577       if (dev)
02578         {
02579           struct ath_softc *sc = dev->priv;
02580           struct ath_stats *sc_stats = &sc->sc_stats;     
02581           ATH_LOCK(sc);
02582           metric = sc_stats->ast_rx_crcerr;
02583           ATH_UNLOCK(sc);
02584           dev_put(dev);
02585           return metric;
02586         }
02587       (*code_err) = DEV_NOT_FOUND;
02588       printk ("Device interface not found\n");
02589       return 0;
02590     }
02591   (*code_err) = DEV_NAME_NOT_DEFINED; 
02592   printk("Device interface name not specified !!!\n");
02593   return 0;
02594 }
02595 XIAN_EXPORT_SYMBOL(get_ast_rx_crcerr);
02596 
02597 
02598 /*************************************************************************************************************/
02605 u_int32_t
02606 get_ast_rx_fifoerr(char * dev_name,
02607                    unsigned int * code_err)
02608 {
02609   u_int32_t metric = 0;
02610   struct net_device * dev;
02611 
02612   if ((dev_name) && (strlen(dev_name)))
02613     {
02614       dev = dev_get_by_name(dev_name);  
02615       if (dev)
02616         {
02617           struct ath_softc *sc = dev->priv;
02618           struct ath_stats *sc_stats = &sc->sc_stats;     
02619           ATH_LOCK(sc);
02620           metric = sc_stats->ast_rx_fifoerr;
02621           ATH_UNLOCK(sc);
02622           dev_put(dev);
02623           return metric;
02624         }
02625       (*code_err) = DEV_NOT_FOUND;
02626       printk ("Device interface not found\n");
02627       return 0;
02628     }
02629   (*code_err) = DEV_NAME_NOT_DEFINED; 
02630   printk("Device interface name not specified !!!\n");
02631   return 0;
02632 }
02633 XIAN_EXPORT_SYMBOL(get_ast_rx_fifoerr);
02634 
02635 
02636 /*************************************************************************************************************/
02643 u_int32_t
02644 get_ast_rx_badcrypt(char * dev_name,
02645                     unsigned int * code_err)
02646 {
02647   u_int32_t metric = 0;
02648   struct net_device * dev;
02649 
02650   if ((dev_name) && (strlen(dev_name)))
02651     {
02652       dev = dev_get_by_name(dev_name);  
02653       if (dev)
02654         {
02655           struct ath_softc *sc = dev->priv;
02656           struct ath_stats *sc_stats = &sc->sc_stats;     
02657           ATH_LOCK(sc);
02658           metric = sc_stats->ast_rx_badcrypt;
02659           ATH_UNLOCK(sc);
02660           dev_put(dev);
02661           return metric;
02662         }
02663       (*code_err) = DEV_NOT_FOUND;
02664       printk ("Device interface not found\n");
02665       return 0;
02666     }
02667   (*code_err) = DEV_NAME_NOT_DEFINED; 
02668   printk("Device interface name not specified !!!\n");
02669   return 0;
02670 }
02671 XIAN_EXPORT_SYMBOL(get_ast_rx_badcrypt);
02672 
02673 
02674 /*************************************************************************************************************/
02681 u_int32_t
02682 get_ast_rx_badmic(char * dev_name,
02683                     unsigned int * code_err)
02684 {
02685   u_int32_t metric = 0;
02686   struct net_device * dev;
02687 
02688   if ((dev_name) && (strlen(dev_name)))
02689     {
02690       dev = dev_get_by_name(dev_name);  
02691       if (dev)
02692         {
02693           struct ath_softc *sc = dev->priv;
02694           struct ath_stats *sc_stats = &sc->sc_stats;     
02695           ATH_LOCK(sc);
02696           metric = sc_stats->ast_rx_badmic;
02697           ATH_UNLOCK(sc);
02698           dev_put(dev);
02699           return metric;
02700         }
02701       (*code_err) = DEV_NOT_FOUND;
02702       printk ("Device interface not found\n");
02703       return 0;
02704     }
02705   (*code_err) = DEV_NAME_NOT_DEFINED; 
02706   printk("Device interface name not specified !!!\n");
02707   return 0;
02708 }
02709 XIAN_EXPORT_SYMBOL(get_ast_rx_badmic);
02710 
02711 
02712 /*************************************************************************************************************/
02719 u_int32_t
02720 get_ast_rx_phyerr(char * dev_name,
02721                   unsigned int * code_err)
02722 {
02723   u_int32_t metric = 0;
02724   struct net_device * dev;
02725 
02726   if ((dev_name) && (strlen(dev_name)))
02727     {
02728       dev = dev_get_by_name(dev_name);  
02729       if (dev)
02730         {
02731           struct ath_softc *sc = dev->priv;
02732           struct ath_stats *sc_stats = &sc->sc_stats;     
02733           ATH_LOCK(sc);
02734           metric = sc_stats->ast_rx_phyerr;
02735           ATH_UNLOCK(sc);
02736           dev_put(dev);
02737           return metric;
02738         }
02739       (*code_err) = DEV_NOT_FOUND;
02740       printk ("Device interface not found\n");
02741       return 0;
02742     }
02743   (*code_err) = DEV_NAME_NOT_DEFINED; 
02744   printk("Device interface name not specified !!!\n");
02745   return 0;
02746 }
02747 XIAN_EXPORT_SYMBOL(get_ast_rx_phyerr);
02748 
02749 
02750 /*************************************************************************************************************/
02757 u_int32_t
02758 get_ast_rx_tooshort(char * dev_name,
02759                     unsigned int * code_err)
02760 {
02761   u_int32_t metric = 0;
02762   struct net_device * dev;
02763 
02764   if ((dev_name) && (strlen(dev_name)))
02765     {
02766       dev = dev_get_by_name(dev_name);  
02767       if (dev)
02768         {
02769           struct ath_softc *sc = dev->priv;
02770           struct ath_stats *sc_stats = &sc->sc_stats;     
02771           ATH_LOCK(sc);
02772           metric = sc_stats->ast_rx_tooshort;
02773           ATH_UNLOCK(sc);
02774           dev_put(dev);
02775           return metric;
02776         }
02777       (*code_err) = DEV_NOT_FOUND;
02778       printk ("Device interface not found\n");
02779       return 0;
02780     }
02781   (*code_err) = DEV_NAME_NOT_DEFINED; 
02782   printk("Device interface name not specified !!!\n");
02783   return 0;
02784 }
02785 XIAN_EXPORT_SYMBOL(get_ast_rx_tooshort);
02786 
02787 
02788 /*************************************************************************************************************/
02795 u_int32_t
02796 get_ast_rx_toobig(char * dev_name,
02797                   unsigned int * code_err)
02798 {
02799   u_int32_t metric = 0;
02800   struct net_device * dev;
02801 
02802   if ((dev_name) && (strlen(dev_name)))
02803     {
02804       dev = dev_get_by_name(dev_name);  
02805       if (dev)
02806         {
02807           struct ath_softc *sc = dev->priv;
02808           struct ath_stats *sc_stats = &sc->sc_stats;     
02809           ATH_LOCK(sc);
02810           metric = sc_stats->ast_rx_toobig;
02811           ATH_UNLOCK(sc);
02812           dev_put(dev);
02813           return metric;
02814         }
02815       (*code_err) = DEV_NOT_FOUND;
02816       printk ("Device interface not found\n");
02817       return 0;
02818     }
02819   (*code_err) = DEV_NAME_NOT_DEFINED; 
02820   printk("Device interface name not specified !!!\n");
02821   return 0;
02822 }
02823 XIAN_EXPORT_SYMBOL(get_ast_rx_toobig);
02824 
02825 
02826 /*************************************************************************************************************/
02833 u_int32_t
02834 get_ast_rx_packets(char * dev_name,
02835                    unsigned int * code_err)
02836 {
02837   u_int32_t metric = 0;
02838   struct net_device * dev;
02839 
02840   if ((dev_name) && (strlen(dev_name)))
02841     {
02842       dev = dev_get_by_name(dev_name);  
02843       if (dev)
02844         {
02845           struct ath_softc *sc = dev->priv;
02846           struct ath_stats *sc_stats = &sc->sc_stats;     
02847           ATH_LOCK(sc);
02848           metric = sc_stats->ast_rx_packets;
02849           ATH_UNLOCK(sc);
02850           dev_put(dev);
02851           return metric;
02852         }
02853       (*code_err) = DEV_NOT_FOUND;
02854       printk ("Device interface not found\n");
02855       return 0;
02856     }
02857   (*code_err) = DEV_NAME_NOT_DEFINED; 
02858   printk("Device interface name not specified !!!\n");
02859   return 0;
02860 }
02861 XIAN_EXPORT_SYMBOL(get_ast_rx_packets);
02862 
02863 
02864 /*************************************************************************************************************/
02871 u_int32_t
02872 get_ast_rx_mgt(char * dev_name,
02873                unsigned int * code_err)
02874 {
02875   u_int32_t metric = 0;
02876   struct net_device * dev;
02877 
02878   if ((dev_name) && (strlen(dev_name)))
02879     {
02880       dev = dev_get_by_name(dev_name);  
02881       if (dev)
02882         {
02883           struct ath_softc *sc = dev->priv;
02884           struct ath_stats *sc_stats = &sc->sc_stats;     
02885           ATH_LOCK(sc);
02886           metric = sc_stats->ast_rx_mgt;
02887           ATH_UNLOCK(sc);
02888           dev_put(dev);
02889           return metric;
02890         }
02891       (*code_err) = DEV_NOT_FOUND;
02892       printk ("Device interface not found\n");
02893       return 0;
02894     }
02895   (*code_err) = DEV_NAME_NOT_DEFINED; 
02896   printk("Device interface name not specified !!!\n");
02897   return 0;
02898 }
02899 XIAN_EXPORT_SYMBOL(get_ast_rx_mgt);
02900 
02901 
02902 /*************************************************************************************************************/
02909 u_int32_t
02910 get_ast_rx_ctl(char * dev_name,
02911                unsigned int * code_err)
02912 {
02913   u_int32_t metric = 0;
02914   struct net_device * dev;
02915 
02916   if ((dev_name) && (strlen(dev_name)))
02917     {
02918       dev = dev_get_by_name(dev_name);  
02919       if (dev)
02920         {
02921           struct ath_softc *sc = dev->priv;
02922           struct ath_stats *sc_stats = &sc->sc_stats;     
02923           ATH_LOCK(sc);
02924           metric = sc_stats->ast_rx_ctl;
02925           ATH_UNLOCK(sc);
02926           dev_put(dev);
02927           return metric;
02928         }
02929       (*code_err) = DEV_NOT_FOUND;
02930       printk ("Device interface not found\n");
02931       return 0;
02932     }
02933   (*code_err) = DEV_NAME_NOT_DEFINED; 
02934   printk("Device interface name not specified !!!\n");
02935   return 0;
02936 }
02937 XIAN_EXPORT_SYMBOL(get_ast_rx_ctl);
02938 
02939 
02940 /*************************************************************************************************************/
02947 int8_t
02948 get_ast_tx_rssi(char * dev_name,
02949                 unsigned int * code_err)
02950 {
02951   int8_t  metric = 0;
02952   struct net_device * dev;
02953 
02954   if ((dev_name) && (strlen(dev_name)))
02955     {
02956       dev = dev_get_by_name(dev_name);  
02957       if (dev)
02958         {
02959           struct ath_softc *sc = dev->priv;
02960           struct ath_stats *sc_stats = &sc->sc_stats;     
02961           ATH_LOCK(sc);
02962           metric = sc_stats->ast_tx_rssi;
02963           ATH_UNLOCK(sc);
02964           dev_put(dev);
02965           return metric;
02966         }
02967       (*code_err) = DEV_NOT_FOUND;
02968       printk ("Device interface not found\n");
02969       return 0;
02970     }
02971   (*code_err) = DEV_NAME_NOT_DEFINED; 
02972   printk("Device interface name not specified !!!\n");
02973   return 0;
02974 }
02975 XIAN_EXPORT_SYMBOL(get_ast_tx_rssi);
02976 
02977 
02978 /*************************************************************************************************************/
02985 int8_t
02986 get_ast_rx_rssi(char * dev_name,
02987                 unsigned int * code_err)
02988 {
02989   int8_t metric = 0;
02990   struct net_device * dev;
02991 
02992   if ((dev_name) && (strlen(dev_name)))
02993     {
02994       dev = dev_get_by_name(dev_name);  
02995       if (dev)
02996         {
02997           struct ath_softc *sc = dev->priv;
02998           struct ath_stats *sc_stats = &sc->sc_stats;     
02999           ATH_LOCK(sc);
03000           metric = sc_stats->ast_rx_rssi;
03001           ATH_UNLOCK(sc);
03002           dev_put(dev);
03003           return metric;
03004         }
03005       (*code_err) = DEV_NOT_FOUND;
03006       printk ("Device interface not found\n");
03007       return 0;
03008     }
03009   (*code_err) = DEV_NAME_NOT_DEFINED; 
03010   printk("Device interface name not specified !!!\n");
03011   return 0;
03012 }
03013 XIAN_EXPORT_SYMBOL(get_ast_rx_rssi);
03014 
03015 
03016 /*************************************************************************************************************/
03023 u_int32_t
03024 get_ast_be_xmit(char * dev_name,
03025                 unsigned int * code_err)
03026 {
03027   u_int32_t metric = 0;
03028   struct net_device * dev;
03029 
03030   if ((dev_name) && (strlen(dev_name)))
03031     {
03032       dev = dev_get_by_name(dev_name);  
03033       if (dev)
03034         {
03035           struct ath_softc *sc = dev->priv;
03036           struct ath_stats *sc_stats = &sc->sc_stats;     
03037           ATH_LOCK(sc);
03038           metric = sc_stats->ast_be_xmit;
03039           ATH_UNLOCK(sc);
03040           dev_put(dev);
03041           return metric;
03042         }
03043       (*code_err) = DEV_NOT_FOUND;
03044       printk ("Device interface not found\n");
03045       return 0;
03046     }
03047   (*code_err) = DEV_NAME_NOT_DEFINED; 
03048   printk("Device interface name not specified !!!\n");
03049   return 0;
03050 }
03051 XIAN_EXPORT_SYMBOL(get_ast_be_xmit);
03052 
03053 
03054 /*************************************************************************************************************/
03061 u_int32_t
03062 get_ast_be_nobuf(char * dev_name,
03063                  unsigned int * code_err)
03064 {
03065   u_int32_t metric = 0;
03066   struct net_device * dev;
03067 
03068   if ((dev_name) && (strlen(dev_name)))
03069     {
03070       dev = dev_get_by_name(dev_name);  
03071       if (dev)
03072         {
03073           struct ath_softc *sc = dev->priv;
03074           struct ath_stats *sc_stats = &sc->sc_stats;     
03075           ATH_LOCK(sc);
03076           metric = sc_stats->ast_be_nobuf;
03077           ATH_UNLOCK(sc);
03078           dev_put(dev);
03079           return metric;
03080         }
03081       (*code_err) = DEV_NOT_FOUND;
03082       printk ("Device interface not found\n");
03083       return 0;
03084     }
03085   (*code_err) = DEV_NAME_NOT_DEFINED; 
03086   printk("Device interface name not specified !!!\n");
03087   return 0;
03088 }
03089 XIAN_EXPORT_SYMBOL(get_ast_be_nobuf);
03090 
03091 
03092 /*************************************************************************************************************/
03099 u_int32_t
03100 get_ast_per_cal(char * dev_name,
03101                 unsigned int * code_err)
03102 {
03103   u_int32_t metric = 0;
03104   struct net_device * dev;
03105 
03106   if ((dev_name) && (strlen(dev_name)))
03107     {
03108       dev = dev_get_by_name(dev_name);  
03109       if (dev)
03110         {
03111           struct ath_softc *sc = dev->priv;
03112           struct ath_stats *sc_stats = &sc->sc_stats;     
03113           ATH_LOCK(sc);
03114           metric = sc_stats->ast_per_cal;
03115           ATH_UNLOCK(sc);
03116           dev_put(dev);
03117           return metric;
03118         }
03119       (*code_err) = DEV_NOT_FOUND;
03120       printk ("Device interface not found\n");
03121       return 0;
03122     }
03123   (*code_err) = DEV_NAME_NOT_DEFINED; 
03124   printk("Device interface name not specified !!!\n");
03125   return 0;
03126 }
03127 XIAN_EXPORT_SYMBOL(get_ast_per_cal);
03128 
03129 
03130 /*************************************************************************************************************/
03137 u_int32_t
03138 get_ast_per_calfail(char * dev_name,
03139                     unsigned int * code_err)
03140 {
03141   u_int32_t metric = 0;
03142   struct net_device * dev;
03143 
03144   if ((dev_name) && (strlen(dev_name)))
03145     {
03146       dev = dev_get_by_name(dev_name);  
03147       if (dev)
03148         {
03149           struct ath_softc *sc = dev->priv;
03150           struct ath_stats *sc_stats = &sc->sc_stats;     
03151           ATH_LOCK(sc);
03152           metric = sc_stats->ast_per_calfail;
03153           ATH_UNLOCK(sc);
03154           dev_put(dev);
03155           return metric;
03156         }
03157       (*code_err) = DEV_NOT_FOUND;
03158       printk ("Device interface not found\n");
03159       return 0;
03160     }
03161   (*code_err) = DEV_NAME_NOT_DEFINED; 
03162   printk("Device interface name not specified !!!\n");
03163   return 0;
03164 }
03165 XIAN_EXPORT_SYMBOL(get_ast_per_calfail);
03166 
03167 
03168 /*************************************************************************************************************/
03175 u_int32_t
03176 get_ast_per_rfgain(char * dev_name,
03177                    unsigned int * code_err)
03178 {
03179   u_int32_t metric = 0;
03180   struct net_device * dev;
03181 
03182   if ((dev_name) && (strlen(dev_name)))
03183     {
03184       dev = dev_get_by_name(dev_name);  
03185       if (dev)
03186         {
03187           struct ath_softc *sc = dev->priv;
03188           struct ath_stats *sc_stats = &sc->sc_stats;     
03189           ATH_LOCK(sc);
03190           metric = sc_stats->ast_per_rfgain;
03191           ATH_UNLOCK(sc);
03192           dev_put(dev);
03193           return metric;
03194         }
03195       (*code_err) = DEV_NOT_FOUND;
03196       printk ("Device interface not found\n");
03197       return 0;
03198     }
03199   (*code_err) = DEV_NAME_NOT_DEFINED; 
03200   printk("Device interface name not specified !!!\n");
03201   return 0;
03202 }
03203 XIAN_EXPORT_SYMBOL(get_ast_per_rfgain);
03204 
03205 
03206 /*************************************************************************************************************/
03213 u_int32_t
03214 get_ast_rate_calls(char * dev_name,
03215                    unsigned int * code_err)
03216 {
03217   u_int32_t metric = 0;
03218   struct net_device * dev;
03219 
03220   if ((dev_name) && (strlen(dev_name)))
03221     {
03222       dev = dev_get_by_name(dev_name);  
03223       if (dev)
03224         {
03225           struct ath_softc *sc = dev->priv;
03226           struct ath_stats *sc_stats = &sc->sc_stats;     
03227           ATH_LOCK(sc);
03228           metric = sc_stats->ast_rate_calls;
03229           ATH_UNLOCK(sc);
03230           dev_put(dev);
03231           return metric;
03232         }
03233       (*code_err) = DEV_NOT_FOUND;
03234       printk ("Device interface not found\n");
03235       return 0;
03236     }
03237   (*code_err) = DEV_NAME_NOT_DEFINED; 
03238   printk("Device interface name not specified !!!\n");
03239   return 0;
03240 }
03241 XIAN_EXPORT_SYMBOL(get_ast_rate_calls);
03242 
03243 
03244 /*************************************************************************************************************/
03251 u_int32_t
03252 get_ast_rate_raise(char * dev_name,
03253                    unsigned int * code_err)
03254 {
03255   u_int32_t metric = 0;
03256   struct net_device * dev;
03257 
03258   if ((dev_name) && (strlen(dev_name)))
03259     {
03260       dev = dev_get_by_name(dev_name);  
03261       if (dev)
03262         {
03263           struct ath_softc *sc = dev->priv;
03264           struct ath_stats *sc_stats = &sc->sc_stats;     
03265           ATH_LOCK(sc);
03266           metric = sc_stats->ast_rate_raise;
03267           ATH_UNLOCK(sc);
03268           dev_put(dev);
03269           return metric;
03270         }
03271       (*code_err) = DEV_NOT_FOUND;
03272       printk ("Device interface not found\n");
03273       return 0;
03274     }
03275   (*code_err) = DEV_NAME_NOT_DEFINED; 
03276   printk("Device interface name not specified !!!\n");
03277   return 0;
03278 }
03279 XIAN_EXPORT_SYMBOL(get_ast_rate_raise);
03280 
03281 
03282 /*************************************************************************************************************/
03289 u_int32_t
03290 get_ast_rate_drop(char * dev_name,
03291                   unsigned int * code_err)
03292 {
03293   u_int32_t metric = 0;
03294   struct net_device * dev;
03295 
03296   if ((dev_name) && (strlen(dev_name)))
03297     {
03298       dev = dev_get_by_name(dev_name);  
03299       if (dev)
03300         {
03301           struct ath_softc *sc = dev->priv;
03302           struct ath_stats *sc_stats = &sc->sc_stats;     
03303           ATH_LOCK(sc);
03304           metric = sc_stats->ast_rate_drop;
03305           ATH_UNLOCK(sc);
03306           dev_put(dev);
03307           return metric;
03308         }
03309       (*code_err) = DEV_NOT_FOUND;
03310       printk ("Device interface not found\n");
03311       return 0;
03312     }
03313   (*code_err) = DEV_NAME_NOT_DEFINED; 
03314   printk("Device interface name not specified !!!\n");
03315   return 0;
03316 }
03317 XIAN_EXPORT_SYMBOL(get_ast_rate_drop);
03318 
03319 
03320 /*************************************************************************************************************/
03327 u_int32_t
03328 get_ast_ant_defswitch(char * dev_name,
03329                       unsigned int * code_err)
03330 {
03331   u_int32_t metric = 0;
03332   struct net_device * dev;
03333 
03334   if ((dev_name) && (strlen(dev_name)))
03335     {
03336       dev = dev_get_by_name(dev_name);  
03337       if (dev)
03338         {
03339           struct ath_softc *sc = dev->priv;
03340           struct ath_stats *sc_stats = &sc->sc_stats;     
03341           ATH_LOCK(sc);
03342           metric = sc_stats->ast_ant_defswitch;
03343           ATH_UNLOCK(sc);
03344           dev_put(dev);
03345           return metric;
03346         }
03347       (*code_err) = DEV_NOT_FOUND;
03348       printk ("Device interface not found\n");
03349       return 0;
03350     }
03351   (*code_err) = DEV_NAME_NOT_DEFINED; 
03352   printk("Device interface name not specified !!!\n");
03353   return 0;
03354 }
03355 XIAN_EXPORT_SYMBOL(get_ast_ant_defswitch);
03356 
03357 
03358 /*************************************************************************************************************/
03365 u_int32_t
03366 get_ast_ant_txswitch(char * dev_name,
03367                      unsigned int * code_err)
03368 {
03369   u_int32_t metric = 0;
03370   struct net_device * dev;
03371 
03372   if ((dev_name) && (strlen(dev_name)))
03373     {
03374       dev = dev_get_by_name(dev_name);  
03375       if (dev)
03376         {
03377           struct ath_softc *sc = dev->priv;
03378           struct ath_stats *sc_stats = &sc->sc_stats;     
03379           ATH_LOCK(sc);
03380           metric = sc_stats->ast_ant_txswitch;
03381           ATH_UNLOCK(sc);
03382           dev_put(dev);
03383           return metric;
03384         }
03385       (*code_err) = DEV_NOT_FOUND;
03386       printk ("Device interface not found\n");
03387       return 0;
03388     }
03389   (*code_err) = DEV_NAME_NOT_DEFINED; 
03390   printk("Device interface name not specified !!!\n");
03391   return 0;
03392 }
03393 XIAN_EXPORT_SYMBOL(get_ast_ant_txswitch);
03394 
03395 
03396 /****************************************************************************************************************
03397  ****************************************************************************************************************
03398  *  METRICS OFFERED BY ieee80211_stats
03399  *
03400  *  Number of :
03401  *
03402  * - rx frame with bad version 
03403  * - rx frame too short
03404  * - rx from wrong bssid
03405  * - rx discard 'cuz dup
03406  * - rx w/ wrong direction
03407  * - rx discard 'cuz mcast echo
03408  * - rx discard 'cuz sta !assoc 
03409  * - rx w/ wep but privacy off
03410  * - rx w/o wep and privacy on 
03411  * - rx wep processing failed
03412  * - rx decapsulation failed
03413  * - rx discard mgt frames
03414  * - rx discard ctrl frames 
03415  * - rx beacon frames
03416  * - rx rate set truncated 
03417  * - rx required element missing
03418  * - rx element too big
03419  * - rx element too small 
03420  * - rx element unknown
03421  * - rx frame w/ invalid chan 
03422  * - rx frame chan mismatch
03423  * - rx frame dropped 
03424  * - rx frame ssid mismatch
03425  * - rx w/ unsupported auth alg
03426  * - rx sta auth failure
03427  * - rx auth discard 'cuz CM 
03428  * - rx assoc from wrong bssid
03429  * - rx assoc w/o auth
03430  * - rx assoc w/ cap mismatch 
03431  * - rx assoc w/ no rate match
03432  * - rx assoc w/ bad WPA IE 
03433  * - rx deauthentication
03434  * - rx disassociation
03435  * - rx frame w/ unknown subtype
03436  * - rx failed for lack of buf
03437  * - rx decrypt failed on crc 
03438  * - rx discard ahdemo mgt frame
03439  * - rx bad auth request 
03440  * - rx on unauthorized port 
03441  * - rx w/ incorrect keyid 
03442  * - rx seq# violation (CCMP)
03443  * - rx format bad (CCMP)
03444  * - rx MIC check failed (CCMP) 
03445  * - rx seq# violation (TKIP)
03446  * - rx format bad (TKIP) 
03447  * - rx MIC check failed (TKIP) 
03448  * - rx ICV check failed (TKIP)
03449  * - rx failed 'cuz key type
03450  * - rx failed 'cuz key !setup
03451  * - rx discard 'cuz acl policy 
03452  * - tx failed for lack of buf
03453  * - tx failed for no node 
03454  * - tx of unknown mgt frame 
03455  * - tx failed 'cuz key type 
03456  * - tx failed 'cuz no defkey
03457  * - tx failed 'cuz no space
03458  * - active scans started 
03459  * - passive scans started
03460  * - nodes timed out inactivity 
03461  * - no memory for crypto ctx
03462  * - tkip crypto done in s/w
03463  * - tkip en-MIC done in s/w 
03464  * - tkip de-MIC done in s/w
03465  * - tkip counter measures
03466  * - ccmp crypto done in s/w 
03467  * - wep crypto done in s/w
03468  * - cipher rejected key
03469  * - no key index for setkey
03470  * - driver key delete failed
03471  * - unknown cipher
03472  * - cipher not available 
03473  * - cipher attach failed
03474  * - cipher fallback to s/w
03475  * - driver key alloc failed 
03476  * - en-MIC failed
03477  * - merge failed-cap mismatch
03478  * - merge failed-rate mismatch
03479  * - ps-poll for unassoc. sta 
03480  * - ps-poll w/ incorrect aid
03481  * - ps-poll w/ nothing to send
03482  *   
03483  ****************************************************************************************************************
03484  ***************************************************************************************************************/
03485 
03486 /*************************************************************************************************************/
03493 u_int32_t
03494 get_is_rx_badversion(char * dev_name,
03495                      unsigned int * code_err)
03496 {
03497   u_int32_t metric = 0;
03498   struct net_device * dev;
03499 
03500   if ((dev_name) && (strlen(dev_name)))
03501     {
03502       dev = dev_get_by_name(dev_name);  
03503       if (dev)
03504         {
03505           struct ath_softc *sc = dev->priv;
03506           struct ieee80211com *ic = &sc->sc_ic;
03507 #ifdef MADWIFI_NG
03508           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03509           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03510 #else
03511           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03512 #endif
03513           ATH_LOCK(sc);
03514           metric = ic_stats->is_rx_badversion;
03515           ATH_UNLOCK(sc);
03516           dev_put(dev);
03517           return metric;
03518         }
03519       (*code_err) = DEV_NOT_FOUND;
03520       printk ("Device interface not found\n");
03521       return 0;
03522     }
03523   (*code_err) = DEV_NAME_NOT_DEFINED; 
03524   printk("Device interface name not specified !!!\n");
03525   return 0;
03526 }
03527 XIAN_EXPORT_SYMBOL(get_is_rx_badversion);
03528 
03529 
03530 /*************************************************************************************************************/
03537 u_int32_t
03538 get_is_rx_tooshort(char * dev_name,
03539                    unsigned int * code_err)
03540 {
03541   u_int32_t metric = 0;
03542   struct net_device * dev;
03543 
03544   if ((dev_name) && (strlen(dev_name)))
03545     {
03546       dev = dev_get_by_name(dev_name);  
03547       if (dev)
03548         {
03549           struct ath_softc *sc = dev->priv;
03550           struct ieee80211com *ic = &sc->sc_ic;
03551 #ifdef MADWIFI_NG
03552           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03553           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03554 #else
03555           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03556 #endif
03557           ATH_LOCK(sc);
03558           metric = ic_stats->is_rx_tooshort;
03559           ATH_UNLOCK(sc);
03560           dev_put(dev);
03561           return metric;
03562         }
03563       (*code_err) = DEV_NOT_FOUND;
03564       printk ("Device interface not found\n");
03565       return 0;
03566     }
03567   (*code_err) = DEV_NAME_NOT_DEFINED; 
03568   printk("Device interface name not specified !!!\n");
03569   return 0;
03570 }
03571 XIAN_EXPORT_SYMBOL(get_is_rx_tooshort);
03572 
03573 
03574 /*************************************************************************************************************/
03581 u_int32_t
03582 get_is_rx_wrongbss(char * dev_name,
03583                    unsigned int * code_err)
03584 {
03585   u_int32_t metric = 0;
03586   struct net_device * dev;
03587 
03588   if ((dev_name) && (strlen(dev_name)))
03589     {
03590       dev = dev_get_by_name(dev_name);  
03591       if (dev)
03592         {
03593           struct ath_softc *sc = dev->priv;
03594           struct ieee80211com *ic = &sc->sc_ic;
03595 #ifdef MADWIFI_NG
03596           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03597           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03598 #else
03599           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03600 #endif
03601           ATH_LOCK(sc);
03602           metric = ic_stats->is_rx_wrongbss;
03603           ATH_UNLOCK(sc);
03604           dev_put(dev);
03605           return metric;
03606         }
03607       (*code_err) = DEV_NOT_FOUND;
03608       printk ("Device interface not found\n");
03609       return 0;
03610     }
03611   (*code_err) = DEV_NAME_NOT_DEFINED; 
03612   printk("Device interface name not specified !!!\n");
03613   return 0;
03614 }
03615 XIAN_EXPORT_SYMBOL(get_is_rx_wrongbss);
03616 
03617 
03618 /*************************************************************************************************************/
03625 u_int32_t
03626 get_is_rx_dup(char * dev_name,
03627               unsigned int * code_err)
03628 {
03629   u_int32_t metric = 0;
03630   struct net_device * dev;
03631 
03632   if ((dev_name) && (strlen(dev_name)))
03633     {
03634       dev = dev_get_by_name(dev_name);  
03635       if (dev)
03636         {
03637           struct ath_softc *sc = dev->priv;
03638           struct ieee80211com *ic = &sc->sc_ic;
03639 #ifdef MADWIFI_NG
03640           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03641           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03642 #else
03643           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03644 #endif
03645           ATH_LOCK(sc);
03646           metric = ic_stats->is_rx_dup;
03647           ATH_UNLOCK(sc);
03648           dev_put(dev);
03649           return metric;
03650         }
03651       (*code_err) = DEV_NOT_FOUND;
03652       printk ("Device interface not found\n");
03653       return 0;
03654     }
03655   (*code_err) = DEV_NAME_NOT_DEFINED; 
03656   printk("Device interface name not specified !!!\n");
03657   return 0;
03658 }
03659 XIAN_EXPORT_SYMBOL(get_is_rx_dup);
03660 
03661 
03662 /*************************************************************************************************************/
03669 u_int32_t
03670 get_is_rx_wrongdir(char * dev_name,
03671                    unsigned int * code_err)
03672 {
03673   u_int32_t metric = 0;
03674   struct net_device * dev;
03675 
03676   if ((dev_name) && (strlen(dev_name)))
03677     {
03678       dev = dev_get_by_name(dev_name);  
03679       if (dev)
03680         {
03681           struct ath_softc *sc = dev->priv;
03682           struct ieee80211com *ic = &sc->sc_ic;
03683 #ifdef MADWIFI_NG
03684           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03685           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03686 #else
03687           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03688 #endif
03689           ATH_LOCK(sc);
03690           metric = ic_stats->is_rx_wrongdir;
03691           ATH_UNLOCK(sc);
03692           dev_put(dev);
03693           return metric;
03694         }
03695       (*code_err) = DEV_NOT_FOUND;
03696       printk ("Device interface not found\n");
03697       return 0;
03698     }
03699   (*code_err) = DEV_NAME_NOT_DEFINED; 
03700   printk("Device interface name not specified !!!\n");
03701   return 0;
03702 }
03703 XIAN_EXPORT_SYMBOL(get_is_rx_wrongdir);
03704 
03705 
03706 /*************************************************************************************************************/
03713 u_int32_t
03714 get_is_rx_mcastecho(char * dev_name,
03715                     unsigned int * code_err)
03716 {
03717   u_int32_t metric = 0;
03718   struct net_device * dev;
03719 
03720   if ((dev_name) && (strlen(dev_name)))
03721     {
03722       dev = dev_get_by_name(dev_name);  
03723       if (dev)
03724         {
03725           struct ath_softc *sc = dev->priv;
03726           struct ieee80211com *ic = &sc->sc_ic;
03727 #ifdef MADWIFI_NG
03728           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03729           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03730 #else
03731           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03732 #endif
03733           ATH_LOCK(sc);
03734           metric = ic_stats->is_rx_mcastecho;
03735           ATH_UNLOCK(sc);
03736           dev_put(dev);
03737           return metric;
03738         }
03739       (*code_err) = DEV_NOT_FOUND;
03740       printk ("Device interface not found\n");
03741       return 0;
03742     }
03743   (*code_err) = DEV_NAME_NOT_DEFINED; 
03744   printk("Device interface name not specified !!!\n");
03745   return 0;
03746 }
03747 XIAN_EXPORT_SYMBOL(get_is_rx_mcastecho);
03748 
03749 
03750 /*************************************************************************************************************/
03757 u_int32_t
03758 get_is_rx_notassoc(char * dev_name,
03759                    unsigned int * code_err)
03760 {
03761   u_int32_t metric = 0;
03762   struct net_device * dev;
03763 
03764   if ((dev_name) && (strlen(dev_name)))
03765     {
03766       dev = dev_get_by_name(dev_name);  
03767       if (dev)
03768         {
03769           struct ath_softc *sc = dev->priv;
03770           struct ieee80211com *ic = &sc->sc_ic;
03771 #ifdef MADWIFI_NG
03772           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03773           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03774 #else
03775           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03776 #endif
03777           ATH_LOCK(sc);
03778           metric = ic_stats->is_rx_notassoc;
03779           ATH_UNLOCK(sc);
03780           dev_put(dev);
03781           return metric;
03782         }
03783       (*code_err) = DEV_NOT_FOUND;
03784       printk ("Device interface not found\n");
03785       return 0;
03786     }
03787   (*code_err) = DEV_NAME_NOT_DEFINED; 
03788   printk("Device interface name not specified !!!\n");
03789   return 0;
03790 }
03791 XIAN_EXPORT_SYMBOL(get_is_rx_notassoc);
03792 
03793 
03794 /*************************************************************************************************************/
03801 u_int32_t
03802 get_is_rx_noprivacy(char * dev_name,
03803                     unsigned int * code_err)
03804 {
03805   u_int32_t metric = 0;
03806   struct net_device * dev;
03807 
03808   if ((dev_name) && (strlen(dev_name)))
03809     {
03810       dev = dev_get_by_name(dev_name);  
03811       if (dev)
03812         {
03813           struct ath_softc *sc = dev->priv;
03814           struct ieee80211com *ic = &sc->sc_ic;
03815 #ifdef MADWIFI_NG
03816           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03817           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03818 #else
03819           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03820 #endif
03821           ATH_LOCK(sc);
03822           metric = ic_stats->is_rx_noprivacy;
03823           ATH_UNLOCK(sc);
03824           dev_put(dev);
03825           return metric;
03826         }
03827       (*code_err) = DEV_NOT_FOUND;
03828       printk ("Device interface not found\n");
03829       return 0;
03830     }
03831   (*code_err) = DEV_NAME_NOT_DEFINED; 
03832   printk("Device interface name not specified !!!\n");
03833   return 0;
03834 }
03835 XIAN_EXPORT_SYMBOL(get_is_rx_noprivacy);
03836 
03837 
03838 /*************************************************************************************************************/
03845 u_int32_t
03846 get_is_rx_unencrypted(char * dev_name,
03847                       unsigned int * code_err)
03848 {
03849   u_int32_t metric = 0;
03850   struct net_device * dev;
03851 
03852   if ((dev_name) && (strlen(dev_name)))
03853     {
03854       dev = dev_get_by_name(dev_name);  
03855       if (dev)
03856         {
03857           struct ath_softc *sc = dev->priv;
03858           struct ieee80211com *ic = &sc->sc_ic;
03859 #ifdef MADWIFI_NG
03860           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03861           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03862 #else
03863           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03864 #endif
03865           ATH_LOCK(sc);
03866           metric = ic_stats->is_rx_unencrypted;
03867           ATH_UNLOCK(sc);
03868           dev_put(dev);
03869           return metric;
03870         }
03871       (*code_err) = DEV_NOT_FOUND;
03872       printk ("Device interface not found\n");
03873       return 0;
03874     }
03875   (*code_err) = DEV_NAME_NOT_DEFINED; 
03876   printk("Device interface name not specified !!!\n");
03877   return 0;
03878 }
03879 XIAN_EXPORT_SYMBOL(get_is_rx_unencrypted);
03880 
03881 
03882 /*************************************************************************************************************/
03889 u_int32_t
03890 get_is_rx_wepfail(char * dev_name,
03891                   unsigned int * code_err)
03892 {
03893   u_int32_t metric = 0;
03894   struct net_device * dev;
03895 
03896   if ((dev_name) && (strlen(dev_name)))
03897     {
03898       dev = dev_get_by_name(dev_name);  
03899       if (dev)
03900         {
03901           struct ath_softc *sc = dev->priv;
03902           struct ieee80211com *ic = &sc->sc_ic;
03903 #ifdef MADWIFI_NG
03904           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03905           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03906 #else
03907           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03908 #endif
03909           ATH_LOCK(sc);
03910           metric = ic_stats->is_rx_wepfail;
03911           ATH_UNLOCK(sc);
03912           dev_put(dev);
03913           return metric;
03914         }
03915       (*code_err) = DEV_NOT_FOUND;
03916       printk ("Device interface not found\n");
03917       return 0;
03918     }
03919   (*code_err) = DEV_NAME_NOT_DEFINED; 
03920   printk("Device interface name not specified !!!\n");
03921   return 0;
03922 }
03923 XIAN_EXPORT_SYMBOL(get_is_rx_wepfail);
03924 
03925 
03926 /*************************************************************************************************************/
03933 u_int32_t
03934 get_is_rx_decap(char * dev_name,
03935                 unsigned int * code_err)
03936 {
03937   u_int32_t metric = 0;
03938   struct net_device * dev;
03939 
03940   if ((dev_name) && (strlen(dev_name)))
03941     {
03942       dev = dev_get_by_name(dev_name);  
03943       if (dev)
03944         {
03945           struct ath_softc *sc = dev->priv;
03946           struct ieee80211com *ic = &sc->sc_ic;
03947 #ifdef MADWIFI_NG
03948           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03949           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03950 #else
03951           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03952 #endif
03953           ATH_LOCK(sc);
03954           metric = ic_stats->is_rx_decap;
03955           ATH_UNLOCK(sc);
03956           dev_put(dev);
03957           return metric;
03958         }
03959       (*code_err) = DEV_NOT_FOUND;
03960       printk ("Device interface not found\n");
03961       return 0;
03962     }
03963   (*code_err) = DEV_NAME_NOT_DEFINED; 
03964   printk("Device interface name not specified !!!\n");
03965   return 0;
03966 }
03967 XIAN_EXPORT_SYMBOL(get_is_rx_decap);
03968 
03969 
03970 /*************************************************************************************************************/
03977 u_int32_t
03978 get_is_rx_mgtdiscard(char * dev_name,
03979                      unsigned int * code_err)
03980 {
03981   u_int32_t metric = 0;
03982   struct net_device * dev;
03983 
03984   if ((dev_name) && (strlen(dev_name)))
03985     {
03986       dev = dev_get_by_name(dev_name);  
03987       if (dev)
03988         {
03989           struct ath_softc *sc = dev->priv;
03990           struct ieee80211com *ic = &sc->sc_ic;
03991 #ifdef MADWIFI_NG
03992           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
03993           struct ieee80211_stats * ic_stats = &vap->iv_stats;
03994 #else
03995           struct ieee80211_stats * ic_stats = &ic->ic_stats;
03996 #endif
03997           ATH_LOCK(sc);
03998           metric = ic_stats->is_rx_mgtdiscard;
03999           ATH_UNLOCK(sc);
04000           dev_put(dev);
04001           return metric;
04002         }
04003       (*code_err) = DEV_NOT_FOUND;
04004       printk ("Device interface not found\n");
04005       return 0;
04006     }
04007   (*code_err) = DEV_NAME_NOT_DEFINED; 
04008   printk("Device interface name not specified !!!\n");
04009   return 0;
04010 }
04011 XIAN_EXPORT_SYMBOL(get_is_rx_mgtdiscard);
04012 
04013 
04014 /*************************************************************************************************************/
04021 u_int32_t
04022 get_is_rx_ctl(char * dev_name,
04023               unsigned int * code_err)
04024 {
04025   u_int32_t metric = 0;
04026   struct net_device * dev;
04027 
04028   if ((dev_name) && (strlen(dev_name)))
04029     {
04030       dev = dev_get_by_name(dev_name);  
04031       if (dev)
04032         {
04033           struct ath_softc *sc = dev->priv;
04034           struct ieee80211com *ic = &sc->sc_ic;
04035 #ifdef MADWIFI_NG
04036           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04037           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04038 #else
04039           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04040 #endif
04041           ATH_LOCK(sc);
04042           metric = ic_stats->is_rx_ctl;
04043           ATH_UNLOCK(sc);
04044           dev_put(dev);
04045           return metric;
04046         }
04047       (*code_err) = DEV_NOT_FOUND;
04048       printk ("Device interface not found\n");
04049       return 0;
04050     }
04051   (*code_err) = DEV_NAME_NOT_DEFINED; 
04052   printk("Device interface name not specified !!!\n");
04053   return 0;
04054 }
04055 XIAN_EXPORT_SYMBOL(get_is_rx_ctl);
04056 
04057 
04058 /*************************************************************************************************************/
04065 u_int32_t
04066 get_is_rx_beacon(char * dev_name,
04067                  unsigned int * code_err)
04068 {
04069   u_int32_t metric = 0;
04070   struct net_device * dev;
04071 
04072   if ((dev_name) && (strlen(dev_name)))
04073     {
04074       dev = dev_get_by_name(dev_name);  
04075       if (dev)
04076         {
04077           struct ath_softc *sc = dev->priv;
04078           struct ieee80211com *ic = &sc->sc_ic;
04079 #ifdef MADWIFI_NG
04080           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04081           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04082 #else
04083           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04084 #endif
04085           ATH_LOCK(sc);
04086           metric = ic_stats->is_rx_beacon;
04087           ATH_UNLOCK(sc);
04088           dev_put(dev);
04089           return metric;
04090         }
04091       (*code_err) = DEV_NOT_FOUND;
04092       printk ("Device interface not found\n");
04093       return 0;
04094     }
04095   (*code_err) = DEV_NAME_NOT_DEFINED; 
04096   printk("Device interface name not specified !!!\n");
04097   return 0;
04098 }
04099 XIAN_EXPORT_SYMBOL(get_is_rx_beacon);
04100 
04101 
04102 /*************************************************************************************************************/
04109 u_int32_t
04110 get_is_rx_rstoobig(char * dev_name,
04111                    unsigned int * code_err)
04112 {
04113   u_int32_t metric = 0;
04114   struct net_device * dev;
04115 
04116   if ((dev_name) && (strlen(dev_name)))
04117     {
04118       dev = dev_get_by_name(dev_name);  
04119       if (dev)
04120         {
04121           struct ath_softc *sc = dev->priv;
04122           struct ieee80211com *ic = &sc->sc_ic;
04123 #ifdef MADWIFI_NG
04124           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04125           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04126 #else
04127           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04128 #endif
04129           ATH_LOCK(sc);
04130           metric = ic_stats->is_rx_rstoobig;
04131           ATH_UNLOCK(sc);
04132           dev_put(dev);
04133           return metric;
04134         }
04135       (*code_err) = DEV_NOT_FOUND;
04136       printk ("Device interface not found\n");
04137       return 0;
04138     }
04139   (*code_err) = DEV_NAME_NOT_DEFINED; 
04140   printk("Device interface name not specified !!!\n");
04141   return 0;
04142 }
04143 XIAN_EXPORT_SYMBOL(get_is_rx_rstoobig);
04144 
04145 
04146 /*************************************************************************************************************/
04153 u_int32_t
04154 get_is_rx_elem_missing(char * dev_name,
04155                        unsigned int * code_err)
04156 {
04157   u_int32_t metric = 0;
04158   struct net_device * dev;
04159 
04160   if ((dev_name) && (strlen(dev_name)))
04161     {
04162       dev = dev_get_by_name(dev_name);  
04163       if (dev)
04164         {
04165           struct ath_softc *sc = dev->priv;
04166           struct ieee80211com *ic = &sc->sc_ic;
04167 #ifdef MADWIFI_NG
04168           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04169           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04170 #else
04171           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04172 #endif
04173           ATH_LOCK(sc);
04174           metric = ic_stats->is_rx_elem_missing;
04175           ATH_UNLOCK(sc);
04176           dev_put(dev);
04177           return metric;
04178         }
04179       (*code_err) = DEV_NOT_FOUND;
04180       printk ("Device interface not found\n");
04181       return 0;
04182     }
04183   (*code_err) = DEV_NAME_NOT_DEFINED; 
04184   printk("Device interface name not specified !!!\n");
04185   return 0;
04186 }
04187 XIAN_EXPORT_SYMBOL(get_is_rx_elem_missing);
04188 
04189 
04190 /*************************************************************************************************************/
04197 u_int32_t
04198 get_is_rx_elem_toobig(char * dev_name,
04199                       unsigned int * code_err)
04200 {
04201   u_int32_t metric = 0;
04202   struct net_device * dev;
04203 
04204   if ((dev_name) && (strlen(dev_name)))
04205     {
04206       dev = dev_get_by_name(dev_name);  
04207       if (dev)
04208         {
04209           struct ath_softc *sc = dev->priv;
04210           struct ieee80211com *ic = &sc->sc_ic;
04211 #ifdef MADWIFI_NG
04212           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04213           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04214 #else
04215           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04216 #endif
04217           ATH_LOCK(sc);
04218           metric = ic_stats->is_rx_elem_toobig;
04219           ATH_UNLOCK(sc);
04220           dev_put(dev);
04221           return metric;
04222         }
04223       (*code_err) = DEV_NOT_FOUND;
04224       printk ("Device interface not found\n");
04225       return 0;
04226     }
04227   (*code_err) = DEV_NAME_NOT_DEFINED; 
04228   printk("Device interface name not specified !!!\n");
04229   return 0;
04230 }
04231 XIAN_EXPORT_SYMBOL(get_is_rx_elem_toobig);
04232 
04233 
04234 /*************************************************************************************************************/
04241 u_int32_t
04242 get_is_rx_elem_toosmall(char * dev_name,
04243                         unsigned int * code_err)
04244 {
04245   u_int32_t metric = 0;
04246   struct net_device * dev;
04247 
04248   if ((dev_name) && (strlen(dev_name)))
04249     {
04250       dev = dev_get_by_name(dev_name);  
04251       if (dev)
04252         {
04253           struct ath_softc *sc = dev->priv;
04254           struct ieee80211com *ic = &sc->sc_ic;
04255 #ifdef MADWIFI_NG
04256           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04257           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04258 #else
04259           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04260 #endif
04261           ATH_LOCK(sc);
04262           metric = ic_stats->is_rx_elem_toosmall;
04263           ATH_UNLOCK(sc);
04264           dev_put(dev);
04265           return metric;
04266         }
04267       (*code_err) = DEV_NOT_FOUND;
04268       printk ("Device interface not found\n");
04269       return 0;
04270     }
04271   (*code_err) = DEV_NAME_NOT_DEFINED; 
04272   printk("Device interface name not specified !!!\n");
04273   return 0;
04274 }
04275 XIAN_EXPORT_SYMBOL(get_is_rx_elem_toosmall);
04276 
04277 
04278 /*************************************************************************************************************/
04285 u_int32_t
04286 get_is_rx_elem_unknown(char * dev_name,
04287                        unsigned int * code_err)
04288 {
04289   u_int32_t metric = 0;
04290   struct net_device * dev;
04291 
04292   if ((dev_name) && (strlen(dev_name)))
04293     {
04294       dev = dev_get_by_name(dev_name);  
04295       if (dev)
04296         {
04297           struct ath_softc *sc = dev->priv;
04298           struct ieee80211com *ic = &sc->sc_ic;
04299 #ifdef MADWIFI_NG
04300           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04301           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04302 #else
04303           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04304 #endif
04305           ATH_LOCK(sc);
04306           metric = ic_stats->is_rx_elem_unknown;
04307           ATH_UNLOCK(sc);
04308           dev_put(dev);
04309           return metric;
04310         }
04311       (*code_err) = DEV_NOT_FOUND;
04312       printk ("Device interface not found\n");
04313       return 0;
04314     }
04315   (*code_err) = DEV_NAME_NOT_DEFINED; 
04316   printk("Device interface name not specified !!!\n");
04317   return 0;
04318 }
04319 XIAN_EXPORT_SYMBOL(get_is_rx_elem_unknown);
04320 
04321 
04322 /*************************************************************************************************************/
04329 u_int32_t
04330 get_is_rx_badchan(char * dev_name,
04331                   unsigned int * code_err)
04332 {
04333   u_int32_t metric = 0;
04334   struct net_device * dev;
04335 
04336   if ((dev_name) && (strlen(dev_name)))
04337     {
04338       dev = dev_get_by_name(dev_name);  
04339       if (dev)
04340         {
04341           struct ath_softc *sc = dev->priv;
04342           struct ieee80211com *ic = &sc->sc_ic;
04343 #ifdef MADWIFI_NG
04344           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04345           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04346 #else
04347           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04348 #endif
04349           ATH_LOCK(sc);
04350           metric = ic_stats->is_rx_badchan;
04351           ATH_UNLOCK(sc);
04352           dev_put(dev);
04353           return metric;
04354         }
04355       (*code_err) = DEV_NOT_FOUND;
04356       printk ("Device interface not found\n");
04357       return 0;
04358     }
04359   (*code_err) = DEV_NAME_NOT_DEFINED; 
04360   printk("Device interface name not specified !!!\n");
04361   return 0;
04362 }
04363 XIAN_EXPORT_SYMBOL(get_is_rx_badchan);
04364 
04365 
04366 /*************************************************************************************************************/
04373 u_int32_t
04374 get_is_rx_chanmismatch(char * dev_name,
04375                        unsigned int * code_err)
04376 {
04377   u_int32_t metric = 0;
04378   struct net_device * dev;
04379 
04380   if ((dev_name) && (strlen(dev_name)))
04381     {
04382       dev = dev_get_by_name(dev_name);  
04383       if (dev)
04384         {
04385           struct ath_softc *sc = dev->priv;
04386           struct ieee80211com *ic = &sc->sc_ic;
04387 #ifdef MADWIFI_NG
04388           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04389           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04390 #else
04391           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04392 #endif
04393           ATH_LOCK(sc);
04394           metric = ic_stats->is_rx_chanmismatch;
04395           ATH_UNLOCK(sc);
04396           dev_put(dev);
04397           return metric;
04398         }
04399       (*code_err) = DEV_NOT_FOUND;
04400       printk ("Device interface not found\n");
04401       return 0;
04402     }
04403   (*code_err) = DEV_NAME_NOT_DEFINED; 
04404   printk("Device interface name not specified !!!\n");
04405   return 0;
04406 }
04407 XIAN_EXPORT_SYMBOL(get_is_rx_chanmismatch);
04408 
04409 
04410 /*************************************************************************************************************/
04417 u_int32_t
04418 get_is_rx_nodealloc(char * dev_name,
04419                     unsigned int * code_err)
04420 {
04421   u_int32_t metric = 0;
04422   struct net_device * dev;
04423 
04424   if ((dev_name) && (strlen(dev_name)))
04425     {
04426       dev = dev_get_by_name(dev_name);  
04427       if (dev)
04428         {
04429           struct ath_softc *sc = dev->priv;
04430           struct ieee80211com *ic = &sc->sc_ic;
04431 #ifdef MADWIFI_NG
04432           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04433           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04434 #else
04435           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04436 #endif
04437           ATH_LOCK(sc);
04438           metric = ic_stats->is_rx_nodealloc;
04439           ATH_UNLOCK(sc);
04440           dev_put(dev);
04441           return metric;
04442         }
04443       (*code_err) = DEV_NOT_FOUND;
04444       printk ("Device interface not found\n");
04445       return 0;
04446     }
04447   (*code_err) = DEV_NAME_NOT_DEFINED; 
04448   printk("Device interface name not specified !!!\n");
04449   return 0;
04450 }
04451 XIAN_EXPORT_SYMBOL(get_is_rx_nodealloc);
04452 
04453 
04454 /*************************************************************************************************************/
04461 u_int32_t
04462 get_is_rx_ssidmismatch(char * dev_name,
04463                        unsigned int * code_err)
04464 {
04465   u_int32_t metric = 0;
04466   struct net_device * dev;
04467 
04468   if ((dev_name) && (strlen(dev_name)))
04469     {
04470       dev = dev_get_by_name(dev_name);  
04471       if (dev)
04472         {
04473           struct ath_softc *sc = dev->priv;
04474           struct ieee80211com *ic = &sc->sc_ic;
04475 #ifdef MADWIFI_NG
04476           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04477           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04478 #else
04479           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04480 #endif
04481           ATH_LOCK(sc);
04482           metric = ic_stats->is_rx_ssidmismatch;
04483           ATH_UNLOCK(sc);
04484           dev_put(dev);
04485           return metric;
04486         }
04487       (*code_err) = DEV_NOT_FOUND;
04488       printk ("Device interface not found\n");
04489       return 0;
04490     }
04491   (*code_err) = DEV_NAME_NOT_DEFINED; 
04492   printk("Device interface name not specified !!!\n");
04493   return 0;
04494 }
04495 XIAN_EXPORT_SYMBOL(get_is_rx_ssidmismatch);
04496 
04497 
04498 /*************************************************************************************************************/
04505 u_int32_t
04506 get_is_rx_auth_unsupported(char * dev_name,
04507                            unsigned int * code_err)
04508 {
04509   u_int32_t metric = 0;
04510   struct net_device * dev;
04511 
04512   if ((dev_name) && (strlen(dev_name)))
04513     {
04514       dev = dev_get_by_name(dev_name);  
04515       if (dev)
04516         {
04517           struct ath_softc *sc = dev->priv;
04518           struct ieee80211com *ic = &sc->sc_ic;
04519 #ifdef MADWIFI_NG
04520           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04521           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04522 #else
04523           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04524 #endif
04525           ATH_LOCK(sc);
04526           metric = ic_stats->is_rx_auth_unsupported;
04527           ATH_UNLOCK(sc);
04528           dev_put(dev);
04529           return metric;
04530         }
04531       (*code_err) = DEV_NOT_FOUND;
04532       printk ("Device interface not found\n");
04533       return 0;
04534     }
04535   (*code_err) = DEV_NAME_NOT_DEFINED; 
04536   printk("Device interface name not specified !!!\n");
04537   return 0;
04538 }
04539 XIAN_EXPORT_SYMBOL(get_is_rx_auth_unsupported);
04540 
04541 
04542 /*************************************************************************************************************/
04549 u_int32_t
04550 get_is_rx_auth_fail(char * dev_name,
04551                     unsigned int * code_err)
04552 {
04553   u_int32_t metric = 0;
04554   struct net_device * dev;
04555 
04556   if ((dev_name) && (strlen(dev_name)))
04557     {
04558       dev = dev_get_by_name(dev_name);  
04559       if (dev)
04560         {
04561           struct ath_softc *sc = dev->priv;
04562           struct ieee80211com *ic = &sc->sc_ic;
04563 #ifdef MADWIFI_NG
04564           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04565           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04566 #else
04567           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04568 #endif
04569           ATH_LOCK(sc);
04570           metric = ic_stats->is_rx_auth_fail;
04571           ATH_UNLOCK(sc);
04572           dev_put(dev);
04573           return metric;
04574         }
04575       (*code_err) = DEV_NOT_FOUND;
04576       printk ("Device interface not found\n");
04577       return 0;
04578     }
04579   (*code_err) = DEV_NAME_NOT_DEFINED; 
04580   printk("Device interface name not specified !!!\n");
04581   return 0;
04582 }
04583 XIAN_EXPORT_SYMBOL(get_is_rx_auth_fail);
04584 
04585 
04586 /*************************************************************************************************************/
04593 u_int32_t
04594 get_is_rx_auth_countermeasures(char * dev_name,
04595                                unsigned int * code_err)
04596 {
04597   u_int32_t metric = 0;
04598   struct net_device * dev;
04599 
04600   if ((dev_name) && (strlen(dev_name)))
04601     {
04602       dev = dev_get_by_name(dev_name);  
04603       if (dev)
04604         {
04605           struct ath_softc *sc = dev->priv;
04606           struct ieee80211com *ic = &sc->sc_ic;
04607 #ifdef MADWIFI_NG
04608           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04609           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04610 #else
04611           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04612 #endif
04613           ATH_LOCK(sc);
04614           metric = ic_stats->is_rx_auth_countermeasures;
04615           ATH_UNLOCK(sc);
04616           dev_put(dev);
04617           return metric;
04618         }
04619       (*code_err) = DEV_NOT_FOUND;
04620       printk ("Device interface not found\n");
04621       return 0;
04622     }
04623   (*code_err) = DEV_NAME_NOT_DEFINED; 
04624   printk("Device interface name not specified !!!\n");
04625   return 0;
04626 }
04627 XIAN_EXPORT_SYMBOL(get_is_rx_auth_countermeasures);
04628 
04629 
04630 /*************************************************************************************************************/
04637 u_int32_t
04638 get_is_rx_assoc_bss(char * dev_name,
04639                     unsigned int * code_err)
04640 {
04641   u_int32_t metric = 0;
04642   struct net_device * dev;
04643 
04644   if ((dev_name) && (strlen(dev_name)))
04645     {
04646       dev = dev_get_by_name(dev_name);  
04647       if (dev)
04648         {
04649           struct ath_softc *sc = dev->priv;
04650           struct ieee80211com *ic = &sc->sc_ic;
04651 #ifdef MADWIFI_NG
04652           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04653           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04654 #else
04655           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04656 #endif
04657           ATH_LOCK(sc);
04658           metric = ic_stats->is_rx_assoc_bss;
04659           ATH_UNLOCK(sc);
04660           dev_put(dev);
04661           return metric;
04662         }
04663       (*code_err) = DEV_NOT_FOUND;
04664       printk ("Device interface not found\n");
04665       return 0;
04666     }
04667   (*code_err) = DEV_NAME_NOT_DEFINED; 
04668   printk("Device interface name not specified !!!\n");
04669   return 0;
04670 }
04671 XIAN_EXPORT_SYMBOL(get_is_rx_assoc_bss);
04672 
04673 
04674 /*************************************************************************************************************/
04681 u_int32_t
04682 get_is_rx_assoc_notauth(char * dev_name,
04683                         unsigned int * code_err)
04684 {
04685   u_int32_t metric = 0;
04686   struct net_device * dev;
04687 
04688   if ((dev_name) && (strlen(dev_name)))
04689     {
04690       dev = dev_get_by_name(dev_name);  
04691       if (dev)
04692         {
04693           struct ath_softc *sc = dev->priv;
04694           struct ieee80211com *ic = &sc->sc_ic;
04695 #ifdef MADWIFI_NG
04696           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04697           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04698 #else
04699           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04700 #endif
04701           ATH_LOCK(sc);
04702           metric = ic_stats->is_rx_assoc_notauth;
04703           ATH_UNLOCK(sc);
04704           dev_put(dev);
04705           return metric;
04706         }
04707       (*code_err) = DEV_NOT_FOUND;
04708       printk ("Device interface not found\n");
04709       return 0;
04710     }
04711   (*code_err) = DEV_NAME_NOT_DEFINED; 
04712   printk("Device interface name not specified !!!\n");
04713   return 0;
04714 }
04715 XIAN_EXPORT_SYMBOL(get_is_rx_assoc_notauth);
04716 
04717 
04718 /*************************************************************************************************************/
04725 u_int32_t
04726 get_is_rx_assoc_capmismatch(char * dev_name,
04727                             unsigned int * code_err)
04728 {
04729   u_int32_t metric = 0;
04730   struct net_device * dev;
04731 
04732   if ((dev_name) && (strlen(dev_name)))
04733     {
04734       dev = dev_get_by_name(dev_name);  
04735       if (dev)
04736         {
04737           struct ath_softc *sc = dev->priv;
04738           struct ieee80211com *ic = &sc->sc_ic;
04739 #ifdef MADWIFI_NG
04740           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04741           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04742 #else
04743           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04744 #endif
04745           ATH_LOCK(sc);
04746           metric = ic_stats->is_rx_assoc_capmismatch;
04747           ATH_UNLOCK(sc);
04748           dev_put(dev);
04749           return metric;
04750         }
04751       (*code_err) = DEV_NOT_FOUND;
04752       printk ("Device interface not found\n");
04753       return 0;
04754     }
04755   (*code_err) = DEV_NAME_NOT_DEFINED; 
04756   printk("Device interface name not specified !!!\n");
04757   return 0;
04758 }
04759 XIAN_EXPORT_SYMBOL(get_is_rx_assoc_capmismatch);
04760 
04761 
04762 /*************************************************************************************************************/
04769 u_int32_t
04770 get_is_rx_assoc_norate(char * dev_name,
04771                        unsigned int * code_err)
04772 {
04773   u_int32_t metric = 0;
04774   struct net_device * dev;
04775 
04776   if ((dev_name) && (strlen(dev_name)))
04777     {
04778       dev = dev_get_by_name(dev_name);  
04779       if (dev)
04780         {
04781           struct ath_softc *sc = dev->priv;
04782           struct ieee80211com *ic = &sc->sc_ic;
04783 #ifdef MADWIFI_NG
04784           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04785           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04786 #else
04787           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04788 #endif
04789           ATH_LOCK(sc);
04790           metric = ic_stats->is_rx_assoc_norate;
04791           ATH_UNLOCK(sc);
04792           dev_put(dev);
04793           return metric;
04794         }
04795       (*code_err) = DEV_NOT_FOUND;
04796       printk ("Device interface not found\n");
04797       return 0;
04798     }
04799   (*code_err) = DEV_NAME_NOT_DEFINED; 
04800   printk("Device interface name not specified !!!\n");
04801   return 0;
04802 }
04803 XIAN_EXPORT_SYMBOL(get_is_rx_assoc_norate);
04804 
04805 
04806 /*************************************************************************************************************/
04813 u_int32_t
04814 get_is_rx_assoc_badwpaie(char * dev_name,
04815                          unsigned int * code_err)
04816 {
04817   u_int32_t metric = 0;
04818   struct net_device * dev;
04819 
04820   if ((dev_name) && (strlen(dev_name)))
04821     {
04822       dev = dev_get_by_name(dev_name);  
04823       if (dev)
04824         {
04825           struct ath_softc *sc = dev->priv;
04826           struct ieee80211com *ic = &sc->sc_ic;
04827 #ifdef MADWIFI_NG
04828           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04829           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04830 #else
04831           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04832 #endif
04833           ATH_LOCK(sc);
04834           metric = ic_stats->is_rx_assoc_badwpaie;
04835           ATH_UNLOCK(sc);
04836           dev_put(dev);
04837           return metric;
04838         }
04839       (*code_err) = DEV_NOT_FOUND;
04840       printk ("Device interface not found\n");
04841       return 0;
04842     }
04843   (*code_err) = DEV_NAME_NOT_DEFINED; 
04844   printk("Device interface name not specified !!!\n");
04845   return 0;
04846 }
04847 XIAN_EXPORT_SYMBOL(get_is_rx_assoc_badwpaie);
04848 
04849 
04850 /*************************************************************************************************************/
04857 u_int32_t
04858 get_is_rx_deauth(char * dev_name,
04859                  unsigned int * code_err)
04860 {
04861   u_int32_t metric = 0;
04862   struct net_device * dev;
04863 
04864   if ((dev_name) && (strlen(dev_name)))
04865     {
04866       dev = dev_get_by_name(dev_name);  
04867       if (dev)
04868         {
04869           struct ath_softc *sc = dev->priv;
04870           struct ieee80211com *ic = &sc->sc_ic;
04871 #ifdef MADWIFI_NG
04872           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04873           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04874 #else
04875           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04876 #endif
04877           ATH_LOCK(sc);
04878           metric = ic_stats->is_rx_deauth;
04879           ATH_UNLOCK(sc);
04880           dev_put(dev);
04881           return metric;
04882         }
04883       (*code_err) = DEV_NOT_FOUND;
04884       printk ("Device interface not found\n");
04885       return 0;
04886     }
04887   (*code_err) = DEV_NAME_NOT_DEFINED; 
04888   printk("Device interface name not specified !!!\n");
04889   return 0;
04890 }
04891 XIAN_EXPORT_SYMBOL(get_is_rx_deauth);
04892 
04893 
04894 /*************************************************************************************************************/
04901 u_int32_t
04902 get_is_rx_disassoc(char * dev_name,
04903                    unsigned int * code_err)
04904 {
04905   u_int32_t metric = 0;
04906   struct net_device * dev;
04907 
04908   if ((dev_name) && (strlen(dev_name)))
04909     {
04910       dev = dev_get_by_name(dev_name);  
04911       if (dev)
04912         {
04913           struct ath_softc *sc = dev->priv;
04914           struct ieee80211com *ic = &sc->sc_ic;
04915 #ifdef MADWIFI_NG
04916           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04917           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04918 #else
04919           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04920 #endif
04921           ATH_LOCK(sc);
04922           metric = ic_stats->is_rx_disassoc;
04923           ATH_UNLOCK(sc);
04924           dev_put(dev);
04925           return metric;
04926         }
04927       (*code_err) = DEV_NOT_FOUND;
04928       printk ("Device interface not found\n");
04929       return 0;
04930     }
04931   (*code_err) = DEV_NAME_NOT_DEFINED; 
04932   printk("Device interface name not specified !!!\n");
04933   return 0;
04934 }
04935 XIAN_EXPORT_SYMBOL(get_is_rx_disassoc);
04936 
04937 
04938 /*************************************************************************************************************/
04945 u_int32_t
04946 get_is_rx_badsubtype(char * dev_name,
04947                      unsigned int * code_err)
04948 {
04949   u_int32_t metric = 0;
04950   struct net_device * dev;
04951 
04952   if ((dev_name) && (strlen(dev_name)))
04953     {
04954       dev = dev_get_by_name(dev_name);  
04955       if (dev)
04956         {
04957           struct ath_softc *sc = dev->priv;
04958           struct ieee80211com *ic = &sc->sc_ic;
04959 #ifdef MADWIFI_NG
04960           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
04961           struct ieee80211_stats * ic_stats = &vap->iv_stats;
04962 #else
04963           struct ieee80211_stats * ic_stats = &ic->ic_stats;
04964 #endif
04965           ATH_LOCK(sc);
04966           metric = ic_stats->is_rx_badsubtype;
04967           ATH_UNLOCK(sc);
04968           dev_put(dev);
04969           return metric;
04970         }
04971       (*code_err) = DEV_NOT_FOUND;
04972       printk ("Device interface not found\n");
04973       return 0;
04974     }
04975   (*code_err) = DEV_NAME_NOT_DEFINED; 
04976   printk("Device interface name not specified !!!\n");
04977   return 0;
04978 }
04979 XIAN_EXPORT_SYMBOL(get_is_rx_badsubtype);
04980 
04981 
04982 /*************************************************************************************************************/
04989 u_int32_t
04990 get_is_rx_nobuf(char * dev_name,
04991                 unsigned int * code_err)
04992 {
04993   u_int32_t metric = 0;
04994   struct net_device * dev;
04995 
04996   if ((dev_name) && (strlen(dev_name)))
04997     {
04998       dev = dev_get_by_name(dev_name);  
04999       if (dev)
05000         {
05001           struct ath_softc *sc = dev->priv;
05002           struct ieee80211com *ic = &sc->sc_ic;
05003 #ifdef MADWIFI_NG
05004           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05005           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05006 #else
05007           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05008 #endif
05009           ATH_LOCK(sc);
05010           metric = ic_stats->is_rx_nobuf;
05011           ATH_UNLOCK(sc);
05012           dev_put(dev);
05013           return metric;
05014         }
05015       (*code_err) = DEV_NOT_FOUND;
05016       printk ("Device interface not found\n");
05017       return 0;
05018     }
05019   (*code_err) = DEV_NAME_NOT_DEFINED; 
05020   printk("Device interface name not specified !!!\n");
05021   return 0;
05022 }
05023 XIAN_EXPORT_SYMBOL(get_is_rx_nobuf);
05024 
05025 
05026 /*************************************************************************************************************/
05033 u_int32_t
05034 get_is_rx_decryptcrc(char * dev_name,
05035                      unsigned int * code_err)
05036 {
05037   u_int32_t metric = 0;
05038   struct net_device * dev;
05039 
05040   if ((dev_name) && (strlen(dev_name)))
05041     {
05042       dev = dev_get_by_name(dev_name);  
05043       if (dev)
05044         {
05045           struct ath_softc *sc = dev->priv;
05046           struct ieee80211com *ic = &sc->sc_ic;
05047 #ifdef MADWIFI_NG
05048           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05049           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05050 #else
05051           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05052 #endif
05053           ATH_LOCK(sc);
05054           metric = ic_stats->is_rx_decryptcrc;
05055           ATH_UNLOCK(sc);
05056           dev_put(dev);
05057           return metric;
05058         }
05059       (*code_err) = DEV_NOT_FOUND;
05060       printk ("Device interface not found\n");
05061       return 0;
05062     }
05063   (*code_err) = DEV_NAME_NOT_DEFINED; 
05064   printk("Device interface name not specified !!!\n");
05065   return 0;
05066 }
05067 XIAN_EXPORT_SYMBOL(get_is_rx_decryptcrc);
05068 
05069 
05070 /*************************************************************************************************************/
05077 u_int32_t
05078 get_is_rx_ahdemo_mgt(char * dev_name,
05079                      unsigned int * code_err)
05080 {
05081   u_int32_t metric = 0;
05082   struct net_device * dev;
05083 
05084   if ((dev_name) && (strlen(dev_name)))
05085     {
05086       dev = dev_get_by_name(dev_name);  
05087       if (dev)
05088         {
05089           struct ath_softc *sc = dev->priv;
05090           struct ieee80211com *ic = &sc->sc_ic;
05091 #ifdef MADWIFI_NG
05092           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05093           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05094 #else
05095           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05096 #endif
05097           ATH_LOCK(sc);
05098           metric = ic_stats->is_rx_ahdemo_mgt;
05099           ATH_UNLOCK(sc);
05100           dev_put(dev);
05101           return metric;
05102         }
05103       (*code_err) = DEV_NOT_FOUND;
05104       printk ("Device interface not found\n");
05105       return 0;
05106     }
05107   (*code_err) = DEV_NAME_NOT_DEFINED; 
05108   printk("Device interface name not specified !!!\n");
05109   return 0;
05110 }
05111 XIAN_EXPORT_SYMBOL(get_is_rx_ahdemo_mgt);
05112 
05113 
05114 /*************************************************************************************************************/
05121 u_int32_t
05122 get_is_rx_bad_auth(char * dev_name,
05123                    unsigned int * code_err)
05124 {
05125   u_int32_t metric = 0;
05126   struct net_device * dev;
05127 
05128   if ((dev_name) && (strlen(dev_name)))
05129     {
05130       dev = dev_get_by_name(dev_name);  
05131       if (dev)
05132         {
05133           struct ath_softc *sc = dev->priv;
05134           struct ieee80211com *ic = &sc->sc_ic;
05135 #ifdef MADWIFI_NG
05136           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05137           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05138 #else
05139           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05140 #endif
05141           ATH_LOCK(sc);
05142           metric = ic_stats->is_rx_bad_auth;
05143           ATH_UNLOCK(sc);
05144           dev_put(dev);
05145           return metric;
05146         }
05147       (*code_err) = DEV_NOT_FOUND;
05148       printk ("Device interface not found\n");
05149       return 0;
05150     }
05151   (*code_err) = DEV_NAME_NOT_DEFINED; 
05152   printk("Device interface name not specified !!!\n");
05153   return 0;
05154 }
05155 XIAN_EXPORT_SYMBOL(get_is_rx_bad_auth);
05156 
05157 
05158 /*************************************************************************************************************/
05165 u_int32_t
05166 get_is_rx_unauth(char * dev_name,
05167                  unsigned int * code_err)
05168 {
05169   u_int32_t metric = 0;
05170   struct net_device * dev;
05171 
05172   if ((dev_name) && (strlen(dev_name)))
05173     {
05174       dev = dev_get_by_name(dev_name);  
05175       if (dev)
05176         {
05177           struct ath_softc *sc = dev->priv;
05178           struct ieee80211com *ic = &sc->sc_ic;
05179 #ifdef MADWIFI_NG
05180           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05181           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05182 #else
05183           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05184 #endif
05185           ATH_LOCK(sc);
05186           metric = ic_stats->is_rx_unauth;
05187           ATH_UNLOCK(sc);
05188           dev_put(dev);
05189           return metric;
05190         }
05191       (*code_err) = DEV_NOT_FOUND;
05192       printk ("Device interface not found\n");
05193       return 0;
05194     }
05195   (*code_err) = DEV_NAME_NOT_DEFINED; 
05196   printk("Device interface name not specified !!!\n");
05197   return 0;
05198 }
05199 XIAN_EXPORT_SYMBOL(get_is_rx_unauth);
05200 
05201 
05202 /*************************************************************************************************************/
05209 u_int32_t
05210 get_is_rx_badkeyid(char * dev_name,
05211                    unsigned int * code_err)
05212 {
05213   u_int32_t metric = 0;
05214   struct net_device * dev;
05215 
05216   if ((dev_name) && (strlen(dev_name)))
05217     {
05218       dev = dev_get_by_name(dev_name);  
05219       if (dev)
05220         {
05221           struct ath_softc *sc = dev->priv;
05222           struct ieee80211com *ic = &sc->sc_ic;
05223 #ifdef MADWIFI_NG
05224           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05225           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05226 #else
05227           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05228 #endif
05229           ATH_LOCK(sc);
05230           metric = ic_stats->is_rx_badkeyid;
05231           ATH_UNLOCK(sc);
05232           dev_put(dev);
05233           return metric;
05234         }
05235       (*code_err) = DEV_NOT_FOUND;
05236       printk ("Device interface not found\n");
05237       return 0;
05238     }
05239   (*code_err) = DEV_NAME_NOT_DEFINED; 
05240   printk("Device interface name not specified !!!\n");
05241   return 0;
05242 }
05243 XIAN_EXPORT_SYMBOL(get_is_rx_badkeyid);
05244 
05245 
05246 /*************************************************************************************************************/
05253 u_int32_t
05254 get_is_rx_ccmpreplay(char * dev_name,
05255                       unsigned int * code_err)
05256 {
05257   u_int32_t metric = 0;
05258   struct net_device * dev;
05259 
05260   if ((dev_name) && (strlen(dev_name)))
05261     {
05262       dev = dev_get_by_name(dev_name);  
05263       if (dev)
05264         {
05265           struct ath_softc *sc = dev->priv;
05266           struct ieee80211com *ic = &sc->sc_ic;
05267 #ifdef MADWIFI_NG
05268           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05269           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05270 #else
05271           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05272 #endif
05273           ATH_LOCK(sc);
05274           metric = ic_stats->is_rx_ccmpreplay;
05275           ATH_UNLOCK(sc);
05276           dev_put(dev);
05277           return metric;
05278         }
05279       (*code_err) = DEV_NOT_FOUND;
05280       printk ("Device interface not found\n");
05281       return 0;
05282     }
05283   (*code_err) = DEV_NAME_NOT_DEFINED; 
05284   printk("Device interface name not specified !!!\n");
05285   return 0;
05286 }
05287 XIAN_EXPORT_SYMBOL(get_is_rx_ccmpreplay);
05288 
05289 
05290 /*************************************************************************************************************/
05297 u_int32_t
05298 get_is_rx_ccmpformat(char * dev_name,
05299                      unsigned int * code_err)
05300 {
05301   u_int32_t metric = 0;
05302   struct net_device * dev;
05303 
05304   if ((dev_name) && (strlen(dev_name)))
05305     {
05306       dev = dev_get_by_name(dev_name);  
05307       if (dev)
05308         {
05309           struct ath_softc *sc = dev->priv;
05310           struct ieee80211com *ic = &sc->sc_ic;
05311 #ifdef MADWIFI_NG
05312           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05313           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05314 #else
05315           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05316 #endif
05317           ATH_LOCK(sc);
05318           metric = ic_stats->is_rx_ccmpformat;
05319           ATH_UNLOCK(sc);
05320           dev_put(dev);
05321           return metric;
05322         }
05323       (*code_err) = DEV_NOT_FOUND;
05324       printk ("Device interface not found\n");
05325       return 0;
05326     }
05327   (*code_err) = DEV_NAME_NOT_DEFINED; 
05328   printk("Device interface name not specified !!!\n");
05329   return 0;
05330 }
05331 XIAN_EXPORT_SYMBOL(get_is_rx_ccmpformat);
05332 
05333 
05334 /*************************************************************************************************************/
05341 u_int32_t
05342 get_is_rx_ccmpmic(char * dev_name,
05343                      unsigned int * code_err)
05344 {
05345   u_int32_t metric = 0;
05346   struct net_device * dev;
05347 
05348   if ((dev_name) && (strlen(dev_name)))
05349     {
05350       dev = dev_get_by_name(dev_name);  
05351       if (dev)
05352         {
05353           struct ath_softc *sc = dev->priv;
05354           struct ieee80211com *ic = &sc->sc_ic;
05355 #ifdef MADWIFI_NG
05356           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05357           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05358 #else
05359           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05360 #endif
05361           ATH_LOCK(sc);
05362           metric = ic_stats->is_rx_ccmpmic;
05363           ATH_UNLOCK(sc);
05364           dev_put(dev);
05365           return metric;
05366         }
05367       (*code_err) = DEV_NOT_FOUND;
05368       printk ("Device interface not found\n");
05369       return 0;
05370     }
05371   (*code_err) = DEV_NAME_NOT_DEFINED; 
05372   printk("Device interface name not specified !!!\n");
05373   return 0;
05374 }
05375 XIAN_EXPORT_SYMBOL(get_is_rx_ccmpmic);
05376 
05377 
05378 /*************************************************************************************************************/
05385 u_int32_t
05386 get_is_rx_tkipreplay(char * dev_name,
05387                      unsigned int * code_err)
05388 {
05389   u_int32_t metric = 0;
05390   struct net_device * dev;
05391 
05392   if ((dev_name) && (strlen(dev_name)))
05393     {
05394       dev = dev_get_by_name(dev_name);  
05395       if (dev)
05396         {
05397           struct ath_softc *sc = dev->priv;
05398           struct ieee80211com *ic = &sc->sc_ic;
05399 #ifdef MADWIFI_NG
05400           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05401           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05402 #else
05403           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05404 #endif
05405           ATH_LOCK(sc);
05406           metric = ic_stats->is_rx_tkipreplay;
05407           ATH_UNLOCK(sc);
05408           dev_put(dev);
05409           return metric;
05410         }
05411       (*code_err) = DEV_NOT_FOUND;
05412       printk ("Device interface not found\n");
05413       return 0;
05414     }
05415   (*code_err) = DEV_NAME_NOT_DEFINED; 
05416   printk("Device interface name not specified !!!\n");
05417   return 0;
05418 }
05419 XIAN_EXPORT_SYMBOL(get_is_rx_tkipreplay);
05420 
05421 
05422 /*************************************************************************************************************/
05429 u_int32_t
05430 get_is_rx_tkipformat(char * dev_name,
05431                      unsigned int * code_err)
05432 {
05433   u_int32_t metric = 0;
05434   struct net_device * dev;
05435 
05436   if ((dev_name) && (strlen(dev_name)))
05437     {
05438       dev = dev_get_by_name(dev_name);  
05439       if (dev)
05440         {
05441           struct ath_softc *sc = dev->priv;
05442           struct ieee80211com *ic = &sc->sc_ic;
05443 #ifdef MADWIFI_NG
05444           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05445           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05446 #else
05447           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05448 #endif
05449           ATH_LOCK(sc);
05450           metric = ic_stats->is_rx_tkipformat;
05451           ATH_UNLOCK(sc);
05452           dev_put(dev);
05453           return metric;
05454         }
05455       (*code_err) = DEV_NOT_FOUND;
05456       printk ("Device interface not found\n");
05457       return 0;
05458     }
05459   (*code_err) = DEV_NAME_NOT_DEFINED; 
05460   printk("Device interface name not specified !!!\n");
05461   return 0;
05462 }
05463 XIAN_EXPORT_SYMBOL(get_is_rx_tkipformat);
05464 
05465 
05466 /*************************************************************************************************************/
05473 u_int32_t
05474 get_is_rx_tkipmic(char * dev_name,
05475                      unsigned int * code_err)
05476 {
05477   u_int32_t metric = 0;
05478   struct net_device * dev;
05479 
05480   if ((dev_name) && (strlen(dev_name)))
05481     {
05482       dev = dev_get_by_name(dev_name);  
05483       if (dev)
05484         {
05485           struct ath_softc *sc = dev->priv;
05486           struct ieee80211com *ic = &sc->sc_ic;
05487 #ifdef MADWIFI_NG
05488           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05489           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05490 #else
05491           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05492 #endif
05493           ATH_LOCK(sc);
05494           metric = ic_stats->is_rx_tkipmic;
05495           ATH_UNLOCK(sc);
05496           dev_put(dev);
05497           return metric;
05498         }
05499       (*code_err) = DEV_NOT_FOUND;
05500       printk ("Device interface not found\n");
05501       return 0;
05502     }
05503   (*code_err) = DEV_NAME_NOT_DEFINED; 
05504   printk("Device interface name not specified !!!\n");
05505   return 0;
05506 }
05507 XIAN_EXPORT_SYMBOL(get_is_rx_tkipmic);
05508 
05509 
05510 /*************************************************************************************************************/
05517 u_int32_t
05518 get_is_rx_tkipicv(char * dev_name,
05519                   unsigned int * code_err)
05520 {
05521   u_int32_t metric = 0;
05522   struct net_device * dev;
05523 
05524   if ((dev_name) && (strlen(dev_name)))
05525     {
05526       dev = dev_get_by_name(dev_name);  
05527       if (dev)
05528         {
05529           struct ath_softc *sc = dev->priv;
05530           struct ieee80211com *ic = &sc->sc_ic;
05531 #ifdef MADWIFI_NG
05532           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05533           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05534 #else
05535           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05536 #endif
05537           ATH_LOCK(sc);
05538           metric = ic_stats->is_rx_tkipicv;
05539           ATH_UNLOCK(sc);
05540           dev_put(dev);
05541           return metric;
05542         }
05543       (*code_err) = DEV_NOT_FOUND;
05544       printk ("Device interface not found\n");
05545       return 0;
05546     }
05547   (*code_err) = DEV_NAME_NOT_DEFINED; 
05548   printk("Device interface name not specified !!!\n");
05549   return 0;
05550 }
05551 XIAN_EXPORT_SYMBOL(get_is_rx_tkipicv);
05552 
05553 
05554 /*************************************************************************************************************/
05561 u_int32_t
05562 get_is_rx_badcipher(char * dev_name,
05563                     unsigned int * code_err)
05564 {
05565   u_int32_t metric = 0;
05566   struct net_device * dev;
05567 
05568   if ((dev_name) && (strlen(dev_name)))
05569     {
05570       dev = dev_get_by_name(dev_name);  
05571       if (dev)
05572         {
05573           struct ath_softc *sc = dev->priv;
05574           struct ieee80211com *ic = &sc->sc_ic;
05575 #ifdef MADWIFI_NG
05576           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05577           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05578 #else
05579           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05580 #endif
05581           ATH_LOCK(sc);
05582           metric = ic_stats->is_rx_badcipher;
05583           ATH_UNLOCK(sc);
05584           dev_put(dev);
05585           return metric;
05586         }
05587       (*code_err) = DEV_NOT_FOUND;
05588       printk ("Device interface not found\n");
05589       return 0;
05590     }
05591   (*code_err) = DEV_NAME_NOT_DEFINED; 
05592   printk("Device interface name not specified !!!\n");
05593   return 0;
05594 }
05595 XIAN_EXPORT_SYMBOL(get_is_rx_badcipher);
05596 
05597 
05598 /*************************************************************************************************************/
05605 u_int32_t
05606 get_is_rx_nocipherctx(char * dev_name,
05607                      unsigned int * code_err)
05608 {
05609   u_int32_t metric = 0;
05610   struct net_device * dev;
05611 
05612   if ((dev_name) && (strlen(dev_name)))
05613     {
05614       dev = dev_get_by_name(dev_name);  
05615       if (dev)
05616         {
05617           struct ath_softc *sc = dev->priv;
05618           struct ieee80211com *ic = &sc->sc_ic;
05619 #ifdef MADWIFI_NG
05620           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05621           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05622 #else
05623           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05624 #endif
05625           ATH_LOCK(sc);
05626           metric = ic_stats->is_rx_nocipherctx;
05627           ATH_UNLOCK(sc);
05628           dev_put(dev);
05629           return metric;
05630         }
05631       (*code_err) = DEV_NOT_FOUND;
05632       printk ("Device interface not found\n");
05633       return 0;
05634     }
05635   (*code_err) = DEV_NAME_NOT_DEFINED; 
05636   printk("Device interface name not specified !!!\n");
05637   return 0;
05638 }
05639 XIAN_EXPORT_SYMBOL(get_is_rx_nocipherctx);
05640 
05641 
05642 /*************************************************************************************************************/
05649 u_int32_t
05650 get_is_rx_acl(char * dev_name,
05651               unsigned int * code_err)
05652 {
05653   u_int32_t metric = 0;
05654   struct net_device * dev;
05655 
05656   if ((dev_name) && (strlen(dev_name)))
05657     {
05658       dev = dev_get_by_name(dev_name);  
05659       if (dev)
05660         {
05661           struct ath_softc *sc = dev->priv;
05662           struct ieee80211com *ic = &sc->sc_ic;
05663 #ifdef MADWIFI_NG
05664           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05665           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05666 #else
05667           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05668 #endif
05669           ATH_LOCK(sc);
05670           metric = ic_stats->is_rx_acl;
05671           ATH_UNLOCK(sc);
05672           dev_put(dev);
05673           return metric;
05674         }
05675       (*code_err) = DEV_NOT_FOUND;
05676       printk ("Device interface not found\n");
05677       return 0;
05678     }
05679   (*code_err) = DEV_NAME_NOT_DEFINED; 
05680   printk("Device interface name not specified !!!\n");
05681   return 0;
05682 }
05683 XIAN_EXPORT_SYMBOL(get_is_rx_acl);
05684 
05685 
05686 /*************************************************************************************************************/
05693 u_int32_t
05694 get_is_tx_nobuf(char * dev_name,
05695                 unsigned int * code_err)
05696 {
05697   u_int32_t metric = 0;
05698   struct net_device * dev;
05699 
05700   if ((dev_name) && (strlen(dev_name)))
05701     {
05702       dev = dev_get_by_name(dev_name);  
05703       if (dev)
05704         {
05705           struct ath_softc *sc = dev->priv;
05706           struct ieee80211com *ic = &sc->sc_ic;
05707 #ifdef MADWIFI_NG
05708           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05709           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05710 #else
05711           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05712 #endif
05713           ATH_LOCK(sc);
05714           metric = ic_stats->is_tx_nobuf;
05715           ATH_UNLOCK(sc);
05716           dev_put(dev);
05717           return metric;
05718         }
05719       (*code_err) = DEV_NOT_FOUND;
05720       printk ("Device interface not found\n");
05721       return 0;
05722     }
05723   (*code_err) = DEV_NAME_NOT_DEFINED; 
05724   printk("Device interface name not specified !!!\n");
05725   return 0;
05726 }
05727 XIAN_EXPORT_SYMBOL(get_is_tx_nobuf);
05728 
05729 
05730 /*************************************************************************************************************/
05737 u_int32_t
05738 get_is_tx_nonode(char * dev_name,
05739                  unsigned int * code_err)
05740 {
05741   u_int32_t metric = 0;
05742   struct net_device * dev;
05743 
05744   if ((dev_name) && (strlen(dev_name)))
05745     {
05746       dev = dev_get_by_name(dev_name);  
05747       if (dev)
05748         {
05749           struct ath_softc *sc = dev->priv;
05750           struct ieee80211com *ic = &sc->sc_ic;
05751 #ifdef MADWIFI_NG
05752           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05753           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05754 #else
05755           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05756 #endif
05757           ATH_LOCK(sc);
05758           metric = ic_stats->is_tx_nonode;
05759           ATH_UNLOCK(sc);
05760           dev_put(dev);
05761           return metric;
05762         }
05763       (*code_err) = DEV_NOT_FOUND;
05764       printk ("Device interface not found\n");
05765       return 0;
05766     }
05767   (*code_err) = DEV_NAME_NOT_DEFINED; 
05768   printk("Device interface name not specified !!!\n");
05769   return 0;
05770 }
05771 XIAN_EXPORT_SYMBOL(get_is_tx_nonode);
05772 
05773 
05774 /*************************************************************************************************************/
05781 u_int32_t
05782 get_is_tx_unknownmgt(char * dev_name,
05783                      unsigned int * code_err)
05784 {
05785   u_int32_t metric = 0;
05786   struct net_device * dev;
05787 
05788   if ((dev_name) && (strlen(dev_name)))
05789     {
05790       dev = dev_get_by_name(dev_name);  
05791       if (dev)
05792         {
05793           struct ath_softc *sc = dev->priv;
05794           struct ieee80211com *ic = &sc->sc_ic;
05795 #ifdef MADWIFI_NG
05796           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05797           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05798 #else
05799           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05800 #endif
05801           ATH_LOCK(sc);
05802           metric = ic_stats->is_tx_unknownmgt;
05803           ATH_UNLOCK(sc);
05804           dev_put(dev);
05805           return metric;
05806         }
05807       (*code_err) = DEV_NOT_FOUND;
05808       printk ("Device interface not found\n");
05809       return 0;
05810     }
05811   (*code_err) = DEV_NAME_NOT_DEFINED; 
05812   printk("Device interface name not specified !!!\n");
05813   return 0;
05814 }
05815 XIAN_EXPORT_SYMBOL(get_is_tx_unknownmgt);
05816 
05817 
05818 /*************************************************************************************************************/
05825 u_int32_t
05826 get_is_tx_badcipher(char * dev_name,
05827                     unsigned int * code_err)
05828 {
05829   u_int32_t metric = 0;
05830   struct net_device * dev;
05831 
05832   if ((dev_name) && (strlen(dev_name)))
05833     {
05834       dev = dev_get_by_name(dev_name);  
05835       if (dev)
05836         {
05837           struct ath_softc *sc = dev->priv;
05838           struct ieee80211com *ic = &sc->sc_ic;
05839 #ifdef MADWIFI_NG
05840           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05841           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05842 #else
05843           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05844 #endif
05845           ATH_LOCK(sc);
05846           metric = ic_stats->is_tx_badcipher;
05847           ATH_UNLOCK(sc);
05848           dev_put(dev);
05849           return metric;
05850         }
05851       (*code_err) = DEV_NOT_FOUND;
05852       printk ("Device interface not found\n");
05853       return 0;
05854     }
05855   (*code_err) = DEV_NAME_NOT_DEFINED; 
05856   printk("Device interface name not specified !!!\n");
05857   return 0;
05858 }
05859 XIAN_EXPORT_SYMBOL(get_is_tx_badcipher);
05860 
05861 
05862 /*************************************************************************************************************/
05869 u_int32_t
05870 get_is_tx_nodefkey(char * dev_name,
05871                    unsigned int * code_err)
05872 {
05873   u_int32_t metric = 0;
05874   struct net_device * dev;
05875 
05876   if ((dev_name) && (strlen(dev_name)))
05877     {
05878       dev = dev_get_by_name(dev_name);  
05879       if (dev)
05880         {
05881           struct ath_softc *sc = dev->priv;
05882           struct ieee80211com *ic = &sc->sc_ic;
05883 #ifdef MADWIFI_NG
05884           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05885           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05886 #else
05887           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05888 #endif
05889           ATH_LOCK(sc);
05890           metric = ic_stats->is_tx_nodefkey;
05891           ATH_UNLOCK(sc);
05892           dev_put(dev);
05893           return metric;
05894         }
05895       (*code_err) = DEV_NOT_FOUND;
05896       printk ("Device interface not found\n");
05897       return 0;
05898     }
05899   (*code_err) = DEV_NAME_NOT_DEFINED; 
05900   printk("Device interface name not specified !!!\n");
05901   return 0;
05902 }
05903 XIAN_EXPORT_SYMBOL(get_is_tx_nodefkey);
05904 
05905 
05906 /*************************************************************************************************************/
05913 u_int32_t
05914 get_is_tx_noheadroom(char * dev_name,
05915                      unsigned int * code_err)
05916 {
05917   u_int32_t metric = 0;
05918   struct net_device * dev;
05919 
05920   if ((dev_name) && (strlen(dev_name)))
05921     {
05922       dev = dev_get_by_name(dev_name);  
05923       if (dev)
05924         {
05925           struct ath_softc *sc = dev->priv;
05926           struct ieee80211com *ic = &sc->sc_ic;
05927 #ifdef MADWIFI_NG
05928           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05929           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05930 #else
05931           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05932 #endif
05933           ATH_LOCK(sc);
05934           metric = ic_stats->is_tx_noheadroom;
05935           ATH_UNLOCK(sc);
05936           dev_put(dev);
05937           return metric;
05938         }
05939       (*code_err) = DEV_NOT_FOUND;
05940       printk ("Device interface not found\n");
05941       return 0;
05942     }
05943   (*code_err) = DEV_NAME_NOT_DEFINED; 
05944   printk("Device interface name not specified !!!\n");
05945   return 0;
05946 }
05947 XIAN_EXPORT_SYMBOL(get_is_tx_noheadroom);
05948 
05949 
05950 /*************************************************************************************************************/
05957 u_int32_t
05958 get_is_scan_active(char * dev_name,
05959                    unsigned int * code_err)
05960 {
05961   u_int32_t metric = 0;
05962   struct net_device * dev;
05963 
05964   if ((dev_name) && (strlen(dev_name)))
05965     {
05966       dev = dev_get_by_name(dev_name);  
05967       if (dev)
05968         {
05969           struct ath_softc *sc = dev->priv;
05970           struct ieee80211com *ic = &sc->sc_ic;
05971 #ifdef MADWIFI_NG
05972           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
05973           struct ieee80211_stats * ic_stats = &vap->iv_stats;
05974 #else
05975           struct ieee80211_stats * ic_stats = &ic->ic_stats;
05976 #endif
05977           ATH_LOCK(sc);
05978           metric = ic_stats->is_scan_active;
05979           ATH_UNLOCK(sc);
05980           dev_put(dev);
05981           return metric;
05982         }
05983       (*code_err) = DEV_NOT_FOUND;
05984       printk ("Device interface not found\n");
05985       return 0;
05986     }
05987   (*code_err) = DEV_NAME_NOT_DEFINED; 
05988   printk("Device interface name not specified !!!\n");
05989   return 0;
05990 }
05991 XIAN_EXPORT_SYMBOL(get_is_scan_active);
05992 
05993 
05994 /*************************************************************************************************************/
06001 u_int32_t
06002 get_is_scan_passive(char * dev_name,
06003                     unsigned int * code_err)
06004 {
06005   u_int32_t metric = 0;
06006   struct net_device * dev;
06007 
06008   if ((dev_name) && (strlen(dev_name)))
06009     {
06010       dev = dev_get_by_name(dev_name);  
06011       if (dev)
06012         {
06013           struct ath_softc *sc = dev->priv;
06014           struct ieee80211com *ic = &sc->sc_ic;
06015 #ifdef MADWIFI_NG
06016           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06017           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06018 #else
06019           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06020 #endif
06021           ATH_LOCK(sc);
06022           metric = ic_stats->is_scan_passive;
06023           ATH_UNLOCK(sc);
06024           dev_put(dev);
06025           return metric;
06026         }
06027       (*code_err) = DEV_NOT_FOUND;
06028       printk ("Device interface not found\n");
06029       return 0;
06030     }
06031   (*code_err) = DEV_NAME_NOT_DEFINED; 
06032   printk("Device interface name not specified !!!\n");
06033   return 0;
06034 }
06035 XIAN_EXPORT_SYMBOL(get_is_scan_passive);
06036 
06037 
06038 /*************************************************************************************************************/
06045 u_int32_t
06046 get_is_node_timeout(char * dev_name,
06047                     unsigned int * code_err)
06048 {
06049   u_int32_t metric = 0;
06050   struct net_device * dev;
06051 
06052   if ((dev_name) && (strlen(dev_name)))
06053     {
06054       dev = dev_get_by_name(dev_name);  
06055       if (dev)
06056         {
06057           struct ath_softc *sc = dev->priv;
06058           struct ieee80211com *ic = &sc->sc_ic;
06059 #ifdef MADWIFI_NG
06060           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06061           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06062 #else
06063           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06064 #endif
06065           ATH_LOCK(sc);
06066           metric = ic_stats->is_node_timeout;
06067           ATH_UNLOCK(sc);
06068           dev_put(dev);
06069           return metric;
06070         }
06071       (*code_err) = DEV_NOT_FOUND;
06072       printk ("Device interface not found\n");
06073       return 0;
06074     }
06075   (*code_err) = DEV_NAME_NOT_DEFINED; 
06076   printk("Device interface name not specified !!!\n");
06077   return 0;
06078 }
06079 XIAN_EXPORT_SYMBOL(get_is_node_timeout);
06080 
06081 
06082 /*************************************************************************************************************/
06089 u_int32_t
06090 get_is_crypto_nomem(char * dev_name,
06091                     unsigned int * code_err)
06092 {
06093   u_int32_t metric = 0;
06094   struct net_device * dev;
06095 
06096   if ((dev_name) && (strlen(dev_name)))
06097     {
06098       dev = dev_get_by_name(dev_name);  
06099       if (dev)
06100         {
06101           struct ath_softc *sc = dev->priv;
06102           struct ieee80211com *ic = &sc->sc_ic;
06103 #ifdef MADWIFI_NG
06104           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06105           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06106 #else
06107           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06108 #endif
06109           ATH_LOCK(sc);
06110           metric = ic_stats->is_crypto_nomem;
06111           ATH_UNLOCK(sc);
06112           dev_put(dev);
06113           return metric;
06114         }
06115       (*code_err) = DEV_NOT_FOUND;
06116       printk ("Device interface not found\n");
06117       return 0;
06118     }
06119   (*code_err) = DEV_NAME_NOT_DEFINED; 
06120   printk("Device interface name not specified !!!\n");
06121   return 0;
06122 }
06123 XIAN_EXPORT_SYMBOL(get_is_crypto_nomem);
06124 
06125 
06126 /*************************************************************************************************************/
06133 u_int32_t
06134 get_is_crypto_tkip(char * dev_name,
06135                    unsigned int * code_err)
06136 {
06137   u_int32_t metric = 0;
06138   struct net_device * dev;
06139 
06140   if ((dev_name) && (strlen(dev_name)))
06141     {
06142       dev = dev_get_by_name(dev_name);  
06143       if (dev)
06144         {
06145           struct ath_softc *sc = dev->priv;
06146           struct ieee80211com *ic = &sc->sc_ic;
06147 #ifdef MADWIFI_NG
06148           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06149           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06150 #else
06151           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06152 #endif
06153           ATH_LOCK(sc);
06154           metric = ic_stats->is_crypto_tkip;
06155           ATH_UNLOCK(sc);
06156           dev_put(dev);
06157           return metric;
06158         }
06159       (*code_err) = DEV_NOT_FOUND;
06160       printk ("Device interface not found\n");
06161       return 0;
06162     }
06163   (*code_err) = DEV_NAME_NOT_DEFINED; 
06164   printk("Device interface name not specified !!!\n");
06165   return 0;
06166 }
06167 XIAN_EXPORT_SYMBOL(get_is_crypto_tkip);
06168 
06169 
06170 /*************************************************************************************************************/
06177 u_int32_t
06178 get_is_crypto_tkipenmic(char * dev_name,
06179                            unsigned int * code_err)
06180 {
06181   u_int32_t metric = 0;
06182   struct net_device * dev;
06183 
06184   if ((dev_name) && (strlen(dev_name)))
06185     {
06186       dev = dev_get_by_name(dev_name);  
06187       if (dev)
06188         {
06189           struct ath_softc *sc = dev->priv;
06190           struct ieee80211com *ic = &sc->sc_ic;
06191 #ifdef MADWIFI_NG
06192           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06193           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06194 #else
06195           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06196 #endif
06197           ATH_LOCK(sc);
06198           metric = ic_stats->is_crypto_tkipenmic;
06199           ATH_UNLOCK(sc);
06200           dev_put(dev);
06201           return metric;
06202         }
06203       (*code_err) = DEV_NOT_FOUND;
06204       printk ("Device interface not found\n");
06205       return 0;
06206     }
06207   (*code_err) = DEV_NAME_NOT_DEFINED; 
06208   printk("Device interface name not specified !!!\n");
06209   return 0;
06210 }
06211 XIAN_EXPORT_SYMBOL(get_is_crypto_tkipenmic);
06212 
06213 
06214 /*************************************************************************************************************/
06221 u_int32_t
06222 get_is_crypto_tkipdemic(char * dev_name,
06223                         unsigned int * code_err)
06224 {
06225   u_int32_t metric = 0;
06226   struct net_device * dev;
06227 
06228   if ((dev_name) && (strlen(dev_name)))
06229     {
06230       dev = dev_get_by_name(dev_name);  
06231       if (dev)
06232         {
06233           struct ath_softc *sc = dev->priv;
06234           struct ieee80211com *ic = &sc->sc_ic;
06235 #ifdef MADWIFI_NG
06236           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06237           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06238 #else
06239           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06240 #endif
06241           ATH_LOCK(sc);
06242           metric = ic_stats->is_crypto_tkipdemic;
06243           ATH_UNLOCK(sc);
06244           dev_put(dev);
06245           return metric;
06246         }
06247       (*code_err) = DEV_NOT_FOUND;
06248       printk ("Device interface not found\n");
06249       return 0;
06250     }
06251   (*code_err) = DEV_NAME_NOT_DEFINED; 
06252   printk("Device interface name not specified !!!\n");
06253   return 0;
06254 }
06255 XIAN_EXPORT_SYMBOL(get_is_crypto_tkipdemic);
06256 
06257 
06258 /*************************************************************************************************************/
06265 u_int32_t
06266 get_is_crypto_tkipcm(char * dev_name,
06267                      unsigned int * code_err)
06268 {
06269   u_int32_t metric = 0;
06270   struct net_device * dev;
06271 
06272   if ((dev_name) && (strlen(dev_name)))
06273     {
06274       dev = dev_get_by_name(dev_name);  
06275       if (dev)
06276         {
06277           struct ath_softc *sc = dev->priv;
06278           struct ieee80211com *ic = &sc->sc_ic;
06279 #ifdef MADWIFI_NG
06280           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06281           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06282 #else
06283           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06284 #endif
06285           ATH_LOCK(sc);
06286           metric = ic_stats->is_crypto_tkipcm;
06287           ATH_UNLOCK(sc);
06288           dev_put(dev);
06289           return metric;
06290         }
06291       (*code_err) = DEV_NOT_FOUND;
06292       printk ("Device interface not found\n");
06293       return 0;
06294     }
06295   (*code_err) = DEV_NAME_NOT_DEFINED; 
06296   printk("Device interface name not specified !!!\n");
06297   return 0;
06298 }
06299 XIAN_EXPORT_SYMBOL(get_is_crypto_tkipcm);
06300 
06301 
06302 /*************************************************************************************************************/
06309 u_int32_t
06310 get_is_crypto_ccmp(char * dev_name,
06311                    unsigned int * code_err)
06312 {
06313   u_int32_t metric = 0;
06314   struct net_device * dev;
06315 
06316   if ((dev_name) && (strlen(dev_name)))
06317     {
06318       dev = dev_get_by_name(dev_name);  
06319       if (dev)
06320         {
06321           struct ath_softc *sc = dev->priv;
06322           struct ieee80211com *ic = &sc->sc_ic;
06323 #ifdef MADWIFI_NG
06324           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06325           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06326 #else
06327           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06328 #endif
06329           ATH_LOCK(sc);
06330           metric = ic_stats->is_crypto_ccmp;
06331           ATH_UNLOCK(sc);
06332           dev_put(dev);
06333           return metric;
06334         }
06335       (*code_err) = DEV_NOT_FOUND;
06336       printk ("Device interface not found\n");
06337       return 0;
06338     }
06339   (*code_err) = DEV_NAME_NOT_DEFINED; 
06340   printk("Device interface name not specified !!!\n");
06341   return 0;
06342 }
06343 XIAN_EXPORT_SYMBOL(get_is_crypto_ccmp);
06344 
06345 
06346 /*************************************************************************************************************/
06353 u_int32_t
06354 get_is_crypto_wep(char * dev_name,
06355                   unsigned int * code_err)
06356 {
06357   u_int32_t metric = 0;
06358   struct net_device * dev;
06359 
06360   if ((dev_name) && (strlen(dev_name)))
06361     {
06362       dev = dev_get_by_name(dev_name);  
06363       if (dev)
06364         {
06365           struct ath_softc *sc = dev->priv;
06366           struct ieee80211com *ic = &sc->sc_ic;
06367 #ifdef MADWIFI_NG
06368           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06369           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06370 #else
06371           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06372 #endif
06373           ATH_LOCK(sc);
06374           metric = ic_stats->is_crypto_wep;
06375           ATH_UNLOCK(sc);
06376           dev_put(dev);
06377           return metric;
06378         }
06379       (*code_err) = DEV_NOT_FOUND;
06380       printk ("Device interface not found\n");
06381       return 0;
06382     }
06383   (*code_err) = DEV_NAME_NOT_DEFINED; 
06384   printk("Device interface name not specified !!!\n");
06385   return 0;
06386 }
06387 XIAN_EXPORT_SYMBOL(get_is_crypto_wep);
06388 
06389 
06390 /*************************************************************************************************************/
06397 u_int32_t
06398 get_is_crypto_setkey_cipher(char * dev_name,
06399                             unsigned int * code_err)
06400 {
06401   u_int32_t metric = 0;
06402   struct net_device * dev;
06403 
06404   if ((dev_name) && (strlen(dev_name)))
06405     {
06406       dev = dev_get_by_name(dev_name);  
06407       if (dev)
06408         {
06409           struct ath_softc *sc = dev->priv;
06410           struct ieee80211com *ic = &sc->sc_ic;
06411 #ifdef MADWIFI_NG
06412           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06413           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06414 #else
06415           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06416 #endif
06417           ATH_LOCK(sc);
06418           metric = ic_stats->is_crypto_setkey_cipher;
06419           ATH_UNLOCK(sc);
06420           dev_put(dev);
06421           return metric;
06422         }
06423       (*code_err) = DEV_NOT_FOUND;
06424       printk ("Device interface not found\n");
06425       return 0;
06426     }
06427   (*code_err) = DEV_NAME_NOT_DEFINED; 
06428   printk("Device interface name not specified !!!\n");
06429   return 0;
06430 }
06431 XIAN_EXPORT_SYMBOL(get_is_crypto_setkey_cipher);
06432 
06433 
06434 /*************************************************************************************************************/
06441 u_int32_t
06442 get_is_crypto_setkey_nokey(char * dev_name,
06443                            unsigned int * code_err)
06444 {
06445   u_int32_t metric = 0;
06446   struct net_device * dev;
06447 
06448   if ((dev_name) && (strlen(dev_name)))
06449     {
06450       dev = dev_get_by_name(dev_name);  
06451       if (dev)
06452         {
06453           struct ath_softc *sc = dev->priv;
06454           struct ieee80211com *ic = &sc->sc_ic;
06455 #ifdef MADWIFI_NG
06456           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06457           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06458 #else
06459           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06460 #endif
06461           ATH_LOCK(sc);
06462           metric = ic_stats->is_crypto_setkey_nokey;
06463           ATH_UNLOCK(sc);
06464           dev_put(dev);
06465           return metric;
06466         }
06467       (*code_err) = DEV_NOT_FOUND;
06468       printk ("Device interface not found\n");
06469       return 0;
06470     }
06471   (*code_err) = DEV_NAME_NOT_DEFINED; 
06472   printk("Device interface name not specified !!!\n");
06473   return 0;
06474 }
06475 XIAN_EXPORT_SYMBOL(get_is_crypto_setkey_nokey);
06476 
06477 
06478 /*************************************************************************************************************/
06485 u_int32_t
06486 get_is_crypto_delkey(char * dev_name,
06487                      unsigned int * code_err)
06488 {
06489   u_int32_t metric = 0;
06490   struct net_device * dev;
06491 
06492   if ((dev_name) && (strlen(dev_name)))
06493     {
06494       dev = dev_get_by_name(dev_name);  
06495       if (dev)
06496         {
06497           struct ath_softc *sc = dev->priv;
06498           struct ieee80211com *ic = &sc->sc_ic;
06499 #ifdef MADWIFI_NG
06500           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06501           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06502 #else
06503           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06504 #endif
06505           ATH_LOCK(sc);
06506           metric = ic_stats->is_crypto_delkey;
06507           ATH_UNLOCK(sc);
06508           dev_put(dev);
06509           return metric;
06510         }
06511       (*code_err) = DEV_NOT_FOUND;
06512       printk ("Device interface not found\n");
06513       return 0;
06514     }
06515   (*code_err) = DEV_NAME_NOT_DEFINED; 
06516   printk("Device interface name not specified !!!\n");
06517   return 0;
06518 }
06519 XIAN_EXPORT_SYMBOL(get_is_crypto_delkey);
06520 
06521 
06522 /*************************************************************************************************************/
06529 u_int32_t
06530 get_is_crypto_badcipher(char * dev_name,
06531                         unsigned int * code_err)
06532 {
06533   u_int32_t metric = 0;
06534   struct net_device * dev;
06535 
06536   if ((dev_name) && (strlen(dev_name)))
06537     {
06538       dev = dev_get_by_name(dev_name);  
06539       if (dev)
06540         {
06541           struct ath_softc *sc = dev->priv;
06542           struct ieee80211com *ic = &sc->sc_ic;
06543 #ifdef MADWIFI_NG
06544           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06545           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06546 #else
06547           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06548 #endif
06549           ATH_LOCK(sc);
06550           metric = ic_stats->is_crypto_badcipher;
06551           ATH_UNLOCK(sc);
06552           dev_put(dev);
06553           return metric;
06554         }
06555       (*code_err) = DEV_NOT_FOUND;
06556       printk ("Device interface not found\n");
06557       return 0;
06558     }
06559   (*code_err) = DEV_NAME_NOT_DEFINED; 
06560   printk("Device interface name not specified !!!\n");
06561   return 0;
06562 }
06563 XIAN_EXPORT_SYMBOL(get_is_crypto_badcipher);
06564 
06565 
06566 /*************************************************************************************************************/
06573 u_int32_t
06574 get_is_crypto_nocipher(char * dev_name,
06575                        unsigned int * code_err)
06576 {
06577   u_int32_t metric = 0;
06578   struct net_device * dev;
06579 
06580   if ((dev_name) && (strlen(dev_name)))
06581     {
06582       dev = dev_get_by_name(dev_name);  
06583       if (dev)
06584         {
06585           struct ath_softc *sc = dev->priv;
06586           struct ieee80211com *ic = &sc->sc_ic;
06587 #ifdef MADWIFI_NG
06588           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06589           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06590 #else
06591           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06592 #endif
06593           ATH_LOCK(sc);
06594           metric = ic_stats->is_crypto_nocipher;
06595           ATH_UNLOCK(sc);
06596           dev_put(dev);
06597           return metric;
06598         }
06599       (*code_err) = DEV_NOT_FOUND;
06600       printk ("Device interface not found\n");
06601       return 0;
06602     }
06603   (*code_err) = DEV_NAME_NOT_DEFINED; 
06604   printk("Device interface name not specified !!!\n");
06605   return 0;
06606 }
06607 XIAN_EXPORT_SYMBOL(get_is_crypto_nocipher);
06608 
06609 
06610 /*************************************************************************************************************/
06617 u_int32_t
06618 get_is_crypto_attachfail(char * dev_name,
06619                          unsigned int * code_err)
06620 {
06621   u_int32_t metric = 0;
06622   struct net_device * dev;
06623 
06624   if ((dev_name) && (strlen(dev_name)))
06625     {
06626       dev = dev_get_by_name(dev_name);  
06627       if (dev)
06628         {
06629           struct ath_softc *sc = dev->priv;
06630           struct ieee80211com *ic = &sc->sc_ic;
06631 #ifdef MADWIFI_NG
06632           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06633           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06634 #else
06635           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06636 #endif
06637           ATH_LOCK(sc);
06638           metric = ic_stats->is_crypto_attachfail;
06639           ATH_UNLOCK(sc);
06640           dev_put(dev);
06641           return metric;
06642         }
06643       (*code_err) = DEV_NOT_FOUND;
06644       printk ("Device interface not found\n");
06645       return 0;
06646     }
06647   (*code_err) = DEV_NAME_NOT_DEFINED; 
06648   printk("Device interface name not specified !!!\n");
06649   return 0;
06650 }
06651 XIAN_EXPORT_SYMBOL(get_is_crypto_attachfail);
06652 
06653 
06654 /*************************************************************************************************************/
06661 u_int32_t
06662 get_is_crypto_swfallback(char * dev_name,
06663                          unsigned int * code_err)
06664 {
06665   u_int32_t metric = 0;
06666   struct net_device * dev;
06667 
06668   if ((dev_name) && (strlen(dev_name)))
06669     {
06670       dev = dev_get_by_name(dev_name);  
06671       if (dev)
06672         {
06673           struct ath_softc *sc = dev->priv;
06674           struct ieee80211com *ic = &sc->sc_ic;
06675 #ifdef MADWIFI_NG
06676           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06677           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06678 #else
06679           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06680 #endif
06681           ATH_LOCK(sc);
06682           metric = ic_stats->is_crypto_swfallback;
06683           ATH_UNLOCK(sc);
06684           dev_put(dev);
06685           return metric;
06686         }
06687       (*code_err) = DEV_NOT_FOUND;
06688       printk ("Device interface not found\n");
06689       return 0;
06690     }
06691   (*code_err) = DEV_NAME_NOT_DEFINED; 
06692   printk("Device interface name not specified !!!\n");
06693   return 0;
06694 }
06695 XIAN_EXPORT_SYMBOL(get_is_crypto_swfallback);
06696 
06697 
06698 /*************************************************************************************************************/
06705 u_int32_t
06706 get_is_crypto_keyfail(char * dev_name,
06707                       unsigned int * code_err)
06708 {
06709   u_int32_t metric = 0;
06710   struct net_device * dev;
06711 
06712   if ((dev_name) && (strlen(dev_name)))
06713     {
06714       dev = dev_get_by_name(dev_name);  
06715       if (dev)
06716         {
06717           struct ath_softc *sc = dev->priv;
06718           struct ieee80211com *ic = &sc->sc_ic;
06719 #ifdef MADWIFI_NG
06720           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06721           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06722 #else
06723           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06724 #endif
06725           ATH_LOCK(sc);
06726           metric = ic_stats->is_crypto_keyfail;
06727           ATH_UNLOCK(sc);
06728           dev_put(dev);
06729           return metric;
06730         }
06731       (*code_err) = DEV_NOT_FOUND;
06732       printk ("Device interface not found\n");
06733       return 0;
06734     }
06735   (*code_err) = DEV_NAME_NOT_DEFINED; 
06736   printk("Device interface name not specified !!!\n");
06737   return 0;
06738 }
06739 XIAN_EXPORT_SYMBOL(get_is_crypto_keyfail);
06740 
06741 
06742 /*************************************************************************************************************/
06749 u_int32_t
06750 get_is_crypto_enmicfail(char * dev_name,
06751                         unsigned int * code_err)
06752 {
06753   u_int32_t metric = 0;
06754   struct net_device * dev;
06755 
06756   if ((dev_name) && (strlen(dev_name)))
06757     {
06758       dev = dev_get_by_name(dev_name);  
06759       if (dev)
06760         {
06761           struct ath_softc *sc = dev->priv;
06762           struct ieee80211com *ic = &sc->sc_ic;
06763 #ifdef MADWIFI_NG
06764           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06765           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06766 #else
06767           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06768 #endif
06769           ATH_LOCK(sc);
06770           metric = ic_stats->is_crypto_enmicfail;
06771           ATH_UNLOCK(sc);
06772           dev_put(dev);
06773           return metric;
06774         }
06775       (*code_err) = DEV_NOT_FOUND;
06776       printk ("Device interface not found\n");
06777       return 0;
06778     }
06779   (*code_err) = DEV_NAME_NOT_DEFINED; 
06780   printk("Device interface name not specified !!!\n");
06781   return 0;
06782 }
06783 XIAN_EXPORT_SYMBOL(get_is_crypto_enmicfail);
06784 
06785 
06786 /*************************************************************************************************************/
06793 u_int32_t
06794 get_is_ibss_capmismatch(char * dev_name,
06795                         unsigned int * code_err)
06796 {
06797   u_int32_t metric = 0;
06798   struct net_device * dev;
06799 
06800   if ((dev_name) && (strlen(dev_name)))
06801     {
06802       dev = dev_get_by_name(dev_name);  
06803       if (dev)
06804         {
06805           struct ath_softc *sc = dev->priv;
06806           struct ieee80211com *ic = &sc->sc_ic;
06807 #ifdef MADWIFI_NG
06808           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06809           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06810 #else
06811           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06812 #endif
06813           ATH_LOCK(sc);
06814           metric = ic_stats->is_ibss_capmismatch;
06815           ATH_UNLOCK(sc);
06816           dev_put(dev);
06817           return metric;
06818         }
06819       (*code_err) = DEV_NOT_FOUND;
06820       printk ("Device interface not found\n");
06821       return 0;
06822     }
06823   (*code_err) = DEV_NAME_NOT_DEFINED; 
06824   printk("Device interface name not specified !!!\n");
06825   return 0;
06826 }
06827 XIAN_EXPORT_SYMBOL(get_is_ibss_capmismatch);
06828 
06829 
06830 /*************************************************************************************************************/
06837 u_int32_t
06838 get_is_ibss_norate(char * dev_name,
06839                      unsigned int * code_err)
06840 {
06841   u_int32_t metric = 0;
06842   struct net_device * dev;
06843 
06844   if ((dev_name) && (strlen(dev_name)))
06845     {
06846       dev = dev_get_by_name(dev_name);  
06847       if (dev)
06848         {
06849           struct ath_softc *sc = dev->priv;
06850           struct ieee80211com *ic = &sc->sc_ic;
06851 #ifdef MADWIFI_NG
06852           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06853           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06854 #else
06855           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06856 #endif
06857           ATH_LOCK(sc);
06858           metric = ic_stats->is_ibss_norate;
06859           ATH_UNLOCK(sc);
06860           dev_put(dev);
06861           return metric;
06862         }
06863       (*code_err) = DEV_NOT_FOUND;
06864       printk ("Device interface not found\n");
06865       return 0;
06866     }
06867   (*code_err) = DEV_NAME_NOT_DEFINED; 
06868   printk("Device interface name not specified !!!\n");
06869   return 0;
06870 }
06871 XIAN_EXPORT_SYMBOL(get_is_ibss_norate);
06872 
06873 
06874 /*************************************************************************************************************/
06881 u_int32_t
06882 get_is_ps_unassoc(char * dev_name,
06883                   unsigned int * code_err)
06884 {
06885   u_int32_t metric = 0;
06886   struct net_device * dev;
06887 
06888   if ((dev_name) && (strlen(dev_name)))
06889     {
06890       dev = dev_get_by_name(dev_name);  
06891       if (dev)
06892         {
06893           struct ath_softc *sc = dev->priv;
06894           struct ieee80211com *ic = &sc->sc_ic;
06895 #ifdef MADWIFI_NG
06896           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06897           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06898 #else
06899           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06900 #endif
06901           ATH_LOCK(sc);
06902           metric = ic_stats->is_ps_unassoc;
06903           ATH_UNLOCK(sc);
06904           dev_put(dev);
06905           return metric;
06906         }
06907       (*code_err) = DEV_NOT_FOUND;
06908       printk ("Device interface not found\n");
06909       return 0;
06910     }
06911   (*code_err) = DEV_NAME_NOT_DEFINED; 
06912   printk("Device interface name not specified !!!\n");
06913   return 0;
06914 }
06915 XIAN_EXPORT_SYMBOL(get_is_ps_unassoc);
06916 
06917 
06918 /*************************************************************************************************************/
06925 u_int32_t
06926 get_is_ps_badaid(char * dev_name,
06927                  unsigned int * code_err)
06928 {
06929   u_int32_t metric = 0;
06930   struct net_device * dev;
06931 
06932   if ((dev_name) && (strlen(dev_name)))
06933     {
06934       dev = dev_get_by_name(dev_name);  
06935       if (dev)
06936         {
06937           struct ath_softc *sc = dev->priv;
06938           struct ieee80211com *ic = &sc->sc_ic;
06939 #ifdef MADWIFI_NG
06940           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06941           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06942 #else
06943           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06944 #endif
06945           ATH_LOCK(sc);
06946           metric = ic_stats->is_ps_badaid;
06947           ATH_UNLOCK(sc);
06948           dev_put(dev);
06949           return metric;
06950         }
06951       (*code_err) = DEV_NOT_FOUND;
06952       printk ("Device interface not found\n");
06953       return 0;
06954     }
06955   (*code_err) = DEV_NAME_NOT_DEFINED; 
06956   printk("Device interface name not specified !!!\n");
06957   return 0;
06958 }
06959 XIAN_EXPORT_SYMBOL(get_is_ps_badaid);
06960 
06961 /*************************************************************************************************************/
06968 u_int32_t
06969 get_is_ps_qempty(char * dev_name,
06970                  unsigned int * code_err)
06971 {
06972   u_int32_t metric = 0;
06973   struct net_device * dev;
06974 
06975   if ((dev_name) && (strlen(dev_name)))
06976     {
06977       dev = dev_get_by_name(dev_name);  
06978       if (dev)
06979         {
06980           struct ath_softc *sc = dev->priv;
06981           struct ieee80211com *ic = &sc->sc_ic;
06982 #ifdef MADWIFI_NG
06983           struct ieee80211vap * vap = TAILQ_FIRST(&ic->ic_vaps);
06984           struct ieee80211_stats * ic_stats = &vap->iv_stats;
06985 #else
06986           struct ieee80211_stats * ic_stats = &ic->ic_stats;
06987 #endif
06988           ATH_LOCK(sc);
06989           metric = ic_stats->is_ps_qempty;
06990           ATH_UNLOCK(sc);
06991           dev_put(dev);
06992           return metric;
06993         }
06994       (*code_err) = DEV_NOT_FOUND;
06995       printk ("Device interface not found\n");
06996       return 0;
06997     }
06998   (*code_err) = DEV_NAME_NOT_DEFINED; 
06999   printk("Device interface name not specified !!!\n");
07000   return 0;
07001 }
07002 XIAN_EXPORT_SYMBOL(get_is_ps_qempty);
07003 
07004 
07005 /*************************************************************************************************************/
07012 u_int8_t *
07013 get_node_macadd(char * dev_name)
07014 {
07015   struct net_device * dev;  
07016 
07017   if (is_dev_available(dev_name))
07018   {
07019       dev = dev_get_by_name(dev_name);
07020       return  (dev->dev_addr);
07021   }
07022   return NULL;
07023   
07024 }
07025 XIAN_EXPORT_SYMBOL(get_node_macadd);
07026 
07027 
07028 /******************************************************************************************************************************/
07035 void get_node_example (char * name)
07036 {
07037   struct net_device * dev;
07038   struct ath_softc * sc;
07039   struct ieee80211com * ic;
07040   struct ieee80211_node_table * nt;
07041   struct ieee80211_node * ni;
07042 
07043   if (is_dev_available (name))
07044     {
07045       dev = dev_get_by_name(name);
07046       printk ("Le nom de l'interface est : %s\n", dev->name);
07047       sc = dev->priv;
07048       ic = &sc->sc_ic;
07049       nt = &ic->ic_sta;
07050       
07051       printk ("Mon addresse MAC: %s\n", ether_sprintf (dev->dev_addr));
07052       
07053       ATH_LOCK(sc);
07054       IEEE80211_NODE_LOCK(nt);
07055       TAILQ_FOREACH(ni, &nt->nt_node, ni_list)
07056         {
07057           /*
07058             if (!(IEEE80211_ADDR_EQ(dev->dev_addr,ni->ni_macaddr)))
07059             {
07060           */
07061           printk("\n");
07062           printk("*****\n");
07063           printk("MAC: %s \n",ether_sprintf(ni->ni_macaddr));
07064           printk("Assoc ID: %u \n",ni->ni_associd);
07065           printk("Signal Quality: %u \n", ni->ni_rssi);
07066           printk("Transmission Rate %u\n", (ni->ni_rates.rs_rates[ni->ni_txrate] & 0x7f / 2));
07067           printk("*****\n");
07068           //}
07069         }
07070       IEEE80211_NODE_UNLOCK(nt);
07071       ATH_UNLOCK(sc);
07072     }
07073   return;
07074 }
07075 XIAN_EXPORT_SYMBOL(get_node_example);
07076 
07077 /**************************************************************************************************************************************/
07083 int
07084 is_hexa (char c)
07085 {
07086   return ((c == '0') || 
07087           (c == '1') || 
07088           (c == '2') || 
07089           (c == '3') || 
07090           (c == '4') || 
07091           (c == '5') || 
07092           (c == '6') || 
07093           (c == '7') || 
07094           (c == '8') || 
07095           (c == '9') || 
07096           (c == 'A') || 
07097           (c == 'a') ||
07098           (c == 'B') ||
07099           (c == 'b') ||
07100           (c == 'C') ||
07101           (c == 'c') ||
07102           (c == 'D') ||
07103           (c == 'd') ||
07104           (c == 'E') ||
07105           (c == 'e') ||
07106           (c == 'F') ||
07107           (c == 'f'));
07108 }
07109 
07110 /**************************************************************************************************************************************/
07118 int
07119 is_mac_addr_valid (char * mac_addr)
07120 {
07121   if (mac_addr) {
07122     if (strlen (mac_addr) == ((IEEE80211_MAC_ADDR_LEN)))
07123       return (is_hexa(mac_addr[0]) && 
07124               is_hexa(mac_addr[1]) && 
07125               (mac_addr[2] == ':') && 
07126               is_hexa(mac_addr[3]) &&
07127               is_hexa(mac_addr[4]) &&
07128               (mac_addr[5] == ':') &&
07129               is_hexa(mac_addr[6]) &&
07130               is_hexa(mac_addr[7]) &&
07131               (mac_addr[8] == ':') &&
07132               is_hexa(mac_addr[9]) &&
07133               is_hexa(mac_addr[10]) &&
07134               (mac_addr[11] == ':') &&
07135               is_hexa(mac_addr[12]) &&
07136               is_hexa(mac_addr[13]) &&
07137               (mac_addr[14] == ':') &&
07138               is_hexa(mac_addr[15]) &&
07139               is_hexa(mac_addr[16])
07140               );
07141   }
07142   return 0;
07143 }
07144 
07145 /**************************************************************************************************************************************/
07156 void
07157 convert_mac_addr (char * mac_addr, unsigned char * res, unsigned int * code_err)
07158 {
07159   char s[2];
07160   if (is_mac_addr_valid (mac_addr))
07161   {
07162     int i, y;
07163     y = 0;
07164     for (i=0;i<IEEE80211_MAC_ADDR_LEN;i = i+3)
07165     {
07166       s[0] = mac_addr[i];
07167       s[1] = mac_addr[i+1];
07168       res[y] = simple_strtoul (s, NULL, 16);
07169       y++;
07170     }
07171     return;
07172   }  
07173   (*code_err) = INVALID_MAC_ADDR;
07174   return;
07175 }
07176 
07177 
07178 
07179 /*********************************************************************************************************
07180  *  LOAD AND UNLOAD KERNEL MODULE FUNCTIONS
07181  ********************************************************************************************************/
07182 
07183 
07184 /*
07185  *  Load Module. It is in this function that must be implemented the content functionalities of the module
07186  *  No input and output params
07187  */
07188 
07189 int init_m(void)
07190 {
07191 
07192   printk(KERN_ALERT "Init XIAN KSI module\n");
07193   return 0;
07194 }
07195 
07196 /*
07197  *  Unload  module
07198  *  No input and output params
07199  */
07200 
07201 void exit_m(void)
07202 {
07203   printk(KERN_ALERT "Unload XIAN KSI module\n");
07204 }
07205 
07206 
07207 module_init(init_m);
07208 module_exit(exit_m);
07209 
07210 MODULE_DESCRIPTION("XIAN - Kernel Space XIAN Interface - KSI");
07211 MODULE_LICENSE("GPL");
Generated on Mon Jan 21 12:31:46 2008 for XIAN by  doxygen 1.5.3