drivers/net/wireless/rt2x00/rt2x00config.c

   1 /*
   2         Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
   3         <http://rt2x00.serialmonkey.com>
   4
   5         This program is free software; you can redistribute it and/or modify
   6         it under the terms of the GNU General Public License as published by
   7         the Free Software Foundation; either version 2 of the License, or
   8         (at your option) any later version.
   9
  10         This program is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13         GNU General Public License for more details.
  14
  15         You should have received a copy of the GNU General Public License
  16         along with this program; if not, write to the
  17         Free Software Foundation, Inc.,
  18         59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22         Module: rt2x00lib
  23         Abstract: rt2x00 generic configuration routines.
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28
  29 #include "rt2x00.h"
  30 #include "rt2x00lib.h"
  31
  32 void rt2x00lib_config_intf(struct rt2x00_dev *rt2x00dev,
  33                            struct rt2x00_intf *intf,
  34                            enum nl80211_iftype type,
  35                            u8 *mac, u8 *bssid)
  36 {
  37         struct rt2x00intf_conf conf;
  38         unsigned int flags = 0;
  39
  40         conf.type = type;
  41
  42         switch (type) {
  43         case NL80211_IFTYPE_ADHOC:
  44         case NL80211_IFTYPE_AP:
  45                 conf.sync = TSF_SYNC_BEACON;
  46                 break;
  47         case NL80211_IFTYPE_STATION:
  48                 conf.sync = TSF_SYNC_INFRA;
  49                 break;
  50         default:
  51                 conf.sync = TSF_SYNC_NONE;
  52                 break;
  53         }
  54
  55         /*
  56          * Note that when NULL is passed as address we will send
  57          * 00:00:00:00:00 to the device to clear the address.
  58          * This will prevent the device being confused when it wants
  59          * to ACK frames or consideres itself associated.
  60          */
  61         memset(&conf.mac, 0, sizeof(conf.mac));
  62         if (mac)
  63                 memcpy(&conf.mac, mac, ETH_ALEN);
  64
  65         memset(&conf.bssid, 0, sizeof(conf.bssid));
  66         if (bssid)
  67                 memcpy(&conf.bssid, bssid, ETH_ALEN);
  68
  69         flags |= CONFIG_UPDATE_TYPE;
  70         if (mac || (!rt2x00dev->intf_ap_count && !rt2x00dev->intf_sta_count))
  71                 flags |= CONFIG_UPDATE_MAC;
  72         if (bssid || (!rt2x00dev->intf_ap_count && !rt2x00dev->intf_sta_count))
  73                 flags |= CONFIG_UPDATE_BSSID;
  74
  75         rt2x00dev->ops->lib->config_intf(rt2x00dev, intf, &conf, flags);
  76 }
  77
  78 void rt2x00lib_config_erp(struct rt2x00_dev *rt2x00dev,
  79                           struct rt2x00_intf *intf,
  80                           struct ieee80211_bss_conf *bss_conf)
  81 {
  82         struct rt2x00lib_erp erp;
  83
  84         memset(&erp, 0, sizeof(erp));
  85
  86         erp.short_preamble = bss_conf->use_short_preamble;
  87         erp.cts_protection = bss_conf->use_cts_prot;
  88
  89         erp.ack_timeout = PLCP + get_duration(ACK_SIZE, 10);
  90         erp.ack_consume_time = SIFS + PLCP + get_duration(ACK_SIZE, 10);
  91
  92         if (rt2x00dev->hw->conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME)
  93                 erp.ack_timeout += SHORT_DIFS;
  94         else
  95                 erp.ack_timeout += DIFS;
  96
  97         if (bss_conf->use_short_preamble) {
  98                 erp.ack_timeout += SHORT_PREAMBLE;
  99                 erp.ack_consume_time += SHORT_PREAMBLE;
 100         } else {
 101                 erp.ack_timeout += PREAMBLE;
 102                 erp.ack_consume_time += PREAMBLE;
 103         }
 104
 105         rt2x00dev->ops->lib->config_erp(rt2x00dev, &erp);
 106 }
 107
 108 void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev,
 109                               enum antenna rx, enum antenna tx)
 110 {
 111         struct rt2x00lib_conf libconf;
 112
 113         libconf.ant.rx = rx;
 114         libconf.ant.tx = tx;
 115
 116         if (rx == rt2x00dev->link.ant.active.rx &&
 117             tx == rt2x00dev->link.ant.active.tx)
 118                 return;
 119
 120         /*
 121          * Antenna setup changes require the RX to be disabled,
 122          * else the changes will be ignored by the device.
 123          */
 124         if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
 125                 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF_LINK);
 126
 127         /*
 128          * Write new antenna setup to device and reset the link tuner.
 129          * The latter is required since we need to recalibrate the
 130          * noise-sensitivity ratio for the new setup.
 131          */
 132         rt2x00dev->ops->lib->config(rt2x00dev, &libconf, CONFIG_UPDATE_ANTENNA);
 133         rt2x00lib_reset_link_tuner(rt2x00dev);
 134         rt2x00_reset_link_ant_rssi(&rt2x00dev->link);
 135
 136         rt2x00dev->link.ant.active.rx = libconf.ant.rx;
 137         rt2x00dev->link.ant.active.tx = libconf.ant.tx;
 138
 139         if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
 140                 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON_LINK);
 141 }
 142
 143 static u32 rt2x00lib_get_basic_rates(struct ieee80211_supported_band *band)
 144 {
 145         const struct rt2x00_rate *rate;
 146         unsigned int i;
 147         u32 mask = 0;
 148
 149         for (i = 0; i < band->n_bitrates; i++) {
 150                 rate = rt2x00_get_rate(band->bitrates[i].hw_value);
 151                 if (rate->flags & DEV_RATE_BASIC)
 152                         mask |= rate->ratemask;
 153         }
 154
 155         return mask;
 156 }
 157
 158 void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
 159                       struct ieee80211_conf *conf, const int force_config)
 160 {
 161         struct rt2x00lib_conf libconf;
 162         struct ieee80211_supported_band *band;
 163         struct antenna_setup *default_ant = &rt2x00dev->default_ant;
 164         struct antenna_setup *active_ant = &rt2x00dev->link.ant.active;
 165         int flags = 0;
 166         int short_slot_time;
 167
 168         /*
 169          * In some situations we want to force all configurations
 170          * to be reloaded (When resuming for instance).
 171          */
 172         if (force_config) {
 173                 flags = CONFIG_UPDATE_ALL;
 174                 goto config;
 175         }
 176
 177         /*
 178          * Check which configuration options have been
 179          * updated and should be send to the device.
 180          */
 181         if (rt2x00dev->rx_status.band != conf->channel->band)
 182                 flags |= CONFIG_UPDATE_PHYMODE;
 183         if (rt2x00dev->rx_status.freq != conf->channel->center_freq)
 184                 flags |= CONFIG_UPDATE_CHANNEL;
 185         if (rt2x00dev->tx_power != conf->power_level)
 186                 flags |= CONFIG_UPDATE_TXPOWER;
 187
 188         /*
 189          * Determining changes in the antenna setups request several checks:
 190          * antenna_sel_{r,t}x = 0
 191          *    -> Does active_{r,t}x match default_{r,t}x
 192          *    -> Is default_{r,t}x SW_DIVERSITY
 193          * antenna_sel_{r,t}x = 1/2
 194          *    -> Does active_{r,t}x match antenna_sel_{r,t}x
 195          * The reason for not updating the antenna while SW diversity
 196          * should be used is simple: Software diversity means that
 197          * we should switch between the antenna's based on the
 198          * quality. This means that the current antenna is good enough
 199          * to work with untill the link tuner decides that an antenna
 200          * switch should be performed.
 201          */
 202         if (!conf->antenna_sel_rx &&
 203             default_ant->rx != ANTENNA_SW_DIVERSITY &&
 204             default_ant->rx != active_ant->rx)
 205                 flags |= CONFIG_UPDATE_ANTENNA;
 206         else if (conf->antenna_sel_rx &&
 207                  conf->antenna_sel_rx != active_ant->rx)
 208                 flags |= CONFIG_UPDATE_ANTENNA;
 209         else if (active_ant->rx == ANTENNA_SW_DIVERSITY)
 210                 flags |= CONFIG_UPDATE_ANTENNA;
 211
 212         if (!conf->antenna_sel_tx &&
 213             default_ant->tx != ANTENNA_SW_DIVERSITY &&
 214             default_ant->tx != active_ant->tx)
 215                 flags |= CONFIG_UPDATE_ANTENNA;
 216         else if (conf->antenna_sel_tx &&
 217                  conf->antenna_sel_tx != active_ant->tx)
 218                 flags |= CONFIG_UPDATE_ANTENNA;
 219         else if (active_ant->tx == ANTENNA_SW_DIVERSITY)
 220                 flags |= CONFIG_UPDATE_ANTENNA;
 221
 222         /*
 223          * The following configuration options are never
 224          * stored anywhere and will always be updated.
 225          */
 226         flags |= CONFIG_UPDATE_SLOT_TIME;
 227         flags |= CONFIG_UPDATE_BEACON_INT;
 228
 229         /*
 230          * We have determined what options should be updated,
 231          * now precalculate device configuration values depending
 232          * on what configuration options need to be updated.
 233          */
 234 config:
 235         memset(&libconf, 0, sizeof(libconf));
 236
 237         if (flags & CONFIG_UPDATE_PHYMODE) {
 238                 band = &rt2x00dev->bands[conf->channel->band];
 239
 240                 libconf.band = conf->channel->band;
 241                 libconf.basic_rates = rt2x00lib_get_basic_rates(band);
 242         }
 243
 244         if (flags & CONFIG_UPDATE_CHANNEL) {
 245                 memcpy(&libconf.rf,
 246                        &rt2x00dev->spec.channels[conf->channel->hw_value],
 247                        sizeof(libconf.rf));
 248
 249                 memcpy(&libconf.channel,
 250                        &rt2x00dev->spec.channels_info[conf->channel->hw_value],
 251                        sizeof(libconf.channel));
 252         }
 253
 254         if (flags & CONFIG_UPDATE_ANTENNA) {
 255                 if (conf->antenna_sel_rx)
 256                         libconf.ant.rx = conf->antenna_sel_rx;
 257                 else if (default_ant->rx != ANTENNA_SW_DIVERSITY)
 258                         libconf.ant.rx = default_ant->rx;
 259                 else if (active_ant->rx == ANTENNA_SW_DIVERSITY)
 260                         libconf.ant.rx = ANTENNA_B;
 261                 else
 262                         libconf.ant.rx = active_ant->rx;
 263
 264                 if (conf->antenna_sel_tx)
 265                         libconf.ant.tx = conf->antenna_sel_tx;
 266                 else if (default_ant->tx != ANTENNA_SW_DIVERSITY)
 267                         libconf.ant.tx = default_ant->tx;
 268                 else if (active_ant->tx == ANTENNA_SW_DIVERSITY)
 269                         libconf.ant.tx = ANTENNA_B;
 270                 else
 271                         libconf.ant.tx = active_ant->tx;
 272         }
 273
 274         if (flags & CONFIG_UPDATE_SLOT_TIME) {
 275                 short_slot_time = conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME;
 276
 277                 libconf.slot_time =
 278                     short_slot_time ? SHORT_SLOT_TIME : SLOT_TIME;
 279                 libconf.sifs = SIFS;
 280                 libconf.pifs = short_slot_time ? SHORT_PIFS : PIFS;
 281                 libconf.difs = short_slot_time ? SHORT_DIFS : DIFS;
 282                 libconf.eifs = short_slot_time ? SHORT_EIFS : EIFS;
 283         }
 284
 285         libconf.conf = conf;
 286
 287         /*
 288          * Start configuration.
 289          */
 290         rt2x00dev->ops->lib->config(rt2x00dev, &libconf, flags);
 291
 292         /*
 293          * Some configuration changes affect the link quality
 294          * which means we need to reset the link tuner.
 295          */
 296         if (flags & (CONFIG_UPDATE_CHANNEL | CONFIG_UPDATE_ANTENNA))
 297                 rt2x00lib_reset_link_tuner(rt2x00dev);
 298
 299         if (flags & CONFIG_UPDATE_PHYMODE) {
 300                 rt2x00dev->curr_band = conf->channel->band;
 301                 rt2x00dev->rx_status.band = conf->channel->band;
 302         }
 303
 304         rt2x00dev->rx_status.freq = conf->channel->center_freq;
 305         rt2x00dev->tx_power = conf->power_level;
 306
 307         if (flags & CONFIG_UPDATE_ANTENNA) {
 308                 rt2x00dev->link.ant.active.rx = libconf.ant.rx;
 309                 rt2x00dev->link.ant.active.tx = libconf.ant.tx;
 310         }
 311 }