if_ath_ioctl.c

Go to the documentation of this file.

/*
 * Copyright (c) 2004 Massachusetts Institute of Technology
 * John Bicket
 */

/*
 * Originally derived from the following.
 */

/*
 * Copyright (c) 2002-2004 Sam Leffler, Errno Consulting
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
 *    redistribution must be conditioned upon including a substantially
 *    similar Disclaimer requirement for further binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGES.
 *
 * $Id: if_ath_ioctl.c,v 1.13 2005/01/10 06:40:06 jbicket Exp $
 */

/*
 * Wireless extensions support for 802.11 common code.
 */
#ifndef EXPORT_SYMTAB
#define EXPORT_SYMTAB
#endif

#include <linux/config.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/utsname.h>
#include <linux/if_arp.h>               /* XXX for ARPHRD_ETHER */

#if AH_BYTE_ORDER == AH_BIG_ENDIAN
#define _OS_REG_WRITE(_ah, _reg, _val) do {                                 \
        if ( (_reg) >= 0x4000 && (_reg) < 0x5000)                           \
                *((volatile u_int32_t *)((_ah)->ah_sh + (_reg))) =          \
                        __bswap32((_val));                                  \
        else                                                                \
                *((volatile u_int32_t *)((_ah)->ah_sh + (_reg))) = (_val);  \
} while (0)
#define _OS_REG_READ(_ah, _reg) \
        (((_reg) >= 0x4000 && (_reg) < 0x5000) ? \
                __bswap32(*((volatile u_int32_t *)((_ah)->ah_sh + (_reg)))) : \
                *((volatile u_int32_t *)((_ah)->ah_sh + (_reg))))
#else /* AH_LITTLE_ENDIAN */
#define _OS_REG_WRITE(_ah, _reg, _val) do { \
        *((volatile u_int32_t *)((_ah)->ah_sh + (_reg))) = (_val); \
} while (0)
#define _OS_REG_READ(_ah, _reg) \
        *((volatile u_int32_t *)((_ah)->ah_sh + (_reg)))
#endif /* AH_BYTE_ORDER */

#if defined(AH_DEBUG) || defined(AH_REGOPS_FUNC) || defined(AH_DEBUG_ALQ)
/* use functions to do register operations */
#define OS_REG_WRITE(_ah, _reg, _val)   ath_hal_reg_write(_ah, _reg, _val)
#define OS_REG_READ(_ah, _reg)          ath_hal_reg_read(_ah, _reg)

extern  void __ahdecl ath_hal_reg_write(struct ath_hal *ah,
                u_int reg, u_int32_t val);
extern  u_int32_t __ahdecl ath_hal_reg_read(struct ath_hal *ah, u_int reg);
#else
/* inline register operations */
#define OS_REG_WRITE(_ah, _reg, _val)   _OS_REG_WRITE(_ah, _reg, _val)
#define OS_REG_READ(_ah, _reg)          _OS_REG_READ(_ah, _reg)
#endif /* AH_DEBUG || AH_REGFUNC || AH_DEBUG_ALQ */

#include <net/iw_handler.h>

#include <asm/uaccess.h>

#include "if_athvar.h"
#ifdef CONFIG_NET_WIRELESS

#define IS_UP(_dev) \
        (((_dev)->flags & (IFF_RUNNING|IFF_UP)) == (IFF_RUNNING|IFF_UP))


struct iw_statistics *
ath_iw_getstats(struct net_device *dev)
{
#define NZ(x)   ((x) ? (x) : 1)
        struct ath_softc *sc = dev->priv;

        sc->ic_iwstats.status = 0;
        sc->ic_iwstats.discard.nwid = 0;
        sc->ic_iwstats.discard.code = 0;
        sc->ic_iwstats.discard.fragment = 0;
        sc->ic_iwstats.discard.retries = 0;
        sc->ic_iwstats.discard.misc = 0;

        sc->ic_iwstats.miss.beacon = 0;

        return &sc->ic_iwstats;
#undef NZ
}


int
ath_ioctl_giwname(struct net_device *dev,
                   struct iw_request_info *info,
                   char *name, char *extra)
{
  struct ath_softc *sc = dev->priv;
  switch (sc->ic_curmode) {
  case IEEE80211_MODE_11A:
    strncpy(name, "IEEE 802.11a", IFNAMSIZ);
    break;
  case IEEE80211_MODE_11B:
    strncpy(name, "IEEE 802.11b", IFNAMSIZ);
    break;
  case IEEE80211_MODE_11G:
    strncpy(name, "IEEE 802.11g", IFNAMSIZ);
    break;
  case IEEE80211_MODE_TURBO:
    strncpy(name, "IEEE 802.11-TURBO", IFNAMSIZ);
    break;
  default:
    strncpy(name, "IEEE 802.11", IFNAMSIZ);
    break;
  }    

  return 0;
}

/*
 * Convert MHz frequency to IEEE channel number.
 */
u_int
mhz2ieee(u_int freq, u_int flags)
{
        if (flags & IEEE80211_CHAN_2GHZ) {      /* 2GHz band */
                if (freq == 2484)
                        return 14;
                if (freq < 2484)
                        return (freq - 2407) / 5;
                else
                        return 15 + ((freq - 2512) / 20);
        } else if (flags & IEEE80211_CHAN_5GHZ) {       /* 5Ghz band */
                return (freq - 5000) / 5;
        } else {                                /* either, guess */
                if (freq == 2484)
                        return 14;
                if (freq < 2484)
                        return (freq - 2407) / 5;
                if (freq < 5000)
                        return 15 + ((freq - 2512) / 20);
                return (freq - 5000) / 5;
        }
}


int
ath_ioctl_siwfreq(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_freq *freq, char *extra)
{
  struct ath_softc *sc = dev->priv;
  struct ieee80211channel *c;
  int i;
  
  if (freq->e > 1)
    return -EINVAL;
  if (freq->e == 1)
    i = mhz2ieee(freq->m / 100000, 0);
  else
    i = freq->m;
  if (i > IEEE80211_CHAN_MAX || isclr(sc->ic_chan_avail, i)) {
    printk ("channel not active %d\n", i);
    return -EINVAL;
  }
  c = &sc->ic_channels[i];
  if (c == sc->current_channel) /* no change, just return */
    return 0;
  sc->current_channel = c;

  return IS_UP(dev) ? -(dev->open)(dev) : 0;

}
int
ath_ioctl_giwfreq(struct net_device *dev,
                                struct iw_request_info *info,
                                struct iw_freq *freq, char *extra)
{
        struct ath_softc *sc = dev->priv;

        if (!sc || !sc->current_channel)
                return -EINVAL;

        freq->m = sc->current_channel->ic_freq * 100000;
        freq->e = 1;

        return 0;
}


int
ath_ioctl_giwessid(struct net_device *dev,
                                struct iw_request_info *info,
                  struct iw_point *data, char *essid) {
  struct ath_softc *sc = dev->priv;
  
  data->flags = 1;              /* active */
  if (data->length > sc->ic_esslen) {
    data->length = sc->ic_esslen;
    memcpy(essid, sc->ic_essid, data->length);
  }
  
  return 0;

}

int
ath_ioctl_siwessid(struct net_device *dev,
                                struct iw_request_info *info,
                  struct iw_point *data, char *essid) {

  struct ath_softc *sc = dev->priv;
  
  if (data->flags == 0) {               /* ANY */
    memset(sc->ic_essid, 0, IEEE80211_NWID_LEN);
    sc->ic_esslen = 0;
  } else {
    int i, len;
    
    len = IW_ESSID_MAX_SIZE;
    if (len > IEEE80211_NWID_LEN)
      len = IEEE80211_NWID_LEN;
    memcpy(sc->ic_essid, essid, len);
    /* XXX: scan for \0 to calculate the length */
    for (i = 0; i < len && sc->ic_essid[i] != '\0'; i++)
      ;
    sc->ic_esslen = i;
  }
  return IS_UP(dev) ? -(dev->open)(dev) : 0;
  
}


int
ath_ioctl_siwmode(struct net_device *dev,
                        struct iw_request_info *info,
                        __u32 *mode, char *extra)
{
  struct ath_softc *sc = dev->priv;

  enum ieee80211_opmode newmode = IW_MODE_INFRA;
  switch (*mode) {
  case IW_MODE_INFRA:
    /* default ? */
    newmode = IEEE80211_M_STA;
    break;
  case IW_MODE_ADHOC:
    newmode = IEEE80211_M_IBSS;
    break;
  case IW_MODE_MASTER:
    newmode = IEEE80211_M_HOSTAP;
    break;
  }
  *mode = IW_MODE_ADHOC;

  if (newmode != sc->ic_opmode) {
    sc->ic_opmode = newmode;
    return IS_UP(dev) ? -(dev->open)(dev) : 0;
  }


  return 0;
}

int
ath_ioctl_giwmode(struct net_device *dev,
                        struct iw_request_info *info,
                        __u32 *mode, char *extra)
{
  struct ath_softc *sc = dev->priv;

  switch (sc->ic_opmode) {
  case IEEE80211_M_STA:
    *mode = IW_MODE_INFRA;
    break;
  case IEEE80211_M_IBSS:
    *mode = IW_MODE_ADHOC;
    break;
  case IEEE80211_M_HOSTAP:
    *mode = IW_MODE_MASTER;
    break;
  case IEEE80211_M_AHDEMO:
    /* does this exist ? */
    *mode = IW_MODE_ADHOC;
  case IEEE80211_M_MONITOR:
    /* XXX this is wrong */
    *mode = IW_MODE_ADHOC;
    break;
  }
  return 0;
}


int
ath_ioctl_siwsens(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *sens, char *extra)
{
        return 0;
}

int
ath_ioctl_giwsens(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *sens, char *extra)
{
        sens->value = 0;
        sens->fixed = 1;

        return 0;
}

int
ath_ioctl_siwrate(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rrq, char *extra)
{
  struct ath_softc *sc = dev->priv;
  int dot11Rate = 2 * (rrq->value / 1000000);
  int index = sc->sc_rixmap[dot11Rate & IEEE80211_RATE_VAL];
  
  const HAL_RATE_TABLE *rt = sc->sc_rates[sc->ic_curmode];
  KASSERT(rt != NULL, ("no h/w rate set for phy mode %u", mode));
  if (index >= 0 && index < rt->rateCount && rt->info[index].valid) {
    sc->ic_fixed_rate = dot11Rate;
    return 0;
  }

  return -EINVAL;

}

int
ath_ioctl_giwrate(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rrq, char *extra)
{
  struct ath_softc *sc = dev->priv;

  int dot11Rate = sc->ic_fixed_rate;
  int index = sc->sc_rixmap[dot11Rate & IEEE80211_RATE_VAL];
  int rate = 0;

  const HAL_RATE_TABLE *rt = sc->sc_rates[sc->ic_curmode];
  KASSERT(rt != NULL, ("no h/w rate set for phy mode %u", mode));

  if (index >= 0 && index < rt->rateCount && rt->info[index].valid) {
    rate = dot11Rate / 2;
  }

  rrq->value = 1000000 * rate;

  return 0;
}

int
ath_ioctl_siwnickn(struct net_device *dev,
                         struct iw_request_info *info,
                         struct iw_point *data, char *nickname)
{
        struct ath_softc *sc = dev->priv;

        if (data->length > IEEE80211_NWID_LEN)
                return -EINVAL;

        memset(sc->ic_nickname, 0, IEEE80211_NWID_LEN);
        memcpy(sc->ic_nickname, nickname, data->length);
        sc->ic_nicknamelen = data->length;

        return 0;
}

int
ath_ioctl_giwnickn(struct net_device *dev,
                         struct iw_request_info *info,
                         struct iw_point *data, char *nickname)
{
        struct ath_softc *sc = dev->priv;

        if (data->length > sc->ic_nicknamelen + 1)
                data->length = sc->ic_nicknamelen + 1;
        if (data->length > 0) {
                memcpy(nickname, sc->ic_nickname, data->length-1);
                nickname[data->length-1] = '\0';
        }
        return 0;
}

int
ath_ioctl_siwrts(struct net_device *dev,
                       struct iw_request_info *info,
                       struct iw_param *rts, char *extra)
{
  struct ath_softc *sc = dev->priv;
  u16 val;
  
  if (rts->disabled) {
    val = IEEE80211_RTS_MAX;
  } else if (IEEE80211_RTS_MIN > rts->value || rts->value > IEEE80211_RTS_MAX) {
    return -EINVAL;
  } else {
    val = rts->value;
  }

  if (val != sc->ic_rts_threshold) {
    sc->ic_rts_threshold = val;
  }
  return -EINVAL;
}

int
ath_ioctl_giwrts(struct net_device *dev,
                       struct iw_request_info *info,
                       struct iw_param *rts, char *extra)
{
  struct ath_softc *sc = dev->priv;
  rts->value = sc->ic_rts_threshold;
  rts->disabled = (rts->value == IEEE80211_RTS_MAX);
  rts->fixed = 1;

  return 0;
}

int
ath_ioctl_siwfrag(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rts, char *extra)
{
  return 0;
}

int
ath_ioctl_giwfrag(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rts, char *extra)
{
        rts->value = 2346;
        rts->disabled = (rts->value == 2346);
        rts->fixed = 1;

        return 0;
}

int
ath_ioctl_siwap(struct net_device *dev,
                      struct iw_request_info *info,
                      struct sockaddr *ap_addr, char *extra)
{
        struct ath_softc *sc = dev->priv;

        
        IEEE80211_ADDR_COPY(sc->bssid, &ap_addr->sa_data);
        /* looks like a zero address disables */
        return 0;
}

int
ath_ioctl_giwap(struct net_device *dev,
                      struct iw_request_info *info,
                      struct sockaddr *ap_addr, char *extra)
{
        struct ath_softc *sc = dev->priv;

        IEEE80211_ADDR_COPY(&ap_addr->sa_data, sc->bssid);
        ap_addr->sa_family = ARPHRD_ETHER;
        return 0;
}

int
ath_ioctl_siwretry(struct net_device *dev,
                                 struct iw_request_info *info,
                                 struct iw_param *rrq, char *extra)
{
  return 0;
}

int
ath_ioctl_giwretry(struct net_device *dev,
                                 struct iw_request_info *info,
                                 struct iw_param *rrq, char *extra)
{

  switch (rrq->flags & IW_RETRY_TYPE) {
  case IW_RETRY_LIFETIME:
    rrq->flags = IW_RETRY_LIFETIME;
    rrq->value = 1 * 1024;
    break;
  case IW_RETRY_LIMIT:
    rrq->flags = IW_RETRY_LIMIT;
    switch (rrq->flags & IW_RETRY_MODIFIER) {
    case IW_RETRY_MIN:
      rrq->flags |= IW_RETRY_MAX;
      rrq->value = 8;
      break;
    case IW_RETRY_MAX:
      rrq->flags |= IW_RETRY_MAX;
      rrq->value = 8;
      break;
    }
  }
  return 0;

}

int
ath_ioctl_siwtxpow(struct net_device *dev,
                         struct iw_request_info *info,
                         struct iw_param *rrq, char *extra)
{
  return 0;
}

int
ath_ioctl_giwtxpow(struct net_device *dev,
                         struct iw_request_info *info,
                         struct iw_param *rrq, char *extra)
{

        rrq->disabled = 1;
        rrq->fixed = 1;
        rrq->flags = IW_TXPOW_DBM;
        rrq->value = 0;
        return 0;
}

int
ath_ioctl_siwpower(struct net_device *dev,
                         struct iw_request_info *info,
                         struct iw_param *wrq, char *extra)
{
        return 0;
}

int
ath_ioctl_giwpower(struct net_device *dev,
                        struct iw_request_info *info,
                        struct iw_param *rrq, char *extra)
{
  rrq->disabled = 1;
  return 0;
}

static int
ath_ioctl_setparam(struct net_device *dev, struct iw_request_info *info,
                         void *w, char *extra)
{
  //struct ath_softc *sc = dev->priv;
  int *i = (int *) extra;
  int param = i[0];
  //int value = i[1];
  
  switch (param) {
    
  case IEEE80211_PARAM_MODE:
    /* fallthrough */
  default:
    return -EOPNOTSUPP;
  
  }
  return 0;
}

static int
ath_ioctl_getparam(struct net_device *dev, struct iw_request_info *info,
                        void *w, char *extra)
{
  struct ath_softc *sc = dev->priv;
  int *param = (int *) extra;

  switch (param[0]) {
  case IEEE80211_PARAM_MODE:
    param[0] = sc->ic_curmode;
   
  default:
    return -EOPNOTSUPP;
  }
  return 0;
}

int
ath_ioctl_giwrange(struct net_device *dev,
                         struct iw_request_info *info,
                         struct iw_point *data, char *extra)
{
        struct ath_softc *sc = dev->priv;
        struct iw_range *range = (struct iw_range *) extra;
        int i;

        data->length = sizeof(struct iw_range);
        memset(range, 0, sizeof(struct iw_range));

        /* TODO: could fill num_txpower and txpower array with
         * something; however, there are 128 different values.. */

        range->txpower_capa = IW_TXPOW_DBM;

        if (sc->ic_opmode == IEEE80211_M_STA ||
            sc->ic_opmode == IEEE80211_M_IBSS) {
                range->min_pmp = 1 * 1024;
                range->max_pmp = 65535 * 1024;
                range->min_pmt = 1 * 1024;
                range->max_pmt = 1000 * 1024;
                range->pmp_flags = IW_POWER_PERIOD;
                range->pmt_flags = IW_POWER_TIMEOUT;
                range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT |
                        IW_POWER_UNICAST_R | IW_POWER_ALL_R;
        }

        range->we_version_compiled = WIRELESS_EXT;
        range->we_version_source = 13;

        range->retry_capa = IW_RETRY_LIMIT;
        range->retry_flags = IW_RETRY_LIMIT;
        range->min_retry = 0;
        range->max_retry = 255;

        range->num_channels = IEEE80211_CHAN_MAX;       /* XXX */

        range->num_frequency = 0;
        for (i = 0; i <= IEEE80211_CHAN_MAX; i++)
          if (isset(sc->ic_chan_avail, i)) {
                        range->freq[range->num_frequency].i = i;
                        range->freq[range->num_frequency].m =
                                sc->ic_channels[i].ic_freq * 100000;
                        range->freq[range->num_frequency].e = 1;
                        if (++range->num_frequency == IW_MAX_FREQUENCIES)
                                break;
                }

        /* Max quality is max field value minus noise floor */
        range->max_qual.qual  = 0xff - 161;

        /*
         * In order to use dBm measurements, 'level' must be lower
         * than any possible measurement (see iw_print_stats() in
         * wireless tools).  It's unclear how this is meant to be
         * done, but setting zero in these values forces dBm and
         * the actual numbers are not used.
         */
        range->max_qual.level = 0;
        range->max_qual.noise = 0;

        range->sensitivity = 3;

        range->max_encoding_tokens = IEEE80211_WEP_NKID;
        range->num_encoding_sizes = 2;
        range->encoding_size[0] = 5;
        range->encoding_size[1] = 13;


        /* estimated maximum TCP throughput values (bps) */
        range->throughput = 5500000;

        range->min_rts = 0;
        range->max_rts = 2347;
        range->min_frag = 256;
        range->max_frag = 2346;

        return 0;
}

static int ath_ioctl_getreg(struct net_device *dev,
                                     struct iw_request_info *info,
                                     void *wrqu, char *extra)
{
  struct ath_softc *sc = dev->priv;
  uint32_t reg = *((uint32_t *) extra);
  uint32_t *res = (uint32_t *) extra;

  if (reg < 0x4000 || reg > 0x9000) {
    return -EINVAL;
  }
  *res = OS_REG_READ(sc->sc_ah, reg);
  return 0;
}


static int ath_ioctl_setreg(struct net_device *dev,
                             struct iw_request_info *info,
                             void *wrqu, char *extra) 
{
  struct ath_softc *sc = dev->priv;
  int *i = (int *) extra;
  uint32_t reg = *i;
  uint32_t val = *(i + 1);
  
  if (reg < 0x4000 || reg > 0x9000) {
    return -EINVAL;
  }

  OS_REG_WRITE(sc->sc_ah, reg, val);
  return  0;
}

static int ath_ioctl_getrxhdr(struct net_device *dev,
                                     struct iw_request_info *info,
                                     void *wrqu, char *extra)
{
  struct ath_softc *sc = dev->priv;
  uint32_t *res = (uint32_t *) extra;

  switch (sc->dev_type) {
  case ARPHRD_IEEE80211:   *res = 0; break;
  case ARPHRD_IEEE80211_PRISM:   *res = 1; break;
  default: 
    return -EINVAL;
  }
  return 0;
}

static int ath_ioctl_setrxhdr(struct net_device *dev,
                             struct iw_request_info *info,
                             void *wrqu, char *extra) 
{
  struct ath_softc *sc = dev->priv;
  int param = *((int *)wrqu);
  uint32_t type = sc->dev_type;

  switch (param) {
  case 0: type = ARPHRD_IEEE80211;   break;
  case 1: type = ARPHRD_IEEE80211_PRISM;   break;
  default: 
    return -EINVAL;
  }

  if (type == sc->dev_type) {
    return 0;
  }

  sc->dev_type = type;
  return IS_UP(dev) ? -(dev->open)(dev) : 0;
}
                           
/* Structures to export the Wireless Handlers */
static const iw_handler ath_handlers[] = {
        (iw_handler) NULL,                              /* SIOCSIWCOMMIT */
        (iw_handler) ath_ioctl_giwname,         /* SIOCGIWNAME */
        (iw_handler) NULL,                              /* SIOCSIWNWID */
        (iw_handler) NULL,                              /* SIOCGIWNWID */
        (iw_handler) ath_ioctl_siwfreq,         /* SIOCSIWFREQ */
        (iw_handler) ath_ioctl_giwfreq,         /* SIOCGIWFREQ */
        (iw_handler) ath_ioctl_siwmode,         /* SIOCSIWMODE */
        (iw_handler) ath_ioctl_giwmode,         /* SIOCGIWMODE */
        (iw_handler) ath_ioctl_siwsens,         /* SIOCSIWSENS */
        (iw_handler) ath_ioctl_giwsens,         /* SIOCGIWSENS */
        (iw_handler) NULL /* not used */,               /* SIOCSIWRANGE */
        (iw_handler) ath_ioctl_giwrange,                /* SIOCGIWRANGE */
        (iw_handler) NULL /* not used */,               /* SIOCSIWPRIV */
        (iw_handler) NULL /* kernel code */,            /* SIOCGIWPRIV */
        (iw_handler) NULL /* not used */,               /* SIOCSIWSTATS */
        (iw_handler) NULL /* kernel code */,            /* SIOCGIWSTATS */
        (iw_handler) NULL,                              /* SIOCSIWSPY */
        (iw_handler) NULL,                              /* SIOCGIWSPY */
        (iw_handler) NULL,                              /* -- hole -- */
        (iw_handler) NULL,                              /* -- hole -- */
        (iw_handler) ath_ioctl_siwap,           /* SIOCSIWAP */
        (iw_handler) ath_ioctl_giwap,           /* SIOCGIWAP */
        (iw_handler) NULL,                              /* -- hole -- */
        (iw_handler) NULL,                              /* SIOCGIWAPLIST */
        (iw_handler) NULL,                              /* SIOCSIWSCAN */
        (iw_handler) NULL,                              /* SIOCGIWSCAN */
        (iw_handler) ath_ioctl_siwessid,                /* SIOCSIWESSID */
        (iw_handler) ath_ioctl_giwessid,                /* SIOCGIWESSID */
        (iw_handler) ath_ioctl_siwnickn,                /* SIOCSIWNICKN */
        (iw_handler) ath_ioctl_giwnickn,                /* SIOCGIWNICKN */
        (iw_handler) NULL,                              /* -- hole -- */
        (iw_handler) NULL,                              /* -- hole -- */
        (iw_handler) ath_ioctl_siwrate,         /* SIOCSIWRATE */
        (iw_handler) ath_ioctl_giwrate,         /* SIOCGIWRATE */
        (iw_handler) ath_ioctl_siwrts,          /* SIOCSIWRTS */
        (iw_handler) ath_ioctl_giwrts,          /* SIOCGIWRTS */
        (iw_handler) ath_ioctl_siwfrag,         /* SIOCSIWFRAG */
        (iw_handler) ath_ioctl_giwfrag,         /* SIOCGIWFRAG */
        (iw_handler) ath_ioctl_siwtxpow,                /* SIOCSIWTXPOW */
        (iw_handler) ath_ioctl_giwtxpow,                /* SIOCGIWTXPOW */
        (iw_handler) ath_ioctl_siwretry,                /* SIOCSIWRETRY */
        (iw_handler) ath_ioctl_giwretry,                /* SIOCGIWRETRY */
        (iw_handler) NULL,              /* SIOCSIWENCODE */
        (iw_handler) NULL,              /* SIOCGIWENCODE */
        (iw_handler) ath_ioctl_siwpower,                /* SIOCSIWPOWER */
        (iw_handler) ath_ioctl_giwpower,                /* SIOCGIWPOWER */
};

static const iw_handler ath_priv_handlers[] = {
        (iw_handler) ath_ioctl_setparam,                /* SIOCWFIRSTPRIV+0 */
        (iw_handler) ath_ioctl_getparam,                /* SIOCWFIRSTPRIV+1 */
        (iw_handler) ath_ioctl_setreg, 
        (iw_handler) ath_ioctl_getreg, 
        (iw_handler) ath_ioctl_setrxhdr, 
        (iw_handler) ath_ioctl_getrxhdr, 
};
static const struct iw_priv_args ath_priv_args[] = {
        { IEEE80211_IOCTL_SETPARAM,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setparam" },
        { IEEE80211_IOCTL_SETREG,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setreg" },
        { IEEE80211_IOCTL_GETREG,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getreg" },
        { IEEE80211_IOCTL_SETRXHDR,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "setrxhdr" },
        { IEEE80211_IOCTL_GETRXHDR,
          0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getrxhdr" },
#if WIRELESS_EXT >= 12
        /*
         * These depends on sub-ioctl support which added in version 12.
         */
        { IEEE80211_IOCTL_GETPARAM,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getparam" },
        /* sub-ioctl handlers */
        { IEEE80211_IOCTL_SETPARAM,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "" },
        { IEEE80211_IOCTL_GETPARAM,
          0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "" },
        /* sub-ioctl definitions */
        { IEEE80211_PARAM_TURBO,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "turbo" },
        { IEEE80211_PARAM_TURBO,
          0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_turbo" },
        { IEEE80211_PARAM_MODE,
          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "mode" },
        { IEEE80211_PARAM_MODE,
          0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_mode" },
#endif /* WIRELESS_EXT >= 12 */
};

const struct iw_handler_def ath_iw_handler_def = {
#define N(a)    (sizeof (a) / sizeof (a[0]))
        .standard               = (iw_handler *) ath_handlers,
        .num_standard           = N(ath_handlers),
        .private                = (iw_handler *) ath_priv_handlers,
        .num_private            = N(ath_priv_handlers),
        .private_args           = (struct iw_priv_args *) ath_priv_args,
        .num_private_args       = N(ath_priv_args),
#undef N
};
#endif /* CONFIG_NET_WIRELESS */

---