drivers/net/wireless/orinoco/cfg.c

   1 /* cfg80211 support
   2  *
   3  * See copyright notice in main.c
   4  */
   5 #include <linux/ieee80211.h>
   6 #include <net/cfg80211.h>
   7 #include "hw.h"
   8 #include "main.h"
   9 #include "orinoco.h"
  10
  11 #include "cfg.h"
  12
  13 /* Supported bitrates. Must agree with hw.c */
  14 static struct ieee80211_rate orinoco_rates[] = {
  15         { .bitrate = 10 },
  16         { .bitrate = 20 },
  17         { .bitrate = 55 },
  18         { .bitrate = 110 },
  19 };
  20
  21 static const void * const orinoco_wiphy_privid = &orinoco_wiphy_privid;
  22
  23 /* Called after orinoco_private is allocated. */
  24 void orinoco_wiphy_init(struct wiphy *wiphy)
  25 {
  26         struct orinoco_private *priv = wiphy_priv(wiphy);
  27
  28         wiphy->privid = orinoco_wiphy_privid;
  29
  30         set_wiphy_dev(wiphy, priv->dev);
  31 }
  32
  33 /* Called after firmware is initialised */
  34 int orinoco_wiphy_register(struct wiphy *wiphy)
  35 {
  36         struct orinoco_private *priv = wiphy_priv(wiphy);
  37         int i, channels = 0;
  38
  39         if (priv->firmware_type == FIRMWARE_TYPE_AGERE)
  40                 wiphy->max_scan_ssids = 1;
  41         else
  42                 wiphy->max_scan_ssids = 0;
  43
  44         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
  45
  46         /* TODO: should we set if we only have demo ad-hoc?
  47          *       (priv->has_port3)
  48          */
  49         if (priv->has_ibss)
  50                 wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
  51
  52         if (!priv->broken_monitor || force_monitor)
  53                 wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
  54
  55         priv->band.bitrates = orinoco_rates;
  56         priv->band.n_bitrates = ARRAY_SIZE(orinoco_rates);
  57
  58         /* Only support channels allowed by the card EEPROM */
  59         for (i = 0; i < NUM_CHANNELS; i++) {
  60                 if (priv->channel_mask & (1 << i)) {
  61                         priv->channels[i].center_freq =
  62                                 ieee80211_dsss_chan_to_freq(i + 1);
  63                         channels++;
  64                 }
  65         }
  66         priv->band.channels = priv->channels;
  67         priv->band.n_channels = channels;
  68
  69         wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
  70         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
  71
  72         i = 0;
  73         if (priv->has_wep) {
  74                 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_WEP40;
  75                 i++;
  76
  77                 if (priv->has_big_wep) {
  78                         priv->cipher_suites[i] = WLAN_CIPHER_SUITE_WEP104;
  79                         i++;
  80                 }
  81         }
  82         if (priv->has_wpa) {
  83                 priv->cipher_suites[i] = WLAN_CIPHER_SUITE_TKIP;
  84                 i++;
  85         }
  86         wiphy->cipher_suites = priv->cipher_suites;
  87         wiphy->n_cipher_suites = i;
  88
  89         wiphy->rts_threshold = priv->rts_thresh;
  90         if (!priv->has_mwo)
  91                 wiphy->frag_threshold = priv->frag_thresh + 1;
  92         wiphy->retry_short = priv->short_retry_limit;
  93         wiphy->retry_long = priv->long_retry_limit;
  94
  95         return wiphy_register(wiphy);
  96 }
  97
  98 static int orinoco_change_vif(struct wiphy *wiphy, struct net_device *dev,
  99                               enum nl80211_iftype type, u32 *flags,
 100                               struct vif_params *params)
 101 {
 102         struct orinoco_private *priv = wiphy_priv(wiphy);
 103         int err = 0;
 104         unsigned long lock;
 105
 106         if (orinoco_lock(priv, &lock) != 0)
 107                 return -EBUSY;
 108
 109         switch (type) {
 110         case NL80211_IFTYPE_ADHOC:
 111                 if (!priv->has_ibss && !priv->has_port3)
 112                         err = -EINVAL;
 113                 break;
 114
 115         case NL80211_IFTYPE_STATION:
 116                 break;
 117
 118         case NL80211_IFTYPE_MONITOR:
 119                 if (priv->broken_monitor && !force_monitor) {
 120                         wiphy_warn(wiphy,
 121                                    "Monitor mode support is buggy in this firmware, not enabling\n");
 122                         err = -EINVAL;
 123                 }
 124                 break;
 125
 126         default:
 127                 err = -EINVAL;
 128         }
 129
 130         if (!err) {
 131                 priv->iw_mode = type;
 132                 set_port_type(priv);
 133                 err = orinoco_commit(priv);
 134         }
 135
 136         orinoco_unlock(priv, &lock);
 137
 138         return err;
 139 }
 140
 141 static int orinoco_scan(struct wiphy *wiphy,
 142                         struct cfg80211_scan_request *request)
 143 {
 144         struct orinoco_private *priv = wiphy_priv(wiphy);
 145         int err;
 146
 147         if (!request)
 148                 return -EINVAL;
 149
 150         if (priv->scan_request && priv->scan_request != request)
 151                 return -EBUSY;
 152
 153         priv->scan_request = request;
 154
 155         err = orinoco_hw_trigger_scan(priv, request->ssids);
 156         /* On error the we aren't processing the request */
 157         if (err)
 158                 priv->scan_request = NULL;
 159
 160         return err;
 161 }
 162
 163 static int orinoco_set_monitor_channel(struct wiphy *wiphy,
 164                                        struct ieee80211_channel *chan,
 165                                        enum nl80211_channel_type channel_type)
 166 {
 167         struct orinoco_private *priv = wiphy_priv(wiphy);
 168         int err = 0;
 169         unsigned long flags;
 170         int channel;
 171
 172         if (!chan)
 173                 return -EINVAL;
 174
 175         if (channel_type != NL80211_CHAN_NO_HT)
 176                 return -EINVAL;
 177
 178         if (chan->band != IEEE80211_BAND_2GHZ)
 179                 return -EINVAL;
 180
 181         channel = ieee80211_freq_to_dsss_chan(chan->center_freq);
 182
 183         if ((channel < 1) || (channel > NUM_CHANNELS) ||
 184              !(priv->channel_mask & (1 << (channel - 1))))
 185                 return -EINVAL;
 186
 187         if (orinoco_lock(priv, &flags) != 0)
 188                 return -EBUSY;
 189
 190         priv->channel = channel;
 191         if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
 192                 /* Fast channel change - no commit if successful */
 193                 struct hermes *hw = &priv->hw;
 194                 err = hw->ops->cmd_wait(hw, HERMES_CMD_TEST |
 195                                             HERMES_TEST_SET_CHANNEL,
 196                                         channel, NULL);
 197         }
 198         orinoco_unlock(priv, &flags);
 199
 200         return err;
 201 }
 202
 203 static int orinoco_set_wiphy_params(struct wiphy *wiphy, u32 changed)
 204 {
 205         struct orinoco_private *priv = wiphy_priv(wiphy);
 206         int frag_value = -1;
 207         int rts_value = -1;
 208         int err = 0;
 209
 210         if (changed & WIPHY_PARAM_RETRY_SHORT) {
 211                 /* Setting short retry not supported */
 212                 err = -EINVAL;
 213         }
 214
 215         if (changed & WIPHY_PARAM_RETRY_LONG) {
 216                 /* Setting long retry not supported */
 217                 err = -EINVAL;
 218         }
 219
 220         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
 221                 /* Set fragmentation */
 222                 if (priv->has_mwo) {
 223                         if (wiphy->frag_threshold < 0)
 224                                 frag_value = 0;
 225                         else {
 226                                 printk(KERN_WARNING "%s: Fixed fragmentation "
 227                                        "is not supported on this firmware. "
 228                                        "Using MWO robust instead.\n",
 229                                        priv->ndev->name);
 230                                 frag_value = 1;
 231                         }
 232                 } else {
 233                         if (wiphy->frag_threshold < 0)
 234                                 frag_value = 2346;
 235                         else if ((wiphy->frag_threshold < 257) ||
 236                                  (wiphy->frag_threshold > 2347))
 237                                 err = -EINVAL;
 238                         else
 239                                 /* cfg80211 value is 257-2347 (odd only)
 240                                  * orinoco rid has range 256-2346 (even only) */
 241                                 frag_value = wiphy->frag_threshold & ~0x1;
 242                 }
 243         }
 244
 245         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
 246                 /* Set RTS.
 247                  *
 248                  * Prism documentation suggests default of 2432,
 249                  * and a range of 0-3000.
 250                  *
 251                  * Current implementation uses 2347 as the default and
 252                  * the upper limit.
 253                  */
 254
 255                 if (wiphy->rts_threshold < 0)
 256                         rts_value = 2347;
 257                 else if (wiphy->rts_threshold > 2347)
 258                         err = -EINVAL;
 259                 else
 260                         rts_value = wiphy->rts_threshold;
 261         }
 262
 263         if (!err) {
 264                 unsigned long flags;
 265
 266                 if (orinoco_lock(priv, &flags) != 0)
 267                         return -EBUSY;
 268
 269                 if (frag_value >= 0) {
 270                         if (priv->has_mwo)
 271                                 priv->mwo_robust = frag_value;
 272                         else
 273                                 priv->frag_thresh = frag_value;
 274                 }
 275                 if (rts_value >= 0)
 276                         priv->rts_thresh = rts_value;
 277
 278                 err = orinoco_commit(priv);
 279
 280                 orinoco_unlock(priv, &flags);
 281         }
 282
 283         return err;
 284 }
 285
 286 const struct cfg80211_ops orinoco_cfg_ops = {
 287         .change_virtual_intf = orinoco_change_vif,
 288         .set_monitor_channel = orinoco_set_monitor_channel,
 289         .scan = orinoco_scan,
 290         .set_wiphy_params = orinoco_set_wiphy_params,
 291 };