Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cfg.c
Go to the documentation of this file.
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. */
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 */
35 {
36  struct orinoco_private *priv = wiphy_priv(wiphy);
37  int i, channels = 0;
38 
40  wiphy->max_scan_ssids = 1;
41  else
42  wiphy->max_scan_ssids = 0;
43 
45 
46  /* TODO: should we set if we only have demo ad-hoc?
47  * (priv->has_port3)
48  */
49  if (priv->has_ibss)
51 
52  if (!priv->broken_monitor || force_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;
71 
72  i = 0;
73  if (priv->has_wep) {
75  i++;
76 
77  if (priv->has_big_wep) {
79  i++;
80  }
81  }
82  if (priv->has_wpa) {
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,
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) {
111  if (!priv->has_ibss && !priv->has_port3)
112  err = -EINVAL;
113  break;
114 
116  break;
117 
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,
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,
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 |
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 
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 };